Bug Summary

File:bozo/bosserver.c
Location:line 998, column 5
Description:Value stored to 'code' is never read

Annotated Source Code

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