Return to dkhup.c CVS log

Up to [Research Unix] / researchv10no / ipc / mgrs / ndkmgr

Annotation of researchv10no/ipc/mgrs/ndkmgr/dkhup.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <sys/dkio.h>
        !             3: #include <signal.h>
        !             4: #include <errno.h>
        !             5: #include <ctype.h>
        !             6: 
        !             7: char *netfiles = "/dev/dk/dk";
        !             8: #define        TRAFFIC 2       /* if unit != b, dkctlchan ignores this anyway */
        !             9: #define        DEFUNIT 'a'
        !            10: 
        !            11: main(argc, argv)
        !            12: int argc;
        !            13: char **argv;
        !            14: {
        !            15:        int unit;
        !            16:        int noinit;
        !            17:        int fd;
        !            18:        int i;
        !            19: 
        !            20:        unit = DEFUNIT; /* look at netfiles by default */
        !            21:        noinit = 0;
        !            22:        for (i = 1; i < argc; i++) {
        !            23:                if (strcmp(argv[i], "-t") == 0)
        !            24:                        continue;
        !            25:                if (isdigit(*argv[i])) {
        !            26:                        unit = *argv[i];
        !            27:                        continue;
        !            28:                }
        !            29:                if (strcmp(argv[i], "-i") == 0) {
        !            30:                        noinit = 1;
        !            31:                        continue;
        !            32:                }
        !            33:                if (strcmp(argv[i], "-N") == 0 && ++i < argc) {
        !            34:                        netfiles = argv[i];
        !            35:                        continue;
        !            36:                }
        !            37:                fprintf(stderr, "usage: dkhup [-N netfiles] [-t [02]]\n");
        !            38:                exit(1);
        !            39:        }
        !            40:        setup();
        !            41:        fd = init(unit, noinit);
        !            42:        if (fork())
        !            43:                exit(0);
        !            44:        i = 0;
        !            45:        for (;;) {
        !            46:                if (takemesg(fd) > 0) {
        !            47:                        i = 0;
        !            48:                        continue;
        !            49:                }
        !            50:                if (++i < 5) {          /* give it a few tries */
        !            51:                        sleep(1);
        !            52:                        continue;
        !            53:                }
        !            54:                fd = reset(unit, fd);
        !            55:        }
        !            56: }
        !            57: 
        !            58: setup()
        !            59: {
        !            60:        signal(SIGINT, SIG_IGN);
        !            61:        signal(SIGQUIT, SIG_IGN);
        !            62:        signal(SIGHUP, SIG_IGN);
        !            63:        signal(SIGTERM, SIG_IGN);
        !            64:        signal(SIGPIPE, SIG_IGN);
        !            65: }
        !            66: 
        !            67: int
        !            68: init(unit, noinit)
        !            69: int unit, noinit;
        !            70: {
        !            71:        int fd;
        !            72: 
        !            73:        if ((fd = dkctlchan(TRAFFIC, unit)) < 0) {
        !            74:                fprintf(stderr, "dkhup %s %c: can't open control channel\n", netfiles, unit);
        !            75:                return (-1);
        !            76:        }
        !            77:        if (noinit == 0) {
        !            78:                ioctl(fd, DIOCHUP, 0);
        !            79:                ioctl(fd, DIOCHUP, 0);
        !            80:                ioctl(fd, DIOCHUP, 0);
        !            81:        }
        !            82:        ioctl(fd, DIOCNXCL, 0);
        !            83:        return (fd);
        !            84: }
        !            85: 
        !            86: /*
        !            87:  * wait for a message from the CMC
        !            88:  * this shouldn't happen;
        !            89:  * messages are supposed to be intercepted by the system
        !            90:  * if the read returns an error,
        !            91:  * the interface shut down
        !            92:  */
        !            93: 
        !            94: takemesg(fd)
        !            95: int fd;
        !            96: {
        !            97:        int n;
        !            98:        char buf[64];
        !            99: 
        !           100:        if ((n = read(fd, buf, sizeof(buf))) <= 0)
        !           101:                return (-1);
        !           102:        /*
        !           103:         * if it was interesting to print the message,
        !           104:         * this would be the place to do so
        !           105:         */
        !           106:        return (1);
        !           107: }
        !           108: 
        !           109: /*
        !           110:  * reset after an error
        !           111:  * close the channel, try to reset the KMC (assumed)
        !           112:  */
        !           113: 
        !           114: int
        !           115: reset(unit, fd)
        !           116: int unit;
        !           117: int fd;
        !           118: {
        !           119:        fprintf(stderr, "dkhup %s %c: error %d; resetting\n", netfiles, unit, errno);
        !           120:        ioctl(fd, KIOCSHUT, 0);
        !           121:        close(fd);
        !           122:        sleep(45);
        !           123:        loadkmc(unit);
        !           124:        sleep(5);
        !           125:        while ((fd = init(unit, 0)) < 0) {
        !           126:                fprintf(stderr, "dkhup %s %c: can't reinit\n", netfiles, unit);
        !           127:                sleep(60);      /* or just exit? */
        !           128:        }
        !           129:        return (fd);
        !           130: }
        !           131: 
        !           132: loadkmc(unit)
        !           133: int unit;
        !           134: {
        !           135:        char buf[64];
        !           136: 
        !           137:        if (unit == DEFUNIT)
        !           138:                unit = '2';             /* ugh */
        !           139:        sprintf(buf, "cd /usr/dk; /etc/kmcdump %c", unit);
        !           140:        system(buf);
        !           141:        sprintf(buf, "/etc/kdiload %c", unit);
        !           142:        system(buf);
        !           143: }

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