Return to mach.c CVS log

Up to [CSRG BSD Unix] / 43BSD / old / berknet

Annotation of 43BSD/old/berknet/mach.c, revision 1.1

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

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