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