![[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] / 3BSD / cmd / net|
Return to mach.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / net |
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: # ifndef CC
15: submit(a) {}
16: # endif
17:
18: # ifdef FUID
19: setgid() {};
20: # endif
21:
22: /*
23: Set the owner uid/gid of a file.
24: On v7, this is done by the chown command
25: with three args - (file, uid, gid).
26: On Vanilla V6 this is done using the
27: top byte of the second parameter as the gid byte.
28: On Berkeley Funny uids on V6, no gid is specified.
29: */
30: mchown(sfn,uid,gid)
31: char *sfn;
32: int uid;
33: int gid;
34: {
35: # ifndef V6
36: chown(sfn,uid,gid);
37: # else
38: # ifndef FUID
39: uid = uidmask(uid);
40: uid = ((gid&0377) << 8) | (uid & 0377);
41: # endif
42: chown(sfn,uid);
43: # endif
44: }
45:
46:
47: char vaxtovax;
48: long fixuplong(a)
49: long a; {
50: # ifdef ISVAX
51: register char *p,c1,c2;
52: char c3,c4;
53: if(!vaxtovax){
54: p = (char*) &a;
55: c1 = *p++;
56: c2 = *p++;
57: c3 = *p++;
58: c4 = *p++;
59: p = (char*) &a;
60: *p++ = c3;
61: *p++ = c4;
62: *p++ = c1;
63: *p++ = c2;
64: }
65: # endif
66: return(a);
67: }
68: /*
69: SnFromuid(uid)
70:
71: The login name corresponding to uid.
72: Reads the password file.
73: Successive calls overwrite the static string returned.
74: Returns NULL if error.
75: */
76: char *SnFromUid(uid)
77: register int uid;
78: {
79: register struct passwd *pwd;
80: static int ouid = -1;
81: static char oresult[20] = "";
82: uid = uidmask(uid);
83: if(uid == ouid)
84: return(oresult);
85: # ifdef HPASSWD
86: if(getname(uid,oresult) == 0){
87: ouid = uid;
88: return(oresult);
89: }
90: # endif
91: pwd = getpwuid(uid);
92: if(pwd != NULL){
93: strcpy(oresult,pwd->pw_name);
94: ouid = uid;
95: return(oresult);
96: }
97: return(NULL);
98: }
99:
100: /* handle the regular unix and local mods difference for user id's */
101: /* this call returns the 1 word uid = to what getuid will return */
102: guid(uid,gid){
103: uid = uidmask(uid);
104: # ifdef FUID
105: return((uid & 0377) | (gid << 8));
106: # else
107: return(uid);
108: # endif
109: }
110:
111: # ifdef OLDTTY
112: isatty(i){
113: return(ttyn(i) != 'x');
114: }
115: char *ttyname(i){ /* return NULL if not TTY */
116: char c;
117: static char ttystr[] = "/dev/ttyx";
118: c = ttyn(i);
119: ttystr[8] = c;
120: return(c == 'x' ? NULL : ttystr);
121: }
122: # endif
123:
124: # ifdef CCTTY
125: # undef ttyname()
126: myttyname(i){ /* return NULL for non tty */
127: static char s[15],*p;
128: p = ttyname(i);
129: if(p == NULL)return(NULL);
130: strcpy(s,"/dev/");
131: strcat(s,p);
132: return(s);
133: }
134: # define ttyname(S) myttyname(S)
135: # endif
136:
137: /* get passwd from passwdf */
138: getpwdf(pwd)
139: struct passwd *pwd; {
140: # ifdef PASSWDF
141: # ifndef TESTING
142: register char *p, *q;
143: char buf1[BUFSIZ], found;
144: FILE *pw;
145: pwd->pw_passwd[0] = 0;
146: pw = fopen("/etc/passwdf","r");
147: if(pw == NULL) return;
148: found = 0;
149: while(fgets(buf1,BUFSIZ,pw) != NULL){
150: for(p=buf1; *p && *p != ':'; p++);
151: *p = 0;
152: if(strcmp(buf1,pwd->pw_name) == 0){
153: found = 1;
154: break;
155: }
156: }
157: fclose(pw);
158: if(!found)return;
159: q = ++p;
160: for(;*p && *p != ':';p++);
161: *p = 0;
162: strcpy(pwd->pw_passwd,q);
163: /*
164: debug("user %s passwd %s %s",pwd->pw_name,pwd->pw_passwd);
165: */
166: # endif
167: # endif
168: }
169: /*
170: these are all the v7 routines not available on the v6 machines
171: */
172:
173: # ifdef V6
174:
175: char **environ; /* global environment pointer */
176:
177: ioctl(a,b,c){
178: return(0); /* always succeeds */
179: }
180: long atol(s)
181: register char *s; {
182: long i = 0;
183: while('0' <= *s && *s <= '9')
184: i = i * 10 + (*s++ - '0');
185: return(i);
186: }
187: long gettime(){
188: long tt;
189: time(&tt);
190: return(tt);
191: }
192: long getsize(str)
193: struct stat *str; {
194: long wk;
195: wk = ((long)(str->st_size0 & 0377)) << 16;
196: wk += (long)((unsigned)str->st_size1);
197: return(wk);
198: }
199: /*
200: getenv("HOME")
201:
202: always returns home directory.
203: returns NULL if there is error.
204: */
205: char *getenv(){
206: register char *shdir = NULL;
207: register struct passwd *pwd;
208: register int it;
209: if(shomedir[0] != 0)return(shomedir);
210: it = ttyn(2);
211: # ifdef OLDTTY
212: if(it == 'x')it = ttyn(1);
213: if(it == 'x')it = ttyn(0);
214: if(it != 'x' && hget(it) == 0)shdir = hgethome();
215: # endif
216: # ifdef CCTTY
217: if(it == -1)it = ttyn(1);
218: if(it == -1)it = ttyn(0);
219: if(it != -1 && hget(it) == 0)shdir = hgethome();
220: # endif
221: if(shdir == NULL){
222: pwd = PwdCurrent();
223: if(pwd != NULL)shdir = pwd->pw_dir;
224: }
225: if(shdir != NULL)strcpy(shomedir,shdir);
226: return(shdir);
227: }
228:
229: /* doesn't handle split passwd files */
230: struct passwd *
231: getpwuid(uid)
232: register uid;
233: {
234: register struct passwd *p;
235: struct passwd *getpwent();
236:
237: uid = uidmask(uid);
238: setpwent();
239: while( (p = getpwent()) && guid(p->pw_uid,p->pw_gid) != uid );
240: endpwent();
241: return(p);
242: }
243:
244: static char PASSWD[] = "/etc/passwd";
245: static char EMPTY[] = "";
246: static FILE *pwf = NULL;
247: static char line[BUFSIZ+1];
248: static struct passwd passwd;
249:
250: setpwent()
251: {
252: if( pwf == NULL )
253: pwf = fopen( PASSWD, "r" );
254: else
255: rewind( pwf );
256: }
257:
258: endpwent()
259: {
260: if( pwf != NULL ){
261: fclose( pwf );
262: pwf = NULL;
263: }
264: }
265:
266: static char *
267: pwskip(p)
268: register char *p;
269: {
270: while( *p && *p != ':' )
271: ++p;
272: if( *p ) *p++ = 0;
273: return(p);
274: }
275:
276: struct passwd *
277: getpwent()
278: {
279: register char *p;
280:
281: if (pwf == NULL) {
282: if( (pwf = fopen( PASSWD, "r" )) == NULL )
283: return(0);
284: }
285: p = fgets(line, BUFSIZ, pwf);
286: if (p==NULL)
287: return(0);
288: passwd.pw_name = p;
289: p = pwskip(p);
290: passwd.pw_passwd = p;
291: p = pwskip(p);
292: passwd.pw_uid = atoi(p);
293: passwd.pw_uid = uidmask(passwd.pw_uid);
294: p = pwskip(p);
295: passwd.pw_gid = atoi(p);
296: passwd.pw_quota = 0;
297: passwd.pw_comment = EMPTY;
298: p = pwskip(p);
299: passwd.pw_gecos = p;
300: p = pwskip(p);
301: passwd.pw_dir = p;
302: p = pwskip(p);
303: passwd.pw_shell = p;
304: while(*p && *p != '\n') p++;
305: *p = '\0';
306: return(&passwd);
307: }
308:
309: struct passwd *
310: getpwnam(name)
311: char *name;
312: {
313: register struct passwd *p;
314: struct passwd *getpwent();
315:
316: setpwent();
317: while( (p = getpwent()) && strcmp(name,p->pw_name) );
318: endpwent();
319: return(p);
320: }
321: /*
322: getlogin()
323:
324: Return current user name by looking at /etc/utmp.
325: Returns NULL if not found.
326: */
327: char *getlogin()
328: {
329: struct utmp utmpstr;
330: static char snSave[10];
331: register char *sttyname,*s;
332: register FILE *fp;
333:
334: sttyname = ttyname(2);
335: if(sttyname == NULL)sttyname = ttyname(1);
336: if(sttyname == NULL)sttyname = ttyname(0);
337: if(sttyname == NULL)return(NULL);
338:
339: fp = fopen("/etc/utmp","r");
340: if(fp == NULL)return(NULL);
341:
342: snSave[0] = 0;
343: while(fread(&utmpstr,1,sizeof utmpstr,fp) == sizeof utmpstr){
344: # ifdef OLDTTY
345: if(utmpstr.ut_tty == sttyname[8]){
346: # else
347: if(strcmp(utmpstr.ut_line,sttyname+5) == 0){
348: # endif
349: utmpstr.ut_tty = 0;
350: strcpy(snSave,utmpstr.ut_name);
351: }
352: }
353:
354: fclose(fp);
355: s = snSave;
356: while(*s != 0 && *s != ' ')s++;
357: *s = 0;
358: if(snSave[0] == 0)return(NULL);
359: return(snSave);
360: }
361: /*
362: * Unix routine to do an "fopen" on file descriptor
363: * The mode has to be repeated because you can't query its
364: * status
365: */
366:
367: FILE *
368: fdopen(fd, mode)
369: register char *mode;
370: {
371: extern int errno;
372: register FILE *iop;
373: extern FILE *_lastbuf;
374:
375: for (iop = _iob; iop->_flag&(_IOREAD|_IOWRT); iop++)
376: if (iop >= _lastbuf)
377: return(NULL);
378: iop->_cnt = 0;
379: iop->_file = fd;
380: if (*mode != 'r') {
381: iop->_flag |= _IOWRT;
382: if (*mode == 'a')
383: lseek(fd, 0L, 2);
384: } else
385: iop->_flag |= _IOREAD;
386: return(iop);
387: }
388: system(s)
389: char *s;
390: {
391: int status, pid, w;
392: register int (*istat)(), (*qstat)();
393:
394: while((pid = fork()) == -1)sleep(2);
395: if (pid == 0) {
396: execl("/bin/sh", "sh", "-c", s, 0);
397: _exit(127);
398: }
399: istat = signal(SIGINT, SIG_IGN);
400: qstat = signal(SIGQUIT, SIG_IGN);
401: while ((w = wait(&status)) != pid && w != -1)
402: ;
403: if (w == -1)
404: status = -1;
405: signal(SIGINT, istat);
406: signal(SIGQUIT, qstat);
407: return(status);
408: }
409:
410: char *
411: getpass(prompt)
412: char *prompt;
413: {
414: struct sgttyb ttyb;
415: int flags;
416: register char *p;
417: register c;
418: FILE *fi = NULL;
419: static char pbuf[9];
420: int (*signal())();
421: int (*sig)();
422:
423: /* modified because Cory needs super-user to stty /dev/tty */
424: # ifndef CORY
425: if ((fi = fopen("/dev/tty", "r")) == NULL)
426: fi = stdin;
427: else
428: setbuf(fi, (char *)NULL);
429: gtty(fileno(fi), &ttyb);
430: # else
431: if(gtty(0,&ttyb) >= 0)fi = stdin;
432: else if(gtty(2,&ttyb) >= 0)fi = stderr;
433: else {
434: pbuf[0] = 0;
435: return(pbuf);
436: }
437: # endif
438: sig = signal(SIGINT, SIG_IGN);
439: flags = ttyb.sg_flags;
440: ttyb.sg_flags &= ~ECHO;
441: if(stty(fileno(fi), &ttyb) < 0) perror("stty:");
442: fprintf(stderr, prompt);
443: for (p=pbuf; (c = getc(fi))!='\n' && c!=EOF;) {
444: if (p < &pbuf[8])
445: *p++ = c;
446: }
447: *p = '\0';
448: fprintf(stderr, "\n");
449: ttyb.sg_flags = flags;
450: stty(fileno(fi), &ttyb);
451: signal(SIGINT, sig);
452: # ifndef CORY
453: if (fi != stdin)
454: fclose(fi);
455: # endif
456: return(pbuf);
457: }
458: /* end of non-vax v7 routines */
459: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.