![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to condevs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / uucp|
Return to condevs.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / uucp |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)condevs.c 5.6 (Berkeley) 8/12/83";
3: #endif
4:
5: /*
6: * Here are various dialers to establish the machine-machine connection.
7: * conn.c/condevs.c was glued together by Mike Mitchell.
8: * The dialers were supplied by many people, to whom we are grateful.
9: *
10: * ---------------------------------------------------------------------
11: * NOTE:
12: * There is a bug that occurs at least on PDP11s due to a limitation of
13: * setjmp/longjmp. If the routine that does a setjmp is interrupted
14: * and longjmp-ed to, it loses its register variables (on a pdp11).
15: * What works is if the routine that does the setjmp
16: * calls a routine and it is the *subroutine* that is interrupted.
17: *
18: * Anyway, in conclusion, condevs.c is plagued with register variables
19: * that are used inside
20: * if (setjmp(...)) {
21: * ....
22: * }
23: *
24: * THE FIX: In dnopn(), for example, delete the 'register' Devices *dev.
25: * (That was causing a core dump; deleting register fixed it.)
26: * Also for dnopn delete 'register' int dnf... .
27: * In pkopn, delete 'register' flds... .
28: * There may be others, especially mcm's version of hysopen.
29: * You could just delete all references to register, that is safest.
30: * This problem might not occur on 4.1bsd, I am not sure.
31: * Tom Truscott
32: */
33: #include <sys/types.h>
34: #include <errno.h>
35: #include <setjmp.h>
36: #include <signal.h>
37: #include <sgtty.h>
38: #include "uucp.h"
39:
40: extern char devSel[]; /* name to pass to delock() in close */
41: extern int errno, next_fd;
42: extern jmp_buf Sjbuf;
43: extern int alarmtr();
44: int nulldev(), nodev(), Acuopn(), diropn(), dircls();
45:
46: #ifdef DATAKIT
47: int dkopn();
48: #endif
49: #ifdef DN11
50: int dnopn(), dncls();
51: #endif
52: #ifdef HAYES
53: int hysopn(), hyscls();
54: #endif
55: #ifdef HAYESQ
56: int hysqopn(), hysqcls(); /* a version of hayes that doesn't use ret codes */
57: #endif
58: #ifdef ANCHOR
59: int ancopn(), anccls();
60: #endif
61: #ifdef DF02
62: int df2opn(), df2cls();
63: #endif
64: #ifdef PNET
65: int pnetopn();
66: #endif
67: #ifdef VENTEL
68: int ventopn(), ventcls();
69: #endif
70: #ifdef UNET
71: #include <UNET/unetio.h>
72: #include <UNET/tcp.h>
73: int unetopn(), unetcls();
74: #endif UNET
75: #ifdef VADIC
76: int vadopn(), vadcls();
77: #endif VADIC
78: #ifdef RVMACS
79: int rvmacsopn(), rvmacscls();
80: #endif
81: #ifdef MICOM
82: int micopn(), miccls();
83: #endif MICOM
84:
85: struct condev condevs[] = {
86: { "DIR", "direct", diropn, nulldev, dircls },
87: #ifdef DATAKIT
88: { "DK", "datakit", dkopn, nulldev, nulldev },
89: #endif
90: #ifdef PNET
91: { "PNET", "pnet", pnetopn, nulldev, nulldev },
92: #endif
93: #ifdef UNET
94: { "UNET", "UNET", unetopn, nulldev, unetcls },
95: #endif UNET
96: #ifdef MICOM
97: { "MICOM", "micom", micopn, nulldev, miccls },
98: #endif MICOM
99: #ifdef DN11
100: { "ACU", "dn11", Acuopn, dnopn, dncls },
101: #endif
102: #ifdef HAYES
103: { "ACU", "hayes", Acuopn, hysopn, hyscls },
104: #endif HAYES
105: #ifdef HAYESQ /* a version of hayes that doesn't use result codes */
106: { "ACU", "hayesq", Acuopn, hysqopn, hysqcls },
107: #endif HATESQ
108: #ifdef ANCHOR
109: { "ACU", "anchor", Acuopn, ancopn, anccls },
110: #endif ANCHOR
111: #ifdef DF02
112: { "ACU", "DF02", Acuopn, df2opn, df2cls },
113: #endif
114: #ifdef VENTEL
115: { "ACU", "ventel", Acuopn, ventopn, ventcls },
116: #endif VENTEL
117: #ifdef VADIC
118: { "ACU", "vadic", Acuopn, vadopn, vadcls },
119: #endif VADIC
120: #ifdef RVMACS
121: { "ACU", "rvmacs", Acuopn, rvmacsopn, rvmacscls },
122: #endif RVMACS
123:
124: /* Insert new entries before this line */
125: { NULL, NULL, NULL, NULL, NULL } };
126:
127: /***
128: * nulldev a null device (returns CF_DIAL)
129: */
130: int nulldev()
131: {
132: return(CF_DIAL);
133: }
134:
135: /***
136: * nodev a null device (returns CF_NODEV)
137: */
138: int nodev()
139: {
140: return(CF_NODEV);
141: }
142:
143:
144: /*
145: * The first things in this file are the generic devices.
146: * Generic devices look through L-devices and call the CU_open routines for
147: * appropriate devices. Some things, like the Unet interface, or direct
148: * connect, do not use the CU_open entry. ACUs must search to find the'
149: * right routine to call.
150: */
151:
152: /***
153: * diropn(flds) connect to hardware line
154: * char *flds[];
155: *
156: * return codes:
157: * >0 - file number - ok
158: * FAIL - failed
159: */
160:
161: diropn(flds)
162: register char *flds[];
163: {
164: register int dcr, status;
165: struct Devices dev;
166: char dcname[20];
167: FILE *dfp;
168: dfp = fopen(DEVFILE, "r");
169: ASSERT(dfp != NULL, "CAN'T OPEN", DEVFILE, 0);
170: while ((status = rddev(dfp, &dev)) != FAIL) {
171: if (strcmp(flds[F_CLASS], dev.D_class) != SAME)
172: continue;
173: if (strcmp(flds[F_PHONE], dev.D_line) != SAME)
174: continue;
175: if (mlock(dev.D_line) != FAIL)
176: break;
177: }
178: fclose(dfp);
179: if (status == FAIL) {
180: logent("DEVICE", "NO");
181: return(CF_NODEV);
182: }
183:
184: sprintf(dcname, "/dev/%s", dev.D_line);
185: if (setjmp(Sjbuf)) {
186: delock(dev.D_line);
187: return(FAIL);
188: }
189: signal(SIGALRM, alarmtr);
190: alarm(10);
191: getnextfd();
192: errno = 0;
193: dcr = open(dcname, 2); /* read/write */
194: next_fd = -1;
195: if (dcr < 0 && errno == EACCES)
196: logent(dcname, "CAN'T OPEN");
197: alarm(0);
198: if (dcr < 0) {
199: delock(dev.D_line);
200: return(FAIL);
201: }
202: fflush(stdout);
203: fixline(dcr, dev.D_speed);
204: strcpy(devSel, dev.D_line); /* for latter unlock */
205: CU_end = dircls;
206: return(dcr);
207: }
208:
209: dircls(fd)
210: register int fd;
211: {
212: if (fd > 0) {
213: close(fd);
214: delock(devSel);
215: }
216: }
217:
218: #ifdef DATAKIT
219:
220: #include <dk.h>
221: #define DKTRIES 2
222:
223: /***
224: * dkopn(flds) make datakit connection
225: *
226: * return codes:
227: * >0 - file number - ok
228: * FAIL - failed
229: */
230:
231: dkopn(flds)
232: char *flds[];
233: {
234: int dkphone;
235: register char *cp;
236: register ret, i;
237:
238: if (setjmp(Sjbuf))
239: return(FAIL);
240:
241: signal(SIGALRM, alarmtr);
242: dkphone = 0;
243: cp = flds[F_PHONE];
244: while(*cp)
245: dkphone = 10 * dkphone + (*cp++ - '0');
246: DEBUG(4, "dkphone (%d) ", dkphone);
247: for (i = 0; i < DKTRIES; i++) {
248: getnextfd();
249: ret = dkdial(D_SH, dkphone, 0);
250: next_fd = -1;
251: DEBUG(4, "dkdial (%d)\n", ret);
252: if (ret > -1)
253: break;
254: }
255: return(ret);
256: }
257: #endif
258:
259: #ifdef PNET
260: /***
261: * pnetopn(flds)
262: *
263: * call remote machine via Purdue network
264: * use dial string as host name, speed as socket number
265: * Author: Steve Bellovin
266: */
267:
268: pnetopn(flds)
269: char *flds[];
270: {
271: int fd;
272: int socket;
273: register char *cp;
274:
275: fd = pnetfile();
276: DEBUG(4, "pnet fd - %d\n", fd);
277: if (fd < 0) {
278: logent("AVAILABLE DEVICE", "NO");
279: return(CF_NODEV);
280: }
281: socket = 0;
282: for (cp = flds[F_CLASS]; *cp; cp++)
283: socket = 10*socket + (*cp - '0');
284: DEBUG(4, "socket - %d\n", socket);
285: if (setjmp(Sjbuf)) {
286: DEBUG(4, "pnet timeout - %s\n", flds[F_PHONE]);
287: return(FAIL);
288: }
289: signal(SIGALRM, alarmtr);
290: DEBUG(4, "host - %s\n", flds[F_PHONE]);
291: alarm(15);
292: if (pnetscon(fd, flds[F_PHONE], socket) < 0) {
293: DEBUG(4, "pnet connect failed - %s\n", flds[F_PHONE]);
294: return(FAIL);
295: }
296: alarm(0);
297: return(fd);
298: }
299: #endif PNET
300:
301: #ifdef UNET
302: /***
303: * unetopn -- make UNET (tcp-ip) connection
304: *
305: * return codes:
306: * >0 - file number - ok
307: * FAIL - failed
308: */
309:
310: /* Default port of uucico server */
311: #define DFLTPORT 33
312:
313: unetopn(flds)
314: register char *flds[];
315: {
316: register int ret, port;
317: int unetcls();
318:
319: port = atoi(flds[F_PHONE]);
320: if (port <= 0 || port > 255)
321: port = DFLTPORT;
322: DEBUG(4, "unetopn host %s, ", flds[F_NAME]);
323: DEBUG(4, "port %d\n", port);
324: if (setjmp(Sjbuf)) {
325: logent("tcpopen", "TIMEOUT");
326: endhnent(); /* see below */
327: return(CF_DIAL);
328: }
329: signal(SIGALRM, alarmtr);
330: alarm(30);
331: ret = tcpopen(flds[F_NAME], port, 0, TO_ACTIVE, "rw");
332: alarm(0);
333: endhnent(); /* wave magic wand at 3com and incant "eat it, bruce" */
334: if (ret < 0) {
335: DEBUG(5, "tcpopen failed: errno %d\n", errno);
336: logent("tcpopen", "FAILED");
337: return(CF_DIAL);
338: }
339: CU_end = unetcls;
340: return(ret);
341: }
342:
343: /*
344: * unetcls -- close UNET connection.
345: */
346: unetcls(fd)
347: register int fd;
348: {
349: DEBUG(4, "UNET CLOSE called\n", 0);
350: if (fd > 0) {
351: /* disable this until a timeout is put in
352: if (ioctl(fd, UIOCCLOSE, STBNULL))
353: logent("UNET CLOSE", "FAILED");
354: */
355: close(fd);
356: DEBUG(4, "closed fd %d\n", fd);
357: }
358: }
359: #endif UNET
360:
361: #ifdef MICOM
362:
363: /*
364: * micopn: establish connection through a micom.
365: * Returns descriptor open to tty for reading and writing.
366: * Negative values (-1...-7) denote errors in connmsg.
367: * Be sure to disconnect tty when done, via HUPCL or stty 0.
368: */
369: micopn(flds)
370: register char *flds[];
371: {
372: extern errno;
373: char *rindex(), *fdig(), dcname[20];
374: int dh, ok = 0, speed;
375: register struct condev *cd;
376: register FILE *dfp;
377: struct Devices dev;
378:
379: dfp = fopen(DEVFILE, "r");
380: ASSERT(dfp != NULL, "Can't open", DEVFILE, 0);
381:
382: signal(SIGALRM, alarmtr);
383: dh = -1;
384: for(cd = condevs; ((cd->CU_meth != NULL)&&(dh < 0)); cd++) {
385: if (snccmp(flds[F_LINE], cd->CU_meth) == SAME) {
386: fseek(dfp, (off_t)0, 0);
387: while(rddev(dfp, &dev) != FAIL) {
388: if (strcmp(flds[F_CLASS], dev.D_class) != SAME)
389: continue;
390: if (snccmp(flds[F_LINE], dev.D_type) != SAME)
391: continue;
392: if (mlock(dev.D_line) == FAIL)
393: continue;
394:
395: sprintf(dcname, "/dev/%s", dev.D_line);
396: getnextfd();
397: alarm(10);
398: if (setjmp(Sjbuf)) {
399: delock(dev.D_line);
400: logent(dev.D_line,"micom open TIMEOUT");
401: dh = -1;
402: break;
403: }
404: dh = open(dcname, 2);
405: alarm(0);
406: next_fd = -1;
407: if (dh > 0) {
408: break;
409: }
410: devSel[0] = '\0';
411: delock(dev.D_line);
412: }
413: }
414: }
415: fclose(dfp);
416: if (dh < 0)
417: return(CF_NODEV);
418:
419: speed = atoi(fdig(flds[F_CLASS]));
420: fixline(dh, speed);
421: sleep(1);
422:
423: /* negotiate with micom */
424: if (speed != 4800) /* damn their eyes! */
425: write(dh, "\r", 1);
426: else
427: write(dh, " ", 1);
428:
429: DEBUG(4, "wanted %s ", "NAME");
430: ok = expect("NAME", dh);
431: DEBUG(4, "got %s\n", ok ? "?" : "that");
432: if (ok == 0) {
433: write(dh, flds[F_PHONE], strlen(flds[F_PHONE]));
434: sleep(1);
435: write(dh, "\r", 1);
436: DEBUG(4, "wanted %s ", "GO");
437: ok = expect("GO", dh);
438: DEBUG(4, "got %s\n", ok ? "?" : "that");
439: }
440:
441: if (ok != 0) {
442: if (dh > 2)
443: close(dh);
444: DEBUG(4, "micom failed\n", "");
445: delock(dev.D_line);
446: return(CF_DIAL);
447: } else
448: DEBUG(4, "micom ok\n", "");
449:
450: CU_end = cd->CU_clos;
451: strcat(devSel, dev.D_line); /* for later unlock */
452: return(dh);
453:
454: }
455:
456: miccls(fd)
457: register int fd;
458: {
459:
460: if (fd > 0) {
461: close(fd);
462: delock(devSel);
463: }
464: }
465: #endif MICOM
466:
467: /***
468: * Acuopn - open an ACU and dial the number. The condevs table
469: * will be searched until a dialing unit is found that is
470: * free.
471: *
472: * return codes: >0 - file number - o.k.
473: * FAIL - failed
474: */
475:
476: char devSel[20]; /* used for later unlock() */
477:
478: Acuopn(flds)
479: register char *flds[];
480: {
481: char phone[MAXPH+1];
482: register struct condev *cd;
483: register int fd;
484: register FILE *dfp;
485: struct Devices dev;
486:
487: exphone(flds[F_PHONE], phone);
488: devSel[0] = '\0';
489: DEBUG(4, "Dialing %s\n", phone);
490: dfp = fopen(DEVFILE, "r");
491: ASSERT(dfp != NULL, "Can't open", DEVFILE, 0);
492:
493: for(cd = condevs; cd->CU_meth != NULL; cd++) {
494: if (snccmp(flds[F_LINE], cd->CU_meth) == SAME) {
495: fseek(dfp, (off_t)0, 0);
496: while(rddev(dfp, &dev) != FAIL) {
497: if (strcmp(flds[F_CLASS], dev.D_class) != SAME)
498: continue;
499: if (snccmp(flds[F_LINE], dev.D_type) != SAME)
500: continue;
501: if (dev.D_brand[0] == '\0')
502: logent("Acuopn","No 'brand' name on ACU");
503: else if (snccmp(dev.D_brand, cd->CU_brand) != SAME)
504: continue;
505: if (mlock(dev.D_line) == FAIL)
506: continue;
507:
508: DEBUG(4, "Using %s\n", cd->CU_brand);
509: fd = (*(cd->CU_open))(phone, flds, &dev);
510: if (fd > 0) {
511: CU_end = cd->CU_clos; /* point CU_end at close func */
512: fclose(dfp);
513: strcpy(devSel, dev.D_line); /* save for later unlock() */
514: return(fd);
515: }
516: delock(dev.D_line);
517: }
518: }
519: }
520: fclose(dfp);
521: return(FAIL);
522: }
523:
524: #ifdef DN11
525:
526: /***
527: * dnopn(ph, flds, dev) dial remote machine
528: * char *ph;
529: * char *flds[];
530: * struct Devices *dev;
531: *
532: * return codes:
533: * file descriptor - succeeded
534: * FAIL - failed
535: */
536:
537: dnopn(ph, flds, dev)
538: char *ph;
539: char *flds[];
540: struct Devices *dev;
541: {
542: char dcname[20], dnname[20], phone[MAXPH+2], c = 0;
543: #ifdef SYSIII
544: struct termio ttbuf;
545: #endif
546: int dnf, dcf;
547: int nw, lt, pid, status;
548: unsigned timelim;
549:
550: sprintf(dnname, "/dev/%s", dev->D_calldev);
551: errno = 0;
552:
553: if (setjmp(Sjbuf)) {
554: logent(dnname, "CAN'T OPEN");
555: DEBUG(4, "%s Open timed out\n", dnname);
556: return(CF_NODEV);
557: }
558: signal(SIGALRM, alarmtr);
559: getnextfd();
560: alarm(10);
561: dnf = open(dnname, 1);
562: alarm(0);
563: next_fd = -1;
564: if (dnf < 0 && errno == EACCES) {
565: logent(dnname, "CAN'T OPEN");
566: logent("DEVICE", "NO");
567: return(CF_NODEV);
568: }
569: /* rti!trt: avoid passing acu file descriptor to children */
570: fioclex(dnf);
571:
572: sprintf(dcname, "/dev/%s", dev->D_line);
573: sprintf(phone, "%s%s", ph, ACULAST);
574: DEBUG(4, "dc - %s, ", dcname);
575: DEBUG(4, "acu - %s\n", dnname);
576: pid = 0;
577: if (setjmp(Sjbuf)) {
578: logent("DIALUP DN write", "TIMEOUT");
579: if (pid)
580: kill(pid, 9);
581: delock(dev->D_line);
582: if (dnf)
583: close(dnf);
584: return(FAIL);
585: }
586: signal(SIGALRM, alarmtr);
587: timelim = 5 * strlen(phone);
588: alarm(timelim < 30 ? 30 : timelim);
589: if ((pid = fork()) == 0) {
590: sleep(2);
591: fclose(stdin);
592: fclose(stdout);
593: #ifdef TIOCFLUSH
594: ioctl(dnf, TIOCFLUSH, STBNULL);
595: #endif
596: nw = write(dnf, phone, lt = strlen(phone));
597: if (nw != lt) {
598: logent("DIALUP ACU write", "FAILED");
599: exit(1);
600: }
601: DEBUG(4, "ACU write ok%s\n", "");
602: exit(0);
603: }
604: /* open line - will return on carrier */
605: /* RT needs a sleep here because it returns immediately from open */
606:
607: #if RT
608: sleep(15);
609: #endif
610:
611: getnextfd();
612: errno = 0;
613: dcf = open(dcname, 2);
614: next_fd = -1;
615: if (dcf < 0 && errno == EACCES)
616: logent(dcname, "CAN'T OPEN");
617: DEBUG(4, "dcf is %d\n", dcf);
618: if (dcf < 0) {
619: logent("DIALUP LINE open", "FAILED");
620: alarm(0);
621: kill(pid, 9);
622: close(dnf);
623: delock(dev->D_line);
624: return(FAIL);
625: }
626: /* brl-bmd.351 (Doug Kingston) says the next ioctl is unneeded . */
627: /* ioctl(dcf, TIOCHPCL, STBNULL);*/
628: while ((nw = wait(<)) != pid && nw != -1)
629: ;
630: #ifdef SYSIII
631: ioctl(dcf, TCGETA, &ttbuf);
632: if(!(ttbuf.c_cflag & HUPCL)) {
633: ttbuf.c_cflag |= HUPCL;
634: ioctl(dcf, TCSETA, &ttbuf);
635: }
636: #endif
637: alarm(0);
638: fflush(stdout);
639: fixline(dcf, dev->D_speed);
640: DEBUG(4, "Fork Stat %o\n", lt);
641: if (lt != 0) {
642: close(dcf);
643: if (dnf)
644: close(dnf);
645: delock(dev->D_line);
646: return(FAIL);
647: }
648: return(dcf);
649: }
650:
651: /***
652: * dncls() close dn type call unit
653: *
654: * return codes: None
655: */
656: dncls(fd)
657: register int fd;
658: {
659: if (fd > 0) {
660: close(fd);
661: sleep(5);
662: delock(devSel);
663: }
664: }
665: #endif DN11
666:
667: #ifdef DF02
668: /***
669: * df2opn(ph, flds, dev) dial remote machine
670: * char *ph;
671: * char *flds[];
672: * struct Devices *dev;
673: *
674: * return codes:
675: * file descriptor - succeeded
676: * FAIL - failed
677: *
678: * Modified 9/28/81 by Bill Shannon (DEC)
679: * Changed to use DEC DF02 or DF03 ACU
680: */
681:
682:
683: df2opn(ph, flds, dev)
684: char *ph;
685: char *flds[];
686: struct Devices *dev;
687: {
688: char dcname[20], dnname[20], phone[MAXPH+2], c = 0;
689: #ifdef SYSIII
690: struct termio ttbuf;
691: #endif
692: int dcf, dnf;
693: int nw, lt, pid, st, status;
694: unsigned timelim;
695:
696: sprintf(dnname, "/dev/%s", dev->D_calldev);
697: if (setjmp(Sjbuf)) {
698: logent(dnname, "CAN'T OPEN");
699: DEBUG(4, "%s Open timed out\n", dnname);
700: return(CF_NODEV);
701: }
702: signal(SIGALRM, alarmtr);
703: getnextfd();
704: errno = 0;
705: alarm(10);
706: dnf = open(dnname, 2 );
707: alarm(0);
708: next_fd = -1;
709: if (dnf < 0 && errno == EACCES) {
710: logent(dnname, "CAN'T OPEN");
711: delock(dev->D_line);
712: logent("DEVICE", "NO");
713: return(CF_NODEV);
714: }
715: /* rti!trt: avoid passing acu file descriptor to children */
716: fioclex(dnf);
717:
718: sprintf(dcname, "/dev/%s", dev->D_line);
719: fixline(dnf, dev->D_speed);
720: sprintf(phone, "\02%s", ph);
721: DEBUG(4, "dc - %s, ", dcname);
722: DEBUG(4, "acu - %s\n", dnname);
723: pid = 0;
724: if (setjmp(Sjbuf)) {
725: logent("DIALUP DN write", "TIMEOUT");
726: if (pid)
727: kill(pid, 9);
728: delock(dev->D_line);
729: if (dnf)
730: close(dnf);
731: return(FAIL);
732: }
733: signal(SIGALRM, alarmtr);
734: timelim = 5 * strlen(phone);
735: alarm(timelim < 30 ? 30 : timelim);
736: if ((pid = fork()) == 0) {
737: sleep(2);
738: fclose(stdin);
739: fclose(stdout);
740: #ifdef TIOCFLUSH
741: ioctl(dnf, TIOCFLUSH, STBNULL);
742: #endif
743: write(dnf, "\01", 1);
744: sleep(1);
745: nw = write(dnf, phone, lt = strlen(phone));
746: if (nw != lt) {
747: logent("DIALUP ACU write", "FAILED");
748: exit(1);
749: }
750: DEBUG(4, "ACU write ok%s\n", "");
751: exit(0);
752: }
753: /* open line - will return on carrier */
754: /* RT needs a sleep here because it returns immediately from open */
755:
756: #if RT
757: sleep(15);
758: #endif
759:
760: if (read(dnf, &c, 1) != 1 || c != 'A')
761: dcf = -1;
762: else
763: dcf = 0;
764: DEBUG(4, "dcf is %d\n", dcf);
765: if (dcf < 0) {
766: logent("DIALUP LINE open", "FAILED");
767: alarm(0);
768: kill(pid, 9);
769: close(dnf);
770: delock(dev->D_line);
771: return(FAIL);
772: }
773: dcf = dnf;
774: dnf = 0;
775: /* brl-bmd.351 (Doug Kingston) says the next ioctl is unneeded . */
776: /* ioctl(dcf, TIOCHPCL, STBNULL);*/
777: while ((nw = wait(<)) != pid && nw != -1)
778: ;
779: #ifdef SYSIII
780: ioctl(dcf, TCGETA, &ttbuf);
781: if(!(ttbuf.c_cflag & HUPCL)) {
782: ttbuf.c_cflag |= HUPCL;
783: ioctl(dcf, TCSETA, &ttbuf);
784: }
785: #endif
786: alarm(0);
787: fflush(stdout);
788: fixline(dcf, dev->D_speed);
789: DEBUG(4, "Fork Stat %o\n", lt);
790: if (lt != 0) {
791: close(dcf);
792: if (dnf)
793: close(dnf);
794: delock(dev->D_line);
795: return(FAIL);
796: }
797: return(dcf);
798: }
799:
800: /*
801: * df2cls() close the DF02/DF03 call unit
802: *
803: * return codes: none
804: */
805:
806: df2cls(fd)
807: register int fd;
808: {
809: if (fd > 0) {
810: close(fd);
811: sleep(5);
812: delock(devSel);
813: }
814: }
815: #endif DF02
816:
817: #ifdef HAYES
818: /***
819: * hysopn(telno, flds, dev) connect to hayes smartmodem
820: * char *flds[], *dev[];
821: *
822: * return codes:
823: * >0 - file number - ok
824: * CF_DIAL,CF_DEVICE - failed
825: */
826: /*
827: * Define HAYSTONE if you have touch tone dialing.
828: */
829: /*#define HAYSTONE */
830:
831: hysopn(telno, flds, dev)
832: char *telno;
833: char *flds[];
834: struct Devices *dev;
835: {
836: int dh = -1;
837: extern errno;
838: char dcname[20];
839:
840: sprintf(dcname, "/dev/%s", dev->D_line);
841: DEBUG(4, "dc - %s\n", dcname);
842: if (setjmp(Sjbuf)) {
843: DEBUG(1, "timeout hayes open %s\n", dcname);
844: logent("hayes open", "TIMEOUT");
845: if (dh >= 0)
846: close(dh);
847: delock(dev->D_line);
848: return(CF_DIAL);
849: }
850: signal(SIGALRM, alarmtr);
851: getnextfd();
852: alarm(10);
853: dh = open(dcname, 2); /* read/write */
854: alarm(0);
855:
856: /* modem is open */
857: next_fd = -1;
858: if (dh >= 0) {
859: fixline(dh, dev->D_speed);
860: #ifdef HAYSTONE
861: sendthem("\rATDT\\c", dh);
862: #else
863: sendthem("\rATDP\\c", dh);
864: #endif
865: sendthem(telno, dh);
866:
867: if (expect("CONNECT", dh) != 0) {
868: logent("HSM no carrier", "FAILED");
869: strcpy(devSel, dev->D_line);
870: hyscls(dh);
871: return(CF_DIAL);
872: }
873:
874: }
875: if (dh < 0) {
876: DEBUG(4, "hayes failed\n", "");
877: delock(dev->D_line);
878: } else
879: DEBUG(4, "hayes ok\n", "");
880: return(dh);
881: }
882:
883: hyscls(fd)
884: int fd;
885: {
886: char dcname[20];
887: struct sgttyb hup, sav;
888:
889: if (fd > 0) {
890: sprintf(dcname, "/dev/%s", devSel);
891: DEBUG(4, "Hanging up fd = %d\n", fd);
892: /*
893: * code to drop DTR -- change to 0 baud then back to default.
894: */
895: gtty(fd, &hup);
896: gtty(fd, &sav);
897: hup.sg_ispeed = B0;
898: hup.sg_ospeed = B0;
899: stty(fd, &hup);
900: sleep(2);
901: stty(fd, &sav);
902: /*
903: * now raise DTR -- close the device & open it again.
904: */
905: sleep(2);
906: close(fd);
907: sleep(2);
908: fd = open(dcname, 2);
909: /*
910: * Since we have a getty sleeping on this line, when it wakes up it sends
911: * all kinds of garbage to the modem. Unfortunatly, the modem likes to
912: * execute the previous command when it sees the garbage. The previous
913: * command was to dial the phone, so let's make the last command reset
914: * the modem.
915: */
916: sleep(1);
917: sendthem("+++\\d", fd);
918: sleep(1);
919: sendthem("\rATZ\\d", fd);
920: close(fd);
921: delock(devSel);
922: }
923: }
924:
925: #endif HAYES
926:
927: #ifdef ANCHOR
928: /***
929: * ancopn(telno, flds, dev) connect to anchor smartmodem
930: * char *flds[], *dev[];
931: *
932: * return codes:
933: * >0 - file number - ok
934: * CF_DIAL,CF_DEVICE - failed
935: */
936: /*
937: * Define HAYSTONE if you have touch tone dialing.
938: */
939: /*#define HAYSTONE */
940:
941: ancopn(telno, flds, dev)
942: char *telno;
943: char *flds[];
944: struct Devices *dev;
945: {
946: int dh = -1;
947: extern errno;
948: char dcname[20];
949:
950: sprintf(dcname, "/dev/%s", dev->D_line);
951: DEBUG(4, "dc - %s\n", dcname);
952: if (setjmp(Sjbuf)) {
953: DEBUG(1, "timeout anchor open %s\n", dcname);
954: logent("anchor open", "TIMEOUT");
955: if (dh >= 0)
956: close(dh);
957: delock(dev->D_line);
958: return(CF_DIAL);
959: }
960: signal(SIGALRM, alarmtr);
961: getnextfd();
962: alarm(10);
963: dh = open(dcname, 2); /* read/write */
964: alarm(0);
965:
966: /* modem is open */
967: next_fd = -1;
968: if (dh >= 0) {
969: fixline(dh, dev->D_speed);
970: #ifdef HAYSTONE
971: sendthem("\rATDT\\c", dh);
972: #else
973: sendthem("\rATDP\\c", dh);
974: #endif
975: sendthem(telno, dh);
976:
977: if (ancexpect("CONNECT", dh) != 0) {
978: logent("HSM no carrier", "FAILED");
979: strcpy(devSel, dev->D_line);
980: anccls(dh);
981: return(CF_DIAL);
982: }
983:
984: }
985: if (dh < 0) {
986: DEBUG(4, "anchor failed\n", "");
987: delock(dev->D_line);
988: } else
989: DEBUG(4, "anchor ok\n", "");
990: return(dh);
991: }
992:
993: /*----------------------------------------------------
994: steal the drop-modem code from "tip"
995: -----------------------------------------------------*/
996: anccls(fd)
997: int fd;
998: {
999: char dcname[20];
1000: struct sgttyb hup, sav;
1001:
1002: if (fd > 0) {
1003: register int retry;
1004:
1005: sprintf(dcname, "/dev/%s", devSel);
1006: DEBUG(4, "Hanging up fd = %d\n", fd);
1007:
1008: sleep(2);
1009: retry = 3;
1010: do {
1011: ancwrite("+++",0,fd);
1012: sleep(2);
1013: } while (!ancexpect("OK", fd) && --retry >0);
1014: ancwrite("AT\r",1,fd);
1015: expect("OK", fd);
1016: ancwrite("ATZ\r",1,fd);
1017:
1018: close(fd);
1019: delock(devSel);
1020: }
1021: }
1022:
1023: /*-------------------------------------------------------
1024: this function stolen from "tip"
1025: ------------------------------------------------------*/
1026: static
1027: ancwrite(cp, delay, fd)
1028: register char *cp;
1029: int delay;
1030: int fd;
1031: {
1032:
1033: for (; *cp; sleep(delay), cp++) {
1034: write(fd, cp, 1);
1035: #ifdef DEBUG
1036: write(1, cp, 1);
1037: if (*cp=='\r')
1038: write(1,"\n",1);
1039: #endif
1040: }
1041: }
1042:
1043: /*--------------------------------------------------------
1044: this function stolen from "tip"
1045: -------------------------------------------------------*/
1046: static
1047: ancexpect(cp,fd )
1048: register char *cp;
1049: int fd;
1050: /* if cp == (char *)0, read any junks coming from the modem */
1051: {
1052: char buf[300];
1053: register char *rp = buf;
1054: int alarmtr(), timeout = 30, online = 0;
1055:
1056: if (strcmp(cp, "\"\"") == 0)
1057: return (1);
1058: *rp = 0;
1059: /*
1060: * If we are waiting for the AnchorAutomation to complete
1061: * dialing and get a connection, allow more time.
1062: *
1063: * If we are collecting junks from AnchorAutomation, allow more time.
1064: */
1065: online = strcmp(cp, "CONNECT") == 0;
1066: timeout = 10;
1067:
1068: signal(SIGALRM, alarmtr);
1069: if (setjmp(Sjbuf)) {
1070: if (cp)
1071: return (0);
1072: else
1073: return (1);
1074: }
1075: alarm(timeout);
1076:
1077: while (notin(cp, buf) && rp < buf + sizeof (buf) - 1) {
1078: if (online && notin("CARRIER", buf) == 0)
1079: return (0);
1080: if (read(fd, rp, 1) < 0) {
1081: printf("tip: cannot read from modem");fflush(stdout);
1082: alarm(0);
1083: return (0);
1084: }
1085: *rp &= 0177;
1086: #ifdef DEBUG
1087: if (*rp < ' ' || *rp==0177) {
1088: printf("^%c", *rp^0100);
1089: } else
1090: printf("%c", *rp);
1091: fflush(stdout);
1092: #endif DEBUG
1093: if (*rp)
1094: rp++;
1095: *rp = '\0';
1096: }
1097: alarm(0);
1098: return (1);
1099: }
1100:
1101: /*---------------------------------------------------------------
1102: this function stolen from "tip"
1103: ---------------------------------------------------------------*/
1104: static
1105: notin(sh, lg)
1106: char *sh, *lg;
1107: {
1108:
1109: if (sh==(char *)0)
1110: return(1);
1111:
1112: for (; *lg; lg++)
1113: if (prefix(sh, lg))
1114: return (0);
1115: return (1);
1116: }
1117:
1118: /*-----------------------------------------------------------
1119: this function stolen from "tip"
1120: ------------------------------------------------------------*/
1121: static
1122: prefix(s1, s2)
1123: register char *s1, *s2;
1124: {
1125: register char c;
1126:
1127: while ((c = *s1++) == *s2++)
1128: if (c == '\0')
1129: return (1);
1130: return (c == '\0');
1131: }
1132:
1133: #endif ANCHOR
1134:
1135: #ifdef HAYESQ
1136: /*
1137: * New dialout routine to work with Hayes' SMART MODEM
1138: * 13-JUL-82, Mike Mitchell
1139: * Modified 23-MAR-83 to work with Tom Truscott's (rti!trt)
1140: * version of UUCP (ncsu!mcm)
1141: *
1142: * The modem should be set to NOT send any result codes to
1143: * the system (switch 3 up, 4 down). This end will figure out
1144: * what is wrong.
1145: *
1146: * I had lots of problems with the modem sending
1147: * result codes since I am using the same modem for both incomming and
1148: * outgoing calls. I'd occasionally miss the result code (getty would
1149: * grab it), and the connect would fail. Worse yet, the getty would
1150: * think the result code was a user name, and send garbage to it while
1151: * it was in the command state. I turned off ALL result codes, and hope
1152: * for the best. 99% of the time the modem is in the correct state.
1153: * Occassionally it doesn't connect, or the phone was busy, etc., and
1154: * uucico sits there trying to log in. It eventually times out, calling
1155: * clsacu() in the process, so it resets itself for the next attempt.
1156: */
1157:
1158: /*
1159: * Define HAYSTONE if touch-tone dialing is to be used. If it is not defined,
1160: * Pulse dialing is assumed.
1161: */
1162: /*#define HAYSTONE*/
1163:
1164: hysqopn(telno, flds, dev)
1165: char *telno, *flds[];
1166: struct Devices *dev;
1167: {
1168: char dcname[20], phone[MAXPH+10], c = 0;
1169: #ifdef SYSIII
1170: struct termio ttbuf;
1171: #endif
1172: int status, dnf;
1173: unsigned timelim;
1174:
1175: signal(SIGALRM, alarmtr);
1176: sprintf(dcname, "/dev/%s", dev->D_line);
1177:
1178: getnextfd();
1179: if (setjmp(Sjbuf)) {
1180: delock(dev->D_line);
1181: logent("DEVICE", "NO");
1182: DEBUG(4, "Open timed out %s", dcname);
1183: return(CF_NODEV);
1184: }
1185: alarm(10);
1186:
1187: if ((dnf = open(dcname, 2)) <= 0) {
1188: delock(dev->D_line);
1189: logent("DEVICE", "NO");
1190: DEBUG(4, "Can't open %s", dcname);
1191: return(CF_NODEV);
1192: }
1193:
1194: alarm(0);
1195: next_fd = -1;
1196: fixline(dnf, dev->D_speed);
1197: DEBUG(4, "Hayes port - %s, ", dcname);
1198:
1199: #ifdef HAYSTONE
1200: sprintf(phone, "\rATDT%s\r", telno);
1201: #else
1202: sprintf(phone, "\rATDP%s\r", telno);
1203: #endif
1204:
1205: write(dnf, phone, strlen(phone));
1206:
1207: /* calculate delay time for the other system to answer the phone.
1208: * Default is 15 seconds, add 2 seconds for each comma in the phone
1209: * number.
1210: */
1211: timelim = 150;
1212: while(*telno) {
1213: c = *telno++;
1214: if (c == ',')
1215: timelim += 20;
1216: else {
1217: #ifdef HAYSTONE
1218: timelim += 2; /* .2 seconds per tone */
1219: }
1220: #else
1221: if (c == '0') timelim += 10; /* .1 second per digit */
1222: else if (c > '0' && c <= '9')
1223: timelim += (c - '0');
1224: }
1225: #endif
1226: }
1227: alarm(timelim/10);
1228: if (setjmp(Sjbuf) == 0) {
1229: read(dnf, &c, 1);
1230: alarm(0);
1231: }
1232:
1233: return(dnf);
1234: }
1235:
1236: hysqcls(fd)
1237: int fd;
1238: {
1239: char dcname[20];
1240: struct sgttyb hup, sav;
1241:
1242: if (fd > 0) {
1243: sprintf(dcname, "/dev/%s", devSel);
1244: DEBUG(4, "Hanging up fd = %d\n", fd);
1245: /*
1246: * code to drop DTR -- change to 0 baud then back to default.
1247: */
1248: gtty(fd, &hup);
1249: gtty(fd, &sav);
1250: hup.sg_ispeed = B0;
1251: hup.sg_ospeed = B0;
1252: stty(fd, &hup);
1253: sleep(2);
1254: stty(fd, &sav);
1255: /*
1256: * now raise DTR -- close the device & open it again.
1257: */
1258: sleep(2);
1259: close(fd);
1260: sleep(2);
1261: fd = open(dcname, 2);
1262: /*
1263: * Since we have a getty sleeping on this line, when it wakes up it sends
1264: * all kinds of garbage to the modem. Unfortunatly, the modem likes to
1265: * execute the previous command when it sees the garbage. The previous
1266: * command was to dial the phone, so let's make the last command reset
1267: * the modem.
1268: */
1269: sleep(2);
1270: write(fd, "\rATZ\r", 5);
1271: close(fd);
1272: delock(devSel);
1273: }
1274: }
1275:
1276: #endif HAYESQ
1277:
1278: #ifdef VENTEL
1279: ventopn(telno, flds, dev)
1280: char *flds[], *telno;
1281: struct Devices *dev;
1282: {
1283: int dh;
1284: int i, ok = -1;
1285: char dcname[20];
1286:
1287: sprintf(dcname, "/dev/%s", dev->D_line);
1288: if (setjmp(Sjbuf)) {
1289: DEBUG(1, "timeout ventel open\n", "");
1290: logent("ventel open", "TIMEOUT");
1291: if (dh >= 0)
1292: close(dh);
1293: delock(dev->D_line);
1294: return(CF_NODEV);
1295: }
1296: signal(SIGALRM, alarmtr);
1297: getnextfd();
1298: alarm(10);
1299: dh = open(dcname, 2);
1300: next_fd = -1;
1301: if (dh < 0) {
1302: DEBUG(4,"%s\n", errno == 4 ? "no carrier" : "can't open modem");
1303: delock(dev->D_line);
1304: return(errno == 4 ? CF_DIAL : CF_NODEV);
1305: }
1306:
1307: /* modem is open */
1308: fixline(dh, dev->D_speed);
1309:
1310: /* translate - to % and = to & for VenTel */
1311: DEBUG(4, "calling %s -> ", telno);
1312: for (i = 0; i < strlen(telno); ++i) {
1313: switch(telno[i]) {
1314: case '-': /* delay */
1315: telno[i] = '%';
1316: break;
1317: case '=': /* await dial tone */
1318: telno[i] = '&';
1319: break;
1320: case '<':
1321: telno[i] = '%';
1322: break;
1323: }
1324: }
1325: DEBUG(4, "%s\n", telno);
1326: sleep(1);
1327: for(i = 0; i < 5; ++i) { /* make up to 5 tries */
1328: slowrite(dh, "\r\r");/* awake, thou lowly VenTel! */
1329:
1330: DEBUG(4, "wanted %s ", "$");
1331: ok = expect("$", dh);
1332: DEBUG(4, "got %s\n", ok ? "?" : "that");
1333: if (ok != 0)
1334: continue;
1335: slowrite(dh, "K"); /* "K" (enter number) command */
1336: DEBUG(4, "wanted %s ", "DIAL: ");
1337: ok = expect("DIAL: ", dh);
1338: DEBUG(4, "got %s\n", ok ? "?" : "that");
1339: if (ok == 0)
1340: break;
1341: }
1342:
1343: if (ok == 0) {
1344: slowrite(dh, telno); /* send telno, send \r */
1345: slowrite(dh, "\r");
1346: DEBUG(4, "wanted %s ", "ONLINE");
1347: ok = expect("ONLINE!", dh);
1348: DEBUG(4, "got %s\n", ok ? "?" : "that");
1349: }
1350: if (ok != 0) {
1351: if (dh > 2)
1352: close(dh);
1353: DEBUG(4, "venDial failed\n", "");
1354: return(CF_DIAL);
1355: } else
1356: DEBUG(4, "venDial ok\n", "");
1357: return(dh);
1358: }
1359:
1360:
1361: /*
1362: * uucpdelay: delay execution for numerator/denominator seconds.
1363: */
1364:
1365: #ifdef INTERVALTIMER
1366: #define uucpdelay(num,denom) intervaldelay(1000000*num/denom)
1367: #include <sys/time.h>
1368: catch alarm sig
1369: SIGALRM
1370: struct itimerval itimerval;
1371: itimerval.itimer_reload =
1372: itimerval.rtime.itimer_interval =
1373: itimerval.rtime.itimer_value =
1374: settimer(ITIMER_REAL, &itimerval);
1375: pause();
1376: alarm comes in
1377: turn off timer.
1378: #endif INTERVALTIMER
1379:
1380: #ifdef FASTTIMER
1381: #define uucpdelay(num,denom) nap(60*num/denom)
1382: /* Sleep in increments of 60ths of second. */
1383: nap (time)
1384: register int time;
1385: {
1386: static int fd;
1387:
1388: if (fd == 0)
1389: fd = open (FASTTIMER, 0);
1390:
1391: read (fd, 0, time);
1392: }
1393: #endif FASTTIMER
1394:
1395: #ifdef FTIME
1396: #define uucpdelay(num,denom) ftimedelay(1000*num/denom)
1397: #include <sys/timeb.h>
1398: ftimedelay(n)
1399: {
1400: static struct timeb loctime;
1401: ftime(&loctime);
1402: {register i = loctime.millitm;
1403: while (abs((int)(loctime.millitm - i))<n) ftime(&loctime);
1404: }
1405: }
1406: #endif FTIME
1407:
1408: #ifdef BUSYLOOP
1409: #define uucpdelay(num,denom) busyloop(CPUSPEED*num/denom)
1410: #define CPUSPEED 1000000 /* VAX 780 is 1MIPS */
1411: #define DELAY(n) { register long N = (n); while (--N > 0); }
1412: busyloop(n)
1413: {
1414: DELAY(n);
1415: }
1416: #endif BUSYLOOP
1417:
1418: slowrite(fd, str)
1419: register char *str;
1420: {
1421: DEBUG(6, "slowrite ", "");
1422: while (*str) {
1423: DEBUG(6, "%c", *str);
1424: uucpdelay(1,10); /* delay 1/10 second */
1425: write(fd, str, 1);
1426: str++;
1427: }
1428: DEBUG(6, "\n", "");
1429: }
1430:
1431:
1432: ventcls(fd)
1433: int fd;
1434: {
1435:
1436: if (fd > 0) {
1437: close(fd);
1438: sleep(5);
1439: delock(devSel);
1440: }
1441: }
1442: #endif VENTEL
1443:
1444: #ifdef VADIC
1445:
1446: /*
1447: * vadopn: establish dial-out connection through a Racal-Vadic 3450.
1448: * Returns descriptor open to tty for reading and writing.
1449: * Negative values (-1...-7) denote errors in connmsg.
1450: * Be sure to disconnect tty when done, via HUPCL or stty 0.
1451: */
1452:
1453: vadopn(telno, flds, dev)
1454: char *telno;
1455: char *flds[];
1456: struct Devices *dev;
1457: {
1458: int dh = -1;
1459: int i, ok, er = 0, delay;
1460: extern errno;
1461: char dcname[20];
1462:
1463: sprintf(dcname, "/dev/%s", dev->D_line);
1464: if (setjmp(Sjbuf)) {
1465: DEBUG(1, "timeout vadic open\n", "");
1466: logent("vadic open", "TIMEOUT");
1467: if (dh >= 0)
1468: close(dh);
1469: delock(dev->D_line);
1470: return(CF_NODEV);
1471: }
1472: signal(SIGALRM, alarmtr);
1473: getnextfd();
1474: alarm(10);
1475: dh = open(dcname, 2);
1476: alarm(0);
1477:
1478: /* modem is open */
1479: next_fd = -1;
1480: if (dh < 0) {
1481: delock(dev->D_line);
1482: return(CF_NODEV);
1483: }
1484: fixline(dh, dev->D_speed);
1485:
1486: /* translate - to K for Vadic */
1487: DEBUG(4, "calling %s -> ", telno);
1488: delay = 0;
1489: for (i = 0; i < strlen(telno); ++i) {
1490: switch(telno[i]) {
1491: case '=': /* await dial tone */
1492: case '-': /* delay */
1493: case '<':
1494: telno[i] = 'K';
1495: delay += 5;
1496: break;
1497: }
1498: }
1499: DEBUG(4, "%s\n", telno);
1500: for(i = 0; i < 5; ++i) { /* make 5 tries */
1501: /* wake up Vadic */
1502: sendthem("\005\\d", dh);
1503: DEBUG(4, "wanted %s ", "*");
1504: ok = expect("*", dh);
1505: DEBUG(4, "got %s\n", ok ? "?" : "that");
1506: if (ok != 0)
1507: continue;
1508:
1509: sendthem("D\\d", dh); /* "D" (enter number) command */
1510: DEBUG(4, "wanted %s ", "NUMBER?\\r\\n");
1511: ok = expect("NUMBER?\r\n", dh);
1512: DEBUG(4, "got %s\n", ok ? "?" : "that");
1513: if (ok != 0)
1514: continue;
1515:
1516: /* send telno, send \r */
1517: sendthem(telno, dh);
1518: ok = expect(telno, dh);
1519: if (ok == 0)
1520: ok = expect("\r\n", dh);
1521: DEBUG(4, "got %s\n", ok ? "?" : "that");
1522: if (ok != 0)
1523: continue;
1524:
1525: sendthem("", dh); /* confirm number */
1526: DEBUG(4, "wanted %s ", "DIALING: ");
1527: ok = expect("DIALING: ", dh);
1528: DEBUG(4, "got %s\n", ok ? "?" : "that");
1529: if (ok == 0)
1530: break;
1531: }
1532:
1533: if (ok == 0) {
1534: sleep(10 + delay); /* give vadic some time */
1535: DEBUG(4, "wanted ON LINE\\r\\n ", 0);
1536: ok = expect("ON LINE\r\n", dh);
1537: DEBUG(4, "got %s\n", ok ? "?" : "that");
1538: }
1539:
1540: if (ok != 0) {
1541: sendthem("I\\d", dh); /* back to idle */
1542: if (dh > 2)
1543: close(dh);
1544: DEBUG(4, "vadDial failed\n", "");
1545: delock(dev->D_line);
1546: return(CF_DIAL);
1547: }
1548: DEBUG(4, "vadic ok\n", "");
1549: return(dh);
1550: }
1551:
1552: vadcls(fd) {
1553:
1554: if (fd > 0) {
1555: close(fd);
1556: sleep(5);
1557: delock(devSel);
1558: }
1559: }
1560:
1561: #endif VADIC
1562:
1563: #ifdef RVMACS
1564: /*
1565: * Racal-Vadic 'RV820' MACS system with 831 adaptor.
1566: * A typical 300 baud L-devices entry is
1567: * ACU /dev/tty10 /dev/tty11,48 300 rvmacs
1568: * where tty10 is the communication line (D_Line),
1569: * tty11 is the dialer line (D_calldev),
1570: * the '4' is the dialer address + modem type (viz. dialer 0, Bell 103),
1571: * and the '8' is the communication port (they are 1-indexed).
1572: * BUGS:
1573: * Only tested with one dialer, one modem
1574: * uses common speed for dialer and communication line.
1575: * UNTESTED
1576: */
1577:
1578: #define STX 02 /* Access Adaptor */
1579: #define ETX 03 /* Transfer to Dialer */
1580: #define SI 017 /* Buffer Empty (end of phone number) */
1581: #define SOH 01 /* Abort */
1582:
1583: rvmacsopn(ph, flds, dev)
1584: char *ph, *flds[];
1585: struct Devices *dev;
1586: {
1587: register int va, i, child;
1588: register char *p;
1589: char c, acu[20], com[20];
1590:
1591: child = -1;
1592: if ((p = index(dev->D_calldev, ',')) == NULL) {
1593: DEBUG(2, "No dialer/modem specification\n", 0);
1594: goto failret;
1595: }
1596: *p++ = '\0';
1597: if (setjmp(Sjbuf)) {
1598: logent("rvmacsopn", "TIMEOUT");
1599: i = CF_DIAL;
1600: goto ret;
1601: }
1602: DEBUG(4, "STARTING CALL\n", 0);
1603: sprintf(acu, "/dev/%s", dev->D_calldev);
1604: getnextfd();
1605: signal(SIGALRM, alarmtr);
1606: alarm(30);
1607: if ((va = open(acu, 2)) < 0) {
1608: logent(acu, "CAN'T OPEN");
1609: i = CF_NODEV;
1610: goto ret;
1611: }
1612: fixline(va, dev->D_speed);
1613:
1614: p_chwrite(va, STX); /* access adaptor */
1615: i = *p++ - '0';
1616: if (i < 0 || i > 7) {
1617: logent(p-1, "Bad dialer address/modem type\n");
1618: goto failret;
1619: }
1620: p_chwrite(va, i); /* Send Dialer Address Digit */
1621: i = *p - '0';
1622: if (i <= 0 || i > 14) {
1623: logent(p-1, "Bad modem address\n");
1624: goto failret;
1625: }
1626: p_chwrite(va, i-1); /* Send Modem Address Digit */
1627: write(va, ph, strlen(ph)); /* Send Phone Number */
1628: p_chwrite(va, SI); /* Send Buffer Empty */
1629: p_chwrite(va, ETX); /* Initiate Call */
1630: sprintf(com, "/dev/%s", dev->D_line);
1631:
1632: /* create child to open comm line */
1633: if ((child = fork()) == 0) {
1634: signal(SIGINT, SIG_DFL);
1635: open(com, 0);
1636: sleep(5);
1637: exit(1);
1638: }
1639:
1640: if (read(va, &c, 1) != 1) {
1641: logent("ACU READ", "FAILED");
1642: goto failret;
1643: }
1644: switch(c) {
1645: case 'A':
1646: /* Fine! */
1647: break;
1648: case 'B':
1649: DEBUG(2, "CALL ABORTED\n", 0);
1650: goto failret;
1651: case 'D':
1652: DEBUG(2, "Dialer format error\n", 0);
1653: goto failret;
1654: case 'E':
1655: DEBUG(2, "Dialer parity error\n", 0);
1656: goto failret;
1657: case 'F':
1658: DEBUG(2, "Phone number too long\n", 0);
1659: goto failret;
1660: case 'G':
1661: DEBUG(2, "Busy signal\n", 0);
1662: goto failret;
1663: default:
1664: DEBUG(2, "Unknown MACS return code '%c'\n", i);
1665: goto failret;
1666: }
1667: /*
1668: * open line - will return on carrier
1669: */
1670: if ((i = open(com, 2)) < 0) {
1671: if (errno == EIO)
1672: logent("carrier", "LOST");
1673: else
1674: logent("dialup open", "FAILED");
1675: goto failret;
1676: }
1677: fixline(i, dev->D_speed);
1678: goto ret;
1679: failret:
1680: i = CF_DIAL;
1681: ret:
1682: alarm(0);
1683: if (child != -1)
1684: kill(child, SIGKILL);
1685: close(va);
1686: return(i);
1687: }
1688:
1689: rvmacscls(fd)
1690: register int fd;
1691: {
1692: DEBUG(2, "MACS close %d\n", fd);
1693: p_chwrite(fd, SOH);
1694: /* ioctl(fd, TIOCCDTR, NULL);*/
1695: close(fd);
1696: }
1697: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.