warn when starting without keys
[openafs.git] / src / budb / server.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 #include <afs/stds.h>
13
14 #include <roken.h>
15
16 #ifdef AFS_NT40_ENV
17 #include <WINNT/afsevent.h>
18 #endif
19 #include <afs/cmd.h>
20 #include <lwp.h>
21 #include <ubik.h>
22 #include <rx/xdr.h>
23 #include <rx/rx.h>
24 #include <rx/rxkad.h>
25 #include <rx/rx_globals.h>
26 #include <afs/cellconfig.h>
27 #include <afs/bubasics.h>
28 #include <afs/afsutil.h>
29 #include <afs/com_err.h>
30 #include <afs/audit.h>
31
32 #include "budb_errs.h"
33 #include "database.h"
34 #include "error_macros.h"
35 #include "budb_internal.h"
36 #include "globals.h"
37
38 struct ubik_dbase *BU_dbase;
39 struct afsconf_dir *BU_conf;    /* for getting cell info */
40
41 int argHandler(struct cmd_syndesc *, void *);
42 int truncateDatabase(void);
43 int parseServerList(struct cmd_item *);
44
45 char lcell[MAXKTCREALMLEN];
46 afs_uint32 myHost = 0;
47 int helpOption;
48 static struct logOptions logopts;
49
50 /* server's global configuration information. This is exported to other
51  * files/routines
52  */
53
54 buServerConfT globalConf;
55 buServerConfP globalConfPtr = &globalConf;
56 char dbDir[AFSDIR_PATH_MAX], cellConfDir[AFSDIR_PATH_MAX];
57 /* debugging control */
58 int debugging = 0;
59
60 int rxBind = 0;
61 int lwps   = 3;
62
63 #define MINLWP  3
64 #define MAXLWP 16
65
66 #define ADDRSPERSITE 16         /* Same global is in rx/rx_user.c */
67 afs_uint32 SHostAddrs[ADDRSPERSITE];
68
69 /* check whether caller is authorized to manage RX statistics */
70 int
71 BU_rxstat_userok(struct rx_call *call)
72 {
73     return afsconf_SuperUser(BU_conf, call, NULL);
74 }
75
76 /**
77  * Return true if this name is a member of the local realm.
78  */
79 int
80 BU_IsLocalRealmMatch(void *rock, char *name, char *inst, char *cell)
81 {
82     struct afsconf_dir *dir = (struct afsconf_dir *)rock;
83     afs_int32 islocal = 0;      /* default to no */
84     int code;
85
86     code = afsconf_IsLocalRealmMatch(dir, &islocal, name, inst, cell);
87     if (code) {
88         LogError(code, "Failed local realm check; name=%s, inst=%s, cell=%s\n",
89                  name, inst, cell);
90     }
91     return islocal;
92 }
93
94 int
95 convert_cell_to_ubik(struct afsconf_cell *cellinfo, afs_uint32 *myHost,
96                      afs_uint32 *serverList)
97 {
98     int i;
99     char hostname[64];
100     struct hostent *th;
101
102     /* get this host */
103     gethostname(hostname, sizeof(hostname));
104     th = gethostbyname(hostname);
105     if (!th) {
106         printf("prserver: couldn't get address of this host.\n");
107         BUDB_EXIT(1);
108     }
109     memcpy(myHost, th->h_addr, sizeof(afs_uint32));
110
111     for (i = 0; i < cellinfo->numServers; i++)
112         /* omit my host from serverList */
113         if (cellinfo->hostAddr[i].sin_addr.s_addr != *myHost)
114             *serverList++ = cellinfo->hostAddr[i].sin_addr.s_addr;
115
116     *serverList = 0;            /* terminate list */
117     return 0;
118 }
119
120 /* MyBeforeProc
121  *      The whole purpose of MyBeforeProc is to detect
122  *      if the -help option was not within the command line.
123  *      If it were, this routine would never have been called.
124  */
125 static int
126 MyBeforeProc(struct cmd_syndesc *as, void *arock)
127 {
128     helpOption = 0;
129     return 0;
130 }
131
132 /* initializeCommands
133  *      initialize all the supported commands and their arguments
134  */
135
136 void
137 initializeArgHandler(void)
138 {
139     struct cmd_syndesc *cptr;
140
141     cmd_SetBeforeProc(MyBeforeProc, NULL);
142
143     cptr = cmd_CreateSyntax(NULL, argHandler, NULL, 0, "Backup database server");
144
145     cmd_AddParm(cptr, "-database", CMD_SINGLE, CMD_OPTIONAL,
146                 "database directory");
147
148     cmd_AddParm(cptr, "-cellservdb", CMD_SINGLE, CMD_OPTIONAL,
149                 "cell configuration directory");
150
151     cmd_AddParm(cptr, "-resetdb", CMD_FLAG, CMD_OPTIONAL,
152                 "truncate the database");
153
154     cmd_AddParm(cptr, "-noauth", CMD_FLAG, CMD_OPTIONAL,
155                 "run without authentication");
156
157     cmd_AddParm(cptr, "-smallht", CMD_FLAG, CMD_OPTIONAL,
158                 "use small hash tables");
159
160     cmd_AddParm(cptr, "-servers", CMD_LIST, CMD_OPTIONAL,
161                 "list of ubik database servers");
162
163     cmd_AddParm(cptr, "-ubikbuffers", CMD_SINGLE, CMD_OPTIONAL,
164                 "the number of ubik buffers");
165
166     cmd_AddParm(cptr, "-auditlog", CMD_SINGLE, CMD_OPTIONAL,
167                 "audit log path");
168
169     cmd_AddParm(cptr, "-p", CMD_SINGLE, CMD_OPTIONAL,
170                 "number of processes");
171
172     cmd_AddParm(cptr, "-rxbind", CMD_FLAG, CMD_OPTIONAL,
173                 "bind the Rx socket (primary interface only)");
174
175     cmd_AddParm(cptr, "-audit-interface", CMD_SINGLE, CMD_OPTIONAL,
176                 "audit interface (file or sysvmq)");
177
178     cmd_AddParm(cptr, "-transarc-logs", CMD_FLAG, CMD_OPTIONAL,
179                 "enable Transarc style logging");
180 }
181
182 int
183 argHandler(struct cmd_syndesc *as, void *arock)
184 {
185
186     /* globalConfPtr provides the handle for the configuration information */
187
188     /* database directory */
189     if (as->parms[0].items != 0) {
190         globalConfPtr->databaseDirectory = strdup(as->parms[0].items->data);
191         if (globalConfPtr->databaseDirectory == 0)
192             BUDB_EXIT(-1);
193     }
194
195     /* -cellservdb, cell configuration directory */
196     if (as->parms[1].items != 0) {
197         globalConfPtr->cellConfigdir = strdup(as->parms[1].items->data);
198         if (globalConfPtr->cellConfigdir == 0)
199             BUDB_EXIT(-1);
200
201         globalConfPtr->debugFlags |= DF_RECHECKNOAUTH;
202     }
203
204     /* truncate the database */
205     if (as->parms[2].items != 0)
206         truncateDatabase();
207
208     /* run without authentication */
209     if (as->parms[3].items != 0)
210         globalConfPtr->debugFlags |= DF_NOAUTH;
211
212     /* use small hash tables */
213     if (as->parms[4].items != 0)
214         globalConfPtr->debugFlags |= DF_SMALLHT;
215
216     /* user provided list of ubik database servers */
217     if (as->parms[5].items != 0)
218         parseServerList(as->parms[5].items);
219
220     /* user provided the number of ubik buffers    */
221     if (as->parms[6].items != 0)
222         ubik_nBuffers = atoi(as->parms[6].items->data);
223     else
224         ubik_nBuffers = 0;
225
226     /* param 7 (-auditlog) handled below */
227
228     /* user provided the number of threads    */
229     if (as->parms[8].items != 0) {
230         lwps = atoi(as->parms[8].items->data);
231         if (lwps > MAXLWP) {
232             printf ("Warning: '-p %d' is too big; using %d instead\n",
233                 lwps, MAXLWP);
234             lwps = MAXLWP;
235         }
236         if (lwps < MINLWP) {
237             printf ("Warning: '-p %d' is too small; using %d instead\n",
238                 lwps, MINLWP);
239             lwps = MINLWP;
240         }
241     }
242
243     /* user provided rxbind option    */
244     if (as->parms[9].items != 0) {
245         rxBind = 1;
246     }
247
248     /* -audit-interface */
249     if (as->parms[10].items != 0) {
250         char *interface = as->parms[10].items->data;
251
252         if (osi_audit_interface(interface)) {
253             printf("Invalid audit interface '%s'\n", interface);
254             BUDB_EXIT(-1);
255         }
256     }
257     /* -transarc-logs */
258     if (as->parms[11].items != 0) {
259         logopts.lopt_rotateOnOpen = 1;
260         logopts.lopt_rotateStyle = logRotate_old;
261     }
262
263     /* -auditlog */
264     /* needs to be after -audit-interface, so we osi_audit_interface
265      * before we osi_audit_file */
266     if (as->parms[7].items != 0) {
267         char *fileName = as->parms[7].items->data;
268
269         osi_audit_file(fileName);
270     }
271
272     return 0;
273 }
274
275 /* --- */
276
277 int
278 parseServerList(struct cmd_item *itemPtr)
279 {
280     struct cmd_item *save;
281     char **serverArgs;
282     char **ptr;
283     afs_int32 nservers = 0;
284     afs_int32 code = 0;
285
286     save = itemPtr;
287
288     /* compute number of servers in the list */
289     while (itemPtr) {
290         nservers++;
291         itemPtr = itemPtr->next;
292     }
293
294     LogDebug(3, "%d servers\n", nservers);
295
296     /* now can allocate the space for the server arguments */
297     serverArgs = malloc((nservers + 2) * sizeof(char *));
298     if (serverArgs == 0)
299         ERROR(-1);
300
301     ptr = serverArgs;
302     *ptr++ = "";
303     *ptr++ = "-servers";
304
305     /* now go through and construct the list of servers */
306     itemPtr = save;
307     while (itemPtr) {
308         *ptr++ = itemPtr->data;
309         itemPtr = itemPtr->next;
310     }
311
312     code =
313         ubik_ParseServerList(nservers + 2, serverArgs, &globalConfPtr->myHost,
314                              globalConfPtr->serverList);
315     if (code)
316         ERROR(code);
317
318     /* free space for the server args */
319     free(serverArgs);
320
321   error_exit:
322     return (code);
323 }
324
325 /* truncateDatabase
326  *      truncates just the database file.
327  */
328
329 int
330 truncateDatabase(void)
331 {
332     char *path;
333     afs_int32 code = 0;
334     int fd,r;
335
336     r = asprintf(&path, "%s%s%s",
337                  globalConfPtr->databaseDirectory,
338                  globalConfPtr->databaseName,
339                  globalConfPtr->databaseExtension);
340     if (r < 0 || path == NULL)
341         ERROR(-1);
342
343     fd = open(path, O_RDWR, 0755);
344     if (!fd) {
345         code = errno;
346     } else {
347         if (ftruncate(fd, 0) != 0) {
348             code = errno;
349         } else
350             close(fd);
351     }
352
353     free(path);
354
355   error_exit:
356     return (code);
357 }
358
359
360 /* --- */
361
362 #include "AFS_component_version_number.c"
363
364 int
365 main(int argc, char **argv)
366 {
367     char *whoami = argv[0];
368     char *dbNamePtr = 0;
369     struct afsconf_cell cellinfo_s;
370     struct afsconf_cell *cellinfo = NULL;
371     time_t currentTime;
372     afs_int32 code = 0;
373     char hoststr[16];
374     afs_uint32 host = ntohl(INADDR_ANY);
375     int r;
376
377     char  clones[MAXHOSTSPERCELL];
378
379     struct rx_service *tservice;
380     struct rx_securityClass **securityClasses;
381     afs_int32 numClasses;
382
383     extern int rx_stackSize;
384
385 #ifdef AFS_NT40_ENV
386     /* initialize winsock */
387     if (afs_winsockInit() < 0) {
388         ReportErrorEventAlt(AFSEVT_SVR_WINSOCK_INIT_FAILED, 0, argv[0], 0);
389         fprintf(stderr, "%s: Couldn't initialize winsock.\n", whoami);
390         exit(1);
391     }
392 #endif
393
394 #ifdef  AFS_AIX32_ENV
395     /*
396      * The following signal action for AIX is necessary so that in case of a
397      * crash (i.e. core is generated) we can include the user's data section
398      * in the core dump. Unfortunately, by default, only a partial core is
399      * generated which, in many cases, isn't too useful.
400      */
401     struct sigaction nsa;
402
403     sigemptyset(&nsa.sa_mask);
404     nsa.sa_handler = SIG_DFL;
405     nsa.sa_flags = SA_FULLDUMP;
406     sigaction(SIGSEGV, &nsa, NULL);
407     sigaction(SIGABRT, &nsa, NULL);
408 #endif
409
410     memset(&cellinfo_s, 0, sizeof(cellinfo_s));
411     memset(clones, 0, sizeof(clones));
412
413     memset(&logopts, 0, sizeof(logopts));
414     logopts.lopt_dest = logDest_file;
415     logopts.lopt_filename = AFSDIR_SERVER_BUDBLOG_FILEPATH;
416
417     osi_audit_init();
418     osi_audit(BUDB_StartEvent, 0, AUD_END);
419
420     initialize_BUDB_error_table();
421     initializeArgHandler();
422
423     /* Initialize dirpaths */
424     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
425 #ifdef AFS_NT40_ENV
426         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
427 #endif
428         afs_com_err(whoami, errno, "; Unable to obtain AFS server directory.");
429         exit(2);
430     }
431
432     memset(globalConfPtr, 0, sizeof(*globalConfPtr));
433
434     /* set default configuration values */
435     strcpy(dbDir, AFSDIR_SERVER_DB_DIRPATH);
436     strcat(dbDir, "/");
437     globalConfPtr->databaseDirectory = dbDir;
438     globalConfPtr->databaseName = DEFAULT_DBPREFIX;
439     strcpy(cellConfDir, AFSDIR_SERVER_ETC_DIRPATH);
440     globalConfPtr->cellConfigdir = cellConfDir;
441
442     srandom(1);
443
444 #ifdef AFS_PTHREAD_ENV
445     SetLogThreadNumProgram( rx_GetThreadNum );
446 #endif
447
448     /* process the user supplied args */
449     helpOption = 1;
450     code = cmd_Dispatch(argc, argv);
451     if (code)
452         ERROR(code);
453
454     /* exit if there was a help option */
455     if (helpOption)
456         BUDB_EXIT(0);
457
458     /* open the log file */
459     OpenLog(&logopts);
460
461     /* open the cell's configuration directory */
462     LogDebug(4, "opening %s\n", globalConfPtr->cellConfigdir);
463
464     BU_conf = afsconf_Open(globalConfPtr->cellConfigdir);
465     if (BU_conf == 0) {
466         LogError(code, "Failed getting cell info\n");
467         afs_com_err(whoami, code, "Failed getting cell info");
468         ERROR(BUDB_NOCELLS);
469     }
470
471     if (afsconf_CountKeys(BU_conf) == 0) {
472         LogError(0, "WARNING: No encryption keys found! "
473                     "All authenticated accesses will fail. "
474                     "Run akeyconvert or asetkey to import encryption keys.\n");
475     }
476
477     code = afsconf_GetLocalCell(BU_conf, lcell, sizeof(lcell));
478     if (code) {
479         LogError(0, "** Can't determine local cell name!\n");
480         ERROR(code);
481     }
482
483     if (globalConfPtr->myHost == 0) {
484         /* if user hasn't supplied a list of servers, extract server
485          * list from the cell's database
486          */
487
488         cellinfo = &cellinfo_s;
489
490         LogDebug(1, "Using server list from %s cell database.\n", lcell);
491
492         code = afsconf_GetExtendedCellInfo (BU_conf, lcell, 0, cellinfo,
493                                             clones);
494         if (code) {
495             LogError(0, "Can't read cell information\n");
496             ERROR(code);
497         }
498
499         code =
500             convert_cell_to_ubik(cellinfo, &globalConfPtr->myHost,
501                                  globalConfPtr->serverList);
502         if (code)
503             ERROR(code);
504     }
505
506     /* initialize audit user check */
507     osi_audit_set_user_check(BU_conf, BU_IsLocalRealmMatch);
508
509     /* initialize ubik */
510     ubik_SetClientSecurityProcs(afsconf_ClientAuth, afsconf_UpToDate, BU_conf);
511     ubik_SetServerSecurityProcs(afsconf_BuildServerSecurityObjects,
512                                 afsconf_CheckAuth, BU_conf);
513
514     if (ubik_nBuffers == 0)
515         ubik_nBuffers = 400;
516
517     LogError(0, "Will allocate %d ubik buffers\n", ubik_nBuffers);
518
519     r = asprintf(&dbNamePtr, "%s%s", globalConfPtr->databaseDirectory,
520                  globalConfPtr->databaseName);
521     if (r < 0 || dbNamePtr == 0)
522         ERROR(-1);
523
524     rx_SetRxDeadTime(60);       /* 60 seconds inactive before timeout */
525
526     if (rxBind) {
527         afs_int32 ccode;
528         if (AFSDIR_SERVER_NETRESTRICT_FILEPATH ||
529             AFSDIR_SERVER_NETINFO_FILEPATH) {
530             char reason[1024];
531             ccode = afsconf_ParseNetFiles(SHostAddrs, NULL, NULL,
532                                           ADDRSPERSITE, reason,
533                                           AFSDIR_SERVER_NETINFO_FILEPATH,
534                                           AFSDIR_SERVER_NETRESTRICT_FILEPATH);
535         } else
536         {
537             ccode = rx_getAllAddr(SHostAddrs, ADDRSPERSITE);
538         }
539         if (ccode == 1) {
540             host = SHostAddrs[0];
541         }
542     }
543
544     Log("buserver binding rx to %s:%d\n",
545         afs_inet_ntoa_r(host, hoststr), AFSCONF_BUDBPORT);
546     code = rx_InitHost(host, htons(AFSCONF_BUDBPORT));
547     if (code) {
548         LogError(code, "rx init failed\n");
549         afs_com_err(whoami, code, "rx init failed");
550         ERROR(code);
551     }
552
553     /* Disable jumbograms */
554     rx_SetNoJumbo();
555
556     if (cellinfo) {
557         code = ubik_ServerInitByInfo(globalConfPtr->myHost,
558                                      htons(AFSCONF_BUDBPORT),
559                                      cellinfo,
560                                      clones,
561                                      dbNamePtr,           /* name prefix */
562                                      &BU_dbase);
563     } else {
564         code = ubik_ServerInit(globalConfPtr->myHost, htons(AFSCONF_BUDBPORT),
565                                globalConfPtr->serverList,
566                                dbNamePtr,  /* name prefix */
567                                &BU_dbase);
568     }
569
570     if (code) {
571         LogError(code, "Ubik init failed\n");
572         afs_com_err(whoami, code, "Ubik init failed");
573         ERROR(code);
574     }
575
576     afsconf_BuildServerSecurityObjects(BU_conf, &securityClasses, &numClasses);
577
578     tservice =
579         rx_NewServiceHost(host, 0, BUDB_SERVICE, "BackupDatabase",
580                           securityClasses, numClasses, BUDB_ExecuteRequest);
581
582     if (tservice == (struct rx_service *)0) {
583         LogError(0, "Could not create backup database rx service\n");
584         printf("Could not create backup database rx service\n");
585         BUDB_EXIT(3);
586     }
587     rx_SetMinProcs(tservice, 1);
588     rx_SetMaxProcs(tservice, lwps);
589     rx_SetStackSize(tservice, 10000);
590
591     /* allow super users to manage RX statistics */
592     rx_SetRxStatUserOk(BU_rxstat_userok);
593
594     /* misc. initialization */
595
596     /* database dump synchronization */
597     memset(dumpSyncPtr, 0, sizeof(*dumpSyncPtr));
598     Lock_Init(&dumpSyncPtr->ds_lock);
599
600     rx_StartServer(0);          /* start handling requests */
601
602     code = InitProcs();
603     if (code)
604         ERROR(code);
605
606
607     currentTime = time(0);
608     LogError(0, "Ready to process requests at %s\n", ctime(&currentTime));
609
610     rx_ServerProc(NULL);                /* donate this LWP */
611
612   error_exit:
613     osi_audit(BUDB_FinishEvent, code, AUD_END);
614     return (code);
615 }
616
617 void
618 consistencyCheckDb(void)
619 {
620     /* do consistency checks on structure sizes */
621     if ((sizeof(struct htBlock) > BLOCKSIZE)
622         || (sizeof(struct vfBlock) > BLOCKSIZE)
623         || (sizeof(struct viBlock) > BLOCKSIZE)
624         || (sizeof(struct dBlock) > BLOCKSIZE)
625         || (sizeof(struct tBlock) > BLOCKSIZE)
626         ) {
627         fprintf(stderr, "Block layout error!\n");
628         BUDB_EXIT(99);
629     }
630 }
631
632 void
633 LogDebug(int level, char *fmt, ... )
634 {
635     if (debugging >= level) {
636         va_list ap;
637         va_start(ap, fmt);
638         vFSLog(fmt, ap);
639         va_end(ap);
640     }
641 }
642
643 void
644 Log(char *fmt, ...)
645 {
646     va_list ap;
647
648     va_start(ap, fmt);
649     vFSLog(fmt, ap);
650     va_end(ap);
651 }
652
653 void
654 LogError(long code, char *fmt, ... )
655 {
656     va_list ap;
657     int len;
658     char buffer[1024];
659
660     va_start(ap, fmt);
661     len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
662     va_end(ap);
663     if (len >= 1024) {
664         len = 1023;
665         buffer[1023] = '\0';
666     }
667     /* Be consistent with (unintentional?) historic behavior. */
668     if (code) {
669         FSLog("%s: %s\n", afs_error_table_name(code), afs_error_message(code));
670         WriteLogBuffer(buffer, len);
671     } else {
672         FSLog("%s", buffer);
673     }
674 }