Return to udemon2.c CVS log

Up to [Research Unix] / researchv10no / cmd / udemon

Annotation of researchv10no/cmd/udemon/udemon2.c, revision 1.1

1.1     ! root        1: #
        !             2: 
        !             3: #include <stdio.h>
        !             4: #include "udemon.h"
        !             5: 
        !             6: char argspec[OPNUM][3]         /* required arg types (reverse order) */
        !             7: {                      /* negative entry = any non-name type */
        !             8:        0, 0, 0,                /*OK*/
        !             9:        -1, NTYPE, 0,           /*DEFINE*/
        !            10:        -1, NTYPE, 0,           /*REDEFINE*/
        !            11:        NTYPE, 0, 0,            /*DELETE*/
        !            12:        0, 0, 0,                /*spare*/
        !            13:        0, 0, 0,                /*EOM*/
        !            14:        0, 0, 0,                /*unu   gd*/
        !            15:        0, 0, 0,                /*XMT*/
        !            16:        0, 0, 0,                /*spare*/
        !            17:        0, 0, 0,                /*POP*/
        !            18:        DTYPE, 0, 0,            /*CDIR*/
        !            19:        IITYPE, IITYPE, FTYPE,  /*CMODE*/
        !            20:        XTYPE, FTYPE, 0,        /*OPEN*/
        !            21:        RTYPE, 0, 0,            /*CLOSE*/
        !            22:        IITYPE, RTYPE, 0,       /*SEEK*/
        !            23:        XTYPE, RTYPE, 0,        /*READ*/
        !            24:        XTYPE, RTYPE, 0,        /*WRITE*/
        !            25:        XTYPE, RTYPE, 0,        /*TRUNCATE*/
        !            26:        NTYPE, 0, 0,            /*LOGIN*/
        !            27:        0, 0, 0,                /*QUIT*/
        !            28:        DTYPE, 0, 0,            /*LIST*/
        !            29:        -1, 0, 0,               /*STATUS*/
        !            30:        0, 0, 0,                /*TIME*/
        !            31:        NTYPE, XTYPE, 0,                /*UNIQUE*/
        !            32:        RTYPE, 0, 0,            /*APPEND*/
        !            33:        0, 0, 0,                /*spare*/
        !            34:        WTYPE, -1, 0,           /*ASSIGN*/
        !            35:        NTYPE, XTYPE, 0,        /*FCREATE*/
        !            36:        NTYPE, 0, 0,            /*IF*/
        !            37:        0, 0, 0,                /*FI*/
        !            38:        IITYPE, 0, 0,           /*SKIP*/
        !            39:        NTYPE, XTYPE, 0,        /*DCREATE*/
        !            40:        0, 0, 0,                /*spare*/
        !            41:        NTYPE, 0, 0             /*UNLESS*/
        !            42: };
        !            43: 
        !            44: char nodef[MAXTYPE] {          /*non-zero if type can be used in definition*/
        !            45:        0, 0, 0, 0, 0, 0, 0, 0,
        !            46:        1, 1, 1, 0, 0, 0, 0, 0};
        !            47: 
        !            48: 
        !            49: 
        !            50: deref(xsp)
        !            51: struct sentry *xsp;
        !            52: {
        !            53:        register i, r;
        !            54:        switch (xsp->s_type){
        !            55:        case NTYPE:
        !            56:                if (dstat(ncopy(xsp),&entry) < 0) 
        !            57:                        error(EUNDEF,2);
        !            58:                xsp->s_type = dcheck(xsp);
        !            59:                prt("deref ret %o\n",xsp->s_type);
        !            60:                break;
        !            61:        case WTYPE:
        !            62:                i = xsp->s_val1;
        !            63:                if ((i < 0) || (i >= VARNO)) 
        !            64:                        error(EWADDR,2);
        !            65:                xsp->s_type = wstore[i].s_type;
        !            66:                xsp->s_val = wstore[i].s_val;
        !            67:                xsp->s_val1 = wstore[i].s_val1;
        !            68:                break;
        !            69:        case NULL:
        !            70:                error(EARGT,6);
        !            71:        }
        !            72: }
        !            73: 
        !            74: 
        !            75: argpush(xsp)
        !            76: struct sentry **xsp;
        !            77: {
        !            78:        register struct sentry *pp, *ss;
        !            79: 
        !            80:        ss = sp++;
        !            81:        pp = sp;
        !            82:        while (ss != *xsp){
        !            83:                pp->s_type = ss->s_type;
        !            84:                pp->s_val = ss->s_val;
        !            85:                (pp--)->s_val1 = (ss--)->s_val1;
        !            86:        }
        !            87:        *xsp = pp;
        !            88: }
        !            89: 
        !            90: 
        !            91: 
        !            92: respond(t)
        !            93: char t;
        !            94: {
        !            95:        if (t) *rp++ = t;
        !            96:        if (send(resp,rp-resp,3)) 
        !            97:                return(1);
        !            98:        rp = resp;
        !            99:        return(0);
        !           100: }
        !           101: 
        !           102: 
        !           103: 
        !           104: addup(b,n)
        !           105: int n; 
        !           106: char *b;
        !           107: {
        !           108:        register k,s; 
        !           109:        register char *p;
        !           110: 
        !           111:        s=0;
        !           112:        p = b;
        !           113:        if (n>0){
        !           114:                for (k=0; k<n; k++)
        !           115:                         s =+ p[k];
        !           116:        }
        !           117:        return(s);
        !           118: }
        !           119: 
        !           120: 
        !           121: send(p,n,c)
        !           122: char *p; 
        !           123: int n,c;
        !           124: {
        !           125:        extern timeout();
        !           126:        register r;
        !           127: 
        !           128:        if (c==3) {
        !           129:                prt("send "); 
        !           130:                tprint(p,n);
        !           131:        }else
        !           132:            prt("send data %d,%d\n",n,c);
        !           133:        signal(14,timeout); 
        !           134:        alarm(30);
        !           135:        snstat(fn,&c,0);
        !           136:        r = write(fn,p,n);
        !           137:        alarm(0);
        !           138:        if (r < 0 || panic) 
        !           139:                return(1);
        !           140:        return(0);
        !           141: }
        !           142: 
        !           143: 
        !           144: timeout()
        !           145: {
        !           146:        prt("timeout\n");
        !           147:        panic = 1;
        !           148: }
        !           149: 
        !           150: 
        !           151: recv(b,c)
        !           152: int *c; 
        !           153: char *b;
        !           154: {
        !           155:        register n;
        !           156:        register i;
        !           157:        if ((n = read(fn,b,512)) < 0) 
        !           158:                return(-1);
        !           159:        snstat(fn,c,1);
        !           160:        if (*c==3) {
        !           161:                prt("received "); 
        !           162:                tprint(b,n);
        !           163:        }else
        !           164:            prt("received data %d,%d\n",n,*c);
        !           165:        if (trace){
        !           166: /*
        !           167:                for (i=0; i<n; i++){
        !           168:                        printf("%3.1o ",b[i]&0377);
        !           169:                        if ((i&7) == 7 || i == (n-1))
        !           170:                                printf("\n");
        !           171:                }
        !           172: */
        !           173:        }
        !           174:        return(n);
        !           175: }
        !           176: 
        !           177: 
        !           178: 
        !           179: closeall(){
        !           180:        register i;
        !           181: 
        !           182:        for (i=0; i<OPENS; i++)
        !           183:                if (openf[i]) {
        !           184:                        close(i); 
        !           185:                        openf[i] = 0;
        !           186:                }
        !           187:        for (i=0; i<VARNO; i++)
        !           188:                wstore[i].s_type = 0;
        !           189: }
        !           190: 
        !           191: 
        !           192: logout()
        !           193: {
        !           194:        register g,t;
        !           195:        static struct utmp z;
        !           196:        long    l;
        !           197: 
        !           198:        login = 0;
        !           199:        utmp.u_name[0] = 0;
        !           200: #ifdef ACCT
        !           201:        if ((g = open("/tmp/utmp",1)) >= 0){
        !           202:                t = utmp.u_tty;
        !           203:                if(t >= 'a')
        !           204:                        t =- 'a' - (10+'0');
        !           205:                if((t >= 'A')&&(t<= 'Z'))
        !           206:                        t = 10 + 'z' - 'a' + 1 + '0' + (t - 'A');
        !           207:                l = (t-'0')*16;
        !           208:                seek(g, l, 0);
        !           209:                if(write(g,&utmp,16)<0){
        !           210:                        prt("write in utmp failed\n");
        !           211:                }
        !           212:                close(g);
        !           213:        }
        !           214:        if((g = open("/usr/adm/wtmp",1)) >= 0){
        !           215:                z.u_tty = utmp.u_tty;
        !           216:                time(&z.u_time[0]);
        !           217:                seek(g,0L,2);
        !           218:                write(g,&z,16);
        !           219:                close(g);
        !           220:        }
        !           221: #endif
        !           222: }
        !           223: 
        !           224: 
        !           225: /*
        !           226:  *  data from (fil) , block size (cp).
        !           227:  * k = 0 if (cp) not set, = 1 normal, = 2 if directory entry
        !           228:  */
        !           229: 
        !           230: rcopy(fil,k,cp) 
        !           231: {
        !           232:        register n, code;
        !           233:        long    tell();
        !           234:        register char *bp;
        !           235: 
        !           236:        if (respond(READ)) return(1);
        !           237:        length = 0;
        !           238:        sum = 0;
        !           239:        for (;;){
        !           240:                n = ((k>0)&&(cp<msiz)) ? cp : msiz;
        !           241:                if(trace)
        !           242:                        printf("com %d %d %d %d\n",n,k,cp,msiz);
        !           243:                if(trace)
        !           244:                        printf("posit %d %O\n",fil,tell(fil));
        !           245:                n = read(fil,buf,n);
        !           246:                if(trace)
        !           247:                        printf("read %o %o %o\n",fil,buf,n);
        !           248:                if(trace&&((n == 0) || (n<0))){
        !           249:                        perror("read");
        !           250:                        printf("n = %d %d %d\n",fil,n,k);
        !           251:                }
        !           252:                if (n < 0) 
        !           253:                        error(0,6);
        !           254:                if (k == 2){
        !           255:                        if (n != cp) {
        !           256:                                n=0; 
        !           257:                                code = 4;
        !           258:                        }else
        !           259:                        if (buf[0] == 0) 
        !           260:                                continue;
        !           261:                        else{
        !           262:                                code = 1;
        !           263:                        }
        !           264:                }else
        !           265:                        if (k>0){
        !           266:                                cp =- n;
        !           267:                                code = (cp==0) ? 2 : ((n==msiz) ? 1 : 4);
        !           268:                        }else
        !           269:                                if (k<0) code = (n==0) ? 4 : 1;
        !           270:                                else
        !           271:                                        code = (n==msiz) ? 1 : 4;
        !           272:                length =+ n;
        !           273:                sum =+ addup(buf,n);
        !           274:                prt("part sum %o %o\n",sum , n);
        !           275:                if (send(buf,n,code)) 
        !           276:                        return(1);
        !           277:                if (code > 1) 
        !           278:                        break;
        !           279:        }
        !           280:        bp = buf;
        !           281:        *bp++ = 'K';
        !           282:        *bp++ = (sum >> 8); *bp++ = (sum &0377);
        !           283:        *bp++ = (length >> 8); *bp++ = (length&0377);
        !           284:        prt("send checksum %o %o\n",sum, length);
        !           285:        if(send(buf,5,3) < 0)
        !           286:                return(1);
        !           287:        prt("checksum ok\n");
        !           288:        return(0);
        !           289: }
        !           290: 
        !           291: ncopy(p)
        !           292: struct sentry *p;
        !           293: {
        !           294:        register i;
        !           295:        register char *np;
        !           296: 
        !           297:        prt("ncopy %o\n",p->s_type);
        !           298:        if (p->s_type == NTYPE){
        !           299:                np = p->s_val1;
        !           300:                prt("Ntype %s\n",np);
        !           301:                for (i=0; i<(NSIZ-1); i++){
        !           302:                        if (*np == 0) break;
        !           303:                        nbuf[i] = *np++;
        !           304:                }
        !           305:                nbuf[i] = 0;
        !           306:                return(nbuf);
        !           307:        }
        !           308:        prt("ncopy ret %o\n",p->s_val1);
        !           309:        return(p->s_val1);
        !           310: }
        !           311: 
        !           312: 
        !           313: decimal(v)
        !           314: char *v;
        !           315: {
        !           316:        register n, negative;
        !           317:        char c;
        !           318: 
        !           319:        n=0; 
        !           320:        negative=0;
        !           321:        while (c = *v++){
        !           322:                if ((n==0) && (c=='-')) {
        !           323:                        negative=1; 
        !           324:                        continue;
        !           325:                }
        !           326:                if ((c < '0') || (c > '9')) {
        !           327:                        mesg("Bad buffer size");
        !           328:                        exit(EBAD);
        !           329:                }
        !           330:                n = (n*10) + (c-'0');
        !           331:        }
        !           332:        if (negative) 
        !           333:                n = -n;
        !           334:        return(n);
        !           335: }
        !           336: 
        !           337: 
        !           338: dcheck(p){
        !           339:        register i;
        !           340: 
        !           341:        prt("dcheck on %s\n",ncopy(p));
        !           342:        if (filstat(ncopy(p),&statbuf) < 0) 
        !           343:                return(NULL);
        !           344:        if (statbuf->type == FFILE) 
        !           345:                return(FTYPE);
        !           346:        if (statbuf->type == DIR) 
        !           347:                return(DTYPE);
        !           348:        return(NULL);
        !           349: }
        !           350: char   pbuf[128];
        !           351: getpwentry(uname)
        !           352: char *uname;
        !           353: {
        !           354:        char    *np,*namep;
        !           355:        extern char *copy();
        !           356:        int     t,f;
        !           357:        long    l;
        !           358:        int     i;
        !           359: 
        !           360:        utmp.u_tty = 'A' + chan;
        !           361:        if(getent(uname,pbuf))
        !           362:                return(1);
        !           363:        np = colon(pbuf);
        !           364: #ifdef ROOT
        !           365:        if(*np != ':')
        !           366:                return(1);
        !           367: #endif
        !           368:        for(i=0;i<8;i++)
        !           369:                utmp.u_name[i] = 0;
        !           370:        copy(utmp.u_name,pbuf,t = (size(pbuf)>8)?8:size(pbuf));
        !           371:        np = colon(np);
        !           372:        uid = 0;
        !           373:        while (*np != ':')
        !           374:                uid = uid*10 + *np++ - '0';
        !           375: #ifndef ROOT
        !           376:        if(uid == ROOTUSR)              /* disallow root */
        !           377:                return(1);      /* */
        !           378: #endif
        !           379:        np++;
        !           380:        np = colon(np);         /* skip group id */
        !           381:        np = colon(np);
        !           382:        namep = np;
        !           383:        np = colon(np);
        !           384:        prt("dir = %s\n",namep);
        !           385:        copy(unixid,namep,  t = (size(namep)>8)?8:size(namep));
        !           386:        if (chdir(namep)<0) {
        !           387:                error(0,9);
        !           388:        }
        !           389:        time(&utmp.u_time[0]);
        !           390: #ifdef ACCT
        !           391:        if ((f = open("/tmp/utmp", 1)) >= 0) {
        !           392:                t = utmp.u_tty;
        !           393:                if (t>='a')
        !           394:                        t =- 'a' - (10+'0');
        !           395:                if((t >= 'A')&&(t<= 'Z'))
        !           396:                        t = 10 + 'z' - 'a' + 1 + '0' + (t - 'A');
        !           397:                l = (t-'0')*16;
        !           398:                seek(f, l, 0);
        !           399:                write(f, &utmp, 16);
        !           400:                close(f);
        !           401:        }
        !           402:        if ((f = open("/usr/adm/wtmp", 1)) >= 0) {
        !           403:                seek(f, 0L, 2);
        !           404:                write(f, &utmp, 16);
        !           405:                close(f);
        !           406:        }
        !           407: #endif
        !           408:        return(0);
        !           409: }
        !           410: char   ab[BUFSIZ];
        !           411: getent(name, rbuf)
        !           412: char *name, *rbuf;
        !           413: {
        !           414:        int fi, r, c;
        !           415:        FILE *ffin;
        !           416:        register char *gnp, *rnp;
        !           417: 
        !           418:        r = 1;
        !           419:        if((ffin = fopen(netpwd, "r")) == NULL){
        !           420:                prt("Can't open passwd");
        !           421:                goto ret;
        !           422: 
        !           423:        }
        !           424:        setbuf(ffin,&ab);
        !           425: loop:
        !           426:        gnp = name;
        !           427:        rnp = rbuf;
        !           428:        while((c=getc(ffin)) != '\n') {
        !           429:                if(c == EOF)
        !           430:                        goto ret;
        !           431: 
        !           432:                *rnp++ = c;
        !           433:        }
        !           434:        *rnp++ = '\0';
        !           435:        rnp = rbuf;
        !           436:        while (*gnp++ == *rnp++);
        !           437:        if ((*--gnp!='\0')  || *--rnp!=':')
        !           438:                goto loop;
        !           439: 
        !           440:        r = 0;
        !           441: ret:
        !           442:        fclose(ffin);
        !           443:        return(r);
        !           444: }
        !           445: 
        !           446: colon(p)
        !           447: register char *p;
        !           448: {
        !           449: 
        !           450:        while (*p != ':') {
        !           451:                if (*p++ == '\0') {
        !           452:                        error(EPWD,2);
        !           453:                }
        !           454:        }
        !           455:        *p++ = '\0';
        !           456:        return(p);
        !           457: }
        !           458: dstat(p,bp)
        !           459: struct dentry  *bp;
        !           460: char   *p;
        !           461: {
        !           462:        int     f;
        !           463: 
        !           464:        prt("dstat on %s\n",p);
        !           465:        bp->d_type = NULL;
        !           466:        if((f = open(p,0)) < 0)
        !           467:                return(-1);
        !           468:        close(f);
        !           469:        bp->d_type = NTYPE;
        !           470:        return(1);
        !           471: }
        !           472: /*
        !           473:  * Copy c characters of q into p
        !           474:  */
        !           475: char *copy(p,q,c)
        !           476: register char  *p,*q;
        !           477: int    c;
        !           478: {
        !           479:        register i;
        !           480: 
        !           481:        for(i=0;i<c;i++){
        !           482:                *p++ = *q++;
        !           483:        }
        !           484:        return(c);
        !           485: }
        !           486: /*
        !           487:  * Length of string
        !           488:  */
        !           489: size(s)
        !           490: register char *s;
        !           491: {
        !           492:        register i;
        !           493: 
        !           494:        i = 0;
        !           495:        while(*s++ != '\0')
        !           496:                i++;
        !           497:        return(i);
        !           498: }

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