2 * Copyright (c) 1986, 1993
3 * The Regents of the University of California. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. All advertising materials mentioning features or use of this software
14 * must display the following acknowledgement:
15 * This product includes software developed by the University of
16 * California, Berkeley and its contributors.
17 * 4. Neither the name of the University nor the names of its contributors
18 * may be used to endorse or promote products derived from this software
19 * without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * @(#)unidialer.c 8.1 (Berkeley) 6/6/93
34 * $FreeBSD: src/usr.bin/tip/libacu/unidialer.c,v 1.7 1999/08/28 01:06:30 peter Exp $
35 * $DragonFly: src/usr.bin/tip/libacu/unidialer.c,v 1.4 2005/05/07 23:20:43 corecode Exp $
39 * Generalized routines for calling up on a Hayes AT command set based modem.
40 * Control variables are pulled out of a modem caps-style database to
41 * configure the driver for a particular modem.
45 #include "pathnames.h"
47 #include <sys/times.h>
53 #include "acucommon.h"
61 mpt_notype, mpt_string, mpt_number, mpt_boolean
65 modem_parm_type_t modem_parm_type;
80 static char modem_name [80];
81 static char *dial_command;
82 static char *hangup_command;
83 static char *echo_off_command;
84 static char *reset_command;
85 static char *init_string;
86 static char *escape_sequence;
87 static int hw_flow_control;
89 static unsigned int intercharacter_delay;
90 static unsigned int intercommand_delay;
91 static unsigned int escape_guard_time;
92 static unsigned int reset_delay;
94 static int unidialer_dialer (register char *num, char *acu);
95 static void unidialer_disconnect ();
96 static void unidialer_abort ();
97 static int unidialer_connect(void);
98 static int unidialer_swallow(char *);
100 static acu_t unidialer =
104 unidialer_disconnect,
109 Table of parameters kept in modem database
111 modem_parm_t modem_parms [] = {
112 { mpt_string, "dial_command", &dial_command, "ATDT%s\r" },
113 { mpt_string, "hangup_command", &hangup_command, "ATH\r", },
114 { mpt_string, "echo_off_command", &echo_off_command, "ATE0\r" },
115 { mpt_string, "reset_command", &reset_command, "ATZ\r" },
116 { mpt_string, "init_string", &init_string, "AT&F\r", },
117 { mpt_string, "escape_sequence", &escape_sequence, "+++" },
118 { mpt_boolean, "hw_flow_control", (char **)&hw_flow_control, NULL },
119 { mpt_boolean, "lock_baud", (char **)&lock_baud, NULL },
120 { mpt_number, "intercharacter_delay", (char **)&intercharacter_delay, (char *)50 },
121 { mpt_number, "intercommand_delay", (char **)&intercommand_delay, (char *)300 },
122 { mpt_number, "escape_guard_time", (char **)&escape_guard_time, (char *)300 },
123 { mpt_number, "reset_delay", (char **)&reset_delay, (char *)3000 },
124 { mpt_notype, NULL, NULL, NULL }
130 static void unidialer_verbose_read ();
131 static void unidialer_modem_cmd (int fd, CONST char *cmd);
132 static void unidialer_write (int fd, CONST char *cp, int n);
133 static void unidialer_write_str (int fd, CONST char *cp);
134 static void unidialer_disconnect ();
135 static void sigALRM ();
136 static int unidialersync ();
137 static int unidialer_swallow (register char *match);
142 static int timeout = 0;
143 static int connected = 0;
144 static jmp_buf timeoutbuf, intbuf;
146 #define cgetflag(f) (cgetcap(bp, f, ':') != NULL)
150 #define print_str(x) printf (#x " = %s\n", x)
151 #define print_num(x) printf (#x " = %d\n", x)
153 void dumpmodemparms (char *modem)
155 printf ("modem parms for %s\n", modem);
156 print_str (dial_command);
157 print_str (hangup_command);
158 print_str (echo_off_command);
159 print_str (reset_command);
160 print_str (init_string);
161 print_str (escape_sequence);
162 print_num (lock_baud);
163 print_num (intercharacter_delay);
164 print_num (intercommand_delay);
165 print_num (escape_guard_time);
166 print_num (reset_delay);
171 static int getmodemparms (const char *modem)
173 char *bp, *db_array [3], *modempath;
177 modempath = getenv ("MODEMS");
181 if (modempath != NULL)
182 db_array [ndx++] = modempath;
184 db_array [ndx++] = _PATH_MODEMS;
185 db_array [ndx] = NULL;
187 if ((stat = cgetent (&bp, db_array, (char *)modem)) < 0) {
190 warnx ("unknown modem %s", modem);
193 warnx ("can't open modem description file");
196 warnx ("possible reference loop in modem description file");
201 for (mpp = modem_parms; mpp->name; mpp++)
203 switch (mpp->modem_parm_type)
206 if (cgetstr (bp, (char *)mpp->name, mpp->value.string) == -1)
207 *mpp->value.string = mpp->default_value.string;
213 if (cgetnum (bp, (char *)mpp->name, &l) == -1)
214 *mpp->value.number = mpp->default_value.number;
216 *mpp->value.number = (unsigned int)l;
221 *mpp->value.number = cgetflag ((char *)mpp->name);
225 strncpy (modem_name, modem, sizeof (modem_name) - 1);
226 modem_name [sizeof (modem_name) - 1] = '\0';
232 acu_t* unidialer_getmodem (const char *modem_name)
235 if (getmodemparms (modem_name))
240 static int unidialer_modem_ready ()
244 ioctl (FD, TIOCMGET, &state);
245 return (state & TIOCM_DSR) ? 1 : 0;
251 static int unidialer_waitfor_modem_ready (int ms)
255 for (count = 0; count < ms; count += 100)
257 if (unidialer_modem_ready ())
260 printf ("unidialer_waitfor_modem_ready: modem ready.\n");
273 int unidialer_tty_clocal (int flag)
281 t.c_cflag &= ~CLOCAL;
282 tcsetattr (FD, TCSANOW, &t);
283 #elif defined(TIOCMSET)
286 Don't have CLOCAL so raise CD in software to
289 ioctl (FD, TIOCMGET, &state);
294 ioctl (FD, TIOCMSET, &state);
298 int unidialer_get_modem_response (char *buf, int bufsz, int response_timeout)
301 char c, *p = buf, *lid = buf + bufsz - 1;
306 f = signal (SIGALRM, sigALRM);
310 if (setjmp (timeoutbuf)) {
314 printf ("get_response: timeout buf=%s, state=%d\n", buf, state);
319 ualarm (response_timeout * 1000, 0);
328 if (read (FD, &c, 1) == 1)
337 printf ("get_response: unexpected char %s.\n", ctrl (c));
344 if (read (FD, &c, 1) == 1)
349 printf ("get_response: <CRLF> encountered.\n", buf);
357 printf ("get_response: unexpected char %s.\n", ctrl (c));
364 if (read (FD, &c, 1) == 1)
368 else if (c >= ' ' && p < lid)
374 if (read (FD, &c, 1) == 1)
383 printf ("get_response: %s\n", buf);
398 int unidialer_get_okay (int ms)
402 okay = unidialer_get_modem_response (buf, sizeof (buf), ms) &&
403 strcmp (buf, "OK") == 0;
407 static int unidialer_dialer (register char *num, char *acu)
410 char dial_string [80];
416 dumpmodemparms (modem_name);
421 if ((i = speed(number(value(BAUDRATE)))) == 0)
426 if (boolean(value(VERBOSE)))
427 printf("Using \"%s\"\n", acu);
434 if (!unidialersync()) {
436 printf("tip: can't synchronize with %s\n", modem_name);
438 logent(value(HOST), num, modem_name, "can't synch up");
443 unidialer_modem_cmd (FD, echo_off_command); /* turn off echoing */
448 if (boolean(value(VERBOSE)))
449 unidialer_verbose_read();
452 acu_flush (); /* flush any clutter */
454 unidialer_modem_cmd (FD, init_string);
456 if (!unidialer_get_okay (reset_delay))
461 for (cp = num; *cp; cp++)
465 (void) sprintf (dial_string, dial_command, num);
467 unidialer_modem_cmd (FD, dial_string);
469 connected = unidialer_connect ();
471 if (connected && hw_flow_control) {
472 acu_hw_flow_control (hw_flow_control);
477 sprintf(line, "%d second dial timeout",
478 number(value(DIALTIMEOUT)));
479 logent(value(HOST), num, modem_name, line);
484 unidialer_disconnect ();
489 static void unidialer_disconnect ()
493 acu_flush (); /* flush any clutter */
495 unidialer_tty_clocal (TRUE);
497 /* first hang up the modem*/
498 ioctl (FD, TIOCCDTR, 0);
500 ioctl (FD, TIOCSDTR, 0);
503 * If AT&D2, then dropping DTR *should* just hangup the modem. But
504 * some modems reset anyway; also, the modem may be programmed to reset
505 * anyway with AT&D3. Play it safe and wait for the full reset time before
508 acu_nap (reset_delay);
510 if (!unidialer_waitfor_modem_ready (reset_delay))
513 printf ("unidialer_disconnect: warning CTS low.\r\n");
518 * If not strapped for DTR control, try to get command mode.
520 for (retries = okay = 0; retries < MAXRETRY && !okay; retries++)
523 /* flush any clutter */
527 printf ("unidialer_disconnect: warning flush failed.\r\n");
530 timeout_value = escape_guard_time;
531 timeout_value += (timeout_value * retries / MAXRETRY);
532 acu_nap (timeout_value);
533 acu_flush (); /* flush any clutter */
534 unidialer_modem_cmd (FD, escape_sequence);
535 acu_nap (timeout_value);
536 unidialer_modem_cmd (FD, hangup_command);
537 okay = unidialer_get_okay (reset_delay);
542 logent(value(HOST), "", modem_name, "can't hang up modem");
544 if (boolean(value(VERBOSE)))
545 printf("hang up failed\n");
551 static void unidialer_abort ()
553 unidialer_write_str (FD, "\r"); /* send anything to abort the call */
554 unidialer_disconnect ();
557 static void sigALRM ()
559 (void) printf("\07timeout waiting for reply\n");
561 longjmp(timeoutbuf, 1);
564 static int unidialer_swallow (register char *match)
569 f = signal(SIGALRM, sigALRM);
573 if (setjmp(timeoutbuf)) {
578 alarm(number(value(DIALTIMEOUT)));
591 if (boolean(value(VERBOSE)))
597 } while (c == *match++);
598 signal(SIGALRM, SIG_DFL);
601 if (boolean(value(VERBOSE)))
607 static struct baud_msg {
619 static int unidialer_connect ()
627 if (unidialer_swallow("\r\n") == 0)
629 f = signal(SIGALRM, sigALRM);
631 nc = 0; nl = sizeof(dialer_buf)-1;
632 bzero(dialer_buf, sizeof(dialer_buf));
634 for (nc = 0, nl = sizeof(dialer_buf)-1 ; nl > 0 ; nc++, nl--) {
635 if (setjmp(timeoutbuf))
637 alarm(number(value(DIALTIMEOUT)));
644 if (unidialer_swallow("\n") == 0)
648 if (strcmp(dialer_buf, "RINGING") == 0 &&
649 boolean(value(VERBOSE))) {
651 printf("%s\r\n", dialer_buf);
655 if (strncmp(dialer_buf, "CONNECT",
656 sizeof("CONNECT")-1) != 0)
661 if (boolean(value(VERBOSE)))
662 printf("%s\r\n", dialer_buf);
666 for (bm = baud_msg ; bm->msg ; bm++)
667 if (strcmp(bm->msg, dialer_buf+sizeof("CONNECT")-1) == 0) {
668 if (!acu_setspeed (bm->baud))
672 if (boolean(value(VERBOSE)))
673 printf("%s\r\n", dialer_buf);
682 printf("%s\r\n", dialer_buf);
689 * This convoluted piece of code attempts to get
690 * the unidialer in sync.
692 static int unidialersync ()
698 while (already++ < MAXRETRY) {
699 acu_nap (intercommand_delay);
700 acu_flush (); /* flush any clutter */
701 unidialer_write_str (FD, reset_command); /* reset modem */
702 bzero(buf, sizeof(buf));
703 acu_nap (reset_delay);
704 ioctl (FD, FIONREAD, &len);
706 len = read(FD, buf, sizeof(buf));
709 printf("unidialersync (%s): (\"%s\")\n\r", modem_name, buf);
711 if (index(buf, '0') ||
712 (index(buf, 'O') && index(buf, 'K')))
716 * If not strapped for DTR control,
717 * try to get command mode.
719 acu_nap (escape_guard_time);
720 unidialer_write_str (FD, escape_sequence);
721 acu_nap (escape_guard_time);
722 unidialer_write_str (FD, hangup_command);
724 * Toggle DTR to force anyone off that might have left
725 * the modem connected.
727 acu_nap (escape_guard_time);
728 ioctl (FD, TIOCCDTR, 0);
730 ioctl (FD, TIOCSDTR, 0);
732 acu_nap (intercommand_delay);
733 unidialer_write_str (FD, reset_command);
738 Send commands to modem; impose delay between commands.
740 static void unidialer_modem_cmd (int fd, const char *cmd)
742 static struct timeval oldt = { 0, 0 };
745 if (tod_lt (&newt, &oldt))
747 unsigned int naptime;
748 tod_subfrom (&oldt, newt);
749 naptime = oldt.tv_sec * 1000 + oldt.tv_usec / 1000;
750 if (naptime > intercommand_delay)
753 printf ("unidialer_modem_cmd: suspicious naptime (%u ms)\r\n", naptime);
755 naptime = intercommand_delay;
758 printf ("unidialer_modem_cmd: delaying %u ms\r\n", naptime);
762 unidialer_write_str (fd, cmd);
765 newt.tv_usec = intercommand_delay;
766 tod_addto (&oldt, &newt);
769 static void unidialer_write_str (int fd, const char *cp)
772 printf ("unidialer (%s): sending %s\n", modem_name, cp);
774 unidialer_write (fd, cp, strlen (cp));
777 static void unidialer_write (int fd, const char *cp, int n)
779 acu_nap (intercharacter_delay);
780 for ( ; n-- ; cp++) {
782 acu_nap (intercharacter_delay);
787 static void unidialer_verbose_read()
792 if (ioctl(FD, FIONREAD, &n) < 0)
796 if (read(FD, buf, n) != n)
802 /* end of unidialer.c */