![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to conn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / uucp|
Return to conn.c CVS log | Up to [Research Unix] / researchv10no / cmd / uucp |
1.1 root 1: /* @(#)conn.c 1.16
2: */
3: #include "uucp.h"
4: VERSION(@(#)conn.c 1.16);
5:
6: static char _ProtoStr[20] = ""; /* protocol string from Systems file entry */
7: extern jmp_buf Sjbuf;
8:
9: int alarmtr();
10: static void getProto();
11: /* static getto(), finds(); PUT this back after altconn is included */
12: extern getto();
13: static finds();
14:
15: static notin(), ifdate(), classmatch();
16:
17: extern struct caller caller[];
18:
19: /* Needed for cu for force which line will be used */
20: #ifdef STANDALONE
21: extern char *Myline;
22: #endif STANDALONE
23:
24: /*
25: * conn - place a telephone call to system and login, etc.
26: *
27: * return codes:
28: * FAIL - connection failed
29: * >0 - file no. - connect ok
30: * When a failure occurs, Uerror is set.
31: */
32:
33: conn(system)
34: char *system;
35: {
36: int nf, fn = FAIL;
37: char *flds[F_MAX+1];
38: FILE *fsys;
39: int (*oalrm)();
40: #ifdef MANYSYS
41: #define SYSCLOSE pclose
42: FILE *sysopen();
43: #else
44: #define SYSCLOSE fclose
45: #endif
46:
47: CDEBUG(4, "conn(%s)\n", system);
48: #ifndef MANYSYS
49: fsys = fopen(SYSFILE, "r");
50: #else
51: fsys = sysopen(system);
52: #endif
53: ASSERT(fsys != NULL, Ct_OPEN, SYSFILE, errno);
54: Uerror = 0;
55: while ((nf = finds(fsys, system, flds, F_MAX)) > 0) {
56: fn = getto(flds);
57: CDEBUG(4, "getto ret %d\n", fn);
58: if (fn < 0)
59: continue;
60: #ifdef STANDALONE
61: SYSCLOSE(fsys);
62: return(fn);
63: #else
64: if (chat(nf - F_LOGIN, flds + F_LOGIN, fn,"","") == SUCCESS) {
65: SYSCLOSE(fsys);
66: return(fn); /* successful return */
67: }
68:
69: /* login failed */
70: DEBUG(6, "close caller (%d)\n", fn);
71: if (setjmp(Sjbuf) == 0) {
72: oalrm = signal(SIGALRM, alarmtr);
73: alarm(30);
74: close(fn);
75: }
76: alarm(0);
77: signal(SIGALRM, oalrm);
78: if (Dc[0] != NULLCHAR) {
79: DEBUG(6, "delock(%s)\n", Dc);
80: delock(Dc);
81: }
82: #endif
83: }
84:
85: /* finds or getto failed */
86: SYSCLOSE(fsys);
87: CDEBUG(1, "Call Failed: %s\n", UERRORTEXT);
88: return(FAIL);
89: }
90:
91: /*
92: * getto - connect to remote machine
93: *
94: * return codes:
95: * >0 - file number - ok
96: * FAIL - failed
97: */
98:
99: getto(flds)
100: char *flds[];
101: {
102: FILE *dfp;
103: char *dev[D_MAX+2], devbuf[BUFSIZ];
104: register int status;
105: register int dcf = -1;
106: int reread = 0;
107: int tries = 0; /* count of call attempts - for limit purposes */
108:
109: CDEBUG(1, "Device Type %s wanted\n", flds[F_TYPE]);
110: dfp = fopen(DEVFILE, "r");
111: ASSERT(dfp != NULL, Ct_OPEN, DEVFILE, errno);
112: Uerror = 0;
113: while (tries < TRYCALLS) {
114: if ((status=rddev(dfp, flds[F_TYPE], dev, devbuf, D_MAX)) == FAIL) {
115: if (tries == 0 || ++reread >= TRYCALLS)
116: break;
117: rewind(dfp);
118: continue;
119: }
120: /* check class, check (and possibly set) speed */
121: if (classmatch(flds, dev) != SUCCESS)
122: continue;
123: if ((dcf = processdev(flds, dev)) >= 0)
124: break;
125:
126: switch(Uerror) {
127: case SS_CANT_ACCESS_DEVICE:
128: case SS_DEVICE_FAILED:
129: case SS_LOCKED_DEVICE:
130: break;
131: default:
132: tries++;
133: break;
134: }
135: }
136: (void) fclose(dfp);
137: if (status == FAIL && !Uerror) {
138: CDEBUG(1, "Requested Device Type Not Found\n", 0);
139: Uerror = SS_NO_DEVICE;
140: }
141: return(dcf);
142: }
143:
144: /*
145: * classmatch - process 'Any' in Devices and Systems and
146: * determine the correct speed, or match for ==
147: */
148:
149: static int
150: classmatch(flds, dev)
151: char *flds[], *dev[];
152: {
153: /* check class, check (and possibly set) speed */
154: if (EQUALS(flds[F_CLASS], "Any")
155: && EQUALS(dev[D_CLASS], "Any")) {
156: dev[D_CLASS] = flds[F_CLASS] = DEFAULT_BAUDRATE;
157: return(SUCCESS);
158: } else if (EQUALS(dev[F_CLASS], "Any")) {
159: dev[D_CLASS] = flds[F_CLASS];
160: return(SUCCESS);
161: } else if (EQUALS(flds[F_CLASS], "Any")) {
162: flds[D_CLASS] = dev[F_CLASS];
163: return(SUCCESS);
164: } else if (EQUALS(flds[F_CLASS], dev[D_CLASS]))
165: return(SUCCESS);
166: else
167: return(FAIL);
168: }
169:
170:
171: /***
172: * rddev - find and unpack a line from device file for this caller type
173: * lines starting with whitespace of '#' are comments
174: *
175: * return codes:
176: * >0 - number of arguments in vector - succeeded
177: * FAIL - EOF
178: ***/
179:
180: rddev(fp, type, dev, buf, devcount)
181: FILE *fp;
182: char *type;
183: char *dev[];
184: char *buf;
185: {
186: int na;
187:
188: while (fgets(buf, BUFSIZ, fp) != NULL) {
189: if (buf[0] == ' ' || buf[0] == '\t'
190: || buf[0] == '\n' || buf[0] == '\0' || buf[0] == '#')
191: continue;
192: na = getargs(buf, dev, devcount);
193: ASSERT(na >= D_CALLER, "BAD LINE", buf, na);
194:
195: /* For cu -- to force the requested line to be used */
196: #ifdef STANDALONE
197: if ((Myline != NULL) && (!EQUALS(Myline, dev[D_LINE])) )
198: continue;
199: #endif STANDALONE
200:
201: bsfix(dev); /* replace \X fields */
202: if (EQUALS(dev[D_TYPE], type))
203: return(na);
204: }
205: return(FAIL);
206: }
207:
208:
209: /*
210: * finds - set system attribute vector
211: *
212: * input:
213: * fsys - open Systems file descriptor
214: * sysnam - system name to find
215: * output:
216: * flds - attibute vector from Systems file
217: * fldcount - number of fields in flds
218: * return codes:
219: * >0 - number of arguments in vector - succeeded
220: * FAIL - failed
221: * Uerror set:
222: * 0 - found a line in Systems file
223: * SS_BADSYSTEM - no line found in Systems file
224: * SS_TIME_WRONG - wrong time to call
225: */
226:
227: static
228: finds(fsys, sysnam, flds, fldcount)
229: char *sysnam, *flds[];
230: FILE *fsys;
231: {
232: static char info[BUFSIZ];
233: int na;
234:
235: /* format of fields
236: * 0 name;
237: * 1 time
238: * 2 acu/hardwired
239: * 3 speed
240: * etc
241: */
242: while (fgets(info, BUFSIZ, fsys) != NULL) {
243: if (info[0] == '#')
244: continue;
245: na = getargs(info, flds, fldcount);
246: bsfix(flds); /* replace \X fields */
247: if ( !EQUALSN(sysnam, flds[F_NAME], SYSNSIZE))
248: continue;
249: #ifndef STANDALONE
250: if (ifdate(flds[F_TIME])) {
251: /* found a good entry */
252: getProto(flds[F_TYPE]);
253: Uerror = 0;
254: return(na); /* FOUND OK LINE */
255: }
256: CDEBUG(1, "Wrong Time To Call: %s\n", flds[F_TIME]);
257: Uerror = SS_TIME_WRONG;
258: #else
259: Uerror = 0;
260: return(na); /* FOUND OK LINE */
261: #endif
262: }
263: if (!Uerror)
264: Uerror = SS_BADSYSTEM;
265: return(FAIL);
266: }
267:
268: /*
269: * getProto - get the protocol letters from the input string.
270: * input:
271: * str - string from Systems file (flds[F_TYPE])--the ,
272: * delimits the protocol string
273: * e.g. ACU,g or DK,d
274: * output:
275: * str - the , (if present) will be replaced with NULLCHAR
276: * global ProtoStr will be modified
277: * return: none
278: */
279:
280: static
281: void
282: getProto(str)
283: char *str;
284: {
285: register char *p;
286: if ( (p=strchr(str, ',')) != NULL) {
287: *p = NULLCHAR;
288: (void) strcpy(_ProtoStr, p+1);
289: DEBUG(7, "ProtoStr = %s\n", _ProtoStr);
290: }
291: else
292: *_ProtoStr = NULLCHAR;
293: }
294:
295: /*
296: * check for a specified protocol selection string
297: * return:
298: * protocol string pointer
299: * NULL if none specified for LOGNAME
300: */
301: char *
302: protoString()
303: {
304: return(_ProtoStr[0] == NULLCHAR ? NULL : _ProtoStr);
305: }
306:
307: static int _Echoflag;
308: static int _Slowflag;
309: /*
310: * chat - do conversation
311: * input:
312: * flds - fields from Systems file
313: * nf - number of fields in flds array
314: * dcr - write file number
315: * phstr1 - phone number to replace \D
316: * phstr2 - phone number to replace \T
317: *
318: * return codes: 0 | FAIL
319: */
320:
321: chat(nf, flds, fn, phstr1, phstr2)
322: char *flds[], *phstr1, *phstr2;
323: int nf, fn;
324: {
325: char *want, *altern;
326: extern char *strchr();
327: int k, ok;
328:
329: _Echoflag = 0;
330: _Slowflag = 0;
331: for (k = 0; k < nf; k += 2) {
332: want = flds[k];
333: ok = FAIL;
334: while (ok != 0) {
335: altern = strchr(want, '-');
336: if (altern != NULL)
337: *altern++ = NULLCHAR;
338: ok = expect(want, fn);
339: if (ok == 0)
340: break;
341: if (altern == NULL) {
342: Uerror = SS_LOGIN_FAILED;
343: logent(UERRORTEXT, "FAILED");
344: return(FAIL);
345: }
346: want = strchr(altern, '-');
347: if (want != NULL)
348: *want++ = NULLCHAR;
349: sendthem(altern, fn, phstr1, phstr2);
350: }
351: sleep(2);
352: if (flds[k+1])
353: sendthem(flds[k+1], fn, phstr1, phstr2);
354: }
355: return(0);
356: }
357:
358: /***
359: * expect(str, fn) look for expected string
360: * char *str;
361: *
362: * return codes:
363: * 0 - found
364: * FAIL - lost line or too many characters read
365: * some character - timed out
366: *
367: * There are many delicacies here.
368: * -- keep the system calls in the inner loop to a minimum;
369: * else a garrulous system might time out while we're reading
370: * its chatter.
371: * -- because systems may be garrulous but correct, the alarm
372: * must be reset whenever a character arrives; time out only
373: * if nothing has come for a while. But putting the alarm inside
374: * the inner loop slows it down too much; so put it outside,
375: * and don't time out if anything arrives. But that might let
376: * the far side time out in some pathological cases, so wait
377: * a shorter time if some character have already arrived.
378: * -- reading several characters at a time might be a mistake;
379: * we might consume something beyond the string we expect,
380: * discard it here, but need it later. Too bad for now.
381: */
382:
383: #define MR 2000 /* max chars before we give up */
384: #define NNEXT 4 /* chars to read at a time */
385:
386: expect(str, fn)
387: char *str;
388: int fn;
389: {
390: static char rdvec[MR];
391: register char *rp = rdvec;
392: register int kr, c;
393: char nextch[NNEXT];
394: char dbuf[NNEXT*2 + 1];
395: register char *dp, *cp;
396: int nread;
397: extern errno;
398:
399: CDEBUG(4, "expect: (", 0);
400: for (c=0; kr=str[c]; c++)
401: if (kr < 040) {
402: CDEBUG(4, "^%c", kr | 0100);
403: } else {
404: CDEBUG(4, "%c", kr);
405: }
406: CDEBUG(4, ")\n", 0);
407:
408: if (EQUALS(str, "\"\"")) {
409: CDEBUG(4, "got it\n", 0);
410: return(0);
411: }
412: nread = 0;
413: if (setjmp(Sjbuf) && nread == 0) {
414: return(FAIL);
415: }
416: (void) signal(SIGALRM, alarmtr);
417: if (nread)
418: alarm(MAXEXPECTTIME/2); /* cheap hack */
419: else
420: alarm(MAXEXPECTTIME);
421: nread = 0;
422: do {
423: errno = 0;
424: kr = read(fn, nextch, NNEXT);
425: if (kr <= 0) {
426: alarm(0);
427: CDEBUG(4, "lost line errno - %d\n", errno);
428: logent("LOGIN", "LOST LINE");
429: return(FAIL);
430: }
431: if (rp + kr >= rdvec + MR) {
432: CDEBUG(4, "\ntoo much junk\n", 0);
433: alarm(0);
434: return(FAIL);
435: }
436: nread += kr;
437: for (dp = dbuf, cp = nextch; --kr >= 0; ) {
438: if ((c = *cp++ & 0177) == 0)
439: continue;
440: *rp++ = c;
441: if (c >= 040)
442: *dp++ = c;
443: else {
444: *dp++ = '^';
445: *dp++ = c+0100;
446: }
447: }
448: *dp = 0;
449: CDEBUG(4, "%s", dbuf);
450: *rp = NULLCHAR;
451: } while (notin(str, rdvec));
452: alarm(0);
453: CDEBUG(4, "got it\n", 0);
454: return(0);
455: }
456:
457:
458: /***
459: * alarmtr() - catch alarm routine for "expect".
460: */
461:
462: alarmtr()
463: {
464: CDEBUG(6, "timed out\n", 0);
465: longjmp(Sjbuf, 1);
466: }
467:
468:
469: /***
470: * sendthem(str, fn, phstr1, phstr2) send line of chat sequence
471: * char *str, *phstr;
472: *
473: * return codes: none
474: */
475:
476: sendthem(str, fn, phstr1, phstr2)
477: char *str, *phstr1, *phstr2;
478: int fn;
479: {
480: int sendcr = 1;
481: register char *sptr, *pptr;
482:
483: if (PREFIX("BREAK", str)) {
484: /* send break */
485: CDEBUG(5, "BREAK\n", 0);
486: genbrk(fn);
487: return;
488: }
489:
490: if (EQUALS(str, "EOT")) {
491: CDEBUG(5, "EOT\n", 0);
492: (void) write(fn, EOTMSG, strlen(EOTMSG));
493: return;
494: }
495:
496: if (EQUALS(str, "\"\"")) {
497: CDEBUG(5, "\"\"\n", 0);
498: str += 2;
499: }
500:
501: CDEBUG(5, "sendthem (", "");
502: if (setjmp(Sjbuf)) /* Timer so echo check doesn't last forever */
503: goto err;
504: (void) signal(SIGALRM, alarmtr);
505: alarm(MAXEXPECTTIME);
506: for (sptr = str; *sptr; sptr++) {
507: if (*sptr == '\\')
508: switch(*++sptr) {
509: case 'D':
510: for (pptr=phstr1; *pptr; pptr++)
511: if (wrchar(fn, pptr))
512: goto err;
513: continue;
514: case 'T':
515: for (pptr=phstr2; *pptr; pptr++)
516: if (wrchar(fn, pptr))
517: goto err;
518: continue;
519: case 'N':
520: *sptr = 0;
521: break;
522: case 'd':
523: CDEBUG(5, "DELAY\n", 0);
524: sleep(2);
525: continue;
526: case 'c':
527: if (*(sptr+1) == NULLCHAR) {
528: CDEBUG(5, "<NO CR>", 0);
529: sendcr = 0;
530: continue;
531: }
532: CDEBUG(5, "<NO CR - MIDDLE IGNORED>\n", 0);
533: continue;
534: case 's':
535: *sptr = ' ';
536: break;
537: case 'p':
538: CDEBUG(5, "PAUSE\n", 0);
539: nap(HZ/4); /* approximately 1/4 second */
540: continue;
541: case 'E':
542: CDEBUG(5, "ECHO CHECK ON\n", 0);
543: _Echoflag = 1;
544: continue;
545: case 'e':
546: CDEBUG(5, "ECHO CHECK OFF\n", 0);
547: _Echoflag = 0;
548: continue;
549: case 'K':
550: CDEBUG(5, "BREAK\n", 0);
551: genbrk(fn);
552: continue;
553: case 'W':
554: _Slowflag = 1;
555: continue;
556: case 'w':
557: _Slowflag = 0;
558: continue;
559: case '\\':
560: /* backslash escapes itself */
561: break;
562: default:
563: /* send the backslash */
564: --sptr;
565: break;
566: }
567: if (wrchar(fn, sptr))
568: goto err;
569: }
570:
571: if (sendcr) {
572: CDEBUG(5, "^M", 0);
573: (void) write(fn, "\r", 1);
574: }
575: err:
576: alarm(0);
577: CDEBUG(5, ")\n", 0);
578: return;
579: }
580:
581: wrchar(fn, sptr)
582: register int fn;
583: register char *sptr;
584: {
585: if (GRPCHK(getgid())) /* protect Systems file */
586: {
587: CDEBUG(5, "%s", *sptr < 040 ? "^" : "");
588: CDEBUG(5, "%c", *sptr < 040 ? *sptr | 0100 : *sptr);
589: }
590: if ((write(fn, sptr, 1)) != 1)
591: return(FAIL);
592: if (_Echoflag) {
593: char chr;
594: while(1) { /* Should set a timer here */
595: if (read(fn, &chr, 1) != 1)
596: return(FAIL);
597: chr &= 0177;
598: CDEBUG(4, "%s", chr < 040 ? "^" : "");
599: CDEBUG(4, "%c", chr < 040 ? chr | 0100 : chr);
600: if (chr == ((*sptr) & 0177))
601: break;
602: }
603:
604: }
605: if (_Slowflag)
606: sleep(1);
607: return(SUCCESS);
608: }
609:
610:
611: /***
612: * notin(sh, lg) check for occurrence of substring "sh"
613: * char *sh, *lg;
614: *
615: * return codes:
616: * 0 - found the string
617: * 1 - not in the string
618: */
619:
620: static
621: notin(sh, lg)
622: register char *sh, *lg;
623: {
624: while (*lg != NULLCHAR) {
625: if (PREFIX(sh, lg))
626: return(0);
627: else
628: lg++;
629: }
630: return(1);
631: }
632:
633:
634: /*******
635: * ifdate(s)
636: * char *s;
637: *
638: * ifdate - this routine will check a string (s)
639: * like "MoTu0800-1730" to see if the present
640: * time is within the given limits.
641: * SIDE EFFECT - Retrytime is set to number following ";"
642: *
643: * String alternatives:
644: * Wk - Mo thru Fr
645: * zero or one time means all day
646: * Any - any day
647: *
648: * return codes:
649: * 0 - not within limits
650: * 1 - within limits
651: */
652:
653: static
654: ifdate(s)
655: char *s;
656: {
657: static char *days[] = {
658: "Su", "Mo", "Tu", "We", "Th", "Fr", "Sa", 0
659: };
660: time_t clock;
661: int t__now;
662: char *p, *strrchr(), *strchr();
663: struct tm *tp;
664:
665: time(&clock);
666: tp = localtime(&clock);
667: t__now = tp->tm_hour * 100 + tp->tm_min; /* "navy" time */
668:
669: /*
670: * pick up retry time for failures
671: * global variable Retrytime is set here
672: */
673: if ((p = strrchr(s, ';')) != NULL)
674: if (isdigit(p[1])) {
675: if (sscanf(p+1, "%d", &Retrytime) < 1)
676: Retrytime = 5; /* 5 minutes is error default */
677: Retrytime *= 60;
678: *p = NULLCHAR;
679: }
680:
681: while (*s) {
682: int i, dayok;
683:
684: for (dayok = 0; (!dayok) && isalpha(*s); s++) {
685: if (PREFIX("Any", s))
686: dayok = 1;
687: else if (PREFIX("Wk", s)) {
688: if (tp->tm_wday >= 1 && tp->tm_wday <= 5)
689: dayok = 1;
690: } else
691: for (i = 0; days[i]; i++)
692: if (PREFIX(days[i], s))
693: if (tp->tm_wday == i)
694: dayok = 1;
695: }
696:
697: if (dayok) {
698: int t__low, t__high;
699:
700: while (isalpha(*s)) /* flush remaining day stuff */
701: s++;
702:
703: if ((sscanf(s, "%d-%d", &t__low, &t__high) < 2)
704: || (t__low == t__high))
705: return(1);
706:
707: /* 0000 crossover? */
708: if (t__low < t__high) {
709: if (t__low <= t__now && t__now <= t__high)
710: return(1);
711: } else if (t__low <= t__now || t__now <= t__high)
712: return(1);
713:
714: /* aim at next time slot */
715: if ((s = strchr(s, ',')) == NULL)
716: break;
717: }
718: s++;
719: }
720: return(0);
721: }
722:
723: /***
724: * char *
725: * fdig(cp) find first digit in string
726: *
727: * return - pointer to first digit in string or end of string
728: */
729:
730: char *
731: fdig(cp)
732: char *cp;
733: {
734: char *c;
735:
736: for (c = cp; *c; c++)
737: if (*c >= '0' && *c <= '9')
738: break;
739: return(c);
740: }
741:
742:
743: #ifdef FASTTIMER
744: /* Sleep in increments of 60ths of second. */
745: nap (time)
746: register int time;
747: {
748: static int fd;
749:
750: if (fd == 0)
751: fd = open (FASTTIMER, 0);
752:
753: read (fd, 0, time);
754: }
755:
756: #endif FASTTIMER
757:
758: #ifdef BSD4_2
759:
760: /* nap(n) -- sleep for 'n' ticks of 1/60th sec each. */
761: /* This version, by Mark Horton, uses the select system call */
762:
763:
764: nap(n)
765: unsigned n;
766: {
767: struct timeval tv;
768: int rc;
769:
770: if (n==0)
771: return;
772: tv.tv_sec = n/60;
773: tv.tv_usec = ((n%60)*1000000L)/60;
774: rc = select(32, 0, 0, 0, &tv);
775: }
776:
777: #endif
778:
779: #ifdef NONAP
780:
781: /* nap(n) where n is ticks
782: *
783: * loop using n/HZ part of a second
784: * if n represents more than 1 second, then
785: * use sleep(time) where time is the equivalent
786: * seconds rounded off to full seconds
787: * NOTE - this is a rough approximation and chews up
788: * processor resource!
789: */
790:
791: nap(n)
792: unsigned n;
793: {
794: struct tms tbuf;
795: long endtime;
796: int i;
797:
798: if (n > HZ) {
799: /* > second, use sleep, rounding time */
800: sleep( (int) (((n)+HZ/2)/HZ) );
801: return;
802: }
803:
804: /* use timing loop for < 1 second */
805: endtime = times(&tbuf) + 3*n/4; /* use 3/4 because of scheduler! */
806: while (times(&tbuf) < endtime) {
807: for (i=0; i<1000; i++, i*i)
808: ;
809: }
810: return;
811: }
812:
813:
814: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.