Return to mach.c CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / berknet

Annotation of 41BSD/cmd/berknet/mach.c, revision 1.1

1.1     ! root        1: /*
        !             2:    This file is meant to handle all the machine
        !             3:    dependencies in the network code.
        !             4:    Everything is conditionally compiled.
        !             5: 
        !             6:    It can be uses w/o network stuff to simulate
        !             7:    v7 for other programs, too.
        !             8: */
        !             9: # include <stdio.h>
        !            10: # include "mach.h"
        !            11: 
        !            12: char shomedir[100];
        !            13: 
        !            14: int debugflg;
        !            15: 
        !            16: /* the CC and SRC machines have the submit() call */
        !            17: # ifndef CC
        !            18: # ifndef SRC
        !            19: submit(a) {}
        !            20: # endif
        !            21: # endif
        !            22: 
        !            23: # ifdef FUID
        !            24: setgid() {};
        !            25: # endif
        !            26: 
        !            27: /* 
        !            28:    Set the owner uid/gid of a file.
        !            29:    On v7, this is done by the chown command
        !            30:    with three args - (file, uid, gid).
        !            31:    On Vanilla V6 this is done using the
        !            32:    top byte of the second parameter as the gid byte.
        !            33:    On Berkeley Funny uids on V6, no gid is specified.
        !            34: */
        !            35: mchown(sfn,uid,gid)
        !            36:        char *sfn;
        !            37:        int uid;
        !            38:        int gid;
        !            39: {
        !            40: # ifndef V6
        !            41:        chown(sfn,uid,gid);
        !            42: # else
        !            43: # ifndef FUID
        !            44:                uid = uidmask(uid);
        !            45:                uid = ((gid&0377) << 8) | (uid & 0377);
        !            46: # endif
        !            47:        chown(sfn,uid);
        !            48: # endif
        !            49: }
        !            50:        
        !            51: 
        !            52: /*
        !            53:        SnFromuid(uid)
        !            54: 
        !            55:        The login name corresponding to uid.
        !            56:        Reads the password file.
        !            57:        Successive calls overwrite the static string returned.
        !            58:        Returns NULL if error.
        !            59: */
        !            60: char *SnFromUid(uid)
        !            61:        register int uid;
        !            62: {
        !            63:        register struct passwd *pwd;
        !            64:        static int ouid = -1;
        !            65:        static char oresult[20] = "";
        !            66:        uid = uidmask(uid);
        !            67:        if(uid == ouid)
        !            68:                return(oresult);
        !            69: # ifdef HPASSWD
        !            70:        if(getname(uid,oresult) == 0){
        !            71:                ouid = uid;
        !            72:                return(oresult);
        !            73:        }
        !            74: # endif
        !            75:        pwd = getpwuid(uid);
        !            76:        if(pwd != NULL){
        !            77:                strcpy(oresult,pwd->pw_name);
        !            78:                ouid = uid;
        !            79:                return(oresult);
        !            80:        }
        !            81:        return(NULL);
        !            82: }
        !            83: uidfromsn(sn)
        !            84: register char *sn;
        !            85: {
        !            86:        register int him = -1;
        !            87:        register struct passwd *pwd;
        !            88: # ifdef HPASSWD
        !            89:        him = getuserid(sn);
        !            90: # endif
        !            91:        if(him == -1){
        !            92:                pwd = getpwnam(sn);
        !            93:                if(pwd != NULL)him = guid(pwd->pw_uid,pwd->pw_gid);
        !            94:                }
        !            95:        return(him);
        !            96: }
        !            97: 
        !            98: /* handle the regular unix and local mods difference for user id's */
        !            99: /* this call returns the 1 word uid = to what getuid will return */
        !           100: guid(uid,gid){
        !           101:        uid = uidmask(uid);
        !           102: # ifdef FUID
        !           103:        return((uid & 0377) | (gid << 8));
        !           104: # else
        !           105:        return(uid);
        !           106: # endif
        !           107:        }
        !           108: 
        !           109: # ifdef OLDTTY
        !           110: isatty(i){
        !           111:        return(ttyn(i) != 'x');
        !           112:        }
        !           113: char *ttyname(i){              /* return NULL if not TTY */
        !           114:        char c;
        !           115:        static char ttystr[] = "/dev/ttyx";
        !           116:        c = ttyn(i);
        !           117:        ttystr[8] = c;
        !           118:        return(c == 'x' ? NULL : ttystr);
        !           119:        }
        !           120: # endif
        !           121: 
        !           122: # ifdef CCTTY
        !           123: # undef ttyname()
        !           124: char *myttyname(i){            /* return NULL for non tty */
        !           125:        static char s[15],*p;
        !           126:        p = ttyname(i);
        !           127:        if(p == NULL)return(NULL);
        !           128:        strcpy(s,"/dev/");
        !           129:        strcat(s,p);
        !           130:        return(s);
        !           131:        }
        !           132: # define ttyname(S) myttyname(S)
        !           133: # endif
        !           134: 
        !           135: /* expand control chars in string s */
        !           136: expandcc(s)
        !           137:   register char *s; {
        !           138:        char stemp[100];
        !           139:        register char *p;
        !           140: 
        !           141:        if(s == NULL)return;
        !           142:        strcpy(stemp,s);
        !           143:        p = stemp;
        !           144:        while(*p){
        !           145:                if(!isprint(*p)){
        !           146:                        *s++ = '^';
        !           147:                        *s++ = *p++ + 0140;
        !           148:                }
        !           149:                else *s++ = *p++;
        !           150:        }
        !           151: }
        !           152: 
        !           153: /* get passwd from passwdf */
        !           154: getpwdf(pwd)
        !           155:   struct passwd *pwd; {
        !           156: # ifdef PASSWDF
        !           157: # ifndef TESTING
        !           158:        register char *p, *q;
        !           159:        char buf1[BUFSIZ], found;
        !           160:        FILE *pw;
        !           161:        debug("reading passwdf\n");
        !           162:        pwd->pw_passwd[0] = 0;
        !           163:        pw = fopen("/etc/passwdf","r");
        !           164:        if(pw == NULL) return;
        !           165:        found = 0;
        !           166:        while(fgets(buf1,BUFSIZ,pw) != NULL){
        !           167:                for(p=buf1; *p && *p != ':'; p++);
        !           168:                *p = 0;
        !           169:                if(strcmp(buf1,pwd->pw_name) == 0){
        !           170:                        found = 1;
        !           171:                        break;
        !           172:                        }
        !           173:                }
        !           174:        fclose(pw);
        !           175:        if(!found)return;
        !           176:        q = ++p;
        !           177:        for(;*p && *p != ':';p++);
        !           178:        *p = 0;
        !           179:        strcpy(pwd->pw_passwd,q);
        !           180:        /*
        !           181:        debug("user %s passwd %s %s",pwd->pw_name,pwd->pw_passwd);
        !           182:        */
        !           183: # endif
        !           184: # endif
        !           185:        }
        !           186: /*
        !           187:        getutmp()
        !           188:        return a pointer to the system utmp structure associated with
        !           189:        terminal sttyname, e.g. "/dev/tty3"
        !           190:        Is version independent-- will work on v6 systems
        !           191:        return NULL if error
        !           192: */
        !           193: struct utmp *getutmp(sttyname)
        !           194: char *sttyname;
        !           195: {
        !           196: # ifdef OLDTTY
        !           197:        struct v6utmp {
        !           198:                char v6ut_name[8];
        !           199:                char v6ut_tty;
        !           200:                char v6ut_fill;
        !           201:                long v6ut_time;
        !           202:                int  v6ut_fl1;
        !           203:                } v6utmpstr;
        !           204: # endif
        !           205:        static struct utmp utmpstr;
        !           206:        FILE *fdutmp;
        !           207: 
        !           208:        debug("reading utmp\n");
        !           209:        if(sttyname == NULL || sttyname[0] == 0)return(NULL);
        !           210: 
        !           211:        fdutmp = fopen("/etc/utmp","r");
        !           212:        if(fdutmp == NULL)return(NULL);
        !           213: 
        !           214: # ifndef OLDTTY
        !           215:        while(fread(&utmpstr,1,sizeof utmpstr,fdutmp) == sizeof utmpstr)
        !           216:                if(strcmp(utmpstr.ut_line,sttyname+5) == 0){
        !           217:                        fclose(fdutmp);
        !           218:                        return(&utmpstr);
        !           219:                }
        !           220: # else
        !           221:        while(fread(&v6utmpstr,1,sizeof v6utmpstr,fdutmp) == sizeof v6utmpstr)
        !           222:                if(v6utmpstr.v6ut_tty == sttyname[8]){
        !           223:                        strcpy(utmpstr.ut_name,v6utmpstr.v6ut_name);
        !           224:                        strcpy(utmpstr.ut_line,"ttyx");
        !           225:                        utmpstr.ut_line[3] = v6utmpstr.v6ut_tty;
        !           226:                        utmpstr.ut_time = v6utmpstr.v6ut_time;
        !           227:                        fclose(fdutmp);
        !           228:                        return(&utmpstr);
        !           229:                }
        !           230: # endif
        !           231:        fclose(fdutmp);
        !           232:        return(NULL);
        !           233: }
        !           234: 
        !           235: /*
        !           236:    these are all the v7 routines not available on the v6 machines
        !           237: */
        !           238: 
        !           239: # ifdef V6
        !           240: 
        !           241: char **environ;                        /* global environment pointer */
        !           242: 
        !           243: ioctl(a,b,c){
        !           244:        return(0);              /* always succeeds */
        !           245:        }
        !           246: long atol(s)
        !           247:   register char *s; {
        !           248:        long i = 0;
        !           249:        while('0' <= *s && *s <= '9')
        !           250:                i = i * 10 + (*s++ - '0');
        !           251:        return(i);
        !           252:        }
        !           253: long gettime(){
        !           254:        long tt;
        !           255:        time(&tt);
        !           256:        return(tt);
        !           257:        }
        !           258: long getsize(str)
        !           259:   struct stat *str; {
        !           260:        long wk;
        !           261:        wk = ((long)(str->st_size0 & 0377)) << 16;
        !           262:        wk += (long)((unsigned)str->st_size1);
        !           263:        return(wk);
        !           264:        }
        !           265: /*
        !           266:        getenv("HOME")
        !           267: 
        !           268:        always returns home directory.
        !           269:        returns NULL if there is error.
        !           270: */
        !           271: char *getenv(){
        !           272:        register char *shdir = NULL;
        !           273:        register struct passwd *pwd;
        !           274:        register int it;
        !           275:        if(shomedir[0] != 0)return(shomedir);
        !           276: # ifdef BERKELEY
        !           277:        /* hget only works on Berkeley machines */
        !           278:        it = ttyn(2);
        !           279: # ifdef OLDTTY
        !           280:        if(it == 'x')it = ttyn(1);
        !           281:        if(it == 'x')it = ttyn(0);
        !           282:        if(it != 'x' && hget(it) == 0)shdir = hgethome();
        !           283: # endif
        !           284: # ifdef CCTTY
        !           285:        if(it == -1)it = ttyn(1);
        !           286:        if(it == -1)it = ttyn(0);
        !           287:        if(it != -1 && hget(it) == 0)shdir = hgethome();
        !           288: # endif
        !           289: # endif
        !           290:        if(shdir == NULL){
        !           291:                pwd = PwdCurrent();
        !           292:                if(pwd != NULL)shdir = pwd->pw_dir;
        !           293:                }
        !           294:        if(shdir != NULL)strcpy(shomedir,shdir);
        !           295:        return(shdir);
        !           296:        }
        !           297: 
        !           298: /* doesn't handle split passwd files */
        !           299: struct passwd *
        !           300: getpwuid(uid)
        !           301: register uid;
        !           302: {
        !           303:        register struct passwd *p;
        !           304:        struct passwd *getpwent();
        !           305: 
        !           306:        uid = uidmask(uid);
        !           307:        setpwent();
        !           308:        while( (p = getpwent()) && guid(p->pw_uid,p->pw_gid) != uid );
        !           309:        endpwent();
        !           310:        return(p);
        !           311: }
        !           312: 
        !           313: static char PASSWD[]   = "/etc/passwd";
        !           314: static char EMPTY[] = "";
        !           315: static FILE *pwf = NULL;
        !           316: static char line[BUFSIZ+1];
        !           317: static struct passwd passwd;
        !           318: 
        !           319: setpwent()
        !           320: {
        !           321:        debug("reading passwd\n");
        !           322:        if( pwf == NULL )
        !           323:                pwf = fopen( PASSWD, "r" );
        !           324:        else
        !           325:                rewind( pwf );
        !           326: }
        !           327: 
        !           328: endpwent()
        !           329: {
        !           330:        if( pwf != NULL ){
        !           331:                fclose( pwf );
        !           332:                pwf = NULL;
        !           333:        }
        !           334: }
        !           335: 
        !           336: static char *
        !           337: pwskip(p)
        !           338: register char *p;
        !           339: {
        !           340:        while( *p && *p != ':' )
        !           341:                ++p;
        !           342:        if( *p ) *p++ = 0;
        !           343:        return(p);
        !           344: }
        !           345: 
        !           346: struct passwd *
        !           347: getpwent()
        !           348: {
        !           349:        register char *p;
        !           350: 
        !           351:        if (pwf == NULL) {
        !           352:                if( (pwf = fopen( PASSWD, "r" )) == NULL )
        !           353:                        return(0);
        !           354:        }
        !           355:        p = fgets(line, BUFSIZ, pwf);
        !           356:        if (p==NULL)
        !           357:                return(0);
        !           358:        passwd.pw_name = p;
        !           359:        p = pwskip(p);
        !           360:        passwd.pw_passwd = p;
        !           361:        p = pwskip(p);
        !           362:        passwd.pw_uid = atoi(p);
        !           363:        passwd.pw_uid = uidmask(passwd.pw_uid);
        !           364:        p = pwskip(p);
        !           365:        passwd.pw_gid = atoi(p);
        !           366:        passwd.pw_quota = 0;
        !           367:        passwd.pw_comment = EMPTY;
        !           368:        p = pwskip(p);
        !           369:        passwd.pw_gecos = p;
        !           370:        p = pwskip(p);
        !           371:        passwd.pw_dir = p;
        !           372:        p = pwskip(p);
        !           373:        passwd.pw_shell = p;
        !           374:        while(*p && *p != '\n') p++;
        !           375:        *p = '\0';
        !           376:        return(&passwd);
        !           377: }
        !           378: 
        !           379: struct passwd *
        !           380: getpwnam(name)
        !           381: char *name;
        !           382: {
        !           383:        register struct passwd *p;
        !           384:        struct passwd *getpwent();
        !           385: 
        !           386:        setpwent();
        !           387:        while( (p = getpwent()) && strcmp(name,p->pw_name) );
        !           388:        endpwent();
        !           389:        return(p);
        !           390: }
        !           391: /*
        !           392:        getlogin()
        !           393: 
        !           394:        Return current user name by looking at /etc/utmp (calls getutmp()).
        !           395:        Returns NULL if not found.
        !           396: */
        !           397: char *getlogin()
        !           398: {
        !           399:        register struct utmp *putmp;
        !           400:        register char *s;
        !           401:        char sttyname[30];
        !           402: 
        !           403:        if(isatty(2))strcpy(sttyname,ttyname(2));
        !           404:        else if(isatty(0))strcpy(sttyname,ttyname(0));
        !           405:        else if(isatty(1))strcpy(sttyname,ttyname(1));
        !           406:        else return(NULL);
        !           407: 
        !           408:        putmp = getutmp(sttyname);
        !           409:        if(putmp == NULL)return(NULL);
        !           410:        s = putmp->ut_name;
        !           411:        while(*s != 0 && *s != ' ')s++;
        !           412:        *s = 0;
        !           413:        if(putmp->ut_name[0] == 0)return(NULL);
        !           414:        return(putmp->ut_name);
        !           415: }
        !           416: /*
        !           417:  * Unix routine to do an "fopen" on file descriptor
        !           418:  * The mode has to be repeated because you can't query its
        !           419:  * status
        !           420:  */
        !           421: 
        !           422: FILE *
        !           423: fdopen(fd, mode)
        !           424: register char *mode;
        !           425: {
        !           426:        extern int errno;
        !           427:        register FILE *iop;
        !           428:        extern FILE *_lastbuf;
        !           429: 
        !           430:        for (iop = _iob; iop->_flag&(_IOREAD|_IOWRT); iop++)
        !           431:                if (iop >= _lastbuf)
        !           432:                        return(NULL);
        !           433:        iop->_cnt = 0;
        !           434:        iop->_file = fd;
        !           435:        if (*mode != 'r') {
        !           436:                iop->_flag |= _IOWRT;
        !           437:                if (*mode == 'a')
        !           438:                        lseek(fd, 0L, 2);
        !           439:        } else
        !           440:                iop->_flag |= _IOREAD;
        !           441:        return(iop);
        !           442: }
        !           443: system(s)
        !           444: char *s;
        !           445: {
        !           446:        int status, pid, w;
        !           447:        register int (*istat)(), (*qstat)();
        !           448: 
        !           449:        while((pid = fork()) == -1)sleep(2);
        !           450:        if (pid == 0) {
        !           451:                execl("/bin/sh", "sh", "-c", s, 0);
        !           452:                _exit(127);
        !           453:        }
        !           454:        istat = signal(SIGINT, SIG_IGN);
        !           455:        qstat = signal(SIGQUIT, SIG_IGN);
        !           456:        while ((w = wait(&status)) != pid && w != -1)
        !           457:                ;
        !           458:        if (w == -1)
        !           459:                status = -1;
        !           460:        signal(SIGINT, istat);
        !           461:        signal(SIGQUIT, qstat);
        !           462:        return(status);
        !           463: }
        !           464: 
        !           465: char *
        !           466: getpass(prompt)
        !           467: char *prompt;
        !           468: {
        !           469:        struct sgttyb ttyb;
        !           470:        int flags;
        !           471:        register char *p;
        !           472:        register c;
        !           473:        FILE *fi = NULL;
        !           474:        static char pbuf[9];
        !           475:        int (*signal())();
        !           476:        int (*sig)();
        !           477: 
        !           478:        /*      modified because Cory needs super-user to stty /dev/tty */
        !           479:        if ((fi = fopen("/dev/tty", "r")) == NULL)
        !           480:                fi = stdin;
        !           481:        else
        !           482:                setbuf(fi, (char *)NULL);
        !           483:        if(gtty(fileno(fi),&ttyb) < 0){
        !           484:                pbuf[0] = 0;
        !           485:                return(pbuf);
        !           486:        }
        !           487:        /*
        !           488:        if(gtty(0,&ttyb) >= 0)fi = stdin;
        !           489:        else if(gtty(2,&ttyb) >= 0)fi = stderr;
        !           490:        else {
        !           491:                pbuf[0] = 0;
        !           492:                return(pbuf);
        !           493:                }
        !           494:        */
        !           495:        sig = signal(SIGINT, SIG_IGN);
        !           496:        flags = ttyb.sg_flags;
        !           497:        ttyb.sg_flags &= ~ECHO;
        !           498:        if(stty(fileno(fi), &ttyb) < 0) perror("stty:");
        !           499:        fprintf(stderr, prompt);
        !           500:        for (p=pbuf; (c = getc(fi))!='\n' && c!=EOF;) {
        !           501:                if (p < &pbuf[8])
        !           502:                        *p++ = c;
        !           503:        }
        !           504:        *p = '\0';
        !           505:        fprintf(stderr, "\n");
        !           506:        ttyb.sg_flags = flags;
        !           507:        stty(fileno(fi), &ttyb);
        !           508:        signal(SIGINT, sig);
        !           509:        if (fi != stdin)
        !           510:                fclose(fi);
        !           511:        return(pbuf);
        !           512: }
        !           513: /*
        !           514:  * Compare strings (at most n bytes):  s1>s2: >0  s1==s2: 0  s1<s2: <0
        !           515:  */
        !           516: 
        !           517: strncmp(s1, s2, n)
        !           518: register char *s1, *s2;
        !           519: register n;
        !           520: {
        !           521: 
        !           522:        while (--n >= 0 && *s1 == *s2++)
        !           523:                if (*s1++ == '\0')
        !           524:                        return(0);
        !           525:        return(n<0 ? 0 : *s1 - *--s2);
        !           526: }
        !           527: /* end of non-vax v7 routines */
        !           528: # endif
        !           529: /*
        !           530:        PwdCurrent()
        !           531: 
        !           532:        Read the password file and return pwd to
        !           533:        entry for current user.
        !           534:        Return NULL if error.
        !           535: 
        !           536:        This code is a little screwed up because of the conventions
        !           537:        regarding the state of the utmp file after someone su's--
        !           538:        either to root or to another person.
        !           539:        The final decision was to return getpwuid(getuid) if
        !           540:        the machine has one login name per userid,
        !           541:        and if there are multiple login names per userid, to
        !           542:        search the passwd file for the getlogin() name and return
        !           543:        the passwd file entry for that.
        !           544:        If there is no utmp entry, just use the userid.
        !           545:        This means that people who su on machine with multiple
        !           546:        user-id's will get the passwd entry for the account recorded
        !           547:        in the utmp file, not their current userid.
        !           548: */
        !           549: struct passwd *
        !           550: PwdCurrent()
        !           551: {
        !           552:        register struct passwd *pwd;
        !           553:        register char *sn;
        !           554: 
        !           555: # ifdef MULTNAMS
        !           556:        sn = getlogin();
        !           557:        if(sn != NULL && sn[0] != 0 && sn[0] != ' '){
        !           558:                pwd = getpwnam(sn);
        !           559:                if(pwd != NULL)return(pwd);
        !           560:        }
        !           561: # endif
        !           562: 
        !           563:        return(getpwuid(uidmask(getuid())));
        !           564: }
        !           565: /*VARARGS0*/
        !           566: debug(s,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,t)
        !           567: char *s; {
        !           568:        if(debugflg){
        !           569:                printf(s,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,t);
        !           570:                putchar('\n');
        !           571:                }
        !           572:        }

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