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 <kdart@cisco.com>
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 <Francis@SwissMail.Com>
49 * 		Thu May 15 17:15:40 MET DST 1997
50 *
51 *
52 *      Added -r "report file" switch & REPORT keyword.
53 *              Robert Geer <bgeer@xmission.com>
54 *
55 *      Added -s "use stderr" and -S "don't use syslog" switches.
56 *              June 18, 1997
57 *              Karl O. Pinc <kop@meme.com>
58 *
59 *
60 *	Added -e "echo" switch & ECHO keyword
61 *		Dick Streefland <dicks@tasking.nl>
62 *
63 *
64 *	Considerable updates and modifications by
65 *		Al Longyear <longyear@pobox.com>
66 *		Paul Mackerras <paulus@cs.anu.edu.au>
67 *
68 *
69 *	The original author is:
70 *
71 *		Karl Fox <karl@MorningStar.Com>
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: stable/11/usr.bin/chat/chat.c 313100 2017-02-02 18:27:20Z asomers $");
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
112static int echo;
113static int verbose;
114static int to_log;
115static int to_stderr;
116static int Verbose;
117static int quiet;
118static int exit_code;
119static FILE* report_fp;
120static char *report_file;
121static char *chat_file;
122static char *phone_num;
123static char *phone_num2;
124static int timeout = DEFAULT_CHAT_TIMEOUT;
125
126static char blank[] = "";
127
128static 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)
133static struct termios saved_tty_parameters;
134
135static char *abort_string[MAX_ABORTS], *fail_reason, fail_buffer[50];
136static int n_aborts, abort_next, timeout_next, echo_next;
137static int clear_abort_next;
138
139static char *report_string[MAX_REPORTS];
140static char  report_buffer[50];
141static int n_reports, report_next, report_gathering;
142static int clear_report_next;
143
144static int say_next, hup_next;
145
146void *dup_mem(void *b, size_t c);
147void *copy_of(char *s);
148static void usage(void);
149void chat_logf(const char *fmt, ...);
150void fatal(int code, const char *fmt, ...);
151SIGTYPE sigalrm(int signo);
152SIGTYPE sigint(int signo);
153SIGTYPE sigterm(int signo);
154SIGTYPE sighup(int signo);
155void init(void);
156void set_tty_parameters(void);
157void echo_stderr(int);
158void break_sequence(void);
159void terminate(int status);
160void do_file(char *chatfile);
161int  get_string(char *string);
162int  put_string(char *s);
163int  write_char(int c);
164int  put_char(int c);
165int  get_char(void);
166void chat_send(char *s);
167char *character(int c);
168void chat_expect(char *s);
169char *clean(char *s, int sending);
170void pack_array(char **array, int end);
171char *expect_strtok(char *, const char *);
172int vfmtmsg(char *, int, const char *, va_list);	/* vsprintf++ */
173
174void *
175dup_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
185void *
186copy_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 */
199int
200main(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
318void
319do_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 */
387static void
388usage(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 */
401void
402chat_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
420void
421fatal(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
436static int alarmed;
437
438SIGTYPE 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
456SIGTYPE sigint(int signo __unused)
457{
458    fatal(2, "SIGINT");
459}
460
461SIGTYPE sigterm(int signo __unused)
462{
463    fatal(2, "SIGTERM");
464}
465
466SIGTYPE sighup(int signo __unused)
467{
468    fatal(2, "SIGHUP");
469}
470
471void 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
483void 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
507void break_sequence(void)
508{
509    tcsendbreak (0, 0);
510}
511
512void 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 */
555char *
556clean(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
706char *
707expect_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
761void
762chat_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
850char *
851character(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 */
872void
873chat_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
1022int
1023get_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
1048int 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
1075int
1076write_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
1093int
1094put_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 */
1144void
1145echo_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 */
1172int
1173get_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
1314void
1315pack_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
1340int
1341vfmtmsg(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