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