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