Bug Summary

File:bozo/bosoprocs.c
Location:line 1012, 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 <roken.h>
15
16#ifdef AFS_NT40_ENV
17#include <sys/utime.h>
18#endif /* AFS_NT40_ENV */
19
20#include <rx/xdr.h>
21#include <rx/rx.h>
22#include <rx/rxkad.h>
23#include <afs/cellconfig.h>
24#include <afs/keys.h>
25#include <afs/afsutil.h>
26#include <afs/fileutil.h>
27#include <afs/ktime.h>
28#include <afs/audit.h>
29#include <afs/kautils.h>
30
31#include "bnode.h"
32#include "bosint.h"
33#include "bosprototypes.h"
34
35extern struct ktime bozo_nextRestartKT, bozo_nextDayKT;
36
37extern struct afsconf_dir *bozo_confdir;
38extern int bozo_newKTs;
39extern int DoLogging;
40extern int bozo_isrestricted;
41
42afs_int32
43SBOZO_GetRestartTime(struct rx_call *acall, afs_int32 atype, struct bozo_netKTime *aktime)
44{
45 afs_int32 code;
46
47 code = 0; /* assume success */
48 switch (atype) {
49 case 1:
50 memcpy(aktime, &bozo_nextRestartKT, sizeof(struct ktime));
51 break;
52
53 case 2:
54 memcpy(aktime, &bozo_nextDayKT, sizeof(struct ktime));
55 break;
56
57 default:
58 code = BZDOM(39429L);
59 break;
60 }
61
62 return code;
63}
64
65afs_int32
66SBOZO_SetRestartTime(struct rx_call *acall, afs_int32 atype, struct bozo_netKTime *aktime)
67{
68 afs_int32 code;
69 char caller[MAXKTCNAMELEN64];
70
71 /* check for proper permissions */
72 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
73 code = BZACCESS(39430L);
74 goto fail;
75 }
76 if (DoLogging)
77 bozo_Log("%s is executing SetRestartTime\n", caller);
78
79 code = 0; /* assume success */
80 switch (atype) {
81 case 1:
82 memcpy(&bozo_nextRestartKT, aktime, sizeof(struct ktime));
83 break;
84
85 case 2:
86 memcpy(&bozo_nextDayKT, aktime, sizeof(struct ktime));
87 break;
88
89 default:
90 code = BZDOM(39429L);
91 break;
92 }
93
94 if (code == 0) {
95 /* try to update the bozo init file */
96 code = WriteBozoFile(0);
97 bozo_newKTs = 1;
98 }
99
100 fail:
101 osi_auditU(acall, BOS_SetRestartEvent"AFS_BOS_SetReSt", code, AUD_END0);
102 return code;
103}
104
105afs_int32
106SBOZO_Exec(struct rx_call *acall, char *acmd)
107{
108
109 char caller[MAXKTCNAMELEN64];
110 int code;
111
112 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
113 code = BZACCESS(39430L);
114 goto fail;
115 }
116 if (bozo_isrestricted) {
117 code = BZACCESS(39430L);
118 goto fail;
119 }
120 if (DoLogging)
121 bozo_Log("%s is executing the shell command '%s'\n", caller, acmd);
122
123 /* should copy output to acall, but don't yet cause its hard */
124 /* hard... NOT! Nnow _at least_ return the exit status */
125 code = system(acmd);
126 osi_auditU(acall, BOS_ExecEvent"AFS_BOS_Exec", code, AUD_STR1, acmd, AUD_END0);
127
128 fail:
129 return code;
130}
131
132afs_int32
133SBOZO_GetDates(struct rx_call *acall, char *aname, afs_int32 *atime,
134 afs_int32 *abakTime, afs_int32 *aoldTime)
135{
136 struct stat tstat;
137 char *strp;
138 char tbuffer[AFSDIR_PATH_MAX256];
139
140 *atime = *abakTime = *aoldTime = 0;
141
142 /* construct local path from canonical (wire-format) path */
143 if (ConstructLocalBinPath(aname, &strp)) {
144 return 0;
145 }
146 strcpy(tbuffer, strp);
147 free(strp);
148
149 strp = tbuffer + strlen(tbuffer);
150
151 if (!stat(tbuffer, &tstat)) {
152 *atime = tstat.st_mtimest_mtim.tv_sec;
153 }
154
155 strcpy(strp, ".BAK");
156 if (!stat(tbuffer, &tstat)) {
157 *abakTime = tstat.st_mtimest_mtim.tv_sec;
158 }
159
160 strcpy(strp, ".OLD");
161 if (!stat(tbuffer, &tstat)) {
162 *aoldTime = tstat.st_mtimest_mtim.tv_sec;
163 }
164 return 0;
165}
166
167afs_int32
168SBOZO_UnInstall(struct rx_call *acall, char *aname)
169{
170 char *filepath;
171 char fpOld[AFSDIR_PATH_MAX256], fpBak[AFSDIR_PATH_MAX256];
172 afs_int32 code;
173 char caller[MAXKTCNAMELEN64];
174 struct stat tstat;
175
176 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
177 code = BZACCESS(39430L);
178 osi_auditU(acall, BOS_UnInstallEvent"AFS_BOS_UnInst", code, AUD_STR1, aname, AUD_END0);
179 return code;
180 }
181 if (bozo_isrestricted) {
182 code = BZACCESS(39430L);
183 osi_auditU(acall, BOS_UnInstallEvent"AFS_BOS_UnInst", code, AUD_STR1, aname, AUD_END0);
184 return code;
185 }
186
187 /* construct local path from canonical (wire-format) path */
188 if (ConstructLocalBinPath(aname, &filepath)) {
189 return BZNOENT(39425L);
190 }
191
192 if (DoLogging)
193 bozo_Log("%s is executing UnInstall '%s'\n", caller, filepath);
194
195 strcpy(fpBak, filepath);
196 strcat(fpBak, ".BAK");
197 strcpy(fpOld, filepath);
198 strcat(fpOld, ".OLD");
199
200 code = renamefile(fpBak, filepath);
201 if (code) {
202 /* can't find .BAK, try .OLD */
203 code = renamefile(fpOld, filepath);
204 if (code && errno(* __error()) == ENOENT2) /* If doesn't exist don't fail */
205 code = 0;
206 } else {
207 /* now rename .OLD to .BAK */
208 if (stat(fpOld, &tstat) == 0)
209 code = renamefile(fpOld, fpBak);
210 }
211 if (code)
212 code = errno(* __error());
213
214 osi_auditU(acall, BOS_UnInstallEvent"AFS_BOS_UnInst", code, AUD_STR1, filepath, AUD_END0);
215 free(filepath);
216
217 return code;
218}
219
220#define BOZO_OLDTIME(7*24*3600) (7*24*3600) /* 7 days old */
221static void
222SaveOldFiles(char *aname)
223{
224 afs_int32 code;
225 char bbuffer[AFSDIR_PATH_MAX256], obuffer[AFSDIR_PATH_MAX256];
226 struct stat tstat;
227 afs_int32 now;
228 afs_int32 oldTime, bakTime;
229
230 strcpy(bbuffer, aname);
231 strcat(bbuffer, ".BAK");
232 strcpy(obuffer, aname);
233 strcat(obuffer, ".OLD");
234 now = FT_ApproxTime();
235
236 code = stat(aname, &tstat);
237 if (code < 0)
238 return; /* can't stat file */
239
240 code = stat(obuffer, &tstat); /* discover old file's time */
241 if (code)
242 oldTime = 0;
243 else
244 oldTime = tstat.st_mtimest_mtim.tv_sec;
245
246 code = stat(bbuffer, &tstat); /* discover back file's time */
247 if (code)
248 bakTime = 0;
249 else
250 bakTime = tstat.st_mtimest_mtim.tv_sec;
251
252 if (bakTime && (oldTime == 0 || bakTime < now - BOZO_OLDTIME(7*24*3600))) {
253 /* no .OLD file, or .BAK is at least a week old */
254 code = renamefile(bbuffer, obuffer);
255 }
256
257 /* finally rename to .BAK extension */
258 renamefile(aname, bbuffer);
259}
260
261afs_int32
262SBOZO_Install(struct rx_call *acall, char *aname, afs_int32 asize, afs_int32 mode, afs_int32 amtime)
263{
264 afs_int32 code;
265 int fd;
266 afs_int32 len;
267 afs_int32 total;
268#ifdef AFS_NT40_ENV
269 struct _utimbuf utbuf;
270#else
271 struct timeval tvb[2];
272#endif
273 char filepath[AFSDIR_PATH_MAX256], tbuffer[AFSDIR_PATH_MAX256], *fpp;
274 char caller[MAXKTCNAMELEN64];
275
276 if (!afsconf_SuperUser(bozo_confdir, acall, caller))
277 return BZACCESS(39430L);
278 if (bozo_isrestricted)
279 return BZACCESS(39430L);
280
281 /* construct local path from canonical (wire-format) path */
282 if (ConstructLocalBinPath(aname, &fpp)) {
283 return BZNOENT(39425L);
284 }
285 strcpy(filepath, fpp);
286 free(fpp);
287
288 if (DoLogging)
289 bozo_Log("%s is executing Install '%s'\n", caller, filepath);
290
291 /* open file */
292 fpp = filepath + strlen(filepath);
293 strcpy(fpp, ".NEW"); /* append ".NEW" to end of filepath */
294 fd = open(filepath, O_CREAT0x0200 | O_RDWR0x0002 | O_TRUNC0x0400, 0777);
295 if (fd < 0)
296 return errno(* __error());
297 total = 0;
298 while (1) {
299 len = rx_Read(acall, tbuffer, sizeof(tbuffer))rx_ReadProc(acall, tbuffer, sizeof(tbuffer));
300 if (len < 0) {
301 close(fd);
302 unlink(filepath);
303 return 102;
304 }
305 if (len == 0)
306 break; /* no more input */
307 code = write(fd, tbuffer, len);
308 if (code != len) {
309 close(fd);
310 unlink(filepath);
311 return 100;
312 }
313 total += len; /* track total written for safety check at end */
314 }
315 close(fd);
316 if (asize != total) {
317 unlink(filepath);
318 return 101; /* wrong size */
319 }
320
321 /* save old files */
322 *fpp = '\0'; /* remove ".NEW" from end of filepath */
323 SaveOldFiles(filepath); /* don't care if it works, still install */
324
325 /* all done, rename to final name */
326 strcpy(tbuffer, filepath);
327 strcat(tbuffer, ".NEW");
328 code = (renamefile(tbuffer, filepath) ? errno(* __error()) : 0);
329
330 /* label file with same time for our sanity */
331#ifdef AFS_NT40_ENV
332 utbuf.actime = utbuf.modtime = amtime;
333 _utime(filepath, &utbuf);
334#else
335 tvb[0].tv_sec = tvb[1].tv_sec = amtime;
336 tvb[0].tv_usec = tvb[1].tv_usec = 0;
337 utimes(filepath, tvb);
338#endif /* AFS_NT40_ENV */
339
340 if (mode)
341 chmod(filepath, mode);
342
343 if (code < 0) {
344 osi_auditU(acall, BOS_InstallEvent"AFS_BOS_Inst", code, AUD_STR1, filepath, AUD_END0);
345 return errno(* __error());
346 } else
347 return 0;
348}
349
350afs_int32
351SBOZO_SetCellName(struct rx_call *acall, char *aname)
352{
353 struct afsconf_cell tcell;
354 afs_int32 code;
355 char caller[MAXKTCNAMELEN64];
356 char clones[MAXHOSTSPERCELL8];
357
358 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
359 code = BZACCESS(39430L);
360 goto fail;
361 }
362 if (DoLogging)
363 bozo_Log("%s is executing SetCellName '%s'\n", caller, aname);
364
365 code =
366 afsconf_GetExtendedCellInfo(bozo_confdir, NULL((void *)0), NULL((void *)0), &tcell,
367 clones);
368 if (code)
369 goto fail;
370
371 /* Check that tcell has enough space for the new cellname. */
372 if (strlen(aname) > sizeof tcell.name - 1) {
373 bozo_Log
374 ("ERROR: SetCellName: cell name '%s' exceeds %ld bytes (cell name not changed)\n",
375 aname, (long)(sizeof tcell.name - 1));
376 code = BZDOM(39429L);
377 goto fail;
378 }
379
380 strcpy(tcell.name, aname);
381 code =
382 afsconf_SetExtendedCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATHgetDirPath(AFSDIR_SERVER_ETC_DIRPATH_ID),
383 &tcell, clones);
384
385 fail:
386 osi_auditU(acall, BOS_SetCellEvent"AFS_BOS_SetCell", code, AUD_STR1, aname, AUD_END0);
387 return code;
388}
389
390afs_int32
391SBOZO_GetCellName(struct rx_call *acall, char **aname)
392{
393 afs_int32 code;
394 char tname[MAXCELLCHARS64];
395
396 code = afsconf_GetLocalCell(bozo_confdir, tname, sizeof(tname));
397 if (code) {
398 /* must set output parameters even if aborting */
399 *aname = (char *)malloc(1);
400 **aname = 0;
401 } else {
402 *aname = (char *)malloc(strlen(tname) + 1);
403 strcpy(*aname, tname);
404 }
405
406 return code;
407}
408
409afs_int32
410SBOZO_GetCellHost(struct rx_call *acall, afs_uint32 awhich, char **aname)
411{
412 afs_int32 code;
413 struct afsconf_cell tcell;
414 char *tp;
415 char clones[MAXHOSTSPERCELL8];
416
417 code =
418 afsconf_GetExtendedCellInfo(bozo_confdir, NULL((void *)0), NULL((void *)0), &tcell,
419 clones);
420 if (code)
421 goto fail;
422
423 if (awhich >= tcell.numServers) {
424 code = BZDOM(39429L);
425 goto fail;
426 }
427
428 tp = tcell.hostName[awhich];
429 *aname = (char *)malloc(strlen(tp) + 3);
430 if (clones[awhich]) {
431 strcpy(*aname, "[");
432 strcat(*aname, tp);
433 strcat(*aname, "]");
434 } else
435 strcpy(*aname, tp);
436 goto done;
437
438 fail:
439 *aname = (char *)malloc(1); /* return fake string */
440 **aname = 0;
441
442 done:
443 return code;
444}
445
446afs_int32
447SBOZO_DeleteCellHost(struct rx_call *acall, char *aname)
448{
449 afs_int32 code;
450 struct afsconf_cell tcell;
451 afs_int32 which;
452 int i;
453 char caller[MAXKTCNAMELEN64];
454 char clones[MAXHOSTSPERCELL8];
455
456 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
457 code = BZACCESS(39430L);
458 goto fail;
459 }
460 if (DoLogging)
461 bozo_Log("%s is executing DeleteCellHost '%s'\n", caller, aname);
462
463 code =
464 afsconf_GetExtendedCellInfo(bozo_confdir, NULL((void *)0), NULL((void *)0), &tcell,
465 clones);
466 if (code)
467 goto fail;
468
469 which = -1;
470 for (i = 0; i < tcell.numServers; i++) {
471 if (strcmp(tcell.hostName[i], aname) == 0) {
472 which = i;
473 break;
474 }
475 }
476
477 if (which < 0) {
478 code = BZNOENT(39425L);
479 goto fail;
480 }
481
482 memset(&tcell.hostAddr[which], 0, sizeof(struct sockaddr_in));
483 memset(tcell.hostName[which], 0, MAXHOSTCHARS64);
484 code =
485 afsconf_SetExtendedCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATHgetDirPath(AFSDIR_SERVER_ETC_DIRPATH_ID),
486 &tcell, clones);
487
488 fail:
489 osi_auditU(acall, BOS_DeleteHostEvent"AFS_BOS_DelHst", code, AUD_STR1, aname, AUD_END0);
490 return code;
491}
492
493afs_int32
494SBOZO_AddCellHost(struct rx_call *acall, char *aname)
495{
496 afs_int32 code;
497 struct afsconf_cell tcell;
498 afs_int32 which;
499 int i;
500 char caller[MAXKTCNAMELEN64];
501 char clones[MAXHOSTSPERCELL8];
502 char *n;
503 char isClone = 0;
504
505 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
506 code = BZACCESS(39430L);
507 goto fail;
508 }
509 if (DoLogging)
510 bozo_Log("%s is executing AddCellHost '%s'\n", caller, aname);
511
512 code =
513 afsconf_GetExtendedCellInfo(bozo_confdir, NULL((void *)0), NULL((void *)0), &tcell,
514 clones);
515 if (code)
516 goto fail;
517
518 n = aname;
519 if (*n == '[') {
520 *(n + strlen(n) - 1) = 0;
521 ++n;
522 isClone = 1;
523 }
524
525 which = -1;
526 for (i = 0; i < tcell.numServers; i++) {
527 if (strcmp(tcell.hostName[i], n) == 0) {
528 which = i;
529 break;
530 }
531 }
532 if (which < 0) {
533 which = tcell.numServers;
534 tcell.numServers++;
535
536 /*
537 * Check that tcell has enough space for an additional host.
538 *
539 * We assume that tcell.hostAddr[] and tcell.hostName[] have the
540 * same number of entries.
541 */
542 if (tcell.numServers >
543 sizeof tcell.hostAddr / sizeof tcell.hostAddr[0]) {
544 bozo_Log
545 ("ERROR: AddCellHost: attempt to add more than %ld database servers (database server '%s' not added)\n",
546 (long)(sizeof tcell.hostAddr / sizeof tcell.hostAddr[0]),
547 aname);
548 code = BZDOM(39429L);
549 goto fail;
550 }
551
552 /* Check that tcell has enough space for the new hostname. */
553 if (strlen(aname) > sizeof tcell.hostName[0] - 1) {
554 bozo_Log
555 ("ERROR: AddCellHost: host name '%s' exceeds %ld bytes (not added)\n",
556 aname, (long)(sizeof tcell.hostName[0] - 1));
557 code = BZDOM(39429L);
558 goto fail;
559 }
560 }
561
562 memset(&tcell.hostAddr[which], 0, sizeof(struct sockaddr_in));
563 strcpy(tcell.hostName[which], n);
564 clones[which] = isClone;
565 code =
566 afsconf_SetExtendedCellInfo(bozo_confdir, AFSDIR_SERVER_ETC_DIRPATHgetDirPath(AFSDIR_SERVER_ETC_DIRPATH_ID),
567 &tcell, clones);
568
569 fail:
570 osi_auditU(acall, BOS_AddHostEvent"AFS_BOS_AddHst", code, AUD_STR1, aname, AUD_END0);
571 return code;
572}
573
574afs_int32
575SBOZO_ListKeys(struct rx_call *acall, afs_int32 an, afs_int32 *akvno,
576 struct bozo_key *akey, struct bozo_keyInfo *akeyinfo)
577{
578 struct afsconf_keys tkeys;
579 afs_int32 code;
580 struct stat tstat;
581 int noauth = 0;
582 char caller[MAXKTCNAMELEN64];
583 rxkad_level enc_level = rxkad_clear0;
584
585 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
586 code = BZACCESS(39430L);
587 goto fail;
588 }
589 if (DoLogging)
590 bozo_Log("%s is executing ListKeys\n", caller);
591
592 code = afsconf_GetKeys(bozo_confdir, &tkeys);
593 if (code)
594 goto fail;
595
596 if (tkeys.nkeys <= an) {
597 code = BZDOM(39429L);
598 goto fail;
599 }
600 *akvno = tkeys.key[an].kvno;
601 memset(akeyinfo, 0, sizeof(struct bozo_keyInfo));
602
603 noauth = afsconf_GetNoAuthFlag(bozo_confdir);
604 rxkad_GetServerInfo(acall->conn, &enc_level, 0, 0, 0, 0, 0);
605 /*
606 * only return actual keys in noauth or if this is an encrypted connection
607 */
608
609 if ((noauth) || (enc_level == rxkad_crypt2)) {
610 memcpy(akey, tkeys.key[an].key, 8);
611 } else
612 memset(akey, 0, 8);
613
614 code = stat(AFSDIR_SERVER_KEY_FILEPATHgetDirPath(AFSDIR_SERVER_KEY_FILEPATH_ID), &tstat);
615 if (code == 0) {
616 akeyinfo->mod_sec = tstat.st_mtimest_mtim.tv_sec;
617 }
618 ka_KeyCheckSum(tkeys.key[an].key, &akeyinfo->keyCheckSum);
619 /* only errors is bad key parity */
620
621 fail:
622 if (noauth)
623 osi_auditU(acall, BOS_UnAuthListKeysEvent"AFS_BOS_LstKeyU", code, AUD_END0);
624 osi_auditU(acall, BOS_ListKeysEvent"AFS_BOS_LstKey", code, AUD_END0);
625 return code;
626}
627
628afs_int32
629SBOZO_AddKey(struct rx_call *acall, afs_int32 an, struct bozo_key *akey)
630{
631 afs_int32 code;
632 char caller[MAXKTCNAMELEN64];
633 rxkad_level enc_level = rxkad_clear0;
634 int noauth;
635
636 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
637 code = BZACCESS(39430L);
638 goto fail;
639 }
640 noauth = afsconf_GetNoAuthFlag(bozo_confdir);
641 rxkad_GetServerInfo(acall->conn, &enc_level, 0, 0, 0, 0, 0);
642 if ((!noauth) && (enc_level != rxkad_crypt2)) {
643 code = BZENCREQ(39436L);
644 goto fail;
645 }
646 if (DoLogging)
647 bozo_Log("%s is executing AddKey\n", caller);
648
649 code = afsconf_AddKey(bozo_confdir, an, akey->data, 0);
650 if (code == AFSCONF_KEYINUSE512)
651 code = BZKEYINUSE(39435L); /* Unique code for afs rpc calls */
652 fail:
653 osi_auditU(acall, BOS_AddKeyEvent"AFS_BOS_AddKey", code, AUD_END0);
654 return code;
655}
656
657afs_int32
658SBOZO_SetNoAuthFlag(struct rx_call *acall, afs_int32 aflag)
659{
660 afs_int32 code = 0;
661 char caller[MAXKTCNAMELEN64];
662
663 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
664 code = BZACCESS(39430L);
665 goto fail;
666 }
667 if (DoLogging)
668 bozo_Log("%s is executing Set No Authentication\n", caller);
669
670 afsconf_SetNoAuthFlag(bozo_confdir, aflag);
671
672 fail:
673 osi_auditU(acall, BOS_SetNoAuthEvent"AFS_BOS_SetNoAu", code, AUD_LONG5, aflag, AUD_END0);
674 return code;
675}
676
677afs_int32
678SBOZO_DeleteKey(struct rx_call *acall, afs_int32 an)
679{
680 afs_int32 code;
681 char caller[MAXKTCNAMELEN64];
682
683 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
684 code = BZACCESS(39430L);
685 goto fail;
686 }
687 if (DoLogging)
688 bozo_Log("%s is executing DeleteKey\n", caller);
689
690 code = afsconf_DeleteKey(bozo_confdir, an);
691
692 fail:
693 osi_auditU(acall, BOS_DeleteKeyEvent"AFS_BOS_DelKey", code, AUD_END0);
694 return code;
695}
696
697
698afs_int32
699SBOZO_ListSUsers(struct rx_call *acall, afs_int32 an, char **aname)
700{
701 afs_int32 code;
702 char *tp;
703
704 tp = *aname = (char *)malloc(256);
705 *tp = 0; /* in case getnthuser doesn't null-terminate the string */
706 code = afsconf_GetNthUser(bozo_confdir, an, tp, 256);
707
708 /* fail: */
709 osi_auditU(acall, BOS_ListSUserEvent"AFS_BOS_LstSUsr", code, AUD_END0);
710 return code;
711}
712
713afs_int32
714SBOZO_AddSUser(struct rx_call *acall, char *aname)
715{
716 afs_int32 code;
717 char caller[MAXKTCNAMELEN64];
718
719 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
720 code = BZACCESS(39430L);
721 goto fail;
722 }
723 if (DoLogging)
724 bozo_Log("%s is executing Add SuperUser '%s'\n", caller, aname);
725
726 code = afsconf_AddUser(bozo_confdir, aname);
727
728 fail:
729 osi_auditU(acall, BOS_AddSUserEvent"AFS_BOS_AddSUsr", code, AUD_END0);
730 return code;
731}
732
733afs_int32
734SBOZO_DeleteSUser(struct rx_call *acall, char *aname)
735{
736 afs_int32 code;
737 char caller[MAXKTCNAMELEN64];
738
739 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
740 code = BZACCESS(39430L);
741 goto fail;
742 }
743
744 if (DoLogging)
745 bozo_Log("%s is executing Delete SuperUser '%s'\n", caller, aname);
746
747 code = afsconf_DeleteUser(bozo_confdir, aname);
748
749 fail:
750 osi_auditU(acall, BOS_DeleteSUserEvent"AFS_BOS_DelSUsr", code, AUD_END0);
751 return code;
752}
753
754afs_int32
755SBOZO_CreateBnode(struct rx_call *acall, char *atype, char *ainstance,
756 char *ap1, char *ap2, char *ap3, char *ap4, char *ap5,
757 char *notifier)
758{
759 struct bnode *tb;
760 afs_int32 code;
761 char caller[MAXKTCNAMELEN64];
762
763 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
764 code = BZACCESS(39430L);
765 goto fail;
766 }
767 if (bozo_isrestricted) {
768 const char *salvpath = AFSDIR_CANONICAL_SERVER_SALVAGER_FILEPATH"/usr/afs" "/bin" "/" "salvager";
769 /* for DAFS, 'bos salvage' will pass "salvageserver -client" instead */
770 const char *salsrvpath = AFSDIR_CANONICAL_SERVER_SALSRV_FILEPATH"/usr/afs" "/bin" "/" "salvageserver" " -client ";
771
772 /* still allow 'bos salvage' to work */
773 if (strcmp(atype, "cron") || strcmp(ainstance, "salvage-tmp")
774 || strcmp(ap2, "now")
775 || (strncmp(ap1, salvpath, strlen(salvpath))
776 && strncmp(ap1, salsrvpath, strlen(salsrvpath)))) {
777
778 code = BZACCESS(39430L);
779 goto fail;
780 }
781 }
782
783 code =
784 bnode_Create(atype, ainstance, &tb, ap1, ap2, ap3, ap4, ap5, notifier,
785 BSTAT_NORMAL1, 1);
786 if (!code)
787 bnode_SetStat(tb, BSTAT_NORMAL1);
788
789 fail:
790 osi_auditU(acall, BOS_CreateBnodeEvent"AFS_BOS_CreBnod", code, AUD_END0);
791 return code;
792}
793
794afs_int32
795SBOZO_WaitAll(struct rx_call *acall)
796{
797 afs_int32 code;
798 char caller[MAXKTCNAMELEN64];
799
800 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
801 code = BZACCESS(39430L);
802 goto fail;
803 }
804
805 if (DoLogging)
806 bozo_Log("%s is executing Wait for All\n", caller);
807
808 code = bnode_WaitAll();
809
810 fail:
811 osi_auditU(acall, BOS_WaitAllEvent"AFS_BOS_WaitAll", code, AUD_END0);
812 return code;
813}
814
815afs_int32
816SBOZO_DeleteBnode(struct rx_call *acall, char *ainstance)
817{
818 afs_int32 code;
819 char caller[MAXKTCNAMELEN64];
820
821 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
822 code = BZACCESS(39430L);
823 goto fail;
824 }
825 if (bozo_isrestricted) {
826 code = BZACCESS(39430L);
827 goto fail;
828 }
829 if (DoLogging)
830 bozo_Log("%s is executing DeleteBnode '%s'\n", caller, ainstance);
831
832 code = bnode_DeleteName(ainstance);
833
834 fail:
835 osi_auditU(acall, BOS_DeleteBnodeEvent"AFS_BOS_DelBnod", code, AUD_STR1, ainstance,
836 AUD_END0);
837 return code;
838}
839
840static int
841swproc(struct bnode *abnode, void *arock)
842{
843 if (abnode->goal == BSTAT_NORMAL1)
844 return 0; /* this one's not shutting down */
845 /* otherwise, we are shutting down */
846 bnode_Hold(abnode);
847 bnode_WaitStatus(abnode, BSTAT_SHUTDOWN0);
848 bnode_Release(abnode);
849 return 0; /* don't stop apply function early, no matter what */
850}
851
852static int
853stproc(struct bnode *abnode, void *arock)
854{
855 if (abnode->fileGoal == BSTAT_SHUTDOWN0)
856 return 0; /* don't do these guys */
857
858 bnode_Hold(abnode);
859 bnode_SetStat(abnode, BSTAT_NORMAL1);
860 bnode_Release(abnode);
861 return 0;
862}
863
864static int
865sdproc(struct bnode *abnode, void *arock)
866{
867 bnode_Hold(abnode);
868 bnode_SetStat(abnode, BSTAT_SHUTDOWN0);
869 bnode_Release(abnode);
870 return 0;
871}
872
873/* shutdown and leave down */
874afs_int32
875SBOZO_ShutdownAll(struct rx_call *acall)
876{
877 /* iterate over all bnodes, setting the status to temporarily disabled */
878 afs_int32 code;
879 char caller[MAXKTCNAMELEN64];
880
881 /* check for authorization */
882 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
883 code = BZACCESS(39430L);
884 goto fail;
885 }
886 if (DoLogging)
887 bozo_Log("%s is executing ShutdownAll\n", caller);
888
889 code = bnode_ApplyInstance(sdproc, NULL((void *)0));
890
891 fail:
892 osi_auditU(acall, BOS_ShutdownAllEvent"AFS_BOS_ShtdAll", code, AUD_END0);
893 return code;
894}
895
896/* shutdown and restart */
897afs_int32
898SBOZO_RestartAll(struct rx_call *acall)
899{
900 afs_int32 code;
901 char caller[MAXKTCNAMELEN64];
902
903 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
904 code = BZACCESS(39430L);
905 goto fail;
906 }
907 if (DoLogging)
908 bozo_Log("%s is executing RestartAll\n", caller);
909
910 /* start shutdown of all processes */
911 code = bnode_ApplyInstance(sdproc, NULL((void *)0));
912 if (code)
913 goto fail;
914
915 /* wait for all done */
916 code = bnode_ApplyInstance(swproc, NULL((void *)0));
917 if (code)
918 goto fail;
919
920 /* start them up again */
921 code = bnode_ApplyInstance(stproc, NULL((void *)0));
922
923 fail:
924 osi_auditU(acall, BOS_RestartAllEvent"AFS_BOS_ReStAll", code, AUD_END0);
925 return code;
926}
927
928afs_int32
929SBOZO_ReBozo(struct rx_call *acall)
930{
931 afs_int32 code;
932 char caller[MAXKTCNAMELEN64];
933
934 /* acall is null if called internally to restart bosserver */
935 if (acall && !afsconf_SuperUser(bozo_confdir, acall, caller)) {
936 code = BZACCESS(39430L);
937 goto fail;
938 }
939 if (DoLogging)
940 bozo_Log("%s is executing ReBozo\n", caller);
941
942 /* start shutdown of all processes */
943 code = bnode_ApplyInstance(sdproc, NULL((void *)0));
944 if (code)
945 goto fail;
946
947 /* wait for all done */
948 code = bnode_ApplyInstance(swproc, NULL((void *)0));
949 if (code)
950 goto fail;
951
952 if (acall)
953 osi_auditU(acall, BOS_RebozoEvent"AFS_BOS_ReBos", code, AUD_END0);
954 else
955 osi_audit(BOS_RebozoIntEvent"AFS_BOS_ReBosIn", code, AUD_END0);
956
957 if (acall)
958 rx_EndCall(acall, 0); /* try to get it done */
959 rx_Finalize();
960 bozo_ReBozo(); /* this reexecs us, and doesn't return, of course */
961
962 fail:
963 /* Differentiate between external and internal ReBozo; prevents AFS_Aud_NoCall event */
964 if (acall)
965 osi_auditU(acall, BOS_RebozoEvent"AFS_BOS_ReBos", code, AUD_END0);
966 else
967 osi_audit(BOS_RebozoIntEvent"AFS_BOS_ReBosIn", code, AUD_END0);
968 return code; /* should only get here in unusual circumstances */
969}
970
971/* make sure all are running */
972afs_int32
973SBOZO_StartupAll(struct rx_call *acall)
974{
975 afs_int32 code;
976 char caller[MAXKTCNAMELEN64];
977
978 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
979 code = BZACCESS(39430L);
980 goto fail;
981 }
982 if (DoLogging)
983 bozo_Log("%s is executing StartupAll\n", caller);
984 code = bnode_ApplyInstance(stproc, NULL((void *)0));
985
986 fail:
987 osi_auditU(acall, BOS_StartupAllEvent"AFS_BOS_StartAl", code, AUD_END0);
988 return code;
989}
990
991afs_int32
992SBOZO_Restart(struct rx_call *acall, char *ainstance)
993{
994 struct bnode *tb;
995 afs_int32 code;
996 char caller[MAXKTCNAMELEN64];
997
998 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
999 code = BZACCESS(39430L);
1000 goto fail;
1001 }
1002 if (DoLogging)
1003 bozo_Log("%s is executing Restart '%s'\n", caller, ainstance);
1004
1005 tb = bnode_FindInstance(ainstance);
1006 if (!tb) {
1007 code = BZNOENT(39425L);
1008 goto fail;
1009 }
1010
1011 /* setup return code */
1012 code = 0;
Value stored to 'code' is never read
1013
1014 bnode_Hold(tb);
1015 bnode_SetStat(tb, BSTAT_SHUTDOWN0);
1016 code = bnode_WaitStatus(tb, BSTAT_SHUTDOWN0); /* this can fail */
1017 bnode_SetStat(tb, BSTAT_NORMAL1);
1018 bnode_Release(tb);
1019
1020 fail:
1021 osi_auditU(acall, BOS_RestartEvent"AFS_BOS_ReStart", code, AUD_STR1, ainstance, AUD_END0);
1022 return code;
1023}
1024
1025/* set temp status */
1026afs_int32
1027SBOZO_SetTStatus(struct rx_call *acall, char *ainstance, afs_int32 astatus)
1028{
1029 struct bnode *tb;
1030 afs_int32 code;
1031 char caller[MAXKTCNAMELEN64];
1032
1033 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
1034 code = BZACCESS(39430L);
1035 goto fail;
1036 }
1037 if (DoLogging)
1038 bozo_Log("%s is executing SetTempStatus '%s'\n", caller, ainstance);
1039
1040 tb = bnode_FindInstance(ainstance);
1041 if (!tb) {
1042 code = BZNOENT(39425L);
1043 goto fail;
1044 }
1045 bnode_Hold(tb);
1046 code = bnode_SetStat(tb, astatus);
1047 bnode_Release(tb);
1048
1049 fail:
1050 osi_auditU(acall, BOS_SetTempStatusEvent"AFS_BOS_SetTSta", code, AUD_STR1, ainstance,
1051 AUD_END0);
1052 return code;
1053}
1054
1055afs_int32
1056SBOZO_SetStatus(struct rx_call *acall, char *ainstance, afs_int32 astatus)
1057{
1058 struct bnode *tb;
1059 afs_int32 code;
1060 char caller[MAXKTCNAMELEN64];
1061
1062 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
1063 code = BZACCESS(39430L);
1064 goto fail;
1065 }
1066 if (DoLogging)
1067 bozo_Log("%s is executing SetStatus '%s' (status = %d)\n", caller,
1068 ainstance, astatus);
1069
1070 tb = bnode_FindInstance(ainstance);
1071 if (!tb) {
1072 code = BZNOENT(39425L);
1073 goto fail;
1074 }
1075 bnode_Hold(tb);
1076 bnode_SetFileGoal(tb, astatus);
1077 code = bnode_SetStat(tb, astatus);
1078 bnode_Release(tb);
1079
1080 fail:
1081 osi_auditU(acall, BOS_SetStatusEvent"AFS_BOS_SetStat", code, AUD_STR1, ainstance, AUD_END0);
1082 return code;
1083}
1084
1085afs_int32
1086SBOZO_GetStatus(struct rx_call *acall, char *ainstance, afs_int32 *astat,
1087 char **astatDescr)
1088{
1089 struct bnode *tb;
1090 afs_int32 code;
1091
1092 tb = bnode_FindInstance(ainstance);
1093 if (!tb) {
1094 code = BZNOENT(39425L);
1095 goto fail;
1096 }
1097
1098 bnode_Hold(tb);
1099 code = bnode_GetStat(tb, astat);
1100 if (code) {
1101 bnode_Release(tb);
1102 goto fail;
1103 }
1104
1105 *astatDescr = (char *)malloc(BOZO_BSSIZE256);
1106 code = bnode_GetString(tb, *astatDescr, BOZO_BSSIZE256);
1107 bnode_Release(tb);
1108 if (code)
1109 (*astatDescr)[0] = 0; /* null string means no further info */
1110 return 0;
1111
1112 fail:
1113 *astatDescr = (char *)malloc(1);
1114 **astatDescr = 0;
1115 return code;
1116}
1117
1118struct eidata {
1119 char *iname;
1120 int counter;
1121};
1122
1123static int
1124eifunc(struct bnode *abnode, void *param)
1125{
1126 struct eidata *arock = (struct eidata *)param;
1127
1128 if (arock->counter-- == 0) {
1129 /* done */
1130 strcpy(arock->iname, abnode->name);
1131 return 1;
1132 } else {
1133 /* not there yet */
1134 return 0;
1135 }
1136}
1137
1138static int
1139ZapFile(const char *adir, const char *aname)
1140{
1141 char tbuffer[256];
1142 if (snprintf(tbuffer, 256, "%s/%s", adir, aname)<256)
1143 return unlink(tbuffer);
1144 else
1145 return -1;
1146}
1147
1148afs_int32
1149SBOZO_Prune(struct rx_call *acall, afs_int32 aflags)
1150{
1151 afs_int32 code;
1152 DIR *dirp;
1153 struct dirent *tde;
1154 int i;
1155 char caller[MAXKTCNAMELEN64];
1156
1157 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
1158 code = BZACCESS(39430L);
1159 goto fail;
1160 }
1161 if (bozo_isrestricted) {
1162 code = BZACCESS(39430L);
1163 goto fail;
1164 }
1165 if (DoLogging)
1166 bozo_Log("%s is executing Prune (flags=%d)\n", caller, aflags);
1167
1168 /* first scan AFS binary directory */
1169 dirp = opendir(AFSDIR_SERVER_BIN_DIRPATHgetDirPath(AFSDIR_SERVER_BIN_DIRPATH_ID));
1170 if (dirp) {
1171 for (tde = readdir(dirp); tde; tde = readdir(dirp)) {
1172 i = strlen(tde->d_name);
1173 if (aflags & BOZO_PRUNEOLD1) {
1174 if (i >= 4 && strncmp(tde->d_name + i - 4, ".OLD", 4) == 0)
1175 ZapFile(AFSDIR_SERVER_BIN_DIRPATHgetDirPath(AFSDIR_SERVER_BIN_DIRPATH_ID), tde->d_name);
1176 }
1177 if (aflags & BOZO_PRUNEBAK2) {
1178 if (i >= 4 && strncmp(tde->d_name + i - 4, ".BAK", 4) == 0)
1179 ZapFile(AFSDIR_SERVER_BIN_DIRPATHgetDirPath(AFSDIR_SERVER_BIN_DIRPATH_ID), tde->d_name);
1180 }
1181 }
1182 closedir(dirp);
1183 }
1184
1185 /* then scan AFS log directory */
1186 dirp = opendir(AFSDIR_SERVER_LOGS_DIRPATHgetDirPath(AFSDIR_SERVER_LOGS_DIRPATH_ID));
1187 if (dirp) {
1188 for (tde = readdir(dirp); tde; tde = readdir(dirp)) {
1189 if (aflags & BOZO_PRUNECORE4) {
1190 if (strncmp(tde->d_name, AFSDIR_CORE_FILE"core", 4) == 0)
1191 ZapFile(AFSDIR_SERVER_LOGS_DIRPATHgetDirPath(AFSDIR_SERVER_LOGS_DIRPATH_ID), tde->d_name);
1192 }
1193 }
1194 closedir(dirp);
1195 }
1196 code = 0;
1197
1198 fail:
1199 osi_auditU(acall, BOS_PruneLogs"AFS_BOS_PrnLog", code, AUD_END0);
1200 return code;
1201}
1202
1203afs_int32
1204SBOZO_EnumerateInstance(struct rx_call *acall, afs_int32 anum,
1205 char **ainstance)
1206{
1207 struct eidata tdata;
1208
1209 *ainstance = (char *)malloc(BOZO_BSSIZE256);
1210 **ainstance = 0;
1211 tdata.counter = anum;
1212 tdata.iname = *ainstance;
1213 bnode_ApplyInstance(eifunc, &tdata);
1214 if (tdata.counter >= 0)
1215 return BZDOM(39429L); /* anum > # of actual instances */
1216 else
1217 return 0;
1218}
1219
1220struct bozo_bosEntryStats bozo_bosEntryStats[] = {
1221 {NULL((void *)0), 1, 1, 0755, 02}, /* AFSDIR_SERVER_AFS_DIRPATH */
1222 {NULL((void *)0), 1, 1, 0755, 02}, /* AFSDIR_SERVER_ETC_DIRPATH */
1223 {NULL((void *)0), 1, 1, 0755, 02}, /* AFSDIR_SERVER_BIN_DIRPATH */
1224 {NULL((void *)0), 1, 1, 0755, 02}, /* AFSDIR_SERVER_LOGS_DIRPATH */
1225 {NULL((void *)0), 1, 0, 0700, 07}, /* AFSDIR_SERVER_BACKUP_DIRPATH */
1226 {NULL((void *)0), 1, 1, 0700, 07}, /* AFSDIR_SERVER_DB_DIRPATH */
1227 {NULL((void *)0), 1, 1, 0700, 07}, /* AFSDIR_SERVER_LOCAL_DIRPATH */
1228 {NULL((void *)0), 0, 1, 0600, 07}, /* AFSDIR_SERVER_KEY_FILEPATH */
1229 {NULL((void *)0), 0, 1, 0600, 03}
1230}; /* AFSDIR_SERVER_ULIST_FILEPATH */
1231int bozo_nbosEntryStats =
1232 sizeof(bozo_bosEntryStats) / sizeof(bozo_bosEntryStats[0]);
1233
1234/* This function performs initialization of the bozo_bosEntrystats[]
1235 * array. This array contains the list of dirs that the bosserver
1236 * is interested in along with their recommended permissions
1237 * NOTE: This initialization is a bit ugly. This was caused because
1238 * the path names require procedural as opposed to static initialization.
1239 * The other fields in the struct are however, statically initialized.
1240 */
1241int
1242initBosEntryStats(void)
1243{
1244 bozo_bosEntryStats[0].path = AFSDIR_SERVER_AFS_DIRPATHgetDirPath(AFSDIR_SERVER_AFS_DIRPATH_ID);
1245 bozo_bosEntryStats[1].path = AFSDIR_SERVER_ETC_DIRPATHgetDirPath(AFSDIR_SERVER_ETC_DIRPATH_ID);
1246 bozo_bosEntryStats[2].path = AFSDIR_SERVER_BIN_DIRPATHgetDirPath(AFSDIR_SERVER_BIN_DIRPATH_ID);
1247 bozo_bosEntryStats[3].path = AFSDIR_SERVER_LOGS_DIRPATHgetDirPath(AFSDIR_SERVER_LOGS_DIRPATH_ID);
1248 bozo_bosEntryStats[4].path = AFSDIR_SERVER_BACKUP_DIRPATHgetDirPath(AFSDIR_SERVER_BACKUP_DIRPATH_ID);
1249 bozo_bosEntryStats[5].path = AFSDIR_SERVER_DB_DIRPATHgetDirPath(AFSDIR_SERVER_DB_DIRPATH_ID);
1250 bozo_bosEntryStats[6].path = AFSDIR_SERVER_LOCAL_DIRPATHgetDirPath(AFSDIR_SERVER_LOCAL_DIRPATH_ID);
1251 bozo_bosEntryStats[7].path = AFSDIR_SERVER_KEY_FILEPATHgetDirPath(AFSDIR_SERVER_KEY_FILEPATH_ID);
1252 bozo_bosEntryStats[8].path = AFSDIR_SERVER_ULIST_FILEPATHgetDirPath(AFSDIR_SERVER_ULIST_FILEPATH_ID);
1253
1254 return 0;
1255}
1256
1257/* StatEachEntry - If it's not there, it is okay. If anything else goes wrong
1258 * complain. Otherwise check permissions: shouldn't allow write or (usually)
1259 * read. */
1260
1261static int
1262StatEachEntry(IN struct bozo_bosEntryStats *stats)
1263{
1264 struct stat info;
1265 if (stat(stats->path, &info)) {
1266 if (errno(* __error()) == ENOENT2)
1267 return 1; /* no such entry: just ignore it */
1268 return 0; /* something else went wrong */
1269 } else {
1270 int rights;
1271 if (((info.st_mode & S_IFDIR0040000) != 0) != stats->dir)
1272 return 0; /* not expected type */
1273 if (stats->rootOwner && (info.st_uid != 0))
1274 return 0; /* not owned by root */
1275 rights = (info.st_mode & 0000777);
1276 if ((rights & stats->reqPerm) != stats->reqPerm)
1277 return 0; /* required permissions not present */
1278 if ((rights & stats->proPerm) != 0)
1279 return 0; /* prohibited permissions present */
1280 }
1281 return 1;
1282}
1283
1284/* DirAccessOK - checks the mode bits on the AFS dir and decendents and
1285 * returns 0 if some are not OK and 1 otherwise. For efficiency, it doesn't do
1286 * this check more often than every 5 seconds. */
1287
1288int
1289DirAccessOK(void)
1290{
1291#ifdef AFS_NT40_ENV
1292 /* underlying filesystem may not support directory protection */
1293 return 1;
1294#else
1295 static afs_uint32 lastTime = 0;
1296 afs_uint32 now = FT_ApproxTime();
1297 static int lastResult = -1;
1298 int result;
1299 int i;
1300
1301 if ((now - lastTime) < 5)
1302 return lastResult;
1303 lastTime = now;
1304
1305 result = 1;
1306 for (i = 0; i < bozo_nbosEntryStats; i++) {
1307 struct bozo_bosEntryStats *e = &bozo_bosEntryStats[i];
1308 if (!StatEachEntry(e)) {
1309 bozo_Log("unhappy with %s which is a %s that should "
1310 "have at least rights %o, at most rights %o %s\n",
1311 e->path, e->dir ? "dir" : "file", e->reqPerm,
1312 (~e->proPerm & 0777),
1313 e->rootOwner ? ", owned by root" : "");
1314 result = 0;
1315 break;
1316 }
1317 }
1318
1319 if (result != lastResult) { /* log changes */
1320 bozo_Log("Server directory access is %sokay\n",
1321 (result ? "" : "not "));
1322 }
1323 lastResult = result;
1324 return lastResult;
1325#endif /* AFS_NT40_ENV */
1326}
1327
1328int
1329GetRequiredDirPerm(const char *path)
1330{
1331 int i;
1332 for (i = 0; i < bozo_nbosEntryStats; i++)
1333 if (strcmp(path, bozo_bosEntryStats[i].path) == 0)
1334 return bozo_bosEntryStats[i].reqPerm;
1335 return -1;
1336}
1337
1338afs_int32
1339SBOZO_GetInstanceInfo(IN struct rx_call *acall,
1340 IN char *ainstance,
1341 OUT char **atype,
1342 OUT struct bozo_status *astatus)
1343{
1344 struct bnode *tb;
1345
1346 tb = bnode_FindInstance(ainstance);
1347 *atype = (char *)malloc(BOZO_BSSIZE256);
1348 **atype = 0;
1349 if (!tb)
1350 return BZNOENT(39425L);
1351 if (tb->type)
1352 strcpy(*atype, tb->type->name);
1353 else
1354 (*atype)[0] = 0; /* null string */
1355 memset(astatus, 0, sizeof(struct bozo_status)); /* good defaults */
1356 astatus->goal = tb->goal;
1357 astatus->fileGoal = tb->fileGoal;
1358 astatus->procStartTime = tb->procStartTime;
1359 astatus->procStarts = tb->procStarts;
1360 astatus->lastAnyExit = tb->lastAnyExit;
1361 astatus->lastErrorExit = tb->lastErrorExit;
1362 astatus->errorCode = tb->errorCode;
1363 astatus->errorSignal = tb->errorSignal;
1364 if (tb->flags & BNODE_ERRORSTOP0x10)
1365 astatus->flags |= BOZO_ERRORSTOP2;
1366 if (bnode_HasCore(tb))
1367 astatus->flags |= BOZO_HASCORE1;
1368 if (!DirAccessOK())
1369 astatus->flags |= BOZO_BADDIRACCESS4;
1370 return 0;
1371}
1372
1373afs_int32
1374SBOZO_GetInstanceParm(struct rx_call *acall,
1375 char *ainstance,
1376 afs_int32 anum,
1377 char **aparm)
1378{
1379 struct bnode *tb;
1380 char *tp;
1381 afs_int32 code;
1382
1383 tp = (char *)malloc(BOZO_BSSIZE256);
1384 *aparm = tp;
1385 *tp = 0; /* null-terminate string in error case */
1386 tb = bnode_FindInstance(ainstance);
1387 if (!tb)
1388 return BZNOENT(39425L);
1389 bnode_Hold(tb);
1390 if (anum == 999) {
1391 if (tb->notifier) {
1392 memcpy(tp, tb->notifier, strlen(tb->notifier) + 1);
1393 code = 0;
1394 } else
1395 code = BZNOENT(39425L); /* XXXXX */
1396 } else
1397 code = bnode_GetParm(tb, anum, tp, BOZO_BSSIZE256);
1398 bnode_Release(tb);
1399
1400 /* Not Currently Audited */
1401 return code;
1402}
1403
1404afs_int32
1405SBOZO_GetLog(struct rx_call *acall, char *aname)
1406{
1407 afs_int32 code;
1408 FILE *tfile;
1409 int tc;
1410 char *logpath;
1411 char buffer;
1412 char caller[MAXKTCNAMELEN64];
1413
1414 /* Check access since 'aname' could specify a file outside of the
1415 * AFS log directory (which is bosserver's working directory).
1416 */
1417 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
1418 code = BZACCESS(39430L);
1419 goto fail;
1420 }
1421 if (bozo_isrestricted && strchr(aname, '/')
1422 && strcmp(aname, AFSDIR_CANONICAL_SERVER_SLVGLOG_FILEPATH"/usr/afs" "/logs" "/" "SalvageLog")) {
1423 code = BZACCESS(39430L);
1424 goto fail;
1425 }
1426
1427 /* construct local path from canonical (wire-format) path */
1428 if (ConstructLocalLogPath(aname, &logpath)) {
1429 return BZNOENT(39425L);
1430 }
1431 if (DoLogging)
1432 bozo_Log("%s is executing GetLog '%s'\n", caller, logpath);
1433 tfile = fopen(logpath, "r");
1434 free(logpath);
1435
1436 if (!tfile) {
1437 return BZNOENT(39425L);
1438 }
1439
1440 while (1) {
1441 tc = getc(tfile)(!__isthreaded ? (--(tfile)->_r < 0 ? __srget(tfile) : (
int)(*(tfile)->_p++)) : (getc)(tfile));
1442 if (tc == 0)
1443 continue; /* our termination condition on other end */
1444 if (tc == EOF(-1))
1445 break;
1446 buffer = tc;
1447 if (rx_Write(acall, &buffer, 1)rx_WriteProc(acall, &buffer, 1) != 1) {
1448 fclose(tfile);
1449 code = BZNET(39433L);
1450 goto fail;
1451 }
1452 }
1453
1454 /* all done, cleanup and return */
1455 fclose(tfile);
1456
1457 /* write out the end delimeter */
1458 buffer = 0;
1459 if (rx_Write(acall, &buffer, 1)rx_WriteProc(acall, &buffer, 1) != 1)
1460 return BZNET(39433L);
1461 code = 0;
1462
1463 fail:
1464 osi_auditU(acall, BOS_GetLogsEvent"AFS_BOS_GetLog", code, AUD_END0);
1465 return code;
1466}
1467
1468afs_int32
1469SBOZO_GetInstanceStrings(struct rx_call *acall, char *abnodeName,
1470 char **as1, char **as2, char **as3, char **as4)
1471{
1472 struct bnode *tb;
1473
1474 *as2 = (char *)malloc(1);
1475 **as2 = 0;
1476 *as3 = (char *)malloc(1);
1477 **as3 = 0;
1478 *as4 = (char *)malloc(1);
1479 **as4 = 0;
1480 tb = bnode_FindInstance(abnodeName);
1481 if (!tb)
1482 goto fail;
1483
1484 /* now, return the appropriate error string, if any */
1485 if (tb->lastErrorName) {
1486 *as1 = (char *)malloc(strlen(tb->lastErrorName) + 1);
1487 strcpy(*as1, tb->lastErrorName);
1488 } else {
1489 *as1 = (char *)malloc(1);
1490 **as1 = 0;
1491 }
1492 return 0;
1493
1494 fail:
1495 *as1 = (char *)malloc(1);
1496 **as1 = 0;
1497 return BZNOENT(39425L);
1498}
1499
1500afs_int32
1501SBOZO_GetRestrictedMode(struct rx_call *acall, afs_int32 *arestmode)
1502{
1503 *arestmode = bozo_isrestricted;
1504 return 0;
1505}
1506
1507afs_int32
1508SBOZO_SetRestrictedMode(struct rx_call *acall, afs_int32 arestmode)
1509{
1510 afs_int32 code;
1511 char caller[MAXKTCNAMELEN64];
1512
1513 if (!afsconf_SuperUser(bozo_confdir, acall, caller)) {
1514 return BZACCESS(39430L);
1515 }
1516 if (bozo_isrestricted) {
1517 return BZACCESS(39430L);
1518 }
1519 if (arestmode != 0 && arestmode != 1) {
1520 return BZDOM(39429L);
1521 }
1522 bozo_isrestricted = arestmode;
1523 code = WriteBozoFile(0);
1524
1525 return code;
1526}
1527
1528void *
1529bozo_ShutdownAndExit(void *param)
1530{
1531 int asignal = (intptr_t)param;
1532 int code;
1533
1534 bozo_Log
1535 ("Shutdown of BOS server and processes in response to signal %d\n",
1536 asignal);
1537
1538 /* start shutdown of all processes */
1539 if ((code = bnode_ApplyInstance(sdproc, NULL((void *)0))) == 0) {
1540 /* wait for shutdown to complete */
1541 code = bnode_ApplyInstance(swproc, NULL((void *)0));
1542 }
1543
1544 if (code) {
1545 bozo_Log("Shutdown incomplete (code = %d); manual cleanup required\n",
1546 code);
1547 }
1548
1549 rx_Finalize();
1550 exit(code);
1551}