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