Return to limiter.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/limiter.c, revision 1.1

1.1     ! root        1: #include <sys/types.h>
        !             2: #include <sys/filio.h>
        !             3: #include <stdio.h>
        !             4: #include <sys/stream.h>
        !             5: 
        !             6: extern int conn_ld;
        !             7: extern int mesg_ld;
        !             8: #define        msglen(mp)      ((mp)->losize + ((mp)->hisize<<8))
        !             9: 
        !            10: int count;             /* max connections */
        !            11: fd_set serving;                /* clients being served */
        !            12: int nserving;
        !            13: fd_set waiting;                /* clients waiting */
        !            14: int nwaiting;
        !            15: int fd;                        /* mounted fd */
        !            16: 
        !            17: 
        !            18: main(ac, av)
        !            19:        int ac;
        !            20:        char *av[];
        !            21: {
        !            22:        if(ac!=3)
        !            23:                die("usage: %s path count\n", av[0]);
        !            24:        fd=mountit(av[1]);
        !            25:        count=atoi(av[2]);
        !            26:        if(count<=0)
        !            27:                die("usage: %s path count\n", av[0]);
        !            28:        detach();
        !            29:        doit();
        !            30: }
        !            31: 
        !            32: doit()
        !            33: {
        !            34:        int i, n;
        !            35:        fd_set afds;
        !            36: 
        !            37:        FD_ZERO(serving);
        !            38:        for(;;){
        !            39:                afds=serving;
        !            40:                FD_SET(fd, afds);
        !            41:                switch(n=select(NOFILE, &afds, 0, 10000L)){
        !            42:                case -1:
        !            43:                        /* there's a bad fd in the group */
        !            44:                        afds=serving;
        !            45:                        for(i=0; i<NOFILE; i++)
        !            46:                                if(FD_ISSET(i, afds))
        !            47:                                        dropclient(i);
        !            48:                        break;
        !            49:                case 0:
        !            50:                        /* timeout, try again */
        !            51:                        break;
        !            52:                default:
        !            53:                        /* look for new clients */
        !            54:                        if(FD_ISSET(fd, afds)){
        !            55:                                request();
        !            56:                                n--;
        !            57:                        }
        !            58: 
        !            59:                        /* someone needs servicing */
        !            60:                        for(i=0; n && i<NOFILE; i++){
        !            61:                                if(FD_ISSET(i, afds)){
        !            62:                                        dropclient(i);
        !            63:                                        n--;
        !            64:                                }
        !            65:                        }
        !            66:                        break;
        !            67:                }
        !            68:        }
        !            69: }
        !            70: 
        !            71: newclient(cfd)
        !            72:        int cfd;
        !            73: {
        !            74:        FD_SET(cfd, waiting);
        !            75:        nwaiting++;
        !            76:        wtos();
        !            77: }
        !            78: 
        !            79: dropclient(cfd)
        !            80:        int cfd;
        !            81: {
        !            82:        FD_CLR(cfd, serving);
        !            83:        nserving--;
        !            84:        close(cfd);
        !            85:        wtos();
        !            86: }
        !            87: 
        !            88: wtos()
        !            89: {
        !            90:        int i=0;
        !            91:        struct mesg m;
        !            92: 
        !            93:        while(nwaiting && nserving<count){
        !            94:                for(;i<NOFILE;i++){
        !            95:                        if(FD_ISSET(i,waiting)){
        !            96:                                nwaiting--;
        !            97:                                nserving++;
        !            98:                                FD_SET(i, serving);
        !            99:                                FD_CLR(i, waiting);
        !           100:                                m.losize = 0;
        !           101:                                m.hisize = 0 >> 8;
        !           102:                                m.type = M_HANGUP;
        !           103:                                m.magic = MSGMAGIC;
        !           104:                                if(ioctl(i, FIOACCEPT, (void *)0)<0
        !           105:                                || ioctl(i, FIOPUSHLD, &mesg_ld)<0
        !           106:                                || write(i, &m, sizeof(m))!=sizeof(m)){
        !           107:                                        close(i);
        !           108:                                        FD_CLR(i, serving);
        !           109:                                        nserving--;
        !           110:                                        continue;
        !           111:                                }
        !           112:                        }
        !           113:                }
        !           114:        }
        !           115: }
        !           116: 
        !           117: request()
        !           118: {
        !           119:        struct passfd pass;
        !           120: 
        !           121:        if(ioctl(fd, FIORCVFD, &pass)<0)
        !           122:                abort();
        !           123:        newclient(pass.fd);
        !           124: }
        !           125: 
        !           126: mountit(path)
        !           127:        char *path;
        !           128: {
        !           129:        int pfd[2];
        !           130: 
        !           131:        /* make a node to mount onto */
        !           132:        if (access(path,0)<0 && creat(path, 0666)<0)
        !           133:                die("can't creat %s\n", path);
        !           134: 
        !           135:        /* get the stream to mount */
        !           136:        if (pipe(pfd) < 0)
        !           137:                die("out of pipes\n", 0);
        !           138:        if (ioctl(pfd[1], FIOPUSHLD, &conn_ld) < 0)
        !           139:                die("can't push line discipline\n", 0);
        !           140: 
        !           141:        /* mount */
        !           142:        if (fmount(3, pfd[1], path, 0) < 0)
        !           143:                die("can't mount onto %s\n", path);
        !           144:        umask(0);
        !           145:        chmod(path, 0666);
        !           146:        close(pfd[1]);
        !           147:        return pfd[0];
        !           148: }
        !           149: 
        !           150: detach()
        !           151: {
        !           152:        switch(fork()){
        !           153:        case -1:
        !           154:                die("can't fork\n", 0);
        !           155:        case 0:
        !           156:                break;
        !           157:        default:
        !           158:                exit(0);
        !           159:        }
        !           160:        for(fd=0; fd<NSYSFILE; fd++)
        !           161:                close(fd);
        !           162:        setpgrp(getpid(), getpid());
        !           163: }
        !           164: 
        !           165: die(a, b)
        !           166:        char *a;
        !           167: {
        !           168:        fprintf(stderr, a, b);
        !           169:        exit(1);
        !           170: }

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