src/bozo/bosserver.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 <afs/procmgmt.h>
  15 #include <roken.h>
  16
  17 #ifdef IGNORE_SOME_GCC_WARNINGS
  18 # pragma GCC diagnostic warning "-Wdeprecated-declarations"
  19 #endif
  20
  21 #ifdef HAVE_SYS_RESOURCE_H
  22 #include <sys/resource.h>
  23 #endif
  24
  25 #ifdef AFS_NT40_ENV
  26 #include <direct.h>
  27 #include <WINNT/afsevent.h>
  28 #endif /* AFS_NT40_ENV */
  29
  30 #include <rx/rx.h>
  31 #include <rx/xdr.h>
  32 #include <rx/rx_globals.h>
  33 #include <rx/rxkad.h>
  34 #include <rx/rxstat.h>
  35 #include <afs/keys.h>
  36 #include <afs/ktime.h>
  37 #include <afs/afsutil.h>
  38 #include <afs/fileutil.h>
  39 #include <afs/audit.h>
  40 #include <afs/cellconfig.h>
  41
  42 #if defined(AFS_SGI_ENV)
  43 #include <afs/afs_args.h>
  44 #endif
  45
  46 #include "bosint.h"
  47 #include "bnode.h"
  48 #include "bosprototypes.h"
  49
  50 #define BOZO_LWP_STACKSIZE      16000
  51 extern struct bnode_ops fsbnode_ops, dafsbnode_ops, ezbnode_ops, cronbnode_ops;
  52
  53 struct afsconf_dir *bozo_confdir = 0;   /* bozo configuration dir */
  54 static PROCESS bozo_pid;
  55 const char *bozo_fileName;
  56 FILE *bozo_logFile;
  57
  58 const char *DoCore;
  59 int DoLogging = 0;
  60 int DoSyslog = 0;
  61 const char *DoPidFiles = NULL;
  62 #ifndef AFS_NT40_ENV
  63 int DoSyslogFacility = LOG_DAEMON;
  64 #endif
  65 static afs_int32 nextRestart;
  66 static afs_int32 nextDay;
  67
  68 struct ktime bozo_nextRestartKT, bozo_nextDayKT;
  69 int bozo_newKTs;
  70 int rxBind = 0;
  71 int rxkadDisableDotCheck = 0;
  72
  73 #define ADDRSPERSITE 16         /* Same global is in rx/rx_user.c */
  74 afs_uint32 SHostAddrs[ADDRSPERSITE];
  75
  76 int bozo_isrestricted = 0;
  77 int bozo_restdisable = 0;
  78
  79 void
  80 bozo_insecureme(int sig)
  81 {
  82     signal(SIGFPE, bozo_insecureme);
  83     bozo_isrestricted = 0;
  84     bozo_restdisable = 1;
  85 }
  86
  87 struct bztemp {
  88     FILE *file;
  89 };
  90
  91 /* check whether caller is authorized to manage RX statistics */
  92 int
  93 bozo_rxstat_userok(struct rx_call *call)
  94 {
  95     return afsconf_SuperUser(bozo_confdir, call, NULL);
  96 }
  97
  98 /* restart bozo process */
  99 int
 100 bozo_ReBozo(void)
 101 {
 102 #ifdef AFS_NT40_ENV
 103     /* exit with restart code; SCM integrator process will restart bosserver */
 104     int status = BOSEXIT_RESTART;
 105
 106     /* if noauth flag is set, pass "-noauth" to new bosserver */
 107     if (afsconf_GetNoAuthFlag(bozo_confdir)) {
 108         status |= BOSEXIT_NOAUTH_FLAG;
 109     }
 110     /* if logging is on, pass "-log" to new bosserver */
 111     if (DoLogging) {
 112         status |= BOSEXIT_LOGGING_FLAG;
 113     }
 114     /* if rxbind is set, pass "-rxbind" to new bosserver */
 115     if (rxBind) {
 116         status |= BOSEXIT_RXBIND_FLAG;
 117     }
 118     exit(status);
 119 #else
 120     /* exec new bosserver process */
 121     char *argv[4];
 122     int i = 0;
 123
 124     argv[i] = (char *)AFSDIR_SERVER_BOSVR_FILEPATH;
 125     i++;
 126
 127     /* if noauth flag is set, pass "-noauth" to new bosserver */
 128     if (afsconf_GetNoAuthFlag(bozo_confdir)) {
 129         argv[i] = "-noauth";
 130         i++;
 131     }
 132     /* if logging is on, pass "-log" to new bosserver */
 133     if (DoLogging) {
 134         argv[i] = "-log";
 135         i++;
 136     }
 137     /* if rxbind is set, pass "-rxbind" to new bosserver */
 138     if (rxBind) {
 139         argv[i] = "-rxbind";
 140         i++;
 141     }
 142 #ifndef AFS_NT40_ENV
 143     /* if syslog logging is on, pass "-syslog" to new bosserver */
 144     if (DoSyslog) {
 145         char *arg = (char *)malloc(40); /* enough for -syslog=# */
 146         if (DoSyslogFacility != LOG_DAEMON) {
 147             snprintf(arg, 40, "-syslog=%d", DoSyslogFacility);
 148         } else {
 149             strcpy(arg, "-syslog");
 150         }
 151         argv[i] = arg;
 152         i++;
 153     }
 154 #endif
 155
 156     /* null-terminate argument list */
 157     argv[i] = NULL;
 158
 159     /* close random fd's */
 160     for (i = 3; i < 64; i++) {
 161         close(i);
 162     }
 163
 164     unlink(AFSDIR_SERVER_BOZRXBIND_FILEPATH);
 165
 166     execv(argv[0], argv);       /* should not return */
 167     _exit(1);
 168 #endif /* AFS_NT40_ENV */
 169 }
 170
 171 /* make sure a dir exists */
 172 static int
 173 MakeDir(const char *adir)
 174 {
 175     struct stat tstat;
 176     afs_int32 code;
 177     if (stat(adir, &tstat) < 0 || (tstat.st_mode & S_IFMT) != S_IFDIR) {
 178         int reqPerm;
 179         unlink(adir);
 180         reqPerm = GetRequiredDirPerm(adir);
 181         if (reqPerm == -1)
 182             reqPerm = 0777;
 183 #ifdef AFS_NT40_ENV
 184         /* underlying filesystem may not support directory protection */
 185         code = mkdir(adir);
 186 #else
 187         code = mkdir(adir, reqPerm);
 188 #endif
 189         return code;
 190     }
 191     return 0;
 192 }
 193
 194 /* create all the bozo dirs */
 195 static int
 196 CreateDirs(const char *coredir)
 197 {
 198     if ((!strncmp
 199          (AFSDIR_USR_DIRPATH, AFSDIR_CLIENT_ETC_DIRPATH,
 200           strlen(AFSDIR_USR_DIRPATH)))
 201         ||
 202         (!strncmp
 203          (AFSDIR_USR_DIRPATH, AFSDIR_SERVER_BIN_DIRPATH,
 204           strlen(AFSDIR_USR_DIRPATH)))) {
 205         MakeDir(AFSDIR_USR_DIRPATH);
 206     }
 207     if (!strncmp
 208         (AFSDIR_SERVER_AFS_DIRPATH, AFSDIR_SERVER_BIN_DIRPATH,
 209          strlen(AFSDIR_SERVER_AFS_DIRPATH))) {
 210         MakeDir(AFSDIR_SERVER_AFS_DIRPATH);
 211     }
 212     MakeDir(AFSDIR_SERVER_BIN_DIRPATH);
 213     MakeDir(AFSDIR_SERVER_ETC_DIRPATH);
 214     MakeDir(AFSDIR_SERVER_LOCAL_DIRPATH);
 215     MakeDir(AFSDIR_SERVER_DB_DIRPATH);
 216     MakeDir(AFSDIR_SERVER_LOGS_DIRPATH);
 217 #ifndef AFS_NT40_ENV
 218     if (!strncmp
 219         (AFSDIR_CLIENT_VICE_DIRPATH, AFSDIR_CLIENT_ETC_DIRPATH,
 220          strlen(AFSDIR_CLIENT_VICE_DIRPATH))) {
 221         MakeDir(AFSDIR_CLIENT_VICE_DIRPATH);
 222     }
 223     MakeDir(AFSDIR_CLIENT_ETC_DIRPATH);
 224
 225     symlink(AFSDIR_SERVER_THISCELL_FILEPATH, AFSDIR_CLIENT_THISCELL_FILEPATH);
 226     symlink(AFSDIR_SERVER_CELLSERVDB_FILEPATH,
 227             AFSDIR_CLIENT_CELLSERVDB_FILEPATH);
 228 #endif /* AFS_NT40_ENV */
 229     if (coredir)
 230         MakeDir(coredir);
 231     return 0;
 232 }
 233
 234 /* strip the \\n from the end of the line, if it is present */
 235 static int
 236 StripLine(char *abuffer)
 237 {
 238     char *tp;
 239
 240     tp = abuffer + strlen(abuffer);     /* starts off pointing at the null  */
 241     if (tp == abuffer)
 242         return 0;               /* null string, no last character to check */
 243     tp--;                       /* aim at last character */
 244     if (*tp == '\n')
 245         *tp = 0;
 246     return 0;
 247 }
 248
 249 /* write one bnode's worth of entry into the file */
 250 static int
 251 bzwrite(struct bnode *abnode, void *arock)
 252 {
 253     struct bztemp *at = (struct bztemp *)arock;
 254     int i;
 255     char tbuffer[BOZO_BSSIZE];
 256     afs_int32 code;
 257
 258     if (abnode->notifier)
 259         fprintf(at->file, "bnode %s %s %d %s\n", abnode->type->name,
 260                 abnode->name, abnode->fileGoal, abnode->notifier);
 261     else
 262         fprintf(at->file, "bnode %s %s %d\n", abnode->type->name,
 263                 abnode->name, abnode->fileGoal);
 264     for (i = 0;; i++) {
 265         code = bnode_GetParm(abnode, i, tbuffer, BOZO_BSSIZE);
 266         if (code) {
 267             if (code != BZDOM)
 268                 return code;
 269             break;
 270         }
 271         fprintf(at->file, "parm %s\n", tbuffer);
 272     }
 273     fprintf(at->file, "end\n");
 274     return 0;
 275 }
 276
 277 #define MAXPARMS    20
 278 int
 279 ReadBozoFile(char *aname)
 280 {
 281     FILE *tfile;
 282     char tbuffer[BOZO_BSSIZE];
 283     char *tp;
 284     char *instp, *typep, *notifier, *notp;
 285     afs_int32 code;
 286     afs_int32 ktmask, ktday, kthour, ktmin, ktsec;
 287     afs_int32 i, goal;
 288     struct bnode *tb;
 289     char *parms[MAXPARMS];
 290     char *thisparms[MAXPARMS];
 291     int rmode;
 292
 293     /* rename BozoInit to BosServer for the user */
 294     if (!aname) {
 295         /* if BozoInit exists and BosConfig doesn't, try a rename */
 296         if (access(AFSDIR_SERVER_BOZINIT_FILEPATH, 0) == 0
 297             && access(AFSDIR_SERVER_BOZCONF_FILEPATH, 0) != 0) {
 298             code =
 299                 renamefile(AFSDIR_SERVER_BOZINIT_FILEPATH,
 300                            AFSDIR_SERVER_BOZCONF_FILEPATH);
 301             if (code < 0)
 302                 perror("bosconfig rename");
 303         }
 304         if (access(AFSDIR_SERVER_BOZCONFNEW_FILEPATH, 0) == 0) {
 305             code =
 306                 renamefile(AFSDIR_SERVER_BOZCONFNEW_FILEPATH,
 307                            AFSDIR_SERVER_BOZCONF_FILEPATH);
 308             if (code < 0)
 309                 perror("bosconfig rename");
 310         }
 311     }
 312
 313     /* don't do server restarts by default */
 314     bozo_nextRestartKT.mask = KTIME_NEVER;
 315     bozo_nextRestartKT.hour = 0;
 316     bozo_nextRestartKT.min = 0;
 317     bozo_nextRestartKT.day = 0;
 318
 319     /* restart processes at 5am if their binaries have changed */
 320     bozo_nextDayKT.mask = KTIME_HOUR | KTIME_MIN;
 321     bozo_nextDayKT.hour = 5;
 322     bozo_nextDayKT.min = 0;
 323
 324     for (code = 0; code < MAXPARMS; code++)
 325         parms[code] = NULL;
 326     tfile = (FILE *) 0;
 327     if (!aname)
 328         aname = (char *)bozo_fileName;
 329     tfile = fopen(aname, "r");
 330     if (!tfile)
 331         return 0;               /* -1 */
 332     instp = malloc(BOZO_BSSIZE);
 333     typep = malloc(BOZO_BSSIZE);
 334     notifier = notp = malloc(BOZO_BSSIZE);
 335     while (1) {
 336         /* ok, read lines giving parms and such from the file */
 337         tp = fgets(tbuffer, sizeof(tbuffer), tfile);
 338         if (tp == (char *)0)
 339             break;              /* all done */
 340
 341         if (strncmp(tbuffer, "restarttime", 11) == 0) {
 342             code =
 343                 sscanf(tbuffer, "restarttime %d %d %d %d %d", &ktmask, &ktday,
 344                        &kthour, &ktmin, &ktsec);
 345             if (code != 5) {
 346                 code = -1;
 347                 goto fail;
 348             }
 349             /* otherwise we've read in the proper ktime structure; now assign
 350              * it and continue processing */
 351             bozo_nextRestartKT.mask = ktmask;
 352             bozo_nextRestartKT.day = ktday;
 353             bozo_nextRestartKT.hour = kthour;
 354             bozo_nextRestartKT.min = ktmin;
 355             bozo_nextRestartKT.sec = ktsec;
 356             continue;
 357         }
 358
 359         if (strncmp(tbuffer, "checkbintime", 12) == 0) {
 360             code =
 361                 sscanf(tbuffer, "checkbintime %d %d %d %d %d", &ktmask,
 362                        &ktday, &kthour, &ktmin, &ktsec);
 363             if (code != 5) {
 364                 code = -1;
 365                 goto fail;
 366             }
 367             /* otherwise we've read in the proper ktime structure; now assign
 368              * it and continue processing */
 369             bozo_nextDayKT.mask = ktmask;       /* time to restart the system */
 370             bozo_nextDayKT.day = ktday;
 371             bozo_nextDayKT.hour = kthour;
 372             bozo_nextDayKT.min = ktmin;
 373             bozo_nextDayKT.sec = ktsec;
 374             continue;
 375         }
 376
 377         if (strncmp(tbuffer, "restrictmode", 12) == 0) {
 378             code = sscanf(tbuffer, "restrictmode %d", &rmode);
 379             if (code != 1) {
 380                 code = -1;
 381                 goto fail;
 382             }
 383             if (rmode != 0 && rmode != 1) {
 384                 code = -1;
 385                 goto fail;
 386             }
 387             bozo_isrestricted = rmode;
 388             continue;
 389         }
 390
 391         if (strncmp("bnode", tbuffer, 5) != 0) {
 392             code = -1;
 393             goto fail;
 394         }
 395         notifier = notp;
 396         code =
 397             sscanf(tbuffer, "bnode %s %s %d %s", typep, instp, &goal,
 398                    notifier);
 399         if (code < 3) {
 400             code = -1;
 401             goto fail;
 402         } else if (code == 3)
 403             notifier = NULL;
 404
 405         memset(thisparms, 0, sizeof(thisparms));
 406
 407         for (i = 0; i < MAXPARMS; i++) {
 408             /* now read the parms, until we see an "end" line */
 409             tp = fgets(tbuffer, sizeof(tbuffer), tfile);
 410             if (!tp) {
 411                 code = -1;
 412                 goto fail;
 413             }
 414             StripLine(tbuffer);
 415             if (!strncmp(tbuffer, "end", 3))
 416                 break;
 417             if (strncmp(tbuffer, "parm ", 5)) {
 418                 code = -1;
 419                 goto fail;      /* no "parm " either */
 420             }
 421             if (!parms[i])      /* make sure there's space */
 422                 parms[i] = (char *)malloc(BOZO_BSSIZE);
 423             strcpy(parms[i], tbuffer + 5);      /* remember the parameter for later */
 424             thisparms[i] = parms[i];
 425         }
 426
 427         /* ok, we have the type and parms, now create the object */
 428         code =
 429             bnode_Create(typep, instp, &tb, thisparms[0], thisparms[1],
 430                          thisparms[2], thisparms[3], thisparms[4], notifier,
 431                          goal ? BSTAT_NORMAL : BSTAT_SHUTDOWN, 0);
 432         if (code)
 433             goto fail;
 434
 435         /* bnode created in 'temporarily shutdown' state;
 436          * check to see if we are supposed to run this guy,
 437          * and if so, start the process up */
 438         if (goal) {
 439             bnode_SetStat(tb, BSTAT_NORMAL);    /* set goal, taking effect immediately */
 440         } else {
 441             bnode_SetStat(tb, BSTAT_SHUTDOWN);
 442         }
 443     }
 444     /* all done */
 445     code = 0;
 446
 447   fail:
 448     if (instp)
 449         free(instp);
 450     if (typep)
 451         free(typep);
 452     for (i = 0; i < MAXPARMS; i++)
 453         if (parms[i])
 454             free(parms[i]);
 455     if (tfile)
 456         fclose(tfile);
 457     return code;
 458 }
 459
 460 /* write a new bozo file */
 461 int
 462 WriteBozoFile(char *aname)
 463 {
 464     FILE *tfile;
 465     char tbuffer[AFSDIR_PATH_MAX];
 466     afs_int32 code;
 467     struct bztemp btemp;
 468
 469     if (!aname)
 470         aname = (char *)bozo_fileName;
 471     strcpy(tbuffer, aname);
 472     strcat(tbuffer, ".NBZ");
 473     tfile = fopen(tbuffer, "w");
 474     if (!tfile)
 475         return -1;
 476     btemp.file = tfile;
 477
 478     fprintf(tfile, "restrictmode %d\n", bozo_isrestricted);
 479     fprintf(tfile, "restarttime %d %d %d %d %d\n", bozo_nextRestartKT.mask,
 480             bozo_nextRestartKT.day, bozo_nextRestartKT.hour,
 481             bozo_nextRestartKT.min, bozo_nextRestartKT.sec);
 482     fprintf(tfile, "checkbintime %d %d %d %d %d\n", bozo_nextDayKT.mask,
 483             bozo_nextDayKT.day, bozo_nextDayKT.hour, bozo_nextDayKT.min,
 484             bozo_nextDayKT.sec);
 485     code = bnode_ApplyInstance(bzwrite, &btemp);
 486     if (code || (code = ferror(tfile))) {       /* something went wrong */
 487         fclose(tfile);
 488         unlink(tbuffer);
 489         return code;
 490     }
 491     /* close the file, check for errors and snap new file into place */
 492     if (fclose(tfile) == EOF) {
 493         unlink(tbuffer);
 494         return -1;
 495     }
 496     code = renamefile(tbuffer, aname);
 497     if (code) {
 498         unlink(tbuffer);
 499         return -1;
 500     }
 501     return 0;
 502 }
 503
 504 static int
 505 bdrestart(struct bnode *abnode, void *arock)
 506 {
 507     afs_int32 code;
 508
 509     if (abnode->fileGoal != BSTAT_NORMAL || abnode->goal != BSTAT_NORMAL)
 510         return 0;               /* don't restart stopped bnodes */
 511     bnode_Hold(abnode);
 512     code = bnode_RestartP(abnode);
 513     if (code) {
 514         /* restart the dude */
 515         bnode_SetStat(abnode, BSTAT_SHUTDOWN);
 516         bnode_WaitStatus(abnode, BSTAT_SHUTDOWN);
 517         bnode_SetStat(abnode, BSTAT_NORMAL);
 518     }
 519     bnode_Release(abnode);
 520     return 0;                   /* keep trying all bnodes */
 521 }
 522
 523 #define BOZO_MINSKIP 3600       /* minimum to advance clock */
 524 /* lwp to handle system restarts */
 525 static void *
 526 BozoDaemon(void *unused)
 527 {
 528     afs_int32 now;
 529
 530     /* now initialize the values */
 531     bozo_newKTs = 1;
 532     while (1) {
 533         IOMGR_Sleep(60);
 534         now = FT_ApproxTime();
 535
 536         if (bozo_restdisable) {
 537             bozo_Log("Restricted mode disabled by signal\n");
 538             bozo_restdisable = 0;
 539         }
 540
 541         if (bozo_newKTs) {      /* need to recompute restart times */
 542             bozo_newKTs = 0;    /* done for a while */
 543             nextRestart = ktime_next(&bozo_nextRestartKT, BOZO_MINSKIP);
 544             nextDay = ktime_next(&bozo_nextDayKT, BOZO_MINSKIP);
 545         }
 546
 547         /* see if we should do a restart */
 548         if (now > nextRestart) {
 549             SBOZO_ReBozo(0);    /* doesn't come back */
 550         }
 551
 552         /* see if we should restart a server */
 553         if (now > nextDay) {
 554             nextDay = ktime_next(&bozo_nextDayKT, BOZO_MINSKIP);
 555
 556             /* call the bnode restartp function, and restart all that require it */
 557             bnode_ApplyInstance(bdrestart, 0);
 558         }
 559     }
 560     return NULL;
 561 }
 562
 563 #ifdef AFS_AIX32_ENV
 564 static int
 565 tweak_config(void)
 566 {
 567     FILE *f;
 568     char c[80];
 569     int s, sb_max, ipfragttl;
 570
 571     sb_max = 131072;
 572     ipfragttl = 20;
 573     f = popen("/usr/sbin/no -o sb_max", "r");
 574     s = fscanf(f, "sb_max = %d", &sb_max);
 575     fclose(f);
 576     if (s < 1)
 577         return;
 578     f = popen("/usr/sbin/no -o ipfragttl", "r");
 579     s = fscanf(f, "ipfragttl = %d", &ipfragttl);
 580     fclose(f);
 581     if (s < 1)
 582         ipfragttl = 20;
 583
 584     if (sb_max < 131072)
 585         sb_max = 131072;
 586     if (ipfragttl > 20)
 587         ipfragttl = 20;
 588
 589     sprintf(c, "/usr/sbin/no -o sb_max=%d -o ipfragttl=%d", sb_max,
 590             ipfragttl);
 591     f = popen(c, "r");
 592     fclose(f);
 593 }
 594 #endif
 595
 596 #if 0
 597 /*
 598  * This routine causes the calling process to go into the background and
 599  * to lose its controlling tty.
 600  *
 601  * It does not close or otherwise alter the standard file descriptors.
 602  *
 603  * It writes warning messages to the standard error output if certain
 604  * fundamental errors occur.
 605  *
 606  * This routine requires
 607  *
 608  * #include <sys/types.h>
 609  * #include <sys/stat.h>
 610  * #include <fcntl.h>
 611  * #include <unistd.h>
 612  * #include <stdlib.h>
 613  *
 614  * and has been tested on:
 615  *
 616  * AIX 4.2
 617  * Digital Unix 4.0D
 618  * HP-UX 11.0
 619  * IRIX 6.5
 620  * Linux 2.1.125
 621  * Solaris 2.5
 622  * Solaris 2.6
 623  */
 624
 625 #ifndef AFS_NT40_ENV
 626 static void
 627 background(void)
 628 {
 629     /*
 630      * A process is a process group leader if its process ID
 631      * (getpid()) and its process group ID (getpgrp()) are the same.
 632      */
 633
 634     /*
 635      * To create a new session (and thereby lose our controlling
 636      * terminal) we cannot be a process group leader.
 637      *
 638      * To guarantee we are not a process group leader, we fork and
 639      * let the parent process exit.
 640      */
 641
 642     if (getpid() == getpgrp()) {
 643         pid_t pid;
 644         pid = fork();
 645         switch (pid) {
 646         case -1:
 647             abort();            /* leave footprints */
 648             break;
 649         case 0:         /* child */
 650             break;
 651         default:                /* parent */
 652             exit(0);
 653             break;
 654         }
 655     }
 656
 657     /*
 658      * By here, we are not a process group leader, so we can make a
 659      * new session and become the session leader.
 660      */
 661
 662     {
 663         pid_t sid = setsid();
 664
 665         if (sid == -1) {
 666             static char err[] = "bosserver: WARNING: setsid() failed\n";
 667             write(STDERR_FILENO, err, sizeof err - 1);
 668         }
 669     }
 670
 671     /*
 672      * Once we create a new session, the current process is a
 673      * session leader without a controlling tty.
 674      *
 675      * On some systems, the first tty device the session leader
 676      * opens automatically becomes the controlling tty for the
 677      * session.
 678      *
 679      * So, to guarantee we do not acquire a controlling tty, we fork
 680      * and let the parent process exit.  The child process is not a
 681      * session leader, and so it will not acquire a controlling tty
 682      * even if it should happen to open a tty device.
 683      */
 684
 685     if (getpid() == getpgrp()) {
 686         pid_t pid;
 687         pid = fork();
 688         switch (pid) {
 689         case -1:
 690             abort();            /* leave footprints */
 691             break;
 692         case 0:         /* child */
 693             break;
 694         default:                /* parent */
 695             exit(0);
 696             break;
 697         }
 698     }
 699
 700     /*
 701      * check that we no longer have a controlling tty
 702      */
 703
 704     {
 705         int fd;
 706
 707         fd = open("/dev/tty", O_RDONLY);
 708
 709         if (fd >= 0) {
 710             static char err[] =
 711                 "bosserver: WARNING: /dev/tty still attached\n";
 712             close(fd);
 713             write(STDERR_FILENO, err, sizeof err - 1);
 714         }
 715     }
 716 }
 717 #endif /* ! AFS_NT40_ENV */
 718 #endif
 719
 720 static char *
 721 make_pid_filename(char *ainst, char *aname)
 722 {
 723     char *buffer = NULL;
 724     int length;
 725
 726     length = strlen(DoPidFiles) + strlen(ainst) + 6;
 727     if (aname && *aname) {
 728         length += strlen(aname) + 1;
 729     }
 730     buffer = malloc(length * sizeof(char));
 731     if (!buffer) {
 732         if (aname) {
 733             bozo_Log("Failed to alloc pid filename buffer for %s.%s.\n",
 734                      ainst, aname);
 735         } else {
 736             bozo_Log("Failed to alloc pid filename buffer for %s.\n", ainst);
 737         }
 738     } else {
 739         if (aname && *aname) {
 740             snprintf(buffer, length, "%s/%s.%s.pid", DoPidFiles, ainst,
 741                      aname);
 742         } else {
 743             snprintf(buffer, length, "%s/%s.pid", DoPidFiles, ainst);
 744         }
 745     }
 746     return buffer;
 747 }
 748
 749 /**
 750  * Write a file containing the pid of the named process.
 751  *
 752  * @param ainst instance name
 753  * @param aname sub-process name of the instance, may be null
 754  * @param apid  process id of the newly started process
 755  *
 756  * @returns status
 757  */
 758 int
 759 bozo_CreatePidFile(char *ainst, char *aname, pid_t apid)
 760 {
 761     int code = 0;
 762     char *pidfile = NULL;
 763     FILE *fp;
 764
 765     pidfile = make_pid_filename(ainst, aname);
 766     if (!pidfile) {
 767         return ENOMEM;
 768     }
 769     if ((fp = fopen(pidfile, "w")) == NULL) {
 770         bozo_Log("Failed to open pidfile %s; errno=%d\n", pidfile, errno);
 771         free(pidfile);
 772         return errno;
 773     }
 774     if (fprintf(fp, "%ld\n", afs_printable_int32_ld(apid)) < 0) {
 775         code = errno;
 776     }
 777     if (fclose(fp) != 0) {
 778         code = errno;
 779     }
 780     free(pidfile);
 781     return code;
 782 }
 783
 784 /**
 785  * Clean a pid file for a process which just exited.
 786  *
 787  * @param ainst instance name
 788  * @param aname sub-process name of the instance, may be null
 789  *
 790  * @returns status
 791  */
 792 int
 793 bozo_DeletePidFile(char *ainst, char *aname)
 794 {
 795     char *pidfile = NULL;
 796     pidfile = make_pid_filename(ainst, aname);
 797     if (pidfile) {
 798         unlink(pidfile);
 799         free(pidfile);
 800     }
 801     return 0;
 802 }
 803
 804 /**
 805  * Create the rxbind file of this bosserver.
 806  *
 807  * @param host  bind address of this server
 808  *
 809  * @returns status
 810  */
 811 void
 812 bozo_CreateRxBindFile(afs_uint32 host)
 813 {
 814     char buffer[16];
 815     FILE *fp;
 816
 817     if (host == htonl(INADDR_ANY)) {
 818         host = htonl(0x7f000001);
 819     }
 820
 821     afs_inet_ntoa_r(host, buffer);
 822     bozo_Log("Listening on %s:%d\n", buffer, AFSCONF_NANNYPORT);
 823     if ((fp = fopen(AFSDIR_SERVER_BOZRXBIND_FILEPATH, "w")) == NULL) {
 824         bozo_Log("Unable to open rxbind address file: %s, code=%d\n",
 825                  AFSDIR_SERVER_BOZRXBIND_FILEPATH, errno);
 826     } else {
 827         fprintf(fp, "%s\n", buffer);
 828         fclose(fp);
 829     }
 830 }
 831
 832 /* start a process and monitor it */
 833
 834 #include "AFS_component_version_number.c"
 835
 836 int
 837 main(int argc, char **argv, char **envp)
 838 {
 839     struct rx_service *tservice;
 840     afs_int32 code;
 841     struct afsconf_dir *tdir;
 842     int noAuth = 0;
 843     int i;
 844     char namebuf[AFSDIR_PATH_MAX];
 845     int rxMaxMTU = -1;
 846     afs_uint32 host = htonl(INADDR_ANY);
 847     char *auditFileName = NULL;
 848     struct rx_securityClass **securityClasses;
 849     afs_int32 numClasses;
 850 #ifndef AFS_NT40_ENV
 851     int nofork = 0;
 852     struct stat sb;
 853 #endif
 854 #ifdef  AFS_AIX32_ENV
 855     struct sigaction nsa;
 856
 857     /* for some reason, this permits user-mode RX to run a lot faster.
 858      * we do it here in the bosserver, so we don't have to do it
 859      * individually in each server.
 860      */
 861     tweak_config();
 862
 863     /*
 864      * The following signal action for AIX is necessary so that in case of a
 865      * crash (i.e. core is generated) we can include the user's data section
 866      * in the core dump. Unfortunately, by default, only a partial core is
 867      * generated which, in many cases, isn't too useful.
 868      */
 869     sigemptyset(&nsa.sa_mask);
 870     nsa.sa_handler = SIG_DFL;
 871     nsa.sa_flags = SA_FULLDUMP;
 872     sigaction(SIGSEGV, &nsa, NULL);
 873     sigaction(SIGABRT, &nsa, NULL);
 874 #endif
 875     osi_audit_init();
 876     signal(SIGFPE, bozo_insecureme);
 877
 878 #ifdef AFS_NT40_ENV
 879     /* Initialize winsock */
 880     if (afs_winsockInit() < 0) {
 881         ReportErrorEventAlt(AFSEVT_SVR_WINSOCK_INIT_FAILED, 0, argv[0], 0);
 882         fprintf(stderr, "%s: Couldn't initialize winsock.\n", argv[0]);
 883         exit(2);
 884     }
 885 #endif
 886
 887     /* Initialize dirpaths */
 888     if (!(initAFSDirPath() & AFSDIR_SERVER_PATHS_OK)) {
 889 #ifdef AFS_NT40_ENV
 890         ReportErrorEventAlt(AFSEVT_SVR_NO_INSTALL_DIR, 0, argv[0], 0);
 891 #endif
 892         fprintf(stderr, "%s: Unable to obtain AFS server directory.\n",
 893                 argv[0]);
 894         exit(2);
 895     }
 896
 897     /* some path inits */
 898     bozo_fileName = AFSDIR_SERVER_BOZCONF_FILEPATH;
 899     DoCore = AFSDIR_SERVER_LOGS_DIRPATH;
 900
 901     /* initialize the list of dirpaths that the bosserver has
 902      * an interest in monitoring */
 903     initBosEntryStats();
 904
 905 #if defined(AFS_SGI_ENV)
 906     /* offer some protection if AFS isn't loaded */
 907     if (syscall(AFS_SYSCALL, AFSOP_ENDLOG) < 0 && errno == ENOPKG) {
 908         printf("bosserver: AFS doesn't appear to be configured in O.S..\n");
 909         exit(1);
 910     }
 911 #endif
 912
 913     /* parse cmd line */
 914     for (code = 1; code < argc; code++) {
 915         if (strcmp(argv[code], "-noauth") == 0) {
 916             /* set noauth flag */
 917             noAuth = 1;
 918         } else if (strcmp(argv[code], "-log") == 0) {
 919             /* set extra logging flag */
 920             DoLogging = 1;
 921         }
 922 #ifndef AFS_NT40_ENV
 923         else if (strcmp(argv[code], "-syslog") == 0) {
 924             /* set syslog logging flag */
 925             DoSyslog = 1;
 926         } else if (strncmp(argv[code], "-syslog=", 8) == 0) {
 927             DoSyslog = 1;
 928             DoSyslogFacility = atoi(argv[code] + 8);
 929         } else if (strncmp(argv[code], "-cores=", 7) == 0) {
 930             if (strcmp((argv[code]+7), "none") == 0)
 931                 DoCore = 0;
 932             else
 933                 DoCore = (argv[code]+7);
 934         } else if (strcmp(argv[code], "-nofork") == 0) {
 935             nofork = 1;
 936         }
 937 #endif
 938         else if (strcmp(argv[code], "-enable_peer_stats") == 0) {
 939             rx_enablePeerRPCStats();
 940         } else if (strcmp(argv[code], "-enable_process_stats") == 0) {
 941             rx_enableProcessRPCStats();
 942         }
 943         else if (strcmp(argv[code], "-restricted") == 0) {
 944             bozo_isrestricted = 1;
 945         }
 946         else if (strcmp(argv[code], "-rxbind") == 0) {
 947             rxBind = 1;
 948         }
 949         else if (strcmp(argv[code], "-allow-dotted-principals") == 0) {
 950             rxkadDisableDotCheck = 1;
 951         }
 952         else if (!strcmp(argv[code], "-rxmaxmtu")) {
 953             if ((code + 1) >= argc) {
 954                 fprintf(stderr, "missing argument for -rxmaxmtu\n");
 955                 exit(1);
 956             }
 957             rxMaxMTU = atoi(argv[++code]);
 958             if ((rxMaxMTU < RX_MIN_PACKET_SIZE) ||
 959                 (rxMaxMTU > RX_MAX_PACKET_DATA_SIZE)) {
 960                 printf("rxMaxMTU %d invalid; must be between %d-%" AFS_SIZET_FMT "\n",
 961                         rxMaxMTU, RX_MIN_PACKET_SIZE,
 962                         RX_MAX_PACKET_DATA_SIZE);
 963                 exit(1);
 964             }
 965         }
 966         else if (strcmp(argv[code], "-auditlog") == 0) {
 967             auditFileName = argv[++code];
 968
 969         } else if (strcmp(argv[code], "-audit-interface") == 0) {
 970             char *interface = argv[++code];
 971
 972             if (osi_audit_interface(interface)) {
 973                 printf("Invalid audit interface '%s'\n", interface);
 974                 exit(1);
 975             }
 976         } else if (strncmp(argv[code], "-pidfiles=", 10) == 0) {
 977             DoPidFiles = (argv[code]+10);
 978         } else if (strncmp(argv[code], "-pidfiles", 9) == 0) {
 979             DoPidFiles = AFSDIR_BOSCONFIG_DIR;
 980         }
 981         else {
 982
 983             /* hack to support help flag */
 984
 985 #ifndef AFS_NT40_ENV
 986             printf("Usage: bosserver [-noauth] [-log] "
 987                    "[-auditlog <log path>] "
 988                    "[-audit-interafce <file|sysvmq> (default is file)] "
 989                    "[-rxmaxmtu <bytes>] [-rxbind] [-allow-dotted-principals]"
 990                    "[-syslog[=FACILITY]] "
 991                    "[-enable_peer_stats] [-enable_process_stats] "
 992                    "[-cores=<none|path>] \n"
 993                    "[-pidfiles[=path]] "
 994                    "[-nofork] " "[-help]\n");
 995 #else
 996             printf("Usage: bosserver [-noauth] [-log] "
 997                    "[-auditlog <log path>] "
 998                    "[-audit-interafce <file|sysvmq> (default is file)] "
 999                    "[-rxmaxmtu <bytes>] [-rxbind] [-allow-dotted-principals]"
1000                    "[-enable_peer_stats] [-enable_process_stats] "
1001                    "[-cores=<none|path>] \n"
1002                    "[-pidfiles[=path]] "
1003                    "[-help]\n");
1004 #endif
1005             fflush(stdout);
1006
1007             exit(0);
1008         }
1009     }
1010     if (auditFileName) {
1011         osi_audit_file(auditFileName);
1012     }
1013
1014 #ifndef AFS_NT40_ENV
1015     if (geteuid() != 0) {
1016         printf("bosserver: must be run as root.\n");
1017         exit(1);
1018     }
1019 #endif
1020
1021     code = bnode_Init();
1022     if (code) {
1023         printf("bosserver: could not init bnode package, code %d\n", code);
1024         exit(1);
1025     }
1026
1027     bnode_Register("fs", &fsbnode_ops, 3);
1028     bnode_Register("dafs", &dafsbnode_ops, 4);
1029     bnode_Register("simple", &ezbnode_ops, 1);
1030     bnode_Register("cron", &cronbnode_ops, 2);
1031
1032     /* create useful dirs */
1033     CreateDirs(DoCore);
1034
1035     /* chdir to AFS log directory */
1036     if (DoCore)
1037         chdir(DoCore);
1038     else
1039         chdir(AFSDIR_SERVER_LOGS_DIRPATH);
1040
1041 #if 0
1042     fputs(AFS_GOVERNMENT_MESSAGE, stdout);
1043     fflush(stdout);
1044 #endif
1045
1046     /* go into the background and remove our controlling tty, close open
1047        file desriptors
1048      */
1049
1050 #ifndef AFS_NT40_ENV
1051     if (!nofork)
1052         daemon(1, 0);
1053 #endif /* ! AFS_NT40_ENV */
1054
1055     if ((!DoSyslog)
1056 #ifndef AFS_NT40_ENV
1057         && ((lstat(AFSDIR_BOZLOG_FILE, &sb) == 0) &&
1058         !(S_ISFIFO(sb.st_mode)))
1059 #endif
1060         ) {
1061         strcpy(namebuf, AFSDIR_BOZLOG_FILE);
1062         strcat(namebuf, ".old");
1063         renamefile(AFSDIR_BOZLOG_FILE, namebuf);        /* try rename first */
1064         bozo_logFile = fopen(AFSDIR_BOZLOG_FILE, "a");
1065         if (!bozo_logFile) {
1066             printf("bosserver: can't initialize log file (%s).\n",
1067                    AFSDIR_SERVER_BOZLOG_FILEPATH);
1068             exit(1);
1069         }
1070         /* keep log closed normally, so can be removed */
1071         fclose(bozo_logFile);
1072     } else {
1073 #ifndef AFS_NT40_ENV
1074         openlog("bosserver", LOG_PID, DoSyslogFacility);
1075 #endif
1076     }
1077
1078 #if defined(RLIMIT_CORE) && defined(HAVE_GETRLIMIT)
1079     {
1080       struct rlimit rlp;
1081       getrlimit(RLIMIT_CORE, &rlp);
1082       if (!DoCore)
1083           rlp.rlim_cur = 0;
1084       else
1085           rlp.rlim_max = rlp.rlim_cur = RLIM_INFINITY;
1086       setrlimit(RLIMIT_CORE, &rlp);
1087       getrlimit(RLIMIT_CORE, &rlp);
1088       bozo_Log("Core limits now %d %d\n",(int)rlp.rlim_cur,(int)rlp.rlim_max);
1089     }
1090 #endif
1091
1092     /* Write current state of directory permissions to log file */
1093     DirAccessOK();
1094
1095     if (rxBind) {
1096         afs_int32 ccode;
1097         if (AFSDIR_SERVER_NETRESTRICT_FILEPATH ||
1098             AFSDIR_SERVER_NETINFO_FILEPATH) {
1099             char reason[1024];
1100             ccode = parseNetFiles(SHostAddrs, NULL, NULL,
1101                                   ADDRSPERSITE, reason,
1102                                   AFSDIR_SERVER_NETINFO_FILEPATH,
1103                                   AFSDIR_SERVER_NETRESTRICT_FILEPATH);
1104         } else {
1105             ccode = rx_getAllAddr(SHostAddrs, ADDRSPERSITE);
1106         }
1107         if (ccode == 1)
1108             host = SHostAddrs[0];
1109     }
1110
1111     for (i = 0; i < 10; i++) {
1112         if (rxBind) {
1113             code = rx_InitHost(host, htons(AFSCONF_NANNYPORT));
1114         } else {
1115             code = rx_Init(htons(AFSCONF_NANNYPORT));
1116         }
1117         if (code) {
1118             bozo_Log("can't initialize rx: code=%d\n", code);
1119             sleep(3);
1120         } else
1121             break;
1122     }
1123     if (i >= 10) {
1124         bozo_Log("Bos giving up, can't initialize rx\n");
1125         exit(code);
1126     }
1127
1128     code = LWP_CreateProcess(BozoDaemon, BOZO_LWP_STACKSIZE, /* priority */ 1,
1129                              /* param */ NULL , "bozo-the-clown",
1130                              &bozo_pid);
1131
1132     /* try to read the key from the config file */
1133     tdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH);
1134     if (!tdir) {
1135         /* try to create local cell config file */
1136         struct afsconf_cell tcell;
1137         strcpy(tcell.name, "localcell");
1138         tcell.numServers = 1;
1139         code = gethostname(tcell.hostName[0], MAXHOSTCHARS);
1140         if (code) {
1141             bozo_Log("failed to get hostname, code %d\n", errno);
1142             exit(1);
1143         }
1144         if (tcell.hostName[0][0] == 0) {
1145             bozo_Log("host name not set, can't start\n");
1146             bozo_Log("try the 'hostname' command\n");
1147             exit(1);
1148         }
1149         memset(tcell.hostAddr, 0, sizeof(tcell.hostAddr));      /* not computed */
1150         code =
1151             afsconf_SetCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATH,
1152                                 &tcell);
1153         if (code) {
1154             bozo_Log
1155                 ("could not create cell database in '%s' (code %d), quitting\n",
1156                  AFSDIR_SERVER_ETC_DIRPATH, code);
1157             exit(1);
1158         }
1159         tdir = afsconf_Open(AFSDIR_SERVER_ETC_DIRPATH);
1160         if (!tdir) {
1161             bozo_Log
1162                 ("failed to open newly-created cell database, quitting\n");
1163             exit(1);
1164         }
1165     }
1166
1167     /* read init file, starting up programs */
1168     if ((code = ReadBozoFile(0))) {
1169         bozo_Log
1170             ("bosserver: Something is wrong (%d) with the bos configuration file %s; aborting\n",
1171              code, AFSDIR_SERVER_BOZCONF_FILEPATH);
1172         exit(code);
1173     }
1174
1175     bozo_CreateRxBindFile(host);        /* for local scripts */
1176
1177     /* opened the cell databse */
1178     bozo_confdir = tdir;
1179
1180     /* allow super users to manage RX statistics */
1181     rx_SetRxStatUserOk(bozo_rxstat_userok);
1182
1183     afsconf_SetNoAuthFlag(tdir, noAuth);
1184     afsconf_BuildServerSecurityObjects(tdir, &securityClasses, &numClasses);
1185
1186     if (DoPidFiles) {
1187         bozo_CreatePidFile("bosserver", NULL, getpid());
1188     }
1189
1190     /* Disable jumbograms */
1191     rx_SetNoJumbo();
1192
1193     if (rxMaxMTU != -1) {
1194         rx_SetMaxMTU(rxMaxMTU);
1195     }
1196
1197     tservice = rx_NewServiceHost(host, 0, /* service id */ 1,
1198                                  "bozo", securityClasses, numClasses,
1199                                  BOZO_ExecuteRequest);
1200     rx_SetMinProcs(tservice, 2);
1201     rx_SetMaxProcs(tservice, 4);
1202     rx_SetStackSize(tservice, BOZO_LWP_STACKSIZE);      /* so gethostbyname works (in cell stuff) */
1203     if (rxkadDisableDotCheck) {
1204         rx_SetSecurityConfiguration(tservice, RXS_CONFIG_FLAGS,
1205                                     (void *)RXS_CONFIG_FLAGS_DISABLE_DOTCHECK);
1206     }
1207
1208     tservice =
1209         rx_NewServiceHost(host, 0, RX_STATS_SERVICE_ID, "rpcstats",
1210                           securityClasses, numClasses, RXSTATS_ExecuteRequest);
1211     rx_SetMinProcs(tservice, 2);
1212     rx_SetMaxProcs(tservice, 4);
1213     rx_StartServer(1);          /* donate this process */
1214     return 0;
1215 }
1216
1217 void
1218 bozo_Log(char *format, ...)
1219 {
1220     char tdate[27];
1221     time_t myTime;
1222     va_list ap;
1223
1224     va_start(ap, format);
1225
1226     if (DoSyslog) {
1227 #ifndef AFS_NT40_ENV
1228         vsyslog(LOG_INFO, format, ap);
1229 #endif
1230     } else {
1231         myTime = time(0);
1232         strcpy(tdate, ctime(&myTime));  /* copy out of static area asap */
1233         tdate[24] = ':';
1234
1235         /* log normally closed, so can be removed */
1236
1237         bozo_logFile = fopen(AFSDIR_SERVER_BOZLOG_FILEPATH, "a");
1238         if (bozo_logFile == NULL) {
1239             printf("bosserver: WARNING: problem with %s\n",
1240                    AFSDIR_SERVER_BOZLOG_FILEPATH);
1241             printf("%s ", tdate);
1242             vprintf(format, ap);
1243             fflush(stdout);
1244         } else {
1245             fprintf(bozo_logFile, "%s ", tdate);
1246             vfprintf(bozo_logFile, format, ap);
1247
1248             /* close so rm BosLog works */
1249             fclose(bozo_logFile);
1250         }
1251     }
1252 }