rxgen: Make input strings const
[openafs.git] / src / libadmin / bos / afs_bosAdmin.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12 #include <afs/stds.h>
13
14 #include <roken.h>
15
16 #include <rx/rx.h>
17 #include <rx/rxstat.h>
18 #include <afs/afs_AdminErrors.h>
19 #include <afs/afs_utilAdmin.h>
20 #include <afs/bosint.h>
21 #include <afs/bnode.h>
22 #include <afs/ktime.h>
23 #include <afs/dirpath.h>
24
25 #include "afs_bosAdmin.h"
26 #include "../adminutil/afs_AdminInternal.h"
27
28 typedef struct bos_server {
29     int begin_magic;
30     int is_valid;
31     struct rx_connection *server;
32     struct rx_connection *server_encrypt;
33     struct rx_connection *server_stats;
34     int end_magic;
35 } bos_server_t, *bos_server_p;
36
37 /*
38  * isValidServerHandle - validate a bos_server_p.
39  *
40  * PARAMETERS
41  *
42  * IN serverHandle - the handle to validate
43  *
44  * LOCKS
45  *
46  * No locks are obtained or released by this function
47  *
48  * RETURN CODES
49  *
50  * Returns != 0 upon successful completion.
51  */
52
53 int
54 isValidServerHandle(const bos_server_p serverHandle, afs_status_p st)
55 {
56     int rc = 0;
57     afs_status_t tst = 0;
58
59     if (serverHandle == NULL) {
60         tst = ADMBOSSERVERHANDLENULL;
61         goto fail_IsValidServerHandle;
62     }
63
64     if ((serverHandle->begin_magic != BEGIN_MAGIC)
65         || (serverHandle->end_magic != END_MAGIC)) {
66         tst = ADMBOSSERVERHANDLEBADMAGIC;
67         goto fail_IsValidServerHandle;
68     }
69
70     if (serverHandle->is_valid == 0) {
71         tst = ADMBOSSERVERHANDLEINVALID;
72         goto fail_IsValidServerHandle;
73     }
74
75     if (serverHandle->server == NULL) {
76         tst = ADMBOSSERVERHANDLENOSERVER;
77         goto fail_IsValidServerHandle;
78     }
79
80     if (serverHandle->server_encrypt == NULL) {
81         tst = ADMBOSSERVERHANDLENOSERVER;
82         goto fail_IsValidServerHandle;
83     }
84     rc = 1;
85
86   fail_IsValidServerHandle:
87
88     if (st != NULL) {
89         *st = tst;
90     }
91     return rc;
92 }
93
94 /*
95  * IsValidCellHandle - verify that a cell handle can be used to make bos
96  * requests.
97  *
98  * PARAMETERS
99  *
100  * IN cellHandle - the cellHandle to be validated.
101  *
102  * LOCKS
103  *
104  * No locks are obtained or released by this function
105  *
106  * RETURN CODES
107  *
108  * Returns != 0 upon successful completion.
109  */
110
111 static int
112 IsValidCellHandle(afs_cell_handle_p cellHandle, afs_status_p st)
113 {
114     int rc = 0;
115     afs_status_t tst = 0;
116
117     if (!CellHandleIsValid((void *)cellHandle, &tst)) {
118         goto fail_IsValidCellHandle;
119     }
120
121     if (cellHandle->tokens == NULL) {
122         tst = ADMBOSCELLHANDLENOTOKENS;
123         goto fail_IsValidCellHandle;
124     }
125     rc = 1;
126
127   fail_IsValidCellHandle:
128
129     if (st != NULL) {
130         *st = tst;
131     }
132     return rc;
133 }
134
135 /*
136  * bos_ServerOpen - open a bos server for work.
137  *
138  * PARAMETERS
139  *
140  * IN cellHandle - a previously opened cellHandle.
141  *
142  * IN serverName - the name of the machine that houses the bosserver of 
143  * interest.
144  *
145  * OUT serverHandleP - upon successful completion, this void pointer
146  * will point to a valid server handle for use in future operations.
147  *
148  * LOCKS
149  *
150  * No locks are obtained or released by this function
151  *
152  * RETURN CODES
153  *
154  * Returns != 0 upon successful completion.
155  */
156
157 int ADMINAPI
158 bos_ServerOpen(const void *cellHandle, const char *serverName,
159                void **serverHandleP, afs_status_p st)
160 {
161     int rc = 0;
162     afs_status_t tst = 0;
163     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
164     bos_server_p bos_server = malloc(sizeof(bos_server_t));
165     int serverAddress;
166
167     /*
168      * Validate parameters
169      */
170
171     if (!IsValidCellHandle(c_handle, &tst)) {
172         goto fail_bos_ServerOpen;
173     }
174
175     if ((serverName == NULL) || (*serverName == 0)) {
176         tst = ADMBOSSERVERNAMENULL;
177         goto fail_bos_ServerOpen;
178     }
179
180     if (serverHandleP == NULL) {
181         tst = ADMBOSSERVERHANDLEPNULL;
182         goto fail_bos_ServerOpen;
183     }
184
185     if (util_AdminServerAddressGetFromName(serverName, &serverAddress, &tst)
186         == 0) {
187         goto fail_bos_ServerOpen;
188     }
189
190     if (bos_server == NULL) {
191         tst = ADMNOMEM;
192         goto fail_bos_ServerOpen;
193     }
194
195     bos_server->server =
196         rx_GetCachedConnection(htonl(serverAddress), htons(AFSCONF_NANNYPORT),
197                                1,
198                                c_handle->tokens->afs_sc[c_handle->tokens->
199                                                         sc_index],
200                                c_handle->tokens->sc_index);
201
202     bos_server->server_encrypt =
203         rx_GetCachedConnection(htonl(serverAddress), htons(AFSCONF_NANNYPORT),
204                                1,
205                                c_handle->tokens->afs_encrypt_sc[c_handle->
206                                                                 tokens->
207                                                                 sc_index],
208                                c_handle->tokens->sc_index);
209
210     bos_server->server_stats =
211         rx_GetCachedConnection(htonl(serverAddress), htons(AFSCONF_NANNYPORT),
212                                RX_STATS_SERVICE_ID,
213                                c_handle->tokens->afs_sc[c_handle->tokens->
214                                                         sc_index],
215                                c_handle->tokens->sc_index);
216
217     if ((bos_server->server == NULL) || (bos_server->server_encrypt == NULL)) {
218         tst = ADMBOSSERVERNOCONNECTION;
219         goto fail_bos_ServerOpen;
220     }
221
222     bos_server->begin_magic = BEGIN_MAGIC;
223     bos_server->is_valid = 1;
224     bos_server->end_magic = END_MAGIC;
225
226     *serverHandleP = (void *)bos_server;
227     rc = 1;
228
229   fail_bos_ServerOpen:
230
231     if ((rc == 0) && (bos_server != NULL)) {
232         if (bos_server->server) {
233             rx_ReleaseCachedConnection(bos_server->server);
234         }
235         if (bos_server->server_encrypt) {
236             rx_ReleaseCachedConnection(bos_server->server_encrypt);
237         }
238         free(bos_server);
239     }
240
241     if (st != NULL) {
242         *st = tst;
243     }
244     return rc;
245 }
246
247 /*
248  * bos_ServerClose - close a bos server handle
249  *
250  * PARAMETERS
251  *
252  * IN serverHandle - a bos server handle previously returned by bos_ServerOpen
253  *
254  * LOCKS
255  *
256  * No locks are obtained or released by this function
257  *
258  * RETURN CODES
259  *
260  * Returns != 0 upon successful completion.
261  */
262
263 int ADMINAPI
264 bos_ServerClose(const void *serverHandle, afs_status_p st)
265 {
266     int rc = 0;
267     afs_status_t tst = 0;
268     bos_server_p b_handle = (bos_server_p) serverHandle;
269
270     if (isValidServerHandle(b_handle, &tst)) {
271         rx_ReleaseCachedConnection(b_handle->server);
272         b_handle->is_valid = 0;
273         free(b_handle);
274         rc = 1;
275     }
276
277     if (st != NULL) {
278         *st = tst;
279     }
280     return rc;
281 }
282
283 /*
284  * bos_ProcessCreate - create a new process to run at a bos server.
285  *
286  * PARAMETERS
287  *
288  * IN serverHandle - a previously opened serverHandle.
289  *
290  * IN processName - the name of the process to create.
291  *
292  * IN processType - the type of process to create.
293  *
294  * IN process - the path to the process binary at the bos server.
295  *
296  * IN cronTime - the time specification for cron processes.
297  *
298  * IN notifier - the path to the notifier binary at the bos server.
299  *
300  * LOCKS
301  *
302  * No locks are obtained or released by this function
303  *
304  * RETURN CODES
305  *
306  * Returns != 0 upon successful completion.
307  */
308
309 /*
310  * CAUTION - this list must match bos_ProcessType_t definition
311  */
312
313 static char *processTypes[] = { "simple", "fs", "cron", 0 };
314
315 int ADMINAPI
316 bos_ProcessCreate(const void *serverHandle, char *processName,
317                   bos_ProcessType_t processType, char *process,
318                   char *cronTime, char *notifier, afs_status_p st)
319 {
320     int rc = 0;
321     afs_status_t tst = 0;
322     bos_server_p b_handle = (bos_server_p) serverHandle;
323
324     if (!isValidServerHandle(b_handle, &tst)) {
325         goto fail_bos_ProcessCreate;
326     }
327
328     if (processType == BOS_PROCESS_FS) {
329         tst = ADMBOSPROCESSCREATEBADTYPE;
330         goto fail_bos_ProcessCreate;
331     }
332
333     if ((processName == NULL) || (*processName == 0)) {
334         tst = ADMBOSPROCESSNAMENULL;
335         goto fail_bos_ProcessCreate;
336     }
337
338     if ((process == NULL) || (*process == 0)) {
339         tst = ADMBOSPROCESSNULL;
340         goto fail_bos_ProcessCreate;
341     }
342
343     if ((processType == BOS_PROCESS_CRON) && (cronTime == NULL)) {
344         tst = ADMBOSCRONTIMENULL;
345         goto fail_bos_ProcessCreate;
346     }
347
348     if ((processType == BOS_PROCESS_SIMPLE) && (cronTime != NULL)) {
349         tst = ADMBOSCRONTIMENOTNULL;
350         goto fail_bos_ProcessCreate;
351     }
352
353     tst =
354         BOZO_CreateBnode(b_handle->server, processTypes[processType],
355                          processName, process, (cronTime) ? cronTime : "", "",
356                          "", "", (notifier) ? notifier : NONOTIFIER);
357     if (tst == 0) {
358         rc = 1;
359     }
360
361   fail_bos_ProcessCreate:
362
363     if (st != NULL) {
364         *st = tst;
365     }
366     return rc;
367 }
368
369 /*
370  * bos_FSProcessCreate - create the fs group of processes at the boserver.
371  *
372  * PARAMETERS
373  *
374  * IN serverHandle - a previously opened serverHandle.
375  *
376  * IN processName - the name of the process to create.
377  *
378  * IN fileserverPath - the path to the fileserver binary at the bos server.
379  *
380  * IN volserverPath - the path to the volserver binary at the bos server.
381  *
382  * IN salvagerPath - the path to the salvager binary at the bos server.
383  *
384  * IN notifier - the path to the notifier binary at the bos server.
385  *
386  * LOCKS
387  *
388  * No locks are obtained or released by this function
389  *
390  * RETURN CODES
391  *
392  * Returns != 0 upon successful completion.
393  */
394
395 int ADMINAPI
396 bos_FSProcessCreate(const void *serverHandle, char *processName,
397                     char *fileserverPath, char *volserverPath,
398                     char *salvagerPath, char *notifier,
399                     afs_status_p st)
400 {
401     int rc = 0;
402     afs_status_t tst = 0;
403     bos_server_p b_handle = (bos_server_p) serverHandle;
404
405     if (!isValidServerHandle(b_handle, &tst)) {
406         goto fail_bos_ProcessCreate;
407     }
408
409     if ((processName == NULL) || (*processName == 0)) {
410         tst = ADMBOSPROCESSNAMENULL;
411         goto fail_bos_ProcessCreate;
412     }
413
414     if ((fileserverPath == NULL) || (*fileserverPath == 0)) {
415         tst = ADMBOSFILESERVERPATHNULL;
416         goto fail_bos_ProcessCreate;
417     }
418
419     if ((volserverPath == NULL) || (*volserverPath == 0)) {
420         tst = ADMBOSVOLSERVERPATHNULL;
421         goto fail_bos_ProcessCreate;
422     }
423
424     if ((salvagerPath == NULL) || (*salvagerPath == 0)) {
425         tst = ADMBOSSALVAGERPATHNULL;
426         goto fail_bos_ProcessCreate;
427     }
428
429     tst =
430         BOZO_CreateBnode(b_handle->server, processTypes[BOS_PROCESS_FS],
431                          processName, fileserverPath, volserverPath,
432                          salvagerPath, "", "",
433                          (notifier) ? notifier : NONOTIFIER);
434     if (tst == 0) {
435         rc = 1;
436     }
437
438   fail_bos_ProcessCreate:
439
440     if (st != NULL) {
441         *st = tst;
442     }
443     return rc;
444 }
445
446 /*
447  * bos_ProcessDelete - delete an existing process at a bos server.
448  *
449  * PARAMETERS
450  *
451  * IN serverHandle - a previously opened serverHandle.
452  *
453  * IN processName - the name of the process to delete.
454  *
455  * LOCKS
456  *
457  * No locks are obtained or released by this function
458  *
459  * RETURN CODES
460  *
461  * Returns != 0 upon successful completion.
462  */
463
464 int ADMINAPI
465 bos_ProcessDelete(const void *serverHandle, char *processName,
466                   afs_status_p st)
467 {
468     int rc = 0;
469     afs_status_t tst = 0;
470     bos_server_p b_handle = (bos_server_p) serverHandle;
471
472     if (!isValidServerHandle(b_handle, &tst)) {
473         goto fail_bos_ProcessDelete;
474     }
475
476     if ((processName == NULL) || (*processName == 0)) {
477         tst = ADMBOSPROCESSNAMENULL;
478         goto fail_bos_ProcessDelete;
479     }
480
481     tst = BOZO_DeleteBnode(b_handle->server, processName);
482
483     if (tst == 0) {
484         rc = 1;
485     }
486
487   fail_bos_ProcessDelete:
488
489     if (st != NULL) {
490         *st = tst;
491     }
492     return rc;
493 }
494
495 /*
496  * bos_ProcessExecutionStateGet - get the current execution state of a 
497  * process
498  *
499  * PARAMETERS
500  *
501  * IN serverHandle - a previously opened serverHandle.
502  *
503  * IN processName - the name of the process to retrieve.
504  *
505  * OUT processStatusP - upon successful completion the process execution state
506  *
507  * OUT auxiliaryProcessStatus - set to point to aux proc status if available.
508  * Pass a pointer to an char array at least BOS_MAX_NAME_LEN long.
509  *
510  * LOCKS
511  *
512  * No locks are obtained or released by this function
513  *
514  * RETURN CODES
515  *
516  * Returns != 0 upon successful completion.
517  */
518
519 int ADMINAPI
520 bos_ProcessExecutionStateGet(const void *serverHandle,
521                              char *processName,
522                              bos_ProcessExecutionState_p processStatusP,
523                              char *auxiliaryProcessStatus, afs_status_p st)
524 {
525     int rc = 0;
526     afs_status_t tst = 0;
527     bos_server_p b_handle = (bos_server_p) serverHandle;
528     afs_int32 state;
529
530     if (!isValidServerHandle(b_handle, &tst)) {
531         goto fail_bos_ProcessExecutionStateGet;
532     }
533
534     if ((processName == NULL) || (*processName == 0)) {
535         tst = ADMBOSPROCESSNAMENULL;
536         goto fail_bos_ProcessExecutionStateGet;
537     }
538
539     if (processStatusP == NULL) {
540         tst = ADMBOSPROCESSSTATUSPNULL;
541         goto fail_bos_ProcessExecutionStateGet;
542     }
543
544     if (auxiliaryProcessStatus == NULL) {
545         tst = ADMBOSAUXILIARYPROCESSSTATUSNULL;
546         goto fail_bos_ProcessExecutionStateGet;
547     }
548
549     tst =
550         BOZO_GetStatus(b_handle->server, processName, &state,
551                        &auxiliaryProcessStatus);
552
553     if (tst != 0) {
554         goto fail_bos_ProcessExecutionStateGet;
555     }
556
557     *processStatusP = (bos_ProcessExecutionState_t) state;
558     rc = 1;
559
560   fail_bos_ProcessExecutionStateGet:
561
562     if (st != NULL) {
563         *st = tst;
564     }
565     return rc;
566 }
567
568 /*
569  * SetExecutionState - set the execution state of a process
570  *
571  * PARAMETERS
572  *
573  * IN serverHandle - a previously opened serverHandle.
574  *
575  * IN processName - the name of the process to modify.
576  *
577  * IN processStatus - the new process state.
578  *
579  * IN func - the function to call to set the status.
580  *
581  * LOCKS
582  *
583  * No locks are obtained or released by this function
584  *
585  * RETURN CODES
586  *
587  * Returns != 0 upon successful completion.
588  */
589
590 static int
591 SetExecutionState(const void *serverHandle, const char *processName,
592                   const bos_ProcessExecutionState_t processStatus,
593                   int (*func) (struct rx_connection *, const char *,
594                                afs_int32), afs_status_p st)
595 {
596     int rc = 0;
597     afs_status_t tst = 0;
598     bos_server_p b_handle = (bos_server_p) serverHandle;
599     afs_int32 state;
600
601     if (!isValidServerHandle(b_handle, &tst)) {
602         goto fail_SetExecutionState;
603     }
604
605     if ((processName == NULL) || (*processName == 0)) {
606         tst = ADMBOSPROCESSNAMENULL;
607         goto fail_SetExecutionState;
608     }
609
610     if ((processStatus != BOS_PROCESS_STOPPED)
611         && (processStatus != BOS_PROCESS_RUNNING)) {
612         tst = ADMBOSPROCESSSTATUSSET;
613         goto fail_SetExecutionState;
614     }
615
616     state = (afs_int32) processStatus;
617
618     tst = func(b_handle->server, (char *)processName, state);
619
620     if (tst == 0) {
621         rc = 1;
622     }
623
624   fail_SetExecutionState:
625
626     if (st != NULL) {
627         *st = tst;
628     }
629     return rc;
630 }
631
632 /*
633  * bos_ProcessExecutionStateSet - set the execution state of a process
634  *
635  * PARAMETERS
636  *
637  * IN serverHandle - a previously opened serverHandle.
638  *
639  * IN processName - the name of the process to modify.
640  *
641  * IN processStatus - the new process state.
642  *
643  * LOCKS
644  *
645  * No locks are obtained or released by this function
646  *
647  * RETURN CODES
648  *
649  * Returns != 0 upon successful completion.
650  */
651
652 int ADMINAPI
653 bos_ProcessExecutionStateSet(const void *serverHandle,
654                              const char *processName,
655                              const bos_ProcessExecutionState_t processStatus,
656                              afs_status_p st)
657 {
658     return SetExecutionState(serverHandle, processName, processStatus,
659                              BOZO_SetStatus, st);
660 }
661
662 /*
663  * bos_ProcessExecutionStateSetTemporary - set the execution state of a process
664  * temporarily
665  *
666  * PARAMETERS
667  *
668  * IN serverHandle - a previously opened serverHandle.
669  *
670  * IN processName - the name of the process to modify.
671  *
672  * IN processStatus - the new process state.
673  *
674  * LOCKS
675  *
676  * No locks are obtained or released by this function
677  *
678  * RETURN CODES
679  *
680  * Returns != 0 upon successful completion.
681  */
682
683 int ADMINAPI
684 bos_ProcessExecutionStateSetTemporary(const void *serverHandle,
685                                       char *processName,
686                                       bos_ProcessExecutionState_t
687                                       processStatus, afs_status_p st)
688 {
689     return SetExecutionState(serverHandle, processName, processStatus,
690                              BOZO_SetTStatus, st);
691 }
692
693 /*
694  * The iterator functions and data for the process name retrieval functions
695  */
696
697 typedef struct process_name_get {
698     int next;
699     struct rx_connection *server;
700     char process[CACHED_ITEMS][BOS_MAX_NAME_LEN];
701 } process_name_get_t, *process_name_get_p;
702
703 static int
704 GetProcessNameRPC(void *rpc_specific, int slot, int *last_item,
705                   int *last_item_contains_data, afs_status_p st)
706 {
707     int rc = 0;
708     afs_status_t tst = 0;
709     process_name_get_p proc = (process_name_get_p) rpc_specific;
710     char *ptr = (char *)&proc->process[slot];
711
712     tst = BOZO_EnumerateInstance(proc->server, proc->next++, &ptr);
713
714     if (tst == 0) {
715         rc = 1;
716     } else if (tst == BZDOM) {
717         tst = 0;
718         rc = 1;
719         *last_item = 1;
720         *last_item_contains_data = 0;
721     }
722
723     if (st != NULL) {
724         *st = tst;
725     }
726     return rc;
727 }
728
729 static int
730 GetProcessNameFromCache(void *rpc_specific, int slot, void *dest,
731                         afs_status_p st)
732 {
733     int rc = 0;
734     afs_status_t tst = 0;
735     process_name_get_p proc = (process_name_get_p) rpc_specific;
736
737     strcpy((char *)dest, (char *)&proc->process[slot]);
738     rc = 1;
739
740     if (st != NULL) {
741         *st = tst;
742     }
743     return rc;
744 }
745
746 /*
747  * bos_ProcessNameGetBegin - begin iterating over the list of processes
748  * at a particular bos server.
749  *
750  * PARAMETERS
751  *
752  * IN serverHandle - a previously opened serverHandle.
753  *
754  * OUT iter - an iterator that can be passed to bos_ProcessNameGetNext
755  * to retrieve the process names.
756  *
757  * LOCKS
758  *
759  * No locks are obtained or released by this function
760  *
761  * RETURN CODES
762  *
763  * Returns != 0 upon successful completion.
764  *
765  */
766
767 int ADMINAPI
768 bos_ProcessNameGetBegin(const void *serverHandle, void **iterationIdP,
769                         afs_status_p st)
770 {
771     int rc = 0;
772     afs_status_t tst = 0;
773     bos_server_p b_handle = (bos_server_p) serverHandle;
774     afs_admin_iterator_p iter = malloc(sizeof(afs_admin_iterator_t));
775     process_name_get_p proc = malloc(sizeof(process_name_get_t));
776
777     if (!isValidServerHandle(b_handle, &tst)) {
778         goto fail_bos_ProcessNameGetBegin;
779     }
780
781     if (iterationIdP == NULL) {
782         tst = ADMITERATIONIDPNULL;
783         goto fail_bos_ProcessNameGetBegin;
784     }
785
786     if ((iter == NULL) || (proc == NULL)) {
787         tst = ADMNOMEM;
788         goto fail_bos_ProcessNameGetBegin;
789     }
790
791     proc->next = 0;
792     proc->server = b_handle->server;
793
794     if (IteratorInit
795         (iter, (void *)proc, GetProcessNameRPC, GetProcessNameFromCache, NULL,
796          NULL, &tst)) {
797         *iterationIdP = (void *)iter;
798     } else {
799         goto fail_bos_ProcessNameGetBegin;
800     }
801     rc = 1;
802
803   fail_bos_ProcessNameGetBegin:
804
805     if (rc == 0) {
806         if (iter != NULL) {
807             free(iter);
808         }
809         if (proc != NULL) {
810             free(proc);
811         }
812     }
813
814     if (st != NULL) {
815         *st = tst;
816     }
817     return rc;
818 }
819
820 /*
821  * bos_ProcessNameGetNext - retrieve the next process name from the bos server.
822  *
823  * PARAMETERS
824  *
825  * IN iterationId - an iterator previously returned by bos_ProcessNameGetBegin
826  *
827  * OUT processName - upon successful completion contains the next process name
828  * retrieved from the server.
829  *
830  * LOCKS
831  *
832  * No locks are obtained or released by this function
833  *
834  * RETURN CODES
835  *
836  * Returns != 0 upon successful completion.
837  *
838  */
839
840 int ADMINAPI
841 bos_ProcessNameGetNext(const void *iterationId, char *processName,
842                        afs_status_p st)
843 {
844     int rc = 0;
845     afs_status_t tst = 0;
846     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
847
848     if (processName == NULL) {
849         tst = ADMBOSPROCESSNAMENULL;
850         goto fail_bos_ProcessNameGetNext;
851     }
852
853     if (iterationId == NULL) {
854         tst = ADMITERATIONIDPNULL;
855         goto fail_bos_ProcessNameGetNext;
856     }
857
858     rc = IteratorNext(iter, (void *)processName, &tst);
859
860   fail_bos_ProcessNameGetNext:
861
862     if (st != NULL) {
863         *st = tst;
864     }
865     return rc;
866 }
867
868 /*
869  * bos_ProcessNameGetDone - finish using a process name iterator.
870  *
871  * PARAMETERS
872  *
873  * IN iterationId - an iterator previously returned by bos_ProcessNameGetBegin
874  *
875  * LOCKS
876  *
877  * No locks are obtained or released by this function
878  *
879  * RETURN CODES
880  *
881  * Returns != 0 upon successful completion.
882  *
883  */
884
885 int ADMINAPI
886 bos_ProcessNameGetDone(const void *iterationId, afs_status_p st)
887 {
888     int rc = 0;
889     afs_status_t tst = 0;
890     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
891
892     if (iterationId == NULL) {
893         tst = ADMITERATIONIDPNULL;
894         goto fail_bos_ProcessNameGetDone;
895     }
896
897     rc = IteratorDone(iter, &tst);
898
899   fail_bos_ProcessNameGetDone:
900
901     if (st != NULL) {
902         *st = tst;
903     }
904     return rc;
905 }
906
907 /*
908  * bos_ProcessInfoGet - get information about a single process
909  *
910  * PARAMETERS
911  *
912  * IN serverHandle - a previously opened serverHandle.
913  *
914  * IN processName - the process of interest.
915  *
916  * OUT processTypeP - upon successful completion contains the process type
917  *
918  * OUT processInfoP - upon successful completion contains the process info
919  *
920  * LOCKS
921  *
922  * No locks are obtained or released by this function
923  *
924  * RETURN CODES
925  *
926  * Returns != 0 upon successful completion.
927  *
928  */
929
930 int ADMINAPI
931 bos_ProcessInfoGet(const void *serverHandle, char *processName,
932                    bos_ProcessType_p processTypeP,
933                    bos_ProcessInfo_p processInfoP, afs_status_p st)
934 {
935     int rc = 0;
936     afs_status_t tst = 0;
937     bos_server_p b_handle = (bos_server_p) serverHandle;
938     char type[BOS_MAX_NAME_LEN];
939     char *ptr = type;
940     struct bozo_status status;
941     int i;
942
943     if (!isValidServerHandle(b_handle, &tst)) {
944         goto fail_bos_ProcessInfoGet;
945     }
946
947     if ((processName == NULL) || (*processName == 0)) {
948         tst = ADMBOSPROCESSNAMENULL;
949         goto fail_bos_ProcessInfoGet;
950     }
951
952     if (processTypeP == NULL) {
953         tst = ADMBOSPROCESSTYPEPNULL;
954         goto fail_bos_ProcessInfoGet;
955     }
956
957     if (processInfoP == NULL) {
958         tst = ADMBOSPROCESSINFOPNULL;
959         goto fail_bos_ProcessInfoGet;
960     }
961
962     tst = BOZO_GetInstanceInfo(b_handle->server, processName, &ptr, &status);
963
964     if (tst != 0) {
965         goto fail_bos_ProcessInfoGet;
966     }
967
968
969     for (i = 0; (processTypes[i] != NULL); i++) {
970         if (!strcmp(processTypes[i], type)) {
971             *processTypeP = (bos_ProcessType_t) i;
972             break;
973         }
974     }
975
976     if (processTypes[i] == NULL) {
977         tst = ADMBOSINVALIDPROCESSTYPE;
978         goto fail_bos_ProcessInfoGet;
979     }
980
981     processInfoP->processGoal = (bos_ProcessExecutionState_t) status.goal;
982     processInfoP->processStartTime = status.procStartTime;
983     processInfoP->numberProcessStarts = status.procStarts;
984     processInfoP->processExitTime = status.lastAnyExit;
985     processInfoP->processExitErrorTime = status.lastErrorExit;
986     processInfoP->processErrorCode = status.errorCode;
987     processInfoP->processErrorSignal = status.errorSignal;
988     processInfoP->state = BOS_PROCESS_OK;
989
990     if (status.flags & BOZO_ERRORSTOP) {
991         processInfoP->state |= BOS_PROCESS_TOO_MANY_ERRORS;
992     }
993     if (status.flags & BOZO_HASCORE) {
994         processInfoP->state |= BOS_PROCESS_CORE_DUMPED;
995     }
996     if (status.flags & BOZO_BADDIRACCESS) {
997         processInfoP->state |= BOS_PROCESS_BAD_FILE_ACCESS;
998     }
999     rc = 1;
1000
1001   fail_bos_ProcessInfoGet:
1002
1003     if (st != NULL) {
1004         *st = tst;
1005     }
1006     return rc;
1007 }
1008
1009 /*
1010  * The iterator functions and data for the parameter retrieval functions
1011  */
1012
1013 typedef struct param_get {
1014     int next;
1015     struct rx_connection *server;
1016     char processName[BOS_MAX_NAME_LEN];
1017     char param[CACHED_ITEMS][BOS_MAX_NAME_LEN];
1018 } param_get_t, *param_get_p;
1019
1020 static int
1021 GetParameterRPC(void *rpc_specific, int slot, int *last_item,
1022                 int *last_item_contains_data, afs_status_p st)
1023 {
1024     int rc = 0;
1025     afs_status_t tst = 0;
1026     param_get_p param = (param_get_p) rpc_specific;
1027     char *ptr = (char *)&param->param[slot];
1028
1029     tst =
1030         BOZO_GetInstanceParm(param->server, param->processName, param->next++,
1031                              &ptr);
1032
1033     if (tst == 0) {
1034         rc = 1;
1035     } else if (tst == BZDOM) {
1036         tst = 0;
1037         rc = 1;
1038         *last_item = 1;
1039         *last_item_contains_data = 0;
1040     }
1041
1042     if (st != NULL) {
1043         *st = tst;
1044     }
1045     return rc;
1046 }
1047
1048 static int
1049 GetParameterFromCache(void *rpc_specific, int slot, void *dest,
1050                       afs_status_p st)
1051 {
1052     int rc = 0;
1053     afs_status_t tst = 0;
1054     param_get_p param = (param_get_p) rpc_specific;
1055
1056     strcpy((char *)dest, (char *)&param->param[slot]);
1057     rc = 1;
1058
1059     if (st != NULL) {
1060         *st = tst;
1061     }
1062     return rc;
1063 }
1064
1065 /*
1066  * bos_ProcessParameterGetBegin - begin iterating over the parameters
1067  * of a particular process.
1068  *
1069  * PARAMETERS
1070  *
1071  * IN serverHandle - a previously opened serverHandle.
1072  *
1073  * IN processName - the process whose parameters are returned.
1074  *
1075  * OUT iter - an iterator that can be passed to bos_ProcessParameterGetNext
1076  * to retrieve the parameters.
1077  *
1078  * LOCKS
1079  *
1080  * No locks are obtained or released by this function
1081  *
1082  * RETURN CODES
1083  *
1084  * Returns != 0 upon successful completion.
1085  *
1086  */
1087
1088 int ADMINAPI
1089 bos_ProcessParameterGetBegin(const void *serverHandle,
1090                              const char *processName, void **iterationIdP,
1091                              afs_status_p st)
1092 {
1093     int rc = 0;
1094     afs_status_t tst = 0;
1095     bos_server_p b_handle = (bos_server_p) serverHandle;
1096     afs_admin_iterator_p iter = malloc(sizeof(afs_admin_iterator_t));
1097     param_get_p param = malloc(sizeof(param_get_t));
1098
1099     if (!isValidServerHandle(b_handle, &tst)) {
1100         goto fail_bos_ProcessParameterGetBegin;
1101     }
1102
1103     if ((processName == NULL) || (*processName == 0)) {
1104         tst = ADMBOSPROCESSNAMENULL;
1105         goto fail_bos_ProcessParameterGetBegin;
1106     }
1107
1108     if (iterationIdP == NULL) {
1109         tst = ADMITERATIONIDPNULL;
1110         goto fail_bos_ProcessParameterGetBegin;
1111     }
1112
1113     if ((iter == NULL) || (param == NULL)) {
1114         tst = ADMNOMEM;
1115         goto fail_bos_ProcessParameterGetBegin;
1116     }
1117
1118     param->next = 0;
1119     param->server = b_handle->server;
1120     strcpy(param->processName, processName);
1121
1122     if (IteratorInit
1123         (iter, (void *)param, GetParameterRPC, GetParameterFromCache, NULL,
1124          NULL, &tst)) {
1125         *iterationIdP = (void *)iter;
1126     } else {
1127         goto fail_bos_ProcessParameterGetBegin;
1128     }
1129     rc = 1;
1130
1131   fail_bos_ProcessParameterGetBegin:
1132
1133     if (rc == 0) {
1134         if (iter != NULL) {
1135             free(iter);
1136         }
1137         if (param != NULL) {
1138             free(param);
1139         }
1140     }
1141
1142     if (st != NULL) {
1143         *st = tst;
1144     }
1145     return rc;
1146 }
1147
1148 /*
1149  * bos_ProcessParameterGetNext - retrieve the next parameter 
1150  * from the bos server.
1151  *
1152  * PARAMETERS
1153  *
1154  * IN iterationId - an iterator previously returned by 
1155  * bos_ProcessParameterGetBegin
1156  *
1157  * OUT parameter - upon successful completion contains the next parameter
1158  * retrieved from the server.
1159  *
1160  * LOCKS
1161  *
1162  * No locks are obtained or released by this function
1163  *
1164  * RETURN CODES
1165  *
1166  * Returns != 0 upon successful completion.
1167  *
1168  */
1169
1170 int ADMINAPI
1171 bos_ProcessParameterGetNext(const void *iterationId, char *parameter,
1172                             afs_status_p st)
1173 {
1174     int rc = 0;
1175     afs_status_t tst = 0;
1176     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1177
1178     if (iterationId == NULL) {
1179         tst = ADMITERATIONIDPNULL;
1180         goto fail_bos_ProcessParameterGetNext;
1181     }
1182
1183     if (parameter == NULL) {
1184         tst = ADMBOSPARAMETERNULL;
1185         goto fail_bos_ProcessParameterGetNext;
1186     }
1187
1188     rc = IteratorNext(iter, (void *)parameter, &tst);
1189
1190   fail_bos_ProcessParameterGetNext:
1191
1192     if (st != NULL) {
1193         *st = tst;
1194     }
1195     return rc;
1196 }
1197
1198 /*
1199  * bos_ProcessParameterGetDone - finish using a process name iterator.
1200  *
1201  * PARAMETERS
1202  *
1203  * IN iterationId - an iterator previously returned by
1204  * bos_ProcessParameterGetBegin
1205  *
1206  * LOCKS
1207  *
1208  * No locks are obtained or released by this function
1209  *
1210  * RETURN CODES
1211  *
1212  * Returns != 0 upon successful completion.
1213  *
1214  */
1215
1216 int ADMINAPI
1217 bos_ProcessParameterGetDone(const void *iterationId, afs_status_p st)
1218 {
1219     int rc = 0;
1220     afs_status_t tst = 0;
1221     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1222
1223     if (iterationId == NULL) {
1224         tst = ADMITERATIONIDPNULL;
1225         goto fail_bos_ProcessParameterGetDone;
1226     }
1227
1228     rc = IteratorDone(iter, &tst);
1229
1230   fail_bos_ProcessParameterGetDone:
1231
1232     if (st != NULL) {
1233         *st = tst;
1234     }
1235     return rc;
1236 }
1237
1238 /*
1239  * bos_ProcessNotifierGet - retrieve the notifier associated with a
1240  * process.
1241  *
1242  * PARAMETERS
1243  *
1244  * IN serverHandle - a previously opened serverHandle.
1245  *
1246  * IN processName - the process whose notifier we are retrieving.
1247  *
1248  * OUT notifier - upon successful completion contains the notifier.
1249  *
1250  * LOCKS
1251  *
1252  * No locks are obtained or released by this function
1253  *
1254  * RETURN CODES
1255  *
1256  * Returns != 0 upon successful completion.
1257  *
1258  */
1259
1260 int ADMINAPI
1261 bos_ProcessNotifierGet(const void *serverHandle, const char *processName,
1262                        char *notifier, afs_status_p st)
1263 {
1264     int rc = 0;
1265     afs_status_t tst = 0;
1266     bos_server_p b_handle = (bos_server_p) serverHandle;
1267
1268     if (!isValidServerHandle(b_handle, &tst)) {
1269         goto fail_bos_ProcessNotifierGet;
1270     }
1271
1272     if ((processName == NULL) || (*processName == 0)) {
1273         tst = ADMBOSPROCESSNAMENULL;
1274         goto fail_bos_ProcessNotifierGet;
1275     }
1276
1277     if (notifier == NULL) {
1278         tst = ADMBOSNOTIFIERNULL;
1279         goto fail_bos_ProcessNotifierGet;
1280     }
1281
1282     tst = BOZO_GetInstanceParm(b_handle->server, (char *)processName,
1283                                999, &notifier);
1284
1285     if (tst == 0) {
1286         rc = 1;
1287     }
1288
1289   fail_bos_ProcessNotifierGet:
1290
1291     if (st != NULL) {
1292         *st = tst;
1293     }
1294     return rc;
1295 }
1296
1297 /*
1298  * bos_ProcessRestart - restart a particular process.
1299  *
1300  * PARAMETERS
1301  *
1302  * IN serverHandle - a previously opened serverHandle.
1303  *
1304  * IN processName - the process to restart
1305  *
1306  * LOCKS
1307  *
1308  * No locks are obtained or released by this function
1309  *
1310  * RETURN CODES
1311  *
1312  * Returns != 0 upon successful completion.
1313  *
1314  */
1315
1316 int ADMINAPI
1317 bos_ProcessRestart(const void *serverHandle, const char *processName,
1318                    afs_status_p st)
1319 {
1320     int rc = 0;
1321     afs_status_t tst = 0;
1322     bos_server_p b_handle = (bos_server_p) serverHandle;
1323
1324     if (!isValidServerHandle(b_handle, &tst)) {
1325         goto fail_bos_ProcessRestart;
1326     }
1327
1328     if ((processName == NULL) || (*processName == 0)) {
1329         tst = ADMBOSPROCESSNAMENULL;
1330         goto fail_bos_ProcessRestart;
1331     }
1332
1333     tst = BOZO_Restart(b_handle->server, (char *)processName);
1334
1335     if (tst == 0) {
1336         rc = 1;
1337     }
1338
1339   fail_bos_ProcessRestart:
1340
1341     if (st != NULL) {
1342         *st = tst;
1343     }
1344     return rc;
1345 }
1346
1347 /*
1348  * bos_ProcessAllStop - stop all running processes at a server.
1349  *
1350  * PARAMETERS
1351  *
1352  * IN serverHandle - a previously opened serverHandle.
1353  *
1354  * LOCKS
1355  *
1356  * No locks are obtained or released by this function
1357  *
1358  * RETURN CODES
1359  *
1360  * Returns != 0 upon successful completion.
1361  *
1362  */
1363
1364 int ADMINAPI
1365 bos_ProcessAllStop(const void *serverHandle, afs_status_p st)
1366 {
1367     int rc = 0;
1368     afs_status_t tst = 0;
1369     bos_server_p b_handle = (bos_server_p) serverHandle;
1370
1371     if (!isValidServerHandle(b_handle, &tst)) {
1372         goto fail_bos_ProcessAllStop;
1373     }
1374
1375     tst = BOZO_ShutdownAll(b_handle->server);
1376
1377     if (tst == 0) {
1378         rc = 1;
1379     }
1380
1381   fail_bos_ProcessAllStop:
1382
1383     if (st != NULL) {
1384         *st = tst;
1385     }
1386     return rc;
1387 }
1388
1389 /*
1390  * bos_ProcessAllStart - start all processes that should be running at a
1391  * server.
1392  *
1393  * PARAMETERS
1394  *
1395  * IN serverHandle - a previously opened serverHandle.
1396  *
1397  * LOCKS
1398  *
1399  * No locks are obtained or released by this function
1400  *
1401  * RETURN CODES
1402  *
1403  * Returns != 0 upon successful completion.
1404  *
1405  */
1406
1407 int ADMINAPI
1408 bos_ProcessAllStart(const void *serverHandle, afs_status_p st)
1409 {
1410     int rc = 0;
1411     afs_status_t tst = 0;
1412     bos_server_p b_handle = (bos_server_p) serverHandle;
1413
1414     if (!isValidServerHandle(b_handle, &tst)) {
1415         goto fail_bos_ProcessAllStart;
1416     }
1417
1418     tst = BOZO_StartupAll(b_handle->server);
1419
1420     if (tst == 0) {
1421         rc = 1;
1422     }
1423
1424   fail_bos_ProcessAllStart:
1425
1426     if (st != NULL) {
1427         *st = tst;
1428     }
1429     return rc;
1430 }
1431
1432 /*
1433  * bos_ProcessAllWaitStop - stop all processes, and block until they have
1434  * exited.
1435  *
1436  * PARAMETERS
1437  *
1438  * IN serverHandle - a previously opened serverHandle.
1439  *
1440  * LOCKS
1441  *
1442  * No locks are obtained or released by this function
1443  *
1444  * RETURN CODES
1445  *
1446  * Returns != 0 upon successful completion.
1447  *
1448  */
1449
1450 int ADMINAPI
1451 bos_ProcessAllWaitStop(const void *serverHandle, afs_status_p st)
1452 {
1453     int rc = 0;
1454     afs_status_t tst = 0;
1455     bos_server_p b_handle = (bos_server_p) serverHandle;
1456
1457     if (!isValidServerHandle(b_handle, &tst)) {
1458         goto fail_bos_ProcessAllWaitStop;
1459     }
1460
1461     if (!bos_ProcessAllStop(serverHandle, &tst)) {
1462         goto fail_bos_ProcessAllWaitStop;
1463     }
1464
1465     tst = BOZO_WaitAll(b_handle->server);
1466
1467     if (tst == 0) {
1468         rc = 1;
1469     }
1470
1471   fail_bos_ProcessAllWaitStop:
1472
1473     if (st != NULL) {
1474         *st = tst;
1475     }
1476     return rc;
1477 }
1478
1479 /*
1480  * bos_ProcessAllWaitTransition - block until all processes at the bosserver
1481  * have reached their desired state.
1482  *
1483  * PARAMETERS
1484  *
1485  * IN serverHandle - a previously opened serverHandle.
1486  *
1487  * LOCKS
1488  *
1489  * No locks are obtained or released by this function
1490  *
1491  * RETURN CODES
1492  *
1493  * Returns != 0 upon successful completion.
1494  *
1495  */
1496
1497 int ADMINAPI
1498 bos_ProcessAllWaitTransition(const void *serverHandle, afs_status_p st)
1499 {
1500     int rc = 0;
1501     afs_status_t tst = 0;
1502     bos_server_p b_handle = (bos_server_p) serverHandle;
1503
1504     if (!isValidServerHandle(b_handle, &tst)) {
1505         goto fail_bos_ProcessAllWaitTransition;
1506     }
1507
1508     tst = BOZO_WaitAll(b_handle->server);
1509
1510     if (tst == 0) {
1511         rc = 1;
1512     }
1513
1514   fail_bos_ProcessAllWaitTransition:
1515
1516     if (st != NULL) {
1517         *st = tst;
1518     }
1519     return rc;
1520 }
1521
1522 /*
1523  * bos_ProcessAllStopAndRestart - stop all the running processes, restart
1524  * them, and optionally restart the bosserver itself.
1525  * exited.
1526  *
1527  * PARAMETERS
1528  *
1529  * IN serverHandle - a previously opened serverHandle.
1530  *
1531  * IN restartBosServer - flag to indicate whether to restart bosserver.
1532  *
1533  * LOCKS
1534  *
1535  * No locks are obtained or released by this function
1536  *
1537  * RETURN CODES
1538  *
1539  * Returns != 0 upon successful completion.
1540  *
1541  */
1542
1543 int ADMINAPI
1544 bos_ProcessAllStopAndRestart(const void *serverHandle,
1545                              bos_RestartBosServer_t restartBosServer,
1546                              afs_status_p st)
1547 {
1548     int rc = 0;
1549     afs_status_t tst = 0;
1550     bos_server_p b_handle = (bos_server_p) serverHandle;
1551
1552     if (!isValidServerHandle(b_handle, &tst)) {
1553         goto fail_bos_ProcessAllStopAndRestart;
1554     }
1555
1556     if (restartBosServer == BOS_RESTART_BOS_SERVER) {
1557         tst = BOZO_ReBozo(b_handle->server);
1558         if (tst != 0) {
1559             goto fail_bos_ProcessAllStopAndRestart;
1560         }
1561     }
1562
1563     tst = BOZO_RestartAll(b_handle->server);
1564
1565     if (tst == 0) {
1566         rc = 1;
1567     }
1568
1569   fail_bos_ProcessAllStopAndRestart:
1570
1571     if (st != NULL) {
1572         *st = tst;
1573     }
1574     return rc;
1575 }
1576
1577 /*
1578  * bos_AdminCreate - create a new admin.
1579  *
1580  * PARAMETERS
1581  *
1582  * IN serverHandle - a previously opened serverHandle.
1583  *
1584  * IN adminName - the new admin name.
1585  *
1586  * LOCKS
1587  *
1588  * No locks are obtained or released by this function
1589  *
1590  * RETURN CODES
1591  *
1592  * Returns != 0 upon successful completion.
1593  *
1594  */
1595
1596 int ADMINAPI
1597 bos_AdminCreate(const void *serverHandle, const char *adminName,
1598                 afs_status_p st)
1599 {
1600     int rc = 0;
1601     afs_status_t tst = 0;
1602     bos_server_p b_handle = (bos_server_p) serverHandle;
1603
1604     if (!isValidServerHandle(b_handle, &tst)) {
1605         goto fail_bos_AdminCreate;
1606     }
1607
1608     if ((adminName == NULL) || (*adminName == 0)) {
1609         tst = ADMBOSADMINNAMENULL;
1610         goto fail_bos_AdminCreate;
1611     }
1612
1613     tst = BOZO_AddSUser(b_handle->server, (char *)adminName);
1614
1615     if (tst == 0) {
1616         rc = 1;
1617     }
1618
1619   fail_bos_AdminCreate:
1620
1621     if (st != NULL) {
1622         *st = tst;
1623     }
1624     return rc;
1625 }
1626
1627 /*
1628  * bos_AdminDelete - delete a new admin.
1629  *
1630  * PARAMETERS
1631  *
1632  * IN serverHandle - a previously opened serverHandle.
1633  *
1634  * IN adminName - the admin name.
1635  *
1636  * LOCKS
1637  *
1638  * No locks are obtained or released by this function
1639  *
1640  * RETURN CODES
1641  *
1642  * Returns != 0 upon successful completion.
1643  *
1644  */
1645
1646 int ADMINAPI
1647 bos_AdminDelete(const void *serverHandle, const char *adminName,
1648                 afs_status_p st)
1649 {
1650     int rc = 0;
1651     afs_status_t tst = 0;
1652     bos_server_p b_handle = (bos_server_p) serverHandle;
1653
1654     if (!isValidServerHandle(b_handle, &tst)) {
1655         goto fail_bos_AdminDelete;
1656     }
1657
1658     if ((adminName == NULL) || (*adminName == 0)) {
1659         tst = ADMBOSADMINNAMENULL;
1660         goto fail_bos_AdminDelete;
1661     }
1662
1663     tst = BOZO_DeleteSUser(b_handle->server, (char *)adminName);
1664
1665     if (tst == 0) {
1666         rc = 1;
1667     }
1668
1669   fail_bos_AdminDelete:
1670
1671     if (st != NULL) {
1672         *st = tst;
1673     }
1674     return rc;
1675 }
1676
1677 /*
1678  * The iterator functions and data for the admin retrieval functions
1679  */
1680
1681 typedef struct admin_get {
1682     int next;
1683     struct rx_connection *server;
1684     char admin[CACHED_ITEMS][BOS_MAX_NAME_LEN];
1685 } admin_get_t, *admin_get_p;
1686
1687 static int
1688 GetAdminRPC(void *rpc_specific, int slot, int *last_item,
1689             int *last_item_contains_data, afs_status_p st)
1690 {
1691     int rc = 0;
1692     afs_status_t tst = 0;
1693     admin_get_p admin = (admin_get_p) rpc_specific;
1694     char *ptr = (char *)&admin->admin[slot];
1695
1696     tst = BOZO_ListSUsers(admin->server, admin->next++, &ptr);
1697
1698     /*
1699      * There's no way to tell the difference between an rpc failure
1700      * and the end of the list, so we assume that any error means the
1701      * end of the list
1702      */
1703
1704     if (tst != 0) {
1705         tst = 0;
1706         *last_item = 1;
1707         *last_item_contains_data = 0;
1708     }
1709     rc = 1;
1710
1711     if (st != NULL) {
1712         *st = tst;
1713     }
1714     return rc;
1715 }
1716
1717 static int
1718 GetAdminFromCache(void *rpc_specific, int slot, void *dest, afs_status_p st)
1719 {
1720     int rc = 0;
1721     afs_status_t tst = 0;
1722     admin_get_p admin = (admin_get_p) rpc_specific;
1723
1724     strcpy((char *)dest, (char *)&admin->admin[slot]);
1725     rc = 1;
1726
1727     if (st != NULL) {
1728         *st = tst;
1729     }
1730     return rc;
1731 }
1732
1733 /*
1734  * bos_AdminGetBegin - begin iterating over the administrators.
1735  *
1736  * PARAMETERS
1737  *
1738  * IN serverHandle - a previously opened serverHandle.
1739  *
1740  * OUT iter - an iterator that can be passed to bos_AdminGetBegin
1741  * to retrieve the administrators.
1742  *
1743  * LOCKS
1744  *
1745  * No locks are obtained or released by this function
1746  *
1747  * RETURN CODES
1748  *
1749  * Returns != 0 upon successful completion.
1750  *
1751  */
1752
1753 int ADMINAPI
1754 bos_AdminGetBegin(const void *serverHandle, void **iterationIdP,
1755                   afs_status_p st)
1756 {
1757     int rc = 0;
1758     afs_status_t tst = 0;
1759     bos_server_p b_handle = (bos_server_p) serverHandle;
1760     afs_admin_iterator_p iter = malloc(sizeof(afs_admin_iterator_t));
1761     admin_get_p admin = malloc(sizeof(admin_get_t));
1762
1763     if (!isValidServerHandle(b_handle, &tst)) {
1764         goto fail_bos_AdminGetBegin;
1765     }
1766
1767     if (iterationIdP == NULL) {
1768         tst = ADMITERATIONIDPNULL;
1769         goto fail_bos_AdminGetBegin;
1770     }
1771
1772     if ((iter == NULL) || (admin == NULL)) {
1773         tst = ADMNOMEM;
1774         goto fail_bos_AdminGetBegin;
1775     }
1776
1777     admin->next = 0;
1778     admin->server = b_handle->server;
1779
1780     if (IteratorInit
1781         (iter, (void *)admin, GetAdminRPC, GetAdminFromCache, NULL, NULL,
1782          &tst)) {
1783         *iterationIdP = (void *)iter;
1784         rc = 1;
1785     }
1786
1787   fail_bos_AdminGetBegin:
1788
1789     if (rc == 0) {
1790         if (iter != NULL) {
1791             free(iter);
1792         }
1793         if (admin != NULL) {
1794             free(admin);
1795         }
1796     }
1797
1798     if (st != NULL) {
1799         *st = tst;
1800     }
1801     return rc;
1802 }
1803
1804 /*
1805  * bos_AdminGetNext - retrieve the next administrator 
1806  * from the bos server.
1807  *
1808  * PARAMETERS
1809  *
1810  * IN iterationId - an iterator previously returned by 
1811  * bos_AdminGetBegin
1812  *
1813  * OUT adminName - upon successful completion contains the next administrator
1814  * retrieved from the server.
1815  *
1816  * LOCKS
1817  *
1818  * No locks are obtained or released by this function
1819  *
1820  * RETURN CODES
1821  *
1822  * Returns != 0 upon successful completion.
1823  *
1824  */
1825
1826 int ADMINAPI
1827 bos_AdminGetNext(const void *iterationId, char *adminName, afs_status_p st)
1828 {
1829     int rc = 0;
1830     afs_status_t tst = 0;
1831     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1832
1833     if (iterationId == NULL) {
1834         tst = ADMITERATIONIDPNULL;
1835         goto fail_bos_AdminGetNext;
1836     }
1837
1838     if (adminName == NULL) {
1839         tst = ADMBOSADMINNAMENULL;
1840         goto fail_bos_AdminGetNext;
1841     }
1842
1843     rc = IteratorNext(iter, (void *)adminName, &tst);
1844
1845   fail_bos_AdminGetNext:
1846
1847     if (st != NULL) {
1848         *st = tst;
1849     }
1850     return rc;
1851 }
1852
1853 /*
1854  * bos_AdminGetDone - finish using a administrator iterator.
1855  *
1856  * PARAMETERS
1857  *
1858  * IN iterationId - an iterator previously returned by
1859  * bos_AdminGetBegin
1860  *
1861  * LOCKS
1862  *
1863  * No locks are obtained or released by this function
1864  *
1865  * RETURN CODES
1866  *
1867  * Returns != 0 upon successful completion.
1868  *
1869  */
1870
1871 int ADMINAPI
1872 bos_AdminGetDone(const void *iterationId, afs_status_p st)
1873 {
1874     int rc = 0;
1875     afs_status_t tst = 0;
1876     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
1877
1878     if (iterationId == NULL) {
1879         tst = ADMITERATIONIDPNULL;
1880         goto fail_bos_AdminGetDone;
1881     }
1882
1883     rc = IteratorDone(iter, &tst);
1884
1885   fail_bos_AdminGetDone:
1886
1887     if (st != NULL) {
1888         *st = tst;
1889     }
1890     return rc;
1891 }
1892
1893 /*
1894  * bos_KeyCreate - add a new key to the keyfile.
1895  *
1896  * PARAMETERS
1897  *
1898  * IN serverHandle - a previously opened serverHandle.
1899  *
1900  * IN keyVersionNumber - the key version number.
1901  *
1902  * IN key -  the new key.
1903  *
1904  * LOCKS
1905  *
1906  * No locks are obtained or released by this function
1907  *
1908  * RETURN CODES
1909  *
1910  * Returns != 0 upon successful completion.
1911  *
1912  */
1913
1914 int ADMINAPI
1915 bos_KeyCreate(const void *serverHandle, int keyVersionNumber,
1916               const kas_encryptionKey_p key, afs_status_p st)
1917 {
1918     int rc = 0;
1919     afs_status_t tst = 0;
1920     bos_server_p b_handle = (bos_server_p) serverHandle;
1921
1922     if (!isValidServerHandle(b_handle, &tst)) {
1923         goto fail_bos_KeyCreate;
1924     }
1925
1926     if (key == NULL) {
1927         tst = ADMBOSKEYNULL;
1928         goto fail_bos_KeyCreate;
1929     }
1930
1931     tst = BOZO_AddKey(b_handle->server_encrypt, keyVersionNumber, kas_to_bozoptr(key));
1932
1933     if (tst == 0) {
1934         rc = 1;
1935     }
1936
1937   fail_bos_KeyCreate:
1938
1939     if (st != NULL) {
1940         *st = tst;
1941     }
1942     return rc;
1943 }
1944
1945 /*
1946  * bos_KeyDelete - delete an existing key from the keyfile.
1947  *
1948  * PARAMETERS
1949  *
1950  * IN serverHandle - a previously opened serverHandle.
1951  *
1952  * IN keyVersionNumber - the key version number.
1953  *
1954  * LOCKS
1955  *
1956  * No locks are obtained or released by this function
1957  *
1958  * RETURN CODES
1959  *
1960  * Returns != 0 upon successful completion.
1961  *
1962  */
1963
1964 int ADMINAPI
1965 bos_KeyDelete(const void *serverHandle, int keyVersionNumber, afs_status_p st)
1966 {
1967     int rc = 0;
1968     afs_status_t tst = 0;
1969     bos_server_p b_handle = (bos_server_p) serverHandle;
1970
1971     if (!isValidServerHandle(b_handle, &tst)) {
1972         goto fail_bos_KeyDelete;
1973     }
1974
1975     tst = BOZO_DeleteKey(b_handle->server, keyVersionNumber);
1976
1977     if (tst == 0) {
1978         rc = 1;
1979     }
1980
1981   fail_bos_KeyDelete:
1982
1983     if (st != NULL) {
1984         *st = tst;
1985     }
1986     return rc;
1987 }
1988
1989 /*
1990  * The iterator functions and data for the key retrieval functions
1991  */
1992
1993 typedef struct key_get {
1994     int next;
1995     struct rx_connection *server;
1996     bos_KeyInfo_t key[CACHED_ITEMS];
1997 } key_get_t, *key_get_p;
1998
1999 static int
2000 GetKeyRPC(void *rpc_specific, int slot, int *last_item,
2001           int *last_item_contains_data, afs_status_p st)
2002 {
2003     int rc = 0;
2004     afs_status_t tst = 0;
2005     key_get_p key = (key_get_p) rpc_specific;
2006     struct bozo_keyInfo keyInfo;
2007
2008     tst =
2009         BOZO_ListKeys(key->server, key->next++,
2010                       &key->key[slot].keyVersionNumber, kas_to_bozoptr(&key->key[slot].key),
2011                       &keyInfo);
2012
2013
2014     if (tst == 0) {
2015         key->key[slot].keyStatus.lastModificationDate = keyInfo.mod_sec;
2016         key->key[slot].keyStatus.lastModificationMicroSeconds =
2017             keyInfo.mod_usec;
2018         key->key[slot].keyStatus.checkSum = keyInfo.keyCheckSum;
2019         rc = 1;
2020     } else if (tst == BZDOM) {
2021         tst = 0;
2022         rc = 1;
2023         *last_item = 1;
2024         *last_item_contains_data = 0;
2025     }
2026
2027     if (st != NULL) {
2028         *st = tst;
2029     }
2030     return rc;
2031 }
2032
2033 static int
2034 GetKeyFromCache(void *rpc_specific, int slot, void *dest, afs_status_p st)
2035 {
2036     int rc = 0;
2037     afs_status_t tst = 0;
2038     key_get_p key = (key_get_p) rpc_specific;
2039
2040     memcpy(dest, &key->key[slot], sizeof(bos_KeyInfo_t));
2041     rc = 1;
2042
2043     if (st != NULL) {
2044         *st = tst;
2045     }
2046     return rc;
2047 }
2048
2049 /*
2050  * bos_KeyGetBegin - begin iterating over the keys.
2051  *
2052  * PARAMETERS
2053  *
2054  * IN serverHandle - a previously opened serverHandle.
2055  *
2056  * OUT iter - an iterator that can be passed to bos_KeyGetNext
2057  * to retrieve the keys.
2058  *
2059  * LOCKS
2060  *
2061  * No locks are obtained or released by this function
2062  *
2063  * RETURN CODES
2064  *
2065  * Returns != 0 upon successful completion.
2066  *
2067  */
2068
2069 int ADMINAPI
2070 bos_KeyGetBegin(const void *serverHandle, void **iterationIdP,
2071                 afs_status_p st)
2072 {
2073     int rc = 0;
2074     afs_status_t tst = 0;
2075     bos_server_p b_handle = (bos_server_p) serverHandle;
2076     afs_admin_iterator_p iter = malloc(sizeof(afs_admin_iterator_t));
2077     key_get_p key = malloc(sizeof(key_get_t));
2078
2079     if (!isValidServerHandle(b_handle, &tst)) {
2080         goto fail_bos_KeyGetBegin;
2081     }
2082
2083     if (iterationIdP == NULL) {
2084         tst = ADMITERATIONIDPNULL;
2085         goto fail_bos_KeyGetBegin;
2086     }
2087
2088     if ((iter == NULL) || (key == NULL)) {
2089         tst = ADMNOMEM;
2090         goto fail_bos_KeyGetBegin;
2091     }
2092
2093     key->next = 0;
2094     key->server = b_handle->server_encrypt;
2095
2096     if (IteratorInit
2097         (iter, (void *)key, GetKeyRPC, GetKeyFromCache, NULL, NULL, &tst)) {
2098         *iterationIdP = (void *)iter;
2099         rc = 1;
2100     }
2101
2102   fail_bos_KeyGetBegin:
2103
2104     if (rc == 0) {
2105         if (iter != NULL) {
2106             free(iter);
2107         }
2108         if (key != NULL) {
2109             free(key);
2110         }
2111     }
2112
2113     if (st != NULL) {
2114         *st = tst;
2115     }
2116     return rc;
2117 }
2118
2119 /*
2120  * bos_KeyGetNext - retrieve the next key 
2121  * from the bos server.
2122  *
2123  * PARAMETERS
2124  *
2125  * IN iterationId - an iterator previously returned by 
2126  * bos_KeyGetBegin
2127  *
2128  * OUT keyP - upon successful completion contains the next key
2129  * retrieved from the server.
2130  *
2131  * LOCKS
2132  *
2133  * No locks are obtained or released by this function
2134  *
2135  * RETURN CODES
2136  *
2137  * Returns != 0 upon successful completion.
2138  *
2139  */
2140
2141 int ADMINAPI
2142 bos_KeyGetNext(const void *iterationId, bos_KeyInfo_p keyP, afs_status_p st)
2143 {
2144     int rc = 0;
2145     afs_status_t tst = 0;
2146     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
2147
2148     if (iterationId == NULL) {
2149         tst = ADMITERATIONIDPNULL;
2150         goto fail_bos_KeyGetNext;
2151     }
2152
2153     if (keyP == NULL) {
2154         tst = ADMBOSKEYPNULL;
2155         goto fail_bos_KeyGetNext;
2156     }
2157
2158     rc = IteratorNext(iter, (void *)keyP, &tst);
2159
2160   fail_bos_KeyGetNext:
2161
2162     if (st != NULL) {
2163         *st = tst;
2164     }
2165     return rc;
2166 }
2167
2168 /*
2169  * bos_KeyGetDone - finish using a key iterator.
2170  *
2171  * PARAMETERS
2172  *
2173  * IN iterationId - an iterator previously returned by
2174  * bos_KeyGetBegin
2175  *
2176  * LOCKS
2177  *
2178  * No locks are obtained or released by this function
2179  *
2180  * RETURN CODES
2181  *
2182  * Returns != 0 upon successful completion.
2183  *
2184  */
2185
2186 int ADMINAPI
2187 bos_KeyGetDone(const void *iterationId, afs_status_p st)
2188 {
2189     int rc = 0;
2190     afs_status_t tst = 0;
2191     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
2192
2193     if (iterationId == NULL) {
2194         tst = ADMITERATIONIDPNULL;
2195         goto fail_bos_KeyGetDone;
2196     }
2197
2198     rc = IteratorDone(iter, &tst);
2199
2200   fail_bos_KeyGetDone:
2201
2202     if (st != NULL) {
2203         *st = tst;
2204     }
2205     return rc;
2206 }
2207
2208 /*
2209  * bos_CellSet - set the cell name at a bos server.
2210  *
2211  * PARAMETERS
2212  *
2213  * IN serverHandle - a previously opened serverHandle.
2214  *
2215  * IN cellName - the new cell name.
2216  *
2217  * LOCKS
2218  *
2219  * No locks are obtained or released by this function
2220  *
2221  * RETURN CODES
2222  *
2223  * Returns != 0 upon successful completion.
2224  */
2225
2226 int ADMINAPI
2227 bos_CellSet(const void *serverHandle, const char *cellName, afs_status_p st)
2228 {
2229     int rc = 0;
2230     afs_status_t tst = 0;
2231     bos_server_p b_handle = (bos_server_p) serverHandle;
2232
2233     if (!isValidServerHandle(b_handle, &tst)) {
2234         goto fail_bos_CellSet;
2235     }
2236
2237     if ((cellName == NULL) || (*cellName == 0)) {
2238         tst = ADMCLIENTCELLNAMENULL;
2239         goto fail_bos_CellSet;
2240     }
2241
2242     tst = BOZO_SetCellName(b_handle->server, (char *)cellName);
2243
2244     if (tst == 0) {
2245         rc = 1;
2246     }
2247
2248   fail_bos_CellSet:
2249
2250     if (st != NULL) {
2251         *st = tst;
2252     }
2253     return rc;
2254 }
2255
2256 /*
2257  * bos_CellGet - get the cell name at a bos server.
2258  *
2259  * PARAMETERS
2260  *
2261  * IN serverHandle - a previously opened serverHandle.
2262  *
2263  * OUT cellName - the cell name.
2264  *
2265  * LOCKS
2266  *
2267  * No locks are obtained or released by this function
2268  *
2269  * RETURN CODES
2270  *
2271  * Returns != 0 upon successful completion.
2272  */
2273
2274 int ADMINAPI
2275 bos_CellGet(const void *serverHandle, char *cellName, afs_status_p st)
2276 {
2277     int rc = 0;
2278     afs_status_t tst = 0;
2279     bos_server_p b_handle = (bos_server_p) serverHandle;
2280
2281     if (!isValidServerHandle(b_handle, &tst)) {
2282         goto fail_bos_CellGet;
2283     }
2284
2285     if (cellName == NULL) {
2286         tst = ADMCLIENTCELLNAMENULL;
2287         goto fail_bos_CellGet;
2288     }
2289
2290     tst = BOZO_GetCellName(b_handle->server, &cellName);
2291
2292     if (tst == 0) {
2293         rc = 1;
2294     }
2295
2296   fail_bos_CellGet:
2297
2298     if (st != NULL) {
2299         *st = tst;
2300     }
2301     return rc;
2302 }
2303
2304 /*
2305  * bos_HostCreate - add a new host to the cell.
2306  *
2307  * PARAMETERS
2308  *
2309  * IN serverHandle - a previously opened serverHandle.
2310  *
2311  * IN hostName - the new host.
2312  *
2313  * LOCKS
2314  *
2315  * No locks are obtained or released by this function
2316  *
2317  * RETURN CODES
2318  *
2319  * Returns != 0 upon successful completion.
2320  */
2321
2322 int ADMINAPI
2323 bos_HostCreate(const void *serverHandle, const char *hostName,
2324                afs_status_p st)
2325 {
2326     int rc = 0;
2327     afs_status_t tst = 0;
2328     bos_server_p b_handle = (bos_server_p) serverHandle;
2329
2330     if (!isValidServerHandle(b_handle, &tst)) {
2331         goto fail_bos_HostCreate;
2332     }
2333
2334     if ((hostName == NULL) || (*hostName == 0)) {
2335         tst = ADMBOSHOSTNAMENULL;
2336         goto fail_bos_HostCreate;
2337     }
2338
2339     tst = BOZO_AddCellHost(b_handle->server, (char *)hostName);
2340
2341     if (tst == 0) {
2342         rc = 1;
2343     }
2344
2345   fail_bos_HostCreate:
2346
2347     if (st != NULL) {
2348         *st = tst;
2349     }
2350     return rc;
2351 }
2352
2353 /*
2354  * bos_HostDelete - delete a host from the cell.
2355  *
2356  * PARAMETERS
2357  *
2358  * IN serverHandle - a previously opened serverHandle.
2359  *
2360  * IN hostName - the host.
2361  *
2362  * LOCKS
2363  *
2364  * No locks are obtained or released by this function
2365  *
2366  * RETURN CODES
2367  *
2368  * Returns != 0 upon successful completion.
2369  */
2370
2371 int ADMINAPI
2372 bos_HostDelete(const void *serverHandle, const char *hostName,
2373                afs_status_p st)
2374 {
2375     int rc = 0;
2376     afs_status_t tst = 0;
2377     bos_server_p b_handle = (bos_server_p) serverHandle;
2378
2379     if (!isValidServerHandle(b_handle, &tst)) {
2380         goto fail_bos_HostDelete;
2381     }
2382
2383     if ((hostName == NULL) || (*hostName == 0)) {
2384         tst = ADMBOSHOSTNAMENULL;
2385         goto fail_bos_HostDelete;
2386     }
2387
2388     tst = BOZO_DeleteCellHost(b_handle->server, (char *)hostName);
2389
2390     if (tst == 0) {
2391         rc = 1;
2392     }
2393
2394   fail_bos_HostDelete:
2395
2396     if (st != NULL) {
2397         *st = tst;
2398     }
2399     return rc;
2400 }
2401
2402 /*
2403  * The iterator functions and data for the host retrieval functions
2404  */
2405
2406 typedef struct host_get {
2407     int next;
2408     struct rx_connection *server;
2409     char host[CACHED_ITEMS][BOS_MAX_NAME_LEN];
2410 } host_get_t, *host_get_p;
2411
2412 static int
2413 GetHostRPC(void *rpc_specific, int slot, int *last_item,
2414            int *last_item_contains_data, afs_status_p st)
2415 {
2416     int rc = 0;
2417     afs_status_t tst = 0;
2418     host_get_p host = (host_get_p) rpc_specific;
2419     char *ptr = (char *)&host->host[slot];
2420
2421     tst = BOZO_GetCellHost(host->server, host->next++, &ptr);
2422
2423     if (tst == 0) {
2424         rc = 1;
2425     } else if (tst == BZDOM) {
2426         tst = 0;
2427         rc = 1;
2428         *last_item = 1;
2429         *last_item_contains_data = 0;
2430     }
2431
2432     if (st != NULL) {
2433         *st = tst;
2434     }
2435     return rc;
2436 }
2437
2438 static int
2439 GetHostFromCache(void *rpc_specific, int slot, void *dest, afs_status_p st)
2440 {
2441     int rc = 0;
2442     afs_status_t tst = 0;
2443     host_get_p host = (host_get_p) rpc_specific;
2444
2445     strcpy((char *)dest, (char *)&host->host[slot]);
2446     rc = 1;
2447
2448     if (st != NULL) {
2449         *st = tst;
2450     }
2451     return rc;
2452 }
2453
2454 /*
2455  * bos_HostGetBegin - begin iterating over the hosts in a cell
2456  * at a particular bos server.
2457  *
2458  * PARAMETERS
2459  *
2460  * IN serverHandle - a previously opened serverHandle.
2461  *
2462  * OUT iter - an iterator that can be passed to bos_HostGetNext
2463  * to retrieve the process names.
2464  *
2465  * LOCKS
2466  *
2467  * No locks are obtained or released by this function
2468  *
2469  * RETURN CODES
2470  *
2471  * Returns != 0 upon successful completion.
2472  *
2473  */
2474
2475 int ADMINAPI
2476 bos_HostGetBegin(const void *serverHandle, void **iterationIdP,
2477                  afs_status_p st)
2478 {
2479     int rc = 0;
2480     afs_status_t tst = 0;
2481     bos_server_p b_handle = (bos_server_p) serverHandle;
2482     afs_admin_iterator_p iter = malloc(sizeof(afs_admin_iterator_t));
2483     host_get_p host = malloc(sizeof(host_get_t));
2484
2485     if (!isValidServerHandle(b_handle, &tst)) {
2486         goto fail_bos_HostGetBegin;
2487     }
2488
2489     if (iterationIdP == NULL) {
2490         tst = ADMITERATIONIDPNULL;
2491         goto fail_bos_HostGetBegin;
2492     }
2493
2494     if ((iter == NULL) || (host == NULL)) {
2495         tst = ADMNOMEM;
2496         goto fail_bos_HostGetBegin;
2497     }
2498
2499     host->next = 0;
2500     host->server = b_handle->server;
2501
2502     if (IteratorInit
2503         (iter, (void *)host, GetHostRPC, GetHostFromCache, NULL, NULL,
2504          &tst)) {
2505         *iterationIdP = (void *)iter;
2506         rc = 1;
2507     }
2508
2509   fail_bos_HostGetBegin:
2510
2511     if (rc == 0) {
2512         if (iter != NULL) {
2513             free(iter);
2514         }
2515         if (host != NULL) {
2516             free(host);
2517         }
2518     }
2519
2520     if (st != NULL) {
2521         *st = tst;
2522     }
2523     return rc;
2524 }
2525
2526 /*
2527  * bos_HostGetNext - retrieve the next host 
2528  * from the bos server.
2529  *
2530  * PARAMETERS
2531  *
2532  * IN iterationId - an iterator previously returned by 
2533  * bos_HostGetBegin
2534  *
2535  * OUT hostName - upon successful completion contains the next host
2536  * retrieved from the server.
2537  *
2538  * LOCKS
2539  *
2540  * No locks are obtained or released by this function
2541  *
2542  * RETURN CODES
2543  *
2544  * Returns != 0 upon successful completion.
2545  *
2546  */
2547
2548 int ADMINAPI
2549 bos_HostGetNext(const void *iterationId, char *hostName, afs_status_p st)
2550 {
2551     int rc = 0;
2552     afs_status_t tst = 0;
2553     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
2554
2555     if (iterationId == NULL) {
2556         tst = ADMITERATIONIDPNULL;
2557         goto fail_bos_HostGetNext;
2558     }
2559
2560     if (hostName == NULL) {
2561         tst = ADMBOSHOSTNAMENULL;
2562         goto fail_bos_HostGetNext;
2563     }
2564
2565     rc = IteratorNext(iter, (void *)hostName, &tst);
2566
2567   fail_bos_HostGetNext:
2568
2569     if (st != NULL) {
2570         *st = tst;
2571     }
2572     return rc;
2573 }
2574
2575 /*
2576  * bos_HostGetDone - finish using a host iterator.
2577  *
2578  * PARAMETERS
2579  *
2580  * IN iterationId - an iterator previously returned by
2581  * bos_HostGetBegin
2582  *
2583  * LOCKS
2584  *
2585  * No locks are obtained or released by this function
2586  *
2587  * RETURN CODES
2588  *
2589  * Returns != 0 upon successful completion.
2590  *
2591  */
2592
2593 int ADMINAPI
2594 bos_HostGetDone(const void *iterationId, afs_status_p st)
2595 {
2596     int rc = 0;
2597     afs_status_t tst = 0;
2598     afs_admin_iterator_p iter = (afs_admin_iterator_p) iterationId;
2599
2600     if (iterationId == NULL) {
2601         tst = ADMITERATIONIDPNULL;
2602         goto fail_bos_HostGetDone;
2603     }
2604
2605     rc = IteratorDone(iter, &tst);
2606
2607   fail_bos_HostGetDone:
2608
2609     if (st != NULL) {
2610         *st = tst;
2611     }
2612     return rc;
2613 }
2614
2615 /*
2616  * bos_ExecutableCreate - create a new executable at the bos server.
2617  *
2618  * PARAMETERS
2619  *
2620  * IN serverHandle - a previously opened serverHandle.
2621  *
2622  * IN sourceFile - the executable to install at the bos server.
2623  *
2624  * IN destFile - the location where the executable will be installed.
2625  *
2626  * LOCKS
2627  *
2628  * No locks are obtained or released by this function
2629  *
2630  * RETURN CODES
2631  *
2632  * Returns != 0 upon successful completion.
2633  *
2634  */
2635
2636 int ADMINAPI
2637 bos_ExecutableCreate(const void *serverHandle, const char *sourceFile,
2638                      const char *destFile, afs_status_p st)
2639 {
2640     int rc = 0;
2641     afs_status_t tst = 0;
2642     bos_server_p b_handle = (bos_server_p) serverHandle;
2643     int fd;
2644     struct stat estat;
2645     struct rx_call *tcall;
2646
2647     /*
2648      * Validate arguments
2649      */
2650
2651     if (!isValidServerHandle(b_handle, &tst)) {
2652         goto fail_bos_ExecutableCreate;
2653     }
2654
2655     if ((sourceFile == NULL) || (*sourceFile == 0)) {
2656         tst = ADMBOSSOURCEFILENULL;
2657         goto fail_bos_ExecutableCreate;
2658     }
2659
2660     if ((destFile == NULL) || (*destFile == 0)) {
2661         tst = ADMBOSDESTFILENULL;
2662         goto fail_bos_ExecutableCreate;
2663     }
2664
2665     /*
2666      * Open the file locally and compute its size
2667      */
2668
2669     fd = open(sourceFile, O_RDONLY);
2670
2671     if (fd < 0) {
2672         tst = ADMBOSCANTOPENSOURCEFILE;
2673         goto fail_bos_ExecutableCreate;
2674     }
2675
2676     if (fstat(fd, &estat)) {
2677         tst = ADMBOSCANTSTATSOURCEFILE;
2678         goto fail_bos_ExecutableCreate;
2679     }
2680
2681     /*
2682      * Start a split rpc to the bos server.
2683      */
2684
2685     tcall = rx_NewCall(b_handle->server);
2686
2687     tst =
2688         StartBOZO_Install(tcall, (char *)destFile, estat.st_size,
2689                           (afs_int32) estat.st_mode, estat.st_mtime);
2690
2691     if (tst) {
2692         rx_EndCall(tcall, tst);
2693         goto fail_bos_ExecutableCreate;
2694     }
2695
2696     /*
2697      * Copy the data to the server
2698      */
2699
2700     while (1) {
2701         char tbuffer[512];
2702         ssize_t len;
2703         len = read(fd, tbuffer, sizeof(tbuffer));
2704         if (len < 0) {
2705             tst = ADMBOSCANTREADSOURCEFILE;
2706             rx_EndCall(tcall, len);
2707             goto fail_bos_ExecutableCreate;
2708         }
2709         if (len == 0) {
2710             tst = 0;
2711             break;
2712         }
2713         tst = rx_Write(tcall, tbuffer, len);
2714         if (tst != len) {
2715             tst = ADMBOSSENDSOURCEFILE;
2716             rx_EndCall(tcall, tst);
2717             goto fail_bos_ExecutableCreate;
2718         }
2719     }
2720
2721     /*
2722      * Terminate the rpc to the server
2723      */
2724
2725     tst = rx_EndCall(tcall, tst);
2726
2727     if (tst == 0) {
2728         rc = 1;
2729     }
2730
2731   fail_bos_ExecutableCreate:
2732
2733     if (st != NULL) {
2734         *st = tst;
2735     }
2736     return rc;
2737 }
2738
2739 /*
2740  * bos_ExecutableRevert - revert an executable to a previous .BAK version.
2741  *
2742  * PARAMETERS
2743  *
2744  * IN serverHandle - a previously opened serverHandle.
2745  *
2746  * IN execFile - the executable to revert at the bos server.
2747  *
2748  * LOCKS
2749  *
2750  * No locks are obtained or released by this function
2751  *
2752  * RETURN CODES
2753  *
2754  * Returns != 0 upon successful completion.
2755  *
2756  */
2757
2758 int ADMINAPI
2759 bos_ExecutableRevert(const void *serverHandle, const char *execFile,
2760                      afs_status_p st)
2761 {
2762     int rc = 0;
2763     afs_status_t tst = 0;
2764     bos_server_p b_handle = (bos_server_p) serverHandle;
2765
2766     if (!isValidServerHandle(b_handle, &tst)) {
2767         goto fail_bos_ExecutableRevert;
2768     }
2769
2770     if ((execFile == NULL) || (*execFile == 0)) {
2771         tst = ADMBOSEXECFILENULL;
2772         goto fail_bos_ExecutableRevert;
2773     }
2774
2775     tst = BOZO_UnInstall(b_handle->server, (char *)execFile);
2776
2777     if (tst == 0) {
2778         rc = 1;
2779     }
2780
2781   fail_bos_ExecutableRevert:
2782
2783     if (st != NULL) {
2784         *st = tst;
2785     }
2786     return rc;
2787 }
2788
2789 /*
2790  * bos_ExecutableTimestampGet - get the last mod times for an executable,
2791  * the .BAK version of the executable, and the .OLD version of the
2792  * executable if they exist.
2793  *
2794  * PARAMETERS
2795  *
2796  * IN serverHandle - a previously opened serverHandle.
2797  *
2798  * IN execFile - the executable to revert at the bos server.
2799  *
2800  * LOCKS
2801  *
2802  * No locks are obtained or released by this function
2803  *
2804  * RETURN CODES
2805  *
2806  * Returns != 0 upon successful completion.
2807  *
2808  */
2809
2810 int ADMINAPI
2811 bos_ExecutableTimestampGet(const void *serverHandle, const char *execFile,
2812                            afs_int32 *newTime, afs_int32 *oldTime,
2813                            afs_int32 *bakTime, afs_status_p st)
2814 {
2815     int rc = 0;
2816     afs_status_t tst = 0;
2817     bos_server_p b_handle = (bos_server_p) serverHandle;
2818
2819     if (!isValidServerHandle(b_handle, &tst)) {
2820         goto fail_bos_ExecutableTimestampGet;
2821     }
2822
2823     if ((execFile == NULL) || (*execFile == 0)) {
2824         tst = ADMBOSEXECFILENULL;
2825         goto fail_bos_ExecutableTimestampGet;
2826     }
2827
2828     if (newTime == NULL) {
2829         tst = ADMBOSNEWTIMENULL;
2830         goto fail_bos_ExecutableTimestampGet;
2831     }
2832
2833     if (oldTime == NULL) {
2834         tst = ADMBOSOLDTIMENULL;
2835         goto fail_bos_ExecutableTimestampGet;
2836     }
2837
2838     if (bakTime == NULL) {
2839         tst = ADMBOSBAKTIMENULL;
2840         goto fail_bos_ExecutableTimestampGet;
2841     }
2842
2843     tst =
2844         BOZO_GetDates(b_handle->server, (char *)execFile, newTime, bakTime, oldTime);
2845
2846     if (tst == 0) {
2847         rc = 1;
2848     }
2849
2850   fail_bos_ExecutableTimestampGet:
2851
2852     if (st != NULL) {
2853         *st = tst;
2854     }
2855     return rc;
2856 }
2857
2858 /*
2859  * bos_ExecutablePrune - prune the bak, old, and core files off a server
2860  * machine.
2861  *
2862  * PARAMETERS
2863  *
2864  * IN serverHandle - a previously opened serverHandle.
2865  *
2866  * IN oldFiles - prune .OLD files.
2867  *
2868  * IN bakFiles - prune .BAK files.
2869  *
2870  * IN coreFiles - prune core files.
2871  *
2872  * LOCKS
2873  *
2874  * No locks are obtained or released by this function
2875  *
2876  * RETURN CODES
2877  *
2878  * Returns != 0 upon successful completion.
2879  *
2880  */
2881
2882 int ADMINAPI
2883 bos_ExecutablePrune(const void *serverHandle, bos_Prune_t oldFiles,
2884                     bos_Prune_t bakFiles, bos_Prune_t coreFiles,
2885                     afs_status_p st)
2886 {
2887     int rc = 0;
2888     afs_status_t tst = 0;
2889     bos_server_p b_handle = (bos_server_p) serverHandle;
2890     afs_int32 flags = 0;
2891
2892     if (!isValidServerHandle(b_handle, &tst)) {
2893         goto fail_bos_ExecutablePrune;
2894     }
2895
2896     if (oldFiles == BOS_PRUNE) {
2897         flags |= BOZO_PRUNEOLD;
2898     }
2899
2900     if (bakFiles == BOS_PRUNE) {
2901         flags |= BOZO_PRUNEBAK;
2902     }
2903
2904     if (coreFiles == BOS_PRUNE) {
2905         flags |= BOZO_PRUNECORE;
2906     }
2907
2908     tst = BOZO_Prune(b_handle->server, flags);
2909
2910     if (tst == 0) {
2911         rc = 1;
2912     }
2913
2914   fail_bos_ExecutablePrune:
2915
2916     if (st != NULL) {
2917         *st = tst;
2918     }
2919     return rc;
2920 }
2921
2922 /*
2923  * bos_ExecutableRestartTimeSet - set the restart time of the bos server
2924  * machine.
2925  *
2926  * PARAMETERS
2927  *
2928  * IN serverHandle - a previously opened serverHandle.
2929  *
2930  * IN type - specifies either weekly restart or daily restart time.
2931  *
2932  * IN time - the time to begin restarts.
2933  *
2934  * LOCKS
2935  *
2936  * No locks are obtained or released by this function
2937  *
2938  * RETURN CODES
2939  *
2940  * Returns != 0 upon successful completion.
2941  *
2942  */
2943
2944 int ADMINAPI
2945 bos_ExecutableRestartTimeSet(const void *serverHandle, bos_Restart_t type,
2946                              bos_RestartTime_t time, afs_status_p st)
2947 {
2948     int rc = 0;
2949     afs_status_t tst = 0;
2950     bos_server_p b_handle = (bos_server_p) serverHandle;
2951     afs_int32 restartType = 0;
2952     struct bozo_netKTime restartTime;
2953
2954     if (!isValidServerHandle(b_handle, &tst)) {
2955         goto fail_bos_ExecutableRestartTimeSet;
2956     }
2957
2958     if (type == BOS_RESTART_WEEKLY) {
2959         restartType = 1;
2960     } else {
2961         restartType = 2;
2962     }
2963
2964     if ((time.mask & BOS_RESTART_TIME_HOUR)
2965         && ((time.hour < 0) || (time.hour > 23))) {
2966         tst = ADMBOSHOURINVALID;
2967         goto fail_bos_ExecutableRestartTimeSet;
2968     }
2969
2970     if ((time.mask & BOS_RESTART_TIME_MINUTE)
2971         && ((time.min < 0) || (time.min > 60))) {
2972         tst = ADMBOSMINUTEINVALID;
2973         goto fail_bos_ExecutableRestartTimeSet;
2974     }
2975
2976     if ((time.mask & BOS_RESTART_TIME_SECOND)
2977         && ((time.sec < 0) || (time.sec > 60))) {
2978         tst = ADMBOSSECONDINVALID;
2979         goto fail_bos_ExecutableRestartTimeSet;
2980     }
2981
2982     if ((time.mask & BOS_RESTART_TIME_DAY)
2983         && ((time.day < 0) || (time.day > 6))) {
2984         tst = ADMBOSDAYINVALID;
2985         goto fail_bos_ExecutableRestartTimeSet;
2986     }
2987
2988     restartTime.mask = time.mask;
2989     restartTime.hour = time.hour;
2990     restartTime.min = time.min;
2991     restartTime.sec = time.sec;
2992     restartTime.day = time.day;
2993
2994     tst = BOZO_SetRestartTime(b_handle->server, restartType, &restartTime);
2995
2996     if (tst == 0) {
2997         rc = 1;
2998     }
2999
3000   fail_bos_ExecutableRestartTimeSet:
3001
3002     if (st != NULL) {
3003         *st = tst;
3004     }
3005     return rc;
3006 }
3007
3008 /*
3009  * bos_ExecutableRestartTimeGet - get the restart time of the bos server
3010  * machine.
3011  *
3012  * PARAMETERS
3013  *
3014  * IN serverHandle - a previously opened serverHandle.
3015  *
3016  * IN type - specifies either weekly restart or daily restart time.
3017  *
3018  * OUT timeP - the time to begin restarts.
3019  *
3020  * LOCKS
3021  *
3022  * No locks are obtained or released by this function
3023  *
3024  * RETURN CODES
3025  *
3026  * Returns != 0 upon successful completion.
3027  *
3028  */
3029
3030 int ADMINAPI
3031 bos_ExecutableRestartTimeGet(const void *serverHandle, bos_Restart_t type,
3032                              bos_RestartTime_p timeP, afs_status_p st)
3033 {
3034     int rc = 0;
3035     afs_status_t tst = 0;
3036     bos_server_p b_handle = (bos_server_p) serverHandle;
3037     afs_int32 restartType = 0;
3038     struct bozo_netKTime restartTime;
3039
3040     if (!isValidServerHandle(b_handle, &tst)) {
3041         goto fail_bos_ExecutableRestartTimeGet;
3042     }
3043
3044     if (timeP == NULL) {
3045         tst = ADMBOSTIMEPNULL;
3046         goto fail_bos_ExecutableRestartTimeGet;
3047     }
3048
3049     if (type == BOS_RESTART_WEEKLY) {
3050         restartType = 1;
3051     } else {
3052         restartType = 2;
3053     }
3054
3055     tst = BOZO_GetRestartTime(b_handle->server, restartType, &restartTime);
3056
3057     if (tst != 0) {
3058         goto fail_bos_ExecutableRestartTimeGet;
3059     }
3060
3061     timeP->mask = restartTime.mask;
3062     timeP->hour = restartTime.hour;
3063     timeP->min = restartTime.min;
3064     timeP->sec = restartTime.sec;
3065     timeP->day = restartTime.day;
3066     rc = 1;
3067
3068   fail_bos_ExecutableRestartTimeGet:
3069
3070     if (st != NULL) {
3071         *st = tst;
3072     }
3073     return rc;
3074 }
3075
3076 /*
3077  * bos_LogGet - get a log file from the bos server machine.
3078  *
3079  * PARAMETERS
3080  *
3081  * IN serverHandle - a previously opened serverHandle.
3082  *
3083  * IN log - the log file to retrieve.
3084  *
3085  * IN/OUT logBufferSizeP - the length of the logData buffer on input,
3086  * and upon successful completion, the length of data stored in the buffer.
3087  *
3088  * OUT logData - the retrieved data upon successful completion.
3089  *
3090  * LOCKS
3091  *
3092  * No locks are obtained or released by this function
3093  *
3094  * RETURN CODES
3095  *
3096  * Returns != 0 upon successful completion.
3097  *
3098  */
3099
3100 int ADMINAPI
3101 bos_LogGet(const void *serverHandle, const char *log,
3102            unsigned long *logBufferSizeP, char *logData, afs_status_p st)
3103 {
3104     int rc = 0;
3105     afs_status_t tst = 0;
3106     bos_server_p b_handle = (bos_server_p) serverHandle;
3107     struct rx_call *tcall = NULL;
3108     afs_int32 error;
3109     char buffer;
3110     int have_call = 0;
3111     unsigned long bytes_read = 0;
3112
3113     /*
3114      * Validate parameters
3115      */
3116
3117     if (!isValidServerHandle(b_handle, &tst)) {
3118         goto fail_bos_LogGet;
3119     }
3120
3121     if ((log == NULL) || (*log == 0)) {
3122         tst = ADMBOSLOGNULL;
3123         goto fail_bos_LogGet;
3124     }
3125
3126     if (logBufferSizeP == NULL) {
3127         tst = ADMBOSLOGBUFFERSIZEPNULL;
3128         goto fail_bos_LogGet;
3129     }
3130
3131     if (logData == NULL) {
3132         tst = ADMBOSLOGDATANULL;
3133         goto fail_bos_LogGet;
3134     }
3135
3136     /*
3137      * Begin to retrieve the data
3138      */
3139
3140     tcall = rx_NewCall(b_handle->server);
3141     have_call = 1;
3142     tst = StartBOZO_GetLog(tcall, (char *) log);
3143
3144     if (tst != 0) {
3145         goto fail_bos_LogGet;
3146     }
3147
3148     /*
3149      * Read the log file data
3150      */
3151
3152     while (1) {
3153         error = rx_Read(tcall, &buffer, 1);
3154         if (error != 1) {
3155             tst = ADMBOSLOGFILEERROR;
3156             goto fail_bos_LogGet;
3157         }
3158
3159         /*
3160          * check for the end of the log
3161          */
3162
3163         if (buffer == 0) {
3164             *logBufferSizeP = bytes_read;
3165             break;
3166         }
3167
3168         /*
3169          * We've successfully read another byte, copy it to logData
3170          * if there's room
3171          */
3172
3173         bytes_read++;
3174         if (bytes_read <= *logBufferSizeP) {
3175             *logData++ = buffer;
3176         } else {
3177             tst = ADMMOREDATA;
3178         }
3179     }
3180     if (tst == 0) {
3181         rc = 1;
3182     }
3183
3184   fail_bos_LogGet:
3185
3186     if (have_call) {
3187         rx_EndCall(tcall, 0);
3188     }
3189
3190     if (st != NULL) {
3191         *st = tst;
3192     }
3193     return rc;
3194 }
3195
3196 /*
3197  * bos_AuthSet - set the authorization level required at the bos server.
3198  *
3199  * PARAMETERS
3200  *
3201  * IN serverHandle - a previously opened serverHandle.
3202  *
3203  * IN auth - specifies the new auth level.
3204  *
3205  * LOCKS
3206  *
3207  * No locks are obtained or released by this function
3208  *
3209  * RETURN CODES
3210  *
3211  * Returns != 0 upon successful completion.
3212  *
3213  */
3214
3215 int ADMINAPI
3216 bos_AuthSet(const void *serverHandle, bos_Auth_t auth, afs_status_p st)
3217 {
3218     int rc = 0;
3219     afs_status_t tst = 0;
3220     bos_server_p b_handle = (bos_server_p) serverHandle;
3221     afs_int32 level = 0;
3222
3223     if (!isValidServerHandle(b_handle, &tst)) {
3224         goto fail_bos_AuthSet;
3225     }
3226
3227     if (auth == BOS_AUTH_REQUIRED) {
3228         level = 0;
3229     } else {
3230         level = 1;
3231     }
3232
3233     tst = BOZO_SetNoAuthFlag(b_handle->server, level);
3234
3235     if (tst == 0) {
3236         rc = 1;
3237     }
3238
3239   fail_bos_AuthSet:
3240
3241     if (st != NULL) {
3242         *st = tst;
3243     }
3244     return rc;
3245 }
3246
3247 /*
3248  * bos_CommandExecute - execute a command at the bos server.
3249  *
3250  * PARAMETERS
3251  *
3252  * IN serverHandle - a previously opened serverHandle.
3253  *
3254  * IN command - the command to execute.
3255  *
3256  * LOCKS
3257  *
3258  * No locks are obtained or released by this function
3259  *
3260  * RETURN CODES
3261  *
3262  * Returns != 0 upon successful completion.
3263  *
3264  */
3265
3266 int ADMINAPI
3267 bos_CommandExecute(const void *serverHandle, const char *command,
3268                    afs_status_p st)
3269 {
3270     int rc = 0;
3271     afs_status_t tst = 0;
3272     bos_server_p b_handle = (bos_server_p) serverHandle;
3273
3274     if (!isValidServerHandle(b_handle, &tst)) {
3275         goto fail_bos_CommandExecute;
3276     }
3277
3278     if ((command == NULL) || (*command == 0)) {
3279         tst = ADMBOSCOMMANDNULL;
3280         goto fail_bos_CommandExecute;
3281     }
3282
3283     tst = BOZO_Exec(b_handle->server, (char *) command);
3284
3285     if (tst == 0) {
3286         rc = 1;
3287     }
3288
3289   fail_bos_CommandExecute:
3290
3291     if (st != NULL) {
3292         *st = tst;
3293     }
3294     return rc;
3295 }
3296
3297 /*
3298  * bos_Salvage - perform a remote salvage operation.
3299  *
3300  * PARAMETERS
3301  *
3302  * IN cellHandle - a previously opened cellHandle.
3303  *
3304  * IN serverHandle - a previously opened serverHandle.
3305  *
3306  * IN partitionName - the partition to salvage.  Can be null.
3307  *
3308  * IN volumeName - the volume to salvage.  Can be null, if non-null,
3309  * partitionName cannot be null.
3310  *
3311  * IN numSalvagers - the number of salvage processes to run in parallel.
3312  *
3313  * IN tmpDir - directory to place temporary files.  Can be null.
3314  *
3315  * IN logFile - file where salvage log will be written.  Can be null.
3316  *
3317  * IN force - sets salvager -force flag.
3318  *
3319  * IN salvageDamagedVolumes - sets salvager -oktozap flag.
3320  *
3321  * IN writeInodes - sets salvager -inodes flag.
3322  *
3323  * IN writeRootInodes - sets salvager -rootinodes flag.
3324  *
3325  * IN forceDirectory - sets salvager -salvagedirs flag.
3326  *
3327  * IN forceBlockRead - sets salvager -blockread flag.
3328  *
3329  * LOCKS
3330  *
3331  * No locks are obtained or released by this function
3332  *
3333  * RETURN CODES
3334  *
3335  * Returns != 0 upon successful completion.
3336  *
3337  */
3338
3339 #define INITIAL_LOG_LEN 4096
3340
3341 int ADMINAPI
3342 bos_Salvage(const void *cellHandle, const void *serverHandle,
3343             const char *partitionName, const char *volumeName,
3344             int numSalvagers, const char *tmpDir, const char *logFile,
3345             vos_force_t force,
3346             bos_SalvageDamagedVolumes_t salvageDamagedVolumes,
3347             bos_WriteInodes_t writeInodes,
3348             bos_WriteRootInodes_t writeRootInodes,
3349             bos_ForceDirectory_t forceDirectory,
3350             bos_ForceBlockRead_t forceBlockRead, afs_status_p st)
3351 {
3352     int rc = 0;
3353     afs_status_t tst = 0;
3354     bos_server_p b_handle = (bos_server_p) serverHandle;
3355     afs_cell_handle_p c_handle = (afs_cell_handle_p) cellHandle;
3356     int have_partition = 0;
3357     int have_volume = 0;
3358     unsigned int part = 0;
3359     int try_to_stop_fileserver = 0;
3360     bos_ProcessType_t procType;
3361     bos_ProcessInfo_t procInfo;
3362     FILE *log = NULL;
3363     char command[BOS_MAX_NAME_LEN];
3364     int command_len = 0;
3365     int poll_rc;
3366     char *logData = NULL;
3367     unsigned long logLen = INITIAL_LOG_LEN;
3368
3369     /*
3370      * Validate arguments
3371      */
3372
3373     if (!IsValidCellHandle(c_handle, &tst)) {
3374         goto fail_bos_Salvage;
3375     }
3376
3377     if (!isValidServerHandle(b_handle, &tst)) {
3378         goto fail_bos_Salvage;
3379     }
3380
3381     if (c_handle->vos_valid == 0) {
3382         tst = ADMBOSCELLHANDLENOVOS;
3383         goto fail_bos_Salvage;
3384     }
3385
3386     if ((partitionName != NULL) && (*partitionName != 0)) {
3387         if (!vos_PartitionNameToId(partitionName, &part, &tst)) {
3388             goto fail_bos_Salvage;
3389         }
3390         have_partition = 1;
3391     }
3392
3393     if ((volumeName != NULL) && (*volumeName != 0)) {
3394         if (!have_partition) {
3395             tst = ADMBOSSALVAGEVOLUME;
3396             goto fail_bos_Salvage;
3397         }
3398         have_volume = 1;
3399     }
3400
3401     if ((logFile != NULL) && (*logFile != 0)) {
3402         log = fopen(logFile, "w");
3403         if (!log) {
3404             tst = ADMBOSSALVAGEBADLOG;
3405             goto fail_bos_Salvage;
3406         }
3407     }
3408
3409     /*
3410      * If we are salvaging more than a single volume, stop the fileserver
3411      */
3412
3413     if (!have_volume) {
3414         try_to_stop_fileserver = 1;
3415     }
3416
3417     /*
3418      * Only try to stop the fileserver if it is running
3419      */
3420
3421     if (try_to_stop_fileserver) {
3422         if (bos_ProcessInfoGet
3423             (serverHandle, "fs", &procType, &procInfo, &tst)) {
3424             if (procInfo.processGoal != BOS_PROCESS_RUNNING) {
3425                 try_to_stop_fileserver = 0;
3426             }
3427         }
3428     }
3429
3430     /*
3431      * Make the call to stop the fileserver and wait for it to shutdown
3432      */
3433
3434     if (try_to_stop_fileserver) {
3435         if (!bos_ProcessExecutionStateSetTemporary
3436             (serverHandle, "fs", BOS_PROCESS_STOPPED, &tst)) {
3437             goto fail_bos_Salvage;
3438         }
3439         bos_ProcessAllWaitTransition(serverHandle, &tst);
3440     }
3441
3442     /*
3443      * Create the salvage command line arguments
3444      */
3445
3446     command_len =
3447         sprintf(command, "%s ", AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH);
3448     if (have_partition) {
3449         command_len +=
3450             sprintf(&command[command_len], "-partition %s ", partitionName);
3451     }
3452
3453     if (have_volume) {
3454         command_len +=
3455             sprintf(&command[command_len], "-volumeid %s ", volumeName);
3456     }
3457
3458     if (salvageDamagedVolumes == BOS_DONT_SALVAGE_DAMAGED_VOLUMES) {
3459         command_len += sprintf(&command[command_len], "-nowrite ");
3460     }
3461
3462     if (writeInodes == BOS_SALVAGE_WRITE_INODES) {
3463         command_len += sprintf(&command[command_len], "-inodes ");
3464     }
3465
3466     if (force == VOS_FORCE) {
3467         command_len += sprintf(&command[command_len], "-force ");
3468     }
3469
3470     if (writeRootInodes == BOS_SALVAGE_WRITE_ROOT_INODES) {
3471         command_len += sprintf(&command[command_len], "-rootinodes ");
3472     }
3473
3474     if (forceDirectory == BOS_SALVAGE_FORCE_DIRECTORIES) {
3475         command_len += sprintf(&command[command_len], "-salvagedirs ");
3476     }
3477
3478     if (forceBlockRead == BOS_SALVAGE_FORCE_BLOCK_READS) {
3479         command_len += sprintf(&command[command_len], "-blockreads ");
3480     }
3481
3482     command_len +=
3483         sprintf(&command[command_len], "-parallel %d ", numSalvagers);
3484
3485     if ((tmpDir != NULL) && (*tmpDir != 0)) {
3486         command_len += sprintf(&command[command_len], "-tmpdir %s ", tmpDir);
3487     }
3488
3489     if (command_len > BOS_MAX_NAME_LEN) {
3490         tst = ADMBOSSALVAGEBADOPTIONS;
3491         goto fail_bos_Salvage;
3492     }
3493
3494     /*
3495      * Create the process at the bosserver and wait until it completes
3496      */
3497
3498     if (!bos_ProcessCreate
3499         (serverHandle, "salvage-tmp", BOS_PROCESS_CRON, command, "now", 0,
3500          &tst)) {
3501         goto fail_bos_Salvage;
3502     }
3503
3504     while ((poll_rc =
3505             bos_ProcessInfoGet(serverHandle, "salvage-tmp", &procType,
3506                                &procInfo, &tst))) {
3507         sleep(5);
3508     }
3509
3510     if (tst != BZNOENT) {
3511         goto fail_bos_Salvage;
3512     }
3513
3514     /*
3515      * Print out the salvage log if required by the user
3516      */
3517
3518     if (log != NULL) {
3519
3520         logData = malloc(INITIAL_LOG_LEN);
3521         if (!logData) {
3522             tst = ADMNOMEM;
3523             goto fail_bos_Salvage;
3524         }
3525
3526         while (!bos_LogGet
3527                (serverHandle, AFSDIR_CANONICAL_SERVER_SLVGLOG_FILEPATH,
3528                 &logLen, logData, &tst)) {
3529             if (logLen > INITIAL_LOG_LEN) {
3530                 logData = realloc(logData, (logLen + (logLen / 10)));
3531                 if (logData == NULL) {
3532                     tst = ADMNOMEM;
3533                     goto fail_bos_Salvage;
3534                 }
3535             } else {
3536                 goto fail_bos_Salvage;
3537             }
3538         }
3539         fprintf(log, "SalvageLog:\n%s", logData);
3540     }
3541
3542     /*
3543      * Restart the fileserver if we had stopped it previously
3544      */
3545
3546     if (try_to_stop_fileserver) {
3547         try_to_stop_fileserver = 0;
3548         if (!bos_ProcessExecutionStateSetTemporary
3549             (serverHandle, "fs", BOS_PROCESS_RUNNING, &tst)) {
3550             goto fail_bos_Salvage;
3551         }
3552     }
3553     rc = 1;
3554
3555   fail_bos_Salvage:
3556
3557     if (log != NULL) {
3558         fclose(log);
3559     }
3560
3561     if (logData != NULL) {
3562         free(logData);
3563     }
3564
3565     if (try_to_stop_fileserver) {
3566         bos_ProcessExecutionStateSetTemporary(serverHandle, "fs",
3567                                               BOS_PROCESS_RUNNING, 0);
3568     }
3569
3570     if (st != NULL) {
3571         *st = tst;
3572     }
3573     return rc;
3574 }