![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sub.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / old / berknet|
Return to sub.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / old / berknet |
1.1 root 1: static char sccsid[] = "@(#)sub.c 4.5 (Berkeley) 1/5/83";
2:
3: /*
4: sub.c
5:
6: support procedures
7:
8: the following procedures end up reading the passwd file
9: or the passwdf file and are to be avoided.
10:
11: getpwuid(uid)
12: getpwnam(sn)
13: PwdCurrent()
14: getenv("HOME") maybe if hget, hgethome don't work
15: SnFromUid(uid) maybe if hashed passwd stuff doesn't work
16: SnCurrent() maybe if getlogin fails calls SnFromUid(uid)
17: getpwf()
18: passwdent(uid,sn)
19: */
20:
21: # include "defs.h"
22: # include "config.h"
23: # include <varargs.h>
24:
25: /* global variables */
26: int debugflg = DBV; /* debug flag */
27: char local = LOCAL; /* the machine we're on */
28: struct userinfo status;
29:
30: char netcmd[] = NETCMD;
31: char resfile[] = RESFILE;
32: char senddir[] = SENDDIR;
33: char Bsh[] = BINSH;
34:
35: char shomedir[100];
36:
37: /*
38: passwdent()
39:
40: Read the password file looking for current user's entry.
41: Fill in the status structure.
42: Has the (dangerous) side effect of giving a value to getenv("HOME").
43: */
44: passwdent()
45: {
46: register char *u;
47: register struct passwd *pwd;
48: #ifdef CRN
49: register struct gecos *gcos;
50: #endif
51: pwd = PwdCurrent();
52: if(pwd == NULL){
53: err("Bad uid/username\n");
54: return;
55: }
56: strcpy(status.localname,pwd->pw_name);
57: status.muid = guid(pwd->pw_uid,pwd->pw_gid);
58: status.mgid = pwd->pw_gid;
59: #ifdef CRN
60: if( (gcos=pwgecos( pwd->pw_gecos) ) == NULL )
61: strcpy( status.jobno, MAGICCRN );
62: else {
63: if( debugflg )
64: debug( "crn found = %s\n", gcos->gc_crn );
65: if( isalpha( gcos->gc_crn[0] ) ||
66: isdigit( gcos->gc_crn[0] ) )
67: strcpy( status.jobno, gcos->gc_crn );
68: else
69: strcpy( status.jobno, MAGICCRN );
70: }
71: #else
72: strcpy( status.jobno, "XYZZ" );
73: #endif
74: strcpy(status.dir,pwd->pw_dir);
75: strcpy(shomedir,pwd->pw_dir); /* side effect */
76: u = pwd->pw_shell;
77: if(u[0] == 0 || strcmp(u,"/bin/sbash") == 0)u= Bsh;
78: strcpy(status.loginshell,u);
79: }
80: /*
81: promptlogin(mchto)
82:
83: ask user for login and passwd on mchto.
84: make sure status.localname has a value before calling
85: this. One way is to call passwdent().
86: */
87: promptlogin(mchto)
88: char mchto;
89: {
90: char buf[BUFSIZ], mch;
91: FILE *wf;
92: int c;
93: if(status.login[0]==0 || status.force){
94: buf[0] = 0;
95: wf = fopen("/dev/tty","r");
96: if(wf != NULL){
97: fprintf(stderr,"Name (%s:%s): ",longname(mchto),
98: status.localname);
99: if(fgets(buf, BUFSIZ, wf) != buf){
100: perror("fgets");
101: exit(EX_OSERR);
102: }
103: c = strlen(buf);
104: buf[c > 0 ? c-1 : 0] = 0;
105: if(c > 10){
106: err("Login name too long.\n");
107: exit(EX_USAGE);
108: }
109: if(FMemberSCh(buf,' ')){
110: err("Login names don't have blanks in them.\n");
111: exit(EX_USAGE);
112: }
113: fclose(wf);
114: }
115: if(buf[0] == 0)strcpy(buf,status.localname);
116: mch = MchSFromAddr(status.login,buf);
117: if(mch != local && mch != mchto){
118: err("Must specify login name on %s machine\n",
119: longname(mchto));
120: exit(EX_USAGE);
121: }
122: }
123: if(strcmp(status.login,"network") != 0
124: && (status.mpasswd[0]== 0 || status.force)){
125: sprintf(buf,"Password (%s:%s):",
126: longname(mchto), status.login);
127: strcpy(status.mpasswd,getpass(buf));
128: }
129: if(status.login[0] == 0) strcpy(status.login,status.localname);
130: if(status.mpasswd[0] == 0)strcpy(status.mpasswd,"\"\"");
131: status.force = 0;
132: }
133:
134: #define tst(a,b) (*mode == 'r'? (b) : (a))
135: #define RDR 0
136: #define WTR 1
137: static int popen_pid[20];
138:
139: /* return a file descriptor suitable for writing, send to
140: user toaddress from fromaddress,
141: if cautious != 0 then don't do any forwarding
142: hopcnt is passed thru the mail program.
143: normal value is 0
144: */
145: FILE *
146: mailopen(toaddress, fromaddress, cautious, hopcnt)
147: char *toaddress, *fromaddress;
148: int cautious, hopcnt;
149: {
150: char cmd[100];
151: char *mode = "w";
152: int p[2];
153: register myside, hisside, pid;
154: char shopcnt[20];
155:
156: if(pipe(p) < 0)
157: return NULL;
158: myside = tst(p[WTR], p[RDR]);
159: hisside = tst(p[RDR], p[WTR]);
160: while((pid = fork()) == -1)sleep(2);
161: if(pid == 0) {
162: /* myside and hisside reverse roles in child */
163: close(myside);
164: /*
165: dup2(hisside, tst(0, 1));
166: */
167: close(0);
168: dup(hisside);
169: close(hisside);
170: sprintf(shopcnt,"%d",hopcnt);
171: if(fromaddress != NULL){
172: /* by convention, MAILFWD1 may forward this mail
173: and response messages shouldn't be forwarded */
174: if(!cautious && !FMemberSCh(toaddress,'/')){
175: # ifdef SENDMAIL
176: mexecl("/usr/lib/sendmail",
177: "sendmail", "-oee", "-r", fromaddress,
178: "-h",shopcnt, toaddress, 0);
179: # endif SENDMAIL
180: mexecl(MAILFWD1, "mail","-r",fromaddress,
181: "-h",shopcnt,toaddress,0);
182: }
183: mexecl(SYSMAIL2, "mail","-d","-r",fromaddress,
184: "-h", shopcnt,toaddress,0);
185: } else {
186: if(!cautious && !FMemberSCh(toaddress,'/')){
187: # ifdef SENDMAIL
188: mexecl("/usr/lib/sendmail",
189: "sendmail", "-ee", "-h", shopcnt,
190: toaddress, 0);
191: # endif
192: mexecl(MAILFWD1, "mail","-h", shopcnt,
193: toaddress,0);
194: }
195: mexecl(SYSMAIL2, "mail","-d","-h", shopcnt,toaddress,0);
196: }
197: perror(SYSMAIL2);
198: exit(EX_UNAVAILABLE);
199: }
200: if(pid == -1)
201: return NULL;
202: popen_pid[myside] = pid;
203: close(hisside);
204: return(fdopen(myside, mode));
205: }
206:
207: mailclose(ptr)
208: FILE *ptr;
209: {
210: register f, r, (*hstat)(), (*istat)(), (*qstat)();
211: int status;
212:
213: f = fileno(ptr);
214: fclose(ptr);
215: istat = signal(SIGINT, SIG_IGN);
216: qstat = signal(SIGQUIT, SIG_IGN);
217: hstat = signal(SIGHUP, SIG_IGN);
218: while((r = wait(&status)) != popen_pid[f] && r != -1)
219: ;
220: if(r == -1)
221: status = -1;
222: signal(SIGINT, istat);
223: signal(SIGQUIT, qstat);
224: signal(SIGHUP, hstat);
225: return(status);
226: }
227:
228: /*
229: ch means 'a'-'z', inx in 0..25
230: ch means '0'-'9', inx in 26..35
231: */
232: chtoinx(ch) {
233: if('a' <= ch && ch <= 'z')
234: return(ch - 'a');
235: if('0' <= ch && ch <= '9')
236: return((ch - '0') + 26);
237: err("bad ch");
238: }
239:
240: /*
241: inx is 0..25 means 'a'-'z'
242: inx is 26..35 means '0'-'9'
243: */
244: inxtoch(inx) {
245: if(0 <= inx && inx <= 25)
246: return(inx + 'a');
247: if(26 <= inx && inx <= 35)
248: return('0' + (inx - 26));
249: err("bad ch");
250: }
251:
252: /* determine through machine */
253: gothru(from,to){
254: register int i;
255: switch(from){
256: # ifdef RAND
257: case 'a': i = configA[chtoinx(to)]; break;
258: case 'b': i = configB[chtoinx(to)]; break;
259: case 'c': i = configC[chtoinx(to)]; break;
260: # endif
261: # ifdef NOSC
262: case 'a': i = configA[chtoinx(to)]; break;
263: case 'c': i = configC[chtoinx(to)]; break;
264: case 'm': i = configM[chtoinx(to)]; break;
265: # endif
266: # ifdef BERKELEY
267: /* for Berkeley */
268: case 'a': i = configA[chtoinx(to)]; break;
269: case 'b': i = configB[chtoinx(to)]; break;
270: case 'c': i = configC[chtoinx(to)]; break;
271: case 'd': i = configD[chtoinx(to)]; break;
272: case 'e': i = configE[chtoinx(to)]; break;
273: case 'f': i = configF[chtoinx(to)]; break;
274: case 'g': i = configG[chtoinx(to)]; break;
275: case 'h': i = configH[chtoinx(to)]; break;
276: case 'i': i = configI[chtoinx(to)]; break;
277: case 'j': i = configJ[chtoinx(to)]; break;
278: case 'k': i = configK[chtoinx(to)]; break;
279: case 'l': i = configL[chtoinx(to)]; break;
280: case 'm': i = configM[chtoinx(to)]; break;
281: case 'n': i = configN[chtoinx(to)]; break;
282: case 'o': i = configO[chtoinx(to)]; break;
283: case 'p': i = configP[chtoinx(to)]; break;
284: case 'r': i = configR[chtoinx(to)]; break;
285: case 's': i = configS[chtoinx(to)]; break;
286: case 't': i = configT[chtoinx(to)]; break;
287: case 'u': i = configU[chtoinx(to)]; break;
288: case 'v': i = configV[chtoinx(to)]; break;
289: case 'w': i = configW[chtoinx(to)]; break;
290: case 'x': i = configX[chtoinx(to)]; break;
291: case 'y': i = configY[chtoinx(to)]; break;
292: case 'z': i = configZ[chtoinx(to)]; break;
293: # endif
294: default: i = 0; break;
295: }
296: return(i);
297: }
298:
299: # define NPARMS 20
300: /* prints out commands before executing them */
301: /*VARARGS0*/
302: mexecl(va_alist)
303: va_dcl
304: {
305: char *arr[NPARMS], *file, *f;
306: va_list ap;
307: register int i;
308: va_start(ap);
309: file = va_arg(ap, char *);
310: i = 0;
311: while(f = va_arg(ap, char *)){
312: if(i >= NPARMS){
313: err("too many args");
314: arr[NPARMS-1] = NULL;
315: break;
316: }
317: if(debugflg) err("'%s' ",f);
318: arr[i++] = f;
319: }
320: arr[i] = NULL;
321: va_end(ap);
322: if(debugflg) putc('\n',stderr);
323: execv(file, arr);
324: }
325:
326: /* prints out commands before executing them */
327: mexecv(s,p)
328: register char *s, **p;{
329: register int i;
330: if(debugflg){
331: err("'%s' ",s);
332: for(i=0; p[i]; i++)err("'%s' ",p[i]);
333: putc('\n',stderr);
334: }
335: execv(s,p);
336: }
337:
338: /*VARARGS0*/
339: /* fills in -l - -p from commands like rcp */
340: /* must be called with at least two arguments */
341: kexecl(va_alist)
342: va_dcl
343: {
344: char *a[NPARMS], i = 1, *file;
345: va_list ap;
346: va_start(ap);
347: file = va_arg(ap, char *);
348: a[0] = va_arg(ap, char *);
349: if(status.login[0]){
350: a[i++] = "-l";
351: a[i++] = status.login;
352: }
353: if(status.mpasswd[0]){
354: a[i++] = "-p";
355: a[i++] = status.mpasswd;
356: }
357: if(status.nonotify)a[i++] = "-b";
358: if(status.force) a[i++] = "-f";
359: if(status.quiet) a[i++] = "-q";
360: if(status.nowrite) a[i++] = "-n";
361: while (a[i++] = va_arg(ap, char *)){
362: if(i >= NPARMS){
363: err("too many args");
364: a[NPARMS-1] = NULL;
365: break;
366: }
367: };
368: mexecv(file, a);
369: }
370:
371: /*
372: MchSFromAddr(sn,addr)
373:
374: take an address of the form "mach:username"
375: and return mch as the 1 char code of "mach" and
376: in sn put "username".
377: If addr has no colon in it, return mch==local, sn==addr.
378: Return 0 for mch if host unknown.
379: */
380: MchSFromAddr(sn,addr)
381: char *sn, *addr;
382: {
383: char fcolon = 0, *s, mch, stemp[BUFSIZ];
384:
385: /* assume addr is a local address */
386:
387: strcpy(stemp,addr);
388: s = stemp;
389: while(*s){
390: if(*s == ':'){
391: fcolon = 1;
392: *s++ = 0;
393: break;
394: }
395: s++;
396: }
397: if(fcolon != 1){
398: /* sn better be the right size for addr */
399: mch = local;
400: strcpy(sn,addr);
401: return(mch);
402: }
403:
404: /* addr has a colon in it, s pts to name */
405: mch = lookup(stemp);
406: strcpy(sn,s);
407: return(mch);
408: }
409:
410:
411: /* returns a single character for machine S */
412: /* returns 0 for unknown host */
413: lookup(s)
414: register char *s; {
415: register struct tt *t;
416: if(strlen(s) == 1)return(isupper(*s) ? tolower(*s) : *s);
417: for(t = table; t->bigname; t++)
418: if(streql(s,t->bigname) == 0)return(t->lname);
419: return(0);
420: }
421:
422: /* returns a long name (string) for single character machine c */
423: char *longname(c)
424: register char c;
425: {
426: register struct tt *t;
427: if(c == 0)return("UNKNOWN");
428: for(t = table; t->bigname; t++)
429: if(c == t->lname)return(t->bigname);
430: return("UNKNOWN");
431: }
432: /*
433: FMemberSCh(s,ch)
434:
435: return 1 if ch is a character in string s.
436: 0 otherwise.
437: */
438: FMemberSCh(s,ch)
439: register char *s, ch;
440: {
441: while(*s)if(*s++ == ch)return(1);
442: return(0);
443: }
444:
445: /* return a static string with the form "X hrs X mins X secs" */
446: /* t is # of secs */
447: char *comptime(t)
448: long t; {
449: static char str[30];
450: char buf[20];
451: long w;
452: str[0] = 0;
453: w = t/3600L;
454: if(w > 0L){
455: sprintf(buf,"%ld hr ",w);
456: strcat(str,buf);
457: }
458: t = t % 3600L;
459: w = t/60L;
460: if(w > 0L){
461: sprintf(buf,"%ld min ",w);
462: strcat(str,buf);
463: }
464: t = t % 60L;
465: sprintf(buf,"%ld sec",t);
466: strcat(str,buf);
467: return(str);
468: }
469: /*
470: parseparmlist(string)
471:
472: parses variable parameter lists in string,
473: as defined in genparmlist in net.c
474: */
475: parseparmlist(parmlist)
476: char *parmlist;
477: {
478: while(*parmlist && *parmlist != '(')parmlist++;
479: }
480:
481: /* just like strcmp except upper- and lower-case are ignored */
482: streql(s1,s2)
483: char *s1, *s2; {
484: char a,b;
485: while(*s1 && *s2){
486: a = isupper(*s1) ? tolower(*s1) : *s1;
487: b = isupper(*s2) ? tolower(*s2) : *s2;
488: if(a < b)return(-1);
489: if(a > b)return(1);
490: s1++, s2++;
491: }
492: if(*s2)return(-1);
493: if(*s1)return(1);
494: return(0);
495: }
496: /* VARARGS0 */
497: err(s,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) {
498: fprintf(stderr,s,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r);
499: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.