Return to init.c CVS log

Up to [CSRG BSD Unix] / 43BSD / etc

Annotation of 43BSD/etc/init.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1980,1986 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  */
        !             6: 
        !             7: #ifndef lint
        !             8: static char sccsid[] = "@(#)init.c     5.6 (Berkeley) 5/26/86";
        !             9: #endif not lint
        !            10: 
        !            11: #include <signal.h>
        !            12: #include <sys/types.h>
        !            13: #include <utmp.h>
        !            14: #include <setjmp.h>
        !            15: #include <sys/reboot.h>
        !            16: #include <errno.h>
        !            17: #include <sys/file.h>
        !            18: #include <ttyent.h>
        !            19: #include <sys/syslog.h>
        !            20: #include <sys/stat.h>
        !            21: 
        !            22: #define        LINSIZ  sizeof(wtmp.ut_line)
        !            23: #define        CMDSIZ  200     /* max string length for getty or window command*/
        !            24: #define        ALL     p = itab; p ; p = p->next
        !            25: #define        EVER    ;;
        !            26: #define SCPYN(a, b)    strncpy(a, b, sizeof(a))
        !            27: #define SCMPN(a, b)    strncmp(a, b, sizeof(a))
        !            28: 
        !            29: char   shell[] = "/bin/sh";
        !            30: char   minus[] = "-";
        !            31: char   runc[]  = "/etc/rc";
        !            32: char   utmpf[] = "/etc/utmp";
        !            33: char   wtmpf[] = "/usr/adm/wtmp";
        !            34: char   ctty[]  = "/dev/console";
        !            35: 
        !            36: struct utmp wtmp;
        !            37: struct tab
        !            38: {
        !            39:        char    line[LINSIZ];
        !            40:        char    comn[CMDSIZ];
        !            41:        char    xflag;
        !            42:        int     pid;
        !            43:        int     wpid;           /* window system pid for SIGHUP */
        !            44:        char    wcmd[CMDSIZ];   /* command to start window system process */
        !            45:        time_t  gettytime;
        !            46:        int     gettycnt;
        !            47:        time_t  windtime;
        !            48:        int     windcnt;
        !            49:        struct  tab *next;
        !            50: } *itab;
        !            51: 
        !            52: int    fi;
        !            53: int    mergflag;
        !            54: char   tty[20];
        !            55: jmp_buf        sjbuf, shutpass;
        !            56: time_t time0;
        !            57: 
        !            58: int    reset();
        !            59: int    idle();
        !            60: char   *strcpy(), *strcat();
        !            61: long   lseek();
        !            62: 
        !            63: struct sigvec rvec = { reset, sigmask(SIGHUP), 0 };
        !            64: 
        !            65: 
        !            66: #ifdef vax
        !            67: main()
        !            68: {
        !            69:        register int r11;               /* passed thru from boot */
        !            70: #else
        !            71: main(argc, argv)
        !            72:        char **argv;
        !            73: {
        !            74: #endif
        !            75:        int howto, oldhowto;
        !            76: 
        !            77:        time0 = time(0);
        !            78: #ifdef vax
        !            79:        howto = r11;
        !            80: #else
        !            81:        if (argc > 1 && argv[1][0] == '-') {
        !            82:                char *cp;
        !            83: 
        !            84:                howto = 0;
        !            85:                cp = &argv[1][1];
        !            86:                while (*cp) switch (*cp++) {
        !            87:                case 'a':
        !            88:                        howto |= RB_ASKNAME;
        !            89:                        break;
        !            90:                case 's':
        !            91:                        howto |= RB_SINGLE;
        !            92:                        break;
        !            93:                }
        !            94:        } else {
        !            95:                howto = RB_SINGLE;
        !            96:        }
        !            97: #endif
        !            98:        openlog("init", LOG_CONS|LOG_ODELAY, LOG_AUTH);
        !            99:        sigvec(SIGTERM, &rvec, (struct sigvec *)0);
        !           100:        signal(SIGTSTP, idle);
        !           101:        signal(SIGSTOP, SIG_IGN);
        !           102:        signal(SIGTTIN, SIG_IGN);
        !           103:        signal(SIGTTOU, SIG_IGN);
        !           104:        (void) setjmp(sjbuf);
        !           105:        for (EVER) {
        !           106:                oldhowto = howto;
        !           107:                howto = RB_SINGLE;
        !           108:                if (setjmp(shutpass) == 0)
        !           109:                        shutdown();
        !           110:                if (oldhowto & RB_SINGLE)
        !           111:                        single();
        !           112:                if (runcom(oldhowto) == 0) 
        !           113:                        continue;
        !           114:                merge();
        !           115:                multiple();
        !           116:        }
        !           117: }
        !           118: 
        !           119: int    shutreset();
        !           120: 
        !           121: shutdown()
        !           122: {
        !           123:        register i;
        !           124:        register struct tab *p, *p1;
        !           125: 
        !           126:        close(creat(utmpf, 0644));
        !           127:        signal(SIGHUP, SIG_IGN);
        !           128:        for (p = itab; p ; ) {
        !           129:                term(p);
        !           130:                p1 = p->next;
        !           131:                free(p);
        !           132:                p = p1;
        !           133:        }
        !           134:        itab = (struct tab *)0;
        !           135:        signal(SIGALRM, shutreset);
        !           136:        (void) kill(-1, SIGTERM);       /* one chance to catch it */
        !           137:        sleep(5);
        !           138:        alarm(30);
        !           139:        for (i = 0; i < 5; i++)
        !           140:                kill(-1, SIGKILL);
        !           141:        while (wait((int *)0) != -1)
        !           142:                ;
        !           143:        alarm(0);
        !           144:        shutend();
        !           145: }
        !           146: 
        !           147: char shutfailm[] = "WARNING: Something is hung (wont die); ps axl advised\n";
        !           148: 
        !           149: shutreset()
        !           150: {
        !           151:        int status;
        !           152: 
        !           153:        if (fork() == 0) {
        !           154:                int ct = open(ctty, 1);
        !           155:                write(ct, shutfailm, sizeof (shutfailm));
        !           156:                sleep(5);
        !           157:                exit(1);
        !           158:        }
        !           159:        sleep(5);
        !           160:        shutend();
        !           161:        longjmp(shutpass, 1);
        !           162: }
        !           163: 
        !           164: shutend()
        !           165: {
        !           166:        register i, f;
        !           167: 
        !           168:        acct(0);
        !           169:        signal(SIGALRM, SIG_DFL);
        !           170:        for (i = 0; i < 10; i++)
        !           171:                close(i);
        !           172:        f = open(wtmpf, O_WRONLY|O_APPEND);
        !           173:        if (f >= 0) {
        !           174:                SCPYN(wtmp.ut_line, "~");
        !           175:                SCPYN(wtmp.ut_name, "shutdown");
        !           176:                SCPYN(wtmp.ut_host, "");
        !           177:                time(&wtmp.ut_time);
        !           178:                write(f, (char *)&wtmp, sizeof(wtmp));
        !           179:                close(f);
        !           180:        }
        !           181:        return (1);
        !           182: }
        !           183: 
        !           184: single()
        !           185: {
        !           186:        register pid;
        !           187:        register xpid;
        !           188:        extern  errno;
        !           189: 
        !           190:        do {
        !           191:                pid = fork();
        !           192:                if (pid == 0) {
        !           193:                        signal(SIGTERM, SIG_DFL);
        !           194:                        signal(SIGHUP, SIG_DFL);
        !           195:                        signal(SIGALRM, SIG_DFL);
        !           196:                        signal(SIGTSTP, SIG_IGN);
        !           197:                        (void) open(ctty, O_RDWR);
        !           198:                        dup2(0, 1);
        !           199:                        dup2(0, 2);
        !           200:                        execl(shell, minus, (char *)0);
        !           201:                        exit(0);
        !           202:                }
        !           203:                while ((xpid = wait((int *)0)) != pid)
        !           204:                        if (xpid == -1 && errno == ECHILD)
        !           205:                                break;
        !           206:        } while (xpid == -1);
        !           207: }
        !           208: 
        !           209: runcom(oldhowto)
        !           210:        int oldhowto;
        !           211: {
        !           212:        register pid, f;
        !           213:        int status;
        !           214: 
        !           215:        pid = fork();
        !           216:        if (pid == 0) {
        !           217:                (void) open("/", O_RDONLY);
        !           218:                dup2(0, 1);
        !           219:                dup2(0, 2);
        !           220:                if (oldhowto & RB_SINGLE)
        !           221:                        execl(shell, shell, runc, (char *)0);
        !           222:                else
        !           223:                        execl(shell, shell, runc, "autoboot", (char *)0);
        !           224:                exit(1);
        !           225:        }
        !           226:        while (wait(&status) != pid)
        !           227:                ;
        !           228:        if (status)
        !           229:                return (0);
        !           230:        f = open(wtmpf, O_WRONLY|O_APPEND);
        !           231:        if (f >= 0) {
        !           232:                SCPYN(wtmp.ut_line, "~");
        !           233:                SCPYN(wtmp.ut_name, "reboot");
        !           234:                SCPYN(wtmp.ut_host, "");
        !           235:                if (time0) {
        !           236:                        wtmp.ut_time = time0;
        !           237:                        time0 = 0;
        !           238:                } else
        !           239:                        time(&wtmp.ut_time);
        !           240:                write(f, (char *)&wtmp, sizeof(wtmp));
        !           241:                close(f);
        !           242:        }
        !           243:        return (1);
        !           244: }
        !           245: 
        !           246: struct sigvec  mvec = { merge, sigmask(SIGTERM), 0 };
        !           247: /*
        !           248:  * Multi-user.  Listen for users leaving, SIGHUP's
        !           249:  * which indicate ttys has changed, and SIGTERM's which
        !           250:  * are used to shutdown the system.
        !           251:  */
        !           252: multiple()
        !           253: {
        !           254:        register struct tab *p;
        !           255:        register pid;
        !           256:        int omask;
        !           257: 
        !           258:        sigvec(SIGHUP, &mvec, (struct sigvec *)0);
        !           259:        for (EVER) {
        !           260:                pid = wait((int *)0);
        !           261:                if (pid == -1)
        !           262:                        return;
        !           263:                omask = sigblock(SIGHUP);
        !           264:                for (ALL) {
        !           265:                        /* must restart window system BEFORE emulator */
        !           266:                        if (p->wpid == pid || p->wpid == -1)
        !           267:                                wstart(p);
        !           268:                        if (p->pid == pid || p->pid == -1) {
        !           269:                                /* disown the window system */
        !           270:                                if (p->wpid)
        !           271:                                        kill(p->wpid, SIGHUP);
        !           272:                                rmut(p);
        !           273:                                dfork(p);
        !           274:                        }
        !           275:                }
        !           276:                sigsetmask(omask);
        !           277:        }
        !           278: }
        !           279: 
        !           280: /*
        !           281:  * Merge current contents of ttys file
        !           282:  * into in-core table of configured tty lines.
        !           283:  * Entered as signal handler for SIGHUP.
        !           284:  */
        !           285: #define        FOUND   1
        !           286: #define        CHANGE  2
        !           287: #define WCHANGE 4
        !           288: 
        !           289: merge()
        !           290: {
        !           291:        register struct tab *p;
        !           292:        register struct ttyent *t;
        !           293:        register struct tab *p1;
        !           294: 
        !           295:        for (ALL)
        !           296:                p->xflag = 0;
        !           297:        setttyent();
        !           298:        while (t = getttyent()) {
        !           299:                if ((t->ty_status & TTY_ON) == 0)
        !           300:                        continue;
        !           301:                for (ALL) {
        !           302:                        if (SCMPN(p->line, t->ty_name))
        !           303:                                continue;
        !           304:                        p->xflag |= FOUND;
        !           305:                        if (SCMPN(p->comn, t->ty_getty)) {
        !           306:                                p->xflag |= CHANGE;
        !           307:                                SCPYN(p->comn, t->ty_getty);
        !           308:                        }
        !           309:                        if (SCMPN(p->wcmd, t->ty_window)) {
        !           310:                                p->xflag |= WCHANGE|CHANGE;
        !           311:                                SCPYN(p->wcmd, t->ty_window);
        !           312:                        }
        !           313:                        goto contin1;
        !           314:                }
        !           315: 
        !           316:                /*
        !           317:                 * Make space for a new one
        !           318:                 */
        !           319:                p1 = (struct tab *)calloc(1, sizeof(*p1));
        !           320:                if (!p1) {
        !           321:                        syslog(LOG_ERR, "no space for '%s' !?!", t->ty_name);
        !           322:                        goto contin1;
        !           323:                }
        !           324:                /*
        !           325:                 * Put new terminal at the end of the linked list.
        !           326:                 */
        !           327:                if (itab) {
        !           328:                        for (p = itab; p->next ; p = p->next)
        !           329:                                ;
        !           330:                        p->next = p1;
        !           331:                } else
        !           332:                        itab = p1;
        !           333: 
        !           334:                p = p1;
        !           335:                SCPYN(p->line, t->ty_name);
        !           336:                p->xflag |= FOUND|CHANGE;
        !           337:                SCPYN(p->comn, t->ty_getty);
        !           338:                if (strcmp(t->ty_window, "") != 0) {
        !           339:                        p->xflag |= WCHANGE;
        !           340:                        SCPYN(p->wcmd, t->ty_window);
        !           341:                }
        !           342:        contin1:
        !           343:                ;
        !           344:        }
        !           345:        endttyent();
        !           346:        p1 = (struct tab *)0;
        !           347:        for (ALL) {
        !           348:                if ((p->xflag&FOUND) == 0) {
        !           349:                        term(p);
        !           350:                        wterm(p);
        !           351:                        if (p1)
        !           352:                                p1->next = p->next;
        !           353:                        else
        !           354:                                itab = p->next;
        !           355:                        free(p);
        !           356:                        p = p1 ? p1 : itab;
        !           357:                } else {
        !           358:                        /* window system should be started first */
        !           359:                        if (p->xflag&WCHANGE) {
        !           360:                                wterm(p);
        !           361:                                wstart(p);
        !           362:                        }
        !           363:                        if (p->xflag&CHANGE) {
        !           364:                                term(p);
        !           365:                                dfork(p);
        !           366:                        }
        !           367:                }
        !           368:                p1 = p;
        !           369:        }
        !           370: }
        !           371: 
        !           372: term(p)
        !           373:        register struct tab *p;
        !           374: {
        !           375: 
        !           376:        if (p->pid != 0) {
        !           377:                rmut(p);
        !           378:                kill(p->pid, SIGKILL);
        !           379:        }
        !           380:        p->pid = 0;
        !           381:        /* send SIGHUP to get rid of connections */
        !           382:        if (p->wpid > 0)
        !           383:                kill(p->wpid, SIGHUP);
        !           384: }
        !           385: 
        !           386: #include <sys/ioctl.h>
        !           387: 
        !           388: dfork(p)
        !           389:        struct tab *p;
        !           390: {
        !           391:        register pid;
        !           392:        time_t t;
        !           393:        int dowait = 0;
        !           394: 
        !           395:        time(&t);
        !           396:        p->gettycnt++;
        !           397:        if ((t - p->gettytime) >= 60) {
        !           398:                p->gettytime = t;
        !           399:                p->gettycnt = 1;
        !           400:        } else if (p->gettycnt >= 5) {
        !           401:                dowait = 1;
        !           402:                p->gettytime = t;
        !           403:                p->gettycnt = 1;
        !           404:        }
        !           405:        pid = fork();
        !           406:        if (pid == 0) {
        !           407:                signal(SIGTERM, SIG_DFL);
        !           408:                signal(SIGHUP, SIG_IGN);
        !           409:                sigsetmask(0);  /* since can be called from masked code */
        !           410:                if (dowait) {
        !           411:                        syslog(LOG_ERR, "'%s %s' failing, sleeping", p->comn, p->line);
        !           412:                        closelog();
        !           413:                        sleep(30);
        !           414:                }
        !           415:                execit(p->comn, p->line);
        !           416:                exit(0);
        !           417:        }
        !           418:        p->pid = pid;
        !           419: }
        !           420: 
        !           421: /*
        !           422:  * Remove utmp entry.
        !           423:  */
        !           424: rmut(p)
        !           425:        register struct tab *p;
        !           426: {
        !           427:        register f;
        !           428:        int found = 0;
        !           429:        static unsigned utmpsize;
        !           430:        static struct utmp *utmp;
        !           431:        register struct utmp *u;
        !           432:        int nutmp;
        !           433:        struct stat statbf;
        !           434: 
        !           435:        f = open(utmpf, O_RDWR);
        !           436:        if (f >= 0) {
        !           437:                fstat(f, &statbf);
        !           438:                if (utmpsize < statbf.st_size) {
        !           439:                        utmpsize = statbf.st_size + 10 * sizeof(struct utmp);
        !           440:                        if (utmp)
        !           441:                                utmp = (struct utmp *)realloc(utmp, utmpsize);
        !           442:                        else
        !           443:                                utmp = (struct utmp *)malloc(utmpsize);
        !           444:                        if (!utmp)
        !           445:                                syslog(LOG_ERR, "utmp malloc failed");
        !           446:                }
        !           447:                if (statbf.st_size && utmp) {
        !           448:                        nutmp = read(f, utmp, statbf.st_size);
        !           449:                        nutmp /= sizeof(struct utmp);
        !           450:                        for (u = utmp ; u < &utmp[nutmp] ; u++) {
        !           451:                                if (SCMPN(u->ut_line, p->line) ||
        !           452:                                    u->ut_name[0]==0)
        !           453:                                        continue;
        !           454:                                lseek(f, ((long)u)-((long)utmp), L_SET);
        !           455:                                SCPYN(u->ut_name, "");
        !           456:                                SCPYN(u->ut_host, "");
        !           457:                                time(&u->ut_time);
        !           458:                                write(f, (char *)u, sizeof(*u));
        !           459:                                found++;
        !           460:                        }
        !           461:                }
        !           462:                close(f);
        !           463:        }
        !           464:        if (found) {
        !           465:                f = open(wtmpf, O_WRONLY|O_APPEND);
        !           466:                if (f >= 0) {
        !           467:                        SCPYN(wtmp.ut_line, p->line);
        !           468:                        SCPYN(wtmp.ut_name, "");
        !           469:                        SCPYN(wtmp.ut_host, "");
        !           470:                        time(&wtmp.ut_time);
        !           471:                        write(f, (char *)&wtmp, sizeof(wtmp));
        !           472:                        close(f);
        !           473:                }
        !           474:                /*
        !           475:                 * After a proper login force reset
        !           476:                 * of error detection code in dfork.
        !           477:                 */
        !           478:                p->gettytime = 0;
        !           479:                p->windtime = 0;
        !           480:        }
        !           481: }
        !           482: 
        !           483: reset()
        !           484: {
        !           485: 
        !           486:        longjmp(sjbuf, 1);
        !           487: }
        !           488: 
        !           489: jmp_buf        idlebuf;
        !           490: 
        !           491: idlehup()
        !           492: {
        !           493: 
        !           494:        longjmp(idlebuf, 1);
        !           495: }
        !           496: 
        !           497: idle()
        !           498: {
        !           499:        register struct tab *p;
        !           500:        register pid;
        !           501: 
        !           502:        signal(SIGHUP, idlehup);
        !           503:        for (EVER) {
        !           504:                if (setjmp(idlebuf))
        !           505:                        return;
        !           506:                pid = wait((int *) 0);
        !           507:                if (pid == -1) {
        !           508:                        sigpause(0);
        !           509:                        continue;
        !           510:                }
        !           511:                for (ALL) {
        !           512:                        /* if window system dies, mark it for restart */
        !           513:                        if (p->wpid == pid)
        !           514:                                p->wpid = -1;
        !           515:                        if (p->pid == pid) {
        !           516:                                rmut(p);
        !           517:                                p->pid = -1;
        !           518:                        }
        !           519:                }
        !           520:        }
        !           521: }
        !           522: 
        !           523: wterm(p)
        !           524:        register struct tab *p;
        !           525: {
        !           526:        if (p->wpid != 0) {
        !           527:                kill(p->wpid, SIGKILL);
        !           528:        }
        !           529:        p->wpid = 0;
        !           530: }
        !           531: 
        !           532: wstart(p)
        !           533:        register struct tab *p;
        !           534: {
        !           535:        register pid;
        !           536:        time_t t;
        !           537:        int dowait = 0;
        !           538: 
        !           539:        time(&t);
        !           540:        p->windcnt++;
        !           541:        if ((t - p->windtime) >= 60) {
        !           542:                p->windtime = t;
        !           543:                p->windcnt = 1;
        !           544:        } else if (p->windcnt >= 5) {
        !           545:                dowait = 1;
        !           546:                p->windtime = t;
        !           547:                p->windcnt = 1;
        !           548:        }
        !           549: 
        !           550:        pid = fork();
        !           551: 
        !           552:        if (pid == 0) {
        !           553:                signal(SIGTERM, SIG_DFL);
        !           554:                signal(SIGHUP,  SIG_IGN);
        !           555:                sigsetmask(0);  /* since can be called from masked code */
        !           556:                if (dowait) {
        !           557:                        syslog(LOG_ERR, "'%s %s' failing, sleeping", p->wcmd, p->line);
        !           558:                        closelog();
        !           559:                        sleep(30);
        !           560:                }
        !           561:                execit(p->wcmd, p->line);
        !           562:                exit(0);
        !           563:        }
        !           564:        p->wpid = pid;
        !           565: }
        !           566: 
        !           567: #define NARGS  20      /* must be at least 4 */
        !           568: #define ARGLEN 512     /* total size for all the argument strings */
        !           569: 
        !           570: execit(s, arg)
        !           571:        char *s;
        !           572:        char *arg;      /* last argument on line */
        !           573: {
        !           574:        char *argv[NARGS], args[ARGLEN], *envp[1];
        !           575:        register char *sp = s;
        !           576:        register char *ap = args;
        !           577:        register char c;
        !           578:        register int i;
        !           579: 
        !           580:        /*
        !           581:         * First we have to set up the argument vector.
        !           582:         * "prog arg1 arg2" maps to exec("prog", "-", "arg1", "arg2"). 
        !           583:         */
        !           584:        for (i = 1; i < NARGS - 2; i++) {
        !           585:                argv[i] = ap;
        !           586:                for (EVER) {
        !           587:                        if ((c = *sp++) == '\0' || ap >= &args[ARGLEN-1]) {
        !           588:                                *ap = '\0';
        !           589:                                goto done;
        !           590:                        }
        !           591:                        if (c == ' ') {
        !           592:                                *ap++ = '\0';
        !           593:                                while (*sp == ' ')
        !           594:                                        sp++;
        !           595:                                if (*sp == '\0')
        !           596:                                        goto done;
        !           597:                                break;
        !           598:                        }
        !           599:                        *ap++ = c;
        !           600:                }
        !           601:        }
        !           602: done:
        !           603:        argv[0] = argv[1];
        !           604:        argv[1] = "-";
        !           605:        argv[i+1] = arg;
        !           606:        argv[i+2] = 0;
        !           607:        envp[0] = 0;
        !           608:        execve(argv[0], &argv[1], envp);
        !           609:        /* report failure of exec */
        !           610:        syslog(LOG_ERR, "%s: %m", argv[0]);
        !           611:        closelog();
        !           612:        sleep(10);      /* prevent failures from eating machine */
        !           613: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.