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