![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to callers.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 callers.c CVS log | Up to [Research Unix] / researchv8dc / cmd / uucp |
1.1 root 1: /* %W%
2: */
3: #include "uucp.h"
4: VERSION(%W%);
5:
6: #ifdef BSD4_2
7: #include <netdb.h>
8: #include <netinet/in.h>
9: #include <sys/socket.h>
10: #endif
11: #ifdef UNET
12: #include "UNET/unetio.h"
13: #include "UNET/tcp.h"
14: #endif
15:
16:
17: int alarmtr();
18: extern jmp_buf Sjbuf;
19: extern char *fdig();
20:
21: /*
22: * to add a new caller:
23: * declare the function that knows how to call on the device,
24: * add a line to the callers table giving the name of the device
25: * (from Devices file) and the name of the function
26: * add the function to the end of this file
27: */
28:
29: #ifdef DIAL801
30: int dial801();
31: #endif
32:
33: #ifdef DATAKIT
34: int dkcall();
35: #endif DATAKIT
36:
37: #ifdef V8
38: int Dialout();
39: #endif
40:
41: #ifdef TCP
42: int unetcall();
43: int tcpcall();
44: #endif TCP
45:
46: #ifdef SYTEK
47: int sytcall();
48: #endif SYTEK
49:
50: struct caller Caller[] = {
51:
52: #ifdef DIAL801
53: {"801", dial801},
54: {"212", dial801},
55: #endif DIAL801
56:
57: #ifdef V8
58: {"Dialout", Dialout}, /* ditto but using dialout(III) */
59: #endif
60:
61: #ifdef TCP
62: #ifdef BSD4_2
63: {"TCP", tcpcall}, /* 4.2BSD sockets */
64: #else !BSD4_2
65: #ifdef UNET
66: {"TCP", unetcall}, /* 3com implementation of tcp */
67: {"Unetserver", unetcall},
68: #endif UNET
69: #endif BSD4_2
70: #endif TCP
71:
72: #ifdef DATAKIT
73: {"DK", dkcall}, /* standard AT&T DATAKIT VCS caller */
74: #endif DATAKIT
75:
76: #ifdef SYTEK
77: {"Sytek", sytcall}, /* untested but should work */
78: #endif SYTEK
79:
80: {NULL, NULL} /* this line must be last */
81: };
82:
83: /***
84: * exphone - expand phone number for given prefix and number
85: *
86: * return code - none
87: */
88:
89: static void
90: exphone(in, out)
91: char *in, *out;
92: {
93: FILE *fn;
94: char pre[MAXPH], npart[MAXPH], tpre[MAXPH], p[MAXPH];
95: char buf[BUFSIZ];
96: char *s1;
97:
98: if (!isalpha(*in)) {
99: (void) strcpy(out, in);
100: return;
101: }
102:
103: s1=pre;
104: while (isalpha(*in))
105: *s1++ = *in++;
106: *s1 = NULLCHAR;
107: s1 = npart;
108: while (*in != NULLCHAR)
109: *s1++ = *in++;
110: *s1 = NULLCHAR;
111:
112: tpre[0] = NULLCHAR;
113: fn = fopen(DIALFILE, "r");
114: if (fn != NULL) {
115: while (fgets(buf, BUFSIZ, fn)) {
116: if ( sscanf(buf, "%s%s", p, tpre) < 1)
117: continue;
118: if (EQUALS(p, pre))
119: break;
120: tpre[0] = NULLCHAR;
121: }
122: fclose(fn);
123: }
124:
125: (void) strcpy(out, tpre);
126: (void) strcat(out, npart);
127: return;
128: }
129:
130: /*
131: * repphone - Replace \D and \T sequences in arg with phone
132: * expanding and translating as appropriate.
133: */
134: static char *
135: repphone(arg, phone, trstr)
136: register char *arg, *phone, *trstr;
137: {
138: extern void translate();
139: static char pbuf[2*(MAXPH+2)];
140: register char *fp, *tp;
141:
142: for (tp=pbuf; *arg; arg++) {
143: if (*arg != '\\') {
144: *tp++ = *arg;
145: continue;
146: } else {
147: switch (*(arg+1)) {
148: case 'T':
149: exphone(phone, tp);
150: translate(trstr, tp);
151: for(; *tp; tp++)
152: ;
153: arg++;
154: break;
155: case 'D':
156: for(fp=phone; *tp = *fp++; tp++)
157: ;
158: arg++;
159: break;
160: default:
161: *tp++ = *arg;
162: break;
163: }
164: }
165: }
166: *tp = '\0';
167: return(pbuf);
168: }
169:
170: /*
171: * processdev - Process a line from the Devices file
172: *
173: * return codes:
174: * file descriptor - succeeded
175: * FAIL - failed
176: */
177:
178: processdev(flds, dev)
179: register char *flds[], *dev[];
180: {
181: register int dcf = -1;
182: register struct caller *ca;
183: char *args[D_MAX+1], dcname[20];
184: register char **sdev;
185: extern void translate();
186: register nullfd;
187: char *phonecl; /* clear phone string */
188: char phoneex[2*(MAXPH+2)]; /* expanded phone string */
189:
190: sdev = dev;
191: for (ca = Caller; ca->CA_type != NULL; ca++) {
192: /* This will find built-in caller functions */
193: if (EQUALS(ca->CA_type, dev[D_CALLER])) {
194: DEBUG(5, "Internal caller type %s\n", dev[D_CALLER]);
195: if (dev[D_ARG] == NULL) {
196: /* if NULL - assume translate */
197: dev[D_ARG+1] = NULL; /* needed for for loop later to mark the end */
198: dev[D_ARG] = "\\T";
199: }
200: dev[D_ARG] = repphone(dev[D_ARG], flds[F_PHONE], "");
201: if ((dcf = (*(ca->CA_caller))(flds, dev)) < 0)
202: return(dcf) ;
203: dev += 2; /* Skip to next CALLER and ARG */
204: break;
205: }
206: }
207: if (dcf == -1) {
208: /* Here if not a built-in caller function */
209: if (mlock(dev[D_LINE]) == FAIL) { /* Lock the line */
210: DEBUG(5, "mlock %s failed\n", dev[D_LINE]);
211: Uerror = SS_LOCKED_DEVICE;
212: return(FAIL);
213: }
214: DEBUG(5, "mlock %s succeeded\n", dev[D_LINE]);
215: /*
216: * Open the line
217: */
218: (void) sprintf(dcname, "/dev/%s", dev[D_LINE]);
219: /* take care of the possible partial open fd */
220: (void) close(nullfd = open("/", 0));
221: if (setjmp(Sjbuf)) {
222: (void) close(nullfd);
223: DEBUG(1, "generic open timeout\n", "");
224: logent("generic open", "TIMEOUT");
225: Uerror = SS_CANT_ACCESS_DEVICE;
226: goto bad;
227: }
228: (void) signal(SIGALRM, alarmtr);
229: (void) alarm(10);
230: dcf = open(dcname, 2);
231: (void) alarm(0);
232: if (dcf < 0) {
233: (void) close(nullfd);
234: DEBUG(1, "generic open failed, errno = %d\n", errno);
235: logent("generic open", "FAILED");
236: Uerror = SS_CANT_ACCESS_DEVICE;
237: goto bad;
238: }
239: fixline(dcf, atoi(fdig(flds[F_CLASS])), D_DIRECT);
240: }
241: /*
242: * Now loop through the remaining callers and chat
243: * according to scripts in dialers file.
244: */
245: for (; dev[D_CALLER] != NULL; dev += 2) {
246: register int w;
247: /*
248: * Scan Dialers file to find an entry
249: */
250: if ((w = gdial(dev[D_CALLER], args, D_MAX)) < 1) {
251: DEBUG(1, "%s not found in Dialers file\n", dev[D_CALLER]);
252: logent("generic call to gdial", "FAILED");
253: Uerror = SS_CANT_ACCESS_DEVICE;
254: goto bad;
255: }
256: if (w <= 2) /* do nothing - no chat */
257: break;
258: /*
259: * Translate the phone number
260: */
261: if (dev[D_ARG] == NULL) {
262: /* if NULL - assume no translation */
263: dev[D_ARG+1] = NULL; /* needed for for loop to mark the end */
264: dev[D_ARG] = "\\D";
265: }
266:
267: phonecl = repphone(dev[D_ARG], flds[F_PHONE], args[1]);
268: exphone(phonecl, phoneex);
269: translate(args[1], phoneex);
270: /*
271: * Chat
272: */
273: if (chat(w-2, &args[2], dcf, phonecl, phoneex) != SUCCESS) {
274: Uerror = SS_CHAT_FAILED;
275: goto bad;
276: }
277: }
278: /*
279: * Success at last!
280: */
281: strcpy(Dc, sdev[D_LINE]);
282: return(dcf);
283: bad:
284: (void)close(dcf);
285: delock(sdev[D_LINE]);
286: return(FAIL);
287: }
288:
289: /*
290: * translate the pairs of characters present in the first
291: * string whenever the first of the pair appears in the second
292: * string.
293: */
294: static void
295: translate(ttab, str)
296: register char *ttab, *str;
297: {
298: register char *s;
299:
300: for(;*ttab && *(ttab+1); ttab += 2)
301: for(s=str;*s;s++)
302: if(*ttab == *s)
303: *s = *(ttab+1);
304: }
305:
306: #define MAXLINE 512
307: /*
308: * Get the information about the dialer.
309: * gdial(type, arps, narps)
310: * type -> type of dialer (e.g., penril)
311: * arps -> array of pointers returned by gdial
312: * narps -> number of elements in array returned by gdial
313: * Return value:
314: * -1 -> Can't open DIALERFILE
315: * 0 -> requested type not found
316: * >0 -> success - number of fields filled in
317: */
318: static
319: gdial(type, arps, narps)
320: register char *type, *arps[];
321: register int narps;
322: {
323: static char info[MAXLINE];
324: register FILE *ldial;
325: register na;
326:
327: DEBUG(2, "gdial(%s) called\n", type);
328: if ((ldial = fopen(DIALERFILE, "r")) == NULL)
329: return(-1);
330: while (fgets(info, sizeof(info), ldial) != NULL) {
331: if ((info[0] == '#') || (info[0] == ' ') ||
332: (info[0] == '\t') || (info[0] == '\n'))
333: continue;
334: if ((na = getargs(info, arps, narps)) == 0)
335: continue;
336: if (EQUALS(arps[0], type)) {
337: (void)fclose(ldial);
338: bsfix(arps);
339: return(na);
340: }
341: }
342: (void)fclose(ldial);
343: return(0);
344: }
345:
346:
347: #ifdef DATAKIT
348:
349: /***
350: * dkcall(flds, dev) make a DATAKIT VCS connection
351: * DATAKIT VCS is a trademark of AT&T
352: *
353: * return codes:
354: * >0 - file number - ok
355: * FAIL - failed
356: */
357:
358: #include "dk.h"
359:
360: dkcall(flds, dev)
361: char *flds[], *dev[];
362: {
363: register fd;
364: #ifdef V8
365: extern int dkp_ld;
366: #endif
367:
368: char dialstring[64];
369:
370: strcpy(dialstring, dev[D_ARG]);
371:
372: #ifndef STANDALONE
373: if(*flds[F_CLASS] < '0' || *flds[F_CLASS] > '9')
374: sprintf(dialstring, "%s.%s", dev[D_ARG], flds[F_CLASS]);
375: #endif
376:
377: DEBUG(4, "dkcall(%s)\n", dialstring);
378:
379:
380: #ifdef V8
381: if (setjmp(Sjbuf)) {
382: Uerror = SS_DIAL_FAILED;
383: return(FAIL);
384: }
385:
386: (void) signal(SIGALRM, alarmtr);
387: (void) alarm(70);
388: DEBUG(4, "tdkdial(%s", dialstring);
389: DEBUG(4, ", %d)\n", atoi(flds[F_CLASS]));
390: if ((fd = tdkdial(dialstring, atoi(flds[F_CLASS]))) >= 0)
391: if (dkproto(fd, dkp_ld) < 0)
392: {
393: close(fd);
394: fd = -1;
395: }
396: (void) alarm(0);
397: #else
398: fd = dkdial(dialstring);
399: #endif
400:
401: (void) strcpy(Dc, "DK");
402: if (fd < 0) {
403: Uerror = SS_DIAL_FAILED;
404: return(FAIL);
405: }
406: else
407: return(fd);
408: }
409:
410: #endif DATAKIT
411:
412: #ifdef TCP
413:
414: /***
415: * tcpcall(flds, dev) make ethernet/socket connection
416: *
417: * return codes:
418: * >0 - file number - ok
419: * FAIL - failed
420: */
421:
422: #ifndef BSD4_2
423: /*ARGSUSED*/
424: tcpcall(flds, dev)
425: char *flds[], *dev[];
426: {
427: Uerror = SS_NO_DEVICE;
428: return(FAIL);
429: }
430: #else BSD4_2
431: tcpcall(flds, dev)
432: char *flds[], *dev[];
433: {
434: int ret;
435: short port;
436: extern int errno, sys_nerr;
437: extern char *sys_errlist[];
438: struct servent *sp;
439: struct hostent *hp;
440: struct sockaddr_in sin;
441:
442: port = atoi(dev[D_ARG]);
443: if (port == 0) {
444: sp = getservbyname("uucp", "tcp");
445: ASSERT(sp != NULL, "No uucp server", 0, 0);
446: port = sp->s_port;
447: }
448: else port = htons(port);
449: hp = gethostbyname(flds[F_NAME]);
450: if (hp == NULL) {
451: logent("tcpopen", "no such host");
452: Uerror = SS_NO_DEVICE;
453: return(FAIL);
454: }
455: DEBUG(4, "tcpdial host %s, ", flds[F_NAME]);
456: DEBUG(4, "port %d\n", ntohs(port));
457:
458: ret = socket(AF_INET, SOCK_STREAM, 0);
459: if (ret < 0) {
460: if (errno < sys_nerr) {
461: DEBUG(5, "no socket: %s\n", sys_errlist[errno]);
462: logent("no socket", sys_errlist[errno]);
463: }
464: else {
465: DEBUG(5, "no socket, errno %d\n", errno);
466: logent("tcpopen", "NO SOCKET");
467: }
468: Uerror = SS_NO_DEVICE;
469: return(FAIL);
470: }
471: sin.sin_family = hp->h_addrtype;
472: bcopy(hp->h_addr, (caddr_t)&sin.sin_addr, hp->h_length);
473: sin.sin_port = port;
474: if (setjmp(Sjbuf)) {
475: DEBUG(4, "timeout tcpopen\n", "");
476: logent("tcpopen", "TIMEOUT");
477: Uerror = SS_NO_DEVICE;
478: return(FAIL);
479: }
480: (void) signal(SIGALRM, alarmtr);
481: (void) alarm(30);
482: DEBUG(7, "family: %d\n", sin.sin_family);
483: DEBUG(7, "port: %d\n", sin.sin_port);
484: DEBUG(7, "addr: %08x\n",*((int *) &sin.sin_addr));
485: if (connect(ret, (caddr_t)&sin, sizeof (sin)) < 0) {
486: (void) alarm(0);
487: (void) close(ret);
488: if (errno < sys_nerr) {
489: DEBUG(5, "connect failed: %s\n", sys_errlist[errno]);
490: logent("connect failed", sys_errlist[errno]);
491: }
492: else {
493: DEBUG(5, "connect failed, errno %d\n", errno);
494: logent("tcpopen", "CONNECT FAILED");
495: }
496: Uerror = SS_NO_DEVICE;
497: return(FAIL);
498: }
499: (void) signal(SIGPIPE, SIG_IGN); /* watch out for broken ipc link...*/
500: (void) alarm(0);
501: (void) strcpy(Dc, "IPC");
502: return(ret);
503: }
504:
505: #endif BSD4_2
506:
507: /***
508: * unetcall(flds, dev) make ethernet connection
509: *
510: * return codes:
511: * >0 - file number - ok
512: * FAIL - failed
513: */
514:
515: #ifndef UNET
516: unetcall(flds, dev)
517: char *flds[], *dev[];
518: {
519: Uerror = SS_NO_DEVICE;
520: return(FAIL);
521: }
522: #else UNET
523: unetcall(flds, dev)
524: char *flds[], *dev[];
525: {
526: int ret;
527: int port;
528: extern int errno;
529:
530: port = atoi(dev[D_ARG]);
531: DEBUG(4, "unetdial host %s, ", flds[F_NAME]);
532: DEBUG(4, "port %d\n", port);
533: (void) alarm(30);
534: ret = tcpopen(flds[F_NAME], port, 0, TO_ACTIVE, "rw");
535: (void) alarm(0);
536: endhnent(); /* wave magic wand at 3com and incant "eat it, bruce" */
537: if (ret < 0) {
538: DEBUG(5, "tcpopen failed: errno %d\n", errno);
539: Uerror = SS_DIAL_FAILED;
540: return(FAIL);
541: }
542: (void) strcpy(Dc, "UNET");
543: return(ret);
544: }
545: #endif UNET
546:
547: #endif TCP
548:
549: #ifdef SYTEK
550:
551: /****
552: * sytcall(flds, dev) make a sytek connection
553: *
554: * return codes:
555: * >0 - file number - ok
556: * FAIL - failed
557: */
558:
559: /*ARGSUSED*/
560: sytcall(flds, dev)
561: char *flds[], *dev[];
562: {
563: extern int errno;
564: int dcr, dcr2, nullfd, ret;
565: char dcname[20], command[BUFSIZ];
566:
567: (void) sprintf(dcname, "/dev/%s", dev[D_LINE]);
568: DEBUG(4, "dc - %s, ", dcname);
569: dcr = open(dcname, O_WRONLY|O_NDELAY);
570: if (dcr < 0) {
571: Uerror = SS_DIAL_FAILED;
572: DEBUG(4, "OPEN FAILED %s\n", dcname);
573: delock(dev[D_LINE]);
574: return(FAIL);
575: }
576:
577: sytfixline(dcr, atoi(fdig(dev[D_CLASS])), D_DIRECT);
578: (void) sleep(2);
579: (void) sprintf(command,"\r\rcall %s\r",flds[F_PHONE]);
580: ret = write(dcr, command, strlen(command));
581: (void) sleep(1);
582: DEBUG(4, "COM1 return = %d\n", ret);
583: sytfix2line(dcr);
584: (void) close(nullfd = open("/", 0));
585: (void) signal(SIGALRM, alarmtr);
586: if (setjmp(Sjbuf)) {
587: DEBUG(4, "timeout sytek open\n", "");
588: (void) close(nullfd);
589: (void) close(dcr2);
590: (void) close(dcr);
591: Uerror = SS_DIAL_FAILED;
592: delock(dev[D_LINE]);
593: return(FAIL);
594: }
595: (void) alarm(10);
596: dcr2 = open(dcname,O_RDWR);
597: (void) alarm(0);
598: (void) close(dcr);
599: if (dcr2 < 0) {
600: DEBUG(4, "OPEN 2 FAILED %s\n", dcname);
601: Uerror = SS_DIAL_FAILED;
602: (void) close(nullfd); /* kernel might think dc2 is open */
603: delock(dev[D_LINE]);
604: return(FAIL);
605: }
606: return(dcr2);
607: }
608:
609: #endif SYTEK
610:
611: #ifdef DIAL801
612:
613: /***
614: * dial801(flds, dev) dial remote machine on 801/801
615: * char *flds[], *dev[];
616: *
617: * return codes:
618: * file descriptor - succeeded
619: * FAIL - failed
620: *
621: * unfortunately, open801() is different for usg and non-usg
622: */
623:
624: /*ARGSUSED*/
625: dial801(flds, dev)
626: char *flds[], *dev[];
627: {
628: char dcname[20], dnname[20], phone[MAXPH+2], *fdig();
629: int dcf = -1, speed;
630:
631: if (mlock(dev[D_LINE]) == FAIL) {
632: DEBUG(5, "mlock %s failed\n", dev[D_LINE]);
633: Uerror = SS_LOCKED_DEVICE;
634: return(FAIL);
635: }
636: (void) sprintf(dnname, "/dev/%s", dev[D_CALLDEV]);
637: (void) sprintf(phone, "%s%s", dev[D_ARG] , ACULAST);
638: (void) sprintf(dcname, "/dev/%s", dev[D_LINE]);
639: CDEBUG(1, "Use Port %s, ", dcname);
640: DEBUG(4, "acu - %s, ", dnname);
641: CDEBUG(1, "Phone Number %s\n", phone);
642: VERBOSE("Trying modem - %s, ", dcname); /* for cu */
643: VERBOSE("acu - %s, ", dnname); /* for cu */
644: VERBOSE("calling %s: ", phone); /* for cu */
645: speed = atoi(fdig(dev[D_CLASS]));
646: dcf = open801(dcname, dnname, phone, speed);
647: if (dcf >= 0) {
648: fixline(dcf, speed, D_ACU);
649: (void) strcpy(Dc, dev[D_LINE]); /* for later unlock() */
650: VERBOSE("SUCCEEDED\n", 0);
651: } else {
652: delock(dev[D_LINE]);
653: VERBOSE("FAILED\n", 0);
654: }
655: return(dcf);
656: }
657:
658:
659: #ifndef ATTSV
660: /*ARGSUSED*/
661: open801(dcname, dnname, phone, speed)
662: char *dcname, *dnname, *phone;
663: {
664: int nw, lt, pid = -1, dcf = -1, nullfd, dnf = -1;
665: unsigned timelim;
666:
667: if ((dnf = open(dnname, 1)) < 0) {
668: DEBUG(5, "can't open %s\n", dnname);
669: Uerror = SS_CANT_ACCESS_DEVICE;
670: return(FAIL);
671: }
672: DEBUG(5, "%s is open\n", dnname);
673:
674: (void) close(nullfd = open("/dev/null", 0)); /* partial open hack */
675: if (setjmp(Sjbuf)) {
676: DEBUG(4, "timeout modem open\n", "");
677: logent("801 open", "TIMEOUT");
678: (void) close(nullfd);
679: (void) close(dcf);
680: (void) close(dnf);
681: if (pid > 0) {
682: kill(pid, 9);
683: wait((int *) 0);
684: }
685: Uerror = SS_DIAL_FAILED;
686: return(FAIL);
687: }
688: (void) signal(SIGALRM, alarmtr);
689: timelim = 5 * strlen(phone);
690: (void) alarm(timelim < 30 ? 30 : timelim);
691: if ((pid = fork()) == 0) {
692: sleep(2);
693: nw = write(dnf, phone, lt = strlen(phone));
694: if (nw != lt) {
695: DEBUG(4, "ACU write error %d\n", errno);
696: logent("ACU write", "FAILED");
697: exit(1);
698: }
699: DEBUG(4, "ACU write ok%s\n", "");
700: exit(0);
701: }
702: /* open line - will return on carrier */
703: dcf = open(dcname, 2);
704:
705: DEBUG(4, "dcf is %d\n", dcf);
706: if (dcf < 0) { /* handle like a timeout */
707: (void) alarm(0);
708: longjmp(Sjbuf, 1);
709: }
710:
711: /* modem is open */
712: while ((nw = wait(<)) != pid && nw != -1)
713: ;
714: (void) alarm(0);
715:
716: (void) close(dnf); /* no reason to keep the 801 open */
717: if (lt != 0) {
718: DEBUG(4, "Fork Stat %o\n", lt);
719: (void) close(dcf);
720: Uerror = SS_DIAL_FAILED;
721: return(FAIL);
722: }
723: return(dcf);
724: }
725:
726: #else ATTSV
727:
728: open801(dcname, dnname, phone, speed)
729: char *dcname, *dnname, *phone;
730: {
731: int nw, lt, dcf = -1, nullfd, dnf = -1, ret;
732: unsigned timelim;
733:
734: (void) close(nullfd = open("/", 0)); /* partial open hack */
735: if (setjmp(Sjbuf)) {
736: DEBUG(4, "DN write %s\n", "timeout");
737: (void) close(dnf);
738: (void) close(dcf);
739: (void) close(nullfd);
740: Uerror = SS_DIAL_FAILED;
741: return(FAIL);
742: }
743: (void) signal(SIGALRM, alarmtr);
744: timelim = 5 * strlen(phone);
745: (void) alarm(timelim < 30 ? 30 : timelim);
746:
747: if ((dnf = open(dnname, O_WRONLY)) < 0 ) {
748: DEBUG(5, "can't open %s\n", dnname);
749: Uerror = SS_CANT_ACCESS_DEVICE;
750: return(FAIL);
751: }
752: DEBUG(5, "%s is open\n", dnname);
753: if ( (dcf = open(dcname, O_RDWR | O_NDELAY)) < 0 ) {
754: DEBUG(5, "can't open %s\n", dcname);
755: Uerror = SS_CANT_ACCESS_DEVICE;
756: return(FAIL);
757: }
758:
759: DEBUG(4, "dcf is %d\n", dcf);
760: fixline(dcf, speed, D_ACU);
761: nw = write(dnf, phone, lt = strlen(phone));
762: if (nw != lt) {
763: (void) alarm(0);
764: DEBUG(4, "ACU write error %d\n", errno);
765: (void) close(dnf);
766: (void) close(dcf);
767: Uerror = SS_DIAL_FAILED;
768: return(FAIL);
769: } else
770: DEBUG(4, "ACU write ok%s\n", "");
771:
772: (void) close(dnf);
773: (void) close(nullfd = open("/", 0)); /* partial open hack */
774: ret = open(dcname, 2); /* wait for carrier */
775: (void) alarm(0);
776: (void) close(ret); /* close 2nd modem open() */
777: if (ret < 0) { /* open() interrupted by alarm */
778: DEBUG(4, "Line open %s\n", "failed");
779: Uerror = SS_DIAL_FAILED;
780: (void) close(nullfd); /* close partially opened modem */
781: return(FAIL);
782: }
783: (void) fcntl(dcf,F_SETFL, fcntl(dcf, F_GETFL, 0) & ~O_NDELAY);
784: return(dcf);
785: }
786: #endif ATTSV
787:
788: #endif DIAL801
789:
790: #ifdef V8
791: Dialout(flds)
792: char *flds[];
793: {
794: int fd;
795: char phone[MAXPH+2];
796:
797: exphone(flds[F_PHONE], phone);
798:
799: DEBUG(4, "call dialout(%s", phone);
800: DEBUG(4, ", %s)\n", flds[F_CLASS]);
801: fd = dialout(phone, flds[F_CLASS]);
802: if (fd == -1)
803: Uerror = SS_NO_DEVICE;
804: if (fd == -3)
805: Uerror = SS_DIAL_FAILED;
806: if (fd == -9)
807: Uerror = SS_DEVICE_FAILED;
808:
809: (void) strcpy(Dc, "Dialout");
810:
811: return(fd);
812: }
813: #endif V8
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.