![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cico.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / uucp|
Return to cico.c CVS log | Up to [Research Unix] / researchv8dc / cmd / uucp |
1.1 root 1: /* %W%
2:
3: * uucp file transfer program:
4: * to place a call to a remote machine, login, and
5: * copy files between the two machines.
6:
7: */
8: #include "uucp.h"
9: VERSION(%W%);
10:
11: #ifndef V7
12: #include <sys/sysmacros.h>
13: #endif
14:
15: jmp_buf Sjbuf;
16: extern int Errorrate;
17: char uuxqtarg[MAXBASENAME] = {'\0'};
18:
19: #define USAGE "[-xNUM] [-r[0|1]] -sSYSTEM"
20:
21: extern void closedem();
22:
23: main(argc, argv, envp)
24: char *argv[];
25: char **envp;
26: {
27: extern onintr(), timeout();
28: extern intrEXIT();
29: extern char *pskip();
30: int ret, seq, exitcode;
31: char file[NAMESIZE];
32: char msg[BUFSIZ], *p, *q;
33: char xflag[6]; /* -xN N is single digit */
34: char *ttyn;
35: char cb[128];
36: time_t ts, tconv;
37: #ifndef V7
38: long minulimit, dummy;
39: #endif V7
40:
41: Uid = getuid();
42: Euid = geteuid(); /* this should be UUCPUID */
43: if (Uid == 0)
44: setuid(UUCPUID); /* fails in ATTSV, but so what? */
45: Env = envp;
46: Role = SLAVE;
47: strcpy(Logfile, LOGCICO);
48: *Rmtname = NULLCHAR;
49:
50: closedem();
51: time(&Nstat.t_qtime);
52: tconv = Nstat.t_start = Nstat.t_qtime;
53: strcpy(Progname, "uucico");
54: Pchar = 'C';
55: (void) signal(SIGILL, intrEXIT);
56: (void) signal(SIGTRAP, intrEXIT);
57: (void) signal(SIGIOT, intrEXIT);
58: (void) signal(SIGEMT, intrEXIT);
59: (void) signal(SIGFPE, intrEXIT);
60: (void) signal(SIGBUS, intrEXIT);
61: (void) signal(SIGSEGV, intrEXIT);
62: (void) signal(SIGSYS, intrEXIT);
63: (void) signal(SIGPIPE, SIG_IGN);
64: (void) signal(SIGINT, onintr);
65: (void) signal(SIGHUP, onintr);
66: (void) signal(SIGQUIT, onintr);
67: (void) signal(SIGTERM, onintr);
68: #ifdef ATTSV
69: (void) signal(SIGUSR1, SIG_IGN);
70: (void) signal(SIGUSR2, SIG_IGN);
71: #endif
72: ret = guinfo(Euid, User);
73: ASSERT(ret == 0, "BAD UID ", "", ret);
74: strncpy(Uucp, User, NAMESIZE);
75:
76: setuucp(User);
77: ret = guinfo(Uid, Loginuser);
78: ASSERT(ret == 0, "BAD LOGIN_UID ", "", ret);
79:
80: *xflag = NULLCHAR;
81: Ifn = Ofn = -1;
82: while ((ret = getopt(argc, argv, "d:r:s:x:")) != EOF) {
83: switch (ret) {
84: case 'd':
85: Spool = optarg;
86: break;
87: case 'r':
88: Role = atoi(optarg);
89: break;
90: case 's':
91: if (versys(optarg, 0)) {
92: DEBUG(4, "%s not in Systems file\n", optarg);
93: cleanup(101);
94: }
95: strncpy(Rmtname, optarg, MAXBASENAME);
96: Rmtname[MAXBASENAME] = '\0';
97: /* set args for possible xuuxqt call */
98: strcpy(uuxqtarg, Rmtname);
99: break;
100: case 'x':
101: Debug = atoi(optarg);
102: if (Debug <= 0)
103: Debug = 1;
104: if (Debug > 9)
105: Debug = 9;
106: (void) sprintf(xflag, "-x%d", Debug);
107: break;
108: default:
109: (void) fprintf(stderr, "\tusage: %s %s\n",
110: Progname, USAGE);
111: exit(1);
112: }
113: }
114:
115: if (Role == MASTER) {
116: if (*Rmtname == NULLCHAR) {
117: DEBUG(5, "No -s specified\n" , "");
118: cleanup(101);
119: }
120: /* get Myname - it depends on who I'm calling--Rmtname */
121: (void) mchFind(Rmtname);
122: myName(Myname);
123: if (EQUALSN(Rmtname, Myname, SYSNSIZE)) {
124: DEBUG(5, "This system specified: -sMyname: %s, ", Myname);
125: cleanup(101);
126: }
127: }
128:
129: ASSERT(chdir(Spool) == 0, Ct_CHDIR, Spool, errno);
130: strcpy(Wrkdir, Spool);
131:
132: if (Role == SLAVE) {
133:
134: /*
135: * initial handshake
136: */
137: ret = savline();
138: Ifn = 0;
139: Ofn = 1;
140: fixline(Ifn, 0, D_ACU);
141: freopen(RMTDEBUG, "a", stderr);
142: /* get MyName - use logFind to check PERMISSIONS file */
143: (void) logFind(Loginuser, "");
144: myName(Myname);
145:
146: DEBUG(4,"cico.c: Myname - %s\n",Myname);
147: DEBUG(4,"cico.c: Loginuser - %s\n",Loginuser);
148: Nstat.t_scall = times(&Nstat.t_tga);
149: (void) sprintf(msg, "here=%s", Myname);
150: omsg('S', msg, Ofn);
151: (void) signal(SIGALRM, timeout);
152: (void) alarm(2 * MAXMSGTIME); /* give slow machines a second chance */
153: if (setjmp(Sjbuf)) {
154:
155: /*
156: * timed out
157: */
158: ret = restline();
159: rmlock(CNULL);
160: exit(0);
161: }
162: for (;;) {
163: ret = imsg(msg, Ifn);
164: if (ret != 0) {
165: (void) alarm(0);
166: ret = restline();
167: rmlock(CNULL);
168: exit(0);
169: }
170: if (msg[0] == 'S')
171: break;
172: }
173: Nstat.t_ecall = times(&Nstat.t_tga);
174: (void) alarm(0);
175: q = &msg[1];
176: p = pskip(q);
177: strncpy(Rmtname, q, MAXBASENAME);
178: Rmtname[MAXBASENAME] = '\0';
179:
180: seq = 0;
181: while (*p == '-') {
182: q = pskip(p);
183: switch(*(++p)) {
184: case 'x':
185: Debug = atoi(++p);
186: if (Debug <= 0)
187: Debug = 1;
188: break;
189: case 'Q':
190: seq = atoi(++p);
191: break;
192: default:
193: break;
194: }
195: p = q;
196: }
197: DEBUG(4, "sys-%s\n", Rmtname);
198:
199: #ifdef NOSTRANGERS
200: /* here's the place to look the remote system up in the Systems file.
201: * If the command NOSTRANGERS is executable and
202: /* If they're not in my file then hang up */
203: if ( (access(NOSTRANGERS, 1) == 0) && versys(Rmtname, 1)) {
204: char unkcmd[64];
205: register char *p;
206:
207: omsg('R', "You are unknown to me", Ofn);
208: for (p = Rmtname; *p; p++)
209: if (*p == '\'')
210: *p = ' '; /* cheap hack. who cares. */
211: (void) sprintf(unkcmd, "%s '%s'", NOSTRANGERS, Rmtname);
212: system(unkcmd);
213: cleanup(101);
214: }
215: #endif NOSTRANGERS
216:
217: if (mlock(Rmtname)) {
218: omsg('R', "LCK", Ofn);
219: cleanup(101);
220: }
221:
222: /* validate login using PERMISSIONS file */
223: if (logFind(Loginuser, Rmtname) == FAIL) {
224: Uerror = SS_BAD_LOG_MCH;
225: logent(UERRORTEXT, "FAILED");
226: systat(Rmtname, SS_BAD_LOG_MCH, UERRORTEXT,
227: Retrytime);
228: omsg('R', "LOGIN", Ofn);
229: cleanup(101);
230: }
231:
232: ret = callBack();
233: DEBUG(4,"return from callcheck: %s",ret ? "TRUE" : "FALSE");
234: if (ret==TRUE) {
235: (void) signal(SIGINT, SIG_IGN);
236: (void) signal(SIGHUP, SIG_IGN);
237: omsg('R', "CB", Ofn);
238: logent("CALLBACK", "REQUIRED");
239:
240: /*
241: * set up for call back
242: */
243: systat(Rmtname, SS_CALLBACK, "CALL BACK", Retrytime);
244: gename(CMDPRE, Rmtname, 'C', file);
245: (void) close(creat(file, CFILEMODE));
246: xuucico(Rmtname);
247: cleanup(101);
248: }
249:
250: if (callok(Rmtname) == SS_SEQBAD) {
251: Uerror = SS_SEQBAD;
252: logent(UERRORTEXT, "PREVIOUS");
253: omsg('R', "BADSEQ", Ofn);
254: cleanup(101);
255: }
256:
257: if ((ret = gnxseq(Rmtname)) == seq) {
258: omsg('R', "OK", Ofn);
259: cmtseq();
260: } else {
261: Uerror = SS_SEQBAD;
262: systat(Rmtname, SS_SEQBAD, UERRORTEXT, Retrytime);
263: logent(UERRORTEXT, "HANDSHAKE FAILED");
264: ulkseq();
265: omsg('R', "BADSEQ", Ofn);
266: cleanup(101);
267: }
268: ttyn = ttyname(Ifn);
269: if (ttyn != NULL) {
270: strcpy(Dc, BASENAME(ttyn, '/'));
271: chmod(ttyn, 0666); /* can fail, but who cares? */
272: } else
273: strcpy(Dc, "notty");
274: /* set args for possible xuuxqt call */
275: strcpy(uuxqtarg, Rmtname);
276: }
277:
278: strcpy(User, Uucp);
279: /*
280: * Ensure reasonable ulimit (MINULIMIT)
281: */
282:
283: #ifndef V7
284: minulimit = ulimit(1,dummy);
285: ASSERT(minulimit >= MINULIMIT, "ULIMIT TOO SMALL",
286: Loginuser, minulimit);
287: #endif
288: if (Role == MASTER && callok(Rmtname) != 0) {
289: logent("SYSTEM STATUS", "CAN NOT CALL");
290: cleanup(101);
291: }
292:
293: chremdir(Rmtname);
294:
295: (void) strcpy(Wrkdir, RemSpool);
296: if (Role == MASTER) {
297:
298: /*
299: * master part
300: */
301: (void) signal(SIGINT, SIG_IGN);
302: (void) signal(SIGHUP, SIG_IGN);
303: (void) signal(SIGQUIT, SIG_IGN);
304: if (Ifn != -1 && Role == MASTER) {
305: (void) write(Ofn, EOTMSG, strlen(EOTMSG));
306: (void) close(Ofn);
307: (void) close(Ifn);
308: Ifn = Ofn = -1;
309: rmlock(CNULL);
310: sleep(3);
311: }
312: (void) sprintf(msg, "call to %s ", Rmtname);
313: if (mlock(Rmtname) != 0) {
314: logent(msg, "LOCKED");
315: CDEBUG(1, "Currently Talking With %s\n",
316: Rmtname);
317: cleanup(100);
318: }
319: Nstat.t_scall = times(&Nstat.t_tga);
320: Ofn = Ifn = conn(Rmtname);
321: Nstat.t_ecall = times(&Nstat.t_tga);
322: if (Ofn < 0) {
323: delock(Rmtname);
324: logent(UERRORTEXT, "CONN FAILED");
325: systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
326: cleanup(101);
327: } else {
328: logent(msg, "SUCCEEDED");
329: ttyn = ttyname(Ifn);
330: if (ttyn != NULL)
331: chmod(ttyn, DEVICEMODE);
332: }
333:
334: if (setjmp(Sjbuf)) {
335: delock(Rmtname);
336: Uerror = SS_LOGIN_FAILED;
337: logent(Rmtname, UERRORTEXT);
338: systat(Rmtname, SS_LOGIN_FAILED,
339: UERRORTEXT, Retrytime);
340: DEBUG(4, "%s - failed\n", UERRORTEXT);
341: cleanup(101);
342: }
343: (void) signal(SIGALRM, timeout);
344: /* give slow guys lots of time to thrash */
345: (void) alarm(3 * MAXMSGTIME);
346: for (;;) {
347: ret = imsg(msg, Ifn);
348: if (ret != 0) {
349: continue; /* try again */
350: }
351: if (msg[0] == 'S')
352: break;
353: }
354: (void) alarm(0);
355: if(EQUALSN("here=", &msg[1], 5)){
356: /*
357: /* this is a problem. We'd like to compare with an
358: * untruncated Rmtname but we fear incompatability.
359: * So we'll look at most 6 chars (at most).
360: */
361: if(!EQUALSN(&msg[6], Rmtname, (strlen(Rmtname)< 7 ?
362: strlen(Rmtname) : 6))){
363: delock(Rmtname);
364: Uerror = SS_WRONG_MCH;
365: logent(&msg[6], UERRORTEXT);
366: systat(Rmtname, SS_WRONG_MCH, UERRORTEXT,
367: Retrytime);
368: DEBUG(4, "%s - failed\n", UERRORTEXT);
369: cleanup(101);
370: }
371: }
372: CDEBUG(1,"Login Successful: System=%s\n",&msg[6]);
373: seq = gnxseq(Rmtname);
374: (void) sprintf(msg, "%s -Q%d %s", Myname, seq, xflag);
375: omsg('S', msg, Ofn);
376: (void) alarm(2 * MAXMSGTIME); /* give slow guys some thrash time */
377: for (;;) {
378: ret = imsg(msg, Ifn);
379: DEBUG(4, "msg-%s\n", msg);
380: if (ret != 0) {
381: (void) alarm(0);
382: delock(Rmtname);
383: ulkseq();
384: cleanup(101);
385: }
386: if (msg[0] == 'R')
387: break;
388: }
389: (void) alarm(0);
390:
391: /* check for rejects from remote */
392: Uerror = 0;
393: if (EQUALS(&msg[1], "LCK"))
394: Uerror = SS_RLOCKED;
395: else if (EQUALS(&msg[1], "LOGIN"))
396: Uerror = SS_RLOGIN;
397: else if (EQUALS(&msg[1], "CB"))
398: Uerror = SS_CALLBACK;
399: else if (EQUALS(&msg[1], "You are unknown to me"))
400: Uerror = SS_RUNKNOWN;
401: else if (EQUALS(&msg[1], "BADSEQ"))
402: Uerror = SS_SEQBAD;
403: else if (!EQUALS(&msg[1], "OK"))
404: Uerror = SS_UNKNOWN_RESPONSE;
405: if (Uerror) {
406: delock(Rmtname);
407: systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
408: logent(UERRORTEXT, "HANDSHAKE FAILED");
409: CDEBUG(1, "HANDSHAKE FAILED: %s\n", UERRORTEXT);
410: ulkseq();
411: cleanup(101);
412: }
413: cmtseq();
414: }
415: DEBUG(4, " Rmtname %s, ", Rmtname);
416: DEBUG(4, "Role %s, ", Role ? "MASTER" : "SLAVE");
417: DEBUG(4, "Ifn - %d, ", Ifn);
418: DEBUG(4, "Loginuser - %s\n", Loginuser);
419:
420: /* alarm/setjmp added here due to experience with uucico
421: * hanging for hours in imsg().
422: */
423: if (setjmp(Sjbuf)) {
424: delock(Rmtname);
425: logent("startup", "TIMEOUT");
426: DEBUG(4, "%s - timeout\n", "startup");
427: cleanup(101);
428: }
429: (void) alarm(MAXSTART);
430: ret = startup(Role);
431: (void) alarm(0);
432:
433: if (ret != SUCCESS) {
434: delock(Rmtname);
435: logent("startup", "FAILED");
436: Uerror = SS_STARTUP;
437: CDEBUG(1, "%s\n", UERRORTEXT);
438: systat(Rmtname, Uerror, UERRORTEXT, Retrytime);
439: exitcode = 101;
440: } else {
441: logent("startup", "OK");
442: systat(Rmtname, SS_INPROGRESS, UTEXT(SS_INPROGRESS),Retrytime);
443: Nstat.t_sftp = times(&Nstat.t_tga);
444:
445: exitcode = cntrl(Role);
446: Nstat.t_eftp = times(&Nstat.t_tga);
447: DEBUG(4, "cntrl - %d\n", exitcode);
448: (void) signal(SIGINT, SIG_IGN);
449: (void) signal(SIGHUP, SIG_IGN);
450: (void) signal(SIGALRM, timeout);
451:
452: if (exitcode == 0) {
453: (void) time(&ts);
454: (void) sprintf(cb, "conversation complete %s %ld",
455: Dc, ts - tconv);
456: logent(cb, "OK");
457: systat(Rmtname, SS_OK, UTEXT(SS_OK), Retrytime);
458:
459: } else {
460: logent("conversation complete", "FAILED");
461: systat(Rmtname, SS_CONVERSATION,
462: UTEXT(SS_CONVERSATION), Retrytime);
463: }
464: (void) alarm(2 * MAXMSGTIME); /* give slow guys some thrash time */
465: omsg('O', "OOOOO", Ofn);
466: CDEBUG(4, "send OO %d,", ret);
467: if (!setjmp(Sjbuf)) {
468: for (;;) {
469: omsg('O', "OOOOO", Ofn);
470: ret = imsg(msg, Ifn);
471: if (ret != 0)
472: break;
473: if (msg[0] == 'O')
474: break;
475: }
476: }
477: (void) alarm(0);
478: }
479: cleanup(exitcode);
480: }
481:
482: /*
483: * clean and exit with "code" status
484: */
485: cleanup(code)
486: register int code;
487: {
488: int ret;
489: char *ttyn;
490:
491: (void) signal(SIGINT, SIG_IGN);
492: (void) signal(SIGHUP, SIG_IGN);
493: rmlock(CNULL);
494: closedem();
495: if (Role == SLAVE) {
496: ret = restline();
497: DEBUG(4, "ret restline - %d\n", ret);
498: sethup(0);
499: }
500: if (Ofn != -1) {
501: if (Role == MASTER)
502: (void) write(Ofn, EOTMSG, strlen(EOTMSG));
503: ttyn = ttyname(Ifn);
504: if (ttyn != NULL)
505: chmod(ttyn, 0644); /* can fail, but who cares? */
506: (void) close(Ifn);
507: (void) close(Ofn);
508: }
509: DEBUG(4, "exit code %d\n", code);
510: CDEBUG(1, "Conversation Complete: Status %s\n\n",
511: code ? "FAILED" : "SUCCEEDED");
512:
513: cleanTM();
514: if (code == 0)
515: xuuxqt(uuxqtarg);
516: exit(code);
517: }
518:
519: short TM_cnt = 0;
520: char TM_name[MAXNAMESIZE];
521:
522: cleanTM()
523: {
524: register int i;
525: char tm_name[MAXNAMESIZE];
526:
527: DEBUG(7,"TM_cnt: %d\n",TM_cnt);
528: for(i=0; i < TM_cnt; i++) {
529: (void) sprintf(tm_name, "%s.%3.3d", TM_name, i);
530: DEBUG(7, "tm_name: %s\n", tm_name);
531: unlink(tm_name);
532: }
533: }
534:
535: TMname(file, pnum)
536: char *file;
537: {
538:
539: (void) sprintf(file, "%s/TM.%.5d.%.3d", RemSpool, pnum, TM_cnt);
540: if (TM_cnt == 0)
541: (void) sprintf(TM_name, "%s/TM.%.5d", RemSpool, pnum);
542: DEBUG(7, "TMname(%s)\n", file);
543: TM_cnt++;
544: }
545:
546: /*
547: * intrrupt - remove locks and exit
548: */
549: onintr(inter)
550: register int inter;
551: {
552: char str[30];
553: /* I'm putting a test for zero here because I saw it happen
554: * and don't know how or why, but it seemed to then loop
555: * here for ever?
556: */
557: if (inter == 0)
558: exit(99);
559: (void) signal(inter, SIG_IGN);
560: (void) sprintf(str, "SIGNAL %d", inter);
561: logent(str, "CAUGHT");
562: cleanup(inter);
563: }
564:
565: /*ARGSUSED*/
566: intrEXIT(inter)
567: {
568: char cb[10];
569: extern int errno;
570:
571: (void) sprintf(cb, "%d", errno);
572: logent("INTREXIT", cb);
573: (void) signal(SIGIOT, SIG_DFL);
574: (void) signal(SIGILL, SIG_DFL);
575: rmlock(CNULL);
576: closedem();
577: (void) setuid(Uid);
578: abort();
579: }
580:
581: /*
582: * catch SIGALRM routine
583: */
584: timeout()
585: {
586: longjmp(Sjbuf, 1);
587: }
588:
589: static char *
590: pskip(p)
591: register char *p;
592: {
593: while( *p && *p != ' ' )
594: ++p;
595: if( *p ) *p++ = 0;
596: return(p);
597: }
598:
599: void
600: closedem()
601: {
602: register i;
603:
604: for(i=3;i<_NFILE;i++)
605: (void) close(i);
606: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.