1 /* 2 * Copyright (c) 1986, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 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. Neither the name of the University nor the names of its contributors 14 * may be used to endorse or promote products derived from this software 15 * without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * @(#)unidialer.c 8.1 (Berkeley) 6/6/93 30 * $FreeBSD: src/usr.bin/tip/libacu/unidialer.c,v 1.7 1999/08/28 01:06:30 peter Exp $ 31 */ 32 33 /* 34 * Generalized routines for calling up on a Hayes AT command set based modem. 35 * Control variables are pulled out of a modem caps-style database to 36 * configure the driver for a particular modem. 37 */ 38 #include "tip.h" 39 #include "pathnames.h" 40 41 #include <sys/times.h> 42 #include <assert.h> 43 #include <err.h> 44 #include <stdio.h> 45 #include <stdlib.h> 46 47 #include "acucommon.h" 48 #include "tod.h" 49 50 /* #define DEBUG */ 51 #define MAXRETRY 5 52 53 typedef enum 54 { 55 mpt_notype, mpt_string, mpt_number, mpt_boolean 56 } modem_parm_type_t; 57 58 typedef struct { 59 modem_parm_type_t modem_parm_type; 60 const char *name; 61 union { 62 char **string; 63 unsigned int *number; 64 } value; 65 union { 66 char *string; 67 unsigned int number; 68 } default_value; 69 } modem_parm_t; 70 71 /* 72 Configuration 73 */ 74 static char modem_name [80]; 75 static char *dial_command; 76 static char *hangup_command; 77 static char *echo_off_command; 78 static char *reset_command; 79 static char *init_string; 80 static char *escape_sequence; 81 static int hw_flow_control; 82 static int lock_baud; 83 static unsigned int intercharacter_delay; 84 static unsigned int intercommand_delay; 85 static unsigned int escape_guard_time; 86 static unsigned int reset_delay; 87 88 static int unidialer_dialer(char *num, char *acu); 89 static void unidialer_disconnect(void); 90 static void unidialer_abort(void); 91 static int unidialer_connect(void); 92 static int unidialer_swallow(char *); 93 #ifdef DEBUG 94 static void unidialer_verbose_read (void); 95 #endif 96 static void unidialer_modem_cmd(int fd, const char *cmd); 97 static void unidialer_write(int fd, const char *cp, int n); 98 static void unidialer_write_str(int fd, const char *cp); 99 static void sigALRM(int); 100 static int unidialersync(void); 101 102 static acu_t unidialer = 103 { 104 modem_name, 105 unidialer_dialer, 106 unidialer_disconnect, 107 unidialer_abort 108 }; 109 110 /* 111 Table of parameters kept in modem database 112 */ 113 modem_parm_t modem_parms [] = { 114 { mpt_string, "dial_command", { &dial_command }, { "ATDT%s\r" } }, 115 { mpt_string, "hangup_command", { &hangup_command }, { "ATH\r", } }, 116 { mpt_string, "echo_off_command", { &echo_off_command }, { "ATE0\r" } }, 117 { mpt_string, "reset_command", { &reset_command }, { "ATZ\r" } }, 118 { mpt_string, "init_string", { &init_string }, { "AT{ &F\r", } }, 119 { mpt_string, "escape_sequence", { &escape_sequence }, { "+++" } }, 120 { mpt_boolean, "hw_flow_control", { (char **)&hw_flow_control }, { NULL } }, 121 { mpt_boolean, "lock_baud", { (char **)&lock_baud }, { NULL } }, 122 { mpt_number, "intercharacter_delay", { (char **)&intercharacter_delay }, { (char *)50 } }, 123 { mpt_number, "intercommand_delay", { (char **)&intercommand_delay }, { (char *)300 } }, 124 { mpt_number, "escape_guard_time", { (char **)&escape_guard_time }, { (char *)300 } }, 125 { mpt_number, "reset_delay", { (char **)&reset_delay }, { (char *)3000 } }, 126 { mpt_notype, NULL, { NULL }, { NULL } } 127 }; 128 129 /* 130 Global vars 131 */ 132 static int timeout = 0; 133 static int connected = 0; 134 static jmp_buf timeoutbuf; 135 136 #define cgetflag(f) (cgetcap(bp, f, ':') != NULL) 137 138 #ifdef DEBUG 139 140 #define print_str(x) printf (#x " = %s\n", x) 141 #define print_num(x) printf (#x " = %d\n", x) 142 143 void dumpmodemparms (char *modem) 144 { 145 printf ("modem parms for %s\n", modem); 146 print_str (dial_command); 147 print_str (hangup_command); 148 print_str (echo_off_command); 149 print_str (reset_command); 150 print_str (init_string); 151 print_str (escape_sequence); 152 print_num (lock_baud); 153 print_num (intercharacter_delay); 154 print_num (intercommand_delay); 155 print_num (escape_guard_time); 156 print_num (reset_delay); 157 printf ("\n"); 158 } 159 #endif 160 161 static int getmodemparms (const char *modem) 162 { 163 char *bp, *db_array [3], *modempath; 164 int ndx, stat; 165 modem_parm_t *mpp; 166 167 modempath = getenv ("MODEMS"); 168 169 ndx = 0; 170 171 if (modempath != NULL) 172 db_array [ndx++] = modempath; 173 174 db_array [ndx++] = _PATH_MODEMS; 175 db_array [ndx] = NULL; 176 177 if ((stat = cgetent (&bp, db_array, (char *)modem)) < 0) { 178 switch (stat) { 179 case -1: 180 warnx ("unknown modem %s", modem); 181 break; 182 case -2: 183 warnx ("can't open modem description file"); 184 break; 185 case -3: 186 warnx ("possible reference loop in modem description file"); 187 break; 188 } 189 return 0; 190 } 191 for (mpp = modem_parms; mpp->name; mpp++) 192 { 193 switch (mpp->modem_parm_type) 194 { 195 case mpt_string: 196 if (cgetstr (bp, (char *)mpp->name, mpp->value.string) == -1) 197 *mpp->value.string = mpp->default_value.string; 198 break; 199 case mpt_number: 200 { 201 long l; 202 if (cgetnum (bp, (char *)mpp->name, &l) == -1) 203 *mpp->value.number = mpp->default_value.number; 204 else 205 *mpp->value.number = (unsigned int)l; 206 } 207 break; 208 case mpt_boolean: 209 *mpp->value.number = cgetflag ((char *)mpp->name); 210 break; 211 default: 212 break; 213 } 214 } 215 strncpy (modem_name, modem, sizeof (modem_name) - 1); 216 modem_name [sizeof (modem_name) - 1] = '\0'; 217 return 1; 218 } 219 220 /* 221 */ 222 acu_t * 223 unidialer_getmodem(const char *modem_name) 224 { 225 acu_t* rc = NULL; 226 if (getmodemparms (modem_name)) 227 rc = &unidialer; 228 return rc; 229 } 230 231 static int 232 unidialer_modem_ready(void) 233 { 234 int state; 235 ioctl (FD, TIOCMGET, &state); 236 return (state & TIOCM_DSR) ? 1 : 0; 237 } 238 239 static int unidialer_waitfor_modem_ready (int ms) 240 { 241 int count; 242 for (count = 0; count < ms; count += 100) 243 { 244 if (unidialer_modem_ready ()) 245 { 246 #ifdef DEBUG 247 printf ("unidialer_waitfor_modem_ready: modem ready.\n"); 248 #endif 249 break; 250 } 251 acu_nap (100); 252 } 253 return (count < ms); 254 } 255 256 static void 257 unidialer_tty_clocal(int flag) 258 { 259 struct termios t; 260 tcgetattr (FD, &t); 261 if (flag) 262 t.c_cflag |= CLOCAL; 263 else 264 t.c_cflag &= ~CLOCAL; 265 tcsetattr (FD, TCSANOW, &t); 266 } 267 268 static int 269 unidialer_get_modem_response(char *buf, int bufsz, int response_timeout) 270 { 271 sig_t f; 272 char c, *p = buf, *lid = buf + bufsz - 1; 273 int state; 274 275 assert (bufsz > 0); 276 277 f = signal (SIGALRM, sigALRM); 278 279 timeout = 0; 280 281 if (setjmp (timeoutbuf)) { 282 signal (SIGALRM, f); 283 *p = '\0'; 284 #ifdef DEBUG 285 printf ("get_response: timeout buf=%s\n", buf); 286 #endif 287 return (0); 288 } 289 290 ualarm (response_timeout * 1000, 0); 291 292 state = 0; 293 294 while (1) 295 { 296 switch (state) 297 { 298 case 0: 299 if (read (FD, &c, 1) == 1) 300 { 301 if (c == '\r') 302 { 303 ++state; 304 } 305 else 306 { 307 #ifdef DEBUG 308 printf ("get_response: unexpected char %s.\n", ctrl (c)); 309 #endif 310 } 311 } 312 break; 313 314 case 1: 315 if (read (FD, &c, 1) == 1) 316 { 317 if (c == '\n') 318 { 319 #ifdef DEBUG 320 printf ("get_response: <CRLF> encountered.\n"); 321 #endif 322 ++state; 323 } 324 else 325 { 326 state = 0; 327 #ifdef DEBUG 328 printf ("get_response: unexpected char %s.\n", ctrl (c)); 329 #endif 330 } 331 } 332 break; 333 334 case 2: 335 if (read (FD, &c, 1) == 1) 336 { 337 if (c == '\r') 338 ++state; 339 else if (c >= ' ' && p < lid) 340 *p++ = c; 341 } 342 break; 343 344 case 3: 345 if (read (FD, &c, 1) == 1) 346 { 347 if (c == '\n') 348 { 349 signal (SIGALRM, f); 350 /* ualarm (0, 0); */ 351 alarm (0); 352 *p = '\0'; 353 #ifdef DEBUG 354 printf ("get_response: %s\n", buf); 355 #endif 356 return (1); 357 } 358 else 359 { 360 state = 0; 361 p = buf; 362 } 363 } 364 break; 365 } 366 } 367 } 368 369 static int 370 unidialer_get_okay(int ms) 371 { 372 int okay; 373 char buf [BUFSIZ]; 374 okay = unidialer_get_modem_response (buf, sizeof (buf), ms) && 375 strcmp (buf, "OK") == 0; 376 return okay; 377 } 378 379 static int 380 unidialer_dialer(char *num, char *acu) 381 { 382 char *cp; 383 char dial_string [80]; 384 char line [80]; 385 386 #ifdef DEBUG 387 dumpmodemparms (modem_name); 388 #endif 389 390 if (lock_baud) { 391 int i; 392 if ((i = speed(number(value(BAUDRATE)))) == 0) 393 return 0; 394 ttysetup (i); 395 } 396 397 if (boolean(value(VERBOSE))) 398 printf("Using \"%s\"\n", acu); 399 400 acu_hupcl (); 401 402 /* 403 * Get in synch. 404 */ 405 if (!unidialersync()) { 406 badsynch: 407 printf("tip: can't synchronize with %s\n", modem_name); 408 logent(value(HOST), num, modem_name, "can't synch up"); 409 return (0); 410 } 411 412 unidialer_modem_cmd (FD, echo_off_command); /* turn off echoing */ 413 414 sleep(1); 415 416 #ifdef DEBUG 417 if (boolean(value(VERBOSE))) 418 unidialer_verbose_read(); 419 #endif 420 421 acu_flush (); /* flush any clutter */ 422 423 unidialer_modem_cmd (FD, init_string); 424 425 if (!unidialer_get_okay (reset_delay)) 426 goto badsynch; 427 428 fflush (stdout); 429 430 for (cp = num; *cp; cp++) 431 if (*cp == '=') 432 *cp = ','; 433 434 (void) sprintf (dial_string, dial_command, num); 435 436 unidialer_modem_cmd (FD, dial_string); 437 438 connected = unidialer_connect (); 439 440 if (connected && hw_flow_control) { 441 acu_hw_flow_control (hw_flow_control); 442 } 443 444 if (timeout) { 445 sprintf(line, "%d second dial timeout", 446 number(value(DIALTIMEOUT))); 447 logent(value(HOST), num, modem_name, line); 448 } 449 450 if (timeout) 451 unidialer_disconnect (); 452 453 return (connected); 454 } 455 456 static void 457 unidialer_disconnect(void) 458 { 459 int okay, retries; 460 461 acu_flush (); /* flush any clutter */ 462 463 unidialer_tty_clocal (TRUE); 464 465 /* first hang up the modem*/ 466 ioctl (FD, TIOCCDTR, 0); 467 acu_nap (250); 468 ioctl (FD, TIOCSDTR, 0); 469 470 /* 471 * If AT&D2, then dropping DTR *should* just hangup the modem. But 472 * some modems reset anyway; also, the modem may be programmed to reset 473 * anyway with AT&D3. Play it safe and wait for the full reset time before 474 * proceeding. 475 */ 476 acu_nap (reset_delay); 477 478 if (!unidialer_waitfor_modem_ready (reset_delay)) 479 { 480 #ifdef DEBUG 481 printf ("unidialer_disconnect: warning CTS low.\r\n"); 482 #endif 483 } 484 485 /* 486 * If not strapped for DTR control, try to get command mode. 487 */ 488 for (retries = okay = 0; retries < MAXRETRY && !okay; retries++) 489 { 490 int timeout_value; 491 /* flush any clutter */ 492 if (!acu_flush ()) 493 { 494 #ifdef DEBUG 495 printf ("unidialer_disconnect: warning flush failed.\r\n"); 496 #endif 497 } 498 timeout_value = escape_guard_time; 499 timeout_value += (timeout_value * retries / MAXRETRY); 500 acu_nap (timeout_value); 501 acu_flush (); /* flush any clutter */ 502 unidialer_modem_cmd (FD, escape_sequence); 503 acu_nap (timeout_value); 504 unidialer_modem_cmd (FD, hangup_command); 505 okay = unidialer_get_okay (reset_delay); 506 } 507 if (!okay) 508 { 509 logent(value(HOST), "", modem_name, "can't hang up modem"); 510 if (boolean(value(VERBOSE))) 511 printf("hang up failed\n"); 512 } 513 (void) acu_flush (); 514 close (FD); 515 } 516 517 static void 518 unidialer_abort(void) 519 { 520 unidialer_write_str (FD, "\r"); /* send anything to abort the call */ 521 unidialer_disconnect (); 522 } 523 524 static void 525 sigALRM(int signo) 526 { 527 (void) printf("\07timeout waiting for reply\n"); 528 timeout = 1; 529 longjmp(timeoutbuf, 1); 530 } 531 532 static int unidialer_swallow (char *match) 533 { 534 sig_t f; 535 char c; 536 537 f = signal(SIGALRM, sigALRM); 538 539 timeout = 0; 540 541 if (setjmp(timeoutbuf)) { 542 signal(SIGALRM, f); 543 return (0); 544 } 545 546 alarm(number(value(DIALTIMEOUT))); 547 548 do { 549 if (*match =='\0') { 550 signal(SIGALRM, f); 551 alarm (0); 552 return (1); 553 } 554 do { 555 read (FD, &c, 1); 556 } while (c == '\0'); 557 c &= 0177; 558 #ifdef DEBUG 559 if (boolean(value(VERBOSE))) 560 { 561 /* putchar(c); */ 562 printf (ctrl (c)); 563 } 564 #endif 565 } while (c == *match++); 566 signal(SIGALRM, SIG_DFL); 567 alarm(0); 568 #ifdef DEBUG 569 if (boolean(value(VERBOSE))) 570 fflush (stdout); 571 #endif 572 return (0); 573 } 574 575 static struct baud_msg { 576 char *msg; 577 int baud; 578 } baud_msg[] = { 579 { "", B300 }, 580 { " 1200", B1200 }, 581 { " 2400", B2400 }, 582 { " 9600", B9600 }, 583 { " 9600/ARQ", B9600 }, 584 { 0, 0 }, 585 }; 586 587 static int 588 unidialer_connect(void) 589 { 590 char c; 591 int nc, nl, n; 592 char dialer_buf[64]; 593 struct baud_msg *bm; 594 sig_t f; 595 596 if (unidialer_swallow("\r\n") == 0) 597 return (0); 598 f = signal(SIGALRM, sigALRM); 599 again: 600 nc = 0; nl = sizeof(dialer_buf)-1; 601 bzero(dialer_buf, sizeof(dialer_buf)); 602 timeout = 0; 603 for (nc = 0, nl = sizeof(dialer_buf)-1 ; nl > 0 ; nc++, nl--) { 604 if (setjmp(timeoutbuf)) 605 break; 606 alarm(number(value(DIALTIMEOUT))); 607 n = read(FD, &c, 1); 608 alarm(0); 609 if (n <= 0) 610 break; 611 c &= 0x7f; 612 if (c == '\r') { 613 if (unidialer_swallow("\n") == 0) 614 break; 615 if (!dialer_buf[0]) 616 goto again; 617 if (strcmp(dialer_buf, "RINGING") == 0 && 618 boolean(value(VERBOSE))) { 619 #ifdef DEBUG 620 printf("%s\r\n", dialer_buf); 621 #endif 622 goto again; 623 } 624 if (strncmp(dialer_buf, "CONNECT", 625 sizeof("CONNECT")-1) != 0) 626 break; 627 if (lock_baud) { 628 signal(SIGALRM, f); 629 #ifdef DEBUG 630 if (boolean(value(VERBOSE))) 631 printf("%s\r\n", dialer_buf); 632 #endif 633 return (1); 634 } 635 for (bm = baud_msg ; bm->msg ; bm++) 636 if (strcmp(bm->msg, dialer_buf+sizeof("CONNECT")-1) == 0) { 637 if (!acu_setspeed (bm->baud)) 638 goto error; 639 signal(SIGALRM, f); 640 #ifdef DEBUG 641 if (boolean(value(VERBOSE))) 642 printf("%s\r\n", dialer_buf); 643 #endif 644 return (1); 645 } 646 break; 647 } 648 dialer_buf[nc] = c; 649 } 650 printf("%s\r\n", dialer_buf); 651 error: 652 signal(SIGALRM, f); 653 return (0); 654 } 655 656 /* 657 * This convoluted piece of code attempts to get 658 * the unidialer in sync. 659 */ 660 static int 661 unidialersync(void) 662 { 663 int already = 0; 664 int len; 665 char buf[40]; 666 667 while (already++ < MAXRETRY) { 668 acu_nap (intercommand_delay); 669 acu_flush (); /* flush any clutter */ 670 unidialer_write_str (FD, reset_command); /* reset modem */ 671 bzero(buf, sizeof(buf)); 672 acu_nap (reset_delay); 673 ioctl (FD, FIONREAD, &len); 674 if (len) { 675 len = read(FD, buf, sizeof(buf)); 676 #ifdef DEBUG 677 buf [len] = '\0'; 678 printf("unidialersync (%s): (\"%s\")\n\r", modem_name, buf); 679 #endif 680 if (index(buf, '0') || 681 (index(buf, 'O') && index(buf, 'K'))) 682 return(1); 683 } 684 /* 685 * If not strapped for DTR control, 686 * try to get command mode. 687 */ 688 acu_nap (escape_guard_time); 689 unidialer_write_str (FD, escape_sequence); 690 acu_nap (escape_guard_time); 691 unidialer_write_str (FD, hangup_command); 692 /* 693 * Toggle DTR to force anyone off that might have left 694 * the modem connected. 695 */ 696 acu_nap (escape_guard_time); 697 ioctl (FD, TIOCCDTR, 0); 698 acu_nap (1000); 699 ioctl (FD, TIOCSDTR, 0); 700 } 701 acu_nap (intercommand_delay); 702 unidialer_write_str (FD, reset_command); 703 return (0); 704 } 705 706 /* 707 Send commands to modem; impose delay between commands. 708 */ 709 static void unidialer_modem_cmd (int fd, const char *cmd) 710 { 711 static struct timeval oldt = { 0, 0 }; 712 struct timeval newt; 713 tod_gettime (&newt); 714 if (tod_lt (&newt, &oldt)) 715 { 716 unsigned int naptime; 717 tod_subfrom (&oldt, newt); 718 naptime = oldt.tv_sec * 1000 + oldt.tv_usec / 1000; 719 if (naptime > intercommand_delay) 720 { 721 #ifdef DEBUG 722 printf ("unidialer_modem_cmd: suspicious naptime (%u ms)\r\n", naptime); 723 #endif 724 naptime = intercommand_delay; 725 } 726 #ifdef DEBUG 727 printf ("unidialer_modem_cmd: delaying %u ms\r\n", naptime); 728 #endif 729 acu_nap (naptime); 730 } 731 unidialer_write_str (fd, cmd); 732 tod_gettime (&oldt); 733 newt.tv_sec = 0; 734 newt.tv_usec = intercommand_delay; 735 tod_addto (&oldt, &newt); 736 } 737 738 static void unidialer_write_str (int fd, const char *cp) 739 { 740 #ifdef DEBUG 741 printf ("unidialer (%s): sending %s\n", modem_name, cp); 742 #endif 743 unidialer_write (fd, cp, strlen (cp)); 744 } 745 746 static void unidialer_write (int fd, const char *cp, int n) 747 { 748 acu_nap (intercharacter_delay); 749 for ( ; n-- ; cp++) { 750 write (fd, cp, 1); 751 acu_nap (intercharacter_delay); 752 } 753 } 754 755 #ifdef DEBUG 756 static void unidialer_verbose_read(void) 757 { 758 int n = 0; 759 char buf[BUFSIZ]; 760 761 if (ioctl(FD, FIONREAD, &n) < 0) 762 return; 763 if (n <= 0) 764 return; 765 if (read(FD, buf, n) != n) 766 return; 767 write(1, buf, n); 768 } 769 #endif 770 771 /* end of unidialer.c */ 772