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