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