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