![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ckudia.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / e / bin / cku179|
Return to ckudia.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / cku179 |
1.1 root 1: #ifndef NODIAL
2: char *dialv = "Dial Command, 5A(028) 23 Dec 91";
3:
4: /* C K U D I A -- Dialing program for connection to remote system */
5:
6: /*
7: Original author: Herm Fischer (HFISCHER@USC-ECLB).
8: Contributed to Columbia University for inclusion in C-Kermit.
9: Copyright (C) 1985, Herman Fischer, 16400 Ventura Blvd, Encino CA 91436.
10: Permission is granted to any individual or institution to use, copy, or
11: redistribute this software so long as it is not sold for profit, provided
12: this copyright notice is retained.
13:
14: Os9/68k and Microcom modem support by Bob Larson ([email protected])
15: Additional code by many others over the years.
16:
17: ------
18:
19: This module should work under all versions of Unix. It calls externally
20: defined system-depended functions for i/o, but depends upon the existence
21: of various modem control functions.
22:
23: This module, and the supporting routines in the ckutio.c module, assume
24: that the computer and modem properly utilize the following data communi-
25: cations signals (that means one should prepare the modem to use, not
26: circumvent, these signals):
27:
28: Data Terminal Ready (DTR): This signal is asserted by the computer
29: when Kermit is about to ask the modem to dial a call, and is
30: removed when Kermit wishes to have the modem hang up a call.
31: The signal is asserted both while Kermit is asking the modem
32: to dial a specific number, and after connection, while Kermit
33: is in a data exchange mode.
34:
35: Carrier Detect (CD): This signal must be asserted by the modem when
36: a carrier is detected from a remote modem on a communications
37: circuit. It must be removed by the modem when the circuit
38: disconnects or is hung up. (Carrier Detect is ignored while
39: Kermit is asking the modem to dial the call, because there is
40: no consistant usage of this signal during the dialing phase
41: among different modem manufacturers.)
42: */
43:
44: /*
45: * Modifications:
46: *
47: * 21-Jul-85 Fixed failure returns hanging on no carrier signal
48: * Requires tthang change too (ckutio.c revision)
49: * -- Herm Fischer
50: *
51: * 28-Jun-85 Fixed bug with defaulting the modem-failure message
52: * in lbuf.
53: * -- Dan Schullman
54: *
55: * 27-Jun-85 Merged in code from Joe Orost at Berkeley for
56: * supporting the US Robotics modem, which included
57: * changing the single characters in MDMINF into
58: * multi-character strings and modifying waitfor.
59: * -- Dan Schullman
60: *
61: * 26-Jun-85 Allow interrupts to be used to abort dialing,
62: * and ring the bell when a connection is made.
63: * Reorganized some of the failure paths to use the
64: * same code, and now close the line on failures.
65: * Allow use of stored numbers with the DF100 and
66: * DF200 modems. Handlers now declared after the
67: * call to setjmp.
68: * -- Dan Schullman
69: *
70: * 24-May-85 DF03, DF100-series, DF200-series, and "unknown" modem
71: * support added. Also restructured the various data
72: * tables, fixed some bugs related to missing data and
73: * missing case labels, and modified the failure message
74: * to display the "reason" given by the modem.
75: * -- Dan Schullman
76: * 16-Mar-87 Support for the ATT7300 UNIX PC internal modem was
77: * added.
78: * -- Richard E. Hill
79: *
80: * 21-Feb-88 Os9/68k and microcom modem support.
81: * -- Bob Larson
82: *
83: * 14-Mar-88 Rewrite code for ATT7300 (here and in ckutio.c)
84: * Avoids dial(3c) with it's LCK files, hangs up line
85: * correctly, enables user interrupts and timeouts,
86: * turns on/off the system getty() login procedure.
87: * Correct Hayes command sequence at little.
88: * Procedures: attdial, atthang, ongetty, offgetty.
89: * Parts adapted from work of Richard E. Hill and
90: * Kevin O'Gorman.
91: * -- Joe R. Doupnik
92: *
93: * 13-Jan-89 Added IBM/Siemens/Rolm CBX dialing support.
94: * - F. da Cruz
95: *
96: * 29-Aug-89 Added support for AT&T 2212C, 2224B, 2224CEO, and
97: * 2296A switched-network modems in AT&T mode, and
98: * for the AT&T Digital Terminal Data Module (DTDM).
99: * -- Eric F. Jones
100: *
101: * 4-Jun-90 Added delay on "ANSWERED" for AT&T DTDM
102: * 7-Jun-90 Added support for AT&T ISN Network
103: * - John L. Chmielewski, AT&T
104: *
105: * March 1991 Support for Telebit modems, Kermit spoofing.
106: * Warren Tucker, Larry Jacobs, Frank da Cruz.
107: */
108:
109: /*
110: * To add support for another modem, do the following:
111: *
112: * Define a modem number symbol (n_XXX) for it, keeping the list
113: * in alphabetical and numerical order, and renumbering the values
114: * as necessary. Make sure the n_XXX symbol is unique within 7 chars.
115: *
116: * Create a MDMINF structure for it, again keeping the list alphabetical
117: * for sanity's sake.
118: *
119: * Add the address of the MDMINF structure to the ptrtab array, again
120: * in alphabetical and numerical order.
121: *
122: * Add the "user visible" modem name and corresponding modem number to
123: * the mdmtab array, again in alphabetical order.
124: *
125: * Read through the code and add modem-specific sections as necessary.
126: */
127:
128: /*
129: * The intent of the "unknown" modem is hopefully to allow KERMIT to support
130: * unknown modems by having the user type the entire autodial sequence
131: * (possibly including control characters, etc.) as the "phone number".
132: * The only reason that the CONNECT command cannot be used to do this is
133: * that a remote line cannot normally be opened unless carrier is present.
134: *
135: * The protocol and other characteristics of this modem are unknown, with
136: * some "reasonable" values being chosen for some of them. The only way to
137: * detect if a connection is made is to look for carrier present.
138: */
139: #include "ckcdeb.h"
140: #ifndef MAC
141: #include <signal.h>
142: #endif /* MAC */
143: #include "ckcasc.h"
144: #include "ckcker.h"
145: #include "ckucmd.h"
146:
147: #ifndef ZILOG
148: #include <setjmp.h> /* Longjumps */
149: #else
150: #include <setret.h>
151: #endif /* ZILOG */
152:
153: #ifdef MAC
154: #define signal msignal
155: #define SIGTYP long
156: #define alarm malarm
157: #define SIG_IGN 0
158: #define SIGALRM 1
159: #define SIGINT 2
160: SIGTYP (*msignal(int type, SIGTYP (*func)(int)))(int);
161: #endif /* MAC */
162:
163: extern int flow, local, mdmtyp, quiet, parity, seslog, network, dialhng,
164: dialdpy, mdmspd, dialtmo, dialksp, dialmnp;
165: extern char *dialini;
166: extern CHAR stchr;
167: extern long speed;
168: extern char ttname[], sesfil[];
169:
170: /*
171: * Failure reasons for use with the 'longjmp' exit.
172: */
173: #define F_time 1 /* timeout */
174: #define F_int 2 /* interrupt */
175: #define F_modem 3 /* modem-detected failure */
176: #define F_minit 4 /* cannot initialize modem */
177:
178: static int mymdmtyp; /* Local copy of modem type. */
179: static int n1 = F_time;
180:
181: #define MDMINF struct mdminf
182:
183: MDMINF /* structure for modem-specific information */
184: {
185: int dial_time; /* time modem allows for dialing (secs) */
186: char *pause_chars; /* character(s) to tell modem to pause */
187: int pause_time; /* time associated with pause chars (secs) */
188: char *wake_str; /* string to wakeup modem & put in cmd mode */
189: int wake_rate; /* delay between wake_str characters (msecs) */
190: char *wake_prompt; /* string prompt after wake_str */
191: char *dmode_str; /* string to put modem in dialing mode */
192: char *dmode_prompt; /* string prompt for dialing mode */
193: char *dial_str; /* dialing string, with "%s" for number */
194: int dial_rate; /* delay between dialing characters (msecs) */
195: };
196:
197: /*
198: * Define symbolic modem numbers.
199: *
200: * The numbers MUST correspond to the ordering of entries
201: * within the ptrtab array, and start at one (1).
202: *
203: * It is assumed that there are relatively few of these
204: * values, and that the high(er) bytes of the value may
205: * be used for modem-specific mode information.
206: *
207: * REMEMBER that only the first eight characters of these
208: * names are guaranteed to be unique.
209: */
210:
211: #define n_ATTDTDM 1
212: #define n_ATTISN 2
213: #define n_ATTMODEM 3
214: #define n_CERMETEK 4
215: #define n_DF03 5
216: #define n_DF100 6
217: #define n_DF200 7
218: #define n_GDC 8
219: #define n_HAYES 9
220: #define n_PENRIL 10
221: #define n_RACAL 11
222: #define n_UNKNOWN 12
223: #define n_USROBOT 13
224: #define n_VENTEL 14
225: #define n_CONCORD 15
226: #define n_ATTUPC 16 /* aka Unix PC and ATT7300 */
227: #define n_ROLM 17 /* Rolm CBX DCM */
228: #define n_MICROCOM 18
229: #define n_HST 19
230: #define n_TELEBIT 20 /* Telebit Trailblazer */
231: #define MAX_MDM 20
232: /*
233: * Declare modem "variant" numbers for any of the above for which it is
234: * necessary to note various operational modes, using the second byte
235: * of a modem number.
236: *
237: * It is assumed that such modem modes share the same modem-specific
238: * information (see MDMINF structure) but may differ in some of the actions
239: * that are performed.
240: */
241:
242: /* Warning - this is starting to get kind of hokey... */
243:
244: #define DIAL_NV 256
245: #define DIAL_PEP 512
246: #define DIAL_V32 1024
247: #define DIAL_V42 2048
248: #define DIAL_SLO 4096
249:
250: #define n_HAYESNV ( n_HAYES | DIAL_NV )
251: #define n_TBPEP ( n_TELEBIT | DIAL_PEP )
252: #define n_TB3 ( n_TELEBIT | DIAL_V32 )
253: #define n_TBNV ( n_TELEBIT | DIAL_NV )
254: #define n_TBPNV ( n_TELEBIT | DIAL_NV | DIAL_PEP )
255: #define n_TB3NV ( n_TELEBIT | DIAL_NV | DIAL_V32 )
256: #define n_TB4 ( n_TELEBIT | DIAL_V42 )
257: #define n_TBS ( n_TELEBIT | DIAL_SLO )
258: #define n_TB4NV ( n_TELEBIT | DIAL_NV | DIAL_V42 )
259: #define n_TBSNV ( n_TELEBIT | DIAL_NV | DIAL_SLO )
260:
261: /*
262: * Declare structures containing modem-specific information.
263: *
264: * REMEMBER that only the first SEVEN characters of these
265: * names are guaranteed to be unique.
266: */
267:
268: static
269: MDMINF ATTISN = /* AT&T ISN Network */
270: {
271: 30, /* Dial time */
272: "", /* Pause characters */
273: 0, /* Pause time */
274: "\015\015\015\015", /* Wake string */
275: 900, /* Wake rate */
276: "DIAL", /* Wake prompt */
277: "", /* dmode_str */
278: "", /* dmode_prompt */
279: "%s\015", /* dial_str */
280: 0 /* dial_rate */
281: };
282:
283: static
284: MDMINF ATTMODEM = /* information for AT&T switched-network modems */
285: /* "Number" following "dial" can include: p's and
286: * t's to indicate pulse or tone (default) dialing,
287: * + for wait for dial tone, , for pause, r for
288: * last number dialed, and, except for 2224B, some
289: * comma-delimited options like o12=y, before number.
290:
291: * "Important" options for the modems:
292: *
293: * All: Except for 2224B, enable option 12 for "transparent
294: * data," o12=y. If a computer port used for both
295: * incoming and outgoing calls is connected to the
296: * modem, disable "enter interactive mode on carriage
297: * return," EICR. The Kermit "dial" command can
298: * function with EIA leads standard, EIAS.
299: *
300: * 2212C: Internal hardware switches at their default
301: * positions (four rockers down away from numbers)
302: * unless EICR is not wanted (rocker down at the 4).
303: * For EIAS, rocker down at the 1.
304: *
305: * 2224B: Front-panel switch position 1 must be up (at the 1,
306: * closed). Disable EICR with position 2 down.
307: * For EIAS, position 4 down.
308: * All switches on the back panel down.
309: *
310: * 2224CEO: All front-panel switches down except either 5 or 6.
311: * Enable interactive flow control with o16=y.
312: * Select normal asynchronous mode with o34=0 (zero).
313: * Disable EICR with position 3 up. For EIAS, 1 up.
314: * Reset the modem after changing switches.
315: *
316: * 2296A: If option 00 (zeros) is present, use o00=0.
317: * Enable interactive flow control with o16=y.
318: * Select normal asynchronous mode with o34=0 (zero).
319: * (available in Microcom Networking version, but
320: * not necessarily other models of the 2296A).
321: * Enable modem-port flow control (if available) with
322: * o42=y. Enable asynchronous operation with o50=y.
323: * Disable EICR with o69=n. For EIAS, o66=n, using
324: * front panel.
325: */
326: {
327: 20, /* dial_time */
328: ",", /* pause_chars */
329: 2, /* pause_time */
330: "+", /* wake_str */
331: 0, /* wake_rate */
332: "", /* wake_prompt */
333: "", /* dmode_str */
334: "", /* dmode_prompt */
335: "at%s\015", /* dial_str */
336: 0 /* dial_rate */
337: };
338:
339: static
340: MDMINF ATTDTDM = /* information for AT&T Digital Terminal Data Module
341: * For dialing: KYBD switch down, others usually up. */
342: {
343: 20, /* dial_time */
344: "", /* pause_chars */
345: 0, /* pause_time */
346: "", /* wake_str */
347: 0, /* wake_rate */
348: "", /* wake_prompt */
349: "", /* dmode_str */
350: "", /* dmode_prompt */
351: "%s\015", /* dial_str */ /* not used */
352: 0 /* dial_rate */
353: };
354:
355: static
356: MDMINF CERMETEK = /* information for "Cermetek Info-Mate 212 A" modem */
357: {
358: 20, /* dial_time */
359: "BbPpTt", /* pause_chars */
360: 0, /* pause_time */ /** unknown -- DS **/
361: " XY\016R\015", /* wake_str */
362: 200, /* wake_rate */
363: "", /* wake_prompt */
364: "", /* dmode_str */
365: NULL, /* dmode_prompt */
366: "\016D '%s'\015", /* dial_str */
367: 200 /* dial_rate */
368: };
369:
370: static
371: MDMINF DF03 = /* information for "DEC DF03-AC" modem */
372: {
373: 27, /* dial_time */
374: "=", /* pause_chars */ /* wait for second dial tone */
375: 15, /* pause_time */
376: "\001\002", /* wake_str */
377: 0, /* wake_rate */
378: "", /* wake_prompt */
379: "", /* dmode_str */
380: NULL, /* dmode_prompt */
381: "%s", /* dial_str */
382: 0 /* dial_rate */
383: };
384:
385: static
386: MDMINF DF100 = /* information for "DEC DF100-series" modem */
387: /*
388: * The telephone "number" can include "P"s and/or "T"s
389: * within it to indicate that subsequent digits are
390: * to be dialed using pulse or tone dialing. The
391: * modem defaults to pulse dialing. You may modify
392: * the dial string below to explicitly default all
393: * dialing to pulse or tone, but doing so prevents
394: * the use of phone numbers that you may have stored
395: * in the modem's memory.
396: */
397: {
398: 30, /* dial_time */
399: "=", /* pause_chars */ /* wait for second dial tone */
400: 15, /* pause_time */
401: "\001", /* wake_str */
402: 0, /* wake_rate */
403: "", /* wake_prompt */
404: "", /* dmode_str */
405: NULL, /* dmode_prompt */
406: "%s#", /* dial_str */
407: 0 /* dial_rate */
408: };
409:
410: static
411: MDMINF DF200 = /* information for "DEC DF200-series" modem */
412: /*
413: * The telephone "number" can include "P"s and/or "T"s
414: * within it to indicate that subsequent digits are
415: * to be dialed using pulse or tone dialing. The
416: * modem defaults to pulse dialing. You may modify
417: * the dial string below to explicitly default all
418: * dialing to pulse or tone, but doing so prevents
419: * the use of phone numbers that you may have stored
420: * in the modem's memory.
421: */
422: {
423: 30, /* dial_time */
424: "=W", /* pause_chars */ /* =: second tone; W: 5 secs */
425: 15, /* pause_time */ /* worst case */
426: "\002", /* wake_str */ /* allow stored number usage */
427: 0, /* wake_rate */
428: "", /* wake_prompt */
429: "", /* dmode_str */
430: NULL, /* dmode_prompt */
431: "%s!", /* dial_str */
432: 0 /* dial_rate */
433: };
434:
435: static
436: MDMINF GDC = /* information for "GeneralDataComm 212A/ED" modem */
437: {
438: 32, /* dial_time */
439: "%", /* pause_chars */
440: 3, /* pause_time */
441: "\015\015", /* wake_str */
442: 500, /* wake_rate */
443: "$", /* wake_prompt */
444: "D\015", /* dmode_str */
445: ":", /* dmode_prompt */
446: "T%s\015", /* dial_str */
447: 0 /* dial_rate */
448: };
449:
450: static
451: MDMINF HAYES = /* information for "Hayes" modem */
452: {
453: 35, /* dial_time */
454: ",", /* pause_chars */
455: 2, /* pause_time */
456: "AT\015", /* wake_str */
457: /*
458: Note: Other wake_str's are possible here. For Hayes 2400 that is to
459: be used for both in and out calls, AT&F&D3 might be best. For out calls
460: only, maybe AT&F&D2. See Hayes 2400 manual.
461: */
462: 0, /* wake_rate */
463: "", /* wake_prompt */
464: "", /* dmode_str */
465: "", /* dmode_prompt */
466: "ATD%s\015", /* dial_str, note: user can supply D or T */
467: 0 /* dial_rate */
468: };
469:
470: static
471: MDMINF PENRIL = /* information for "Penril" modem */
472: {
473: 50, /* dial_time */
474: "", /* pause_chars */ /** unknown -- HF **/
475: 0, /* pause_time */
476: "\015\015", /* wake_str */
477: 300, /* wake_rate */
478: ">", /* wake_prompt */
479: "k\015", /* dmode_str */
480: ":", /* dmode_prompt */
481: "%s\015", /* dial_str */
482: 0 /* dial_rate */
483: };
484:
485: static
486: MDMINF RACAL = /* information for "Racal Vadic" modem */
487: {
488: 35, /* dial_time */
489: "Kk", /* pause_chars */
490: 5, /* pause_time */
491: "\005\015", /* wake_str */
492: 50, /* wake_rate */
493: "*", /* wake_prompt */
494: "D\015", /* dmode_str */
495: "?", /* dmode_prompt */
496: "%s\015", /* dial_str */
497: 0 /* dial_rate */
498: };
499:
500: static
501: MDMINF UNKNOWN = /* information for "Unknown" modem */
502: {
503: 30, /* dial_time */
504: "", /* pause_chars */
505: 0, /* pause_time */
506: "", /* wake_str */
507: 0, /* wake_rate */
508: "", /* wake_prompt */
509: "", /* dmode_str */
510: NULL, /* dmode_prompt */
511: "%s\015", /* dial_str */
512: 0 /* dial_rate */
513: };
514:
515: static
516: MDMINF USROBOT = /* information for "US Robotics 212A" modem */
517: {
518: 30, /* dial_time */
519: ",", /* pause_chars */
520: 2, /* pause_time */
521: "ATS2=01\015", /* wake_str */
522: 0, /* wake_rate */
523: "OK\015", /* wake_prompt */
524: "", /* dmode_str */
525: NULL, /* dmode_prompt */
526: "ATTD%s\015", /* dial_str */
527: 0 /* dial_rate */
528: };
529: #ifdef COMMENT
530: /* Reportedly this does not work at all. */
531: static
532: MDMINF VENTEL = /* information for "Ventel" modem */
533: {
534: 20, /* dial_time */
535: "%", /* pause_chars */
536: 5, /* pause_time */
537: "\015\015\015", /* wake_str */
538: 300, /* wake_rate */
539: "$", /* wake_prompt */
540: "", /* dmode_str */
541: NULL, /* dmode_prompt */
542: "<K\015%s\015>", /* dial_str (was "<K%s\r>") */
543: 0 /* dial_rate */
544: };
545: #else
546: /* and this does. */
547: static
548: MDMINF VENTEL = /* information for "Ventel" modem */
549: {
550: 20, /* dial_time */
551: "%", /* pause_chars */
552: 5, /* pause_time */
553: "\015\015\015", /* wake_str */
554: 300, /* wake_rate */
555: "$", /* wake_prompt */
556: "K\015", /* dmode_str (was "") */
557: "Number to call: ", /* dmode_prompt (was NULL) */
558: "%s\015", /* dial_str (was "<K%s\r>") */
559: 0 /* dial_rate */
560: };
561: #endif /* COMMENT */
562:
563: static
564: MDMINF CONCORD = /* Info for Condor CDS 220 2400b modem */
565: {
566: 35, /* dial_time */
567: ",", /* pause_chars */
568: 2, /* pause_time */
569: "\015\015", /* wake_str */
570: 20, /* wake_rate */
571: "CDS >", /* wake_prompt */
572: "", /* dmode_str */
573: NULL, /* dmode_prompt */
574: "<D M%s\015>", /* dial_str */
575: 0 /* dial_rate */
576: };
577:
578: static
579: MDMINF ATTUPC = /* dummy information for "ATT7300/Unix PC" internal modem */
580: {
581: 30, /* dial_time */
582: "", /* pause_chars */
583: 0, /* pause_time */
584: "", /* wake_str */
585: 0, /* wake_rate */
586: "", /* wake_prompt */
587: "", /* dmode_str */
588: NULL, /* dmode_prompt */
589: "%s\015", /* dial_str */
590: 0 /* dial_rate */
591: };
592:
593: static
594: MDMINF ROLM = /* IBM / Siemens / Rolm 8000, 9000, 9751 CBX */
595: {
596: 60, /* dial_time */
597: "", /* pause_chars */
598: 0, /* pause_time */
599: "\015\015", /* wake_str */
600: 5, /* wake_rate */
601: "MODIFY?", /* wake_prompt */
602: "", /* dmode_str */
603: "", /* dmode_prompt */
604: "CALL %s\015", /* dial_str */
605: 0 /* dial_rate */
606: };
607:
608: static
609: MDMINF MICROCOM = /* information for "Microcom" modems in native mode */
610: /* (long answer only) */
611: {
612: 35, /* dial_time */
613: ",!@", /* pause_chars (! and @ aren't pure pauses) */
614: 3, /* pause_time */
615: "\015", /* wake_str */
616: 100, /* wake_rate */
617: "!", /* wake_prompt */
618: "", /* dmode_str */
619: NULL, /* dmode_prompt */
620: "d%s\015", /* dial_str */
621: 0 /* dial_rate */
622: };
623:
624: static
625: MDMINF HST = /* information for Courier HST modem */
626: {
627: 35, /* dial_time */
628: ",", /* pause_chars */
629: 2, /* pause_time */
630: "ATE1Q0S2=43X7&B1&M4\015", /* wake_str */
631: 0, /* wake_rate */
632: "OK\015", /* wake_prompt */
633: "", /* dmode_str */
634: "", /* dmode_prompt */
635: "ATD%s\015", /* dial_str */
636: 0 /* dial_rate */
637: };
638:
639: static
640: MDMINF TELEBIT = /* information for Telebits */
641: {
642: 60, /* dial_time */
643: ",", /* pause_chars */
644: 2, /* pause_time */
645: "AAAAATF1M1Q4X3S2=43\015", /* wake_str */
646: 10, /* wake_rate */
647: "OK\015", /* wake_prompt */
648: "", /* dmode_str */
649: "", /* dmode_prompt */
650: "ATD%s\015", /* dial_str */
651: 80 /* dial_rate */
652: };
653:
654: /*
655: * Declare table for converting modem numbers to information pointers.
656: *
657: * The entries MUST be in ascending order by modem number, without any
658: * "gaps" in the numbers, and starting from one (1).
659: *
660: * This table should NOT include entries for the "variant" modem numbers,
661: * since it is assumed that they share the same information as the normal
662: * value.
663: */
664: static
665: MDMINF *ptrtab[] =
666: {
667: &ATTDTDM,
668: &ATTISN,
669: &ATTMODEM,
670: &CERMETEK,
671: &DF03,
672: &DF100,
673: &DF200,
674: &GDC,
675: &HAYES,
676: &PENRIL,
677: &RACAL,
678: &UNKNOWN,
679: &USROBOT,
680: &VENTEL,
681: &CONCORD,
682: &ATTUPC, /* ATT7300 internal modem, jrd*/
683: &ROLM, /* Rolm CBX, fdc */
684: &MICROCOM,
685: &HST,
686: &TELEBIT
687: };
688:
689: /*
690: * Declare modem names and associated numbers for command parsing,
691: * and also for doing number-to-name translation.
692: *
693: * The entries MUST be in alphabetical order by modem name.
694: */
695: struct keytab mdmtab[] =
696: {
697: "attdtdm", n_ATTDTDM, 0,
698: "attisn", n_ATTISN, 0,
699: "attmodem", n_ATTMODEM, 0,
700: "att7300", n_ATTUPC, 0,
701: "cermetek", n_CERMETEK, 0,
702: "concord", n_CONCORD, 0,
703: "df03-ac", n_DF03, 0,
704: "df100-series", n_DF100, 0,
705: "df200-series", n_DF200, 0,
706: "direct", 0, 0,
707: "gendatacomm", n_GDC, 0,
708: "hayes", n_HAYES, 0,
709: "hst-courier", n_HST, 0,
710: "microcom", n_MICROCOM, 0,
711: "none", 0, 0,
712: "penril", n_PENRIL, 0,
713: "pep-telebit", n_TBPEP, 0,
714: "racalvadic", n_RACAL, 0,
715: "rolm", n_ROLM, 0,
716: "slow-telebit", n_TBS, 0,
717: "telebit", n_TELEBIT, 0,
718: "unknown", n_UNKNOWN, 0,
719: "usrobotics-212a", n_USROBOT, 0,
720: "v32-telebit", n_TB3, 0,
721: "v42-telebit", n_TB4, 0,
722: "ventel", n_VENTEL, 0
723: };
724:
725: int nmdm = (sizeof(mdmtab) / sizeof(struct keytab)); /* number of modems */
726:
727: _PROTOTYP (int dialhup, (void) );
728: _PROTOTYP (int getok, (int) );
729: _PROTOTYP (char * getdws, (int) );
730: _PROTOTYP (static VOID ttslow, (char *s, int millisec) );
731: _PROTOTYP (VOID xcpy, (char *to, char *from, unsigned len) );
732: _PROTOTYP (static VOID waitfor, (char *s) );
733: _PROTOTYP (static VOID dialoc, (char c) );
734: _PROTOTYP (static int didweget, (char *s, char *r) );
735: _PROTOTYP (static VOID spdchg, (long s) );
736:
737: #define DIALING 4 /* for ttpkt parameter */
738: #define CONNECT 5
739:
740: #define CONNECTED 1 /* for completion status */
741: #define FAILED 2
742:
743: static
744: char *F_reason[5] = { /* failure reasons for message */
745: "Unknown", "Timeout", "Interrupt", "Modem", "Initialize" };
746:
747: static int tries = 0;
748: static int mdmecho = 0; /* assume modem does not echo */
749: static int augmdmtyp; /* "augmented" modem type, to handle modem modes */
750:
751: static char *p; /* For command strings & messages */
752:
753: #define LBUFL 100
754: #ifdef DYNAMIC
755: static char *lbuf;
756: #else
757: static char lbuf[LBUFL];
758: #endif /* DYNAMIC */
759:
760: static jmp_buf sjbuf;
761:
762: static SIGTYP (*savalrm)(); /* for saving alarm handler */
763: static SIGTYP (*savint)(); /* for saving interrupt handler */
764:
765: VOID
766: xcpy(to,from,len) /* Copy the given number of bytes */
767: register char *to, *from;
768: register unsigned len; {
769: while (len--) *to++ = *from++;
770: }
771:
772: SIGTYP
773: dialtime(foo) int foo; { /* timer interrupt handler */
774: n1 = F_time;
775: longjmp( sjbuf, F_time );
776: }
777:
778: SIGTYP
779: dialint(foo) int foo; { /* user-interrupt handler */
780: n1 = F_int;
781: longjmp( sjbuf, F_int );
782: }
783:
784: static VOID
785: ttslow(s,millisec) char *s; int millisec; { /* output s-l-o-w-l-y */
786: for (; *s; s++) {
787: ttoc(*s);
788: msleep(millisec);
789: }
790: }
791:
792: /*
793: * Wait for a string of characters.
794: *
795: * The characters are waited for individually, and other characters may
796: * be received "in between". This merely guarantees that the characters
797: * ARE received, and in the order specified.
798: */
799: static VOID
800: waitfor(s) char *s; {
801: CHAR c, x;
802: while ( c = *s++ ) { /* while more characters remain... */
803: do { /* wait for the character */
804: x = ttinc(0) & 0177;
805: debug(F000,"dial waitfor got","",x);
806: if (dialdpy) {
807: if (x != LF) conoc(x);
808: if (x == CR) conoc(LF);
809: }
810: } while ( x != c);
811: }
812: }
813:
814: static int
815: didweget(s,r) char *s, *r; { /* Looks in string s for response r */
816: int lr = (int)strlen(r); /* 0 means not found, 1 means found it */
817: int i;
818: debug(F110,"didweget",r,0);
819: debug(F110," in",s,0);
820: for (i = (int)strlen(s)-lr; i >= 0; i--)
821: if ( s[i] == r[0] ) if ( !strncmp(s+i,r,lr) ) return( 1 );
822: return( 0 );
823: }
824:
825:
826: /* R E S E T -- Reset alarms, etc. on exit. */
827:
828: static VOID
829: reset() {
830: alarm(0);
831: signal(SIGALRM,savalrm); /* restore alarm handler */
832: signal(SIGINT,savint); /* restore interrupt handler */
833: }
834:
835: /*
836: Call this routine when the modem reports that it has connected at a certain
837: speed, giving that speed as the argument. If the connection speed is not
838: the same as Kermit's current communication speed, AND the modem interface
839: speed is not locked (i.e. DIAL SPEED-MATCHING is not ON), then change the
840: device speed to the one given.
841: */
842: static VOID
843: spdchg(s) long s; {
844: int s2;
845: if (!mdmspd) /* If modem interface speed locked, */
846: return; /* don't do this. */
847: if (speed != s) { /* Speeds differ? */
848: s2 = s / 10L; /* Convert to cps expressed as int */
849: if (ttsspd(s2) < 0) { /* Change speed. */
850: printf(" Warning: speed change to %ld failed.\r\n",s);
851: } else {
852: printf(" Speed changed to %ld.\r\n",s);
853: speed = s; /* Update global speed variable */
854: }
855: }
856: }
857:
858: /*
859: Display all characters received from modem dialer through this routine,
860: for consistent handling of carriage returns and linefeeds.
861: */
862:
863: static VOID
864: #ifdef CK_ANSIC
865: dialoc(char c)
866: #else
867: dialoc(c) char c;
868: #endif /* CK_ANSIC */
869: { /* dialoc */ /* Dial Output Character */
870: if (dialdpy) {
871: if (c != LF) conoc(c); /* Don't echo LF */
872: if (c == CR) conoc(LF); /* Echo CR as CRLF */
873: }
874: }
875:
876:
877: /* C K D I A L -- Dial up the remote system */
878:
879: /* Returns 1 if call completed, 0 otherwise */
880:
881: int
882: ckdial(telnbr) char *telnbr; {
883:
884: char c, c2;
885: int waitct, status = 0;
886: char errmsg[50], *erp;
887: MDMINF *pmdminf; /* pointer to modem-specific info */
888: int x, y, m, n;
889: char *s, *pc, *ws;
890:
891: long conspd;
892: char *cptr;
893:
894: mymdmtyp = mdmtyp; /* Make local copy of modem type */
895:
896: if (network) {
897: printf("Sorry, 'dial' not available on network connection\n");
898: return(0);
899: }
900: if (mymdmtyp < 1) {
901: printf("Sorry, you must 'set modem' first\n");
902: return(0);
903: }
904: if (!local) {
905: printf("Sorry, you must 'set line' first\n");
906: return(0);
907: }
908: if (speed < 0L) {
909: printf("Sorry, you must 'set speed' first\n");
910: return(0);
911: }
912: debug(F110,"dial string",telnbr,0);
913:
914: /* Carrier no-wait can be invalidated by ckutio fun and games, jrd */
915: if (ttopen(ttname,&local,mymdmtyp,0) < 0) { /* Open, no carrier wait */
916: erp = errmsg;
917: sprintf(erp,"Sorry, can't open %s",ttname);
918: perror(errmsg);
919: return(0);
920: }
921: pmdminf = ptrtab[(mymdmtyp & 0xff) -1 ]; /* set pointer to modem info */
922: augmdmtyp = mymdmtyp; /* initialize "augmented" modem type */
923: mymdmtyp &= 0xff; /* major modem type */
924:
925: /* interdigit waits for tone dial */
926:
927: if (dialtmo < 1) { /* Automatic computation. */
928: waitct = 1 * (int)strlen(telnbr) ; /* Compute worst case dial time */
929: waitct += pmdminf->dial_time; /* dialtone + completion wait times */
930: for (s = telnbr; *s; s++) { /* add in pause characters time */
931: for (p=pmdminf->pause_chars; *p; p++)
932: if (*s == *p) {
933: waitct += pmdminf->pause_time;
934: break;
935: }
936: }
937: if (augmdmtyp == n_TBPEP || augmdmtyp == n_TBPNV) {
938: waitct += 30; /* Longer connect wait for PEP call */
939: }
940: } else { /* User-specified timeout */
941: waitct = dialtmo;
942: }
943: for (m = 0; m < nmdm; m++) { /* Look up modem type. */
944: if (mdmtab[m].kwval == mymdmtyp) {
945: break;
946: }
947: }
948: printf(" Dialing %s\n",telnbr);
949: printf(" Device=%s, modem=%s, speed=%ld\n",
950: ttname,
951: (m >= nmdm ? "unk" : mdmtab[m].kwd),
952: speed);
953:
954: printf(" The timeout for completing the call is %d seconds.\n",waitct);
955: printf(
956: #ifdef MAC
957: " Type Command-. to cancel the dialing.\n");
958: #else
959: " Type your interrupt character (normally ^C) to cancel the dialing.\n");
960: #endif /* MAC */
961: debug(F111,"ckdial",ttname,(int) (speed / 10L));
962: debug(F101,"ckdial timeout","",waitct);
963:
964: /* Hang up the modem (in case it wasn't "on hook") */
965: /* But only if SET DIAL HANGUP ON... */
966:
967: if (dialhup() < 0) {
968: if (dialhng) {
969: ttclos(0);
970: if (ttopen(ttname,&local,mymdmtyp,0) < 0) {
971: printf("Sorry, Can't hang up tty line\n");
972: printf("Try 'set line %s' again\n",ttname);
973: return(0);
974: }
975: }
976: }
977: if (augmdmtyp == n_ROLM) sleep(1);
978:
979: /* Condition console terminal and communication line */
980:
981: /* Place line into "clocal" dialing state */
982:
983: if (ttpkt(speed,DIALING,parity) < 0) {
984: dialhup(); /* If ttpkt fails do all this... */
985: ttclos(0);
986: if (ttopen(ttname,&local,mymdmtyp,0) < 0) {
987: erp = errmsg;
988: sprintf(erp,"Sorry, can't reopen %s",ttname);
989: perror(errmsg);
990: return(0);
991: } /* And try again. */
992: if (ttpkt(speed,DIALING,parity) < 0) {
993: printf("Sorry, Can't condition communication line\n");
994: printf("Try 'set line %s' again\n",ttname);
995: return(0);
996: }
997: }
998: #ifdef DYNAMIC
999: if (!(lbuf = malloc(LBUFL+1))) { /* Allocate input line buffer */
1000: printf("Sorry, memory buffer can't be allocated\n");
1001: return(0);
1002: }
1003: #endif /* DYNAMIC */
1004: sleep(2); /* Let it finish waking up. */
1005:
1006: /*
1007: Establish jump vector, or handle "failure" jumps.
1008: longjmp() sets global failure reason, n1.
1009: */
1010: if (setjmp(sjbuf)) { /* if a "failure jump" was taken... */
1011: n = n1;
1012: alarm(0); /* disable timeouts */
1013: if (setjmp(sjbuf)) { /* failure while handling failure */
1014: printf ("%s failure while handling failure.\n", F_reason[n1]);
1015: } else { /* first (i.e., non-nested) failure */
1016: signal(SIGALRM, dialtime); /* be sure to catch signals */
1017: #ifdef MAC
1018: signal(SIGINT, dialint);
1019: #else /* MAC */
1020: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
1021: signal(SIGINT, dialint);
1022: #endif /* MAC */
1023: alarm(10); /* be sure to exit this section */
1024: }
1025: switch (n) { /* type of failure */
1026: case F_time: { /* timed out */
1027: printf ("No connection made within the allotted time.\n");
1028: if (mymdmtyp == n_HAYES || mymdmtyp == n_TELEBIT)
1029: ttoc('\015'); /* Send CR to interrupt dialing */
1030: /* some hayes modems don't fail with BUSY on busy lines */
1031: debug(F110,"dial","timeout",0);
1032: break;
1033: }
1034: case F_int: { /* dialing interrupted */
1035: printf ("Dialing interrupted.\n");
1036: debug(F110,"dial","interrupted",0);
1037: if (mymdmtyp == n_HAYES || mymdmtyp == n_TELEBIT)
1038: ttoc('\015'); /* Send CR to interrupt dialing */
1039: break;
1040: }
1041: case F_modem: { /* modem detected a failure */
1042: printf ("Failed (\"");
1043: for (pc = lbuf; *pc; pc++)
1044: if (isprint(*pc))
1045: putchar(*pc); /* display printable reason */
1046: printf ("\").\n");
1047: debug(F110,"dial",lbuf,0);
1048: break;
1049: }
1050: case F_minit: { /* cannot initialize modem */
1051: printf ("Can't initialize modem.\n");
1052: debug(F110,"dial","modem init",0);
1053: break;
1054: }
1055: }
1056: reset(); /* reset alarms, etc. */
1057: dialhup(); /* try to hang up phone. */
1058: #ifdef DYNAMIC
1059: if (lbuf) free(lbuf);
1060: #endif /* DYNAMIC */
1061: return(0); /* exit with failure code */
1062: }
1063:
1064: /* Set timer and interrupt handlers. */
1065:
1066: savalrm = signal(SIGALRM,dialtime); /* Set alarm handler */
1067: #ifdef MAC
1068: savint = signal(SIGINT, dialint);
1069: #else /* MAC */
1070: if ((savint = signal(SIGINT,SIG_IGN)) != SIG_IGN )
1071: signal(SIGINT,dialint); /* Set int handler if not ignored */
1072: #endif /* MAC */
1073: #ifdef COMMENT
1074: x = 10; /* Give modem 10 seconds to wake up */
1075: debug(F101,"ckdial wakeup timout","",x);
1076: x = alarm(x);
1077: debug(F101,"ckdial previous alarm","",x);
1078: #endif /* COMMENT */
1079:
1080: /* Put modem in command mode. */
1081:
1082: switch (augmdmtyp) { /* Send the wakeup string */
1083:
1084: #ifdef ATT7300
1085: case n_ATTUPC: {
1086: /*
1087: For ATT7300/Unix PC's with their special internal modem. Timeout
1088: and user interrupts are enabled during dialing. attdial() is in
1089: file ckutio.c. - jrd
1090: */
1091: _PROTOTYP( int attdial, (char *, long, char *) );
1092: alarm(waitct); /* do alarm properly */
1093: if (attdial(ttname,speed,telnbr)) { /* dial internal modem */
1094: reset(); /* reset alarms, etc. */
1095: if (! quiet) printf(" Call did not complete.");
1096: dialhup(); /* Hangup the call */
1097: #ifdef DYNAMIC
1098: if (lbuf) free(lbuf);
1099: #endif /* DYNAMIC */
1100: return(0); /* return failure */
1101: }
1102: reset(); /* reset alarms, etc. */
1103: ttpkt(speed,CONNECT,parity); /* cancel dialing ioctl */
1104: if (! quiet) {
1105: if (dialdpy) printf("\n");
1106: printf(" Call completed.\07\r\n");
1107: }
1108: #ifdef DYNAMIC
1109: if (lbuf) free(lbuf);
1110: #endif /* DYNAMIC */
1111: return(1); /* no conversation with modem to complete dialing */
1112: }
1113: #endif /* ATT7300 */
1114:
1115: /*
1116: For Hayes modem command language, figure out if modem is giving verbose
1117: or digit result codes.
1118: */
1119: case n_HAYES:
1120: case n_HAYESNV:
1121: ws = dialini ? dialini : HAYES.wake_str;
1122: for (tries = 4; tries > 0; tries--) {
1123: ttslow(ws,pmdminf->wake_rate);
1124: status = getok(4);
1125: if (status > 0) break;
1126: sleep(1); /* Wait before retrying */
1127: }
1128: if (status > 0) break; /* Initialized OK. */
1129: /* modem-initialization failure */
1130: n1 = (status == 0) ? F_minit : F_modem;
1131: longjmp( sjbuf, n1 );
1132:
1133: /*
1134: Telebit support: Trailblazer, T1000, T2500.
1135: C-Kermit global variables 'dialksp', 'flow', 'dialini', 'parity',
1136: and local variable 'augmdmtyp' modify our behavior:
1137:
1138: modulation- and confguration-independent initialization:
1139: S11 DTMF timing (left alone)
1140: S45 remote access (left alone)
1141: S48=1 all 8 bits are significant, 0 only 7 bits
1142: S51=255 set serial port baud rate automatically (no typeahead)
1143: S52=2 go on hook when DTR drops and reset to NV-RAM
1144: S53 DCD/DSR control (left alone)
1145: S54=2 pass BREAK signal to remote modem immediately
1146: S55=0 respond to command escape sequence <sec>+++<sec>
1147: depending upon the value of 'flow':
1148: ==FLO_NONE S58=0 DTE uses no flow control
1149: ==FLO_HARD S58=2 DTE uses hardware (CTS/RTS) flow control
1150: ==FLO_XONX S58=3 DTE uses XON/XOFF flow control
1151: S66 lock interface speed: depends on value of mdmspd variable:
1152: mdmspd == 0 sets S66=1 (lock speed, use flow control)
1153: mdmspd != 0 sets S66=0 (change speed, no flow control)
1154: S68=255 DCE uses whatever flow control DTE uses (specified in S58)
1155: S95=0 MNP: depends on value of dialmnp variable:
1156: dialmnp == 0 sets S95=0 (no MNP)
1157: dialmnp != 0 sets S95=2 (auto MNP)
1158: S110=1 use data compression if remote modem agrees
1159:
1160: SET MODEM TELEBIT
1161: "traditional" configuration (PEP, V.22, V.22bis, 212A, 103):
1162: S50=0 use automatic configuration to answering modem
1163:
1164: SET MODEM PEP-TELEBIT
1165: PEP mode with SET DIAL KERMIT-SPOOF ON
1166: S50=255 use PEP + lock DCE speed to DTE speed
1167: S111=10 Kermit with no parity
1168: S111=11 Kermit with odd parity
1169: S111=12 Kermit with even parity
1170: S111=13 Kermit with mark parity
1171: S111=14 Kermit with space parity
1172: S112=?? set to Kermit's start-of-packet character, stchr
1173:
1174: SET MODEM PEP-TELEBIT with SET DIAL KERMIT-SPOOF OFF
1175: S50=255 use PEP + lock DCE speed to DTE speed
1176: S111=0 use normal PEP inter-modem protocol
1177:
1178: SET MODEM V32-TELEBIT (doesn't work with Trailblazer or T1000)
1179: S50=6 use V.32
1180:
1181: SET MODEM V42-TELEBIT
1182: S50=0 auto speed select
1183: S95=1 MNP reliable mode
1184: S96=1 enable MNP data compression
1185: S97=1 enable LAP-M
1186: S98=3 compression in both directions
1187: S106=1 V.42 detection enable
1188:
1189: SET MODEM SLOW-TELEBIT
1190: S94=1 connect to any speed up to maximum specified by S50
1191: S50=3 connect to Bell 103/212a, V.21, V.22 and V.22bis
1192: */
1193: case n_TELEBIT: /* Telebits... */
1194: case n_TBNV:
1195: case n_TBPEP:
1196: case n_TB3:
1197: case n_TB4:
1198: case n_TBS:
1199: case n_TBPNV:
1200: case n_TB3NV:
1201: case n_TB4NV:
1202: case n_TBSNV: {
1203: int S58,S66,S95,S111,S112; /* Some Telebit register names */
1204: char t25buf[64]; /* Modem command buffer */
1205: /*
1206: If user defined a DIAL INIT-STRING, send that now, otherwise send built-in
1207: Telebit string. Try up to 4 times to get OK or 0 response from modem.
1208: */
1209: ws = dialini ? dialini : TELEBIT.wake_str;
1210: debug(F110,"ckdial telebit init string",ws,0);
1211: for (tries = 4; tries > 0; tries--) {
1212: ttslow(ws,pmdminf->wake_rate);
1213: status = getok(5);
1214: if (status) break;
1215: dialhup(); /* Hang up */
1216: ttflui(); /* Flush input buffer */
1217: }
1218: if (status < 1) {
1219: n1 = F_minit;
1220: longjmp( sjbuf, F_minit ); /* Failed. */
1221: }
1222: if (!dialini) { /* If using built-in init strings */
1223: /* Step 2 */
1224: sprintf(t25buf,
1225: "ATS48=%d S51=255 S52=2 S54=2\015",
1226: parity ? 0 : 1);
1227: s = t25buf;
1228: debug(F110,"ckdial Telebit init step 2",s,0);
1229: for (tries = 4; tries > 0; tries--) {
1230: ttslow(s,pmdminf->wake_rate);
1231: status = getok(5);
1232: if (status) break;
1233: msleep(500);
1234: ttflui();
1235: }
1236: if (status < 1) {
1237: n1 = F_minit;
1238: longjmp( sjbuf, F_minit ); /* Failed. */
1239: }
1240: switch (flow) { /* Flow control */
1241: case FLO_HARD: S58 = 2; break; /* RTX/CTS (hardware) */
1242: default: S58 = 0; break; /* NONE (or other) */
1243: }
1244: if (dialmnp) { /* MNP negotiation */
1245: S95 = 2; /* Enabled (auto) */
1246: } else {
1247: S95 = 0; /* Disabled */
1248: }
1249: S66 = mdmspd ? 0 : 1; /* Interface speed locked? */
1250: msleep(500);
1251: sprintf(t25buf,
1252: "ATS58=%d S55=0 S66=%d S68=255 S95=%d\015",S58,S66,S95);
1253: s = t25buf;
1254: debug(F110,"ckdial Telebit init step 3",s,0);
1255: for (tries = 4; tries > 0; tries--) {
1256: ttslow(s,pmdminf->wake_rate);
1257: status = getok(5);
1258: if (status) break;
1259: msleep(500);
1260: ttflui();
1261: }
1262: if (status < 1) {
1263: n1 = F_minit;
1264: longjmp( sjbuf, F_minit ); /* Failed. */
1265: }
1266: p = "";
1267: s = "";
1268: switch (augmdmtyp) { /* we will auto-config */
1269: case n_TELEBIT: /* 103,212,v22bis modulation */
1270: case n_TBNV:
1271: p = "standard"; /* Automatic speed determination */
1272: s = "ATS50=0 S110=0\015";
1273: break;
1274: case n_TBPEP: /* PEP Protocol */
1275: case n_TBPNV:
1276: if (dialksp) { /* SET DIAL KERMIT-SPOOF ON? */
1277: switch (parity) {
1278: case 'e': S111 = 12; break;
1279: case 'm': S111 = 13; break;
1280: case 'o': S111 = 11; break;
1281: case 's': S111 = 14; break;
1282: default:
1283: case 0: S111 = 10; break;
1284: }
1285: S112 = stchr; /* Start-of-packet character */
1286: sprintf(t25buf,
1287: "ATS50=255 S110=1 S111=%d S112=%d\015",S111,S112);
1288: p = "PEP/Kermit";
1289: s = t25buf;
1290: } else { /* SET DIAL KERMIT-SPOOF OFF */
1291: p = "PEP/No-Kermit";
1292: s = "ATS50=255 S110=1\015"; /* Accept any protocol */
1293: }
1294: debug(F101,"ckdial telebit pep waitct","",waitct);
1295: break;
1296:
1297: case n_TB3: /* Telebit V.32 */
1298: case n_TB3NV:
1299: p = "V.32";
1300: s = "ATS50=6\015";
1301: break;
1302:
1303: case n_TB4: /* Telebit V.42 */
1304: case n_TB4NV:
1305: p = "V.42";
1306: s = "ATS50=0 S95=1 S96=1 S97=1 S98=3 S106=1\015";
1307: break;
1308:
1309: case n_TBS: /* Telebit up to 2400 Baud */
1310: case n_TBSNV:
1311: p = "300/1200/2400 Baud";
1312: s = "ATS94=1 S50=3\015";
1313: break;
1314: }
1315: debug(F111,"ckdial Telebit config",p,speed);
1316: debug(F110,"ckdial Telebit init step 4",s,0);
1317: if (*s) {
1318: for (tries = 4; tries > 0; tries--) {
1319: ttslow(s,pmdminf->wake_rate);
1320: status = getok(5);
1321: if (status) break;
1322: msleep(500);
1323: ttflui();
1324: }
1325: debug(F101,"ckdial telebit init status","",status);
1326: if (status < 1) {
1327: n1 = F_minit;
1328: longjmp(sjbuf, F_minit);
1329: }
1330: }
1331: }
1332: /* Done with Telebit protocols, remove bits from modem type */
1333: /* Except nonverbal bit */
1334: augmdmtyp &= ~(DIAL_PEP|DIAL_V32|DIAL_V42|DIAL_SLO);
1335: debug(F101,"ckdial Telebit augmdmtyp","",augmdmtyp);
1336: break;
1337: }
1338:
1339: case n_MICROCOM: /* interdigit waits for tone dial */
1340: {
1341: jmp_buf savejmp;
1342: alarm(0);
1343: xcpy((char *)savejmp, (char *)sjbuf, sizeof savejmp);
1344: if (setjmp(sjbuf)) {
1345: /* try the autobaud sequence */
1346: xcpy((char *)sjbuf, (char *)savejmp, sizeof savejmp);
1347: alarm(5);
1348: ttslow("44445", MICROCOM.wake_rate);
1349: waitfor(MICROCOM.wake_str);
1350: } else {
1351: alarm(2);
1352: ws = dialini ? dialini : MICROCOM.wake_str;
1353: ttslow(ws, MICROCOM.wake_rate);
1354:
1355: waitfor(ws);
1356: alarm(0);
1357: xcpy((char *)sjbuf, (char *)savejmp, sizeof savejmp);
1358: }
1359: }
1360: break;
1361: case n_ATTDTDM: /* DTDM requires BREAK to wake up */
1362: ttsndb(); /* Send BREAK */
1363: break; /* ttsndb() defined in ckutio.c */
1364:
1365: default: /* place modem into command mode */
1366: ws = dialini ? dialini : pmdminf->wake_str;
1367: debug(F111,"ckdial default, wake string",ws,
1368: pmdminf->wake_rate);
1369: ttslow(ws, pmdminf->wake_rate);
1370: debug(F110,"ckdial default, waiting for wake_prompt",
1371: pmdminf->wake_prompt,0);
1372: savalrm = signal(SIGALRM,dialtime);
1373: alarm(10);
1374: waitfor(pmdminf->wake_prompt);
1375: break;
1376: }
1377: alarm(0); /* turn off alarm */
1378: if (augmdmtyp != n_TELEBIT)
1379: debug(F100,"ckdial got wake prompt","",0);
1380: msleep(500); /* give things settling time */
1381:
1382: /* Enable/disable MNP (Telebit already done above) */
1383:
1384: switch (augmdmtyp) {
1385: case n_HST:
1386: if (dialmnp)
1387: ttslow("AT&K2\015",pmdminf->wake_rate);
1388: else
1389: ttslow("AT&K0\015",pmdminf->wake_rate);
1390: getok(5); /* Get response */
1391: break;
1392: default:
1393: break;
1394: }
1395:
1396: /* Dial the number */
1397: /* put modem into dialing mode */
1398: ttslow(pmdminf->dmode_str, pmdminf->dial_rate);
1399: savalrm = signal(SIGALRM,dialtime);
1400: alarm(10);
1401: if (pmdminf->dmode_prompt) { /* wait for prompt, if any expected */
1402: waitfor(pmdminf->dmode_prompt);
1403: msleep(300);
1404: }
1405: alarm(0); /* turn off alarm on dialing prompts */
1406: ttflui(); /* clear out stuff from waking modem up */
1407:
1408: sprintf(lbuf, pmdminf->dial_str, telnbr); /* form dialing string */
1409: debug(F110,"dialing",lbuf,0);
1410: ttslow(lbuf,pmdminf->dial_rate); /* send dialing string */
1411:
1412: savalrm = signal(SIGALRM,dialtime); /* Time to allow for connecting */
1413: x = alarm(waitct); /* This much time... */
1414: debug(F101,"ckdial old alarm","",x);
1415: debug(F101,"ckdial waitct","",waitct);
1416:
1417: switch (augmdmtyp) {
1418: case n_RACAL: /* acknowledge printout of dialing string */
1419: sleep(3);
1420: ttflui();
1421: ttoc('\015');
1422: break;
1423: case n_VENTEL:
1424: waitfor("\012\012"); /* Ignore the first two strings */
1425: break;
1426: default:
1427: break;
1428: }
1429:
1430: /* Check for connection */
1431:
1432: /*
1433: * I believe we also need to look for carrier in order to determine if a
1434: * connection has been made. In fact, for many we may only want to look for
1435: * the "failure" responses in order to short-circuit the timeout, and let
1436: * carrier be the determination of whether a connection has been made. -- DS
1437: */
1438: status = 0;
1439: strcpy(lbuf,"No Connection"); /* default failure reason */
1440: debug(F101,"dial awaiting response, augmdmtyp","",augmdmtyp);
1441: while (status == 0) {
1442: switch (augmdmtyp) {
1443: default:
1444: for (n = 0; n < LBUFL-1; n++) { /* accumulate response */
1445: lbuf[n] = c2 = (ttinc(0) & 0177);
1446: dialoc(c2);
1447: if ( lbuf[n] == CR || lbuf[n] == LF ) break;
1448: }
1449: lbuf[n] = '\0'; /* Terminate response from modem */
1450: debug(F111,"dial modem response",lbuf,n);
1451: if (n) { /* If one or more characters present */
1452: switch (augmdmtyp) { /* check for modem response message. */
1453: case n_ATTMODEM:
1454: /* Careful - "Connected" / "Not Connected" */
1455: if (didweget(lbuf,"Busy") ||
1456: didweget(lbuf,"Not connected") ||
1457: didweget(lbuf,"Not Connected") ||
1458: didweget(lbuf,"No dial tone") ||
1459: didweget(lbuf,"No Dial Tone") ||
1460: didweget(lbuf,"No answer") ||
1461: didweget(lbuf,"No Answer"))
1462: status = FAILED;
1463: else if (didweget(lbuf,"Answered") ||
1464: didweget(lbuf,"Connected"))
1465: status = CONNECTED;
1466: break;
1467:
1468: case n_ATTISN:
1469: if (didweget(lbuf,"ANSWERED"))
1470: status = CONNECTED;
1471: else if (didweget(lbuf,"BUSY") ||
1472: didweget(lbuf,"DISCONNECT") ||
1473: didweget(lbuf,"NO ANSWER") ||
1474: didweget(lbuf,"WRONG ADDRESS"))
1475: status = FAILED;
1476: break;
1477:
1478: case n_ATTDTDM:
1479: if (didweget(lbuf,"ANSWERED"))
1480: status = CONNECTED;
1481: else if (didweget(lbuf,"BUSY") ||
1482: didweget(lbuf,"CHECK OPTIONS") ||
1483: didweget(lbuf,"DISCONNECTED") ||
1484: didweget(lbuf,"DENIED"))
1485: status = FAILED;
1486: #ifdef DEBUG
1487: #ifdef ATT6300
1488: else if (deblog && didweget(lbuf,"~~"))
1489: status = CONNECTED;
1490: #endif /* ATT6300 */
1491: #endif /* DEBUG */
1492: break;
1493:
1494: case n_CERMETEK:
1495: if (didweget(lbuf,"\016A")) {
1496: status = CONNECTED;
1497: ttslow("\016U 1\015",200); /* make transparent*/
1498: }
1499: break;
1500:
1501: case n_DF100: /* DF100 has short response codes */
1502: if (strcmp(lbuf,"A") == 0)
1503: status = CONNECTED; /* Attached */
1504: else if (strcmp(lbuf,"N") == 0 || /* No Ans or Dialtone */
1505: strcmp(lbuf,"E") == 0 || /* Error */
1506: strcmp(lbuf,"R") == 0) { /* Ready */
1507: status = FAILED;
1508: break;
1509: }
1510: /* otherwise fall thru... */
1511:
1512: case n_DF200:
1513: if (didweget(lbuf,"Attached"))
1514: status = CONNECTED;
1515: /*
1516: * The DF100 will respond with "Attached" even if DTR
1517: * and/or carrier are not present. Another reason to
1518: * (also) wait for carrier?
1519: */
1520: else if (didweget(lbuf,"Busy") ||
1521: didweget(lbuf,"Disconnected") ||
1522: didweget(lbuf,"Error") ||
1523: didweget(lbuf,"No answer") ||
1524: didweget(lbuf,"No dial tone") ||
1525: didweget(lbuf,"Speed:"))
1526: status = FAILED;
1527: /*
1528: * It appears that the "Speed:..." response comes after an
1529: * "Attached" response, so this is never seen. HOWEVER,
1530: * it would be very handy to detect this and temporarily
1531: * reset the speed, since it's a nuisance otherwise.
1532: * If we wait for some more input from the modem, how do
1533: * we know if it's from the remote host or the modem?
1534: * Carrier reportedly doesn't get set until after the
1535: * "Speed:..." response (if any) is sent. Another reason
1536: * to (also) wait for carrier.
1537: */
1538: break;
1539:
1540: case n_GDC:
1541: if (didweget(lbuf,"ON LINE"))
1542: status = CONNECTED;
1543: else if (didweget(lbuf,"NO CONNECT"))
1544: status = FAILED;
1545: break;
1546:
1547: case n_HAYES:
1548: case n_USROBOT:
1549: case n_HST:
1550: case n_TELEBIT:
1551: if (mdmspd) {
1552: s = lbuf;
1553: while (*s != '\0' && *s != 'C') s++;
1554: cptr = (*s == 'C') ? s : NULL;
1555: conspd = 0L;
1556: if ((cptr != NULL) && !strncmp(cptr,"CONNECT ",8)) {
1557: if ((int)strlen(cptr) < 9) /* Just CONNECT, */
1558: conspd = 300L; /* use 300 bps */
1559: else if (isdigit(*(cptr+8))) /* not CONNECT FAST */
1560: conspd = atol(cptr + 8); /* CONNECT nnnn */
1561: if (conspd != speed) {
1562: if ((conspd / 10L) > 0) {
1563: if (ttsspd((int) (conspd / 10L)) < 0) {
1564: printf(" Can't change speed to %lu\r\n",
1565: conspd);
1566: } else {
1567: speed = conspd;
1568: status = CONNECTED;
1569: if ( !quiet )
1570: printf(" Speed changed to %lu\r\n",
1571: conspd);
1572: }
1573: }
1574: } /* Expanded to handle any conceivable speed */
1575: }
1576: }
1577: if (mymdmtyp == n_TELEBIT) {
1578: if (didweget(lbuf,"CONNECT FAST/KERM")) {
1579: status = CONNECTED;
1580: if (!quiet) printf("FAST/KERM ");
1581: break;
1582: }
1583: }
1584: if (didweget(lbuf,"RRING") || didweget(lbuf,"RINGING")) {
1585: status = 0;
1586: } else if (didweget(lbuf,"CONNECT")) {
1587: status = CONNECTED;
1588: } else if (didweget(lbuf,"NO CARRIER") ||
1589: didweget(lbuf,"NO DIALTONE") ||
1590: didweget(lbuf,"NO DIAL TONE") ||
1591: didweget(lbuf,"BUSY") ||
1592: didweget(lbuf,"NO ANSWER") ||
1593: didweget(lbuf,"VOICE") ||
1594: didweget(lbuf,"RING") ||
1595: didweget(lbuf,"ERROR")) {
1596: status = FAILED;
1597: }
1598: break;
1599: case n_PENRIL:
1600: if (didweget(lbuf,"OK"))
1601: status = CONNECTED;
1602: else if (didweget(lbuf,"BUSY") ||
1603: didweget(lbuf,"NO RING"))
1604: status = FAILED;
1605: break;
1606: case n_RACAL:
1607: if (didweget(lbuf,"ON LINE"))
1608: status = CONNECTED;
1609: else if (didweget(lbuf,"FAILED CALL"))
1610: status = FAILED;
1611: break;
1612: case n_ROLM:
1613: if (didweget(lbuf,"CALLING"))
1614: status = 0;
1615: else if (didweget(lbuf,"COMPLETE"))
1616: status = CONNECTED;
1617: else if (didweget(lbuf,"FAILED") ||
1618: didweget(lbuf,"NOT AVAILABLE") ||
1619: didweget(lbuf,"LACKS PERMISSION") ||
1620: didweget(lbuf,"NOT A DATALINE") ||
1621: didweget(lbuf,"BUSY") ||
1622: didweget(lbuf,"ABANDONDED") ||
1623: didweget(lbuf,"DOES NOT ANSWER"))
1624: status = FAILED;
1625: /*
1626: Early versions of the Rolm 9751 CBX software do not
1627: give a CALL COMPLETE indication when dialing an
1628: outpool number, but they do seem to return a long
1629: string of DELs at that point. (this doesn't really
1630: work...)
1631: else if (didweget(lbuf,"\177\177\177"))
1632: status = CONNECTED;
1633: */
1634: break;
1635: case n_VENTEL:
1636: if (didweget(lbuf,"ONLINE!") ||
1637: didweget(lbuf,"Online!"))
1638: status = CONNECTED;
1639: else if (didweget(lbuf,"BUSY") ||
1640: didweget(lbuf,"DEAD PHONE") ||
1641: didweget(lbuf,"Busy"))
1642: status = FAILED;
1643: break;
1644: case n_CONCORD:
1645: if (didweget(lbuf,"INITIATING"))
1646: status = CONNECTED;
1647: else if (didweget(lbuf,"BUSY") ||
1648: didweget(lbuf,"CALL FAILED"))
1649: status = FAILED;
1650: break;
1651: case n_MICROCOM:
1652: /* "RINGBACK" means phone line ringing, continue */
1653: if (didweget(lbuf,"NO CONNECT") ||
1654: didweget(lbuf,"BUSY") ||
1655: didweget(lbuf,"NO DIALTONE") ||
1656: didweget(lbuf,"COMMAND ERROR") ||
1657: didweget(lbuf,"IN USE"))
1658: status = FAILED;
1659: else if (didweget(lbuf,"CONNECT"))
1660: status = CONNECTED;
1661: /* trailing speed ignored */
1662: break;
1663: }
1664: }
1665: break;
1666:
1667: case n_DF03: /* because response lacks CR or NL */
1668: c = ttinc(0) & 0177;
1669: dialoc(c);
1670: debug(F000,"dial df03 got","",c);
1671: if ( c == 'A' ) status = CONNECTED;
1672: if ( c == 'B' ) status = FAILED;
1673: break;
1674:
1675: case n_HAYESNV: /* Hayeslike modems in digit */
1676: case n_TBNV: /* response mode... */
1677: case n_TB3NV:
1678: case n_TBPNV:
1679: case n_TB4NV:
1680: case n_TBSNV:
1681: /*
1682: The method for reading Hayes numeric result codes has been totally
1683: redone as of 5A(174) to account for all of the following. Not all have
1684: been tested, and others probably need to be added.
1685:
1686: Hayes numeric result codes (Hayes 1200 and higher):
1687: 0 = OK
1688: 1 = CONNECT at 300 bps (or 1200 bps on Hayes 1200 with basic code set)
1689: 2 = RING
1690: 3 = NO CARRIER
1691: 4 = ERROR (in command line)
1692: 5 = CONNECT 1200 (extended code set)
1693: Hayes 2400 and higher:
1694: 6 = NO DIALTONE
1695: 7 = BUSY
1696: 8 = NO ANSWER
1697: 9 = (there is no 9)
1698: 10 = CONNECT 2400
1699: Reportedly, the codes for Hayes V.32 modems are:
1700: 1x = CONNECT <suffix>
1701: 5x = CONNECT 1200 <suffix>
1702: 9x = CONNECT 2400 <suffix>
1703: 11x = CONNECT 4800 <suffix>
1704: 12x = CONNECT 9600 <suffix>
1705: Where:
1706: x: suffix:
1707: R = RELIABLE
1708: RC = RELIABLE COMPRESSED
1709: L = LAPM
1710: LC = LAPM COMPRESSED
1711: And for Telebits:
1712: 50 = CONNECT FAST
1713: 52 = RRING
1714: What else?
1715: */
1716: { /* Nonverbal response code handler */
1717: char nbuf[8]; /* Response buffer */
1718: int i, j; /* Buffer pointers */
1719: if (mdmecho) { /* Sponge up dialing string echo. */
1720: while ((c = (ttinc(0) & 0177)) != CR)
1721: dialoc(c);
1722: }
1723: while (status == 0) { /* Read response */
1724: for (i = 0; i < 8; i++) /* Clear the buffer */
1725: nbuf[i] = '\0';
1726: i = 0; /* Reset the buffer pointer. */
1727: c = ttinc(0) & 0177; /* Get first digit of response. */
1728: /* using an untimed, blocking read. */
1729: dialoc(c); /* Echo it if requested. */
1730: if (!isdigit(c)) /* If not a digit, keep looking. */
1731: continue;
1732: nbuf[i++] = c; /* Got a digit, save it. */
1733: while (i < 8) { /* Keep reading till we time out */
1734: y = alarm(0) - 1; /* Save current alarm */
1735: x = ttinc(1); /* Read char with 1-sec timeout */
1736: if (y > 0) alarm(y); /* Restore alarm */
1737: if (x > 0) { /* If we didn't time out, */
1738: c = (char) x; /* we got this character. */
1739: if (c != CR) /* Save it, */
1740: nbuf[i++] = c; /* if it's not a carriage return. */
1741: dialoc(c); /* Echo it. */
1742: } else break; /* Otherwise assume end of response. */
1743: }
1744: nbuf[i] = '\0'; /* Terminate the buffer. */
1745: debug(F111,"dial hayesnv lbuf",lbuf,n);
1746: debug(F111,"dial hayesnv got",nbuf,i);
1747: /*
1748: Separate any non-numeric suffix from the numeric result code
1749: with a null.
1750: */
1751: for (j = i-1; (j > -1) && !isdigit(nbuf[j]); j--)
1752: nbuf[j+1] = nbuf[j];
1753: j++;
1754: nbuf[j++] = '\0';
1755: debug(F110,"dial hayesnv numeric",nbuf,0);
1756: debug(F111,"dial hayesnv suffix ",nbuf+j,j);
1757: if ((int)strlen(nbuf) > 3) /* Probably phone number echoing. */
1758: continue;
1759: /*
1760: Now read and interpret the results...
1761: */
1762: i = atoi(nbuf); /* Convert to integer */
1763: switch (i) {
1764: case 1: /* CONNECT */
1765: status = CONNECTED; /* Could be any speed */
1766: break;
1767: case 2: /* RING */
1768: if (dialdpy) printf("\r\n Local phone is ringing!\r\n");
1769: status = FAILED;
1770: break;
1771: case 3: /* NO CARRIER */
1772: if (dialdpy) printf("\r\n No Carrier.\r\n");
1773: status = FAILED;
1774: break;
1775: case 4: /* ERROR */
1776: if (dialdpy) printf("\r\n Modem Command Error.\r\n");
1777: status = FAILED;
1778: break;
1779: case 5: /* CONNECT 1200 */
1780: spdchg(1200L); /* Change speed if necessary. */
1781: status = CONNECTED;
1782: break;
1783: case 6: /* NO DIALTONE */
1784: if (dialdpy) printf("\r\n No Dialtone.\r\n");
1785: status = FAILED;
1786: break;
1787: case 7: /* BUSY */
1788: if (dialdpy) printf("\r\n Busy.\r\n");
1789: status = FAILED;
1790: break;
1791: case 8: /* NO ANSWER */
1792: if (dialdpy) printf("\r\n No Answer.\r\n");
1793: status = FAILED;
1794: break;
1795: case 9: /* CONNECT 2400 */
1796: case 10:
1797: spdchg(2400L); /* Change speed if necessary. */
1798: status = CONNECTED;
1799: break;
1800: case 11: /* CONNECT 4800 */
1801: spdchg(4800L);
1802: status = CONNECTED;
1803: break;
1804: case 12: /* CONNECT 9600 */
1805: spdchg(9600L);
1806: status = CONNECTED;
1807: break;
1808: case 52: /* RRING */
1809: debug(F101,"dial hayesnv 52 mymdmtyp","",mymdmtyp);
1810: debug(F101,"dial hayesnv 52 n_TELEBIT","",n_TELEBIT);
1811: if (mymdmtyp == n_TELEBIT)
1812: if (dialdpy) printf(" Ringing...\r\n");
1813: break;
1814: case 50: /* CONNECT FAST */
1815: if (mymdmtyp == n_TELEBIT)
1816: status = CONNECTED; /* CONNECT FAST */
1817: break;
1818: default:
1819: break;
1820: }
1821: }
1822: if (status == CONNECTED && nbuf[j] != '\0') {
1823: if (dialdpy) {
1824: printf("\r\n");
1825: if (nbuf[j] == 'R') printf("RELIABLE");
1826: if (nbuf[j] == 'L') printf("LAPM");
1827: if (nbuf[j+1] == 'C') printf(" COMPRESSED");
1828: printf("\r\n");
1829: }
1830: }
1831: }
1832: break;
1833:
1834: case n_UNKNOWN: {
1835: int x, y = waitct;
1836: while (y-- > -1) {
1837: x = ttchk();
1838: if (x > 0) {
1839: if (x > LBUFL) x = LBUFL;
1840: x = ttxin(x,(CHAR *)lbuf);
1841: if ((x > 0) && dialdpy) conol(lbuf);
1842: }
1843: x = ttgmdm(); /* Try to read modem signals */
1844: if (x < 0) break; /* Can't, pretend we suceeded */
1845: if (x & BM_DCD) /* Got signals OK. Carrier present? */
1846: break; /* Yes, done. */
1847: sleep(1);
1848: }
1849: status = CONNECTED;
1850: break;
1851: }
1852: } /* switch (augmdmtyp) */
1853: } /* while status == 0 */
1854: x = alarm(0); /* turn off alarm on connecting */
1855: debug(F101,"ckdial alarm off","",x);
1856: if ( status != CONNECTED ) { /* modem-detected failure */
1857: n1 = F_modem;
1858: longjmp( sjbuf, F_modem ); /* exit (with reason in lbuf) */
1859: }
1860: msleep(1000); /* in case DTR blinks */
1861: alarm(3); /* precaution in case of trouble */
1862: debug(F110,"dial","succeeded",0);
1863: if (augmdmtyp != n_ROLM) /* Rolm has wierd modem signaling */
1864: ttpkt(speed,CONNECT,parity); /* cancel dialing state ioctl */
1865: reset(); /* reset alarms, etc. */
1866: if (!quiet)
1867: printf (" Call completed.\07\n");
1868: #ifdef DYNAMIC
1869: if (lbuf) free(lbuf);
1870: #endif /* DYNAMIC */
1871: return(1); /* return, and presumably connect */
1872: }
1873:
1874: /*
1875: getok - wait up to n seconds for "OK<CRLF>" or "<CR>0" from modem.
1876: Use with Hayeslike modems for reading reply to a nondialing command.
1877: Does its own internal timeout handling, but resets alarms to 0.
1878: Returns 0 if it timed out, 1 if it succeeded, -1 on modem command error.
1879: */
1880: static jmp_buf okbuf; /* Jump-buf for getok(). */
1881:
1882: SIGTYP
1883: oktimo(foo) int foo; { /* Alarm handler for getok(). */
1884: longjmp(okbuf,1);
1885: }
1886:
1887: int
1888: getok(n) int n; {
1889: CHAR c;
1890: int i, x, status;
1891: char rbuf[8]; /* response buffer */
1892: SIGTYP (*saval)(); /* for saving alarm handler locally */
1893:
1894: saval = signal(SIGALRM,oktimo); /* set timer */
1895: alarm(n);
1896: if (setjmp(okbuf)) { /* handle timeout */
1897: alarm(0);
1898: if (saval) signal(SIGALRM,saval);
1899: debug(F100,"getok timed out","",0);
1900: ttflui();
1901: return(0);
1902: } else { /* not timed out... */
1903: status = 0;
1904: rbuf[7] = '\0'; /* Terminate response buffer */
1905: while (status == 0) {
1906: x = ttinc(0); /* Read a character */
1907: if (x < 0) return(-1); /* i/o error */
1908: debug(F101,"getok ttinc returns","",x);
1909: c = x & 0x7f; /* Get low order 7 bits */
1910: debug(F101,"getok converts this to char","",c);
1911: if (dialdpy) conoc((char)c); /* Echo it if requested */
1912: for (i = 0; i < 6; i++) /* Rotate buffer */
1913: rbuf[i] = rbuf[i+1];
1914: rbuf[6] = c; /* Deposit character */
1915: debug(F000,"getok",rbuf,(int) c); /* Log it */
1916: switch (c) { /* Interpret it. */
1917: case CR: /* Got carriage return. */
1918: if (augmdmtyp & DIAL_NV) /* If using digit result codes */
1919: conoc(LF); /* echo a linefeed too. */
1920: break;
1921: case LF: /* Got linefeed. */
1922: /*
1923: Note use of explicit octal codes in the string for
1924: CR and LF. We want real CR and LF here, not whatever
1925: the compiler happens to define \r and \n as...
1926: */
1927: if (!strcmp(rbuf+3,"OK\015\012"))
1928: status = 1;
1929: else if (!strcmp(rbuf,"ERROR\015\012"))
1930: status = -1;
1931: augmdmtyp &= ~(DIAL_NV); /* Turn off the nonverbal bit */
1932: break;
1933: /* Check whether modem echoes its commands... */
1934: case 't': /* Got little t */
1935: if (!strcmp(rbuf+4,"\015at")) mdmecho = 1;
1936: break;
1937: case 'T': /* Got Big T */
1938: if (!strcmp(rbuf+4,"\015AT")) mdmecho = 1;
1939: break;
1940: case '0': /* Got 0: Numeric result code? */
1941: if (rbuf[5] == CR) { /* Yes if previous char was CR. */
1942: augmdmtyp |= DIAL_NV; /* OR in the "nonverbal" bit. */
1943: status = 1;
1944: }
1945: break;
1946: case '4': /* Command line error */
1947: if (rbuf[5] == CR) /* if previous char was CR */
1948: status = -1;
1949: break;
1950: default: /* Other characters, accumulate. */
1951: status = 0;
1952: break;
1953: }
1954: }
1955: debug(F101,"getok returns","",status);
1956: alarm(0);
1957: if (saval) signal(SIGALRM,saval);
1958: ttflui();
1959: return(status);
1960: }
1961: }
1962:
1963: /* Maybe hang up the phone, depending on various SET DIAL parameters. */
1964:
1965: int
1966: dialhup() {
1967: int x = 0;
1968: if (dialhng) { /* DIAL HANGUP ON? */
1969: x = tthang();
1970: if (dialdpy) { /* DIAL DISPLAY ON? */
1971: if (x > 0) /* Yes, tell results from tthang() */
1972: printf(" Hangup ok\r\n");
1973: else if (x == 0)
1974: printf(" Hangup skipped\r\n");
1975: else
1976: perror(" Hangup error");
1977: }
1978: } else if (dialdpy) printf(" No hangup\r\n"); /* DIAL HANGUP OFF */
1979: return(x);
1980: }
1981:
1982: char * /* Let external routines ask */
1983: getdws(mdmtyp) int mdmtyp; { /* about dial wake string. */
1984: MDMINF * pmdminf;
1985: if (mdmtyp < 1 || mdmtyp > MAX_MDM) return("");
1986: pmdminf = ptrtab[(mdmtyp & 0xff) -1 ];
1987: return(dialini ? dialini : pmdminf->wake_str);
1988: }
1989:
1990: #else
1991: char *dialv = "Dial Command Disabled";
1992: #endif /* NODIAL */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.