chat/chat.c

   1 /*
   2  *      Chat -- a program for automatic session establishment (i.e. dial
   3  *              the phone and log in).
   4  *
   5  * Standard termination codes:
   6  *  0 - successful completion of the script
   7  *  1 - invalid argument, expect string too large, etc.
   8  *  2 - error on an I/O operation or fatal error condtion.
   9  *  3 - timeout waiting for a simple string.
  10  *  4 - the first string declared as "ABORT"
  11  *  5 - the second string declared as "ABORT"
  12  *  6 - ... and so on for successive ABORT strings.
  13  *
  14  *      This software is in the public domain.
  15  *
  16  *      Please send all bug reports, requests for information, etc. to:
  17  *
  18  *              Al Longyear (longyear@netcom.com)
  19  *              (I was the last person to change this code.)
  20  *
  21  *      Added -r "report file" switch & REPORT keyword.
  22  *              Robert Geer <bgeer@xmission.com>
  23  *
  24  *      Added -e "echo" switch & ECHO keyword
  25  *              Dick Streefland <dicks@tasking.nl>
  26  *
  27  *      The original author is:
  28  *
  29  *              Karl Fox <karl@MorningStar.Com>
  30  *              Morning Star Technologies, Inc.
  31  *              1760 Zollinger Road
  32  *              Columbus, OH  43221
  33  *              (614)451-1883
  34  *
  35  */
  36
  37 #ifndef lint
  38 static char rcsid[] = "$Id: chat.c,v 1.14 1997/04/30 05:40:50 paulus Exp $";
  39 #endif
  40
  41 #include <stdio.h>
  42 #include <ctype.h>
  43 #include <time.h>
  44 #include <fcntl.h>
  45 #include <signal.h>
  46 #include <errno.h>
  47 #include <string.h>
  48 #include <stdlib.h>
  49 #include <unistd.h>
  50 #include <sys/types.h>
  51 #include <sys/stat.h>
  52 #include <syslog.h>
  53
  54 #ifndef TERMIO
  55 #undef  TERMIOS
  56 #define TERMIOS
  57 #endif
  58
  59 #ifdef TERMIO
  60 #include <termio.h>
  61 #endif
  62 #ifdef TERMIOS
  63 #include <termios.h>
  64 #endif
  65
  66 #define STR_LEN 1024
  67
  68 #ifndef SIGTYPE
  69 #define SIGTYPE void
  70 #endif
  71
  72 #ifdef __STDC__
  73 #undef __P
  74 #define __P(x)  x
  75 #else
  76 #define __P(x)  ()
  77 #define const
  78 #endif
  79
  80 #ifndef O_NONBLOCK
  81 #define O_NONBLOCK      O_NDELAY
  82 #endif
  83
  84 /*************** Micro getopt() *********************************************/
  85 #define OPTION(c,v)     (_O&2&&**v?*(*v)++:!c||_O&4?0:(!(_O&1)&& \
  86                                 (--c,++v),_O=4,c&&**v=='-'&&v[0][1]?*++*v=='-'\
  87                                 &&!v[0][1]?(--c,++v,0):(_O=2,*(*v)++):0))
  88 #define OPTARG(c,v)     (_O&2?**v||(++v,--c)?(_O=1,--c,*v++): \
  89                                 (_O=4,(char*)0):(char*)0)
  90 #define OPTONLYARG(c,v) (_O&2&&**v?(_O=1,--c,*v++):(char*)0)
  91 #define ARG(c,v)        (c?(--c,*v++):(char*)0)
  92
  93 static int _O = 0;              /* Internal state */
  94 /*************** Micro getopt() *********************************************/
  95
  96 char *program_name;
  97
  98 #define MAX_ABORTS              50
  99 #define MAX_REPORTS             50
 100 #define DEFAULT_CHAT_TIMEOUT    45
 101
 102 int echo          = 0;
 103 int verbose       = 0;
 104 int Verbose       = 0;
 105 int quiet         = 0;
 106 int report        = 0;
 107 int exit_code     = 0;
 108 FILE* report_fp   = (FILE *) 0;
 109 char *report_file = (char *) 0;
 110 char *chat_file   = (char *) 0;
 111 int timeout       = DEFAULT_CHAT_TIMEOUT;
 112
 113 int have_tty_parameters = 0;
 114
 115 #ifdef TERMIO
 116 #define term_parms struct termio
 117 #define get_term_param(param) ioctl(0, TCGETA, param)
 118 #define set_term_param(param) ioctl(0, TCSETA, param)
 119 struct termio saved_tty_parameters;
 120 #endif
 121
 122 #ifdef TERMIOS
 123 #define term_parms struct termios
 124 #define get_term_param(param) tcgetattr(0, param)
 125 #define set_term_param(param) tcsetattr(0, TCSANOW, param)
 126 struct termios saved_tty_parameters;
 127 #endif
 128
 129 char *abort_string[MAX_ABORTS], *fail_reason = (char *)0,
 130         fail_buffer[50];
 131 int n_aborts = 0, abort_next = 0, timeout_next = 0, echo_next = 0;
 132
 133 char *report_string[MAX_REPORTS] ;
 134 char  report_buffer[50] ;
 135 int n_reports = 0, report_next = 0, report_gathering = 0 ;
 136
 137 void *dup_mem __P((void *b, size_t c));
 138 void *copy_of __P((char *s));
 139 void usage __P((void));
 140 void logf __P((const char *str));
 141 void logflush __P((void));
 142 void fatal __P((const char *msg));
 143 void sysfatal __P((const char *msg));
 144 SIGTYPE sigalrm __P((int signo));
 145 SIGTYPE sigint __P((int signo));
 146 SIGTYPE sigterm __P((int signo));
 147 SIGTYPE sighup __P((int signo));
 148 void unalarm __P((void));
 149 void init __P((void));
 150 void set_tty_parameters __P((void));
 151 void echo_stderr __P((int));
 152 void break_sequence __P((void));
 153 void terminate __P((int status));
 154 void do_file __P((char *chat_file));
 155 int  get_string __P((register char *string));
 156 int  put_string __P((register char *s));
 157 int  write_char __P((int c));
 158 int  put_char __P((int c));
 159 int  get_char __P((void));
 160 void chat_send __P((register char *s));
 161 char *character __P((int c));
 162 void chat_expect __P((register char *s));
 163 char *clean __P((register char *s, int sending));
 164 void break_sequence __P((void));
 165 void terminate __P((int status));
 166 void die __P((void));
 167 char *expect_strtok __P((char *, char *));
 168
 169 int main __P((int, char *[]));
 170
 171 void *dup_mem(b, c)
 172 void *b;
 173 size_t c;
 174     {
 175     void *ans = malloc (c);
 176     if (!ans)
 177         {
 178         fatal ("memory error!\n");
 179         }
 180     memcpy (ans, b, c);
 181     return ans;
 182     }
 183
 184 void *copy_of (s)
 185 char *s;
 186     {
 187     return dup_mem (s, strlen (s) + 1);
 188     }
 189
 190 /*
 191  *      chat [ -v ] [ -t timeout ] [ -f chat-file ] [ -r report-file ] \
 192  *              [...[[expect[-say[-expect...]] say expect[-say[-expect]] ...]]]
 193  *
 194  *      Perform a UUCP-dialer-like chat script on stdin and stdout.
 195  */
 196 int
 197 main(argc, argv)
 198 int argc;
 199 char **argv;
 200     {
 201     int option;
 202     char *arg;
 203
 204     program_name = *argv;
 205     tzset();
 206
 207     while ((option = OPTION(argc, argv)) != 0)
 208         {
 209         switch (option)
 210             {
 211             case 'e':
 212                 ++echo;
 213                 break;
 214
 215             case 'v':
 216                 ++verbose;
 217                 break;
 218
 219             case 'V':
 220                 ++Verbose;
 221                 break;
 222
 223             case 'f':
 224                 if ((arg = OPTARG(argc, argv)) != NULL)
 225                     {
 226                     chat_file = copy_of(arg);
 227                     }
 228                 else
 229                     {
 230                     usage();
 231                     }
 232                 break;
 233
 234             case 't':
 235                 if ((arg = OPTARG(argc, argv)) != NULL)
 236                     {
 237                     timeout = atoi(arg);
 238                     }
 239                 else
 240                     {
 241                     usage();
 242                     }
 243                 break;
 244
 245             case 'r':
 246                 arg = OPTARG (argc, argv);
 247                 if (arg)
 248                     {
 249                     if (report_fp != NULL)
 250                         {
 251                         fclose (report_fp);
 252                         }
 253                     report_file = copy_of (arg);
 254                     report_fp   = fopen (report_file, "a");
 255                     if (report_fp != NULL)
 256                         {
 257                         if (verbose)
 258                             {
 259                             fprintf (report_fp, "Opening \"%s\"...\n",
 260                                      report_file);
 261                             }
 262                         report = 1;
 263                         }
 264                     }
 265                 break;
 266
 267             default:
 268                 usage();
 269                 break;
 270             }
 271       }
 272 /*
 273  * Default the report file to the stderr location
 274  */
 275     if (report_fp == NULL)
 276         {
 277         report_fp = stderr;
 278         }
 279
 280 #ifdef ultrix
 281     openlog("chat", LOG_PID);
 282 #else
 283     openlog("chat", LOG_PID | LOG_NDELAY, LOG_LOCAL2);
 284
 285     if (verbose)
 286         {
 287         setlogmask(LOG_UPTO(LOG_INFO));
 288         }
 289     else
 290         {
 291         setlogmask(LOG_UPTO(LOG_WARNING));
 292         }
 293 #endif
 294
 295     init();
 296
 297     if (chat_file != NULL)
 298         {
 299         arg = ARG(argc, argv);
 300         if (arg != NULL)
 301             {
 302             usage();
 303             }
 304         else
 305             {
 306             do_file (chat_file);
 307             }
 308         }
 309     else
 310         {
 311         while ((arg = ARG(argc, argv)) != NULL)
 312             {
 313             chat_expect(arg);
 314
 315             if ((arg = ARG(argc, argv)) != NULL)
 316                 {
 317                 chat_send(arg);
 318                 }
 319             }
 320         }
 321
 322     terminate(0);
 323     return 0;
 324     }
 325
 326 /*
 327  *  Process a chat script when read from a file.
 328  */
 329
 330 void do_file (chat_file)
 331 char *chat_file;
 332     {
 333     int linect, sendflg;
 334     char *sp, *arg, quote;
 335     char buf [STR_LEN];
 336     FILE *cfp;
 337
 338     cfp = fopen (chat_file, "r");
 339     if (cfp == NULL)
 340         {
 341         syslog (LOG_ERR, "%s -- open failed: %m", chat_file);
 342         terminate (1);
 343         }
 344
 345     linect = 0;
 346     sendflg = 0;
 347
 348     while (fgets(buf, STR_LEN, cfp) != NULL)
 349         {
 350         sp = strchr (buf, '\n');
 351         if (sp)
 352             {
 353             *sp = '\0';
 354             }
 355
 356         linect++;
 357         sp = buf;
 358         while (*sp != '\0')
 359             {
 360             if (*sp == ' ' || *sp == '\t')
 361                 {
 362                 ++sp;
 363                 continue;
 364                 }
 365
 366             if (*sp == '"' || *sp == '\'')
 367                 {
 368                 quote = *sp++;
 369                 arg = sp;
 370                 while (*sp != quote)
 371                     {
 372                     if (*sp == '\0')
 373                         {
 374                         syslog (LOG_ERR, "unterminated quote (line %d)",
 375                                 linect);
 376                         terminate (1);
 377                         }
 378
 379                     if (*sp++ == '\\')
 380                         {
 381                         if (*sp != '\0')
 382                             {
 383                             ++sp;
 384                             }
 385                         }
 386                     }
 387                 }
 388             else
 389                 {
 390                 arg = sp;
 391                 while (*sp != '\0' && *sp != ' ' && *sp != '\t')
 392                     {
 393                     ++sp;
 394                     }
 395                 }
 396
 397             if (*sp != '\0')
 398                 {
 399                 *sp++ = '\0';
 400                 }
 401
 402             if (sendflg)
 403                 {
 404                 chat_send (arg);
 405                 }
 406             else
 407                 {
 408                 chat_expect (arg);
 409                 }
 410             sendflg = !sendflg;
 411             }
 412         }
 413     fclose (cfp);
 414     }
 415
 416 /*
 417  *      We got an error parsing the command line.
 418  */
 419 void usage()
 420     {
 421     fprintf(stderr, "\
 422 Usage: %s [-e] [-v] [-t timeout] [-r report-file] {-f chat-file | chat-script}\n",
 423             program_name);
 424     exit(1);
 425     }
 426
 427 char line[128];
 428 char *p;
 429
 430 void logf (str)
 431 const char *str;
 432 {
 433     int l = strlen(line);
 434
 435     if (l + strlen(str) >= sizeof(line)) {
 436         syslog(LOG_INFO, "%s", line);
 437         l = 0;
 438     }
 439     strcpy(line + l, str);
 440
 441     if (str[strlen(str)-1] == '\n') {
 442         syslog (LOG_INFO, "%s", line);
 443         line[0] = 0;
 444     }
 445 }
 446
 447 void logflush()
 448     {
 449     if (line[0] != 0)
 450         {
 451         syslog(LOG_INFO, "%s", line);
 452         line[0] = 0;
 453         }
 454     }
 455
 456 /*
 457  *      Terminate with an error.
 458  */
 459 void die()
 460     {
 461     terminate(1);
 462     }
 463
 464 /*
 465  *      Print an error message and terminate.
 466  */
 467
 468 void fatal (msg)
 469 const char *msg;
 470     {
 471     syslog(LOG_ERR, "%s", msg);
 472     terminate(2);
 473     }
 474
 475 /*
 476  *      Print an error message along with the system error message and
 477  *      terminate.
 478  */
 479
 480 void sysfatal (msg)
 481 const char *msg;
 482     {
 483     syslog(LOG_ERR, "%s: %m", msg);
 484     terminate(2);
 485     }
 486
 487 int alarmed = 0;
 488
 489 SIGTYPE sigalrm(signo)
 490 int signo;
 491     {
 492     int flags;
 493
 494     alarm(1);
 495     alarmed = 1;                /* Reset alarm to avoid race window */
 496     signal(SIGALRM, sigalrm);   /* that can cause hanging in read() */
 497
 498     logflush();
 499     if ((flags = fcntl(0, F_GETFL, 0)) == -1)
 500         {
 501         sysfatal("Can't get file mode flags on stdin");
 502         }
 503     else
 504         {
 505         if (fcntl(0, F_SETFL, flags | O_NONBLOCK) == -1)
 506             {
 507             sysfatal("Can't set file mode flags on stdin");
 508             }
 509         }
 510
 511     if (verbose)
 512         {
 513         syslog(LOG_INFO, "alarm");
 514         }
 515     }
 516
 517 void unalarm()
 518     {
 519     int flags;
 520
 521     if ((flags = fcntl(0, F_GETFL, 0)) == -1)
 522         {
 523         sysfatal("Can't get file mode flags on stdin");
 524         }
 525     else
 526         {
 527         if (fcntl(0, F_SETFL, flags & ~O_NONBLOCK) == -1)
 528             {
 529             sysfatal("Can't set file mode flags on stdin");
 530             }
 531         }
 532     }
 533
 534 SIGTYPE sigint(signo)
 535 int signo;
 536     {
 537     fatal("SIGINT");
 538     }
 539
 540 SIGTYPE sigterm(signo)
 541 int signo;
 542     {
 543     fatal("SIGTERM");
 544     }
 545
 546 SIGTYPE sighup(signo)
 547 int signo;
 548     {
 549     fatal("SIGHUP");
 550     }
 551
 552 void init()
 553     {
 554     signal(SIGINT, sigint);
 555     signal(SIGTERM, sigterm);
 556     signal(SIGHUP, sighup);
 557
 558     set_tty_parameters();
 559     signal(SIGALRM, sigalrm);
 560     alarm(0);
 561     alarmed = 0;
 562     }
 563
 564 void set_tty_parameters()
 565     {
 566 #if defined(get_term_param)
 567     term_parms t;
 568
 569     if (get_term_param (&t) < 0)
 570         {
 571         sysfatal("Can't get terminal parameters");
 572         }
 573
 574     saved_tty_parameters = t;
 575     have_tty_parameters  = 1;
 576
 577     t.c_iflag     |= IGNBRK | ISTRIP | IGNPAR;
 578     t.c_oflag      = 0;
 579     t.c_lflag      = 0;
 580     t.c_cc[VERASE] =
 581     t.c_cc[VKILL]  = 0;
 582     t.c_cc[VMIN]   = 1;
 583     t.c_cc[VTIME]  = 0;
 584
 585     if (set_term_param (&t) < 0)
 586         {
 587         sysfatal("Can't set terminal parameters");
 588         }
 589 #endif
 590     }
 591
 592 void break_sequence()
 593     {
 594 #ifdef TERMIOS
 595     tcsendbreak (0, 0);
 596 #endif
 597     }
 598
 599 void terminate(status)
 600 int status;
 601     {
 602     echo_stderr(-1);
 603     if (report_file != (char *) 0 && report_fp != (FILE *) NULL)
 604         {
 605 /*
 606  * Allow the last of the report string to be gathered before we terminate.
 607  */
 608         if (report_gathering) {
 609             int c, rep_len;
 610
 611             rep_len = strlen(report_buffer);
 612             while (rep_len + 1 <= sizeof(report_buffer)) {
 613                 alarm(1);
 614                 c = get_char();
 615                 alarm(0);
 616                 if (c < 0 || iscntrl(c))
 617                     break;
 618                 report_buffer[rep_len] = c;
 619                 ++rep_len;
 620             }
 621             report_buffer[rep_len] = 0;
 622             fprintf (report_fp, "chat:  %s\n", report_buffer);
 623         }
 624         if (verbose)
 625             {
 626             fprintf (report_fp, "Closing \"%s\".\n", report_file);
 627             }
 628         fclose (report_fp);
 629         report_fp = (FILE *) NULL;
 630         }
 631
 632 #if defined(get_term_param)
 633     if (have_tty_parameters)
 634         {
 635         if (set_term_param (&saved_tty_parameters) < 0)
 636             {
 637             syslog(LOG_ERR, "Can't restore terminal parameters: %m");
 638             exit(1);
 639             }
 640         }
 641 #endif
 642
 643     exit(status);
 644     }
 645
 646 /*
 647  *      'Clean up' this string.
 648  */
 649 char *clean(s, sending)
 650 register char *s;
 651 int sending;
 652     {
 653     char temp[STR_LEN], cur_chr;
 654     register char *s1;
 655     int add_return = sending;
 656 #define isoctal(chr) (((chr) >= '0') && ((chr) <= '7'))
 657
 658     s1 = temp;
 659     while (*s)
 660         {
 661         cur_chr = *s++;
 662         if (cur_chr == '^')
 663             {
 664             cur_chr = *s++;
 665             if (cur_chr == '\0')
 666                 {
 667                 *s1++ = '^';
 668                 break;
 669                 }
 670             cur_chr &= 0x1F;
 671             if (cur_chr != 0)
 672                 {
 673                 *s1++ = cur_chr;
 674                 }
 675             continue;
 676             }
 677
 678         if (cur_chr != '\\')
 679             {
 680             *s1++ = cur_chr;
 681             continue;
 682             }
 683
 684         cur_chr = *s++;
 685         if (cur_chr == '\0')
 686             {
 687             if (sending)
 688                 {
 689                 *s1++ = '\\';
 690                 *s1++ = '\\';
 691                 }
 692             break;
 693             }
 694
 695         switch (cur_chr)
 696             {
 697         case 'b':
 698             *s1++ = '\b';
 699             break;
 700
 701         case 'c':
 702             if (sending && *s == '\0')
 703                 {
 704                 add_return = 0;
 705                 }
 706             else
 707                 {
 708                 *s1++ = cur_chr;
 709                 }
 710             break;
 711
 712         case '\\':
 713         case 'K':
 714         case 'p':
 715         case 'd':
 716             if (sending)
 717                 {
 718                 *s1++ = '\\';
 719                 }
 720
 721             *s1++ = cur_chr;
 722             break;
 723
 724         case 'q':
 725             quiet = 1;
 726             break;
 727
 728         case 'r':
 729             *s1++ = '\r';
 730             break;
 731
 732         case 'n':
 733             *s1++ = '\n';
 734             break;
 735
 736         case 's':
 737             *s1++ = ' ';
 738             break;
 739
 740         case 't':
 741             *s1++ = '\t';
 742             break;
 743
 744         case 'N':
 745             if (sending)
 746                 {
 747                 *s1++ = '\\';
 748                 *s1++ = '\0';
 749                 }
 750             else
 751                 {
 752                 *s1++ = 'N';
 753                 }
 754             break;
 755
 756         default:
 757             if (isoctal (cur_chr))
 758                 {
 759                 cur_chr &= 0x07;
 760                 if (isoctal (*s))
 761                     {
 762                     cur_chr <<= 3;
 763                     cur_chr |= *s++ - '0';
 764                     if (isoctal (*s))
 765                         {
 766                         cur_chr <<= 3;
 767                         cur_chr |= *s++ - '0';
 768                         }
 769                     }
 770
 771                 if (cur_chr != 0 || sending)
 772                     {
 773                     if (sending && (cur_chr == '\\' || cur_chr == 0))
 774                         {
 775                         *s1++ = '\\';
 776                         }
 777                     *s1++ = cur_chr;
 778                     }
 779                 break;
 780                 }
 781
 782             if (sending)
 783                 {
 784                 *s1++ = '\\';
 785                 }
 786             *s1++ = cur_chr;
 787             break;
 788             }
 789         }
 790
 791     if (add_return)
 792         {
 793         *s1++ = '\r';
 794         }
 795
 796     *s1++ = '\0'; /* guarantee closure */
 797     *s1++ = '\0'; /* terminate the string */
 798     return dup_mem (temp, (size_t) (s1 - temp)); /* may have embedded nuls */
 799     }
 800
 801 /*
 802  * A modified version of 'strtok'. This version skips \ sequences.
 803  */
 804
 805 char *expect_strtok (s, term)
 806 char *s, *term;
 807     {
 808     static  char *str   = "";
 809     int     escape_flag = 0;
 810     char   *result;
 811 /*
 812  * If a string was specified then do initial processing.
 813  */
 814     if (s)
 815         {
 816         str = s;
 817         }
 818 /*
 819  * If this is the escape flag then reset it and ignore the character.
 820  */
 821     if (*str)
 822         {
 823         result = str;
 824         }
 825     else
 826         {
 827         result = (char *) 0;
 828         }
 829
 830     while (*str)
 831         {
 832         if (escape_flag)
 833             {
 834             escape_flag = 0;
 835             ++str;
 836             continue;
 837             }
 838
 839         if (*str == '\\')
 840             {
 841             ++str;
 842             escape_flag = 1;
 843             continue;
 844             }
 845 /*
 846  * If this is not in the termination string, continue.
 847  */
 848         if (strchr (term, *str) == (char *) 0)
 849             {
 850             ++str;
 851             continue;
 852             }
 853 /*
 854  * This is the terminator. Mark the end of the string and stop.
 855  */
 856         *str++ = '\0';
 857         break;
 858         }
 859     return (result);
 860     }
 861
 862 /*
 863  * Process the expect string
 864  */
 865
 866 void chat_expect (s)
 867 char *s;
 868     {
 869     char *expect;
 870     char *reply;
 871
 872     if (strcmp(s, "ABORT") == 0)
 873         {
 874         ++abort_next;
 875         return;
 876         }
 877
 878     if (strcmp(s, "REPORT") == 0)
 879         {
 880         ++report_next;
 881         return;
 882         }
 883
 884     if (strcmp(s, "TIMEOUT") == 0)
 885         {
 886         ++timeout_next;
 887         return;
 888         }
 889
 890     if (strcmp(s, "ECHO") == 0)
 891         {
 892         ++echo_next;
 893         return;
 894         }
 895 /*
 896  * Fetch the expect and reply string.
 897  */
 898     for (;;)
 899         {
 900         expect = expect_strtok (s, "-");
 901         s      = (char *) 0;
 902
 903         if (expect == (char *) 0)
 904             {
 905             return;
 906             }
 907
 908         reply = expect_strtok (s, "-");
 909 /*
 910  * Handle the expect string. If successful then exit.
 911  */
 912         if (get_string (expect))
 913             {
 914             return;
 915             }
 916 /*
 917  * If there is a sub-reply string then send it. Otherwise any condition
 918  * is terminal.
 919  */
 920         if (reply == (char *) 0 || exit_code != 3)
 921             {
 922             break;
 923             }
 924
 925         chat_send (reply);
 926         }
 927 /*
 928  * The expectation did not occur. This is terminal.
 929  */
 930     if (fail_reason)
 931         {
 932         syslog(LOG_INFO, "Failed (%s)", fail_reason);
 933         }
 934     else
 935         {
 936         syslog(LOG_INFO, "Failed");
 937         }
 938     terminate(exit_code);
 939     }
 940
 941 /*
 942  * Translate the input character to the appropriate string for printing
 943  * the data.
 944  */
 945
 946 char *character(c)
 947 int c;
 948     {
 949     static char string[10];
 950     char *meta;
 951
 952     meta = (c & 0x80) ? "M-" : "";
 953     c &= 0x7F;
 954
 955     if (c < 32)
 956         {
 957         sprintf(string, "%s^%c", meta, (int)c + '@');
 958         }
 959     else
 960         {
 961         if (c == 127)
 962             {
 963             sprintf(string, "%s^?", meta);
 964             }
 965         else
 966             {
 967             sprintf(string, "%s%c", meta, c);
 968             }
 969         }
 970
 971     return (string);
 972     }
 973
 974 /*
 975  *  process the reply string
 976  */
 977 void chat_send (s)
 978 register char *s;
 979     {
 980     if (echo_next)
 981         {
 982         echo_next = 0;
 983         echo = (strcmp(s, "ON") == 0);
 984         return;
 985         }
 986     if (abort_next)
 987         {
 988         char *s1;
 989
 990         abort_next = 0;
 991
 992         if (n_aborts >= MAX_ABORTS)
 993             {
 994             fatal("Too many ABORT strings");
 995             }
 996
 997         s1 = clean(s, 0);
 998
 999         if (strlen(s1) > strlen(s)
1000             || strlen(s1) + 1 > sizeof(fail_buffer))
1001             {
1002             syslog(LOG_WARNING, "Illegal or too-long ABORT string ('%s')", s);
1003             die();
1004             }
1005
1006         abort_string[n_aborts++] = s1;
1007
1008         if (verbose)
1009             {
1010             logf("abort on (");
1011
1012             for (s1 = s; *s1; ++s1)
1013                 {
1014                 logf(character(*s1));
1015                 }
1016
1017             logf(")\n");
1018             }
1019         return;
1020         }
1021
1022     if (report_next)
1023         {
1024         char *s1;
1025
1026         report_next = 0;
1027         if (n_reports >= MAX_REPORTS)
1028             {
1029             fatal("Too many REPORT strings");
1030             }
1031
1032         s1 = clean(s, 0);
1033
1034         if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1)
1035             {
1036             syslog(LOG_WARNING, "Illegal or too-long REPORT string ('%s')", s);
1037             die();
1038             }
1039
1040         report_string[n_reports++] = s1;
1041
1042         if (verbose)
1043             {
1044             logf("report (");
1045             s1 = s;
1046             while (*s1)
1047                 {
1048                 logf(character(*s1));
1049                 ++s1;
1050                 }
1051             logf(")\n");
1052             }
1053         return;
1054         }
1055
1056     if (timeout_next)
1057         {
1058         timeout_next = 0;
1059         timeout = atoi(s);
1060
1061         if (timeout <= 0)
1062             {
1063             timeout = DEFAULT_CHAT_TIMEOUT;
1064             }
1065
1066         if (verbose)
1067             {
1068             syslog(LOG_INFO, "timeout set to %d seconds", timeout);
1069             }
1070         return;
1071         }
1072
1073     if (strcmp(s, "EOT") == 0)
1074         {
1075         s = "^D\\c";
1076         }
1077     else
1078         {
1079         if (strcmp(s, "BREAK") == 0)
1080             {
1081             s = "\\K\\c";
1082             }
1083         }
1084
1085     if (!put_string(s))
1086         {
1087         syslog(LOG_INFO, "Failed");
1088         terminate(1);
1089         }
1090     }
1091
1092 int get_char()
1093     {
1094     int status;
1095     char c;
1096
1097     status = read(0, &c, 1);
1098
1099     switch (status)
1100         {
1101     case 1:
1102         return ((int)c & 0x7F);
1103
1104     default:
1105         syslog(LOG_WARNING, "warning: read() on stdin returned %d",
1106                status);
1107
1108     case -1:
1109         if ((status = fcntl(0, F_GETFL, 0)) == -1)
1110             {
1111             sysfatal("Can't get file mode flags on stdin");
1112             }
1113         else
1114             {
1115             if (fcntl(0, F_SETFL, status & ~O_NONBLOCK) == -1)
1116                 {
1117                 sysfatal("Can't set file mode flags on stdin");
1118                 }
1119             }
1120
1121         return (-1);
1122         }
1123     }
1124
1125 int put_char(c)
1126 int c;
1127     {
1128     int status;
1129     char ch = c;
1130
1131     usleep(10000);              /* inter-character typing delay (?) */
1132
1133     status = write(1, &ch, 1);
1134
1135     switch (status)
1136         {
1137     case 1:
1138         return (0);
1139
1140     default:
1141         syslog(LOG_WARNING, "warning: write() on stdout returned %d",
1142                status);
1143
1144     case -1:
1145         if ((status = fcntl(0, F_GETFL, 0)) == -1)
1146             {
1147             sysfatal("Can't get file mode flags on stdin");
1148             }
1149         else
1150             {
1151             if (fcntl(0, F_SETFL, status & ~O_NONBLOCK) == -1)
1152                 {
1153                 sysfatal("Can't set file mode flags on stdin");
1154                 }
1155             }
1156
1157         return (-1);
1158         }
1159     }
1160
1161 int write_char (c)
1162 int c;
1163     {
1164     if (alarmed || put_char(c) < 0)
1165         {
1166         extern int errno;
1167
1168         alarm(0);
1169         alarmed = 0;
1170
1171         if (verbose)
1172             {
1173             if (errno == EINTR || errno == EWOULDBLOCK)
1174                 {
1175                 syslog(LOG_INFO, " -- write timed out");
1176                 }
1177             else
1178                 {
1179                 syslog(LOG_INFO, " -- write failed: %m");
1180                 }
1181             }
1182         return (0);
1183         }
1184     return (1);
1185     }
1186
1187 int put_string (s)
1188 register char *s;
1189     {
1190     quiet = 0;
1191     s = clean(s, 1);
1192
1193     if (verbose)
1194         {
1195         logf("send (");
1196
1197         if (quiet)
1198             {
1199             logf("??????");
1200             }
1201         else
1202             {
1203             register char *s1 = s;
1204
1205             for (s1 = s; *s1; ++s1)
1206                 {
1207                 logf(character(*s1));
1208                 }
1209             }
1210
1211         logf(")\n");
1212         }
1213
1214     alarm(timeout); alarmed = 0;
1215
1216     while (*s)
1217         {
1218         register char c = *s++;
1219
1220         if (c != '\\')
1221             {
1222             if (!write_char (c))
1223                 {
1224                 return 0;
1225                 }
1226             continue;
1227             }
1228
1229         c = *s++;
1230         switch (c)
1231             {
1232         case 'd':
1233             sleep(1);
1234             break;
1235
1236         case 'K':
1237             break_sequence();
1238             break;
1239
1240         case 'p':
1241             usleep(10000);      /* 1/100th of a second (arg is microseconds) */
1242             break;
1243
1244         default:
1245             if (!write_char (c))
1246                 return 0;
1247             break;
1248             }
1249         }
1250
1251     alarm(0);
1252     alarmed = 0;
1253     return (1);
1254     }
1255
1256 /*
1257  *      Echo a character to stderr.
1258  *      When called with -1, a '\n' character is generated when
1259  *      the cursor is not at the beginning of a line.
1260  */
1261 void echo_stderr(n)
1262 int n;
1263     {
1264         static int need_lf;
1265         char *s;
1266
1267         switch (n)
1268             {
1269         case '\r':              /* ignore '\r' */
1270             break;
1271         case -1:
1272             if (need_lf == 0)
1273                 break;
1274             /* fall through */
1275         case '\n':
1276             write(2, "\n", 1);
1277             need_lf = 0;
1278             break;
1279         default:
1280             s = character(n);
1281             write(2, s, strlen(s));
1282             need_lf = 1;
1283             break;
1284             }
1285     }
1286
1287 /*
1288  *      'Wait for' this string to appear on this file descriptor.
1289  */
1290 int get_string(string)
1291 register char *string;
1292     {
1293     char temp[STR_LEN];
1294     int c, printed = 0, len, minlen;
1295     register char *s = temp, *end = s + STR_LEN;
1296
1297     fail_reason = (char *)0;
1298     string = clean(string, 0);
1299     len = strlen(string);
1300     minlen = (len > sizeof(fail_buffer)? len: sizeof(fail_buffer)) - 1;
1301
1302     if (verbose)
1303         {
1304         register char *s1;
1305
1306         logf("expect (");
1307
1308         for (s1 = string; *s1; ++s1)
1309             {
1310             logf(character(*s1));
1311             }
1312
1313         logf(")\n");
1314         }
1315
1316     if (len > STR_LEN)
1317         {
1318         syslog(LOG_INFO, "expect string is too long");
1319         exit_code = 1;
1320         return 0;
1321         }
1322
1323     if (len == 0)
1324         {
1325         if (verbose)
1326             {
1327             syslog(LOG_INFO, "got it");
1328             }
1329
1330         return (1);
1331         }
1332
1333     alarm(timeout);
1334     alarmed = 0;
1335
1336     while ( ! alarmed && (c = get_char()) >= 0)
1337         {
1338         int n, abort_len, report_len;
1339
1340         if (echo)
1341             {
1342             echo_stderr(c);
1343             }
1344         if (verbose)
1345             {
1346             if (c == '\n')
1347                 {
1348                 logf("\n");
1349                 }
1350             else
1351                 {
1352                 logf(character(c));
1353                 }
1354             }
1355
1356         if (Verbose) {
1357            if (c == '\n')      fputc( '\n', stderr );
1358            else if (c != '\r') fprintf( stderr, "%s", character(c) );
1359         }
1360
1361         *s++ = c;
1362
1363         if (!report_gathering)
1364             {
1365             for (n = 0; n < n_reports; ++n)
1366                 {
1367                 if ((report_string[n] != (char*) NULL) &&
1368                     s - temp >= (report_len = strlen(report_string[n])) &&
1369                     strncmp(s - report_len, report_string[n], report_len) == 0)
1370                     {
1371                     time_t time_now   = time ((time_t*) NULL);
1372                     struct tm* tm_now = localtime (&time_now);
1373
1374                     strftime (report_buffer, 20, "%b %d %H:%M:%S ", tm_now);
1375                     strcat (report_buffer, report_string[n]);
1376
1377                     report_string[n] = (char *) NULL;
1378                     report_gathering = 1;
1379                     break;
1380                     }
1381                 }
1382             }
1383         else
1384             {
1385             if (!iscntrl (c))
1386                 {
1387                 int rep_len = strlen (report_buffer);
1388                 report_buffer[rep_len]     = c;
1389                 report_buffer[rep_len + 1] = '\0';
1390                 }
1391             else
1392                 {
1393                 report_gathering = 0;
1394                 fprintf (report_fp, "chat:  %s\n", report_buffer);
1395                 }
1396             }
1397
1398         if (s - temp >= len &&
1399             c == string[len - 1] &&
1400             strncmp(s - len, string, len) == 0)
1401             {
1402             if (verbose)
1403                 {
1404                 logf(" -- got it\n");
1405                 }
1406
1407             alarm(0);
1408             alarmed = 0;
1409             return (1);
1410             }
1411
1412         for (n = 0; n < n_aborts; ++n)
1413             {
1414             if (s - temp >= (abort_len = strlen(abort_string[n])) &&
1415                 strncmp(s - abort_len, abort_string[n], abort_len) == 0)
1416                 {
1417                 if (verbose)
1418                     {
1419                     logf(" -- failed\n");
1420                     }
1421
1422                 alarm(0);
1423                 alarmed = 0;
1424                 exit_code = n + 4;
1425                 strcpy(fail_reason = fail_buffer, abort_string[n]);
1426                 return (0);
1427                 }
1428             }
1429
1430         if (s >= end)
1431             {
1432             strncpy (temp, s - minlen, minlen);
1433             s = temp + minlen;
1434             }
1435
1436         if (alarmed && verbose)
1437             {
1438             syslog(LOG_WARNING, "warning: alarm synchronization problem");
1439             }
1440         }
1441
1442     alarm(0);
1443
1444     if (verbose && printed)
1445         {
1446         if (alarmed)
1447             {
1448             logf(" -- read timed out\n");
1449             }
1450         else
1451             {
1452             logflush();
1453             syslog(LOG_INFO, " -- read failed: %m");
1454             }
1455         }
1456
1457     exit_code = 3;
1458     alarmed   = 0;
1459     return (0);
1460     }
1461
1462 #ifdef NO_USLEEP
1463 #include <sys/types.h>
1464 #include <sys/time.h>
1465
1466 /*
1467   usleep -- support routine for 4.2BSD system call emulations
1468   last edit:  29-Oct-1984     D A Gwyn
1469   */
1470
1471 extern int        select();
1472
1473 int
1474 usleep( usec )                            /* returns 0 if ok, else -1 */
1475     long                usec;           /* delay in microseconds */
1476 {
1477     static struct                       /* `timeval' */
1478         {
1479         long    tv_sec;         /* seconds */
1480         long    tv_usec;        /* microsecs */
1481         } delay;            /* _select() timeout */
1482
1483     delay.tv_sec  = usec / 1000000L;
1484     delay.tv_usec = usec % 1000000L;
1485
1486     return select( 0, (long *)0, (long *)0, (long *)0, &delay );
1487 }
1488 #endif