![[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 / ckermit|
Return to ckudia.c CVS log | Up to [MW Coherent from dump] / coherent / e / bin / ckermit |
1.1 root 1: #ifndef NODIAL
2: char *dialv = "Dial Command, 5A(046) 2 Nov 92";
3:
4: /* C K U D I A -- Module for automatic modem dialing. */
5:
6: /*
7: Copyright (C) 1985, 1992, Trustees of Columbia University in the City of New
8: York. Permission is granted to any individual or institution to use this
9: software as long as it is not sold for profit. This copyright notice must be
10: retained. This software may not be included in commercial products without
11: written permission of Columbia University.
12:
13: Original (version 1, 1985) author: Herm Fischer, Encino, CA.
14: Contributed to Columbia University in 1985 for inclusion in C-Kermit 4.0.
15: Author and maintainer since 1985: Frank da Cruz, Columbia University,
16: [email protected].
17:
18: Contributions by many others throughout the years, including: Fernando
19: Cabral, John Chmielewski, Joe Doupnik, Richard Hill, Larry Jacobs, Eric
20: Jones, Tom Kloos, Bob Larson, Peter Mauzey, Joe Orost, Kevin O'Gorman, Kai
21: Uwe Rommel, Dan Schullman, Warren Tucker, and others too numerous to list
22: here (but see acknowledgements in ckcmai.c).
23:
24: This module calls externally defined system-dependent functions for
25: communications i/o, as defined in CKCPLM.DOC, the C-Kermit Program Logic
26: Manual, and thus should be portable to all systems that implement those
27: functions, and where alarm() and signal() work as they do in UNIX.
28: */
29:
30: /*
31: To add support for another modem, do the following, all in this module:
32:
33: 1. Define a modem-type number symbol (n_XXX) for it.
34:
35: 2. Adjust MAX_MDM to the new number of modem types.
36:
37: 3. Create a MDMINF structure for it.
38:
39: 4. Add the address of the MDMINF structure to the ptrtab[] array,
40: according to the numerical value of the modem-type number.
41:
42: 5. Add the user-visible (SET MODEM) name and corresponding modem
43: number to the mdmtab[] array, in alphabetical order by modem-name string.
44:
45: 6. Read through the code and add modem-specific sections as necessary.
46:
47: NOTE: The MINIDIAL symbol is used to build this module to include support
48: for only a minimum number of standard and/or generally useful modem types,
49: namely Hayes, CCITT V.25bis, "Unknown", and None. When adding support for
50: a new modem type, keep it outside of the MINIDIAL sections.
51: */
52:
53: #include "ckcdeb.h"
54: #ifndef MAC
55: #include <signal.h>
56: #endif /* MAC */
57: #include "ckcasc.h"
58: #include "ckcker.h"
59: #include "ckucmd.h"
60: #include "ckcnet.h"
61:
62: #ifndef ZILOG
63: #include <setjmp.h> /* Longjumps */
64: #else
65: #include <setret.h>
66: #endif /* ZILOG */
67:
68: #ifdef MAC
69: #define signal msignal
70: #define SIGTYP long
71: #define alarm malarm
72: #define SIG_IGN 0
73: #define SIGALRM 1
74: #define SIGINT 2
75: SIGTYP (*msignal(int type, SIGTYP (*func)(int)))(int);
76: #endif /* MAC */
77:
78: int /* SET DIAL parameters */
79: dialhng = 1, /* DIAL HANGUP, default is ON */
80: dialdpy = 0, /* DIAL DISPLAY, default is OFF */
81: mdmspd = 1, /* DIAL SPEED-MATCHING (1 = ON) */
82: dialtmo = 0, /* DIAL TIMEOUT */
83: dialksp = 0, /* DIAL KERMIT-SPOOF */
84: dialmnp = 0, /* DIAL MNP-ENABLE */
85: #ifdef NOMDMHUP
86: dialmhu = 0; /* DIAL MODEM-HANGUP */
87: #else
88: dialmhu = 1; /* DIAL MODEM-HANGUP */
89: #endif /* NOMDMHUP */
90:
91: char *dialdir = NULL; /* DIAL DIRECTORY, default none */
92: char *dialini = NULL; /* DIAL INIT-STRING, default none */
93: char *dialcmd = NULL; /* DIAL DIAL-COMMAND, default none */
94: char *dialnpr = NULL; /* DIAL NUMBER-PREFIX, ditto */
95: FILE * dialfd = NULL; /* File descriptor of dial directory */
96:
97: #ifndef MINIDIAL
98: /*
99: Telebit model codes:
100:
101: ATI Model Numbers Examples
102: --- ------------- --------
103: 123 Telebit in "total Hayes-1200" emulation mode
104: 960 Telebit in Conventional Command (Hayes) mode
105: 961 RA12C IBM PC internal original Trailblazer
106: 962 RA12E External original Trailblazer
107: 963 RM12C Rackmount original Trailblazer
108: 964 T18PC IBM PC internal Trailblazer-Plus (TB+)
109: 965 T18SA, T2SAA, T2SAS External TB+, T1600, T2000, T3000, WB, and later
110: 966 T18RMM Rackmount TB+
111: 967 T2MC IBM PS/2 internal TB+
112: 968 T1000 External T1000
113: 969 ? Qblazer
114: 971 T2500 External T2500
115: 972 T2500 Rackmount T2500
116: */
117:
118: /* Telebit model codes */
119:
120: #define TB_UNK 0 /* Unknown Telebit model */
121: #define TB_BLAZ 1 /* Original TrailBlazer */
122: #define TB_PLUS 2 /* TrailBlazer Plus */
123: #define TB_1000 3 /* T1000 */
124: #define TB_1500 4 /* T1500 */
125: #define TB_1600 5 /* T1600 */
126: #define TB_2000 6 /* T2000 */
127: #define TB_2500 7 /* T2500 */
128: #define TB_3000 8 /* T3000 */
129: #define TB_QBLA 9 /* Qblazer */
130: #define TB_WBLA 10 /* WorldBlazer */
131: #define TB__MAX 10 /* Highest number */
132:
133: char *tb_name[] = { /* Array of model names */
134: "Unknown", /* TB_UNK */
135: "TrailBlazer", /* TB_BLAZ */
136: "TrailBlazer-Plus", /* TB_PLUS */
137: "T1000", /* TB_1000 */
138: "T1500", /* TB_1500 */
139: "T1600", /* TB_1600 */
140: "T2000", /* TB_2000 */
141: "T2500", /* TB_2500 */
142: "T3000", /* TB_3000 */
143: "Qblazer", /* TB_QBLA */
144: "WorldBlazer", /* TB_WBLA */
145: ""
146: };
147: #endif /* MINIDIAL */
148:
149: extern int flow, local, mdmtyp, quiet, backgrd, parity, seslog, network;
150: extern int carrier, duplex;
151: #ifdef NETCONN
152: extern int ttnproto;
153: #endif /* NETCONN */
154: extern CHAR stchr;
155: extern long speed;
156: extern char ttname[], sesfil[];
157:
158: /*
159: * Failure reasons for use with the 'longjmp' exit.
160: */
161: #define F_time 1 /* timeout */
162: #define F_int 2 /* interrupt */
163: #define F_modem 3 /* modem-detected failure */
164: #define F_minit 4 /* cannot initialize modem */
165:
166: static int mymdmtyp; /* Local copy of modem type. */
167: static int n1 = F_time;
168:
169: _PROTOTYP (static int ddinc, (int) );
170: _PROTOTYP (int dialhup, (void) );
171: _PROTOTYP (int getok, (int,int) );
172: _PROTOTYP (char * getdws, (int) );
173: _PROTOTYP (static VOID ttslow, (char *s, int millisec) );
174: _PROTOTYP (VOID xcpy, (char *to, char *from, unsigned len) );
175: _PROTOTYP (static VOID waitfor, (char *s) );
176: _PROTOTYP (static VOID dialoc, (char c) );
177: _PROTOTYP (static int didweget, (char *s, char *r) );
178: _PROTOTYP (static VOID spdchg, (long s) );
179: _PROTOTYP (static VOID tbati3, (int n) );
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: int esc_time; /* guard time on escape sequence (msecs) */
196: char *esc_str; /* escape sequence */
197: char *hup_str; /* hangup string */
198: _PROTOTYP( int (*ok_fn), (int,int) ); /* func to read response string */
199: };
200:
201: /*
202: * Define symbolic modem numbers.
203: *
204: * The numbers MUST correspond to the ordering of entries
205: * within the ptrtab array, and start at one (1).
206: *
207: * It is assumed that there are relatively few of these
208: * values, and that the high(er) bytes of the value may
209: * be used for modem-specific mode information.
210: *
211: * REMEMBER that only the first eight characters of these
212: * names are guaranteed to be unique.
213: */
214:
215: #ifdef MINIDIAL /* Minimum dialer support */
216: /* Only for CCITT, HAYES, and UNK */
217: #define n_CCITT 1
218: #define n_HAYES 2
219: #define n_UNKNOWN 3
220: #define MAX_MDM 3 /* Number of modem types */
221:
222: #else /* Full-blown dialer support */
223:
224: #define n_ATTDTDM 1
225: #define n_ATTISN 2
226: #define n_ATTMODEM 3
227: #define n_CCITT 4
228: #define n_CERMETEK 5
229: #define n_DF03 6
230: #define n_DF100 7
231: #define n_DF200 8
232: #define n_GDC 9
233: #define n_HAYES 10
234: #define n_PENRIL 11
235: #define n_RACAL 12
236: #define n_UNKNOWN 13
237: #define n_USROBOT 14
238: #define n_VENTEL 15
239: #define n_CONCORD 16
240: #define n_ATTUPC 17 /* aka UNIX PC and ATT7300 */
241: #define n_ROLM 18 /* Rolm CBX DCM */
242: #define n_MICROCOM 19
243: #define n_HST 20
244: #define n_TELEBIT 21 /* Telebits of all kinds */
245: #define n_DIGITEL 22 /* Digitel DT-22 (CCITT variant) */
246: #define MAX_MDM 22 /* Number of modem types */
247:
248: #endif /* MINIDIAL */
249:
250: /*
251: * Declare modem "variant" numbers for any of the above for which it is
252: * necessary to note various operational modes, using the second byte
253: * of a modem number.
254: *
255: * It is assumed that such modem modes share the same modem-specific
256: * information (see MDMINF structure) but may differ in some of the actions
257: * that are performed.
258: */
259:
260: /* Warning - this is starting to get kind of hokey... */
261:
262: #define DIAL_NV 256
263: #define n_HAYESNV ( n_HAYES | DIAL_NV )
264:
265: #ifndef MINIDIAL
266: #define DIAL_PEP 512
267: #define DIAL_V32 1024
268: #define DIAL_V42 2048
269: #define DIAL_SLO 4096
270: #define n_TBPEP ( n_TELEBIT | DIAL_PEP )
271: #define n_TB3 ( n_TELEBIT | DIAL_V32 )
272: #define n_TBNV ( n_TELEBIT | DIAL_NV )
273: #define n_TBPNV ( n_TELEBIT | DIAL_NV | DIAL_PEP )
274: #define n_TB3NV ( n_TELEBIT | DIAL_NV | DIAL_V32 )
275: #define n_TB4 ( n_TELEBIT | DIAL_V42 )
276: #define n_TBS ( n_TELEBIT | DIAL_SLO )
277: #define n_TB4NV ( n_TELEBIT | DIAL_NV | DIAL_V42 )
278: #define n_TBSNV ( n_TELEBIT | DIAL_NV | DIAL_SLO )
279: #endif /* MINIDIAL */
280:
281: /*
282: * Declare structures containing modem-specific information.
283: *
284: * REMEMBER that only the first SEVEN characters of these
285: * names are guaranteed to be unique.
286: */
287:
288: #ifndef MINIDIAL
289: static
290: MDMINF ATTISN = /* AT&T ISN Network */
291: {
292: 30, /* Dial time */
293: "", /* Pause characters */
294: 0, /* Pause time */
295: "\015\015\015\015", /* Wake string */
296: 900, /* Wake rate */
297: "DIAL", /* Wake prompt */
298: "", /* dmode_str */
299: "", /* dmode_prompt */
300: "%s\015", /* dial_str */
301: 0, /* dial_rate */
302: 0, /* esc_time */
303: "", /* esc_str */
304: "", /* hup_str */
305: NULL /* ok_fn */
306: };
307:
308: static
309: MDMINF ATTMODEM = /* information for AT&T switched-network modems */
310: /* "Number" following "dial" can include: p's and
311: * t's to indicate pulse or tone (default) dialing,
312: * + for wait for dial tone, , for pause, r for
313: * last number dialed, and, except for 2224B, some
314: * comma-delimited options like o12=y, before number.
315:
316: * "Important" options for the modems:
317: *
318: * All: Except for 2224B, enable option 12 for "transparent
319: * data," o12=y. If a computer port used for both
320: * incoming and outgoing calls is connected to the
321: * modem, disable "enter interactive mode on carriage
322: * return," EICR. The Kermit "dial" command can
323: * function with EIA leads standard, EIAS.
324: *
325: * 2212C: Internal hardware switches at their default
326: * positions (four rockers down away from numbers)
327: * unless EICR is not wanted (rocker down at the 4).
328: * For EIAS, rocker down at the 1.
329: *
330: * 2224B: Front-panel switch position 1 must be up (at the 1,
331: * closed). Disable EICR with position 2 down.
332: * For EIAS, position 4 down.
333: * All switches on the back panel down.
334: *
335: * 2224CEO: All front-panel switches down except either 5 or 6.
336: * Enable interactive flow control with o16=y.
337: * Select normal asynchronous mode with o34=0 (zero).
338: * Disable EICR with position 3 up. For EIAS, 1 up.
339: * Reset the modem after changing switches.
340: *
341: * 2296A: If option 00 (zeros) is present, use o00=0.
342: * Enable interactive flow control with o16=y.
343: * Select normal asynchronous mode with o34=0 (zero).
344: * (available in Microcom Networking version, but
345: * not necessarily other models of the 2296A).
346: * Enable modem-port flow control (if available) with
347: * o42=y. Enable asynchronous operation with o50=y.
348: * Disable EICR with o69=n. For EIAS, o66=n, using
349: * front panel.
350: */
351: {
352: 20, /* dial_time */
353: ",", /* pause_chars */
354: 2, /* pause_time */
355: "+", /* wake_str */
356: 0, /* wake_rate */
357: "", /* wake_prompt */
358: "", /* dmode_str */
359: "", /* dmode_prompt */
360: "at%s\015", /* dial_str */
361: 0, /* dial_rate */
362: 0, /* esc_time */
363: "", /* esc_str */
364: "", /* hup_str */
365: NULL /* ok_fn */
366: };
367:
368: static
369: MDMINF ATTDTDM = /* information for AT&T Digital Terminal Data Module
370: * For dialing: KYBD switch down, others usually up. */
371: {
372: 20, /* dial_time */
373: "", /* pause_chars */
374: 0, /* pause_time */
375: "", /* wake_str */
376: 0, /* wake_rate */
377: "", /* wake_prompt */
378: "", /* dmode_str */
379: "", /* dmode_prompt */
380: "%s\015", /* dial_str */ /* not used */
381: 0, /* dial_rate */
382: 0, /* esc_time */
383: "", /* esc_str */
384: "", /* hup_str */
385: NULL /* ok_fn */
386: };
387: #endif /* MINIDIAL */
388:
389: static
390: MDMINF CCITT = /* CCITT V.25bis autodialer */
391: /*
392: According to V.25bis:
393: . Even parity is required for giving commands to the modem.
394: . Commands might or might not echo.
395: . Responses ("Indications") from the modem are terminated by CR and LF.
396: . Call setup is accomplished by:
397: - DTE raises DTR (V.24 circuit 108) [ttopen() does this]
398: - Modem raises CTS (V.24 circuit 106) [C-Kermit ignores this]
399: - DTE issues a call request command ("CRN")
400: - Modem responds with "VAL" ("command accepted")
401: - If the call is completed:
402: modem responds with "CNX" ("call connected");
403: modem turns CTS (106) OFF;
404: modem turns DSR (107) ON;
405: else:
406: modem responds with "CFI <parameter>" ("call failure indication").
407: . To clear a call, the DTE turns DTR (108) OFF.
408: . There is no mention of the Carrier Detect circuit (109) in the standard.
409: . There is no provision for "escaping back" to the modem's command mode.
410:
411: It is not known whether there exists in real life a pure V.25bis modem.
412: If there is, this code has never been tested on it. See the Digitel entry.
413: */
414: {
415: 40, /* dial_time -- programmable -- */
416: ",:", /* pause_chars -- "," waits for programmable time */
417: /* ":" waits for dial tone */
418: 10, /* pause_time (seconds, just a guess) */
419: "", /* wake_str (none) */
420: 200, /* wake_rate (msec) */
421: "VAL", /* wake_prompt */
422: "", /* dmode_str (none) */
423: "", /* dmode_prompt (none) */
424: "CRN%s\015", /* dial_str */
425: 200, /* dial_rate (msec) */
426: 0, /* No esc_time */
427: "", /* No esc_str */
428: "", /* No hup_str */
429: NULL /* No ok_fn */
430: };
431:
432: #ifndef MINIDIAL /* Don't include the following if -DMINIDIAL ... */
433:
434: static
435: MDMINF CERMETEK = /* Information for "Cermetek Info-Mate 212 A" modem */
436: {
437: 20, /* dial_time */
438: "BbPpTt", /* pause_chars */
439: 0, /* pause_time */ /** unknown -- DS **/
440: " XY\016R\015", /* wake_str */
441: 200, /* wake_rate */
442: "", /* wake_prompt */
443: "", /* dmode_str */
444: NULL, /* dmode_prompt */
445: "\016D '%s'\015", /* dial_str */
446: 200, /* dial_rate */
447: 0, /* esc_time */
448: "", /* esc_str */
449: "", /* hup_str */
450: NULL /* ok_fn */
451: };
452:
453: static
454: MDMINF DF03 = /* information for "DEC DF03-AC" modem */
455: {
456: 27, /* dial_time */
457: "=", /* pause_chars */ /* wait for second dial tone */
458: 15, /* pause_time */
459: "\001\002", /* wake_str */
460: 0, /* wake_rate */
461: "", /* wake_prompt */
462: "", /* dmode_str */
463: NULL, /* dmode_prompt */
464: "%s", /* dial_str */
465: 0, /* dial_rate */
466: 0, /* esc_time */
467: "", /* esc_str */
468: "", /* hup_str */
469: NULL /* ok_fn */
470: };
471:
472: static
473: MDMINF DF100 = /* information for "DEC DF100-series" modem */
474: /*
475: * The telephone "number" can include "P"s and/or "T"s
476: * within it to indicate that subsequent digits are
477: * to be dialed using pulse or tone dialing. The
478: * modem defaults to pulse dialing. You may modify
479: * the dial string below to explicitly default all
480: * dialing to pulse or tone, but doing so prevents
481: * the use of phone numbers that you may have stored
482: * in the modem's memory.
483: */
484: {
485: 30, /* dial_time */
486: "=", /* pause_chars */ /* wait for second dial tone */
487: 15, /* pause_time */
488: "\001", /* wake_str */
489: 0, /* wake_rate */
490: "", /* wake_prompt */
491: "", /* dmode_str */
492: NULL, /* dmode_prompt */
493: "%s#", /* dial_str */
494: 0, /* dial_rate */
495: 0, /* esc_time */
496: "", /* esc_str */
497: "", /* hup_str */
498: NULL /* ok_fn */
499: };
500:
501: static
502: MDMINF DF200 = /* information for "DEC DF200-series" modem */
503: /*
504: * The telephone "number" can include "P"s and/or "T"s
505: * within it to indicate that subsequent digits are
506: * to be dialed using pulse or tone dialing. The
507: * modem defaults to pulse dialing. You may modify
508: * the dial string below to explicitly default all
509: * dialing to pulse or tone, but doing so prevents
510: * the use of phone numbers that you may have stored
511: * in the modem's memory.
512: */
513: {
514: 30, /* dial_time */
515: "=W", /* pause_chars */ /* =: second tone; W: 5 secs */
516: 15, /* pause_time */ /* worst case */
517: "\002", /* wake_str */ /* allow stored number usage */
518: 0, /* wake_rate */
519: "", /* wake_prompt */
520: "", /* dmode_str */
521: NULL, /* dmode_prompt */
522: "%s!", /* dial_str */
523: 0, /* dial_rate */
524: 0, /* esc_time */
525: "", /* esc_str */
526: "", /* hup_str */
527: NULL /* ok_fn */
528: };
529:
530: static
531: MDMINF DIGITEL = /* Digitel DT-22 CCITT variant used in Brazil */
532: /*
533: Attempts to adhere strictly to the V.25bis specification do not produce good
534: results in real life. The modem for which this code was developed: (a)
535: ignores parity; (b) sometimes terminates responses with LF CR instead of CR
536: LF; (c) has a Hayes-like escape sequence; (d) supports a hangup ("HUP")
537: command. Information from Fernando Cabral in Brasilia.
538: */
539: {
540: 40, /* dial_time -- programmable -- */
541: ",:", /* pause_chars -- "," waits for programmable time */
542: /* ":" waits for dial tone */
543: 10, /* pause_time (seconds, just a guess) */
544: "HUP\015", /* wake_str (Not Standard CCITT) */
545: 200, /* wake_rate (msec) */
546: "VAL", /* wake_prompt */
547: "", /* dmode_str (none) */
548: "", /* dmode_prompt (none) */
549: "CRN%s\015", /* dial_str */
550: 200, /* dial_rate (msec) */
551: 1100, /* esc_time (Not Standard CCITT) */
552: "+++", /* esc_str (Not Standard CCITT) */
553: "HUP\015", /* hup_str (Not Standard CCITT) */
554: getok /* ok_fn */
555: };
556:
557: static
558: MDMINF GDC = /* information for "GeneralDataComm 212A/ED" modem */
559: {
560: 32, /* dial_time */
561: "%", /* pause_chars */
562: 3, /* pause_time */
563: "\015\015", /* wake_str */
564: 500, /* wake_rate */
565: "$", /* wake_prompt */
566: "D\015", /* dmode_str */
567: ":", /* dmode_prompt */
568: "T%s\015", /* dial_str */
569: 0, /* dial_rate */
570: 0, /* esc_time */
571: "", /* esc_str */
572: "", /* hup_str */
573: NULL /* ok_fn */
574: };
575: #endif /* MINIDIAL */
576:
577: static
578: MDMINF HAYES = /* Information for Hayes and Hayes-like modems */
579: {
580: 35, /* dial_time */
581: ",", /* pause_chars */
582: 2, /* pause_time */
583: "ATQ0\015", /* wake_str */
584: /*
585: Note: Other wake_str's are possible here. For a Hayes 2400 that is to
586: be used for both in and out calls, AT&F&D3 might be best. For out calls
587: only, maybe AT&F&D2. See Hayes 2400 manual.
588: */
589: 0, /* wake_rate */
590: "", /* wake_prompt */
591: "", /* dmode_str */
592: "", /* dmode_prompt */
593: "ATD%s\015", /* dial_str, note: user can supply D or T */
594: 0, /* dial_rate */
595: 1100, /* esc_time */
596: "+++", /* esc_str */
597: "ATQ0H0\015", /* hup_str */
598: getok /* ok_fn */
599: };
600:
601: #ifndef MINIDIAL
602:
603: static
604: MDMINF PENRIL = /* information for "Penril" modem */
605: {
606: 50, /* dial_time */
607: "", /* pause_chars */ /** unknown -- HF **/
608: 0, /* pause_time */
609: "\015\015", /* wake_str */
610: 300, /* wake_rate */
611: ">", /* wake_prompt */
612: "k\015", /* dmode_str */
613: ":", /* dmode_prompt */
614: "%s\015", /* dial_str */
615: 0, /* dial_rate */
616: 0, /* esc_time */
617: "", /* esc_str */
618: "", /* hup_str */
619: NULL /* ok_fn */
620: };
621:
622: static
623: MDMINF RACAL = /* information for "Racal Vadic" modem, e.g. VA4492E */
624: {
625: 35, /* dial_time (manual says modem is hardwired to 60) */
626: "Kk", /* pause_chars */
627: 5, /* pause_time */
628: "\005\015", /* wake_str, ^E^M */
629: 50, /* wake_rate */
630: "*", /* wake_prompt */
631: "D\015", /* dmode_str */
632: "?", /* dmode_prompt */
633: "%s\015", /* dial_str */
634: 0, /* dial_rate */
635: 1100, /* esc_time */
636: "\003\004", /* esc_str, ^C^D (this actually hangs up) */
637: "\005", /* hup_str, ^E (this goes back to command mode) */
638: NULL /* ok_fn */
639: };
640: #endif /* MINIDIAL */
641:
642: /*
643: The intent of the "unknown" modem is to allow KERMIT to support
644: unknown modems by having the user type the entire autodial sequence
645: (possibly including control characters, etc.) as the "phone number".
646: The protocol and other characteristics of this modem are unknown, with
647: some "reasonable" values being chosen for some of them. The only way to
648: detect if a connection is made is to look for carrier.
649: */
650: static
651: MDMINF UNKNOWN = /* information for "Unknown" modem */
652: {
653: 30, /* dial_time */
654: "", /* pause_chars */
655: 0, /* pause_time */
656: "", /* wake_str */
657: 0, /* wake_rate */
658: "", /* wake_prompt */
659: "", /* dmode_str */
660: NULL, /* dmode_prompt */
661: "%s\015", /* dial_str */
662: 0, /* dial_rate */
663: 0, /* esc_time */
664: "", /* esc_str */
665: "", /* hup_str */
666: NULL /* ok_fn */
667: };
668:
669: #ifndef MINIDIAL
670:
671: static
672: MDMINF USROBOT = /* information for "US Robotics 212A" modem */
673: {
674: 30, /* dial_time */
675: ",", /* pause_chars */
676: 2, /* pause_time */
677: "ATS2=01\015", /* wake_str */
678: 0, /* wake_rate */
679: "OK\015", /* wake_prompt */
680: "", /* dmode_str */
681: NULL, /* dmode_prompt */
682: "ATTD%s\015", /* dial_str */
683: 0, /* dial_rate */
684: 0, /* esc_time */
685: "", /* esc_str */
686: "", /* hup_str */
687: NULL /* ok_fn */
688: };
689:
690: #ifdef COMMENT
691: /* Reportedly this does not work at all. */
692: static
693: MDMINF VENTEL = /* information for "Ventel" modem */
694: {
695: 20, /* dial_time */
696: "%", /* pause_chars */
697: 5, /* pause_time */
698: "\015\015\015", /* wake_str */
699: 300, /* wake_rate */
700: "$", /* wake_prompt */
701: "", /* dmode_str */
702: NULL, /* dmode_prompt */
703: "<K\015%s\015>", /* dial_str (was "<K%s\r>") */
704: 0, /* dial_rate */
705: 0, /* esc_time */
706: "", /* esc_str */
707: "", /* hup_str */
708: NULL /* ok_fn */
709: };
710: #else
711: /* and this does. */
712: static
713: MDMINF VENTEL = /* information for "Ventel" modem */
714: {
715: 20, /* dial_time */
716: "%", /* pause_chars */
717: 5, /* pause_time */
718: "\015\015\015", /* wake_str */
719: 300, /* wake_rate */
720: "$", /* wake_prompt */
721: "K\015", /* dmode_str (was "") */
722: "Number to call: ", /* dmode_prompt (was NULL) */
723: "%s\015", /* dial_str (was "<K%s\r>") */
724: 0, /* dial_rate */
725: 0, /* esc_time */
726: "", /* esc_str */
727: "", /* hup_str */
728: NULL /* ok_fn */
729: };
730: #endif /* COMMENT */
731:
732: static
733: MDMINF CONCORD = /* Info for Condor CDS 220 2400b modem */
734: {
735: 35, /* dial_time */
736: ",", /* pause_chars */
737: 2, /* pause_time */
738: "\015\015", /* wake_str */
739: 20, /* wake_rate */
740: "CDS >", /* wake_prompt */
741: "", /* dmode_str */
742: NULL, /* dmode_prompt */
743: "<D M%s\015>", /* dial_str */
744: 0, /* dial_rate */
745: 0, /* esc_time */
746: "", /* esc_str */
747: "", /* hup_str */
748: NULL /* ok_fn */
749: };
750:
751: static
752: MDMINF ATTUPC = /* dummy information for "ATT7300/Unix PC" internal modem */
753: {
754: 30, /* dial_time */
755: "", /* pause_chars */
756: 0, /* pause_time */
757: "", /* wake_str */
758: 0, /* wake_rate */
759: "", /* wake_prompt */
760: "", /* dmode_str */
761: NULL, /* dmode_prompt */
762: "%s\015", /* dial_str */
763: 0, /* dial_rate */
764: 0, /* esc_time */
765: "", /* esc_str */
766: "", /* hup_str */
767: NULL /* ok_fn */
768: };
769:
770: static
771: MDMINF ROLM = /* IBM / Siemens / Rolm 8000, 9000, 9751 CBX */
772: {
773: 60, /* dial_time */
774: "", /* pause_chars */
775: 0, /* pause_time */
776: "\015\015", /* wake_str */
777: 5, /* wake_rate */
778: "MODIFY?", /* wake_prompt */
779: "", /* dmode_str */
780: "", /* dmode_prompt */
781: "CALL %s\015", /* dial_str */
782: 0, /* dial_rate */
783: 0, /* esc_time */
784: "", /* esc_str */
785: "", /* hup_str */
786: NULL /* ok_fn */
787: };
788:
789: static
790: MDMINF MICROCOM = /* information for "Microcom" modems in native mode */
791: /* (long answer only) */
792: {
793: 35, /* dial_time */
794: ",!@", /* pause_chars (! and @ aren't pure pauses) */
795: 3, /* pause_time */
796: "\015", /* wake_str */
797: 100, /* wake_rate */
798: "!", /* wake_prompt */
799: "", /* dmode_str */
800: NULL, /* dmode_prompt */
801: "d%s\015", /* dial_str */
802: 0, /* dial_rate */
803: 0, /* esc_time */
804: "", /* esc_str */
805: "", /* hup_str */
806: NULL /* ok_fn */
807: };
808:
809: static
810: MDMINF HST = /* information for Courier HST modem */
811: {
812: 35, /* dial_time */
813: ",", /* pause_chars */
814: 2, /* pause_time */
815: "ATQ0S2=43X7&B1&M4\015", /* wake_str */
816: 0, /* wake_rate */
817: "OK\015", /* wake_prompt */
818: "", /* dmode_str */
819: "", /* dmode_prompt */
820: "ATD%s\015", /* dial_str */
821: 0, /* dial_rate */
822: 1100, /* esc_time */
823: "+++", /* esc_str */
824: "ATQ0H0\015", /* hup_str */
825: getok /* ok_fn */
826: };
827:
828: static
829: MDMINF TELEBIT = /* information for Telebits */
830: {
831: 60, /* dial_time */
832: ",", /* pause_chars */
833: 2, /* pause_time */
834: /*
835: NOTE: The wake_string MUST contain the I command (model query), and otherwise
836: must contain commands that work on ALL Telebit models. Here we ensure that
837: result codes are returned (Q0), and ask for extended result codes (X1), and
838: ensure that the escape sequence is +++ and it is enabled. And also, make
839: sure the final character is not a digit (whose echo might be mistaken for a
840: result code). The Ctrl-Q and multiple A's are recommended by Telebit.
841: */
842: "\021AAAATQ0X1S12=50 S2=43 I\015", /* wake_str. */
843: 100, /* wake_rate = 100 msec */
844: "OK\015", /* wake_prompt */
845: "", /* dmode_str */
846: "", /* dmode_prompt */
847: "ATD%s\015", /* dial_str, Note: no T or P */
848: 80, /* dial_rate */
849: 1100, /* esc_time (guard time) */
850: "+++", /* esc_str */
851: "ATQ0H0\015", /* hup_str */
852: getok /* ok_fn */
853: };
854: #endif /* MINIDIAL */
855:
856: /*
857: * Declare table for converting modem numbers to information pointers.
858: *
859: * The entries MUST be in ascending order by modem number, without any
860: * "gaps" in the numbers, and starting from one (1).
861: *
862: * This table should NOT include entries for the "variant" modem numbers,
863: * since they share the same information as the normal value.
864: */
865: static
866: MDMINF *ptrtab[] = {
867: #ifdef MINIDIAL
868: &CCITT,
869: &HAYES,
870: &UNKNOWN
871: #else
872: &ATTDTDM,
873: &ATTISN,
874: &ATTMODEM,
875: &CCITT,
876: &CERMETEK,
877: &DF03,
878: &DF100,
879: &DF200,
880: &GDC,
881: &HAYES,
882: &PENRIL,
883: &RACAL,
884: &UNKNOWN,
885: &USROBOT,
886: &VENTEL,
887: &CONCORD,
888: &ATTUPC,
889: &ROLM,
890: &MICROCOM,
891: &HST,
892: &TELEBIT,
893: &DIGITEL
894: #endif /* MINIDIAL */
895: };
896: /*
897: * Declare modem names and associated numbers for command parsing,
898: * and also for doing number-to-name translation.
899: *
900: * The entries must be in alphabetical order by modem name.
901: */
902: struct keytab mdmtab[] = {
903: #ifndef MINIDIAL
904: "attdtdm", n_ATTDTDM, 0,
905: "attisn", n_ATTISN, 0,
906: "attmodem", n_ATTMODEM, 0,
907: "att7300", n_ATTUPC, 0,
908: #endif /* MINIDIAL */
909: "ccitt-v25bis", n_CCITT, 0,
910: #ifndef MINIDIAL
911: "cermetek", n_CERMETEK, 0,
912: "concord", n_CONCORD, 0,
913: "df03-ac", n_DF03, 0,
914: "df100-series", n_DF100, 0,
915: "df200-series", n_DF200, 0,
916: "digitel-dt22", n_DIGITEL, 0,
917: #endif /* MINIDIAL */
918: "direct", 0, CM_INV, /* Synonym for NONE */
919: #ifndef MINIDIAL
920: "gdc-212a/ed", n_GDC, 0,
921: "gendatacomm", n_GDC, CM_INV, /* Synonym for GDC */
922: #endif /* MINIDIAL */
923: "hayes", n_HAYES, 0,
924: #ifndef MINIDIAL
925: "hst-courier", n_HST, 0,
926: "microcom", n_MICROCOM, 0,
927: #endif /* MINIDIAL */
928: "none", 0, 0,
929: #ifndef MINIDIAL
930: "penril", n_PENRIL, 0,
931: "pep-telebit", n_TBPEP, 0,
932: "racalvadic", n_RACAL, 0,
933: "rolm", n_ROLM, 0,
934: "slow-telebit", n_TBS, 0,
935: "telebit", n_TELEBIT, 0,
936: #endif /* MINIDIAL */
937: "unknown", n_UNKNOWN, 0,
938: #ifndef MINIDIAL
939: "usrobotics-212a", n_USROBOT, 0,
940: "v32-telebit", n_TB3, 0,
941: "v42-telebit", n_TB4, 0,
942: "ventel", n_VENTEL, 0
943: #endif /* MINIDIAL */
944: };
945: int nmdm = (sizeof(mdmtab) / sizeof(struct keytab)); /* Number of modems */
946:
947: #define CONNECTED 1 /* For completion status */
948: #define FAILED 2
949:
950: static
951: char *F_reason[5] = { /* Failure reasons for message */
952: "Unknown", "Timeout", "Interrupt", "Modem", "Initialize" };
953:
954: static int tries = 0;
955: static int mdmecho = 0; /* assume modem does not echo */
956: static int augmdmtyp; /* "augmented" modem type, to handle modem modes */
957:
958: static char *p; /* For command strings & messages */
959:
960: #define LBUFL 100
961: #ifdef DYNAMIC
962: static char *lbuf = NULL;
963: #else
964: static char lbuf[LBUFL];
965: #endif /* DYNAMIC */
966:
967: #define RBUFL 63
968: static char rbuf[RBUFL+1]; /* Modem response buffer */
969:
970: static jmp_buf sjbuf;
971:
972: static SIGTYP (*savalrm)(); /* For saving alarm handler */
973: static SIGTYP (*savint)(); /* For saving interrupt handler */
974:
975: #ifndef MINIDIAL
976: int tbmodel = 0; /* Telebit modem model */
977:
978: char *
979: gtbmodel() { /* Function to return name of Telebit model */
980: if (tbmodel < 0 || tbmodel > TB__MAX) tbmodel = TB_UNK;
981: return(tb_name[tbmodel]);
982: }
983:
984: VOID
985: xcpy(to,from,len) /* Copy the given number of bytes */
986: register char *to, *from;
987: register unsigned len; {
988: while (len--) *to++ = *from++;
989: }
990: #endif /* MINIDIAL */
991:
992: SIGTYP
993: dialtime(foo) int foo; { /* Timer interrupt handler */
994: n1 = F_time; /* Failure reason = timeout */
995:
996: #ifdef __EMX__
997: signal(SIGALRM, SIG_ACK); /* Needed for OS/2 */
998: #endif /* __EMX__ */
999:
1000: #ifdef OSK /* OS-9 */
1001: /*
1002: We are in an intercept routine but do not perform a F$RTE (done implicitly
1003: by RTS), so we have to decrement the sigmask as F$RTE does. Warning:
1004: longjump only restores the CPU registers, NOT the FPU registers. So, don't
1005: use FPU at all or at least don't use common FPU (double or float) register
1006: variables.
1007: */
1008: sigmask(-1);
1009: #endif /* OSK */
1010:
1011: longjmp( sjbuf, F_time );
1012: }
1013:
1014: SIGTYP
1015: dialint(foo) int foo; { /* Keyboard interrupt handler */
1016: n1 = F_int;
1017: #ifdef __EMX__
1018: signal(SIGINT, SIG_ACK); /* Needed for OS/2 */
1019: #endif /* __EMX__ */
1020: #ifdef OSK /* OS-9, see comment in dialtime() */
1021: sigmask(-1);
1022: #endif /* OSK */
1023: longjmp( sjbuf, F_int );
1024: }
1025:
1026: /*
1027: Routine to read a character from communication device, handling TELNET
1028: protocol negotiations in case we're connected to the modem through a
1029: TCP/IP TELNET modem server.
1030: */
1031: static int
1032: ddinc(n) int n; {
1033: int c;
1034:
1035: #ifdef TNCODE
1036: int done = 0;
1037: while (!done) {
1038: c = ttinc(n);
1039: debug(F000,"ddinc","",c);
1040: if (c < 0) return(c);
1041: if (c == IAC && network && ttnproto == NP_TELNET) {
1042: switch (tn_doop((CHAR)(c & 0xff),duplex,ttinc)) {
1043: case 2: duplex = 0; continue;
1044: case 1: duplex = 1;
1045: default: continue;
1046: }
1047: } else done = 1;
1048: }
1049: return(c & 0xff);
1050: #else
1051: return(ttinc(n));
1052: #endif /* TNCODE */
1053: }
1054:
1055: static VOID
1056: ttslow(s,millisec) char *s; int millisec; { /* Output s-l-o-w-l-y */
1057: for (; *s; s++) {
1058: ttoc(*s);
1059: msleep(millisec);
1060: }
1061: }
1062:
1063: /*
1064: * Wait for a string of characters.
1065: *
1066: * The characters are waited for individually, and other characters may
1067: * be received "in between". This merely guarantees that the characters
1068: * ARE received, and in the order specified.
1069: */
1070: static VOID
1071: waitfor(s) char *s; {
1072: CHAR c, x;
1073: while ( c = *s++ ) { /* while more characters remain... */
1074: do { /* wait for the character */
1075: x = ddinc(0) & 0177;
1076: debug(F000,"dial waitfor got","",x);
1077: if (dialdpy) {
1078: if (x != LF) conoc(x);
1079: if (x == CR) conoc(LF);
1080: }
1081: } while ( x != c);
1082: }
1083: }
1084:
1085: static int
1086: didweget(s,r) char *s, *r; { /* Looks in string s for response r */
1087: int lr = (int)strlen(r); /* 0 means not found, 1 means found it */
1088: int i;
1089: debug(F110,"didweget",r,0);
1090: debug(F110," in",s,0);
1091: for (i = (int)strlen(s)-lr; i >= 0; i--)
1092: if ( s[i] == r[0] ) if ( !strncmp(s+i,r,lr) ) return( 1 );
1093: return( 0 );
1094: }
1095:
1096:
1097: /* R E S E T -- Reset alarms, etc. on exit. */
1098:
1099: static VOID
1100: dreset() {
1101: alarm(0);
1102: signal(SIGALRM,savalrm); /* restore alarm handler */
1103: signal(SIGINT,savint); /* restore interrupt handler */
1104: }
1105:
1106: /*
1107: Call this routine when the modem reports that it has connected at a certain
1108: speed, giving that speed as the argument. If the connection speed is not
1109: the same as Kermit's current communication speed, AND the modem interface
1110: speed is not locked (i.e. DIAL SPEED-MATCHING is not ON), then change the
1111: device speed to the one given.
1112: */
1113: static VOID
1114: #ifdef CK_ANSIC
1115: spdchg(long s)
1116: #else
1117: spdchg(s) long s;
1118: #endif /* CK_ANSIC */
1119: /* spdchg */ {
1120: int s2;
1121: if (!mdmspd) /* If modem interface speed locked, */
1122: return; /* don't do this. */
1123: if (speed != s) { /* Speeds differ? */
1124: s2 = s / 10L; /* Convert to cps expressed as int */
1125: if (ttsspd(s2) < 0) { /* Change speed. */
1126: printf(" Warning: speed change to %ld failed.\r\n",s);
1127: } else {
1128: printf(" Speed changed to %ld.\r\n",s);
1129: speed = s; /* Update global speed variable */
1130: }
1131: }
1132: }
1133:
1134: /*
1135: Display all characters received from modem dialer through this routine,
1136: for consistent handling of carriage returns and linefeeds.
1137: */
1138: static VOID
1139: #ifdef CK_ANSIC
1140: dialoc(char c)
1141: #else
1142: dialoc(c) char c;
1143: #endif /* CK_ANSIC */
1144: { /* dialoc */ /* Dial Output Character */
1145: if (dialdpy) {
1146: if (c != LF) conoc(c); /* Don't echo LF */
1147: if (c == CR) conoc(LF); /* Echo CR as CRLF */
1148: }
1149: }
1150:
1151: #ifndef MINIDIAL
1152: /*
1153: tbati3() -- Routine to find out Telebit model when ATI reports "965"
1154: or "971". This routine sends another query, ATI3, to get further info
1155: to narrow down the model number. Argument is ATI response as integer.
1156: Result: sets tbmodel variable to Telebit model.
1157: */
1158: static VOID
1159: tbati3(n) int n; {
1160: int status;
1161: ttflui(); /* Flush input buffer */
1162: ttslow("ATI3\015",100); /* Send ATI3<CR> */
1163: status = getok(5,0); /* Get OK response, nonstrict */
1164: if (status < 1) { /* ERROR or timeout */
1165: tbmodel = TB_UNK;
1166: debug(F111,"tbati3 fails",rbuf,status);
1167: return;
1168: }
1169: debug(F110,"tbati3 rbuf",rbuf,0);
1170:
1171: /* Got a good response, check the model info */
1172:
1173: if (n == 965) { /* "965" - various models. */
1174: if (didweget(rbuf,"T1600")) {
1175: tbmodel = TB_1600; /* T1600 */
1176: } else if (didweget(rbuf,"T3000")) {
1177: tbmodel = TB_3000; /* T3000 */
1178: } else if (didweget(rbuf,"World")) {
1179: tbmodel = TB_WBLA; /* WorldBlazer */
1180: } else if (didweget(rbuf,"Version B") || /* TrailBlazer-Plus models */
1181: didweget(rbuf,"TBSA") ||
1182: didweget(rbuf,"TBRM") ||
1183: didweget(rbuf,"DC")) { /* Ven-Tel EC18K */
1184: tbmodel = TB_PLUS;
1185: } else tbmodel = TB_UNK; /* Others: Unknown */
1186:
1187: } else if (n == 971) { /* "971" could be T1500 or T1600. */
1188: if (didweget(rbuf,"T1500"))
1189: tbmodel = TB_1500;
1190: else tbmodel = TB_2500;
1191: } /* Other, don't change tbmodel. */
1192: }
1193: #endif /* MINIDIAL */
1194:
1195:
1196: /* C K D I A L -- Dial up the remote system */
1197:
1198: /* Returns 1 if call completed, 0 otherwise */
1199:
1200: static int waitct, mdmwait, mdmstat = 0;
1201:
1202: int
1203: ckdial(telnbr) char *telnbr; {
1204:
1205: char c, c2;
1206: char errmsg[50], *erp; /* for error messages */
1207: char fullnum[100]; /* for full (prefixed) phone number */
1208: MDMINF *pmdminf; /* pointer to modem-specific info */
1209: int x, m, n = F_time;
1210: char *s, *pc, *ws;
1211:
1212: long conspd;
1213: char *cptr;
1214:
1215: mymdmtyp = mdmtyp; /* Make local copy of modem type */
1216:
1217: #ifndef MINIDIAL
1218: tbmodel = TB_UNK; /* Initialize Telebit model */
1219: #endif /* MINIDIAL */
1220:
1221: if (mymdmtyp < 1) {
1222: if (network)
1223: printf("Please SET HOST first, and then SET MODEM\n");
1224: else
1225: printf("Sorry, you must SET MODEM first\n");
1226: return(0);
1227: }
1228: if (!local) {
1229: printf("Sorry, you must SET LINE or SET HOST first\n");
1230: return(0);
1231: }
1232: if (!network && speed < 0L) {
1233: printf("Sorry, you must SET SPEED first\n");
1234: return(0);
1235: }
1236: debug(F110,"dial number",telnbr,0);
1237: debug(F110,"dial prefix",(dialnpr ? dialnpr : ""), 0);
1238:
1239: /* Add prefix to phone number */
1240:
1241: if (dialnpr && *dialnpr) {
1242: sprintf(fullnum,"%s%s",(dialnpr ? dialnpr : ""),telnbr);
1243: telnbr = fullnum;
1244: }
1245: debug(F110,"prefixed number", telnbr, 0);
1246:
1247: #ifdef DYNAMIC
1248: if (!(lbuf = malloc(LBUFL+1))) { /* Allocate input line buffer */
1249: printf("Sorry, DIAL memory buffer can't be allocated\n");
1250: return(0);
1251: }
1252: #endif /* DYNAMIC */
1253:
1254: if (ttopen(ttname,&local,mymdmtyp,0) < 0) { /* Open, no carrier wait */
1255: erp = errmsg;
1256: sprintf(erp,"Sorry, can't open %s",ttname);
1257: perror(errmsg);
1258: return(0);
1259: }
1260:
1261: /* Condition console terminal and communication line */
1262:
1263: /* Place line into "clocal" dialing state, */
1264: /* important mainly for System V UNIX. */
1265:
1266: if (ttpkt(speed,FLO_DIAL,parity) < 0) {
1267: ttclos(0); /* If ttpkt fails do all this... */
1268: if (ttopen(ttname,&local,mymdmtyp,0) < 0) {
1269: erp = errmsg;
1270: sprintf(erp,"Sorry, can't reopen %s",ttname);
1271: perror(errmsg);
1272: return(0);
1273: } /* And try again. */
1274: if (ttpkt(speed,FLO_DIAL,parity) < 0) {
1275: printf("Sorry, Can't condition communication line\n");
1276: printf("Try 'set line %s' again\n",ttname);
1277: return(0);
1278: }
1279: }
1280: msleep(500);
1281:
1282: pmdminf = ptrtab[ (mymdmtyp & 0xff) -1 ]; /* set pointer to modem info */
1283: augmdmtyp = mymdmtyp; /* initialize "augmented" modem type */
1284: mymdmtyp &= 0xff; /* major modem type */
1285:
1286: /* Interdigit waits for tone dial */
1287:
1288: if (dialtmo < 1) { /* Automatic computation. */
1289: waitct = 1 * (int)strlen(telnbr) ; /* Compute worst case dial time */
1290: waitct += pmdminf->dial_time; /* dialtone + completion wait times */
1291: for (s = telnbr; *s; s++) { /* add in pause characters time */
1292: for (p=pmdminf->pause_chars; *p; p++)
1293: if (*s == *p) {
1294: waitct += pmdminf->pause_time;
1295: break;
1296: }
1297: }
1298: #ifndef MINIDIAL
1299: if (augmdmtyp == n_TBPEP || augmdmtyp == n_TBPNV) {
1300: waitct += 30; /* Longer connect wait for PEP call */
1301: }
1302: #endif /* MINIDIAL */
1303: } else { /* User-specified timeout */
1304: waitct = dialtmo;
1305: }
1306: /*
1307: waitct is our alarm() timer.
1308: mdmwait is how long we tell the modem to wait for carrier.
1309: We set mdmwait to be 1 second less than waitct, to increase the
1310: chance that we get a response from the modem before timing out.
1311: */
1312: if (waitct < 0) waitct = 0;
1313: mdmwait = (waitct > 5) ? waitct - 5 : waitct;
1314:
1315: for (m = 0; m < nmdm; m++) { /* Look up modem type. */
1316: if (mdmtab[m].kwval == mymdmtyp) {
1317: break;
1318: }
1319: }
1320: if (!quiet && !backgrd) { /* Print information messages. */
1321: printf(" Dialing: %s\n", telnbr);
1322: if (network) {
1323: printf(" Via modem server: %s, modem-dialer: %s\n",
1324: ttname, (m >= nmdm ? "(unknown)" : mdmtab[m].kwd) );
1325: } else {
1326: printf(" Device: %s, modem-dialer: %s",
1327: ttname, (m >= nmdm ? "(unknown)" : mdmtab[m].kwd) );
1328: if (speed > -1L)
1329: printf(", speed: %ld\n", speed);
1330: else
1331: printf(", speed: (unknown)\n", speed);
1332: }
1333: printf(" Dial timeout: %d seconds\n",waitct);
1334: printf(
1335: #ifdef MAC
1336: " Type Command-. to cancel dialing\n"
1337: #else
1338: #ifdef UNIX
1339: " To cancel: type your interrupt character (normally Ctrl-C)\n"
1340: #else
1341: " To cancel: type Ctrl-C\n"
1342: #endif /* UNIX */
1343: #endif /* MAC */
1344: );
1345: }
1346: debug(F111,"ckdial",ttname,(int) (speed / 10L));
1347: debug(F101,"ckdial timeout","",waitct);
1348:
1349: /* Hang up the modem (in case it wasn't "on hook") */
1350: /* But only if SET DIAL HANGUP ON... */
1351:
1352: if (dialhup() < 0) {
1353: debug(F100,"ckdial dialhup failed","",0);
1354: #ifndef MINIDIAL
1355: if (mymdmtyp == n_TELEBIT) /* Telebit might need a BREAK */
1356: ttsndb(); /* first. */
1357: #endif /* MINIDIAL */
1358: if (dialhng) { /* If it failed, */
1359: ttclos(0); /* close and reopen the device. */
1360: if (ttopen(ttname,&local,mymdmtyp,0) < 0) {
1361: printf("Sorry, Can't hang up communication device\n");
1362: printf("Try 'set line %s' again\n",ttname);
1363: return(0);
1364: }
1365: }
1366: }
1367: #ifndef MINIDIAL
1368: if (augmdmtyp == n_ROLM) /* Don't start talking to Rolm */
1369: msleep(500); /* too soon... */
1370: #endif /* MINIDIAL */
1371:
1372: /*
1373: Establish jump vector, or handle "failure" jumps.
1374: longjmp() sets global failure reason, n1.
1375: */
1376: if (setjmp(sjbuf)) { /* if a "failure jump" was taken... */
1377: n = n1;
1378: alarm(0); /* disable timeouts */
1379: if (setjmp(sjbuf)) { /* failure while handling failure */
1380: printf ("%s failure while handling failure.\n", F_reason[n1]);
1381: } else { /* first (i.e., non-nested) failure */
1382: signal(SIGALRM, dialtime); /* be sure to catch signals */
1383: #ifdef MAC
1384: signal(SIGINT, dialint);
1385: #else /* MAC */
1386: #ifdef OSK
1387: if (signal(SIGINT, SIG_IGN) != (SIGTYP (*)()) SIG_IGN)
1388: signal(SIGINT, dialint);
1389: #else
1390: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
1391: signal(SIGINT, dialint);
1392: #endif /* OS9 */
1393: #endif /* MAC */
1394: alarm(10); /* Be sure to exit this section */
1395: }
1396: switch (n) { /* Type of failure */
1397: case F_time: { /* Timed out */
1398: printf ("DIAL TIMEOUT interval expired.\n");
1399: if (mymdmtyp == n_HAYES
1400: #ifndef MINIDIAL
1401: || mymdmtyp == n_TELEBIT || mymdmtyp == n_HST
1402: #endif /* MINIDIAL */
1403: )
1404: ttoc('\015'); /* Send CR to interrupt dialing */
1405: /* some hayes modems don't fail with BUSY on busy lines */
1406: debug(F110,"dial","timeout",0);
1407: break;
1408: }
1409: case F_int: { /* Dialing interrupted */
1410: printf ("Dialing interrupted.\n");
1411: debug(F110,"dial","interrupted",0);
1412: if (mymdmtyp == n_HAYES
1413: #ifndef MINIDIAL
1414: || mymdmtyp == n_TELEBIT || mymdmtyp == n_HST
1415: #endif /* MINIDIAL */
1416: )
1417: ttoc('\015'); /* Send CR to interrupt dialing */
1418: break;
1419: }
1420: case F_modem: { /* Modem detected a failure */
1421: printf ("Call failed (\"");
1422: for (pc = lbuf; *pc; pc++)
1423: if (isprint(*pc))
1424: putchar(*pc); /* Display printable reason */
1425: printf ("\").\n");
1426: debug(F110,"dial",lbuf,0);
1427: break;
1428: }
1429: case F_minit: { /* Cannot initialize modem */
1430: printf ("Can't initialize modem.\n");
1431: debug(F110,"dial","modem init",0);
1432: break;
1433: }
1434: }
1435: dreset(); /* reset alarms, etc. */
1436: #ifdef DYNAMIC
1437: if (lbuf) free(lbuf);
1438: #endif /* DYNAMIC */
1439: return(0); /* exit with failure code */
1440: }
1441:
1442: /* Set timer and interrupt handlers. */
1443:
1444: alarm(0); /* No alarms yet. */
1445: #ifdef MAC
1446: savint = signal(SIGINT, dialint); /* And terminal interrupt handler. */
1447: #else /* MAC */
1448: #ifdef OSK
1449: if ((savint = signal(SIGINT,SIG_IGN)) != (SIGTYP (*)()) SIG_IGN)
1450: signal(SIGINT,dialint);
1451: #else
1452: if ((savint = signal(SIGINT,SIG_IGN)) != SIG_IGN )
1453: signal(SIGINT,dialint);
1454: #endif /* OS-9 */
1455: #endif /* MAC */
1456:
1457: /* Put modem in command mode. */
1458:
1459: switch (augmdmtyp) { /* Send the wakeup string */
1460:
1461: #ifdef ATT7300
1462: case n_ATTUPC: {
1463: /*
1464: For ATT7300/Unix PC's with their special internal modem. Timeout
1465: and user interrupts are enabled during dialing. attdial() is in
1466: file ckutio.c. - jrd
1467: */
1468: _PROTOTYP( int attdial, (char *, long, char *) );
1469: savalrm = signal(SIGALRM,dialtime); /* Set alarm handler. */
1470: alarm(waitct); /* do alarm properly */
1471: if (attdial(ttname,speed,telnbr)) { /* dial internal modem */
1472: dreset(); /* reset alarms, etc. */
1473: printf(" Call failed.\r\n");
1474: dialhup(); /* Hangup the call */
1475: #ifdef DYNAMIC
1476: if (lbuf) free(lbuf);
1477: #endif /* DYNAMIC */
1478: return(0); /* return failure */
1479: }
1480: dreset(); /* reset alarms, etc. */
1481: ttpkt(speed,FLO_DIAX,parity); /* cancel dialing ioctl */
1482: if (!quiet && !backgrd) {
1483: if (dialdpy) printf("\n");
1484: printf(" Call complete.\07\r\n");
1485: }
1486: #ifdef DYNAMIC
1487: if (lbuf) free(lbuf);
1488: #endif /* DYNAMIC */
1489: return(1); /* no conversation with modem to complete dialing */
1490: }
1491: #endif /* ATT7300 */
1492:
1493: /*
1494: For Hayes modem command language, figure out if modem is giving verbose
1495: or digit result codes.
1496: */
1497: case n_HAYES:
1498: case n_HAYESNV:
1499: #ifndef MINIDIAL
1500: case n_HST:
1501: if (augmdmtyp == n_HST)
1502: m = 255;
1503: else
1504: #endif /* MINIDIAL */
1505: m = 60; /* Maximum value for S7 */
1506: ws = dialini ? dialini : HAYES.wake_str;
1507: for (tries = 4; tries > 0; tries--) {
1508: ttslow(ws,pmdminf->wake_rate);
1509: mdmstat = getok(4,1);
1510: if (mdmstat > 0) break;
1511: sleep(1); /* Wait before retrying */
1512: }
1513: if (mdmstat > 0) { /* Initialized OK. */
1514: char hbuf[10];
1515: /*
1516: Now tell the modem about our dial timeout. For Hayes 1200, the maximum
1517: is 60 seconds. For Hayes 2400 (the manual says) it is 30 seconds, but I'm
1518: not sure I believe this (I don't have one handy to see for myself).
1519: If you give the modem a value larger than its maximum, it sets the timeout
1520: to its maximum. The manual does not say what happens when the value is 0,
1521: but experimentation shows that it allows the modem to wait forever, in
1522: which case Kermit will time out at the desired time.
1523: */
1524: /*
1525: Note by Kai Uwe Rommel:
1526: This is not acceptable for general use of the hayes modem type with other
1527: compatible modems. Most other modems allow a range of 1..255 while 0 is
1528: invalid on several modems. Let it be the user's responsibility to make
1529: sure a valid value is used. Higher values are desirable for users with
1530: rotary dialing and with high speed modems, where protocol negotiation takes
1531: quite a long time.
1532: */
1533: #ifdef COMMENT
1534: if (mdmwait > m) /* If larger than maximum, */
1535: mdmwait = 0; /* make it infinite. */
1536: #else
1537: if (mdmwait > 255) /* If larger than maximum, */
1538: mdmwait = 255; /* make it maximum. */
1539: #endif /* COMMENT */
1540:
1541: sprintf(hbuf,"ATS7=%d%c",mdmwait,13); /* S7 = Carrier wait time */
1542: ttslow(hbuf,pmdminf->wake_rate); /* Set it. */
1543: mdmstat = getok(4,1); /* Get response from modem */
1544: debug(F101,"S7 mdmstat","",mdmstat);
1545: break; /* Errors here are not fatal */
1546: }
1547: /* modem-initialization failure */
1548: n1 = (mdmstat == 0) ? F_minit : F_modem;
1549: longjmp( sjbuf, n1 );
1550:
1551: #ifndef MINIDIAL
1552:
1553: /*
1554: Telebit modems fall into two basic groups: old and new. The functions and
1555: command sets are different between the two groups, and also vary by specific
1556: models within each group, and even by firmware ROM revision number. Read
1557: ckcker.bwr for details.
1558:
1559: Commands used by C-Kermit include:
1560:
1561: Old New Meaning
1562: ------- -------- ----------------------------------------
1563: Q0 Q0 Enable result codes.
1564: X1 X1 Extended result codes.
1565: X1 X1 Extended result codes + BUSY, NO DIALTONE, etc.
1566: I I Model number inquiry.
1567: I3 I3 Additional model information inquiry.
1568: S12=50 S12=50 Escape sequence guard time (1 sec).
1569: S2=43 S2=43 Escape character is '+'.
1570: S7=xx S7=xx DIAL TIMEOUT, calculated or SET by user.
1571: S48=0 S48=0 7-bit data (Kermit's PARITY is not NONE).
1572: S48=1 S48=1 8-bit data (Kermit's PARITY is NONE).
1573: S50=0 S50=0 Automatic speed & protocol determination.
1574: S50=3 S50=3 2400/1200/300 bps.
1575: S50=6 S50=6 V.32 (9600 bps).
1576: S50=255 S50=255 PEP mode.
1577: S110=1 S190=1 S191=7 Allow compression in PEP mode.
1578: S51=? S51=? DTE interface speed (left alone by Kermit).
1579: S54=3 S61=0 S63=0 Pass BREAK signal (always).
1580: S58=2 S58=2 RTS/CTS flow control if Kermit's FLOW is RTS/CTS.
1581: S58=? S58=? S58 unchanged if Kermit's FLOW is not RTS/CTS.
1582: S68=255 S68=255 Use flow control specified by S58 (always).
1583: S95=0 S180=0 MNP disabled (SET DIAL MNP-ENABLE OFF)
1584: S95=2 S180=3 MNP, fallback to direct (also as V.42 fallback)
1585: S97=1 S180=2 Enable V.42 (LAPM) error correction
1586: S98=3 Enable compression in both directions
1587: S106=1 V.42bis compression enable
1588:
1589: For Kermit Spoof (same commands for all models that support it):
1590:
1591: S111=0 No Kermit spoofing
1592: S111=10 Kermit with no parity
1593: S111=11 Kermit with odd parity
1594: S111=12 Kermit with even parity
1595: S111=13 Kermit with mark parity
1596: S111=14 Kermit with space parity
1597: S112=?? Kermit's start-of-packet character (stchr).
1598: */
1599: case n_TELEBIT: /* Telebits... */
1600: case n_TBPEP:
1601: case n_TB3:
1602: case n_TB4:
1603: case n_TBS:
1604: case n_TBNV:
1605: case n_TBPNV:
1606: case n_TB3NV:
1607: case n_TB4NV:
1608: case n_TBSNV: {
1609: int S111; /* Telebit Kermit spoof register */
1610: char tbcmdbuf[64]; /* Telebit modem command buffer */
1611: char *mnpstr = ""; /* Pointer to MNP-enable string */
1612: char *dprstr = ""; /* Pointer to dial protocol string */
1613: /*
1614: If user defined a DIAL INIT-STRING, send that now, otherwise send built-in
1615: Telebit string. Try up to 4 times to get OK or 0 response from modem.
1616: NOTE: The default init string *must* be independent of Telebit model.
1617: */
1618: ws = dialini ? dialini : TELEBIT.wake_str;
1619: debug(F110,"ckdial telebit init string",ws,0);
1620: for (tries = 4; tries > 0; tries--) {
1621: ttsndb(); /* Begin by sending BREAK */
1622: ttslow(ws,pmdminf->wake_rate); /* Send wakeup string */
1623: mdmstat = getok(5,0); /* Get modem's response */
1624: if (mdmstat) break; /* If response OK, done */
1625: msleep(300); /* Otherwise, sleep 1/3 second */
1626: dialhup(); /* Hang up */
1627: ttflui(); /* Flush input buffer and try again */
1628: }
1629: if (mdmstat < 1) { /* If we didn't get a response */
1630: n1 = F_minit; /* fail, reason = can't initialize */
1631: longjmp( sjbuf, F_minit );
1632: }
1633: if (!dialini) { /* If using built-in init strings... */
1634: /*
1635: Try to get the model number. It should be in the getok() response buffer,
1636: rbuf[], because the Telebit init string asks for it with the "I" command.
1637: If the model number is 965, we have to make another query to narrow it down.
1638: */
1639: if (didweget(rbuf,"962") || /* Check model number */
1640: didweget(rbuf,"961") ||
1641: didweget(rbuf,"963")) {
1642: tbmodel = TB_BLAZ; /* Trailblazer */
1643: } else if (didweget(rbuf,"972")) {
1644: tbmodel = TB_2500; /* T2500 */
1645: } else if (didweget(rbuf,"968")) {
1646: tbmodel = TB_1000; /* T1000 */
1647: } else if (didweget(rbuf,"966") ||
1648: didweget(rbuf,"967") ||
1649: didweget(rbuf,"964")) {
1650: tbmodel = TB_PLUS; /* Trailblazer-Plus */
1651: } else if (didweget(rbuf,"969")) {
1652: tbmodel = TB_QBLA; /* Qblazer */
1653: } else if (didweget(rbuf,"965")) { /* Most new models */
1654: tbati3(965); /* Go find out */
1655: } else if (didweget(rbuf,"971")) { /* T1500 or T2500 */
1656: tbati3(971); /* Go find out */
1657: } else if (didweget(rbuf,"123") || didweget(rbuf,"960")) {
1658: tbmodel = TB_UNK; /* Telebit in Hayes mode */
1659: }
1660: debug(F111,"Telebit model",tb_name[tbmodel],tbmodel);
1661: if (dialdpy)
1662: printf("Telebit model: %s\n",tb_name[tbmodel]);
1663: ttflui();
1664: /*
1665: Dial timeout. S7 is set to the DIAL TIMEOUT value, or else to 255 if the
1666: dial timeout is greater than 255, which is the maximum value for Telebits.
1667: S7 can't be set to 0 on Telebits -- it gives an error.
1668: */
1669: if (mdmwait > 255) /* If dial timeout too big */
1670: mdmwait = 255; /* make it as big as possible. */
1671: /*
1672: Flow control. If C-Kermit's FLOW-CONTROL is RTS/CTS, then we set this on
1673: the modem too. Unfortunately, many versions of UNIX only allow RTS/CTS
1674: to be set outside of Kermit (e.g. by selecting a special device name).
1675: In that case, Kermit doesn't know that it should set RTS/CTS on the modem,
1676: in which case the user can add the appropriate Telebit command with
1677: SET DIAL DIAL-COMMAND.
1678: */
1679: if (flow == FLO_RTSC) { /* RTS/CTS active in Kermit */
1680: sprintf(tbcmdbuf,
1681: "ATS7=%d S48=%d S50=0 S58=2 S68=255\015",
1682: mdmwait, parity ? 0 : 1);
1683: } else
1684: sprintf(tbcmdbuf, /* Otherwise, don't touch modem's */
1685: "ATS7=%d S48=%d S50=0 S68=255\015", /* flow control */
1686: mdmwait, parity ? 0 : 1); /* setting. */
1687: s = tbcmdbuf;
1688: debug(F110,"ckdial Telebit init step 2",s,0);
1689: for (tries = 4; tries > 0; tries--) {
1690: ttslow(s,pmdminf->wake_rate);
1691: mdmstat = getok(5,1);
1692: if (mdmstat) break;
1693: msleep(500);
1694: ttflui();
1695: }
1696: if (mdmstat < 1) {
1697: n1 = F_minit;
1698: longjmp( sjbuf, F_minit ); /* Failed. */
1699: }
1700: /*
1701: Model-dependent items, but constant per model.
1702: */
1703: switch(tbmodel) {
1704: case TB_BLAZ:
1705: case TB_PLUS: /* TrailBlazer-Plus */
1706: case TB_1000: /* T1000 */
1707: case TB_2000: /* T2000 */
1708: case TB_2500: /* T2500 */
1709: #ifdef COMMENT
1710: /* Code from edit 183 told modem to follow RS-232 wrt CD and DTR */
1711: /* DTR, CD, follow RS-232, pass BREAK */
1712: sprintf(tbcmdbuf,"ATS52=1 S53=4 S54=3\015");
1713: #else
1714: /* But everybody agreed we should not touch modem's CD and DTR settings. */
1715: /* Just pass BREAK */
1716: sprintf(tbcmdbuf,"ATS54=3\015");
1717: #endif /* COMMENT */
1718: break;
1719: case TB_1600: /* T1600 */
1720: case TB_3000: /* T3000 */
1721: case TB_WBLA: /* WorldBlazer */
1722: case TB_QBLA: /* Qblazer */
1723: #ifdef COMMENT
1724: /* Code from edit 183 */
1725: /* Follow RS-232, No CONNECT suffix, pass BREAK */
1726: sprintf(tbcmdbuf,"AT&C1&D2&Q0 S59=0 S61=0 S63=0\015");
1727: #else
1728: /* Everybody agrees we should not touch modem's CD and DTR settings. */
1729: /* Also no more &Q0, no more S59=0 (doesn't matter, so don't touch). */
1730: /* So this section now deals only with treatment of BREAK. */
1731: /* Here we also raise the result code from X1 to X2, which allows */
1732: /* the T1600, T3000, and WB to supply NO DIALTONE, BUSY, RRING, and DIALING. */
1733: /* X2 means something else on the other models. */
1734: /* Transmit BREAK in sequence, raise result code. */
1735: sprintf(tbcmdbuf,"ATX2 S61=0 S63=0\015");
1736: #endif /* COMMENT */
1737: break;
1738: default: /* Others, do nothing */
1739: tbcmdbuf[0] = NUL;
1740: break;
1741: }
1742: s = tbcmdbuf;
1743: if (*s) {
1744: debug(F110,"ckdial Telebit init step 3",s,0);
1745: for (tries = 4; tries > 0; tries--) {
1746: ttslow(s,pmdminf->wake_rate);
1747: mdmstat = getok(5,1);
1748: if (mdmstat) break;
1749: msleep(500);
1750: ttflui();
1751: }
1752: if (mdmstat < 1) {
1753: n1 = F_minit;
1754: longjmp( sjbuf, F_minit ); /* Failed. */
1755: }
1756: } else debug(F100,"ckdial Telebit init step 3 skipped","",0);
1757:
1758: /* Error correction, MNP or V.42 */
1759:
1760: if (augmdmtyp & DIAL_V42) { /* User wants V.42 */
1761: switch (tbmodel) { /* which implies fallback to MNP. */
1762: case TB_PLUS: /* BC7.00 and up firmware */
1763: case TB_2000: /* now really the same as TB+ ? */
1764: case TB_2500: /* LAPM+compress->MNP->direct */
1765: mnpstr = "S50=0 S95=2 S97=1 S98=3 S106=1";
1766: break;
1767: case TB_1600:
1768: case TB_3000:
1769: case TB_WBLA:
1770: case TB_QBLA:
1771: #ifdef COMMENT
1772: mnpstr = "S180=2 S181=0"; /* V.42, fallback = lock speed */
1773: #else
1774: /* Better not to mess with S181, let it be used however user has it set. */
1775: /* S180=2 allows fallback to MNP, S180=1 disallows fallback to MNP. */
1776: mnpstr = "S180=2"; /* V.42 */
1777: #endif /* COMMENT */
1778: break;
1779: default:
1780: if (dialdpy)
1781: printf("V.42 not supported by this Telebit model\n");
1782: }
1783: } else { /* Handle DIAL MNP-ENABLE setting */
1784: switch (tbmodel) {
1785: case TB_BLAZ: /* TrailBlazer */
1786: case TB_PLUS: /* TrailBlazer-Plus */
1787: case TB_1000: /* T1000 */
1788: case TB_2000: /* T2000 */
1789: case TB_2500: /* T2500 */
1790: mnpstr = dialmnp ? "S95=2" : "S95=0"; /* ON, OFF */
1791: break;
1792: case TB_1600: /* T1600 */
1793: case TB_3000: /* T3000 */
1794: case TB_WBLA: /* WorldBlazer */
1795: case TB_QBLA: /* Qblazer */
1796: mnpstr = dialmnp ? "S180=3" : "S180=0"; /* ON, OFF */
1797: /* (Leave S181 fallback method alone) */
1798: break;
1799: default:
1800: mnpstr = "";
1801: }
1802: }
1803:
1804: /* Dialing protocol */
1805:
1806: dprstr = ""; /* Initialize dialing protocol string */
1807: p = ""; /* and message string */
1808: switch (augmdmtyp) {
1809: case n_TELEBIT: /* Start at highest and work down */
1810: case n_TBNV:
1811: p = "standard";
1812: switch (tbmodel) { /* First group starts with PEP */
1813: case TB_BLAZ: /* TrailBlazer */
1814: case TB_PLUS: /* TrailBlazer-Plus */
1815: case TB_1000: /* T1000 */
1816: case TB_2000: /* T2000 */
1817: case TB_2500: /* T2500 */
1818: dprstr = "S50=0 S110=1"; /* PEP, compression allowed. */
1819: break;
1820: case TB_WBLA: /* WorldBlazer has PEP */
1821: dprstr = "S50=0 S190=1 S191=7"; /* PEP, */
1822: break; /* compression allowed. */
1823: case TB_1600: /* T1600 doesn't have PEP */
1824: case TB_3000: /* T3000 doesn't */
1825: case TB_QBLA: /* Qblazer doesn't*/
1826: default:
1827: dprstr = "S50=0"; /* No PEP available */
1828: break;
1829: }
1830: break;
1831:
1832: case n_TBS: /* Telebit up to 2400 Baud */
1833: case n_TBSNV: /* i.e. "Slow mode". */
1834: p = "300/1200/2400 Baud"; /* Leave S90 alone assuming it is */
1835: dprstr = "S50=3"; /* already set for V.22 vs 212A */
1836: break;
1837: case n_TB3: /* Telebit V.32 */
1838: case n_TB3NV:
1839: if (tbmodel == TB_3000 || tbmodel == TB_1600 ||
1840: tbmodel == TB_2500 || tbmodel == TB_WBLA) {
1841: p = "V.32";
1842: /* Note: we don't touch S51 (interface speed) here. */
1843: /* We're already talking to the modem, and the modem */
1844: /* SHOULD be able to make a V.32 call no matter what */
1845: /* its interface speed is. (In practice, however, */
1846: /* that is not always true.) */
1847: dprstr = "S50=6";
1848: } else if (dialdpy)
1849: printf("V.32 not supported by this Telebit model.\n");
1850: break;
1851: case n_TBPEP: /* Force PEP Protocol */
1852: case n_TBPNV:
1853: if (tbmodel != TB_1600 && /* Models that don't support PEP */
1854: tbmodel != TB_3000 &&
1855: tbmodel != TB_QBLA) {
1856: p = "PEP";
1857: if (tbmodel == TB_WBLA) /* WorldBlazer */
1858: dprstr = "S50=255 S190=1 S191=7";
1859: else if (tbmodel != TB_1000)
1860: dprstr = "S50=255 S110=1"; /* TrailBlazer, etc. */
1861: else dprstr = "S50=255"; /* T1000, no compression */
1862: } else if (dialdpy)
1863: printf("PEP not supported by this Telebit model.\n");
1864: break;
1865: }
1866:
1867: /* Kermit Spoof */
1868:
1869: if (dialksp) {
1870: p = "Kermit Spoof";
1871: switch (parity) { /* S111 value depends on parity */
1872: case 'e': S111 = 12; break;
1873: case 'm': S111 = 13; break;
1874: case 'o': S111 = 11; break;
1875: case 's': S111 = 14; break;
1876: case 0:
1877: default: S111 = 10; break;
1878:
1879: }
1880: #ifdef COMMENT
1881: /*
1882: This code forced the use of PEP mode if DIAL KERMIT-SPOOF was ON, which
1883: prevented successful connection if the other modem did not support PEP.
1884: */
1885: if (tbmodel == TB_BLAZ || /* Must force PEP on old models */
1886: tbmodel == TB_PLUS ||
1887: tbmodel == TB_1000 ||
1888: tbmodel == TB_2000 ||
1889: tbmodel == TB_2500)
1890: sprintf(tbcmdbuf,"AT%s %s S50=255 S111=%d S112=%d\015",
1891: mnpstr,dprstr,S111,stchr);
1892: /* PEP is not required on T1500, T1600, T3000, and WB */
1893: /* (but MNP is, but that is user's responsibility). */
1894: else
1895: #endif /* COMMENT */
1896: if (tbmodel != TB_QBLA)
1897: sprintf(tbcmdbuf,"AT%s %s S111=%d S112=%d\015",
1898: mnpstr,dprstr,S111,stchr);
1899: else { /* Qblazer has no Kermit spoof */
1900: sprintf(tbcmdbuf,"AT%s %s\015", mnpstr,dprstr);
1901: p = "No Kermit Spoof";
1902: if (dialdpy)
1903: printf("Kermit Spoof not supported by Qblazer\n");
1904: }
1905: } else { /* No Kermit spoof */
1906: p = "No Kermit Spoof";
1907: sprintf(tbcmdbuf,"AT%s %s %s\015",
1908: mnpstr, dprstr,
1909: (tbmodel == TB_QBLA) ? "" : "S111=0 S112=0");
1910: }
1911: s = tbcmdbuf;
1912: debug(F111,"ckdial Telebit config",p,speed);
1913: debug(F110,"ckdial Telebit init step 4",s,0);
1914: if (*s) {
1915: for (tries = 4; tries > 0; tries--) {
1916: ttslow(s,pmdminf->wake_rate);
1917: mdmstat = getok(5,1);
1918: if (mdmstat) break;
1919: msleep(500);
1920: ttflui();
1921: }
1922: debug(F101,"ckdial telebit init mdmstat","",mdmstat);
1923: if (mdmstat < 1) {
1924: n1 = F_minit;
1925: longjmp(sjbuf, F_minit);
1926: }
1927: }
1928: }
1929: /* Done with Telebit protocols, remove bits from modem type */
1930: /* Except nonverbal bit */
1931: augmdmtyp &= ~(DIAL_PEP|DIAL_V32|DIAL_V42|DIAL_SLO);
1932: debug(F101,"ckdial Telebit augmdmtyp","",augmdmtyp);
1933: break;
1934: }
1935:
1936: case n_MICROCOM: /* Interdigit waits for tone dial */
1937: {
1938: jmp_buf savejmp;
1939: alarm(0);
1940: savalrm = signal(SIGALRM,dialtime); /* Set alarm handler. */
1941: xcpy((char *)savejmp, (char *)sjbuf, sizeof savejmp);
1942: if (setjmp(sjbuf)) {
1943: /* try the autobaud sequence */
1944: xcpy((char *)sjbuf, (char *)savejmp, sizeof savejmp);
1945: alarm(5);
1946: ttslow("44445", MICROCOM.wake_rate);
1947: waitfor(MICROCOM.wake_str);
1948: } else {
1949: alarm(2);
1950: ws = dialini ? dialini : MICROCOM.wake_str;
1951: ttslow(ws, MICROCOM.wake_rate);
1952: waitfor(ws);
1953: #ifdef COMMENT
1954: /*
1955: Kermit spoof for Microcom modems. Untested.
1956: This is reportedly the way to do it for QX/3296c, QX/4232hs, QX/4232bis,
1957: and QX/9624c. The effect on other models is unknown.
1958: */
1959: ws = dialksp ? "APM1\015" : "APM0\015"; /* Kermit spoof */
1960: ttslow(ws, MICROCOM.wake_rate);
1961: waitfor(ws);
1962: #endif /* COMMENT */
1963: alarm(0);
1964: signal(SIGALRM,savalrm); /* Set alarm handler. */
1965: xcpy((char *)sjbuf, (char *)savejmp, sizeof savejmp);
1966: }
1967: }
1968: break;
1969:
1970: case n_ATTDTDM: /* DTDM requires BREAK to wake up */
1971: ttsndb(); /* Send BREAK */
1972: break; /* ttsndb() defined in ckutio.c */
1973:
1974: #endif /* MINIDIAL */
1975:
1976: default: /* Place modem into command mode */
1977: ws = dialini ? dialini : pmdminf->wake_str;
1978: if (ws && (int)strlen(ws) > 0) {
1979: debug(F111,"ckdial default, wake string", ws, pmdminf->wake_rate);
1980: ttslow(ws, pmdminf->wake_rate);
1981: } else debug(F100,"ckdial no wake_str","",0);
1982: if (pmdminf->wake_prompt && (int)strlen(pmdminf->wake_prompt) > 0) {
1983: debug(F110,"ckdial default, waiting for wake_prompt",
1984: pmdminf->wake_prompt,0);
1985: savalrm = signal(SIGALRM,dialtime);
1986: alarm(10);
1987: waitfor(pmdminf->wake_prompt);
1988: } else debug(F100,"ckdial no wake_prompt","",0);
1989: break;
1990: }
1991: alarm(0); /* Turn off alarm */
1992: signal(SIGALRM,savalrm); /* Restore alarm handler. */
1993: debug(F100,"ckdial got wake prompt","",0);
1994: msleep(500); /* Allow settling time */
1995:
1996: #ifndef MINIDIAL
1997:
1998: /* Enable/disable MNP (Telebit already done above) */
1999:
2000: switch (augmdmtyp) {
2001: case n_HST:
2002: if (dialmnp)
2003: ttslow("AT&K2\015",pmdminf->wake_rate);
2004: else
2005: ttslow("AT&K0\015",pmdminf->wake_rate);
2006: getok(5,1); /* Get response */
2007: break;
2008:
2009: /* Add others here ... */
2010:
2011: default:
2012: break;
2013: }
2014: #endif /* MINIDIAL */
2015:
2016: /* Put modem into dialing mode, if the modem requires it. */
2017:
2018: if (pmdminf->dmode_str && *(pmdminf->dmode_str)) {
2019: ttslow(pmdminf->dmode_str, pmdminf->dial_rate);
2020: savalrm = signal(SIGALRM,dialtime);
2021: alarm(10);
2022: if (pmdminf->dmode_prompt) { /* Wait for prompt, if any expected */
2023: waitfor(pmdminf->dmode_prompt);
2024: msleep(300);
2025: }
2026: alarm(0); /* Turn off alarm on dialing prompts */
2027: signal(SIGALRM,savalrm); /* Restore alarm */
2028: ttflui(); /* Clear out stuff from waking modem up */
2029: }
2030:
2031: /* Dial the number. First form the dialing string. */
2032:
2033: sprintf(lbuf, dialcmd ? dialcmd : pmdminf->dial_str, telnbr);
2034: debug(F110,"dialing",lbuf,0);
2035: ttslow(lbuf,pmdminf->dial_rate); /* Send the dialing string */
2036:
2037: savalrm = signal(SIGALRM,dialtime); /* Time to allow for connecting */
2038: x = alarm(waitct); /* This much time... */
2039: debug(F101,"ckdial old alarm","",x);
2040: debug(F101,"ckdial waitct","",waitct);
2041:
2042: #ifndef MINIDIAL
2043: switch (augmdmtyp) {
2044: case n_RACAL: /* Acknowledge printout of dialing string */
2045: sleep(3);
2046: ttflui();
2047: ttoc('\015');
2048: break;
2049: case n_VENTEL:
2050: waitfor("\012\012"); /* Ignore the first two strings */
2051: break;
2052: default:
2053: break;
2054: }
2055: #endif /* MINIDIAL */
2056:
2057: /* Check for connection */
2058:
2059: mdmstat = 0; /* No status yet */
2060: strcpy(lbuf,"No Connection"); /* Default reason for failure */
2061: debug(F101,"dial awaiting response, augmdmtyp","",augmdmtyp);
2062: while (mdmstat == 0) {
2063: switch (augmdmtyp) {
2064: default:
2065: for (n = -1; n < LBUFL-1; ) { /* Accumulate response */
2066: c2 = ddinc(0); /* Read a character, blocking */
2067: if (c2 == 0 || c2 == -1) /* Ignore NULs and errors */
2068: continue; /* (Timeout will handle errors) */
2069: else /* Real character, keep it */
2070: lbuf[++n] = c2 & 0177;
2071: dialoc(lbuf[n]); /* Maybe echo it */
2072: if (augmdmtyp == n_CCITT) { /* V.25 bis dialing... */
2073: /*
2074: This assumes that V.25bis indications are all at least 3 characters long
2075: and are terminated by either CRLF or LFCR.
2076: */
2077: if (n < 3) continue;
2078: if ((lbuf[n] == CR) && (lbuf[n-1] == LF)) break;
2079: if ((lbuf[n] == LF) && (lbuf[n-1] == CR)) break;
2080: }
2081: #ifndef MINIDIAL
2082: else if (augmdmtyp == n_DIGITEL) {
2083: if ((lbuf[n] == CR) && (lbuf[n-1] == LF) ||
2084: (lbuf[n] == LF) && (lbuf[n-1] == CR))
2085: break;
2086: else
2087: continue;
2088: }
2089: #endif /* MINIDIAL */
2090: else { /* All others, break on CR or LF */
2091: if ( lbuf[n] == CR || lbuf[n] == LF ) break;
2092: }
2093: }
2094: lbuf[++n] = '\0'; /* Terminate response from modem */
2095: debug(F111,"dial modem response",lbuf,n);
2096: if (n) { /* If one or more characters present */
2097: switch (augmdmtyp) { /* check for modem response message. */
2098: #ifndef MINIDIAL
2099: case n_ATTMODEM:
2100: /* Careful - "Connected" / "Not Connected" */
2101: if (didweget(lbuf,"Busy") ||
2102: didweget(lbuf,"Not connected") ||
2103: didweget(lbuf,"Not Connected") ||
2104: didweget(lbuf,"No dial tone") ||
2105: didweget(lbuf,"No Dial Tone") ||
2106: didweget(lbuf,"No answer") ||
2107: didweget(lbuf,"No Answer"))
2108: mdmstat = FAILED;
2109: else if (didweget(lbuf,"Answered") ||
2110: didweget(lbuf,"Connected"))
2111: mdmstat = CONNECTED;
2112: break;
2113:
2114: case n_ATTISN:
2115: if (didweget(lbuf,"ANSWERED"))
2116: mdmstat = CONNECTED;
2117: else if (didweget(lbuf,"BUSY") ||
2118: didweget(lbuf,"DISCONNECT") ||
2119: didweget(lbuf,"NO ANSWER") ||
2120: didweget(lbuf,"WRONG ADDRESS"))
2121: mdmstat = FAILED;
2122: break;
2123:
2124: case n_ATTDTDM:
2125: if (didweget(lbuf,"ANSWERED"))
2126: mdmstat = CONNECTED;
2127: else if (didweget(lbuf,"BUSY") ||
2128: didweget(lbuf,"CHECK OPTIONS") ||
2129: didweget(lbuf,"DISCONNECTED") ||
2130: didweget(lbuf,"DENIED"))
2131: mdmstat = FAILED;
2132: #ifdef DEBUG
2133: #ifdef ATT6300
2134: else if (deblog && didweget(lbuf,"~~"))
2135: mdmstat = CONNECTED;
2136: #endif /* ATT6300 */
2137: #endif /* DEBUG */
2138: break;
2139: #endif /* MINIDIAL */
2140:
2141: case n_CCITT: /* CCITT V.25bis */
2142: #ifndef MINIDIAL
2143: case n_DIGITEL: /* or Digitel variant */
2144: #endif /* MINIDIAL */
2145: if (didweget(lbuf,"VAL")) { /* Dial command confirmation */
2146: #ifndef MINIDIAL
2147: if (augmdmtyp == n_CCITT)
2148: #endif /* MINIDIAL */
2149: continue; /* Go back and read more */
2150: #ifndef MINIDIAL
2151: /* Digitel doesn't give an explicit connect confirmation message */
2152: else {
2153: int n;
2154: for (n = -1; n < LBUFL-1; ) {
2155: lbuf[++n] = c2 = ddinc(0) & 0177;
2156: dialoc(lbuf[n]);
2157: if ((lbuf[n] == CR) && (lbuf[n-1] == LF) ||
2158: (lbuf[n] == LF) && (lbuf[n-1] == CR))
2159: break;
2160: }
2161: mdmstat = CONNECTED; /* Assume we're connected */
2162: if (dialdpy && carrier != CAR_OFF) {
2163: sleep(1); /* Wait a second */
2164: n = ttgmdm(); /* Try to read modem signals */
2165: if ((n > -1) && (n & BM_DCD == 0))
2166: printf("Warning: No Carrier\n");
2167: }
2168: }
2169: #endif /* MINIDIAL */
2170: } else if (didweget(lbuf,"CNX")) { /* Connected */
2171: mdmstat = CONNECTED;
2172: } else if (didweget(lbuf, "INV")) {
2173: mdmstat = FAILED; /* Command error */
2174: strcpy(lbuf,"INV");
2175: } else if (didweget(lbuf,"CFI")) { /* Call Failure */
2176: #ifdef COMMENT
2177: /*
2178: V.25 bis says that the failure reason comes on the same line, so
2179: we don't need to read any more characters here.
2180: */
2181: for (n = 0; n < LBUFL-1; n++) { /* Read reason */
2182: lbuf[n] = c2 = (ddinc(0) & 0177);
2183: if (c2 == LF) /* Modem answers LF CR */
2184: continue;
2185: dialoc(lbuf[n]);
2186: if (lbuf[n] == CR || lbuf[n] == LF) break;
2187: }
2188: #endif /* COMMENT */
2189: if (didweget(lbuf,"AB")) /* Interpret reason code */
2190: strcpy(lbuf,"AB: Timed out");
2191: else if (didweget(lbuf,"CB"))
2192: strcpy(lbuf,"CB: Local DCE Busy");
2193: else if (didweget(lbuf,"ET"))
2194: strcpy(lbuf,"ET: Busy");
2195: else if (didweget(lbuf, "NS"))
2196: strcpy(lbuf,"NS: Number not stored");
2197: else if (didweget(lbuf,"NT"))
2198: strcpy(lbuf,"NT: No answer");
2199: else if (didweget(lbuf,"RT"))
2200: strcpy(lbuf,"RT: Ring tone");
2201: else if (didweget(lbuf,"PV"))
2202: strcpy(lbuf,"PV: Parameter value error");
2203: else if (didweget(lbuf,"PS"))
2204: strcpy(lbuf,"PS: Parameter syntax error");
2205: else if (didweget(lbuf,"MS"))
2206: strcpy(lbuf,"MS: Message syntax error");
2207: else if (didweget(lbuf,"CU"))
2208: strcpy(lbuf,"CU: Command unknown");
2209: else if (didweget(lbuf,"FC"))
2210: strcpy(lbuf,"FC: Forbidden call");
2211: mdmstat = FAILED;
2212: } else if (didweget(lbuf,"INC")) { /* Incoming Call */
2213: strcpy(lbuf,"INC: Incoming call");
2214: mdmstat = FAILED;
2215: } else if (didweget(lbuf,"DLC")) { /* Delayed Call */
2216: strcpy(lbuf,"DLC: Delayed call");
2217: mdmstat = FAILED;
2218: } else /* Response was probably an echo. */
2219: #ifndef MINIDIAL
2220: if (augmdmtyp == n_CCITT)
2221: #endif /* MINIDIAL */
2222: continue;
2223: #ifndef MINIDIAL
2224: else /* Digitel: If no error, then connect. */
2225: mdmstat = CONNECTED;
2226: #endif /* MINIDIAL */
2227: break;
2228:
2229: #ifndef MINIDIAL
2230: case n_CERMETEK:
2231: if (didweget(lbuf,"\016A")) {
2232: mdmstat = CONNECTED;
2233: ttslow("\016U 1\015",200); /* make transparent*/
2234: }
2235: break;
2236:
2237: case n_DF100: /* DF100 has short response codes */
2238: if (strcmp(lbuf,"A") == 0)
2239: mdmstat = CONNECTED; /* Attached */
2240: else if (strcmp(lbuf,"N") == 0 || /* No Ans or Dialtone */
2241: strcmp(lbuf,"E") == 0 || /* Error */
2242: strcmp(lbuf,"R") == 0) { /* Ready */
2243: mdmstat = FAILED;
2244: break;
2245: }
2246: /* otherwise fall thru... */
2247:
2248: case n_DF200:
2249: if (didweget(lbuf,"Attached"))
2250: mdmstat = CONNECTED;
2251: /*
2252: * The DF100 will respond with "Attached" even if DTR
2253: * and/or carrier are not present. Another reason to
2254: * (also) wait for carrier?
2255: */
2256: else if (didweget(lbuf,"Busy") ||
2257: didweget(lbuf,"Disconnected") ||
2258: didweget(lbuf,"Error") ||
2259: didweget(lbuf,"No answer") ||
2260: didweget(lbuf,"No dial tone") ||
2261: didweget(lbuf,"Speed:"))
2262: mdmstat = FAILED;
2263: /*
2264: * It appears that the "Speed:..." response comes after an
2265: * "Attached" response, so this is never seen. HOWEVER,
2266: * it would be very handy to detect this and temporarily
2267: * reset the speed, since it's a nuisance otherwise.
2268: * If we wait for some more input from the modem, how do
2269: * we know if it's from the remote host or the modem?
2270: * Carrier reportedly doesn't get set until after the
2271: * "Speed:..." response (if any) is sent. Another reason
2272: * to (also) wait for carrier.
2273: */
2274: break;
2275:
2276: case n_GDC:
2277: if (didweget(lbuf,"ON LINE"))
2278: mdmstat = CONNECTED;
2279: else if (didweget(lbuf,"NO CONNECT"))
2280: mdmstat = FAILED;
2281: break;
2282:
2283: case n_USROBOT:
2284: case n_HST:
2285: case n_TELEBIT:
2286: #endif /* MINIDIAL */
2287: case n_HAYES:
2288: if (mdmspd && !network) {
2289: s = lbuf;
2290: while (*s != '\0' && *s != 'C') s++;
2291: cptr = (*s == 'C') ? s : NULL;
2292: conspd = 0L;
2293: if ((cptr != NULL) && !strncmp(cptr,"CONNECT ",8)) {
2294: if ((int)strlen(cptr) < 9) /* Just CONNECT, */
2295: conspd = 300L; /* use 300 bps */
2296: else if (isdigit(*(cptr+8))) /* not CONNECT FAST */
2297: conspd = atol(cptr + 8); /* CONNECT nnnn */
2298: if (conspd != speed) {
2299: if ((conspd / 10L) > 0) {
2300: if (ttsspd((int) (conspd / 10L)) < 0) {
2301: printf(" Can't change speed to %lu\r\n",
2302: conspd);
2303: } else {
2304: speed = conspd;
2305: mdmstat = CONNECTED;
2306: if ( !quiet && !backgrd )
2307: printf(" Speed changed to %lu\r\n",
2308: conspd);
2309: }
2310: }
2311: } /* Expanded to handle any conceivable speed */
2312: }
2313: }
2314: #ifndef MINIDIAL
2315: if (mymdmtyp == n_TELEBIT) {
2316: if (didweget(lbuf,"CONNECT FAST/KERM")) {
2317: mdmstat = CONNECTED;
2318: if (!quiet && !backgrd) printf("FAST/KERM ");
2319: break;
2320: }
2321: }
2322: #endif /* MINIDIAL */
2323: if (didweget(lbuf,"RRING") ||
2324: didweget(lbuf,"RINGING") ||
2325: didweget(lbuf,"DIALING")) {
2326: mdmstat = 0;
2327: } else if (didweget(lbuf,"CONNECT")) {
2328: mdmstat = CONNECTED;
2329: } else if (didweget(lbuf,"NO CARRIER") ||
2330: didweget(lbuf,"NO DIALTONE") ||
2331: didweget(lbuf,"NO DIAL TONE") ||
2332: didweget(lbuf,"BUSY") ||
2333: didweget(lbuf,"NO ANSWER") ||
2334: didweget(lbuf,"VOICE") ||
2335: didweget(lbuf,"RING") ||
2336: didweget(lbuf,"ERROR")) {
2337: mdmstat = FAILED;
2338: }
2339: break;
2340: #ifndef MINIDIAL
2341: case n_PENRIL:
2342: if (didweget(lbuf,"OK"))
2343: mdmstat = CONNECTED;
2344: else if (didweget(lbuf,"BUSY") ||
2345: didweget(lbuf,"NO RING"))
2346: mdmstat = FAILED;
2347: break;
2348: case n_RACAL:
2349: if (didweget(lbuf,"ON LINE"))
2350: mdmstat = CONNECTED;
2351: else if (didweget(lbuf,"FAILED CALL"))
2352: mdmstat = FAILED;
2353: break;
2354: case n_ROLM:
2355: if (didweget(lbuf,"CALLING"))
2356: mdmstat = 0;
2357: else if (didweget(lbuf,"COMPLETE"))
2358: mdmstat = CONNECTED;
2359: else if (didweget(lbuf,"FAILED") ||
2360: didweget(lbuf,"NOT AVAILABLE") ||
2361: didweget(lbuf,"LACKS PERMISSION") ||
2362: didweget(lbuf,"NOT A DATALINE") ||
2363: didweget(lbuf,"INVALID GROUP NAME") ||
2364: didweget(lbuf,"BUSY") ||
2365: didweget(lbuf,"ABANDONDED") ||
2366: didweget(lbuf,"DOES NOT ANSWER") ||
2367: didweget(lbuf,"INVALID DATA LINE NUMBER"))
2368: mdmstat = FAILED;
2369: break;
2370: case n_VENTEL:
2371: if (didweget(lbuf,"ONLINE!") ||
2372: didweget(lbuf,"Online!"))
2373: mdmstat = CONNECTED;
2374: else if (didweget(lbuf,"BUSY") ||
2375: didweget(lbuf,"DEAD PHONE") ||
2376: didweget(lbuf,"Busy"))
2377: mdmstat = FAILED;
2378: break;
2379: case n_CONCORD:
2380: if (didweget(lbuf,"INITIATING"))
2381: mdmstat = CONNECTED;
2382: else if (didweget(lbuf,"BUSY") ||
2383: didweget(lbuf,"CALL FAILED"))
2384: mdmstat = FAILED;
2385: break;
2386: case n_MICROCOM:
2387: /* "RINGBACK" means phone line ringing, continue */
2388: if (didweget(lbuf,"NO CONNECT") ||
2389: didweget(lbuf,"BUSY") ||
2390: didweget(lbuf,"NO DIALTONE") ||
2391: didweget(lbuf,"COMMAND ERROR") ||
2392: didweget(lbuf,"IN USE"))
2393: mdmstat = FAILED;
2394: else if (didweget(lbuf,"CONNECT"))
2395: mdmstat = CONNECTED;
2396: /* trailing speed ignored */
2397: break;
2398: #endif /* MINIDIAL */
2399: }
2400: }
2401: break;
2402:
2403: #ifndef MINIDIAL
2404: case n_DF03: /* because response lacks CR or NL */
2405: c = ddinc(0) & 0177;
2406: dialoc(c);
2407: debug(F000,"dial df03 got","",c);
2408: if ( c == 'A' ) mdmstat = CONNECTED;
2409: if ( c == 'B' ) mdmstat = FAILED;
2410: break;
2411:
2412: case n_TBNV: /* Hayeslike modems in digit */
2413: case n_TB3NV /* response mode... */:
2414: case n_TBPNV:
2415: case n_TB4NV:
2416: case n_TBSNV:
2417: #endif /* MINIDIAL */
2418: case n_HAYESNV:
2419:
2420: /*
2421: The method for reading Hayes numeric result codes has been totally
2422: redone as of 5A(174) to account for all of the following. Not all have
2423: been tested, and others probably need to be added.
2424:
2425: Hayes numeric result codes (Hayes 1200 and higher):
2426: 0 = OK
2427: 1 = CONNECT at 300 bps (or 1200 bps on Hayes 1200 with basic code set)
2428: 2 = RING
2429: 3 = NO CARRIER
2430: 4 = ERROR (in command line)
2431: 5 = CONNECT 1200 (extended code set)
2432: Hayes 2400 and higher:
2433: 6 = NO DIALTONE
2434: 7 = BUSY
2435: 8 = NO ANSWER
2436: 9 = (there is no 9)
2437: 10 = CONNECT 2400
2438: Reportedly, the codes for Hayes V.32 modems are:
2439: 1x = CONNECT <suffix>
2440: 5x = CONNECT 1200 <suffix>
2441: 9x = CONNECT 2400 <suffix>
2442: 11x = CONNECT 4800 <suffix>
2443: 12x = CONNECT 9600 <suffix>
2444: Where:
2445: x: suffix:
2446: R = RELIABLE
2447: RC = RELIABLE COMPRESSED
2448: L = LAPM
2449: LC = LAPM COMPRESSED
2450: And for Telebits, all the above, except no suffix in numeric mode, plus:
2451: 11 = CONNECT 4800
2452: 12 = CONNECT 9600
2453: 13 = CONNECT 14400
2454: 14 = CONNECT 19200
2455: 15 = CONNECT 38400
2456: 16 = CONNECT 57600
2457: 20 = CONNECT 300/REL (= MNP)
2458: 22 = CONNECT 1200/REL (= MNP)
2459: 23 = CONNECT 2400/REL (= MNP)
2460: 46 = CONNECT 7512 (i.e. 75/1200)
2461: 47 = CONNECT 1275 (i.e. 1200/75)
2462: 48 = CONNECT 7200
2463: 49 = CONNECT 12000
2464: 50 = CONNECT FAST (not on T1600/3000)
2465: 52 = RRING
2466: 53 = DIALING
2467: 54 = NO PROMPTTONE
2468: 61 = CONNECT FAST/KERM (Kermit spoof)
2469: 70 = CONNECT FAST/COMP (PEP + compression)
2470: 71 = CONNECT FAST/KERM/COMP (PEP + compression + Kermit spoof)
2471: */
2472: #define NBUFL 8
2473: { /* Nonverbal response code handler */
2474: char nbuf[NBUFL+1]; /* Response buffer */
2475: int i, j; /* Buffer pointers */
2476: debug(F101,"RESPONSE mdmecho","",mdmecho);
2477: if (mdmecho) { /* Sponge up dialing string echo. */
2478: while (1) {
2479: c = ddinc(0) & 0x7f;
2480: debug(F000,"SPONGE","",c);
2481: dialoc(c);
2482: if (c == CR) break;
2483: }
2484: }
2485: while (mdmstat == 0) { /* Read response */
2486: for (i = 0; i < NBUFL; i++) /* Clear the buffer */
2487: nbuf[i] = '\0';
2488: i = 0; /* Reset the buffer pointer. */
2489: c = ddinc(0) & 0177; /* Get first digit of response. */
2490: /* using an untimed, blocking read. */
2491: debug(F000,"RESPONSE-A","",c);
2492: dialoc(c); /* Echo it if requested. */
2493: if (!isdigit(c)) /* If not a digit, keep looking. */
2494: continue;
2495: nbuf[i++] = c; /* Got first digit, save it. */
2496: while (c != CR && i < 8) { /* Now read characters up to CR */
2497: x = ddinc(0) & 0177; /* Get a character. */
2498: c = (char) x; /* Got it OK. */
2499: debug(F000,"RESPONSE-C","",c);
2500: if (c != CR) /* If it's not a carriage return, */
2501: nbuf[i++] = c; /* save it. */
2502: dialoc(c); /* Echo it. */
2503: }
2504: nbuf[i] = '\0'; /* Done, terminate the buffer. */
2505: debug(F111,"dial hayesnv lbuf",lbuf,n);
2506: debug(F111,"dial hayesnv got",nbuf,i);
2507: /*
2508: Separate any non-numeric suffix from the numeric result code
2509: with a null.
2510: */
2511: for (j = i-1; (j > -1) && !isdigit(nbuf[j]); j--)
2512: nbuf[j+1] = nbuf[j];
2513: j++;
2514: nbuf[j++] = '\0';
2515: debug(F110,"dial hayesnv numeric",nbuf,0);
2516: debug(F111,"dial hayesnv suffix ",nbuf+j,j);
2517: if ((int)strlen(nbuf) > 3) /* Probably phone number echoing. */
2518: continue;
2519: /*
2520: Now read and interpret the results...
2521: */
2522: i = atoi(nbuf); /* Convert to integer */
2523: switch (i) {
2524: case 1: /* CONNECT */
2525: mdmstat = CONNECTED; /* Could be any speed */
2526: break;
2527: case 2: /* RING */
2528: if (dialdpy) printf("\r\n Local phone is ringing!\r\n");
2529: mdmstat = FAILED;
2530: break;
2531: case 3: /* NO CARRIER */
2532: if (dialdpy) printf("\r\n No Carrier.\r\n");
2533: mdmstat = FAILED;
2534: break;
2535: case 4: /* ERROR */
2536: if (dialdpy) printf("\r\n Modem Command Error.\r\n");
2537: mdmstat = FAILED;
2538: break;
2539: case 5: /* CONNECT 1200 */
2540: spdchg(1200L); /* Change speed if necessary. */
2541: mdmstat = CONNECTED;
2542: break;
2543: case 6: /* NO DIALTONE */
2544: if (dialdpy) printf("\r\n No Dialtone.\r\n");
2545: mdmstat = FAILED;
2546: break;
2547: case 7: /* BUSY */
2548: if (dialdpy) printf("\r\n Busy.\r\n");
2549: mdmstat = FAILED;
2550: break;
2551: case 8: /* NO ANSWER */
2552: if (dialdpy) printf("\r\n No Answer.\r\n");
2553: mdmstat = FAILED;
2554: break;
2555: case 9: /* CONNECT 2400 */
2556: case 10:
2557: spdchg(2400L); /* Change speed if necessary. */
2558: mdmstat = CONNECTED;
2559: break;
2560: case 11: /* CONNECT 4800 */
2561: spdchg(4800L);
2562: mdmstat = CONNECTED;
2563: break;
2564: case 12: /* CONNECT 9600 */
2565: spdchg(9600L);
2566: mdmstat = CONNECTED;
2567: break;
2568: case 13: /* CONNECT 14400 */
2569: spdchg(14400L);
2570: mdmstat = CONNECTED;
2571: break;
2572: case 14:
2573: spdchg(19200L); /* CONNECT 19200 */
2574: mdmstat = CONNECTED;
2575: break;
2576: case 15: /* CONNECT 34800 */
2577: spdchg(38400L);
2578: mdmstat = CONNECTED;
2579: break;
2580: case 16: /* CONNECT 57600 */
2581: spdchg(57600L);
2582: mdmstat = CONNECTED;
2583: break;
2584: case 20: /* CONNECT 300/REL */
2585: spdchg(300L);
2586: mdmstat = CONNECTED;
2587: break;
2588: case 22: /* CONNECT 1200/REL */
2589: spdchg(1200L);
2590: mdmstat = CONNECTED;
2591: break;
2592: case 23: /* CONNECT 2400/REL */
2593: spdchg(2400L);
2594: mdmstat = CONNECTED;
2595: break;
2596: case 46: /* CONNECT 7512 */
2597: spdchg(8880L); /* 75/1200 split speed */
2598: mdmstat = CONNECTED; /* (special C-Kermit code) */
2599: break;
2600: case 47: /* CONNECT 1200/75 */
2601: mdmstat = CONNECTED; /* Speed not supported by Kermit */
2602: printf("CONNECT 1200/75 - Not support by C-Kermit\r\n");
2603: break;
2604: case 48: /* CONNECT 7200 */
2605: spdchg(7200L);
2606: mdmstat = CONNECTED;
2607: break;
2608: case 49: /* CONNECT 12000 */
2609: spdchg(12000L);
2610: mdmstat = CONNECTED;
2611: break;
2612: #ifndef MINIDIAL
2613: case 50: /* CONNECT FAST */
2614: if (mymdmtyp == n_TELEBIT) /* Early models only */
2615: mdmstat = CONNECTED;
2616: break;
2617: case 52: /* RRING */
2618: if (mymdmtyp == n_TELEBIT)
2619: if (dialdpy) printf(" Ringing...\r\n");
2620: break;
2621: case 53: /* DIALING */
2622: if (mymdmtyp == n_TELEBIT)
2623: if (dialdpy) printf(" Dialing...\r\n");
2624: break;
2625: case 54: /* NO PROMPTTONE */
2626: if (mymdmtyp == n_TELEBIT) {
2627: if (dialdpy) printf("\r\n No Prompttone.\r\n");
2628: mdmstat = FAILED;
2629: }
2630: break;
2631: case 61: /* Various Telebit PEP modes */
2632: case 62:
2633: case 63:
2634: case 70:
2635: case 71:
2636: case 72:
2637: case 73:
2638: if (mymdmtyp == n_TELEBIT) /* Early models only */
2639: mdmstat = CONNECTED;
2640: break;
2641: #endif /* MINIDIAL */
2642: default:
2643: break;
2644: }
2645: }
2646: if (mdmstat == CONNECTED && nbuf[j] != '\0') {
2647: if (dialdpy) {
2648: printf("\r\n");
2649: if (nbuf[j] == 'R') printf("RELIABLE");
2650: if (nbuf[j] == 'L') printf("LAPM");
2651: if (nbuf[j+1] == 'C') printf(" COMPRESSED");
2652: printf("\r\n");
2653: }
2654: }
2655: }
2656: break;
2657:
2658: case n_UNKNOWN: {
2659: int x, y = waitct;
2660: mdmstat = FAILED; /* Assume failure. */
2661: while (y-- > -1) {
2662: x = ttchk();
2663: if (x > 0) {
2664: if (x > LBUFL) x = LBUFL;
2665: x = ttxin(x,(CHAR *)lbuf);
2666: if ((x > 0) && dialdpy) conol(lbuf);
2667: }
2668: x = ttgmdm(); /* Try to read modem signals */
2669: if (x < 0) break; /* Can't, fail. */
2670: if (x & BM_DCD) { /* Got signals OK. Carrier present? */
2671: mdmstat = CONNECTED; /* Yes, done. */
2672: break;
2673: } /* No, keep waiting. */
2674: sleep(1);
2675: }
2676: break;
2677: }
2678: } /* switch (augmdmtyp) */
2679: } /* while (mdmstat == 0) */
2680: x = alarm(0); /* Turn off alarm. */
2681: debug(F101,"ckdial alarm off","",x);
2682: if ( mdmstat != CONNECTED ) { /* Modem-detected failure */
2683: n1 = F_modem;
2684: longjmp( sjbuf, F_modem ); /* Exit (with reason in lbuf) */
2685: }
2686: msleep(1000); /* In case DTR blinks */
2687: alarm(3); /* Precaution in case of trouble */
2688: debug(F110,"dial","succeeded",0);
2689: #ifndef MINIDIAL
2690: if (augmdmtyp != n_ROLM) /* Rolm has wierd modem signaling */
2691: #endif /* MINIDIAL */
2692: ttpkt(speed,FLO_DIAX,parity); /* Cancel dialing state ioctl */
2693: dreset(); /* Reset alarms, etc. */
2694: if (!quiet && !backgrd)
2695: printf (" Call complete.\07\n");
2696: #ifdef DYNAMIC
2697: if (lbuf) free(lbuf);
2698: #endif /* DYNAMIC */
2699: return(1); /* Return successfully */
2700: }
2701:
2702: /*
2703: getok() - wait up to n seconds for OK (0) or ERROR (4) response from modem.
2704: Use with Hayeslike or CCITT modems for reading the reply to a nondialing
2705: command.
2706:
2707: Second argument says whether to be strict about numeric result codes, i.e.
2708: to require they be preceded by CR or else be the first character in the
2709: response, e.g. to prevent the ATH0<CR> echo from looking like a valid
2710: response. Strict == 0 is needed for ATI on Telebit, which can return the
2711: model number concatenated with the numeric response code, e.g. "9620"
2712: ("962" is the model number, "0" is the response code). getok() Returns:
2713:
2714: 0 if it timed out,
2715: 1 if it succeeded,
2716: -1 on modem command, i/o, or other error.
2717: */
2718: static jmp_buf okbuf; /* Jump-buf for getok(). */
2719:
2720: SIGTYP
2721: oktimo(foo) int foo; { /* Alarm handler for getok(). */
2722: #ifdef OSK /* OS-9, see comment in dialtime(). */
2723: sigmask(-1);
2724: #endif /* OSK */
2725: longjmp(okbuf,1);
2726: }
2727:
2728: int
2729: getok(n, strict) int n, strict; {
2730: CHAR c;
2731: int i, x, status, oldalarm;
2732: SIGTYP (*saval)(); /* For saving alarm handler locally */
2733:
2734: mdmecho = 0; /* Assume no echoing of commands */
2735: saval = signal(SIGALRM,oktimo); /* Set response timer, */
2736: oldalarm = alarm(n); /* saving old one. */
2737: if (setjmp(okbuf)) { /* Timed out. */
2738: alarm(oldalarm); /* Restore old alarm */
2739: if (saval) signal(SIGALRM,saval); /* and alarm handler */
2740: debug(F100,"getok timeout","",0);
2741: ttflui(); /* Flush input buffer */
2742: return(0); /* and return timeout indication */
2743:
2744: } else if (augmdmtyp == n_CCITT /* CCITT, easy... */
2745: #ifndef MINIDIAL
2746: || augmdmtyp == n_DIGITEL /* Digitel, ditto. */
2747: #endif /* MINIDIAL */
2748: ) {
2749: waitfor("VAL");
2750: return(1);
2751:
2752: } else { /* Hayes & friends, start here... */
2753: status = 0; /* No status yet. */
2754: for (x = 0; x < RBUFL; x++) /* Initialize response buffer */
2755: rbuf[x] = SP; /* to all spaces */
2756: rbuf[RBUFL] = NUL; /* and terminate with NUL. */
2757: while (status == 0) { /* While no status... */
2758: x = ddinc(0); /* Read a character */
2759: if (x < 0) { /* I/O error */
2760: alarm(oldalarm); /* Turn off alarm */
2761: if (saval) signal(SIGALRM,saval); /* and restore handler. */
2762: return(-1); /* Return error code. */
2763: }
2764: debug(F101,"getok ddinc","",x); /* Got a character. */
2765: c = x & 0x7f; /* Get low order 7 bits */
2766: if (!c) /* Don't deposit NULs */
2767: continue; /* or else didweget() won't work */
2768: if (dialdpy) conoc((char)c); /* Echo it if requested */
2769: for (i = 0; i < RBUFL-1; i++) /* Rotate buffer */
2770: rbuf[i] = rbuf[i+1];
2771: rbuf[RBUFL-1] = c; /* Deposit character at end */
2772: debug(F000,"getok:",rbuf,(int) c); /* Log it */
2773: switch (c) { /* Interpret it. */
2774: case CR: /* Got a carriage return. */
2775: switch(rbuf[RBUFL-2]) { /* Look at character before it. */
2776: case '0': /* 0 = OK numeric response */
2777: if (!strict ||
2778: rbuf[RBUFL-3] == CR || rbuf[RBUFL-3] == SP) {
2779: augmdmtyp |= DIAL_NV; /* OR in the "nonverbal" bit. */
2780: status = 1; /* Good response */
2781: }
2782: break;
2783: case '4': /* 4 = ERROR numeric response */
2784: if (!strict ||
2785: rbuf[RBUFL-3] == CR || rbuf[RBUFL-3] == SP) {
2786: augmdmtyp |= DIAL_NV; /* OR in the nonverbal bit. */
2787: status = -1; /* Bad command */
2788: }
2789: break;
2790: }
2791: if (dialdpy && (augmdmtyp & DIAL_NV)) /* If numeric results, */
2792: conoc(LF); /* echo a linefeed too. */
2793: break;
2794: case LF: /* Got a linefeed. */
2795: /*
2796: Note use of explicit octal codes in the string for
2797: CR and LF. We want real CR and LF here, not whatever
2798: the compiler happens to define \r and \n as...
2799: */
2800: if (!strcmp(rbuf+RBUFL-4,"OK\015\012")) /* Good response */
2801: status = 1;
2802: else if (!strcmp(rbuf+RBUFL-7,"ERROR\015\012")) /* Error */
2803: status = -1;
2804: augmdmtyp &= ~(DIAL_NV); /* Turn off the nonverbal bit */
2805: break;
2806: /* Check whether modem echoes its commands... */
2807: case 't': /* Got little t */
2808: if (!strcmp(rbuf+RBUFL-3,"\015at") || /* See if it's "at" */
2809: !strcmp(rbuf+RBUFL-3," at"))
2810: mdmecho = 1;
2811: debug(F111,"MDMECHO-t",rbuf+RBUFL-2,mdmecho);
2812: break;
2813: case 'T': /* Got Big T */
2814: if (!strcmp(rbuf+RBUFL-3,"\015AT") || /* See if it's "AT" */
2815: !strcmp(rbuf+RBUFL-3," AT"))
2816: mdmecho = 1;
2817: debug(F111,"MDMECHO-T",rbuf+RBUFL-3,mdmecho);
2818: break;
2819: default: /* Other characters, accumulate. */
2820: status = 0;
2821: break;
2822: }
2823: }
2824: debug(F101,"getok returns","",status);
2825: alarm(oldalarm); /* Restore previous alarm */
2826: if (saval) signal(SIGALRM,saval); /* and handler */
2827: ttflui(); /* Flush input buffer */
2828: return(status); /* Return status */
2829: }
2830: }
2831:
2832: /* Maybe hang up the phone, depending on various SET DIAL parameters. */
2833:
2834: int
2835: dialhup() {
2836: int x = 0;
2837: if (dialhng) { /* DIAL HANGUP ON? */
2838: x = mdmhup(); /* Try modem-specific method first */
2839: debug(F101,"dialhup mdmhup","",x);
2840: if (x > 0) { /* If it worked, */
2841: if (dialdpy)
2842: printf(" Modem hangup OK\r\n"); /* fine. */
2843: } else if (network) { /* If we're telnetted to */
2844: if (dialdpy) /* a modem server, just print a msg */
2845: printf(" Warning: modem hangup failed\r\n"); /* don't hangup! */
2846: return(0);
2847: } else { /* Otherwise */
2848: x = tthang(); /* Tell the OS to turn off DTR. */
2849: if (dialdpy) { /* DIAL DISPLAY ON? */
2850: if (x > 0) /* Yes, tell results from tthang() */
2851: printf(" Hangup OK\r\n");
2852: else if (x == 0)
2853: printf(" Hangup skipped\r\n");
2854: else
2855: perror(" Hangup error");
2856: }
2857: }
2858: } else if (dialdpy) printf(" Hangup skipped\r\n"); /* DIAL HANGUP OFF */
2859: return(x);
2860: }
2861:
2862: /*
2863: M D M H U P --
2864:
2865: Sends escape sequence to modem, then sends its hangup command. Returns:
2866: 0: If modem type is 0 (direct serial connection),
2867: or if modem type is < 0 (network connection),
2868: or if no action taken because DIAL MODEM-HANGUP is OFF)
2869: or because no hangup string for current modem type,
2870: or C-Kermit is in remote mode,
2871: or if action taken but there was no positive response from modem;
2872: 1: Success: modem is in command state and acknowledged the hangup command;
2873: -1: On modem command error.
2874: */
2875: int
2876: mdmhup() {
2877: #ifdef MDMHUP
2878: MDMINF *p; /* Modem info structure pointer */
2879: int m, x = 0;
2880:
2881: if (dialmhu == 0 || local == 0) /* If DIAL MODEM-HANGUP is OFF, */
2882: return(0); /* or not in local mode, fail. */
2883:
2884: #ifdef OS2
2885: /*
2886: In OS/2, if CARRIER is OFF, and there is indeed no carrier signal, any
2887: attempt to do i/o at this point can hang the program. This might be true
2888: for other operating systems too.
2889: */
2890: if (!network) { /* Not a network connection */
2891: m = ttgmdm(); /* Get modem signals */
2892: if ((m > -1) && (m & BM_DCD == 0)) /* Check for carrier */
2893: return(0); /* No carrier, skip the rest */
2894: }
2895: #endif /* OS2 */
2896:
2897: m = mdmtyp & 0xff; /* Get basic modem type (no bits!). */
2898: if ((m < 1) || (m > MAX_MDM)) /* If modem type not in range, */
2899: return(0); /* fail. */
2900: p = ptrtab[m-1]; /* Get modem info pointer */
2901: if (!(p->hup_str) || !*(p->hup_str)) { /* No hangup string? */
2902: debug(F100,"mdmhup no hup_str","",0); /* No, */
2903: return(0); /* fail. */
2904: } else {
2905: debug(F110,"mdmhup hup_str",p->hup_str,0); /* Yes. */
2906: if (p->esc_str && *(p->esc_str)) { /* Have escape sequence? */
2907: debug(F110,"mdmhup esc_str",p->esc_str,0);
2908: debug(F101,"mdmhup esc_time","",p->esc_time);
2909: if (ttpkt(speed,FLO_DIAL,parity) < 0) /* Condition line */
2910: return(-1); /* for dialing. */
2911: if (p->esc_time) /* If we have a guard time */
2912: msleep(p->esc_time); /* Pause for guard time */
2913: #ifdef NETCONN
2914: /* Send modem's escape sequence */
2915: if (network) { /* Must catch errors here. */
2916: if (ttol((CHAR *)(p->esc_str),(int)strlen(p->esc_str)) < 0)
2917: return(-1);
2918: } else {
2919: ttslow(p->esc_str,p->wake_rate); /* Send escape sequence */
2920: }
2921: #else
2922: ttslow(p->esc_str,p->wake_rate); /* Send escape sequence */
2923: #endif /* NETCONN */
2924: if (p->esc_time) /* Pause for guard time again */
2925: msleep(p->esc_time);
2926: msleep(500); /* Wait half a sec for echoes. */
2927: ttflui(); /* Flush response or echo, if any */
2928: }
2929: #ifdef NETCONN
2930: /* Send modem's hangup command */
2931: if (network) { /* Must catch errors here. */
2932: if (ttol((CHAR *)(p->hup_str),(int)strlen(p->hup_str)) < 0)
2933: return(-1);
2934: } else {
2935: ttslow(p->hup_str,p->wake_rate);
2936: }
2937: #else
2938: ttslow(p->hup_str,p->wake_rate); /* Now Send hangup string */
2939: #endif /* NETCONN */
2940: if (p->ok_fn) { /* Look for OK response */
2941: x = (*(p->ok_fn))(3,1); /* Give it 3 seconds, be strict. */
2942: debug(F101,"mdmhup hangup response","",x);
2943: } else { /* No OK function, */
2944: x = 1; /* so assume it worked */
2945: debug(F101,"mdmhup no ok_fn","",x);
2946: }
2947: return(x); /* Return OK function's return code. */
2948: }
2949: #else /* MDMHUP not defined. */
2950: return(0); /* Always fail. */
2951: #endif /* MDMHUP */
2952: }
2953:
2954: char * /* Let external routines ask */
2955: getdws(mdmtyp) int mdmtyp; { /* about dial init-string. */
2956: MDMINF * p;
2957: if ((mdmtyp & 0xff) < 1 || (mdmtyp & 0xff) > MAX_MDM)
2958: return("");
2959: p = ptrtab[(mdmtyp & 0xff) -1];
2960: return(dialini ? dialini : p->wake_str);
2961: }
2962:
2963: char *
2964: getdcs(mdmtyp) int mdmtyp; { /* Same deal for dial-command */
2965: MDMINF * p;
2966: if ((mdmtyp & 0xff) < 1 || (mdmtyp & 0xff) > MAX_MDM)
2967: return("");
2968: p = ptrtab[(mdmtyp & 0xff) -1];
2969: return(dialcmd ? dialcmd : p->dial_str);
2970: }
2971:
2972: #else /* NODIAL */
2973:
2974: char *dialv = "Dial Command Disabled";
2975:
2976: int /* To allow NODIAL versions to */
2977: mdmhup() { /* call mdmhup(), so calls to */
2978: return(0); /* mdmhup() need not be within */
2979: } /* #ifndef NODIAL conditionals */
2980:
2981: #endif /* NODIAL */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.