Return to init.c CVS log

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

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

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