backup: Don't cast returns from malloc()
[openafs.git] / src / butc / tcmain.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 #include <afs/procmgmt.h>
14
15 #include <roken.h>
16 #include <afs/opr.h>
17
18 #ifdef IGNORE_SOME_GCC_WARNINGS
19 # pragma GCC diagnostic warning "-Wimplicit-function-declaration"
20 #endif
21
22 #ifdef AFS_NT40_ENV
23 #include <WINNT/afsevent.h>
24 #endif
25
26 #include <ctype.h>
27
28 #include <rx/rx.h>
29 #include <rx/rx_globals.h>
30 #include <rx/rxkad.h>
31 #include <rx/xdr.h>
32
33 #include <afs/afsint.h>
34 #include <afs/prs_fs.h>
35 #include <afs/nfs.h>
36 #include <afs/vlserver.h>
37 #include <lwp.h>
38 #include <lock.h>
39 #include <afs/afsutil.h>
40 #include <afs/cellconfig.h>
41 #include <afs/keys.h>
42 #include <afs/volser.h>
43 #include <ubik.h>
44 #include <afs/com_err.h>
45 #include <afs/cmd.h>
46 #include <afs/tcdata.h>
47 #include <afs/bubasics.h>
48 #include <afs/budb_errs.h>
49 #include <afs/budb_client.h>
50 #include <afs/bucoord_prototypes.h>
51 #include <afs/butx.h>
52 #include <afs/kautils.h>
53 #include <afs/bc.h>
54
55 #include "error_macros.h"
56 #define XBSA_TCMAIN
57 #include "butc_xbsa.h"
58 #include "butc_prototypes.h"
59
60 #define N_SECURITY_OBJECTS 3
61 #define ERRCODE_RANGE 8         /* from error_table.h */
62
63 #define TE_PREFIX  "TE"
64 #define TL_PREFIX  "TL"
65 #define CFG_PREFIX "CFG"
66
67 struct ubik_client *cstruct;
68 FILE *logIO, *ErrorlogIO, *centralLogIO, *lastLogIO;
69 char lFile[AFSDIR_PATH_MAX];
70 char logFile[256];
71 char ErrorlogFile[256];
72 char lastLogFile[256];
73 char eFile[AFSDIR_PATH_MAX];
74 char tapeConfigFile[AFSDIR_PATH_MAX];
75 char pFile[AFSDIR_PATH_MAX];
76 int debugLevel = 0;
77 struct tapeConfig globalTapeConfig;
78 struct deviceSyncNode *deviceLatch;
79 char globalCellName[64];
80 char *whoami = "butc";
81
82 /* GLOBAL CONFIGURATION PARAMETERS */
83 int dump_namecheck;
84 int queryoperator;
85 int autoQuery;
86 int isafile;
87 int tapemounted;
88 char *opencallout;
89 char *closecallout;
90 char *restoretofile;
91 int forcemultiple;
92
93 int maxpass;
94 #define PASSESMIN  1
95 #define PASSESMAX  10
96 #define PASSESDFLT 2
97 afs_int32 groupId;
98 #define MINGROUPID 0x1
99 #define MAXGROUPID 0x7FFFFFFF
100 afs_int32 statusSize;
101 #define MINSTATUS  1
102 #define MAXSTATUS  0x7fffffff
103 afs_int32 BufferSize;           /* Size in B stored for data */
104 char *centralLogFile;
105 afs_int32 lastLog;              /* Log last pass info */
106 int rxBind = 0;
107
108 #define ADDRSPERSITE 16         /* Same global is in rx/rx_user.c */
109 afs_uint32 SHostAddrs[ADDRSPERSITE];
110
111 /* dummy routine for the audit work.  It should do nothing since audits */
112 /* occur at the server level and bos is not a server. */
113 int
114 osi_audit(void)
115 {
116     return 0;
117 }
118
119 static afs_int32
120 SafeATOL(char *anum)
121 {
122     afs_int32 total;
123     int tc;
124
125     total = 0;
126     while ((tc = *anum)) {
127         if (tc < '0' || tc > '9')
128             return -1;
129         total *= 10;
130         total += (tc - '0');
131         anum++;
132     }
133     return total;
134 }
135
136 /* atocl
137  *      Convert a string into an afs_int32.
138  *      Returned afs_int32 is in Bytes, Kb, Mb, Gb, or Tb. Based on crunit char.
139  *      This routine only converts unsigned float values.
140  *      The returned value is a whole number.
141  * entry:
142  *      numstring - text string to be converted.
143  *      crunit - value returned in 'B', 'K', 'M', 'G', 'T'.
144  *               ' ' or NULL ==> 'B' (bytes).
145  * exit:
146  *      number - returned value in requested crunit - rounded
147  *               to nearest whole number.
148  * fn return value:
149  *       0 - conversion ok
150  *      -1 - error in conversion
151  * notes:
152  *      should deal with signed numbers. Should signal error if no digits
153  *      seen.
154  */
155 int
156 atocl(char *numstring, char crunit, afs_int32 *number)
157 {
158     float total;
159     afs_int32 runits;
160     char cunit;
161     afs_int32 units;
162     afs_int32 count;
163     char rest[256];
164
165     /* Determine which units to report in */
166     switch (crunit) {
167     case 't':
168     case 'T':
169         runits = 12;
170         break;
171
172     case 'g':
173     case 'G':
174         runits = 9;
175         break;
176
177     case 'm':
178     case 'M':
179         runits = 6;
180         break;
181
182     case 'k':
183     case 'K':
184         runits = 3;
185         break;
186
187     case 'b':
188     case 'B':
189     case ' ':
190     case 0:
191         runits = 0;
192         break;
193
194     default:
195         return (-1);
196     }
197
198     count =
199         sscanf(numstring, "%f%c%s", &total, &cunit, rest);
200     if ((count > 2) || (count <= 0))
201         return -1;
202     if (count == 1)
203         cunit = 'B';            /* bytes */
204
205     switch (cunit) {
206     case 't':
207     case 'T':
208         units = 12;
209         break;
210
211     case 'g':
212     case 'G':
213         units = 9;
214         break;
215
216     case 'm':
217     case 'M':
218         units = 6;
219         break;
220
221     case 'k':
222     case 'K':
223         units = 3;
224         break;
225
226     case 'b':
227     case 'B':
228     case ' ':
229     case 0:
230         units = 0;
231         break;
232
233     default:
234         return (-1);
235     }
236
237     /* Go to correct unit */
238     for (; units < runits; units += 3)
239         total /= 1024.0;
240     for (; units > runits; units -= 3)
241         total *= 1024.0;
242
243     total += 0.5;               /* Round up */
244     if ((total > 0x7fffffff) || (total < 0))    /* Don't go over 2G */
245         total = 0x7fffffff;
246
247     *number = total;
248     return (0);
249 }
250
251 /* replace last two ocurrences of / by _ */
252 #if 0
253 static int
254 stringReplace(char *name)
255 {
256     char *pos;
257     char buffer[256];
258
259     pos = strrchr(name, '/');
260     *pos = '_';
261     strcpy(buffer, pos);
262     pos = strrchr(name, '/');
263     *pos = '\0';
264     strcat(name, buffer);
265     return 0;
266 }
267 #endif
268
269 static int
270 stringNowReplace(char *logFile, char *deviceName)
271 {
272     char *pos = 0;
273     char storeDevice[256];
274     int mvFlag = 0, devPrefLen;
275 #ifdef AFS_NT40_ENV
276     char devPrefix[] = "\\\\.";
277 #else
278     char devPrefix[] = "/dev";
279 #endif
280
281     devPrefLen = strlen(devPrefix);
282     strcpy(storeDevice, deviceName);
283     if (strncmp(deviceName, devPrefix, devPrefLen) == 0) {
284         deviceName += devPrefLen;
285         mvFlag++;
286     }
287     while ((pos = strchr(deviceName, devPrefix[0])))    /* look for / or \ */
288         *pos = '_';
289     strcat(logFile, deviceName);
290     /* now put back deviceName to the way it was */
291     if (mvFlag) {
292         mvFlag = 0;
293         deviceName -= devPrefLen;
294     }
295     strcpy(deviceName, storeDevice);
296
297     return (0);
298 }
299
300
301 /* GetDeviceConfig
302  *      get the configuration information for a particular tape device
303  *      as specified by the portoffset
304  * entry:
305  *      filename - full pathname of file containing the tape device
306  *              configuration information
307  *      config - for return results
308  *      portOffset - for which configuration is required
309  * notes:
310  *      logging not available when this routine is called
311  *      caller return value checks
312  * exit:
313  *      0 => Found entry with same port, return info in config.
314  *     -1 => Error encountered trying to read the file.
315  *      1 => Desired entry does not exist or file does not exist.
316  */
317
318 #define LINESIZE        256
319 static afs_int32
320 GetDeviceConfig(char *filename, struct tapeConfig *config, afs_int32 portOffset)
321 {
322     FILE *devFile = 0;
323     char line[LINESIZE];
324     char devName[LINESIZE], tcapacity[LINESIZE], tfmsize[LINESIZE],
325         trest[LINESIZE];
326     afs_int32 aport;
327     afs_int32 capacity;
328     afs_int32 fmSize;
329     afs_int32 code = 0, count;
330
331     /* Initialize the config struct */
332     config->capacity = 0;
333     config->fileMarkSize = 0;
334     config->portOffset = portOffset;
335     strcpy(config->device, "");
336
337     devFile = fopen(filename, "r");
338     if (!devFile) {
339         if (errno == ENOENT)
340             ERROR_EXIT(1);
341         fprintf(stderr, "Error %d: Can't open %s\n", errno, filename);
342         ERROR_EXIT(-1);
343     }
344
345     while (fgets(line, LINESIZE - 1, devFile)) {
346         count =
347             sscanf(line, "%s %s %s %u%s\n", tcapacity, tfmsize, devName,
348                    &aport, trest);
349
350         if (count == 4 || count == 5) {
351             if (atocl(tcapacity, 'K', &capacity)) {
352                 fprintf(stderr,
353                         "tapeconfig: Tape capacity parse error in: %s\n",
354                         line);
355                 ERROR_EXIT(-1);
356             }
357             if (atocl(tfmsize, 'B', &fmSize)) {
358                 fprintf(stderr,
359                         "tapeconfig: File-mark size parse error in: %s\n",
360                         line);
361                 ERROR_EXIT(-1);
362             }
363         } else {
364             count = sscanf(line, "%s %u%s\n", devName, &aport, trest);
365             if (count == 2 || count == 3) {
366                 capacity = 0x7fffffff;
367                 fmSize = 0;
368             } else {
369                 fprintf(stderr, "tapeconfig: Parse error in: %s\n", line);
370                 ERROR_EXIT(-1);
371             }
372         }
373
374         if ((aport < 0) || (aport > BC_MAXPORTOFFSET)) {
375             fprintf(stderr, "tapeconfig: Port offset parse error in: %s\n",
376                     line);
377             ERROR_EXIT(-1);
378         }
379
380         if (aport != portOffset)
381             continue;
382
383         if (fmSize < 0) {
384             fprintf(stderr, "Invalid file mark size, %d, in: %s\n", fmSize,
385                     line);
386             ERROR_EXIT(-1);
387         }
388
389         config->capacity = capacity;
390         config->fileMarkSize = fmSize;
391         config->portOffset = aport;
392         strncpy(config->device, devName, 100);
393
394         ERROR_EXIT(0);
395     }
396
397     /* fprintf(stderr, "Can't find tapeconfig entry for port offset %d\n", portOffset); */
398     ERROR_EXIT(1);
399
400   error_exit:
401     if (devFile)
402         fclose(devFile);
403     return (code);
404 }
405
406 /* GetConfigParams
407  */
408 static afs_int32
409 GetConfigParams(char *filename, afs_int32 port)
410 {
411     char paramFile[256];
412     FILE *devFile = 0;
413     char line[LINESIZE], cmd[LINESIZE], value[LINESIZE];
414     afs_int32 code = 0;
415     int cnt;
416
417     /* DEFAULT SETTINGS FOR GLOBAL PARAMETERS */
418     dump_namecheck = 1;         /* check tape name on dumps */
419     queryoperator = 1;          /* can question operator */
420     autoQuery = 1;              /* prompt for first tape */
421     isafile = 0;                /* Do not dump to a file */
422     opencallout = NULL;         /* open  callout routine */
423     closecallout = NULL;        /* close callout routine */
424     tapemounted = 0;            /* tape is not mounted */
425 #ifdef xbsa
426     BufferSize = (CONF_XBSA ? XBSADFLTBUFFER : BUTM_BLOCKSIZE);
427     dumpRestAuthnLevel = rpc_c_protect_level_default;
428     xbsaObjectOwner = NULL;     /* bsaObjectOwner */
429     appObjectOwner = NULL;      /* appObjectOwner */
430     adsmServerName = NULL;      /* TSM server name - same as ADSM */
431     xbsaSecToken = NULL;        /* XBSA sercurity token */
432     xbsalGName = NULL;          /* XBSA IGName */
433 #else
434     BufferSize = BUTM_BLOCKSIZE;
435 #endif /*xbsa */
436     centralLogFile = NULL;      /* Log for all butcs */
437     centralLogIO = 0;           /* Log for all butcs */
438     statusSize = 0;             /* size before status message */
439     maxpass = PASSESDFLT;       /* dump passes */
440     lastLog = 0;                /* separate log for last pass */
441     lastLogIO = 0;              /* separate log for last pass */
442     groupId = 0;                /* Group id for multiple dumps */
443
444     /* Try opening the CFG_<port> file */
445     sprintf(paramFile, "%s_%d", filename, port);
446     devFile = fopen(paramFile, "r");
447     if (devFile) {
448         /* Set log names to TL_<port>, TL_<port>.lp and TE_<port> */
449         sprintf(logFile, "%s_%d", lFile, port);
450         sprintf(lastLogFile, "%s_%d.lp", lFile, port);
451         sprintf(ErrorlogFile, "%s_%d", eFile, port);
452     } else if (CONF_XBSA) {
453         /* If configured as XBSA, a configuration file CFG_<port> must exist */
454         printf("Cannot open configuration file %s", paramFile);
455         ERROR_EXIT(1);
456     } else {
457         /* Try the CFG_<device> name as the device file */
458         strcpy(paramFile, filename);
459         stringNowReplace(paramFile, globalTapeConfig.device);
460         /* Set log names to TL_<device>, TL_<device> and TE_<device> */
461         strcpy(logFile, lFile);
462         stringNowReplace(logFile, globalTapeConfig.device);
463         strcpy(lastLogFile, lFile);
464         stringNowReplace(lastLogFile, globalTapeConfig.device);
465         strcat(lastLogFile, ".lp");
466         strcpy(ErrorlogFile, eFile);
467         stringNowReplace(ErrorlogFile, globalTapeConfig.device);
468
469         /* Now open the device file */
470         devFile = fopen(paramFile, "r");
471         if (!devFile)
472             ERROR_EXIT(0);      /* CFG file doesn't exist for non-XBSA and that's ok */
473     }
474
475     /* Read each line of the Configuration file */
476     while (fgets(line, LINESIZE - 1, devFile)) {
477         cnt = sscanf(line, "%s %s", cmd, value);
478         if (cnt != 2) {
479             if (cnt > 0)
480                 printf("Bad line in %s: %s\n", paramFile, line);
481             continue;
482         }
483
484         for (cnt = 0; cnt < strlen(cmd); cnt++)
485             if (islower(cmd[cnt]))
486                 cmd[cnt] = toupper(cmd[cnt]);
487
488         if (!strcmp(cmd, "NAME_CHECK")) {
489             if (CONF_XBSA) {
490                 printf
491                     ("Warning: The %s parameter is ignored with a Backup Service\n",
492                      cmd);
493                 continue;
494             }
495
496             for (cnt = 0; cnt < strlen(value); cnt++)
497                 if (islower(value[cnt]))
498                     value[cnt] = toupper(value[cnt]);
499
500             if (!strcmp(value, "NO")) {
501                 printf("Dump tape name check is disabled\n");
502                 dump_namecheck = 0;
503             } else {
504                 printf("Dump tape name check is enabled\n");
505                 dump_namecheck = 1;
506             }
507         }
508
509         else if (!strcmp(cmd, "MOUNT")) {
510             if (CONF_XBSA) {
511                 printf
512                     ("Warning: The %s parameter is ignored with a Backup Service\n",
513                      cmd);
514                 continue;
515             }
516
517             opencallout = strdup(value);
518             printf("Tape mount callout routine is %s\n", opencallout);
519         }
520
521         else if (!strcmp(cmd, "UNMOUNT")) {
522             if (CONF_XBSA) {
523                 printf
524                     ("Warning: The %s parameter is ignored with a Backup Service\n",
525                      cmd);
526                 continue;
527             }
528
529             closecallout = strdup(value);
530             printf("Tape unmount callout routine is %s\n", closecallout);
531         }
532
533         else if (!strcmp(cmd, "ASK")) {
534             for (cnt = 0; cnt < strlen(value); cnt++)
535                 if (islower(value[cnt]))
536                     value[cnt] = toupper(value[cnt]);
537
538             if (!strcmp(value, "NO")) {
539                 printf("Operator queries are disabled\n");
540                 queryoperator = 0;
541             } else {
542                 printf("Operator queries are enabled\n");
543                 queryoperator = 1;
544             }
545         }
546
547         else if (!strcmp(cmd, "FILE")) {
548             if (CONF_XBSA) {
549                 printf
550                     ("Warning: The %s parameter is ignored with a Backup Service\n",
551                      cmd);
552                 continue;
553             }
554
555             for (cnt = 0; cnt < strlen(value); cnt++)
556                 if (islower(value[cnt]))
557                     value[cnt] = toupper(value[cnt]);
558
559             if (!strcmp(value, "YES")) {
560                 printf("Will dump to a file\n");
561                 isafile = 1;
562             } else {
563                 printf("Will not dump to a file\n");
564                 isafile = 0;
565             }
566         }
567
568         else if (!strcmp(cmd, "AUTOQUERY")) {
569             if (CONF_XBSA) {
570                 printf
571                     ("Warning: The %s parameter is ignored with a Backup Service\n",
572                      cmd);
573                 continue;
574             }
575
576             for (cnt = 0; cnt < strlen(value); cnt++)
577                 if (islower(value[cnt]))
578                     value[cnt] = toupper(value[cnt]);
579
580             if (!strcmp(value, "NO")) {
581                 printf("Auto query is disabled\n");
582                 autoQuery = 0;
583             } else {
584                 printf("Auto query is enabled\n");
585                 autoQuery = 1;
586             }
587         }
588
589         else if (!strcmp(cmd, "BUFFERSIZE")) {
590             afs_int32 size;
591             afs_int32 tapeblocks;
592
593             if (!CONF_XBSA) {
594                 if (atocl(value, 'K', &size)) {
595                     fprintf(stderr, "BUFFERSIZE parse error\n");
596                     size = 0;
597                 }
598
599                 /* A tapeblock is 16KB. Determine # of tapeblocks. Then
600                  * determine BufferSize needed for that many tapeblocks.
601                  */
602                 tapeblocks = size / 16;
603                 if (tapeblocks <= 0)
604                     tapeblocks = 1;
605                 printf("BUFFERSIZE is %u KBytes\n", (tapeblocks * 16));
606                 BufferSize = tapeblocks * BUTM_BLOCKSIZE;
607             } else {
608 #ifdef xbsa
609                 if (atocl(value, 'B', &size)) {
610                     fprintf(stderr, "BUFFERSIZE parse error\n");
611                     size = 0;
612                 }
613                 if (size < XBSAMINBUFFER)
614                     size = XBSAMINBUFFER;
615                 if (size > XBSAMAXBUFFER)
616                     size = XBSAMAXBUFFER;
617                 printf("XBSA buffer size is %u Bytes\n", size);
618                 BufferSize = size;
619 #endif
620             }
621         }
622 #ifndef xbsa
623         /* All the xbsa spacific parameters */
624         else if (!strcmp(cmd, "TYPE") || !strcmp(cmd, "NODE")
625                  || !strcmp(cmd, "SERVER") || !strcmp(cmd, "PASSWORD")
626                  || !strcmp(cmd, "PASSFILE") || !strcmp(cmd, "MGMTCLASS")) {
627             printf("This binary does not have XBSA support\n");
628             return 1;
629         }
630 #else
631         else if (!strcmp(cmd, "TYPE")) {        /* required for XBSA */
632             if (!CONF_XBSA) {
633                 printf
634                     ("Warning: The %s parameter is ignored with a tape drive\n",
635                      cmd);
636                 continue;
637             }
638
639             for (cnt = 0; (size_t) cnt < strlen(value); cnt++)
640                 if (islower(value[cnt]))
641                     value[cnt] = toupper(value[cnt]);
642
643             if (strcmp(value, "TSM") == 0) {
644                 xbsaType = XBSA_SERVER_TYPE_ADSM;       /* Known XBSA server type */
645             } else {
646                 printf("Configuration file error, %s %s is not recognized\n",
647                        cmd, value);
648                 xbsaType = XBSA_SERVER_TYPE_UNKNOWN;
649             }
650             printf("XBSA type is %s\n",
651                    ((xbsaType ==
652                      XBSA_SERVER_TYPE_UNKNOWN) ? "Unknown" : value));
653         }
654
655         else if (!strcmp(cmd, "NODE")) {
656             if (!CONF_XBSA) {
657                 printf
658                     ("Warning: The %s parameter is ignored with a tape drive\n",
659                      cmd);
660                 continue;
661             }
662             xbsaObjectOwner = strdup(value);
663             printf("XBSA node is %s\n", xbsaObjectOwner);
664         }
665
666         else if (!strcmp(cmd, "SERVER")) {      /* required for XBSA */
667             if (!CONF_XBSA) {
668                 printf
669                     ("Warning: The %s parameter is ignored with a tape drive\n",
670                      cmd);
671                 continue;
672             }
673             adsmServerName = strdup(value);
674             printf("XBSA server is %s\n", adsmServerName);
675         }
676
677         else if (!strcmp(cmd, "PASSWORD")) {    /* This or PASSFILE required for XBSA */
678             if (!CONF_XBSA) {
679                 printf
680                     ("Warning: The %s parameter is ignored with a tape drive\n",
681                      cmd);
682                 continue;
683             }
684             if (xbsaSecToken) {
685                 printf
686                     ("Warning: The %s parameter is ignored. Already read password\n",
687                      cmd);
688                 continue;
689             }
690
691             xbsaSecToken = strdup(value);
692             printf("XBSA Password has been read\n");
693         }
694
695         else if (!strcmp(cmd, "PASSFILE")) {    /* This or PASSWORD required for XBSA */
696             FILE *pwdFile;
697             if (!CONF_XBSA) {
698                 printf
699                     ("Warning: The %s parameter is ignored with a tape drive\n",
700                      cmd);
701                 continue;
702             }
703             if (xbsaSecToken) {
704                 printf
705                     ("Warning: The %s parameter is ignored. Already read password\n",
706                      cmd);
707                 continue;
708             }
709
710             pwdFile = fopen(value, "r");
711             if (!pwdFile) {
712                 printf
713                     ("Configuration file error, cannot open password file %s\n",
714                      value);
715                 ERROR_EXIT(1);
716             }
717             xbsaSecToken = malloc(LINESIZE);
718             if (!fscanf(pwdFile, "%s", xbsaSecToken)) {
719                 printf
720                     ("Configuration file error, cannot read password file %s\n",
721                      value);
722                 ERROR_EXIT(1);
723             }
724             printf("XBSA password retrieved from password file\n");
725         }
726
727         else if (!strcmp(cmd, "MGMTCLASS")) {   /* XBSA */
728             if (!CONF_XBSA) {
729                 printf
730                     ("Warning: The %s parameter is ignored with a tape drive\n",
731                      cmd);
732                 continue;
733             }
734             xbsalGName = strdup(value);
735             printf("XBSA management class is %s\n", xbsalGName);
736         }
737 #endif
738
739         else if (!strcmp(cmd, "MAXPASS")) {
740             maxpass = SafeATOL(value);
741             if (maxpass < PASSESMIN)
742                 maxpass = PASSESMIN;
743             if (maxpass > PASSESMAX)
744                 maxpass = PASSESMAX;
745             printf("MAXPASS is %d\n", maxpass);
746         }
747
748         else if (!strcmp(cmd, "GROUPID")) {
749             groupId = SafeATOL(value);
750             if ((groupId < MINGROUPID) || (groupId > MAXGROUPID)) {
751                 printf("Configuration file error, %s %s is invalid\n", cmd,
752                        value);
753                 ERROR_EXIT(1);
754             }
755             printf("Group Id is %d\n", groupId);
756         }
757
758         else if (!strcmp(cmd, "LASTLOG")) {
759             for (cnt = 0; (size_t) cnt < strlen(value); cnt++)
760                 if (islower(value[cnt]))
761                     value[cnt] = toupper(value[cnt]);
762
763             lastLog = (strcmp(value, "YES") == 0);
764             printf("Will %sgenerate a last log\n", (lastLog ? "" : "not "));
765         }
766
767         else if (!strcmp(cmd, "CENTRALLOG")) {
768             centralLogFile = strdup(value);
769             printf("Central log file is %s\n", centralLogFile);
770         }
771
772         else if (!strcmp(cmd, "STATUS")) {
773             if (atocl(value, 'B', &statusSize)) {
774                 fprintf(stderr, "STATUS parse error\n");
775                 statusSize = 0;
776             }
777             if (statusSize < MINSTATUS)
778                 statusSize = MINSTATUS;
779             if (statusSize > MAXSTATUS)
780                 statusSize = MAXSTATUS;
781         }
782
783         else {
784             printf("Warning: Unrecognized configuration parameter: %s", line);
785         }
786     }                           /*fgets */
787
788     if (statusSize) {
789         /* Statussize is in bytes and requires that BufferSize be set first */
790         statusSize *= BufferSize;
791         if (statusSize < 0)
792             statusSize = 0x7fffffff;    /*max size */
793         printf("Status every %ld Bytes\n", afs_printable_int32_ld(statusSize));
794     }
795
796   error_exit:
797     if (devFile)
798         fclose(devFile);
799
800     /* If the butc is configured as XBSA, check for required parameters */
801 #ifdef xbsa
802     if (!code && CONF_XBSA) {
803         if (xbsaType == XBSA_SERVER_TYPE_UNKNOWN) {
804             printf
805                 ("Configuration file error, the TYPE parameter must be specified, or\n");
806             printf("an entry must exist in %s for port %d\n", tapeConfigFile,
807                    port);
808             code = 1;
809         }
810         if (!adsmServerName) {
811             printf
812                 ("Configuration file error, the SERVER parameter must be specified\n");
813             code = 1;
814         }
815         if (!xbsaSecToken) {
816             printf
817                 ("Configuration file error, the PASSWORD or PASSFILE parameter must be specified\n");
818             code = 1;
819         }
820     }
821 #endif /*xbsa */
822     return (code);
823 }
824
825 static int
826 WorkerBee(struct cmd_syndesc *as, void *arock)
827 {
828     afs_int32 code;
829     struct rx_securityClass *(securityObjects[3]);
830     struct rx_service *service;
831     time_t tokenExpires;
832     char cellName[64];
833     int localauth;
834     /*process arguments */
835     afs_int32 portOffset = 0;
836 #ifdef AFS_PTHREAD_ENV
837     pthread_t dbWatcherPid;
838     pthread_attr_t tattr;
839     AFS_SIGSET_DECL;
840 #else
841     PROCESS dbWatcherPid;
842 #endif
843     afs_uint32 host = htonl(INADDR_ANY);
844
845     debugLevel = 0;
846
847     /*initialize the error tables */
848     initialize_KA_error_table();
849     initialize_RXK_error_table();
850     initialize_KTC_error_table();
851     initialize_ACFG_error_table();
852     initialize_CMD_error_table();
853     initialize_VL_error_table();
854     initialize_BUTM_error_table();
855     initialize_BUTC_error_table();
856 #ifdef xbsa
857     initialize_BUTX_error_table();
858 #endif /*xbs */
859     initialize_VOLS_error_table();
860     initialize_BUDB_error_table();
861     initialize_BUCD_error_table();
862
863     if (as->parms[0].items) {
864         portOffset = SafeATOL(as->parms[0].items->data);
865         if (portOffset == -1) {
866             fprintf(stderr, "Illegal port offset '%s'\n",
867                     as->parms[0].items->data);
868             exit(1);
869         } else if (portOffset > BC_MAXPORTOFFSET) {
870             fprintf(stderr, "%u exceeds max port offset %u\n", portOffset,
871                     BC_MAXPORTOFFSET);
872             exit(1);
873         }
874     }
875
876     xbsaType = XBSA_SERVER_TYPE_NONE;   /* default */
877     if (as->parms[3].items) {   /* -device */
878         globalTapeConfig.capacity = 0x7fffffff; /* 2T for max tape capacity */
879         globalTapeConfig.fileMarkSize = 0;
880         globalTapeConfig.portOffset = portOffset;
881         strncpy(globalTapeConfig.device, as->parms[3].items->data, 100);
882         xbsaType = XBSA_SERVER_TYPE_NONE;       /* Not XBSA */
883     } else {
884         /* Search for an entry in tapeconfig file */
885         code = GetDeviceConfig(tapeConfigFile, &globalTapeConfig, portOffset);
886         if (code == -1) {
887             fprintf(stderr, "Problem in reading config file %s\n",
888                     tapeConfigFile);
889             exit(1);
890         }
891         /* Set xbsaType. If code == 1, no entry was found in the tapeconfig file so
892          * it's an XBSA server. Don't know if its ADSM or not so its unknown.
893          */
894         xbsaType =
895             ((code == 1) ? XBSA_SERVER_TYPE_UNKNOWN : XBSA_SERVER_TYPE_NONE);
896     }
897
898     if (as->parms[6].items) {   /* -restoretofile */
899         restoretofile = strdup(as->parms[6].items->data);
900         printf("Restore to file '%s'\n", restoretofile);
901     }
902
903     /* Go and read the config file: CFG_<device> or CFG_<port>. We will also set
904      * the exact xbsaType within the call (won't be unknown) - double check.
905      */
906     code = GetConfigParams(pFile, portOffset);
907     if (code)
908         exit(code);
909 #ifdef xbsa
910     if (xbsaType == XBSA_SERVER_TYPE_UNKNOWN) {
911         printf
912             ("\nConfiguration file error, the TYPE parameter must be specified, or\n");
913         printf("an entry must exist in %s for port %d\n", tapeConfigFile,
914                portOffset);
915         exit(1);
916     }
917 #else
918     /* Not compiled for XBSA code so we can't support it */
919     if (CONF_XBSA) {
920         printf("\nNo entry found in %s for port %d\n", tapeConfigFile,
921                portOffset);
922         printf("This binary does not have XBSA support\n");
923         exit(1);
924     }
925 #endif
926
927     /* Open the log files. The pathnames were set in GetConfigParams() */
928     logIO = fopen(logFile, "a");
929     if (!logIO) {
930         fprintf(stderr, "Failed to open %s\n", logFile);
931         exit(1);
932     }
933     ErrorlogIO = fopen(ErrorlogFile, "a");
934     if (!ErrorlogIO) {
935         fprintf(stderr, "Failed to open %s\n", ErrorlogFile);
936         exit(1);
937     }
938     if (lastLog) {
939         lastLogIO = fopen(lastLogFile, "a");
940         if (!lastLogIO) {
941             fprintf(stderr, "Failed to open %s\n", lastLogFile);
942             exit(1);
943         }
944     }
945     if (centralLogFile) {
946         struct stat sbuf;
947         afs_int32 statcode;
948 #ifndef AFS_NT40_ENV
949         char path[AFSDIR_PATH_MAX];
950 #endif
951
952         statcode = stat(centralLogFile, &sbuf);
953         centralLogIO = fopen(centralLogFile, "a");
954         if (!centralLogIO) {
955             fprintf(stderr, "Failed to open %s; error %d\n", centralLogFile,
956                     errno);
957             exit(1);
958         }
959 #ifndef AFS_NT40_ENV
960         /* Make sure it is not in AFS, has to have been created first */
961         if (!realpath(centralLogFile, path)) {
962             fprintf(stderr,
963                     "Warning: can't determine real path of '%s' (%d)\n",
964                     centralLogFile, errno);
965         } else {
966             if (strncmp(path, "/afs/", 5) == 0) {
967                 fprintf(stderr, "The central log '%s' should not be in AFS\n",
968                         centralLogFile);
969                 exit(1);
970             }
971         }
972 #endif
973
974         /* Write header if created it */
975         if (statcode) {
976             char *h1 =
977                 "TASK   START DATE/TIME      END DATE/TIME        ELAPSED   VOLUMESET\n";
978             char *h2 =
979                 "-----  -------------------  -------------------  --------  ---------\n";
980             /* File didn't exist before so write the header lines */
981             fwrite(h1, strlen(h1), 1, centralLogIO);
982             fwrite(h2, strlen(h2), 1, centralLogIO);
983             fflush(centralLogIO);
984         }
985     }
986
987     if (as->parms[1].items) {
988         debugLevel = SafeATOL(as->parms[1].items->data);
989         if (debugLevel == -1) {
990             TLog(0, "Illegal debug level '%s'\n", as->parms[1].items->data);
991             exit(1);
992         }
993     }
994 #ifdef xbsa
995     /* Setup XBSA library interface */
996     if (CONF_XBSA) {
997         afs_int32 rc;
998         rc = xbsa_MountLibrary(&butxInfo, xbsaType);
999         if (rc != XBSA_SUCCESS) {
1000             TapeLog(0, 0, rc, 0, "Unable to mount the XBSA library\n");
1001             return (1);
1002         }
1003
1004         forcemultiple = (as->parms[7].items ? 1 : 0);/*-xbsaforcemultiple */
1005         if (forcemultiple)
1006             printf("Force XBSA multiple server support\n");
1007
1008         rc = InitToServer(0 /*taskid */ , &butxInfo, adsmServerName);
1009         if (rc != XBSA_SUCCESS)
1010             return (1);
1011     }
1012 #endif /*xbsa */
1013
1014     /* cell switch */
1015     if (as->parms[2].items)
1016         strncpy(cellName, as->parms[2].items->data, sizeof(cellName));
1017     else
1018         cellName[0] = '\0';
1019
1020     if (as->parms[4].items)
1021         autoQuery = 0;
1022
1023     localauth = (as->parms[5].items ? 1 : 0);
1024     rxBind = (as->parms[8].items ? 1 : 0);
1025
1026     if (rxBind) {
1027         afs_int32 ccode;
1028         if (AFSDIR_SERVER_NETRESTRICT_FILEPATH ||
1029             AFSDIR_SERVER_NETINFO_FILEPATH) {
1030             char reason[1024];
1031             ccode = parseNetFiles(SHostAddrs, NULL, NULL,
1032                                            ADDRSPERSITE, reason,
1033                                            AFSDIR_SERVER_NETINFO_FILEPATH,
1034                                            AFSDIR_SERVER_NETRESTRICT_FILEPATH);
1035         } else
1036         {
1037             ccode = rx_getAllAddr(SHostAddrs, ADDRSPERSITE);
1038         }
1039         if (ccode == 1)
1040             host = SHostAddrs[0];
1041     }
1042
1043     code = rx_InitHost(host, htons(BC_TAPEPORT + portOffset));
1044     if (code) {
1045         TapeLog(0, 0, code, 0, "rx init failed on port %u\n",
1046                 BC_TAPEPORT + portOffset);
1047         exit(1);
1048     }
1049     rx_SetRxDeadTime(150);
1050
1051     /* Establish connection with the vldb server */
1052     code = vldbClientInit(0, localauth, cellName, &cstruct, &tokenExpires);
1053     if (code) {
1054         TapeLog(0, 0, code, 0, "Can't access vldb\n");
1055         return code;
1056     }
1057
1058     strcpy(globalCellName, cellName);
1059
1060     /*initialize the dumpNode list */
1061     InitNodeList(portOffset);
1062
1063     deviceLatch = malloc(sizeof(struct deviceSyncNode));
1064     Lock_Init(&(deviceLatch->lock));
1065     deviceLatch->flags = 0;
1066
1067     /* initialize database support, volume support, and logs */
1068
1069     /* Create a single security object, in this case the null security
1070      * object, for unauthenticated connections, which will be used to control
1071      * security on connections made to this server
1072      */
1073
1074     securityObjects[0] = rxnull_NewServerSecurityObject();
1075     securityObjects[1] = (struct rx_securityClass *)0;  /* don't bother with rxvab */
1076     if (!securityObjects[0]) {
1077         TLog(0, "rxnull_NewServerSecurityObject");
1078         exit(1);
1079     }
1080
1081     service =
1082         rx_NewServiceHost(host, 0, 1, "BUTC", securityObjects, 3, TC_ExecuteRequest);
1083     if (!service) {
1084         TLog(0, "rx_NewService");
1085         exit(1);
1086     }
1087     rx_SetMaxProcs(service, 4);
1088
1089     /* Establish connection to the backup database */
1090     code = udbClientInit(0, localauth, cellName);
1091     if (code) {
1092         TapeLog(0, 0, code, 0, "Can't access backup database\n");
1093         exit(1);
1094     }
1095     /* This call is here to verify that we are authentiated.
1096      * The call does nothing and will return BUDB_NOTPERMITTED
1097      * if we don't belong.
1098      */
1099     code = bcdb_deleteDump(0, 0, 0, 0);
1100     if (code == BUDB_NOTPERMITTED) {
1101         TapeLog(0, 0, code, 0, "Can't access backup database\n");
1102         exit(1);
1103     }
1104
1105     initStatus();
1106 #ifdef AFS_PTHREAD_ENV
1107     code = pthread_attr_init(&tattr);
1108     if (code) {
1109         TapeLog(0, 0, code, 0,
1110                 "Can't pthread_attr_init database monitor task");
1111         exit(1);
1112     }
1113     code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
1114     if (code) {
1115         TapeLog(0, 0, code, 0,
1116                 "Can't pthread_attr_setdetachstate database monitor task");
1117         exit(1);
1118     }
1119     AFS_SIGSET_CLEAR();
1120     code = pthread_create(&dbWatcherPid, &tattr, dbWatcher, (void *)2);
1121     AFS_SIGSET_RESTORE();
1122 #else
1123     code =
1124         LWP_CreateProcess(dbWatcher, 20480, LWP_NORMAL_PRIORITY, (void *)2,
1125                           "dbWatcher", &dbWatcherPid);
1126 #endif
1127     if (code) {
1128         TapeLog(0, 0, code, 0, "Can't create database monitor task");
1129         exit(1);
1130     }
1131
1132     TLog(0, "Starting Tape Coordinator: Port offset %u   Debug level %u\n",
1133          portOffset, debugLevel);
1134     TLog(0, "Token expires: %s\n", cTIME(&tokenExpires));
1135
1136     rx_StartServer(1);          /* Donate this process to the server process pool */
1137     TLog(0, "Error: StartServer returned");
1138     exit(1);
1139 }
1140
1141 #ifndef AFS_NT40_ENV
1142 #include "AFS_component_version_number.c"
1143 #endif
1144
1145 int
1146 main(int argc, char **argv)
1147 {
1148     struct cmd_syndesc *ts;
1149     struct cmd_item *ti;
1150
1151 #ifdef  AFS_AIX32_ENV
1152     /*
1153      * The following signal action for AIX is necessary so that in case of a
1154      * crash (i.e. core is generated) we can include the user's data section
1155      * in the core dump. Unfortunately, by default, only a partial core is
1156      * generated which, in many cases, isn't too useful.
1157      */
1158     struct sigaction nsa;
1159
1160     sigemptyset(&nsa.sa_mask);
1161     nsa.sa_handler = SIG_DFL;
1162     nsa.sa_flags = SA_FULLDUMP;
1163     sigaction(SIGSEGV, &nsa, NULL);
1164     sigaction(SIGABRT, &nsa, NULL);
1165 #endif
1166
1167     setlinebuf(stdout);
1168
1169     ts = cmd_CreateSyntax(NULL, WorkerBee, NULL, "tape coordinator");
1170     cmd_AddParm(ts, "-port", CMD_SINGLE, CMD_OPTIONAL, "port offset");
1171     cmd_AddParm(ts, "-debuglevel", CMD_SINGLE, CMD_OPTIONAL, "0 | 1 | 2");
1172     cmd_AddParm(ts, "-cell", CMD_SINGLE, CMD_OPTIONAL, "cell name");
1173     cmd_AddParm(ts, "-device", CMD_SINGLE, (CMD_OPTIONAL | CMD_HIDE),
1174                 "tape device path");
1175     cmd_AddParm(ts, "-noautoquery", CMD_FLAG, CMD_OPTIONAL,
1176                 "do not query operator for first tape");
1177     cmd_AddParm(ts, "-localauth", CMD_FLAG, CMD_OPTIONAL,
1178                 "create tickets from KeyFile");
1179     cmd_AddParm(ts, "-restoretofile", CMD_SINGLE, (CMD_OPTIONAL | CMD_HIDE),
1180                 "file to restore to");
1181     cmd_AddParm(ts, "-xbsaforcemultiple", CMD_FLAG, (CMD_OPTIONAL | CMD_HIDE),
1182                 "Force multiple XBSA server support");
1183     cmd_AddParm(ts, "-rxbind", CMD_FLAG, CMD_OPTIONAL,
1184                 "bind Rx socket");
1185
1186     /* Initialize dirpaths */
1187     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
1188 #ifdef AFS_NT40_ENV
1189         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
1190 #endif
1191         fprintf(stderr, "Unable to obtain AFS server directory.\n");
1192         exit(2);
1193     }
1194
1195     /* setup the file paths */
1196     strcompose(eFile, AFSDIR_PATH_MAX, AFSDIR_SERVER_BACKUP_DIRPATH, "/",
1197                TE_PREFIX, NULL);
1198     strcompose(lFile, AFSDIR_PATH_MAX, AFSDIR_SERVER_BACKUP_DIRPATH, "/",
1199                TL_PREFIX, NULL);
1200     strcompose(pFile, AFSDIR_PATH_MAX, AFSDIR_SERVER_BACKUP_DIRPATH, "/",
1201                CFG_PREFIX, NULL);
1202     strcpy(tapeConfigFile, AFSDIR_SERVER_TAPECONFIG_FILEPATH);
1203
1204     /* special case "no args" case since cmd_dispatch gives help message
1205      * instead
1206      */
1207     if (argc == 1) {
1208         ts = calloc(1, sizeof(struct cmd_syndesc));
1209
1210         ti = malloc(sizeof(struct cmd_item));
1211         ti->next = 0;
1212         ti->data = "0";
1213         ts->parms[0].items = ti;
1214         ti = malloc(sizeof(struct cmd_item));
1215         ti->next = 0;
1216         ti->data = "0";
1217         ts->parms[1].items = ti;
1218         ts->parms[2].items = (struct cmd_item *)NULL;
1219         ts->parms[3].items = (struct cmd_item *)NULL;
1220         ts->parms[4].items = (struct cmd_item *)NULL;
1221         ts->parms[5].items = (struct cmd_item *)NULL;
1222         return WorkerBee(ts, NULL);
1223     } else
1224         return cmd_Dispatch(argc, argv);
1225 }