Rename printf cast helpers and clean up format string warnings
[openafs.git] / src / bozo / bos.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
13
14 #include <afs/stds.h>
15 #include <stdlib.h>
16 #include <stddef.h>
17 #include <sys/types.h>
18 #ifdef AFS_NT40_ENV
19 #include <winsock2.h>
20 #include <io.h>
21 #include <fcntl.h>
22 #else
23 #include <sys/file.h>
24 #include <netinet/in.h>
25 #include <netdb.h>
26 #include <sys/socket.h>
27 #include <strings.h>
28 #endif /* AFS_NT40_ENV */
29 #include <string.h>
30 #include <afs/procmgmt.h>       /* signal(), kill(), wait(), etc. */
31 #include <time.h>
32 #include "bnode.h"
33 #include <errno.h>
34 #include <afs/afsutil.h>
35 #include <afs/cellconfig.h>
36 #include <rx/rx.h>
37 #include <sys/stat.h>
38 #include <rx/xdr.h>
39 #include <afs/auth.h>
40 #include <afs/cellconfig.h>
41 #include <stdio.h>
42 #include <afs/cmd.h>
43 #include <afs/com_err.h>
44 #include <ubik.h>
45 #include <afs/ktime.h>
46 #include <des.h>
47 #include <des_prototypes.h>
48 #include <afs/kautils.h>
49 #include <afs/volser.h>
50
51 static int IStatServer(register struct cmd_syndesc *as, int int32p);
52 static int DoStat(char *aname, register struct rx_connection *aconn, 
53                   int aint32p, int firstTime);
54
55 #include "bosint.h"
56
57 /* command offsets for bos salvage command */
58 #define MRAFS_OFFSET  10
59 #define ADDPARMOFFSET 27
60
61 /* MR-AFS salvage parameters */
62 struct MRAFSSalvageParms {
63     afs_int32 Optdebug;
64     afs_int32 Optnowrite;
65     afs_int32 Optforce;
66     afs_int32 Optoktozap;
67     afs_int32 Optrootfiles;
68     afs_int32 Optsalvagedirs;
69     afs_int32 Optblockreads;
70     afs_int32 OptListResidencies;
71     afs_int32 OptSalvageRemote;
72     afs_int32 OptSalvageArchival;
73     afs_int32 OptIgnoreCheck;
74     afs_int32 OptForceOnLine;
75     afs_int32 OptUseRootDirACL;
76     afs_int32 OptTraceBadLinkCounts;
77     afs_int32 OptDontAskFS;
78     afs_int32 OptLogLevel;
79     afs_int32 OptRxDebug;
80     afs_uint32 OptResidencies;
81 };
82
83 /* dummy routine for the audit work.  It should do nothing since audits */
84 /* occur at the server level and bos is not a server. */
85 int osi_audit(void )
86 {
87     return 0;
88 }
89
90 /* keep those lines small */
91 static char *
92 em(afs_int32 acode)
93 {
94     if (acode == -1)
95         return "communications failure (-1)";
96     else if (acode == -3)
97         return "communications timeout (-3)";
98     else
99         return (char *)afs_error_message(acode);
100 }
101
102 /* get partition id from a name */
103 /* XXX - unused code - could be removed? */
104 #if 0
105 static afs_int32
106 GetPartitionID(char *aname)
107 {
108     register char tc;
109     char ascii[3];
110
111     tc = *aname;
112     if (tc == 0)
113         return -1;              /* unknown */
114     /* numbers go straight through */
115     if (tc >= '0' && tc <= '9') {
116         return atoi(aname);
117     }
118     /* otherwise check for vicepa or /vicepa, or just plain "a" */
119     ascii[2] = 0;
120     if (strlen(aname) <= 2) {
121         strcpy(ascii, aname);
122     } else if (!strncmp(aname, "/vicep", 6)) {
123         strncpy(ascii, aname + 6, 2);
124     } else if (!strncmp(aname, "vicep", 5)) {
125         strncpy(ascii, aname + 5, 2);
126     } else
127         return -1;              /* bad partition name */
128     /* now partitions are named /vicepa ... /vicepz, /vicepaa, /vicepab,
129      * .../vicepzz, and are numbered from 0.  Do the appropriate conversion */
130     if (ascii[1] == 0) {
131         /* one char name, 0..25 */
132         if (ascii[0] < 'a' || ascii[0] > 'z')
133             return -1;          /* wrongo */
134         return ascii[0] - 'a';
135     } else {
136         /* two char name, 26 .. <whatever> */
137         if (ascii[0] < 'a' || ascii[0] > 'z')
138             return -1;          /* wrongo */
139         if (ascii[1] < 'a' || ascii[1] > 'z')
140             return -1;          /* just as bad */
141         return (ascii[0] - 'a') * 26 + (ascii[1] - 'a') + 26;
142     }
143 }
144 #endif
145
146 /* make ctime easier to use */
147 static char *
148 DateOf(afs_int32 atime)
149 {
150     static char tbuffer[30];
151     register char *tp;
152     time_t t = (time_t) atime;
153     tp = ctime(&t);
154     if (tp) {
155         strcpy(tbuffer, tp);
156         tbuffer[24] = 0;        /* get rid of new line */
157     } else
158         strcpy(tbuffer, "BAD TIME");
159     return tbuffer;
160 }
161
162 /* global stuff from main for communicating with GetConn */
163 static struct rx_securityClass *sc[3];
164 static int scIndex;
165
166 /* use the syntax descr to get a connection, authenticated appropriately.
167  * aencrypt is set if we want to encrypt the data on the wire.
168  */
169 static struct rx_connection *
170 GetConn(struct cmd_syndesc *as, int aencrypt)
171 {
172     struct hostent *th;
173     char *hostname;
174     register afs_int32 code;
175     register struct rx_connection *tconn;
176     afs_int32 addr;
177     register struct afsconf_dir *tdir;
178     int encryptLevel;
179     struct ktc_principal sname;
180     struct ktc_token ttoken;
181     int localauth;
182     const char *confdir;
183
184     hostname = as->parms[0].items->data;
185     th = hostutil_GetHostByName(hostname);
186     if (!th) {
187         printf("bos: can't find address for host '%s'\n", hostname);
188         exit(1);
189     }
190     memcpy(&addr, th->h_addr, sizeof(afs_int32));
191
192     /* get tokens for making authenticated connections */
193     localauth = (as->parms[ADDPARMOFFSET + 2].items != 0);
194     confdir =
195         (localauth ? AFSDIR_SERVER_ETC_DIRPATH : AFSDIR_CLIENT_ETC_DIRPATH);
196     tdir = afsconf_Open(confdir);
197     if (tdir) {
198         struct afsconf_cell info;
199         char *tname;
200
201         if (as->parms[ADDPARMOFFSET].items)
202             tname = as->parms[ADDPARMOFFSET].items->data;
203         else
204             tname = NULL;
205         /* next call expands cell name abbrevs for us and handles looking up
206          * local cell */
207         code = afsconf_GetCellInfo(tdir, tname, NULL, &info);
208         if (code) {
209             afs_com_err("bos", code, "(can't find cell '%s' in cell database)",
210                     (tname ? tname : "<default>"));
211             exit(1);
212         } else
213             strcpy(sname.cell, info.name);
214     } else {
215         printf("bos: can't open cell database (%s)\n", confdir);
216         exit(1);
217     }
218     sname.instance[0] = 0;
219     strcpy(sname.name, "afs");
220     sc[0] = rxnull_NewClientSecurityObject();
221     sc[1] = 0;
222     sc[2] = 0;
223     scIndex = 0;
224
225     if (!as->parms[ADDPARMOFFSET + 1].items) {  /* not -noauth */
226         if (as->parms[ADDPARMOFFSET + 2].items) {       /* -localauth */
227             code = afsconf_GetLatestKey(tdir, 0, 0);
228             if (code)
229                 afs_com_err("bos", code, "(getting key from local KeyFile)");
230             else {
231                 if (aencrypt)
232                     code = afsconf_ClientAuthSecure(tdir, &sc[2], &scIndex);
233                 else
234                     code = afsconf_ClientAuth(tdir, &sc[2], &scIndex);
235                 if (code)
236                     afs_com_err("bos", code, "(calling ClientAuth)");
237                 else if (scIndex != 2)  /* this shouldn't happen */
238                     sc[scIndex] = sc[2];
239             }
240         } else {                /* not -localauth, check for tickets */
241             code = ktc_GetToken(&sname, &ttoken, sizeof(ttoken), NULL);
242             if (code == 0) {
243                 /* have tickets, will travel */
244                 if (ttoken.kvno >= 0 && ttoken.kvno <= 256);
245                 else {
246                     fprintf(stderr,
247                             "bos: funny kvno (%d) in ticket, proceeding\n",
248                             ttoken.kvno);
249                 }
250                 /* kerberos tix */
251                 if (aencrypt)
252                     encryptLevel = rxkad_crypt;
253                 else
254                     encryptLevel = rxkad_clear;
255                 sc[2] = (struct rx_securityClass *)
256                     rxkad_NewClientSecurityObject(encryptLevel,
257                                                   &ttoken.sessionKey,
258                                                   ttoken.kvno,
259                                                   ttoken.ticketLen,
260                                                   ttoken.ticket);
261                 scIndex = 2;
262             } else
263                 afs_com_err("bos", code, "(getting tickets)");
264         }
265         if ((scIndex == 0) || (sc[scIndex] == 0)) {
266             fprintf(stderr, "bos: running unauthenticated\n");
267             scIndex = 0;
268         }
269     }
270     tconn =
271         rx_NewConnection(addr, htons(AFSCONF_NANNYPORT), 1, sc[scIndex],
272                          scIndex);
273     if (!tconn) {
274         fprintf(stderr, "bos: could not create rx connection\n");
275         exit(1);
276     }
277     rxs_Release(sc[scIndex]);
278
279     return tconn;
280 }
281
282 static int
283 SetAuth(struct cmd_syndesc *as, void *arock)
284 {
285     register afs_int32 code;
286     register struct rx_connection *tconn;
287     afs_int32 flag;
288     register char *tp;
289
290     tconn = GetConn(as, 0);
291     tp = as->parms[1].items->data;
292     if (strcmp(tp, "on") == 0)
293         flag = 0;               /* auth req.: noauthflag is false */
294     else if (strcmp(tp, "off") == 0)
295         flag = 1;
296     else {
297         printf
298             ("bos: illegal authentication specifier '%s', must be 'off' or 'on'.\n",
299              tp);
300         return 1;
301     }
302     code = BOZO_SetNoAuthFlag(tconn, flag);
303     if (code)
304         afs_com_err("bos", code, "(failed to set authentication flag)");
305     return 0;
306 }
307
308 /* take a name (e.g. foo/bar, and a dir e.g. /usr/afs/bin, and construct
309  * /usr/afs/bin/bar */
310 static int
311 ComputeDestDir(char *aname, char *adir, char *aresult, afs_int32 alen)
312 {
313     register char *tp;
314
315     strcpy(aresult, adir);
316     tp = strrchr(aname, '/');
317     if (!tp) {
318         /* no '/' in name */
319         strcat(aresult, "/");
320         strcat(aresult, aname);
321     } else {
322         /* tp points at the / character */
323         strcat(aresult, tp);
324     }
325     return 0;
326 }
327
328 /* copy data from fd afd to rx call acall */
329 static int
330 CopyBytes(int afd, register struct rx_call *acall)
331 {
332     register afs_int32 code;
333     register afs_int32 len;
334     char tbuffer[256];
335
336     while (1) {
337         len = read(afd, tbuffer, sizeof(tbuffer));
338         if (len < 0)
339             return errno;
340         if (len == 0)
341             return 0;           /* all done */
342         code = rx_Write(acall, tbuffer, len);
343         if (code != len)
344             return -1;
345     }
346 }
347
348 static int
349 Prune(register struct cmd_syndesc *as, void *arock)
350 {
351     register afs_int32 code;
352     register struct rx_connection *tconn;
353     register afs_int32 flags;
354
355     tconn = GetConn(as, 0);
356     flags = 0;
357     if (as->parms[1].items)
358         flags |= BOZO_PRUNEBAK;
359     if (as->parms[2].items)
360         flags |= BOZO_PRUNEOLD;
361     if (as->parms[3].items)
362         flags |= BOZO_PRUNECORE;
363     if (as->parms[4].items)
364         flags |= 0xff;
365     code = BOZO_Prune(tconn, flags);
366     if (code)
367         afs_com_err("bos", code, "(failed to prune server files)");
368     return code;
369 }
370
371 static int
372 Exec(register struct cmd_syndesc *as, void *arock)
373 {
374     register struct rx_connection *tconn;
375     register afs_int32 code;
376
377     tconn = GetConn(as, 0);
378     code = BOZO_Exec(tconn, as->parms[1].items->data);
379     if (code)
380         printf("bos: failed to execute command (%s)\n", em(code));
381     return code;
382 }
383
384 static int
385 GetDate(register struct cmd_syndesc *as, void *arock)
386 {
387     register afs_int32 code;
388     char tbuffer[256];
389     char destDir[256];
390     afs_int32 time, bakTime, oldTime;
391     register struct rx_connection *tconn;
392     register struct cmd_item *ti;
393
394     tconn = GetConn(as, 0);
395     if (!as->parms[1].items) {
396         printf("bos: no files to check\n");
397         return 1;
398     }
399
400     /* compute dest dir or file; default MUST be canonical form of dir path */
401     if (as->parms[2].items)
402         strcpy(destDir, as->parms[2].items->data);
403     else
404         strcpy(destDir, AFSDIR_CANONICAL_SERVER_BIN_DIRPATH);
405
406     for (ti = as->parms[1].items; ti; ti = ti->next) {
407         /* check date for each file */
408         ComputeDestDir(ti->data, destDir, tbuffer, sizeof(tbuffer));
409         code = BOZO_GetDates(tconn, tbuffer, &time, &bakTime, &oldTime);
410         if (code) {
411             printf("bos: failed to check date on %s (%s)\n", ti->data,
412                    em(code));
413             return 1;
414         } else {
415             printf("File %s ", tbuffer);
416             if (time == 0)
417                 printf("does not exist, ");
418             else
419                 printf("dated %s, ", DateOf(time));
420             if (bakTime == 0)
421                 printf("no .BAK file, ");
422             else
423                 printf(".BAK file dated %s, ", DateOf(bakTime));
424             if (oldTime == 0)
425                 printf("no .OLD file.");
426             else
427                 printf(".OLD file dated %s.", DateOf(oldTime));
428             printf("\n");
429         }
430     }
431     return 0;
432 }
433
434 static int
435 UnInstall(register struct cmd_syndesc *as, void *arock)
436 {
437     register afs_int32 code;
438     char tbuffer[256];
439     char destDir[256];
440     register struct cmd_item *ti;
441     register struct rx_connection *tconn;
442
443     tconn = GetConn(as, 0);
444     if (!as->parms[1].items) {
445         printf("bos: no files to uninstall\n");
446         return 1;
447     }
448
449     /* compute dest dir or file; default MUST be canonical form of dir path */
450     if (as->parms[2].items)
451         strcpy(destDir, as->parms[2].items->data);
452     else
453         strcpy(destDir, AFSDIR_CANONICAL_SERVER_BIN_DIRPATH);
454
455     for (ti = as->parms[1].items; ti; ti = ti->next) {
456         /* uninstall each file */
457         ComputeDestDir(ti->data, destDir, tbuffer, sizeof(tbuffer));
458         code = BOZO_UnInstall(tconn, tbuffer);
459         if (code) {
460             printf("bos: failed to uninstall %s (%s)\n", ti->data, em(code));
461             return 1;
462         } else
463             printf("bos: uninstalled file %s\n", ti->data);
464     }
465     return 0;
466 }
467
468 static afs_int32
469 GetServerGoal(struct rx_connection *aconn, char *aname)
470 {
471     char buffer[500];
472     char *tp;
473     register afs_int32 code;
474     struct bozo_status istatus;
475
476     tp = buffer;
477     code = BOZO_GetInstanceInfo(aconn, aname, &tp, &istatus);
478     if (code) {
479         printf("bos: failed to get instance info for '%s' (%s)\n", aname,
480                em(code));
481         /* if we can't get the answer, assume its running */
482         return BSTAT_NORMAL;
483     }
484     if (istatus.goal == 0)
485         return BSTAT_SHUTDOWN;
486     else
487         return BSTAT_NORMAL;
488 }
489
490 static int
491 Install(struct cmd_syndesc *as, void *arock)
492 {
493     struct rx_connection *tconn;
494     register afs_int32 code;
495     register struct cmd_item *ti;
496     struct stat tstat;
497     char tbuffer[256];
498     int fd;
499     struct rx_call *tcall;
500     char destDir[256];
501
502     tconn = GetConn(as, 0);
503     if (!as->parms[1].items) {
504         printf("bos: no files to install\n");
505         return 1;
506     }
507
508     /* compute dest dir or file; default MUST be canonical form of dir path */
509     if (as->parms[2].items)
510         strcpy(destDir, as->parms[2].items->data);
511     else
512         strcpy(destDir, AFSDIR_CANONICAL_SERVER_BIN_DIRPATH);
513
514     for (ti = as->parms[1].items; ti; ti = ti->next) {
515         /* install each file */
516         fd = open(ti->data, O_RDONLY);
517         if (fd < 0) {
518             /* better to quit on error than continue for install command */
519             printf("bos: can't find file '%s', quitting\n", ti->data);
520             return 1;
521         }
522         code = fstat(fd, &tstat);
523         if (code) {
524             printf("bos: failed to stat file %s, errno is %d\n", ti->data,
525                    errno);
526             return 1;
527         }
528         /* compute destination dir */
529         ComputeDestDir(ti->data, destDir, tbuffer, sizeof(tbuffer));
530         tcall = rx_NewCall(tconn);
531         code =
532             StartBOZO_Install(tcall, tbuffer, tstat.st_size,
533                               (afs_int32) tstat.st_mode, tstat.st_mtime);
534         if (code == 0) {
535             code = CopyBytes(fd, tcall);
536         }
537         code = rx_EndCall(tcall, code);
538         if (code) {
539             printf("bos: failed to install %s (%s)\n", ti->data, em(code));
540             return 1;
541         } else
542             printf("bos: installed file %s\n", ti->data);
543     }
544     return 0;
545 }
546
547 static int
548 Shutdown(struct cmd_syndesc *as, void *arock)
549 {
550     register struct rx_connection *tconn;
551     register afs_int32 code;
552     register struct cmd_item *ti;
553
554     tconn = GetConn(as, 0);
555     if (as->parms[1].items == 0) {
556         code = BOZO_ShutdownAll(tconn);
557         if (code)
558             printf("bos: failed to shutdown servers (%s)\n", em(code));
559     } else {
560         for (ti = as->parms[1].items; ti; ti = ti->next) {
561             code = BOZO_SetTStatus(tconn, ti->data, BSTAT_SHUTDOWN);
562             if (code)
563                 printf("bos: failed to shutdown instance %s (%s)\n", ti->data,
564                        em(code));
565         }
566     }
567     if (as->parms[8].items) {
568         code = BOZO_WaitAll(tconn);
569         if (code)
570             printf("bos: can't wait for processes to shutdown (%s)\n",
571                    em(code));
572     }
573     return 0;
574 }
575
576 static int
577 BlockScannerCmd(struct cmd_syndesc *as, void *arock)
578 {
579     register afs_int32 code;
580     struct rx_connection *tconn;
581     char BlockCommand[] = "/usr/afs/bin/scanner -block";
582
583     tconn = GetConn(as, 0);
584     code = BOZO_Exec(tconn, BlockCommand);
585     if (code)
586         printf
587             ("bos: failed to block scanner from making migration requests (%s)\n",
588              em(code));
589     return 0;
590 }
591
592 static int
593 UnBlockScannerCmd(struct cmd_syndesc *as, void *arock)
594 {
595     register afs_int32 code;
596     struct rx_connection *tconn;
597     char UnBlockCommand[] = "/usr/afs/bin/scanner -unblock";
598
599     tconn = GetConn(as, 0);
600     code = BOZO_Exec(tconn, UnBlockCommand);
601     if (code)
602         printf
603             ("bos: failed to allow scanner daemon to make migration requests again (%s)\n",
604              em(code));
605     return 0;
606 }
607
608 static int
609 GetRestartCmd(struct cmd_syndesc *as, void *arock)
610 {
611     register afs_int32 code;
612     struct ktime generalTime, newBinaryTime;
613     char messageBuffer[256];
614     struct rx_connection *tconn;
615     char *hostp;
616
617     hostp = as->parms[0].items->data;   /* host name for messages */
618     tconn = GetConn(as, 0);
619
620     code = BOZO_GetRestartTime(tconn, 1, (struct bozo_netKTime *) &generalTime);
621     if (code) {
622         printf("bos: failed to retrieve restart information (%s)\n",
623                em(code));
624         return code;
625     }
626     code = BOZO_GetRestartTime(tconn, 2, (struct bozo_netKTime *) &newBinaryTime);
627     if (code) {
628         printf("bos: failed to retrieve restart information (%s)\n",
629                em(code));
630         return code;
631     }
632
633     code = ktime_DisplayString(&generalTime, messageBuffer);
634     if (code) {
635         printf("bos: failed to decode restart time (%s)\n", em(code));
636         return code;
637     }
638     printf("Server %s restarts %s\n", hostp, messageBuffer);
639
640     code = ktime_DisplayString(&newBinaryTime, messageBuffer);
641     if (code) {
642         printf("bos: failed to decode restart time (%s)\n", em(code));
643         return code;
644     }
645     printf("Server %s restarts for new binaries %s\n", hostp, messageBuffer);
646
647     /* all done now */
648     return 0;
649 }
650
651 static int
652 SetRestartCmd(struct cmd_syndesc *as, void *arock)
653 {
654     afs_int32 count = 0;
655     register afs_int32 code;
656     struct ktime restartTime;
657     afs_int32 type = 0 ;
658     struct rx_connection *tconn;
659
660     count = 0;
661     tconn = GetConn(as, 0);
662     if (as->parms[2].items) {
663         count++;
664         type = 1;
665     }
666     if (as->parms[3].items) {
667         count++;
668         type = 2;
669     }
670     if (count > 1) {
671         printf("bos: can't specify more than one restart time at a time\n");
672         return -1;
673     }
674     if (count == 0)
675         type = 1;               /* by default set general restart time */
676
677     if ((code = ktime_ParsePeriodic(as->parms[1].items->data, &restartTime))) {
678         printf("bos: failed to parse '%s' as periodic restart time(%s)\n",
679                as->parms[1].items->data, em(code));
680         return code;
681     }
682
683     code = BOZO_SetRestartTime(tconn, type, (struct bozo_netKTime *) &restartTime);
684     if (code) {
685         printf("bos: failed to set restart time at server (%s)\n", em(code));
686         return code;
687     }
688     return 0;
689 }
690
691 static int
692 Startup(struct cmd_syndesc *as, void *arock)
693 {
694     register struct rx_connection *tconn;
695     register afs_int32 code;
696     register struct cmd_item *ti;
697
698     tconn = GetConn(as, 0);
699     if (as->parms[1].items == 0) {
700         code = BOZO_StartupAll(tconn);
701         if (code)
702             printf("bos: failed to startup servers (%s)\n", em(code));
703     } else {
704         for (ti = as->parms[1].items; ti; ti = ti->next) {
705             code = BOZO_SetTStatus(tconn, ti->data, BSTAT_NORMAL);
706             if (code)
707                 printf("bos: failed to start instance %s (%s)\n", ti->data,
708                        em(code));
709         }
710     }
711     return 0;
712 }
713
714 static int
715 Restart(struct cmd_syndesc *as, void *arock)
716 {
717     register struct rx_connection *tconn;
718     register afs_int32 code;
719     register struct cmd_item *ti;
720
721     tconn = GetConn(as, 0);
722     if (as->parms[2].items) {
723         /* this is really a rebozo command */
724         if (as->parms[1].items) {
725             /* specified specific things to restart, can't do this at the same
726              * time */
727             printf
728                 ("bos: can't specify both '-bos' and specific servers to restart.\n");
729             return 1;
730         }
731         /* otherwise do a rebozo */
732         code = BOZO_ReBozo(tconn);
733         if (code)
734             printf("bos: failed to restart bosserver (%s)\n", em(code));
735         return code;
736     }
737     if (as->parms[1].items == 0) {
738         if (as->parms[3].items) {       /* '-all' */
739             code = BOZO_RestartAll(tconn);
740             if (code)
741                 printf("bos: failed to restart servers (%s)\n", em(code));
742         } else
743             printf("bos: To restart all processes please specify '-all'\n");
744     } else {
745         if (as->parms[3].items) {
746             printf("bos: Can't use '-all' along with individual instances\n");
747         } else {
748             for (ti = as->parms[1].items; ti; ti = ti->next) {
749                 code = BOZO_Restart(tconn, ti->data);
750                 if (code)
751                     printf("bos: failed to restart instance %s (%s)\n",
752                            ti->data, em(code));
753             }
754         }
755     }
756     return 0;
757 }
758
759 static int
760 SetCellName(struct cmd_syndesc *as, void *arock)
761 {
762     register struct rx_connection *tconn;
763     register afs_int32 code;
764
765     tconn = GetConn(as, 0);
766     code = BOZO_SetCellName(tconn, as->parms[1].items->data);
767     if (code)
768         printf("bos: failed to set cell (%s)\n", em(code));
769     return 0;
770 }
771
772 static int
773 AddHost(register struct cmd_syndesc *as, void *arock)
774 {
775     register struct rx_connection *tconn;
776     register afs_int32 code;
777     register struct cmd_item *ti;
778     char name[MAXHOSTCHARS];
779
780     tconn = GetConn(as, 0);
781     for (ti = as->parms[1].items; ti; ti = ti->next) {
782         if (as->parms[2].items) {
783             if (strlen(ti->data) > MAXHOSTCHARS - 3) {
784                 fprintf(stderr, "bos: host name too long\n");
785                 return E2BIG;
786             }
787             name[0] = '[';
788             strcpy(&name[1], ti->data);
789             strcat((char *)&name, "]");
790             code = BOZO_AddCellHost(tconn, name);
791         } else
792             code = BOZO_AddCellHost(tconn, ti->data);
793         if (code)
794             printf("bos: failed to add host %s (%s)\n", ti->data, em(code));
795     }
796     return 0;
797 }
798
799 static int
800 RemoveHost(register struct cmd_syndesc *as, void *arock)
801 {
802     register struct rx_connection *tconn;
803     register afs_int32 code;
804     register struct cmd_item *ti;
805
806     tconn = GetConn(as, 0);
807     for (ti = as->parms[1].items; ti; ti = ti->next) {
808         code = BOZO_DeleteCellHost(tconn, ti->data);
809         if (code)
810             printf("bos: failed to delete host %s (%s)\n", ti->data,
811                    em(code));
812     }
813     return 0;
814 }
815
816 static int
817 ListHosts(register struct cmd_syndesc *as, void *arock)
818 {
819     register struct rx_connection *tconn;
820     register afs_int32 code;
821     char tbuffer[256];
822     char *tp;
823     register afs_int32 i;
824
825     tp = tbuffer;
826     tconn = GetConn(as, 0);
827     code = BOZO_GetCellName(tconn, &tp);
828     if (code) {
829         printf("bos: failed to get cell name (%s)\n", em(code));
830         exit(1);
831     }
832     printf("Cell name is %s\n", tbuffer);
833     for (i = 0;; i++) {
834         code = BOZO_GetCellHost(tconn, i, &tp);
835         if (code == BZDOM)
836             break;
837         if (code != 0) {
838             printf("bos: failed to get cell host %d (%s)\n", i, em(code));
839             exit(1);
840         }
841         printf("    Host %d is %s\n", i + 1, tbuffer);
842     }
843     return 0;
844 }
845
846 static int
847 AddKey(register struct cmd_syndesc *as, void *arock)
848 {
849     register struct rx_connection *tconn;
850     register afs_int32 code;
851     struct ktc_encryptionKey tkey;
852     afs_int32 temp;
853     char *tcell;
854     char cellBuffer[256];
855     char buf[BUFSIZ], ver[BUFSIZ];
856
857     tconn = GetConn(as, 1);
858     memset(&tkey, 0, sizeof(struct ktc_encryptionKey));
859
860     if (as->parms[1].items)
861         strcpy(buf, as->parms[1].items->data);
862     else {
863         /* prompt for key */
864         code = des_read_pw_string(buf, sizeof(buf), "input key: ", 0);
865         if (code || strlen(buf) == 0) {
866             fprintf(stderr, "Bad key: \n");
867             exit(1);
868         }
869         code = des_read_pw_string(ver, sizeof(ver), "Retype input key: ", 0);
870         if (code || strlen(ver) == 0) {
871             fprintf(stderr, "Bad key: \n");
872             exit(1);
873         }
874         if (strcmp(ver, buf) != 0) {
875             fprintf(stderr, "\nInput key mismatch\n");
876             exit(1);
877         }
878
879     }
880
881     temp = atoi(as->parms[2].items->data);
882     if (temp == 999) {
883         /* bcrypt key */
884 /*
885         strcpy((char *)&tkey, as->parms[1].items->data);
886 */
887         strcpy((char *)&tkey, buf);
888     } else {                    /* kerberos key */
889         if (as->parms[ADDPARMOFFSET].items) {
890             strcpy(cellBuffer, as->parms[ADDPARMOFFSET].items->data);
891
892             /* string to key needs upper-case cell names */
893
894             /* I don't believe this is true.  The string to key function
895              * actually expands the cell name, then LOWER-CASES it.  Perhaps it
896              * didn't use to??? */
897             ucstring(cellBuffer, cellBuffer, strlen(cellBuffer));
898             tcell = cellBuffer;
899         } else
900             tcell = NULL;       /* no cell specified, use current */
901 /*
902         ka_StringToKey(as->parms[1].items->data, tcell, &tkey);
903 */
904         ka_StringToKey(buf, tcell, &tkey);
905     }
906     tconn = GetConn(as, 1);
907     code = BOZO_AddKey(tconn, temp, &tkey);
908     if (code) {
909         printf("bos: failed to set key %d (%s)\n", temp, em(code));
910         exit(1);
911     }
912     return 0;
913 }
914
915 static int
916 RemoveKey(register struct cmd_syndesc *as, void *arock)
917 {
918     register struct rx_connection *tconn;
919     register afs_int32 code;
920     afs_int32 temp;
921     register struct cmd_item *ti;
922
923     tconn = GetConn(as, 0);
924     for (ti = as->parms[1].items; ti; ti = ti->next) {
925         temp = atoi(ti->data);
926         code = BOZO_DeleteKey(tconn, temp);
927         if (code) {
928             printf("bos: failed to delete key %d (%s)\n", temp, em(code));
929             exit(1);
930         }
931     }
932     return 0;
933 }
934
935 static int
936 ListKeys(register struct cmd_syndesc *as, void *arock)
937 {
938     register struct rx_connection *tconn;
939     register afs_int32 code;
940     struct ktc_encryptionKey tkey;
941     afs_int32 kvno;
942     struct bozo_keyInfo keyInfo;
943     int everWorked;
944     register afs_int32 i;
945
946     tconn = GetConn(as, 1);
947     everWorked = 0;
948     for (i = 0;; i++) {
949         code = BOZO_ListKeys(tconn, i, &kvno, &tkey, &keyInfo);
950         if (code)
951             break;
952         everWorked = 1;
953         /* first check if key is returned */
954         if ((!ka_KeyIsZero(&tkey, sizeof(tkey))) && (as->parms[1].items)) {
955             printf("key %d is '", kvno);
956             ka_PrintBytes(&tkey, sizeof(tkey));
957             printf("'\n");
958         } else {
959             if (keyInfo.keyCheckSum == 0)       /* shouldn't happen */
960                 printf("key version is %d\n", kvno);
961             else
962                 printf("key %d has cksum %u\n", kvno, keyInfo.keyCheckSum);
963         }
964     }
965     if (everWorked) {
966         printf("Keys last changed on %s.\n", DateOf(keyInfo.mod_sec));
967     }
968     if (code != BZDOM)
969         printf("bos: %s error encountered while listing keys\n", em(code));
970     else
971         printf("All done.\n");
972     return 0;
973 }
974
975 static int
976 AddSUser(register struct cmd_syndesc *as, void *arock)
977 {
978     register struct rx_connection *tconn;
979     register afs_int32 code;
980     int failed;
981     register struct cmd_item *ti;
982
983     failed = 0;
984     tconn = GetConn(as, 0);
985     for (ti = as->parms[1].items; ti; ti = ti->next) {
986         code = BOZO_AddSUser(tconn, ti->data);
987         if (code) {
988             printf("bos: failed to add user '%s' (%s)\n", ti->data, em(code));
989             failed = 1;
990         }
991     }
992     return failed;
993 }
994
995 static int
996 RemoveSUser(register struct cmd_syndesc *as, void *arock)
997 {
998     register struct rx_connection *tconn;
999     register struct cmd_item *ti;
1000     register afs_int32 code;
1001     int failed;
1002
1003     failed = 0;
1004     tconn = GetConn(as, 0);
1005     for (ti = as->parms[1].items; ti; ti = ti->next) {
1006         code = BOZO_DeleteSUser(tconn, ti->data);
1007         if (code) {
1008             printf("bos: failed to delete user '%s', ", ti->data);
1009             if (code == ENOENT)
1010                 printf("(no such user)\n");
1011             else
1012                 printf("(%s)\n", em(code));
1013             failed = 1;
1014         }
1015     }
1016     return failed;
1017 }
1018
1019 #define NPERLINE    10          /* dudes to print per line */
1020 static int
1021 ListSUsers(register struct cmd_syndesc *as, void *arock)
1022 {
1023     register struct rx_connection *tconn;
1024     register int i;
1025     register afs_int32 code;
1026     char tbuffer[256];
1027     char *tp;
1028     int lastNL, printGreeting;
1029
1030     tconn = GetConn(as, 0);
1031     lastNL = 0;
1032     printGreeting = 1;
1033     for (i = 0;; i++) {
1034         tp = tbuffer;
1035         code = BOZO_ListSUsers(tconn, i, &tp);
1036         if (code)
1037             break;
1038         if (printGreeting) {
1039             printGreeting = 0;  /* delay until after first call succeeds */
1040             printf("SUsers are: ");
1041         }
1042         printf("%s ", tbuffer);
1043         if ((i % NPERLINE) == NPERLINE - 1) {
1044             printf("\n");
1045             lastNL = 1;
1046         } else
1047             lastNL = 0;
1048     }
1049     if (code != 1) {
1050         /* a real error code, instead of scanned past end */
1051         printf("bos: failed to retrieve super-user list (%s)\n", em(code));
1052         return code;
1053     }
1054     if (lastNL == 0)
1055         printf("\n");
1056     return 0;
1057 }
1058
1059 static int
1060 StatServer(register struct cmd_syndesc *as, void *arock)
1061 {
1062     register struct rx_connection *tconn;
1063     register afs_int32 code;
1064     register int i;
1065     char ibuffer[BOZO_BSSIZE];
1066     char *tp;
1067     int int32p;
1068
1069     /* int32p==1 is obsolete, smaller, printout */
1070     int32p = (as->parms[2].items != 0 ? 2 : 0);
1071
1072     /* no parms does something pretty different */
1073     if (as->parms[1].items)
1074         return IStatServer(as, int32p);
1075
1076     tconn = GetConn(as, 0);
1077     for (i = 0;; i++) {
1078         /* for each instance */
1079         tp = ibuffer;
1080         code = BOZO_EnumerateInstance(tconn, i, &tp);
1081         if (code == BZDOM)
1082             break;
1083         if (code) {
1084             printf("bos: failed to contact host's bosserver (%s).\n",
1085                    em(code));
1086             break;
1087         }
1088         DoStat(ibuffer, tconn, int32p, (i == 0));       /* print status line */
1089     }
1090     return 0;
1091 }
1092
1093 static int
1094 CreateServer(register struct cmd_syndesc *as, void *arock)
1095 {
1096     register struct rx_connection *tconn;
1097     register afs_int32 code;
1098     char *parms[6];
1099     register struct cmd_item *ti;
1100     register int i;
1101     char *type, *name, *notifier = NONOTIFIER;
1102
1103     tconn = GetConn(as, 0);
1104     for (i = 0; i < 6; i++)
1105         parms[i] = "";
1106     for (i = 0, ti = as->parms[3].items; (ti && i < 6); ti = ti->next, i++) {
1107         parms[i] = ti->data;
1108     }
1109     name = as->parms[1].items->data;
1110     type = as->parms[2].items->data;
1111     if ((ti = as->parms[4].items)) {
1112         notifier = ti->data;
1113     }
1114     code =
1115         BOZO_CreateBnode(tconn, type, name, parms[0], parms[1], parms[2],
1116                          parms[3], parms[4], notifier);
1117     if (code) {
1118         printf
1119             ("bos: failed to create new server instance %s of type '%s' (%s)\n",
1120              name, type, em(code));
1121     }
1122     return code;
1123 }
1124
1125 static int
1126 DeleteServer(register struct cmd_syndesc *as, void *arock)
1127 {
1128     register struct rx_connection *tconn;
1129     register afs_int32 code;
1130     register struct cmd_item *ti;
1131
1132     code = 0;
1133     tconn = GetConn(as, 0);
1134     for (ti = as->parms[1].items; ti; ti = ti->next) {
1135         code = BOZO_DeleteBnode(tconn, ti->data);
1136         if (code) {
1137             if (code == BZBUSY)
1138                 printf("bos: can't delete running instance '%s'\n", ti->data);
1139             else
1140                 printf("bos: failed to delete instance '%s' (%s)\n", ti->data,
1141                        em(code));
1142         }
1143     }
1144     return code;
1145 }
1146
1147 static int
1148 StartServer(register struct cmd_syndesc *as, void *arock)
1149 {
1150     register struct rx_connection *tconn;
1151     register afs_int32 code;
1152     register struct cmd_item *ti;
1153
1154     code = 0;
1155     tconn = GetConn(as, 0);
1156     for (ti = as->parms[1].items; ti; ti = ti->next) {
1157         code = BOZO_SetStatus(tconn, ti->data, BSTAT_NORMAL);
1158         if (code)
1159             printf("bos: failed to start instance '%s' (%s)\n", ti->data,
1160                    em(code));
1161     }
1162     return code;
1163 }
1164
1165 static int
1166 StopServer(register struct cmd_syndesc *as, void *arock)
1167 {
1168     register struct rx_connection *tconn;
1169     register afs_int32 code;
1170     register struct cmd_item *ti;
1171
1172     code = 0;
1173     tconn = GetConn(as, 0);
1174     for (ti = as->parms[1].items; ti; ti = ti->next) {
1175         code = BOZO_SetStatus(tconn, ti->data, BSTAT_SHUTDOWN);
1176         if (code)
1177             printf("bos: failed to change stop instance '%s' (%s)\n",
1178                    ti->data, em(code));
1179     }
1180     if (as->parms[8].items) {
1181         code = BOZO_WaitAll(tconn);
1182         if (code)
1183             printf("bos: can't wait for processes to shutdown (%s)\n",
1184                    em(code));
1185     }
1186     return code;
1187 }
1188
1189 #define PARMBUFFERSSIZE 32
1190
1191 static afs_int32
1192 DoSalvage(struct rx_connection * aconn, char * aparm1, char * aparm2, 
1193           char * aoutName, afs_int32 showlog, char * parallel, 
1194           char * atmpDir, char * orphans, int dafs, 
1195           struct MRAFSSalvageParms * mrafsParm)
1196 {
1197     register afs_int32 code;
1198     char *parms[6];
1199     char buffer;
1200     char tbuffer[BOZO_BSSIZE];
1201     struct bozo_status istatus;
1202     struct rx_call *tcall;
1203     char *tp;
1204     FILE *outFile;
1205     int closeIt;
1206     char partName[20];          /* canonical name for partition */
1207     char pbuffer[PARMBUFFERSSIZE];
1208     afs_int32 partNumber;
1209     char *notifier = NONOTIFIER;
1210
1211     /* if a partition was specified, canonicalize the name, since
1212      * the salvager has a stupid partition ID parser */
1213     if (aparm1) {
1214         partNumber = volutil_GetPartitionID(aparm1);
1215         if (partNumber < 0) {
1216             printf("bos: could not parse partition ID '%s'\n", aparm1);
1217             return EINVAL;
1218         }
1219         tp = volutil_PartitionName(partNumber);
1220         if (!tp) {
1221             printf("bos: internal error parsing partition ID '%s'\n", aparm1);
1222             return EINVAL;
1223         }
1224         strcpy(partName, tp);
1225     } else
1226         partName[0] = 0;
1227
1228     /* open the file name */
1229     if (aoutName) {
1230         outFile = fopen(aoutName, "w");
1231         if (!outFile) {
1232             printf("bos: can't open specified SalvageLog file '%s'\n",
1233                    aoutName);
1234             return ENOENT;
1235         }
1236         closeIt = 1;            /* close this file later */
1237     } else {
1238         outFile = stdout;
1239         closeIt = 0;            /* don't close this file later */
1240     }
1241
1242     for (code = 2; code < 6; code++)
1243         parms[code] = "";
1244     if (!aparm2)
1245         aparm2 = "";
1246
1247     /* MUST pass canonical (wire-format) salvager path to bosserver */
1248     if (*aparm2 != 0) {
1249         /* single volume salvage */
1250         if (dafs) {
1251             /* for DAFS, we call the salvagserver binary with special options.
1252              * in this mode, it simply uses SALVSYNC to tell the currently
1253              * running salvageserver to offline and salvage the volume in question */
1254             strncpy(tbuffer, AFSDIR_CANONICAL_SERVER_SALSRV_FILEPATH, BOZO_BSSIZE);
1255
1256             if ((strlen(tbuffer) + 9 + strlen(partName) + 1 + strlen(aparm2) +
1257                  1) > BOZO_BSSIZE) {
1258                 printf("bos: command line too big\n");
1259                 return (E2BIG);
1260             }
1261
1262             strcat(tbuffer, " -client ");
1263             strcat(tbuffer, partName);
1264             strcat(tbuffer, " ");
1265             strcat(tbuffer, aparm2);
1266         } else {
1267             strncpy(tbuffer, AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH, BOZO_BSSIZE);
1268
1269             if ((strlen(tbuffer) + 1 + strlen(partName) + 1 + strlen(aparm2) +
1270                  1) > BOZO_BSSIZE) {
1271                 printf("bos: command line too big\n");
1272                 return (E2BIG);
1273             }
1274
1275             strcat(tbuffer, " ");
1276             strcat(tbuffer, partName);
1277             strcat(tbuffer, " ");
1278             strcat(tbuffer, aparm2);
1279         }
1280     } else {
1281         /* partition salvage */
1282         strncpy(tbuffer, AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH, BOZO_BSSIZE);
1283         if ((strlen(tbuffer) + 4 + strlen(partName) + 1) > BOZO_BSSIZE) {
1284             printf("bos: command line too big\n");
1285             return (E2BIG);
1286         }
1287         strcat(tbuffer, " -force ");
1288         strcat(tbuffer, partName);
1289     }
1290
1291     /* For DAFS, specifying a single volume does not result in a standard
1292      * salvager call.  Instead, it simply results in a SALVSYNC call to the
1293      * online salvager daemon.  This interface does not give us the same rich
1294      * set of call flags.  Thus, we skip these steps for DAFS single-volume 
1295      * calls */
1296     if (!dafs || (*aparm2 == 0)) {
1297         /* add the parallel option if given */
1298         if (parallel != NULL) {
1299             if ((strlen(tbuffer) + 11 + strlen(parallel) + 1) > BOZO_BSSIZE) {
1300                 printf("bos: command line too big\n");
1301                 return (E2BIG);
1302             }
1303             strcat(tbuffer, " -parallel ");
1304             strcat(tbuffer, parallel);
1305         }
1306
1307         /* add the tmpdir option if given */
1308         if (atmpDir != NULL) {
1309             if ((strlen(tbuffer) + 9 + strlen(atmpDir) + 1) > BOZO_BSSIZE) {
1310                 printf("bos: command line too big\n");
1311                 return (E2BIG);
1312             }
1313             strcat(tbuffer, " -tmpdir ");
1314             strcat(tbuffer, atmpDir);
1315         }
1316
1317         /* add the orphans option if given */
1318         if (orphans != NULL) {
1319             if ((strlen(tbuffer) + 10 + strlen(orphans) + 1) > BOZO_BSSIZE) {
1320                 printf("bos: command line too big\n");
1321                 return (E2BIG);
1322             }
1323             strcat(tbuffer, " -orphans ");
1324             strcat(tbuffer, orphans);
1325         }
1326
1327         if (mrafsParm->Optdebug)
1328             strcat(tbuffer, " -debug");
1329         if (mrafsParm->Optnowrite)
1330             strcat(tbuffer, " -nowrite");
1331         if (mrafsParm->Optforce)
1332             strcat(tbuffer, " -force");
1333         if (mrafsParm->Optoktozap)
1334             strcat(tbuffer, " -oktozap");
1335         if (mrafsParm->Optrootfiles)
1336             strcat(tbuffer, " -rootfiles");
1337         if (mrafsParm->Optsalvagedirs)
1338             strcat(tbuffer, " -salvagedirs");
1339         if (mrafsParm->Optblockreads)
1340             strcat(tbuffer, " -blockreads");
1341         if (mrafsParm->OptListResidencies)
1342             strcat(tbuffer, " -ListResidencies");
1343         if (mrafsParm->OptSalvageRemote)
1344             strcat(tbuffer, " -SalvageRemote");
1345         if (mrafsParm->OptSalvageArchival)
1346             strcat(tbuffer, " -SalvageArchival");
1347         if (mrafsParm->OptIgnoreCheck)
1348             strcat(tbuffer, " -IgnoreCheck");
1349         if (mrafsParm->OptForceOnLine)
1350             strcat(tbuffer, " -ForceOnLine");
1351         if (mrafsParm->OptUseRootDirACL)
1352             strcat(tbuffer, " -UseRootDirACL");
1353         if (mrafsParm->OptTraceBadLinkCounts)
1354             strcat(tbuffer, " -TraceBadLinkCounts");
1355         if (mrafsParm->OptDontAskFS)
1356             strcat(tbuffer, " -DontAskFS");
1357         if (mrafsParm->OptLogLevel) {
1358             sprintf(pbuffer, " -LogLevel %ld", afs_printable_int32_ld(mrafsParm->OptLogLevel));
1359             strcat(tbuffer, pbuffer);
1360         }
1361         if (mrafsParm->OptRxDebug)
1362             strcat(tbuffer, " -rxdebug");
1363         if (mrafsParm->OptResidencies) {
1364             sprintf(pbuffer, " -Residencies %lu", 
1365                     afs_printable_uint32_lu(mrafsParm->OptResidencies));
1366             strcat(tbuffer, pbuffer);
1367         }
1368     }
1369
1370     parms[0] = tbuffer;
1371     parms[1] = "now";           /* when to do it */
1372     code =
1373         BOZO_CreateBnode(aconn, "cron", "salvage-tmp", parms[0], parms[1],
1374                          parms[2], parms[3], parms[4], notifier);
1375     if (code) {
1376         printf("bos: failed to start 'salvager' (%s)\n", em(code));
1377         goto done;
1378     }
1379     /* now wait for bnode to disappear */
1380     while (1) {
1381         IOMGR_Sleep(5);
1382         tp = tbuffer;
1383         code = BOZO_GetInstanceInfo(aconn, "salvage-tmp", &tp, &istatus);
1384         if (code)
1385             break;
1386         printf("bos: waiting for salvage to complete.\n");
1387     }
1388     if (code != BZNOENT) {
1389         printf("bos: salvage failed (%s)\n", em(code));
1390         goto done;
1391     }
1392     code = 0;
1393
1394     /* now print the log file to the output file */
1395     printf("bos: salvage completed\n");
1396     if (aoutName || showlog) {
1397         fprintf(outFile, "SalvageLog:\n");
1398         tcall = rx_NewCall(aconn);
1399         /* MUST pass canonical (wire-format) salvager log path to bosserver */
1400         code =
1401             StartBOZO_GetLog(tcall, AFSDIR_CANONICAL_SERVER_SLVGLOG_FILEPATH);
1402         if (code) {
1403             rx_EndCall(tcall, code);
1404             goto done;
1405         }
1406         /* copy data */
1407         while (1) {
1408             code = rx_Read(tcall, &buffer, 1);
1409             if (code != 1)
1410                 break;
1411             putc(buffer, outFile);
1412             if (buffer == 0)
1413                 break;          /* the end delimeter */
1414         }
1415         code = rx_EndCall(tcall, 0);
1416         /* fall through into cleanup code */
1417     }
1418
1419   done:
1420     if (closeIt && outFile)
1421         fclose(outFile);
1422     return code;
1423 }
1424
1425 static int
1426 GetLogCmd(register struct cmd_syndesc *as, void *arock)
1427 {
1428     struct rx_connection *tconn;
1429     register struct rx_call *tcall;
1430     register afs_int32 code;
1431     char buffer;
1432     int error;
1433
1434     printf("Fetching log file '%s'...\n", as->parms[1].items->data);
1435     tconn = GetConn(as, 0);
1436     tcall = rx_NewCall(tconn);
1437     code = StartBOZO_GetLog(tcall, as->parms[1].items->data);
1438     if (code) {
1439         rx_EndCall(tcall, code);
1440         goto done;
1441     }
1442     /* copy data */
1443     error = 0;
1444     while (1) {
1445         code = rx_Read(tcall, &buffer, 1);
1446         if (code != 1) {
1447             error = EIO;
1448             break;
1449         }
1450         if (buffer == 0)
1451             break;              /* the end delimeter */
1452         putchar(buffer);
1453     }
1454     code = rx_EndCall(tcall, error);
1455     /* fall through into cleanup code */
1456
1457   done:
1458     if (code)
1459         afs_com_err("bos", code, "(while reading log)");
1460     return code;
1461 }
1462
1463 static int
1464 SalvageCmd(struct cmd_syndesc *as, void *arock)
1465 {
1466     register struct rx_connection *tconn;
1467     register afs_int32 code, rc, i;
1468     char *outName;
1469     char tname[BOZO_BSSIZE];
1470     afs_int32 newID;
1471     extern struct ubik_client *cstruct;
1472     afs_int32 curGoal, showlog = 0, dafs = 0, mrafs = 0;
1473     char *parallel;
1474     char *tmpDir;
1475     char *orphans;
1476     char *tp;
1477     char * serviceName;
1478     struct MRAFSSalvageParms mrafsParm;
1479
1480     memset(&mrafsParm, 0, sizeof(mrafsParm));
1481
1482     /* parm 0 is machine name, 1 is partition, 2 is volume, 3 is -all flag */
1483     tconn = GetConn(as, 0);
1484
1485     tp = &tname[0];
1486
1487     /* find out whether fileserver is running demand attach fs */
1488     if ((code = BOZO_GetInstanceParm(tconn, "dafs", 0, &tp) == 0)) {
1489         dafs = 1;
1490         serviceName = "dafs";
1491         /* Find out whether fileserver is running MR-AFS (has a scanner instance) */
1492         /* XXX this should really be done some other way, potentially by RPC */
1493         if ((code = BOZO_GetInstanceParm(tconn, serviceName, 4, &tp) == 0))
1494             mrafs = 1;
1495     } else {
1496         serviceName = "fs";
1497         /* Find out whether fileserver is running MR-AFS (has a scanner instance) */
1498         /* XXX this should really be done some other way, potentially by RPC */
1499         if ((code = BOZO_GetInstanceParm(tconn, serviceName, 3, &tp) == 0))
1500             mrafs = 1;
1501     }
1502
1503     /* we can do a volume, a partition or the whole thing, but not mixtures
1504      * thereof */
1505     if (!as->parms[1].items && as->parms[2].items) {
1506         printf("bos: must specify partition to salvage individual volume.\n");
1507         return -1;
1508     }
1509     if (as->parms[5].items && as->parms[3].items) {
1510         printf("bos: can not specify both -file and -showlog.\n");
1511         return -1;
1512     }
1513     if (as->parms[4].items && (as->parms[1].items || as->parms[2].items)) {
1514         printf("bos: can not specify -all with other flags.\n");
1515         return -1;
1516     }
1517
1518     /* get the output file name, if any */
1519     if (as->parms[3].items)
1520         outName = as->parms[3].items->data;
1521     else
1522         outName = NULL;
1523
1524     if (as->parms[5].items)
1525         showlog = 1;
1526
1527     /* parallel option */
1528     parallel = NULL;
1529     if (as->parms[6].items)
1530         parallel = as->parms[6].items->data;
1531
1532     /* get the tmpdir filename if any */
1533     tmpDir = NULL;
1534     if (as->parms[7].items)
1535         tmpDir = as->parms[7].items->data;
1536
1537     /* -orphans option */
1538     orphans = NULL;
1539     if (as->parms[8].items) {
1540         if (mrafs) {
1541             printf("Can't specify -orphans for MR-AFS fileserver\n");
1542             return EINVAL;
1543         }
1544         orphans = as->parms[8].items->data;
1545     }
1546
1547     if (dafs) {
1548         if (!as->parms[9].items) { /* -forceDAFS flag */
1549             printf("This is a demand attach fileserver.  Are you sure you want to proceed with a manual salvage?\n");
1550             printf("must specify -forceDAFS flag in order to proceed.\n");
1551             return EINVAL;
1552         }
1553     }
1554
1555     if (mrafs) {
1556         if (as->parms[MRAFS_OFFSET].items)
1557             mrafsParm.Optdebug = 1;
1558         if (as->parms[MRAFS_OFFSET + 1].items)
1559             mrafsParm.Optnowrite = 1;
1560         if (as->parms[MRAFS_OFFSET + 2].items)
1561             mrafsParm.Optforce = 1;
1562         if (as->parms[MRAFS_OFFSET + 3].items)
1563             mrafsParm.Optoktozap = 1;
1564         if (as->parms[MRAFS_OFFSET + 4].items)
1565             mrafsParm.Optrootfiles = 1;
1566         if (as->parms[MRAFS_OFFSET + 5].items)
1567             mrafsParm.Optsalvagedirs = 1;
1568         if (as->parms[MRAFS_OFFSET + 6].items)
1569             mrafsParm.Optblockreads = 1;
1570         if (as->parms[MRAFS_OFFSET + 7].items)
1571             mrafsParm.OptListResidencies = 1;
1572         if (as->parms[MRAFS_OFFSET + 8].items)
1573             mrafsParm.OptSalvageRemote = 1;
1574         if (as->parms[MRAFS_OFFSET + 9].items)
1575             mrafsParm.OptSalvageArchival = 1;
1576         if (as->parms[MRAFS_OFFSET + 10].items)
1577             mrafsParm.OptIgnoreCheck = 1;
1578         if (as->parms[MRAFS_OFFSET + 11].items)
1579             mrafsParm.OptForceOnLine = 1;
1580         if (as->parms[MRAFS_OFFSET + 12].items)
1581             mrafsParm.OptUseRootDirACL = 1;
1582         if (as->parms[MRAFS_OFFSET + 13].items)
1583             mrafsParm.OptTraceBadLinkCounts = 1;
1584         if (as->parms[MRAFS_OFFSET + 14].items)
1585             mrafsParm.OptDontAskFS = 1;
1586         if (as->parms[MRAFS_OFFSET + 15].items)
1587             mrafsParm.OptLogLevel =
1588                 atoi(as->parms[MRAFS_OFFSET + 15].items->data);
1589         if (as->parms[MRAFS_OFFSET + 16].items)
1590             mrafsParm.OptRxDebug = 1;
1591         if (as->parms[MRAFS_OFFSET + 17].items) {
1592             if (as->parms[MRAFS_OFFSET + 8].items
1593                 || as->parms[MRAFS_OFFSET + 9].items) {
1594                 printf
1595                     ("Can't specify -Residencies with -SalvageRemote or -SalvageArchival\n");
1596                 return EINVAL;
1597             }
1598             code =
1599                 util_GetUInt32(as->parms[MRAFS_OFFSET + 17].items->data,
1600                                &mrafsParm.OptResidencies);
1601             if (code) {
1602                 printf("bos: '%s' is not a valid residency mask.\n",
1603                        as->parms[MRAFS_OFFSET + 13].items->data);
1604                 return code;
1605             }
1606         }
1607     } else {
1608         int stop = 0;
1609
1610         for (i = MRAFS_OFFSET; i < ADDPARMOFFSET; i++) {
1611             if (as->parms[i].items) {
1612                 printf(" %s only possible for MR-AFS fileserver.\n",
1613                        as->parms[i].name);
1614                 stop = 1;
1615             }
1616         }
1617         if (stop)
1618             exit(1);
1619     }
1620
1621     if (as->parms[4].items) {
1622         /* salvage whole enchilada */
1623         curGoal = GetServerGoal(tconn, serviceName);
1624         if (curGoal == BSTAT_NORMAL) {
1625             printf("bos: shutting down '%s'.\n", serviceName);
1626             code = BOZO_SetTStatus(tconn, serviceName, BSTAT_SHUTDOWN);
1627             if (code) {
1628                 printf("bos: failed to stop '%s' (%s)\n", serviceName, em(code));
1629                 return code;
1630             }
1631             code = BOZO_WaitAll(tconn); /* wait for shutdown to complete */
1632             if (code)
1633                 printf
1634                     ("bos: failed to wait for file server shutdown, continuing.\n");
1635         }
1636         /* now do the salvage operation */
1637         printf("Starting salvage.\n");
1638         rc = DoSalvage(tconn, NULL, NULL, outName, showlog, parallel, tmpDir,
1639                        orphans, dafs, &mrafsParm);
1640         if (curGoal == BSTAT_NORMAL) {
1641             printf("bos: restarting %s.\n", serviceName);
1642             code = BOZO_SetTStatus(tconn, serviceName, BSTAT_NORMAL);
1643             if (code) {
1644                 printf("bos: failed to restart '%s' (%s)\n", serviceName, em(code));
1645                 return code;
1646             }
1647         }
1648         if (rc)
1649             return rc;
1650     } else if (!as->parms[2].items) {
1651         if (!as->parms[1].items) {
1652             printf
1653                 ("bos: must specify -all switch to salvage all partitions.\n");
1654             return -1;
1655         }
1656         if (volutil_GetPartitionID(as->parms[1].items->data) < 0) {
1657             /* can't parse volume ID, so complain before shutting down
1658              * file server.
1659              */
1660             printf("bos: can't interpret %s as partition ID.\n",
1661                    as->parms[1].items->data);
1662             return -1;
1663         }
1664         curGoal = GetServerGoal(tconn, serviceName);
1665         /* salvage a whole partition (specified by parms[1]) */
1666         if (curGoal == BSTAT_NORMAL) {
1667             printf("bos: shutting down '%s'.\n", serviceName);
1668             code = BOZO_SetTStatus(tconn, serviceName, BSTAT_SHUTDOWN);
1669             if (code) {
1670                 printf("bos: can't stop '%s' (%s)\n", serviceName, em(code));
1671                 return code;
1672             }
1673             code = BOZO_WaitAll(tconn); /* wait for shutdown to complete */
1674             if (code)
1675                 printf
1676                     ("bos: failed to wait for file server shutdown, continuing.\n");
1677         }
1678         /* now do the salvage operation */
1679         printf("Starting salvage.\n");
1680         rc = DoSalvage(tconn, as->parms[1].items->data, NULL, outName,
1681                        showlog, parallel, tmpDir, orphans, dafs, &mrafsParm);
1682         if (curGoal == BSTAT_NORMAL) {
1683             printf("bos: restarting '%s'.\n", serviceName);
1684             code = BOZO_SetTStatus(tconn, serviceName, BSTAT_NORMAL);
1685             if (code) {
1686                 printf("bos: failed to restart '%s' (%s)\n", serviceName, em(code));
1687                 return code;
1688             }
1689         }
1690         if (rc)
1691             return rc;
1692     } else {
1693         /* salvage individual volume (don't shutdown fs first), just use
1694          * single-shot cron bnode.  Must leave server running when using this
1695          * option, since salvager will ask file server for the volume */
1696         char *tmpname;
1697         afs_int32 err;
1698         const char *confdir;
1699         int localauth;
1700
1701         if (as->parms[ADDPARMOFFSET].items)
1702             tmpname = as->parms[ADDPARMOFFSET].items->data;
1703         else
1704             tmpname = NULL;
1705
1706         localauth = (as->parms[ADDPARMOFFSET + 2].items != 0);
1707         confdir =
1708             (localauth ? AFSDIR_SERVER_ETC_DIRPATH :
1709              AFSDIR_CLIENT_ETC_DIRPATH);
1710         code = vsu_ClientInit( /* noauth */ 1, confdir, tmpname,
1711                               /* server auth */ 0, &cstruct, (int (*)())0);
1712         if (code == 0) {
1713             newID = vsu_GetVolumeID(as->parms[2].items->data, cstruct, &err);
1714             if (newID == 0) {
1715                 printf("bos: can't interpret %s as volume name or ID\n",
1716                        as->parms[2].items->data);
1717                 return -1;
1718             }
1719             sprintf(tname, "%u", newID);
1720         } else {
1721             printf
1722                 ("bos: can't initialize volume system client (code %d), trying anyway.\n",
1723                  code);
1724             strncpy(tname, as->parms[2].items->data, sizeof(tname));
1725         }
1726         if (volutil_GetPartitionID(as->parms[1].items->data) < 0) {
1727             /* can't parse volume ID, so complain before shutting down
1728              * file server.
1729              */
1730             printf("bos: can't interpret %s as partition ID.\n",
1731                    as->parms[1].items->data);
1732             return -1;
1733         }
1734         printf("Starting salvage.\n");
1735         rc = DoSalvage(tconn, as->parms[1].items->data, tname, outName,
1736                        showlog, parallel, tmpDir, orphans, dafs, &mrafsParm);
1737         if (rc)
1738             return rc;
1739     }
1740     return 0;
1741 }
1742
1743 static int
1744 IStatServer(register struct cmd_syndesc *as, int int32p)
1745 {
1746     register struct rx_connection *tconn;
1747     register struct cmd_item *ti;
1748     int firstTime = 1;
1749
1750     tconn = GetConn(as, 0);
1751     for (ti = as->parms[1].items; ti; ti = ti->next) {
1752         DoStat(ti->data, tconn, int32p, firstTime);
1753         firstTime = 0;
1754     }
1755     return 0;
1756 }
1757
1758 static int
1759 DoStat(IN char *aname, 
1760        IN register struct rx_connection *aconn, 
1761        IN int aint32p, 
1762        IN int firstTime)        /* true iff first instance in cmd */
1763 {
1764     afs_int32 temp;
1765     char buffer[500];
1766     register afs_int32 code;
1767     register afs_int32 i;
1768     struct bozo_status istatus;
1769     char *tp;
1770     char *is1, *is2, *is3, *is4;        /* instance strings */
1771
1772     tp = buffer;
1773     code = BOZO_GetInstanceInfo(aconn, aname, &tp, &istatus);
1774     if (code) {
1775         printf("bos: failed to get instance info for '%s' (%s)\n", aname,
1776                em(code));
1777         return -1;
1778     }
1779     if (firstTime && aint32p && (istatus.flags & BOZO_BADDIRACCESS))
1780         printf
1781             ("Bosserver reports inappropriate access on server directories\n");
1782     printf("Instance %s, ", aname);
1783     if (aint32p)
1784         printf("(type is %s) ", buffer);
1785     if (istatus.fileGoal == istatus.goal) {
1786         if (!istatus.goal)
1787             printf("disabled, ");
1788     } else {
1789         if (istatus.fileGoal)
1790             printf("temporarily disabled, ");
1791         else
1792             printf("temporarily enabled, ");
1793     }
1794
1795     if (istatus.flags & BOZO_ERRORSTOP)
1796         printf("stopped for too many errors, ");
1797     if (istatus.flags & BOZO_HASCORE)
1798         printf("has core file, ");
1799
1800     tp = buffer;
1801     code = BOZO_GetStatus(aconn, aname, &temp, &tp);
1802     if (code)
1803         printf("bos: failed to get status for instance '%s' (%s)\n", aname,
1804                em(code));
1805     else {
1806         printf("currently ");
1807         if (temp == BSTAT_NORMAL)
1808             printf("running normally.\n");
1809         else if (temp == BSTAT_SHUTDOWN)
1810             printf("shutdown.\n");
1811         else if (temp == BSTAT_STARTINGUP)
1812             printf("starting up.\n");
1813         else if (temp == BSTAT_SHUTTINGDOWN)
1814             printf("shutting down.\n");
1815         if (buffer[0] != 0) {
1816             printf("    Auxiliary status is: %s.\n", buffer);
1817         }
1818     }
1819
1820     /* are we done yet? */
1821     if (!aint32p)
1822         return 0;
1823
1824     if (istatus.procStartTime)
1825         printf("    Process last started at %s (%d proc starts)\n",
1826                DateOf(istatus.procStartTime), istatus.procStarts);
1827     if (istatus.lastAnyExit) {
1828         printf("    Last exit at %s\n", DateOf(istatus.lastAnyExit));
1829     }
1830     if (istatus.lastErrorExit) {
1831         is1 = is2 = is3 = is4 = NULL;
1832         printf("    Last error exit at %s, ", DateOf(istatus.lastErrorExit));
1833         code = BOZO_GetInstanceStrings(aconn, aname, &is1, &is2, &is3, &is4);
1834         /* don't complain about failing call, since could simply mean
1835          * interface mismatch.
1836          */
1837         if (code == 0) {
1838             if (*is1 != 0) {
1839                 /* non-null instance string */
1840                 printf("by %s, ", is1);
1841             }
1842             free(is1);
1843             free(is2);
1844             free(is3);
1845             free(is4);
1846         }
1847         if (istatus.errorSignal) {
1848             if (istatus.errorSignal == SIGTERM)
1849                 printf("due to shutdown request\n");
1850             else
1851                 printf("due to signal %d\n", istatus.errorSignal);
1852         } else
1853             printf("by exiting with code %d\n", istatus.errorCode);
1854     }
1855
1856     if (aint32p > 1) {
1857         /* try to display all the parms */
1858         for (i = 0;; i++) {
1859             tp = buffer;
1860             code = BOZO_GetInstanceParm(aconn, aname, i, &tp);
1861             if (code)
1862                 break;
1863             printf("    Command %d is '%s'\n", i + 1, buffer);
1864         }
1865         tp = buffer;
1866         code = BOZO_GetInstanceParm(aconn, aname, 999, &tp);
1867         if (!code) {
1868             /* Any type of failure is treated as not having a notifier program */
1869             printf("    Notifier  is '%s'\n", buffer);
1870         }
1871         printf("\n");
1872     }
1873     return 0;
1874 }
1875
1876 #ifdef BOS_RESTRICTED_MODE
1877 static int
1878 GetRestrict(struct cmd_syndesc *as, void *arock)
1879 {
1880     register struct rx_connection *tconn;
1881     afs_int32 code, val;
1882
1883     tconn = GetConn(as, 0);
1884     code = BOZO_GetRestrictedMode(tconn, &val);
1885     if (code)
1886         printf("bos: failed to get restricted mode (%s)\n", em(code));
1887     else
1888         printf("Restricted mode is %s\n", val ? "on" : "off");
1889
1890     return 0;
1891 }
1892
1893 static int
1894 SetRestrict(struct cmd_syndesc *as, void *arock)
1895 {
1896     register struct rx_connection *tconn;
1897     afs_int32 code, val;
1898
1899     tconn = GetConn(as, 0);
1900     util_GetInt32(as->parms[1].items->data, &val);
1901     code = BOZO_SetRestrictedMode(tconn, val);
1902     if (code)
1903         printf("bos: failed to set restricted mode (%s)\n", em(code));
1904     return 0;
1905 }
1906 #endif
1907
1908 static void
1909 add_std_args(register struct cmd_syndesc *ts)
1910 {
1911     cmd_Seek(ts, ADDPARMOFFSET);
1912     /* + 0 */ cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
1913     /* + 1 */ cmd_AddParm(ts, "-noauth", CMD_FLAG, CMD_OPTIONAL,
1914                           "don't authenticate");
1915     /* + 2 */ cmd_AddParm(ts, "-localauth", CMD_FLAG, CMD_OPTIONAL,
1916                           "create tickets from KeyFile");
1917 }
1918
1919 #include "AFS_component_version_number.c"
1920
1921 int
1922 main(int argc, char **argv)
1923 {
1924     register afs_int32 code;
1925     register struct cmd_syndesc *ts;
1926     extern int afsconf_SawCell;
1927
1928 #ifdef  AFS_AIX32_ENV
1929     /*
1930      * The following signal action for AIX is necessary so that in case of a 
1931      * crash (i.e. core is generated) we can include the user's data section 
1932      * in the core dump. Unfortunately, by default, only a partial core is
1933      * generated which, in many cases, isn't too useful.
1934      */
1935     struct sigaction nsa;
1936
1937     sigemptyset(&nsa.sa_mask);
1938     nsa.sa_handler = SIG_DFL;
1939     nsa.sa_flags = SA_FULLDUMP;
1940     sigaction(SIGSEGV, &nsa, NULL);
1941     sigaction(SIGABRT, &nsa, NULL);
1942 #endif
1943
1944     /* start up rx */
1945     code = rx_Init(0);
1946     if (code) {
1947         printf("bos: could not initialize rx (%s)\n", em(code));
1948         exit(1);
1949     }
1950
1951     /* To resolve a AFSCELL environment "Note: ..." problem: Because bos calls ka_Init (why?) before any
1952      * checkup on the existance of a "-cell" option on the particular bos command we don't print the
1953      * message if a cell is passed in. Luckily the rest of the programs don't call these adhoc routines
1954      * and things work fine. Note that if the "-cell" isn't passed then we're still ok since later on
1955      * the proper routine (afsconf_GetCellInfo) is going to be called to do the right thing.
1956      */
1957     afsconf_SawCell = 1;        /* Means don't print warning if AFSCELL is set */
1958     ka_Init(0);
1959     afsconf_SawCell = 0;        /* Reset it */
1960     /* don't check error code, since fails sometimes when we're setting up a
1961      * system */
1962     initialize_CMD_error_table();
1963     initialize_BZ_error_table();
1964
1965     ts = cmd_CreateSyntax("start", StartServer, NULL, "start running a server");
1966     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1967     cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
1968     add_std_args(ts);
1969
1970     ts = cmd_CreateSyntax("stop", StopServer, NULL, "halt a server instance");
1971     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1972     cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
1973     cmd_Seek(ts, 8);
1974     cmd_AddParm(ts, "-wait", CMD_FLAG, CMD_OPTIONAL,
1975                 "wait for process to stop");
1976     add_std_args(ts);
1977
1978     ts = cmd_CreateSyntax("status", StatServer, NULL,
1979                           "show server instance status");
1980     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1981     cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL,
1982                 "server process name");
1983     cmd_AddParm(ts, "-long", CMD_FLAG, CMD_OPTIONAL, "long status");
1984     add_std_args(ts);
1985
1986     ts = cmd_CreateSyntax("shutdown", Shutdown, NULL, "shutdown all processes");
1987     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1988     cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
1989     cmd_Seek(ts, 8);
1990     cmd_AddParm(ts, "-wait", CMD_FLAG, CMD_OPTIONAL,
1991                 "wait for process to stop");
1992     add_std_args(ts);
1993
1994     ts = cmd_CreateSyntax("startup", Startup, NULL, "start all processes");
1995     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
1996     cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
1997     add_std_args(ts);
1998
1999     ts = cmd_CreateSyntax("restart", Restart, NULL, "restart processes");
2000     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2001     cmd_AddParm(ts, "-instance", CMD_LIST, CMD_OPTIONAL, "instances");
2002     cmd_AddParm(ts, "-bosserver", CMD_FLAG, CMD_OPTIONAL,
2003                 "restart bosserver");
2004     cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "restart all processes");
2005     add_std_args(ts);
2006
2007 #ifndef OPBOS
2008
2009     ts = cmd_CreateSyntax("create", CreateServer, NULL,
2010                           "create a new server instance");
2011     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2012     cmd_AddParm(ts, "-instance", CMD_SINGLE, 0, "server process name");
2013     cmd_AddParm(ts, "-type", CMD_SINGLE, 0, "server type");
2014     cmd_AddParm(ts, "-cmd", CMD_LIST, 0, "command lines");
2015     cmd_AddParm(ts, "-notifier", CMD_SINGLE, CMD_OPTIONAL,
2016                 "Notifier program");
2017     add_std_args(ts);
2018
2019     ts = cmd_CreateSyntax("delete", DeleteServer, NULL,
2020                           "delete a server instance");
2021     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2022     cmd_AddParm(ts, "-instance", CMD_LIST, 0, "server process name");
2023     add_std_args(ts);
2024
2025     ts = cmd_CreateSyntax("adduser", AddSUser, NULL,
2026                           "add users to super-user list");
2027     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2028     cmd_AddParm(ts, "-user", CMD_LIST, 0, "user names");
2029     add_std_args(ts);
2030
2031     ts = cmd_CreateSyntax("removeuser", RemoveSUser, NULL,
2032                           "remove users from super-user list");
2033     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2034     cmd_AddParm(ts, "-user", CMD_LIST, 0, "user names");
2035     add_std_args(ts);
2036
2037     ts = cmd_CreateSyntax("listusers", ListSUsers, NULL, "list super-users");
2038     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2039     add_std_args(ts);
2040
2041     ts = cmd_CreateSyntax("addkey", AddKey, NULL,
2042                           "add keys to key dbase (kvno 999 is bcrypt)");
2043     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2044     cmd_AddParm(ts, "-key", CMD_SINGLE, CMD_OPTIONAL, "key");
2045     cmd_AddParm(ts, "-kvno", CMD_SINGLE, 0, "key version number");
2046     add_std_args(ts);
2047
2048     ts = cmd_CreateSyntax("removekey", RemoveKey, NULL,
2049                           "remove keys from key dbase");
2050     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2051     cmd_AddParm(ts, "-kvno", CMD_LIST, 0, "key version number");
2052     add_std_args(ts);
2053
2054     ts = cmd_CreateSyntax("listkeys", ListKeys, NULL, "list keys");
2055     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2056     cmd_AddParm(ts, "-showkey", CMD_FLAG, CMD_OPTIONAL,
2057                 "show the actual key rather than the checksum");
2058     add_std_args(ts);
2059
2060     ts = cmd_CreateSyntax("listhosts", ListHosts, NULL, "get cell host list");
2061     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2062     add_std_args(ts);
2063     cmd_CreateAlias(ts, "getcell");
2064
2065     ts = cmd_CreateSyntax("setcellname", SetCellName, NULL, "set cell name");
2066     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2067     cmd_AddParm(ts, "-name", CMD_SINGLE, 0, "cell name");
2068     add_std_args(ts);
2069
2070     ts = cmd_CreateSyntax("addhost", AddHost, NULL, "add host to cell dbase");
2071     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2072     cmd_AddParm(ts, "-host", CMD_LIST, 0, "host name");
2073     cmd_AddParm(ts, "-clone", CMD_FLAG, CMD_OPTIONAL, "vote doesn't count");
2074     add_std_args(ts);
2075
2076     ts = cmd_CreateSyntax("removehost", RemoveHost, NULL,
2077                           "remove host from cell dbase");
2078     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2079     cmd_AddParm(ts, "-host", CMD_LIST, 0, "host name");
2080     add_std_args(ts);
2081
2082     ts = cmd_CreateSyntax("setauth", SetAuth, NULL,
2083                           "set authentication required flag");
2084     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2085     cmd_AddParm(ts, "-authrequired", CMD_SINGLE, 0,
2086                 "on or off: authentication required for admin requests");
2087     add_std_args(ts);
2088
2089     ts = cmd_CreateSyntax("install", Install, NULL, "install program");
2090     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2091     cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to install");
2092     cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
2093     add_std_args(ts);
2094
2095     ts = cmd_CreateSyntax("uninstall", UnInstall, NULL, "uninstall program");
2096     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2097     cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to uninstall");
2098     cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
2099     add_std_args(ts);
2100
2101     ts = cmd_CreateSyntax("getlog", GetLogCmd, NULL, "examine log file");
2102     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2103     cmd_AddParm(ts, "-file", CMD_SINGLE, 0, "log file to examine");
2104     add_std_args(ts);
2105
2106     ts = cmd_CreateSyntax("getdate", GetDate, NULL, "get dates for programs");
2107     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2108     cmd_AddParm(ts, "-file", CMD_LIST, 0, "files to check");
2109     cmd_AddParm(ts, "-dir", CMD_SINGLE, CMD_OPTIONAL, "destination dir");
2110     add_std_args(ts);
2111
2112     ts = cmd_CreateSyntax("exec", Exec, NULL, "execute shell command on server");
2113     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2114     cmd_AddParm(ts, "-cmd", CMD_SINGLE, 0, "command to execute");
2115     add_std_args(ts);
2116
2117     ts = cmd_CreateSyntax("prune", Prune, NULL, "prune server files");
2118     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2119     cmd_AddParm(ts, "-bak", CMD_FLAG, CMD_OPTIONAL, "delete .BAK files");
2120     cmd_AddParm(ts, "-old", CMD_FLAG, CMD_OPTIONAL, "delete .OLD files");
2121     cmd_AddParm(ts, "-core", CMD_FLAG, CMD_OPTIONAL, "delete core files");
2122     cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "delete all junk files");
2123     add_std_args(ts);
2124
2125     ts = cmd_CreateSyntax("setrestart", SetRestartCmd, NULL,
2126                           "set restart times");
2127     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
2128     cmd_AddParm(ts, "-time", CMD_SINGLE, CMD_REQUIRED,
2129                 "time to restart server");
2130     cmd_AddParm(ts, "-general", CMD_FLAG, CMD_OPTIONAL,
2131                 "set general restart time");
2132     cmd_AddParm(ts, "-newbinary", CMD_FLAG, CMD_OPTIONAL,
2133                 "set new binary restart time");
2134     add_std_args(ts);
2135
2136     ts = cmd_CreateSyntax("getrestart", GetRestartCmd, NULL,
2137                           "get restart times");
2138     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
2139     add_std_args(ts);
2140
2141     ts = cmd_CreateSyntax("salvage", SalvageCmd, NULL,
2142                           "salvage partition or volumes");
2143     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2144     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_OPTIONAL,
2145                 "salvage partition");
2146     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_OPTIONAL,
2147                 "salvage volume number or volume name");
2148     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL,
2149                 "salvage log output file");
2150     cmd_AddParm(ts, "-all", CMD_FLAG, CMD_OPTIONAL, "salvage whole server");
2151     cmd_AddParm(ts, "-showlog", CMD_FLAG, CMD_OPTIONAL,
2152                 "display salvage log");
2153     cmd_AddParm(ts, "-parallel", CMD_SINGLE, CMD_OPTIONAL,
2154                 "# of max parallel partition salvaging");
2155     cmd_AddParm(ts, "-tmpdir", CMD_SINGLE, CMD_OPTIONAL,
2156                 "directory to place tmp files");
2157     cmd_AddParm(ts, "-orphans", CMD_SINGLE, CMD_OPTIONAL,
2158                 "ignore | remove | attach");
2159     cmd_AddParm(ts, "-forceDAFS", CMD_FLAG, CMD_OPTIONAL,
2160                 "(DAFS) force salvage of demand attach fileserver");
2161     cmd_AddParm(ts, "-debug", CMD_FLAG, CMD_OPTIONAL,
2162                 "(MR-AFS) Run in Debugging mode");
2163     cmd_AddParm(ts, "-nowrite", CMD_FLAG, CMD_OPTIONAL,
2164                 "(MR-AFS) Run readonly/test mode");
2165     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
2166                 "(MR-AFS) Force full salvaging");
2167     cmd_AddParm(ts, "-oktozap", CMD_FLAG, CMD_OPTIONAL,
2168                 "(MR-AFS) Give permission to destroy bogus file residencies/volumes - debugging flag");
2169     cmd_AddParm(ts, "-rootfiles", CMD_FLAG, CMD_OPTIONAL,
2170                 "(MR-AFS) Show files owned by root - debugging flag");
2171     cmd_AddParm(ts, "-salvagedirs", CMD_FLAG, CMD_OPTIONAL,
2172                 "(MR-AFS) Force rebuild/salvage of all directories");
2173     cmd_AddParm(ts, "-blockreads", CMD_FLAG, CMD_OPTIONAL,
2174                 "(MR-AFS) Read smaller blocks to handle IO/bad blocks");
2175     cmd_AddParm(ts, "-ListResidencies", CMD_FLAG, CMD_OPTIONAL,
2176                 "(MR-AFS) Just list affected file residencies - debugging flag");
2177     cmd_AddParm(ts, "-SalvageRemote", CMD_FLAG, CMD_OPTIONAL,
2178                 "(MR-AFS) Salvage storage systems that are not directly attached");
2179     cmd_AddParm(ts, "-SalvageArchival", CMD_FLAG, CMD_OPTIONAL,
2180                 "(MR-AFS) Salvage HSM storage systems");
2181     cmd_AddParm(ts, "-IgnoreCheck", CMD_FLAG, CMD_OPTIONAL,
2182                 "(MR-AFS) Don't perform VLDB safety check when deleting unreferenced files.  Only a good idea in single server cell.");
2183     cmd_AddParm(ts, "-ForceOnLine", CMD_FLAG, CMD_OPTIONAL,
2184                 "(MR-AFS) Force the volume to come online, even if it hasn't salvaged cleanly.");
2185     cmd_AddParm(ts, "-UseRootDirACL", CMD_FLAG, CMD_OPTIONAL,
2186                 "(MR-AFS) Use the root directory ACL for lost+found directory if it is created.");
2187     cmd_AddParm(ts, "-TraceBadLinkCounts", CMD_FLAG, CMD_OPTIONAL,
2188                 "(MR-AFS) Print out lines about volume reference count changes.");
2189     cmd_AddParm(ts, "-DontAskFS", CMD_FLAG, CMD_OPTIONAL,
2190                 "(MR-AFS) Don't ask fileserver to take volume offline.  THIS IS VERY DANGEROUS.");
2191     cmd_AddParm(ts, "-LogLevel", CMD_SINGLE, CMD_OPTIONAL,
2192                 "(MR-AFS) log level");
2193     cmd_AddParm(ts, "-rxdebug", CMD_FLAG, CMD_OPTIONAL,
2194                 "(MR-AFS) Write out rx debug information.");
2195     cmd_AddParm(ts, "-Residencies", CMD_SINGLE, CMD_OPTIONAL,
2196                 "(MR-AFS) Numeric mask of residencies to be included in the salvage.  Do not use with -SalvageRemote or -SalvageArchival");
2197     add_std_args(ts);
2198
2199     ts = cmd_CreateSyntax("blockscanner", BlockScannerCmd, NULL,
2200                           "block scanner daemon from making migration requests");
2201     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
2202     add_std_args(ts);
2203
2204     ts = cmd_CreateSyntax("unblockscanner", UnBlockScannerCmd, NULL,
2205                           "allow scanner daemon to make migration requests again");
2206     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
2207     add_std_args(ts);
2208
2209 #ifdef BOS_RESTRICTED_MODE
2210     ts = cmd_CreateSyntax("getrestricted", GetRestrict, NULL,
2211                           "get restrict mode");
2212     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2213     add_std_args(ts);
2214
2215     ts = cmd_CreateSyntax("setrestricted", SetRestrict, NULL,
2216                           "set restrict mode");
2217     cmd_AddParm(ts, "-server", CMD_SINGLE, 0, "machine name");
2218     cmd_AddParm(ts, "-mode", CMD_SINGLE, 0, "mode to set");
2219     add_std_args(ts);
2220 #endif
2221 #endif
2222
2223     code = cmd_Dispatch(argc, argv);
2224     rx_Finalize();
2225     exit(code);
2226 }