Remove internal vldbClientInit prototype
[openafs.git] / src / bucoord / main.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 <sys/types.h>
16 #include <sys/stat.h>
17
18 #ifdef  AFS_AIX32_ENV
19 #include <signal.h>
20 #endif
21 #ifdef AFS_NT40_ENV
22 #include <winsock2.h>
23 #else
24 #include <sys/socket.h>
25 #include <netinet/in.h>
26 #include <netdb.h>
27 #endif
28
29 #include <errno.h>
30 #include <afs/cmd.h>
31 #include <rx/rx.h>
32 #include <rx/rx_globals.h>
33 #include <lwp.h>
34 #include <afs/bubasics.h>
35 #include <fcntl.h>
36 #include <afs/afsutil.h>
37 #include <afs/auth.h>
38 #include <afs/cellconfig.h>
39 #include <afs/keys.h>
40 #include <ubik.h>
41 #include <afs/cmd.h>
42 #include <rx/rxkad.h>
43 #include <afs/volser.h>         /*VLDB_MAXSERVERS */
44 #include <afs/com_err.h>
45 #include <lock.h>
46 #include <afs/budb.h>
47 #include <afs/kautils.h>
48 #include <afs/vlserver.h>
49 #include <afs/butm.h>
50 #include <afs/butx.h>
51 #include <afs/tcdata.h>
52
53 #include "bc.h"                 /*Backup Coordinator structs and defs */
54 #include "bucoord_internal.h"
55 #include "bucoord_prototypes.h"
56
57 int localauth, interact;
58 char tcell[64];
59
60 /*
61  * Global configuration information for the Backup Coordinator.
62  */
63 struct bc_config *bc_globalConfig;      /*Ptr to global BC configuration info */
64
65 struct ubik_client *cstruct;    /* Ptr to Ubik client structure */
66 struct ktc_token ttoken;        /* The token */
67
68 static const char *DefaultConfDir;      /*Default backup config directory */
69 static int bcInit = 0;          /* backupInit called yet ? */
70 char *whoami = "backup";
71
72 /* dummy routine for the audit work.  It should do nothing since audits */
73 /* occur at the server level and bos is not a server. */
74 int
75 osi_audit(void)
76 {
77     return 0;
78 }
79
80 /*
81  * Initialize all the error tables that may be used by com_err
82  * in this module.
83  */
84 void
85 InitErrTabs(void)
86 {
87     initialize_ACFG_error_table();
88     initialize_KA_error_table();
89     initialize_RXK_error_table();
90     initialize_CMD_error_table();
91     initialize_VL_error_table();
92     initialize_BUTM_error_table();
93     initialize_VOLS_error_table();
94     initialize_BUTC_error_table();
95     initialize_BUTX_error_table();
96     initialize_BUDB_error_table();
97     initialize_BUCD_error_table();
98     initialize_KTC_error_table();
99 }
100
101 /* 
102  * got to account for the errors which are volume related but 
103  * not dealt with by standard errno and com_err stuff.
104  */
105 void
106 bc_HandleMisc(afs_int32 code)
107 {
108     if (((code <= VMOVED) && (code >= VSALVAGE)) || (code < 0)) {
109         switch (code) {
110         case -1:
111             fprintf(STDERR, "Possible communication failure\n");
112             break;
113         case VSALVAGE:
114             fprintf(STDERR, "Volume needs salvage\n");
115             break;
116         case VNOVNODE:
117             fprintf(STDERR, "Bad vnode number quoted\n");
118             break;
119         case VNOVOL:
120             fprintf(STDERR,
121                     "Volume not attached, does not exist, or not on line\n");
122             break;
123         case VVOLEXISTS:
124             fprintf(STDERR, "Volume already exists\n");
125             break;
126         case VNOSERVICE:
127             fprintf(STDERR, "Volume is not in service\n");
128             break;
129         case VOFFLINE:
130             fprintf(STDERR, "Volume is off line\n");
131             break;
132         case VONLINE:
133             fprintf(STDERR, "Volume is already on line\n");
134             break;
135         case VDISKFULL:
136             fprintf(STDERR, "Partition is full\n");
137             break;
138         case VOVERQUOTA:
139             fprintf(STDERR, "Volume max quota exceeded\n");
140             break;
141         case VBUSY:
142             fprintf(STDERR, "Volume temporarily unavailable\n");
143             break;
144         case VMOVED:
145             fprintf(STDERR, "Volume has moved to another server\n");
146             break;
147         default:
148             break;
149         }
150     }
151     return;
152 }
153
154 /* Return true if line is all whitespace */
155 static int
156 LineIsBlank(char *aline)
157 {
158     register int tc;
159
160     while ((tc = *aline++))
161         if ((tc != ' ') && (tc != '\t') && (tc != '\n'))
162             return (0);
163
164     return (1);
165 }
166
167
168 /* bc_InitTextConfig
169  *      initialize configuration information that is stored as text blocks
170  */
171
172 afs_int32
173 bc_InitTextConfig(void)
174 {
175     udbClientTextP ctPtr;
176     int i;
177
178     extern struct bc_config *bc_globalConfig;
179
180     mkdir(DefaultConfDir, 777); /* temporary */
181
182     /* initialize the client text structures */
183     ctPtr = &bc_globalConfig->configText[0];
184
185     for (i = 0; i < TB_NUM; i++) {
186         memset(ctPtr, 0, sizeof(*ctPtr));
187         ctPtr->textType = i;
188         ctPtr->textVersion = -1;
189         ctPtr++;
190     }
191
192     return (0);
193 }
194
195 /*----------------------------------------------------------------------------
196  * backupInit
197  *
198  * Description:
199  *      Routine that is called when the backup coordinator is invoked, responsible for
200  *      basic initialization and some command line parsing.
201  *
202  * Returns:
203  *      Zero (but may exit the entire program on error!)
204  *
205  * Environment:
206  *      Nothing interesting.
207  *
208  * Side Effects:
209  *      Initializes this program.
210  *----------------------------------------------------------------------------
211  */
212
213 static int
214 backupInit(void)
215 {
216     register afs_int32 code;
217     static int initd = 0;       /* ever called? */
218     PROCESS watcherPid;
219     PROCESS pid;                /* LWP process ID */
220
221     /* Initialization */
222     initialize_CMD_error_table();
223
224     /* don't run more than once */
225     if (initd) {
226         afs_com_err(whoami, 0, "Backup already initialized.");
227         return 0;
228     }
229     initd = 1;
230
231     code = bc_InitConfig((char *)DefaultConfDir);
232     if (code) {
233         afs_com_err(whoami, code,
234                 "Can't initialize from config files in directory '%s'",
235                 DefaultConfDir);
236         return (code);
237     }
238
239     /*
240      * Set up Rx.
241      */
242     code = LWP_InitializeProcessSupport(LWP_NORMAL_PRIORITY, &pid);
243     if (code) {
244         afs_com_err(whoami, code, "; Can't initialize LWP");
245         return (code);
246     }
247
248     code = rx_Init(htons(0));
249     if (code) {
250         afs_com_err(whoami, code, "; Can't initialize Rx");
251         return (code);
252     }
253
254     rx_SetRxDeadTime(60);
255
256     /* VLDB initialization */
257     code = vldbClientInit(0, localauth, tcell, &cstruct, &ttoken);
258     if (code)
259         return (code);
260
261     /* Backup database initialization */
262     code = udbClientInit(0, localauth, tcell);
263     if (code)
264         return (code);
265
266     /* setup status monitoring thread */
267     initStatus();
268     code =
269         LWP_CreateProcess(statusWatcher, 20480, LWP_NORMAL_PRIORITY,
270                           (void *)2, "statusWatcher", &watcherPid);
271     if (code) {
272         afs_com_err(whoami, code, "; Can't create status monitor task");
273         return (code);
274     }
275
276     return (0);
277 }
278
279 /*----------------------------------------------------------------------------
280  * MyBeforeProc
281  *
282  * Description:
283  *      Make sure we mark down when we need to exit the Backup Coordinator.
284  *      Specifically, we don't want to continue when our help and apropos
285  *      routines are called from the command line.
286  *
287  * Arguments:
288  *      as : Ptr to the command syntax descriptor.
289  *
290  * Returns:
291  *      0.
292  *
293  * Environment:
294  *      This routine is called right before each of the Backup Coordinator
295  *      opcode routines are invoked.
296  *
297  *----------------------------------------------------------------------------
298  */
299
300 static int
301 MyBeforeProc(register struct cmd_syndesc *as, void *arock)
302 {
303     afs_int32 code;
304
305     /* Handling the command line opcode */
306     if (!bcInit) {
307         localauth = ((as && as->parms[14].items) ? 1 : 0);
308         if (as && as->parms[15].items)
309             strcpy(tcell, as->parms[15].items->data);
310         else
311             tcell[0] = '\0';
312
313         code = backupInit();
314         if (code) {
315             afs_com_err(whoami, code, "; Can't initialize backup");
316             exit(1);
317         }
318
319         /* Get initial information from the database */
320         code = bc_InitTextConfig();
321         if (code) {
322             afs_com_err(whoami, code,
323                     "; Can't obtain configuration text from backup database");
324             exit(1);
325         }
326     }
327     bcInit = 1;
328
329     return 0;
330 }
331
332
333 #define MAXV    100
334
335 #include "AFS_component_version_number.c"
336
337 #define MAXRECURSION 20
338 extern int dontExecute;         /* declared in commands.c */
339 extern char *loadFile;          /* declared in commands.c */
340 char lineBuffer[1024];          /* Line typed in by user or read from load file */
341
342 /* 
343  * This will dispatch a command.  It holds a recursive loop for the
344  * "dump -file" option. This option reads backup commands from a file.
345  *
346  * Cannot put this code on other side of cmd_Dispatch call (in
347  * commands.c) because when make a dispatch call when in a dispatch
348  * call, environment is mucked up.
349  * 
350  * To avoid multiple processes stepping on each other in the dispatch code,
351  * put a lock around it so only 1 process gets in at a time.
352  */
353
354 struct Lock dispatchLock;       /* lock on the Dispatch call */
355 #define lock_Dispatch()     ObtainWriteLock(&dispatchLock)
356 #define unlock_Dispatch()   ReleaseWriteLock(&dispatchLock)
357
358 afs_int32
359 doDispatch(afs_int32 targc,
360            char *targv[MAXV], 
361            afs_int32 dispatchCount) /* to prevent infinite recursion */
362 {
363     char *sargv[MAXV];
364     afs_int32 sargc;
365     afs_int32 code, c;
366     FILE *fd;
367     int i;
368     int lineNumber;
369     int noExecute;              /* local capy of global variable */
370     char *internalLoadFile;
371
372     lock_Dispatch();
373
374     loadFile = NULL;
375     code = cmd_Dispatch(targc, targv);
376     internalLoadFile = loadFile;
377
378     unlock_Dispatch();
379
380     if (internalLoadFile) {     /* Load a file in */
381         if (dispatchCount > MAXRECURSION) {     /* Beware recursive loops. */
382             afs_com_err(whoami, 0, "Potential recursion: will not load file %s",
383                     internalLoadFile);
384             code = -1;
385             goto done;
386         }
387
388         fd = fopen(internalLoadFile, "r");      /* Open the load file */
389         if (!fd) {
390             afs_com_err(whoami, errno, "; Cannot open file %s", internalLoadFile);
391             code = -1;
392             goto done;
393         }
394
395         noExecute = dontExecute;
396         if (noExecute)
397             printf("Would have executed the following commands:\n");
398
399         lineNumber = 0;
400         while (fgets(lineBuffer, sizeof(lineBuffer) - 1, fd)) { /* Get commands from file */
401             lineNumber++;
402
403             i = strlen(lineBuffer) - 1;
404             if (lineBuffer[i] == '\n')  /* Drop return at end of line */
405                 lineBuffer[i] = '\0';
406
407             if (noExecute)
408                 printf("        %s\n", lineBuffer);     /* echo */
409             else
410                 printf("------> %s\n", lineBuffer);     /* echo */
411
412             if (!LineIsBlank(lineBuffer) &&     /* Skip if blank line */
413                 (lineBuffer[0] != '#') &&       /*      or comment    */
414                 (!noExecute)) { /*      or no execute */
415                 c = cmd_ParseLine(lineBuffer, sargv, &sargc, MAXV);
416                 if (c) {
417                     afs_com_err(whoami, c, "; Can't parse line");
418                 } else {
419                     doDispatch(sargc, sargv, dispatchCount + 1);        /* Recursive - ignore error */
420                     cmd_FreeArgv(sargv);        /* Free up arguments */
421                 }
422             }
423         }
424
425         fclose(fd);
426     }
427
428   done:
429     if (internalLoadFile)
430         free(internalLoadFile);
431     return (code);
432 }
433
434 int
435 bc_interactCmd(struct cmd_syndesc *as, void *arock)
436 {
437     interact = 1;
438     return 0;
439 }
440
441 static void
442 add_std_args(struct cmd_syndesc *ts)
443 {
444     cmd_Seek(ts, 14);
445     cmd_AddParm(ts, "-localauth", CMD_FLAG, CMD_OPTIONAL,
446                 "local authentication");
447     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
448 }
449
450 int
451 main(int argc, char **argv)
452 {                               /*main */
453     char *targv[MAXV];          /*Ptr to parsed argv stuff */
454     afs_int32 targc;            /*Num parsed arguments */
455     afs_int32 code;             /*Return code */
456     register struct cmd_syndesc *ts;    /*Ptr to parsed command line */
457     int i;
458
459
460 #ifdef  AFS_AIX32_ENV
461     /*
462      * The following signal action for AIX is necessary so that in case of a 
463      * crash (i.e. core is generated) we can include the user's data section 
464      * in the core dump. Unfortunately, by default, only a partial core is
465      * generated which, in many cases, isn't too useful.
466      */
467     struct sigaction nsa;
468
469     sigemptyset(&nsa.sa_mask);
470     nsa.sa_handler = SIG_DFL;
471     nsa.sa_flags = SA_FULLDUMP;
472     sigaction(SIGSEGV, &nsa, NULL);
473 #endif
474     Lock_Init(&dispatchLock);
475     InitErrTabs();              /* init all the error tables which may be used */
476
477     /* setup the default backup dir */
478     DefaultConfDir = AFSDIR_SERVER_BACKUP_DIRPATH;
479     /* Get early warning if the command is interacive mode or not */
480     interact = (((argc < 2) || (argv[1][0] == '-')) ? 1 : 0);
481
482     cmd_SetBeforeProc(MyBeforeProc, NULL);
483
484     ts = cmd_CreateSyntax("dump", bc_DumpCmd, NULL, "start dump");
485     cmd_AddParm(ts, "-volumeset", CMD_SINGLE, CMD_OPTIONAL,
486                 "volume set name");
487     cmd_AddParm(ts, "-dump", CMD_SINGLE, CMD_OPTIONAL, "dump level name");
488     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
489                 "TC port offset");
490     cmd_AddParm(ts, "-at", CMD_LIST, CMD_OPTIONAL, "Date/time to start dump");
491     cmd_AddParm(ts, "-append", CMD_FLAG, CMD_OPTIONAL,
492                 "append to existing dump set");
493     cmd_AddParm(ts, "-n", CMD_FLAG, CMD_OPTIONAL, "don't really execute it");
494     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "load file");
495     if (!interact)
496         add_std_args(ts);
497
498     ts = cmd_CreateSyntax("volrestore", bc_VolRestoreCmd, NULL,
499                           "restore volume");
500     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
501                 "destination machine");
502     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
503                 "destination partition");
504     cmd_AddParm(ts, "-volume", CMD_LIST, CMD_REQUIRED,
505                 "volume(s) to restore");
506     cmd_AddParm(ts, "-extension", CMD_SINGLE, CMD_OPTIONAL,
507                 "new volume name extension");
508     cmd_AddParm(ts, "-date", CMD_LIST, CMD_OPTIONAL,
509                 "date from which to restore");
510     cmd_AddParm(ts, "-portoffset", CMD_LIST, CMD_OPTIONAL, "TC port offsets");
511     cmd_AddParm(ts, "-n", CMD_FLAG, CMD_OPTIONAL, "don't really execute it");
512     cmd_AddParm(ts, "-usedump", CMD_SINGLE, CMD_OPTIONAL,
513                 "specify the dumpID to restore from");
514     if (!interact)
515         add_std_args(ts);
516
517     ts = cmd_CreateSyntax("diskrestore", bc_DiskRestoreCmd, NULL,
518                           "restore partition");
519     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED,
520                 "machine to restore");
521     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED,
522                 "partition to restore");
523     cmd_AddParm(ts, "-portoffset", CMD_LIST, CMD_OPTIONAL, "TC port offset");
524     cmd_Seek(ts, 8);
525     cmd_AddParm(ts, "-newserver", CMD_SINGLE, CMD_OPTIONAL,
526                 "destination machine");
527     cmd_AddParm(ts, "-newpartition", CMD_SINGLE, CMD_OPTIONAL,
528                 "destination partition");
529     cmd_AddParm(ts, "-extension", CMD_SINGLE, CMD_OPTIONAL,
530                 "new volume name extension");
531     cmd_AddParm(ts, "-n", CMD_FLAG, CMD_OPTIONAL, "don't really execute it");
532     if (!interact)
533         add_std_args(ts);
534
535     ts = cmd_CreateSyntax("quit", bc_QuitCmd, NULL, "leave the program");
536
537     ts = cmd_CreateSyntax("volsetrestore", bc_VolsetRestoreCmd, NULL,
538                           "restore a set of volumes");
539     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_OPTIONAL, "volume set name");
540     cmd_AddParm(ts, "-file", CMD_SINGLE, CMD_OPTIONAL, "file name");
541     cmd_AddParm(ts, "-portoffset", CMD_LIST, CMD_OPTIONAL, "TC port offset");
542     cmd_AddParm(ts, "-extension", CMD_SINGLE, CMD_OPTIONAL,
543                 "new volume name extension");
544     cmd_AddParm(ts, "-n", CMD_FLAG, CMD_OPTIONAL, "don't really execute it");
545     if (!interact)
546         add_std_args(ts);
547
548     ts = cmd_CreateSyntax("addhost", bc_AddHostCmd, NULL, "add host to config");
549     cmd_AddParm(ts, "-tapehost", CMD_SINGLE, CMD_REQUIRED,
550                 "tape machine name");
551     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
552                 "TC port offset");
553     if (!interact)
554         add_std_args(ts);
555
556     ts = cmd_CreateSyntax("delhost", bc_DeleteHostCmd, NULL,
557                           "delete host to config");
558     cmd_AddParm(ts, "-tapehost", CMD_SINGLE, CMD_REQUIRED,
559                 "tape machine name");
560     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
561                 "TC port offset");
562     if (!interact)
563         add_std_args(ts);
564
565     ts = cmd_CreateSyntax("listhosts", bc_ListHostsCmd, NULL,
566                           "list config hosts");
567     if (!interact)
568         add_std_args(ts);
569
570     ts = cmd_CreateSyntax("jobs", bc_JobsCmd, NULL, "list running jobs");
571
572     ts = cmd_CreateSyntax("kill", bc_KillCmd, NULL, "kill running job");
573     cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_REQUIRED,
574                 "job ID or dump set name");
575
576     ts = cmd_CreateSyntax("listvolsets", bc_ListVolSetCmd, NULL,
577                           "list volume sets");
578     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_OPTIONAL, "volume set name");
579     if (!interact)
580         add_std_args(ts);
581
582     ts = cmd_CreateSyntax("listdumps", bc_ListDumpScheduleCmd, NULL,
583                           "list dump schedules");
584     if (!interact)
585         add_std_args(ts);
586
587     ts = cmd_CreateSyntax("addvolset", bc_AddVolSetCmd, NULL,
588                           "create a new volume set");
589     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED, "volume set name");
590     cmd_AddParm(ts, "-temporary", CMD_FLAG, CMD_OPTIONAL,
591                 "temporary volume set");
592     if (!interact)
593         add_std_args(ts);
594
595     ts = cmd_CreateSyntax("status", bc_GetTapeStatusCmd, NULL,
596                           "get tape coordinator status");
597     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
598                 "TC port offset");
599     if (!interact)
600         add_std_args(ts);
601
602     ts = cmd_CreateSyntax("delvolset", bc_DeleteVolSetCmd, NULL,
603                           "delete a volume set");
604     cmd_AddParm(ts, "-name", CMD_LIST, CMD_REQUIRED, "volume set name");
605     if (!interact)
606         add_std_args(ts);
607
608     ts = cmd_CreateSyntax("addvolentry", bc_AddVolEntryCmd, NULL,
609                           "add a new volume entry");
610     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED, "volume set name");
611     cmd_AddParm(ts, "-server", CMD_SINGLE, CMD_REQUIRED, "machine name");
612     cmd_AddParm(ts, "-partition", CMD_SINGLE, CMD_REQUIRED, "partition name");
613     cmd_AddParm(ts, "-volumes", CMD_SINGLE, CMD_REQUIRED,
614                 "volume name (regular expression)");
615     if (!interact)
616         add_std_args(ts);
617
618     ts = cmd_CreateSyntax("delvolentry", bc_DeleteVolEntryCmd, NULL,
619                           "delete a volume set sub-entry");
620     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_REQUIRED, "volume set name");
621     cmd_AddParm(ts, "-entry", CMD_SINGLE, CMD_REQUIRED, "volume set index");
622     if (!interact)
623         add_std_args(ts);
624
625     ts = cmd_CreateSyntax("adddump", bc_AddDumpCmd, NULL, "add dump schedule");
626     cmd_AddParm(ts, "-dump", CMD_LIST, CMD_REQUIRED, "dump level name");
627     cmd_AddParm(ts, "-expires", CMD_LIST, CMD_OPTIONAL, "expiration date");
628     if (!interact)
629         add_std_args(ts);
630
631     ts = cmd_CreateSyntax("deldump", bc_DeleteDumpCmd, NULL,
632                           "delete dump schedule");
633     cmd_AddParm(ts, "-dump", CMD_SINGLE, CMD_REQUIRED, "dump level name");
634     if (!interact)
635         add_std_args(ts);
636
637     ts = cmd_CreateSyntax("labeltape", bc_LabelTapeCmd, NULL, "label a tape");
638     cmd_AddParm(ts, "-name", CMD_SINGLE, CMD_OPTIONAL,
639                 "AFS tape name, defaults to NULL");
640     cmd_AddParm(ts, "-size", CMD_SINGLE, CMD_OPTIONAL,
641                 "tape size in Kbytes, defaults to size in tapeconfig");
642     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
643                 "TC port offset");
644     cmd_AddParm(ts, "-pname", CMD_SINGLE, CMD_OPTIONAL,
645                 "permanent tape name");
646     if (!interact)
647         add_std_args(ts);
648
649     ts = cmd_CreateSyntax("readlabel", bc_ReadLabelCmd, NULL,
650                           "read the label on tape");
651     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
652                 "TC port offset");
653     if (!interact)
654         add_std_args(ts);
655
656     ts = cmd_CreateSyntax("scantape", bc_ScanDumpsCmd, NULL,
657                           "dump information recovery from tape");
658     cmd_AddParm(ts, "-dbadd", CMD_FLAG, CMD_OPTIONAL,
659                 "add information to the database");
660     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
661                 "TC port offset");
662     if (!interact)
663         add_std_args(ts);
664
665     ts = cmd_CreateSyntax("volinfo", bc_dblookupCmd, NULL,
666                           "query the backup database");
667     cmd_AddParm(ts, "-volume", CMD_SINGLE, CMD_REQUIRED, "volume name");
668     if (!interact)
669         add_std_args(ts);
670
671     ts = cmd_CreateSyntax("setexp", bc_SetExpCmd, NULL,
672                           "set/clear dump expiration dates");
673     cmd_AddParm(ts, "-dump", CMD_LIST, CMD_REQUIRED, "dump level name");
674     cmd_AddParm(ts, "-expires", CMD_LIST, CMD_OPTIONAL, "expiration date");
675     if (!interact)
676         add_std_args(ts);
677
678     ts = cmd_CreateSyntax("savedb", bc_saveDbCmd, NULL, "save backup database");
679     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
680                 "TC port offset");
681     cmd_AddParm(ts, "-archive", CMD_LIST, CMD_OPTIONAL, "date time");
682     if (!interact)
683         add_std_args(ts);
684
685     ts = cmd_CreateSyntax("restoredb", bc_restoreDbCmd, NULL,
686                           "restore backup database");
687     cmd_AddParm(ts, "-portoffset", CMD_SINGLE, CMD_OPTIONAL,
688                 "TC port offset");
689     if (!interact)
690         add_std_args(ts);
691
692     ts = cmd_CreateSyntax("dumpinfo", bc_dumpInfoCmd, NULL,
693                           "provide information about a dump in the database");
694     cmd_AddParm(ts, "-ndumps", CMD_SINGLE, CMD_OPTIONAL, "no. of dumps");
695     cmd_AddParm(ts, "-id", CMD_SINGLE, CMD_OPTIONAL, "dump id");
696     cmd_AddParm(ts, "-verbose", CMD_FLAG, CMD_OPTIONAL,
697                 "detailed description");
698     if (!interact)
699         add_std_args(ts);
700
701     ts = cmd_CreateSyntax("dbverify", bc_dbVerifyCmd, NULL,
702                           "check ubik database integrity");
703     cmd_AddParm(ts, "-detail", CMD_FLAG, CMD_OPTIONAL, "additional details");
704     if (!interact)
705         add_std_args(ts);
706
707     ts = cmd_CreateSyntax("deletedump", bc_deleteDumpCmd, NULL,
708                           "delete dumps from the database");
709     cmd_AddParm(ts, "-dumpid", CMD_LIST, CMD_OPTIONAL, "dump id");
710     cmd_AddParm(ts, "-from", CMD_LIST, CMD_OPTIONAL, "date time");
711     cmd_AddParm(ts, "-to", CMD_LIST, CMD_OPTIONAL, "date time");
712     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "TC port offset");
713     cmd_AddParm(ts, "-groupid", CMD_SINGLE, CMD_OPTIONAL, "group ID");
714     cmd_AddParm(ts, "-dbonly", CMD_FLAG, CMD_OPTIONAL,
715                 "delete the dump from the backup database only");
716     cmd_AddParm(ts, "-force", CMD_FLAG, CMD_OPTIONAL,
717                 "always delete from backup database");
718     cmd_AddParm(ts, "-noexecute", CMD_FLAG, CMD_OPTIONAL,
719                 "Just list the dumps");
720
721     if (!interact)
722         add_std_args(ts);
723
724     ts = cmd_CreateSyntax("interactive", bc_interactCmd, NULL,
725                           "enter interactive mode");
726     add_std_args(ts);
727
728     /*
729      * Now execute the command.
730      */
731
732     targc = 0;
733     targv[targc++] = argv[0];
734     if (interact)
735         targv[targc++] = "interactive";
736     for (i = 1; i < argc; i++)
737         targv[targc++] = argv[i];
738
739     code = doDispatch(targc, targv, 1);
740
741     if (!interact || !bcInit) { /* Non-interactive mode */
742         if (code)
743             exit(-1);
744         if (bcInit)
745             code = bc_WaitForNoJobs();  /* wait for any jobs to finish */
746         exit(code);             /* and exit */
747     }
748
749     /* Iterate on command lines, interpreting user commands (interactive mode) */
750     while (1) {
751         int ret;
752
753         printf("backup> ");
754         fflush(stdout);
755
756
757         while ((ret = LWP_GetLine(lineBuffer, sizeof(lineBuffer))) == 0)
758             printf("%s: Command line too long\n", whoami);      /* line too long */
759
760         if (ret == -1)
761             return 0;           /* Got EOF */
762
763         if (!LineIsBlank(lineBuffer)) {
764             code = cmd_ParseLine(lineBuffer, targv, &targc, MAXV);
765             if (code)
766                 afs_com_err(whoami, code, "; Can't parse line: '%s'",
767                         afs_error_message(code));
768             else {
769                 doDispatch(targc, targv, 1);
770                 cmd_FreeArgv(targv);
771             }
772         }
773     }
774 }                               /*main */