![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mach.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / berknet|
Return to mach.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / berknet |
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.