xref: /freebsd/usr.bin/chat/chat.c (revision d2c82c0cfe5a674f58837f9d8c1d6ad15f10010e)
19b1aec48SLars Fredriksen /*
29b1aec48SLars Fredriksen  *	Chat -- a program for automatic session establishment (i.e. dial
39b1aec48SLars Fredriksen  *		the phone and log in).
49b1aec48SLars Fredriksen  *
59f65f104SPeter Wemm  * Standard termination codes:
69f65f104SPeter Wemm  *  0 - successful completion of the script
79f65f104SPeter Wemm  *  1 - invalid argument, expect string too large, etc.
801c855caSPeter Wemm  *  2 - error on an I/O operation or fatal error condition.
99f65f104SPeter Wemm  *  3 - timeout waiting for a simple string.
109f65f104SPeter Wemm  *  4 - the first string declared as "ABORT"
119f65f104SPeter Wemm  *  5 - the second string declared as "ABORT"
129f65f104SPeter Wemm  *  6 - ... and so on for successive ABORT strings.
139f65f104SPeter Wemm  *
149b1aec48SLars Fredriksen  *	This software is in the public domain.
159b1aec48SLars Fredriksen  *
163d793cf1SPeter Wemm  * -----------------
1701c855caSPeter Wemm  *	added -T and -U option and \T and \U substitution to pass a phone
1801c855caSPeter Wemm  *	number into chat script. Two are needed for some ISDN TA applications.
1901c855caSPeter Wemm  *	Keith Dart <kdart@cisco.com>
2001c855caSPeter Wemm  *
219b1aec48SLars Fredriksen  *
223d793cf1SPeter Wemm  *	Added SAY keyword to send output to stderr.
233d793cf1SPeter Wemm  *      This allows to turn ECHO OFF and to output specific, user selected,
243d793cf1SPeter Wemm  *      text to give progress messages. This best works when stderr
253d793cf1SPeter Wemm  *      exists (i.e.: pppd in nodetach mode).
263d793cf1SPeter Wemm  *
273d793cf1SPeter Wemm  * 	Added HANGUP directives to allow for us to be called
283d793cf1SPeter Wemm  *      back. When HANGUP is set to NO, chat will not hangup at HUP signal.
293d793cf1SPeter Wemm  *      We rely on timeouts in that case.
303d793cf1SPeter Wemm  *
313d793cf1SPeter Wemm  *      Added CLR_ABORT to clear previously set ABORT string. This has been
323d793cf1SPeter Wemm  *      dictated by the HANGUP above as "NO CARRIER" (for example) must be
333d793cf1SPeter Wemm  *      an ABORT condition until we know the other host is going to close
343d793cf1SPeter Wemm  *      the connection for call back. As soon as we have completed the
353d793cf1SPeter Wemm  *      first stage of the call back sequence, "NO CARRIER" is a valid, non
363d793cf1SPeter Wemm  *      fatal string. As soon as we got called back (probably get "CONNECT"),
373d793cf1SPeter Wemm  *      we should re-arm the ABORT "NO CARRIER". Hence the CLR_ABORT command.
383d793cf1SPeter Wemm  *      Note that CLR_ABORT packs the abort_strings[] array so that we do not
393d793cf1SPeter Wemm  *      have unused entries not being reclaimed.
403d793cf1SPeter Wemm  *
413d793cf1SPeter Wemm  *      In the same vein as above, added CLR_REPORT keyword.
423d793cf1SPeter Wemm  *
433d793cf1SPeter Wemm  *      Allow for comments. Line starting with '#' are comments and are
443d793cf1SPeter Wemm  *      ignored. If a '#' is to be expected as the first character, the
453d793cf1SPeter Wemm  *      expect string must be quoted.
463d793cf1SPeter Wemm  *
473d793cf1SPeter Wemm  *
483d793cf1SPeter Wemm  *		Francis Demierre <Francis@SwissMail.Com>
493d793cf1SPeter Wemm  * 		Thu May 15 17:15:40 MET DST 1997
503d793cf1SPeter Wemm  *
519b1aec48SLars Fredriksen  *
529f65f104SPeter Wemm  *      Added -r "report file" switch & REPORT keyword.
539f65f104SPeter Wemm  *              Robert Geer <bgeer@xmission.com>
549f65f104SPeter Wemm  *
5501c855caSPeter Wemm  *      Added -s "use stderr" and -S "don't use syslog" switches.
5601c855caSPeter Wemm  *              June 18, 1997
5701c855caSPeter Wemm  *              Karl O. Pinc <kop@meme.com>
5801c855caSPeter Wemm  *
593d793cf1SPeter Wemm  *
603d793cf1SPeter Wemm  *	Added -e "echo" switch & ECHO keyword
613d793cf1SPeter Wemm  *		Dick Streefland <dicks@tasking.nl>
623d793cf1SPeter Wemm  *
633d793cf1SPeter Wemm  *
643d793cf1SPeter Wemm  *	Considerable updates and modifications by
653d793cf1SPeter Wemm  *		Al Longyear <longyear@pobox.com>
663d793cf1SPeter Wemm  *		Paul Mackerras <paulus@cs.anu.edu.au>
673d793cf1SPeter Wemm  *
683d793cf1SPeter Wemm  *
699b1aec48SLars Fredriksen  *	The original author is:
709b1aec48SLars Fredriksen  *
719b1aec48SLars Fredriksen  *		Karl Fox <karl@MorningStar.Com>
729b1aec48SLars Fredriksen  *		Morning Star Technologies, Inc.
739b1aec48SLars Fredriksen  *		1760 Zollinger Road
749b1aec48SLars Fredriksen  *		Columbus, OH  43221
759b1aec48SLars Fredriksen  *		(614)451-1883
769f65f104SPeter Wemm  *
773d793cf1SPeter Wemm  *
789b1aec48SLars Fredriksen  */
799b1aec48SLars Fredriksen 
80ee6b974cSMark Murray #include <sys/cdefs.h>
81ee6b974cSMark Murray __FBSDID("$FreeBSD$");
829b1aec48SLars Fredriksen 
839b1aec48SLars Fredriksen #include <sys/types.h>
849b1aec48SLars Fredriksen #include <sys/stat.h>
85ee6b974cSMark Murray #include <ctype.h>
86ee6b974cSMark Murray #include <errno.h>
87ee6b974cSMark Murray #include <fcntl.h>
88ee6b974cSMark Murray #include <signal.h>
89ee6b974cSMark Murray #include <stdarg.h>
90ee6b974cSMark Murray #include <stdio.h>
91ee6b974cSMark Murray #include <stdlib.h>
92ee6b974cSMark Murray #include <string.h>
939b1aec48SLars Fredriksen #include <syslog.h>
949b1aec48SLars Fredriksen #include <termios.h>
95ee6b974cSMark Murray #include <time.h>
96ee6b974cSMark Murray #include <unistd.h>
979b1aec48SLars Fredriksen 
989b1aec48SLars Fredriksen #define	STR_LEN	1024
999b1aec48SLars Fredriksen 
1009b1aec48SLars Fredriksen #ifndef SIGTYPE
1019b1aec48SLars Fredriksen #define SIGTYPE void
1029b1aec48SLars Fredriksen #endif
1039b1aec48SLars Fredriksen 
1049f65f104SPeter Wemm #ifndef O_NONBLOCK
1059f65f104SPeter Wemm #define O_NONBLOCK	O_NDELAY
1069f65f104SPeter Wemm #endif
1079f65f104SPeter Wemm 
1089b1aec48SLars Fredriksen #define	MAX_ABORTS		50
1099f65f104SPeter Wemm #define	MAX_REPORTS		50
1109b1aec48SLars Fredriksen #define	DEFAULT_CHAT_TIMEOUT	45
1119b1aec48SLars Fredriksen 
112bf70beceSEd Schouten static int echo;
113bf70beceSEd Schouten static int verbose;
114bf70beceSEd Schouten static int to_log;
115bf70beceSEd Schouten static int to_stderr;
116bf70beceSEd Schouten static int Verbose;
117bf70beceSEd Schouten static int quiet;
118bf70beceSEd Schouten static int exit_code;
119bf70beceSEd Schouten static FILE* report_fp;
120bf70beceSEd Schouten static char *report_file;
121bf70beceSEd Schouten static char *chat_file;
122bf70beceSEd Schouten static char *phone_num;
123bf70beceSEd Schouten static char *phone_num2;
124bf70beceSEd Schouten static int timeout = DEFAULT_CHAT_TIMEOUT;
1259b1aec48SLars Fredriksen 
126ee6b974cSMark Murray static char blank[] = "";
127ee6b974cSMark Murray 
128bf70beceSEd Schouten static int have_tty_parameters;
1299f65f104SPeter Wemm 
1309f65f104SPeter Wemm #define term_parms struct termios
1319f65f104SPeter Wemm #define get_term_param(param) tcgetattr(0, param)
1329f65f104SPeter Wemm #define set_term_param(param) tcsetattr(0, TCSANOW, param)
133bf70beceSEd Schouten static struct termios saved_tty_parameters;
1349b1aec48SLars Fredriksen 
135bf70beceSEd Schouten static char *abort_string[MAX_ABORTS], *fail_reason, fail_buffer[50];
136bf70beceSEd Schouten static int n_aborts, abort_next, timeout_next, echo_next;
137bf70beceSEd Schouten static int clear_abort_next;
1389b1aec48SLars Fredriksen 
139bf70beceSEd Schouten static char *report_string[MAX_REPORTS];
140bf70beceSEd Schouten static char  report_buffer[50];
141bf70beceSEd Schouten static int n_reports, report_next, report_gathering;
142bf70beceSEd Schouten static int clear_report_next;
1433d793cf1SPeter Wemm 
144bf70beceSEd Schouten static int say_next, hup_next;
1459f65f104SPeter Wemm 
146f1bb2cd2SWarner Losh void *dup_mem(void *b, size_t c);
147f1bb2cd2SWarner Losh void *copy_of(char *s);
148f1bb2cd2SWarner Losh static void usage(void);
1498491f234STim Kientzle void chat_logf(const char *fmt, ...);
150f1bb2cd2SWarner Losh void fatal(int code, const char *fmt, ...);
151f1bb2cd2SWarner Losh SIGTYPE sigalrm(int signo);
152f1bb2cd2SWarner Losh SIGTYPE sigint(int signo);
153f1bb2cd2SWarner Losh SIGTYPE sigterm(int signo);
154f1bb2cd2SWarner Losh SIGTYPE sighup(int signo);
155f1bb2cd2SWarner Losh void init(void);
156f1bb2cd2SWarner Losh void set_tty_parameters(void);
157f1bb2cd2SWarner Losh void echo_stderr(int);
158f1bb2cd2SWarner Losh void break_sequence(void);
159f1bb2cd2SWarner Losh void terminate(int status);
160ee6b974cSMark Murray void do_file(char *chatfile);
161ee6b974cSMark Murray int  get_string(char *string);
162ee6b974cSMark Murray int  put_string(char *s);
163f1bb2cd2SWarner Losh int  write_char(int c);
164f1bb2cd2SWarner Losh int  put_char(int c);
165f1bb2cd2SWarner Losh int  get_char(void);
166ee6b974cSMark Murray void chat_send(char *s);
167f1bb2cd2SWarner Losh char *character(int c);
168ee6b974cSMark Murray void chat_expect(char *s);
169ee6b974cSMark Murray char *clean(char *s, int sending);
170f1bb2cd2SWarner Losh void pack_array(char **array, int end);
171ee6b974cSMark Murray char *expect_strtok(char *, const char *);
172f1bb2cd2SWarner Losh int vfmtmsg(char *, int, const char *, va_list);	/* vsprintf++ */
1733d793cf1SPeter Wemm 
174ee6b974cSMark Murray void *
175ee6b974cSMark Murray dup_mem(void *b, size_t c)
1769b1aec48SLars Fredriksen {
1779b1aec48SLars Fredriksen     void *ans = malloc (c);
1789b1aec48SLars Fredriksen     if (!ans)
17901c855caSPeter Wemm 	fatal(2, "memory error!");
18001c855caSPeter Wemm 
1819b1aec48SLars Fredriksen     memcpy (ans, b, c);
1829b1aec48SLars Fredriksen     return ans;
1839b1aec48SLars Fredriksen }
1849b1aec48SLars Fredriksen 
185ee6b974cSMark Murray void *
186ee6b974cSMark Murray copy_of(char *s)
1879b1aec48SLars Fredriksen {
1889b1aec48SLars Fredriksen     return dup_mem (s, strlen (s) + 1);
1899b1aec48SLars Fredriksen }
1909b1aec48SLars Fredriksen 
1919b1aec48SLars Fredriksen /*
19218ebe779SXin LI  * chat [-esSvV] [-f chat-file] [-r report-file] [-t timeout]
19318ebe779SXin LI  *      [-T phone-number] [-U phone-number2] [chat-script]
19418ebe779SXin LI  * where chat-script has the form:
19518ebe779SXin LI  *	[...[[expect[-send[-expect...]] send expect[-send[-expect]] ...]]]
1969b1aec48SLars Fredriksen  *
1979b1aec48SLars Fredriksen  * Perform a UUCP-dialer-like chat script on stdin and stdout.
1989b1aec48SLars Fredriksen  */
1999b1aec48SLars Fredriksen int
200ee6b974cSMark Murray main(int argc, char *argv[])
2019b1aec48SLars Fredriksen {
2029b1aec48SLars Fredriksen     int option;
2039b1aec48SLars Fredriksen 
2049f65f104SPeter Wemm     tzset();
2059b1aec48SLars Fredriksen 
20618ebe779SXin LI     while ((option = getopt(argc, argv, "ef:r:sSt:T:U:vV")) != -1) {
20701c855caSPeter Wemm 	switch (option) {
2083d793cf1SPeter Wemm 	case 'e':
2093d793cf1SPeter Wemm 	    ++echo;
2103d793cf1SPeter Wemm 	    break;
2113d793cf1SPeter Wemm 
21218ebe779SXin LI 	case 'f':
21318ebe779SXin LI 	    if (chat_file != NULL)
21418ebe779SXin LI 		free(chat_file);
21518ebe779SXin LI 	    chat_file = copy_of(optarg);
2169b1aec48SLars Fredriksen 	    break;
2179b1aec48SLars Fredriksen 
21818ebe779SXin LI 	case 'r':
21918ebe779SXin LI 	    if (report_fp != NULL)
22018ebe779SXin LI 		fclose(report_fp);
22118ebe779SXin LI 	    if (report_file != NULL)
22218ebe779SXin LI 		free(report_file);
22318ebe779SXin LI 	    report_file = copy_of(optarg);
22418ebe779SXin LI 	    report_fp = fopen(report_file, "a");
22518ebe779SXin LI 	    if (report_fp != NULL) {
22618ebe779SXin LI 		if (verbose)
22718ebe779SXin LI 		    fprintf(report_fp, "Opening \"%s\"...\n", report_file);
22818ebe779SXin LI 	    } else
22918ebe779SXin LI 		fatal(2, "cannot open \"%s\" for appending", report_file);
2303d793cf1SPeter Wemm 	    break;
2313d793cf1SPeter Wemm 
23201c855caSPeter Wemm 	case 's':
23301c855caSPeter Wemm 	    ++to_stderr;
23401c855caSPeter Wemm 	    break;
23501c855caSPeter Wemm 
23601c855caSPeter Wemm 	case 'S':
23701c855caSPeter Wemm 	    to_log = 0;
23801c855caSPeter Wemm 	    break;
23901c855caSPeter Wemm 
2409b1aec48SLars Fredriksen 	case 't':
24118ebe779SXin LI 	    timeout = atoi(optarg);
2429b1aec48SLars Fredriksen 	    break;
2439b1aec48SLars Fredriksen 
24401c855caSPeter Wemm 	case 'T':
24518ebe779SXin LI 	    if (phone_num != NULL)
24618ebe779SXin LI 		free(phone_num);
24718ebe779SXin LI 	    phone_num = copy_of(optarg);
24801c855caSPeter Wemm 	    break;
24901c855caSPeter Wemm 
25001c855caSPeter Wemm 	case 'U':
25118ebe779SXin LI 	    if (phone_num2 != NULL)
25218ebe779SXin LI 		free(phone_num2);
25318ebe779SXin LI 	    phone_num2 = copy_of(optarg);
25418ebe779SXin LI 	    break;
25518ebe779SXin LI 
25618ebe779SXin LI 	case 'v':
25718ebe779SXin LI 	    ++verbose;
25818ebe779SXin LI 	    break;
25918ebe779SXin LI 
26018ebe779SXin LI 	case 'V':
26118ebe779SXin LI 	    ++Verbose;
26201c855caSPeter Wemm 	    break;
26301c855caSPeter Wemm 
2649b1aec48SLars Fredriksen 	default:
2659b1aec48SLars Fredriksen 	    usage();
2669f65f104SPeter Wemm 	    break;
2679f65f104SPeter Wemm 	}
2689f65f104SPeter Wemm     }
26918ebe779SXin LI 
27018ebe779SXin LI     argc -= optind;
27118ebe779SXin LI     argv += optind;
27218ebe779SXin LI 
2739f65f104SPeter Wemm /*
2749f65f104SPeter Wemm  * Default the report file to the stderr location
2759f65f104SPeter Wemm  */
2769f65f104SPeter Wemm     if (report_fp == NULL)
2779f65f104SPeter Wemm 	report_fp = stderr;
2789b1aec48SLars Fredriksen 
27901c855caSPeter Wemm     if (to_log) {
2809b1aec48SLars Fredriksen 	openlog("chat", LOG_PID | LOG_NDELAY, LOG_LOCAL2);
2819b1aec48SLars Fredriksen 
2829f65f104SPeter Wemm 	if (verbose)
2839b1aec48SLars Fredriksen 	    setlogmask(LOG_UPTO(LOG_INFO));
2849f65f104SPeter Wemm 	else
2859b1aec48SLars Fredriksen 	    setlogmask(LOG_UPTO(LOG_WARNING));
28601c855caSPeter Wemm     }
2879b1aec48SLars Fredriksen 
28801c855caSPeter Wemm     if (chat_file != NULL) {
28918ebe779SXin LI 	if (*argv != NULL)
2909b1aec48SLars Fredriksen 	    usage();
29118ebe779SXin LI 	else {
29218ebe779SXin LI             init();
2939b1aec48SLars Fredriksen 	    do_file(chat_file);
29418ebe779SXin LI 	}
29501c855caSPeter Wemm     } else {
29618ebe779SXin LI 	init();
29718ebe779SXin LI 	while (*argv != NULL && argc > 0) {
29818ebe779SXin LI 	    chat_expect(*argv);
29918ebe779SXin LI 	    argv++;
30018ebe779SXin LI 	    argc--;
3019b1aec48SLars Fredriksen 
30218ebe779SXin LI 	    if (*argv != NULL && argc > 0) {
30318ebe779SXin LI 		chat_send(*argv);
30418ebe779SXin LI 		argv++;
30518ebe779SXin LI 		argc--;
30618ebe779SXin LI 	    }
3079b1aec48SLars Fredriksen 	}
3089b1aec48SLars Fredriksen     }
3099b1aec48SLars Fredriksen 
3109b1aec48SLars Fredriksen     terminate(0);
3113d793cf1SPeter Wemm     return 0;
3129b1aec48SLars Fredriksen }
3139b1aec48SLars Fredriksen 
3149b1aec48SLars Fredriksen /*
3159b1aec48SLars Fredriksen  *  Process a chat script when read from a file.
3169b1aec48SLars Fredriksen  */
3179b1aec48SLars Fredriksen 
318ee6b974cSMark Murray void
319ee6b974cSMark Murray do_file(char *chatfile)
3209b1aec48SLars Fredriksen {
321d7d10053SAlexander Langer     int linect, sendflg;
3229b1aec48SLars Fredriksen     char *sp, *arg, quote;
3239b1aec48SLars Fredriksen     char buf [STR_LEN];
3249b1aec48SLars Fredriksen     FILE *cfp;
3259b1aec48SLars Fredriksen 
326ee6b974cSMark Murray     cfp = fopen (chatfile, "r");
3279f65f104SPeter Wemm     if (cfp == NULL)
328ee6b974cSMark Murray 	fatal(1, "%s -- open failed: %m", chatfile);
3299b1aec48SLars Fredriksen 
3309b1aec48SLars Fredriksen     linect = 0;
3319b1aec48SLars Fredriksen     sendflg = 0;
3329b1aec48SLars Fredriksen 
33301c855caSPeter Wemm     while (fgets(buf, STR_LEN, cfp) != NULL) {
3349b1aec48SLars Fredriksen 	sp = strchr (buf, '\n');
3359b1aec48SLars Fredriksen 	if (sp)
3369b1aec48SLars Fredriksen 	    *sp = '\0';
3379b1aec48SLars Fredriksen 
3389b1aec48SLars Fredriksen 	linect++;
3399b1aec48SLars Fredriksen 	sp = buf;
3403d793cf1SPeter Wemm 
3413d793cf1SPeter Wemm         /* lines starting with '#' are comments. If a real '#'
3423d793cf1SPeter Wemm            is to be expected, it should be quoted .... */
34301c855caSPeter Wemm         if ( *sp == '#' )
34401c855caSPeter Wemm 	    continue;
3453d793cf1SPeter Wemm 
34601c855caSPeter Wemm 	while (*sp != '\0') {
34701c855caSPeter Wemm 	    if (*sp == ' ' || *sp == '\t') {
3489b1aec48SLars Fredriksen 		++sp;
3499b1aec48SLars Fredriksen 		continue;
3509b1aec48SLars Fredriksen 	    }
3519b1aec48SLars Fredriksen 
35201c855caSPeter Wemm 	    if (*sp == '"' || *sp == '\'') {
3539b1aec48SLars Fredriksen 		quote = *sp++;
3549b1aec48SLars Fredriksen 		arg = sp;
35501c855caSPeter Wemm 		while (*sp != quote) {
3569b1aec48SLars Fredriksen 		    if (*sp == '\0')
35701c855caSPeter Wemm 			fatal(1, "unterminated quote (line %d)", linect);
3589b1aec48SLars Fredriksen 
35901c855caSPeter Wemm 		    if (*sp++ == '\\') {
3609b1aec48SLars Fredriksen 			if (*sp != '\0')
3619b1aec48SLars Fredriksen 			    ++sp;
3629b1aec48SLars Fredriksen 		    }
3639b1aec48SLars Fredriksen 		}
3649f65f104SPeter Wemm 	    }
36501c855caSPeter Wemm 	    else {
3669b1aec48SLars Fredriksen 		arg = sp;
3679b1aec48SLars Fredriksen 		while (*sp != '\0' && *sp != ' ' && *sp != '\t')
3689b1aec48SLars Fredriksen 		    ++sp;
3699b1aec48SLars Fredriksen 	    }
3709b1aec48SLars Fredriksen 
3719b1aec48SLars Fredriksen 	    if (*sp != '\0')
3729b1aec48SLars Fredriksen 		*sp++ = '\0';
3739b1aec48SLars Fredriksen 
3749b1aec48SLars Fredriksen 	    if (sendflg)
3759b1aec48SLars Fredriksen 		chat_send (arg);
3769b1aec48SLars Fredriksen 	    else
3779b1aec48SLars Fredriksen 		chat_expect (arg);
3789b1aec48SLars Fredriksen 	    sendflg = !sendflg;
3799b1aec48SLars Fredriksen 	}
3809b1aec48SLars Fredriksen     }
3819b1aec48SLars Fredriksen     fclose (cfp);
3829b1aec48SLars Fredriksen }
3839b1aec48SLars Fredriksen 
3849b1aec48SLars Fredriksen /*
3859b1aec48SLars Fredriksen  *	We got an error parsing the command line.
3869b1aec48SLars Fredriksen  */
387afaeb553SPhilippe Charnier static void
388ee6b974cSMark Murray usage(void)
3899b1aec48SLars Fredriksen {
39018ebe779SXin LI     fprintf(stderr,
39118ebe779SXin LI       "Usage: chat [-esSvV] [-f chat-file] [-r report-file] [-t timeout]\n"
39218ebe779SXin LI       "            [-T phone-number] [-U phone-number2] [chat-script]\n"
39318ebe779SXin LI       "where chat-script has the form:\n"
39418ebe779SXin LI       "            [...[[expect[-send[-expect...]] send expect[-send[-expect]] ...]]]\n");
3959b1aec48SLars Fredriksen     exit(1);
3969b1aec48SLars Fredriksen }
3979b1aec48SLars Fredriksen 
3989b1aec48SLars Fredriksen /*
39901c855caSPeter Wemm  * Send a message to syslog and/or stderr.
4009b1aec48SLars Fredriksen  */
401ee6b974cSMark Murray void
4028491f234STim Kientzle chat_logf(const char *fmt, ...)
4039b1aec48SLars Fredriksen {
404bf70beceSEd Schouten     char line[1024];
40501c855caSPeter Wemm     va_list args;
40601c855caSPeter Wemm 
40701c855caSPeter Wemm     va_start(args, fmt);
40801c855caSPeter Wemm     vfmtmsg(line, sizeof(line), fmt, args);
409544c5e5bSKevin Lo     va_end(args);
41001c855caSPeter Wemm     if (to_log)
41101c855caSPeter Wemm 	syslog(LOG_INFO, "%s", line);
41201c855caSPeter Wemm     if (to_stderr)
41301c855caSPeter Wemm 	fprintf(stderr, "%s\n", line);
4149b1aec48SLars Fredriksen }
4159b1aec48SLars Fredriksen 
4169b1aec48SLars Fredriksen /*
4179b1aec48SLars Fredriksen  *	Print an error message and terminate.
4189b1aec48SLars Fredriksen  */
4199b1aec48SLars Fredriksen 
420ee6b974cSMark Murray void
421ee6b974cSMark Murray fatal(int code, const char *fmt, ...)
4229b1aec48SLars Fredriksen {
423bf70beceSEd Schouten     char line[1024];
42401c855caSPeter Wemm     va_list args;
4259b1aec48SLars Fredriksen 
42601c855caSPeter Wemm     va_start(args, fmt);
42701c855caSPeter Wemm     vfmtmsg(line, sizeof(line), fmt, args);
428544c5e5bSKevin Lo     va_end(args);
42901c855caSPeter Wemm     if (to_log)
43001c855caSPeter Wemm 	syslog(LOG_ERR, "%s", line);
43101c855caSPeter Wemm     if (to_stderr)
43201c855caSPeter Wemm 	fprintf(stderr, "%s\n", line);
43301c855caSPeter Wemm     terminate(code);
4349b1aec48SLars Fredriksen }
4359b1aec48SLars Fredriksen 
436bf70beceSEd Schouten static int alarmed;
4379b1aec48SLars Fredriksen 
438ee6b974cSMark Murray SIGTYPE sigalrm(int signo __unused)
4399b1aec48SLars Fredriksen {
4409b1aec48SLars Fredriksen     int flags;
4419b1aec48SLars Fredriksen 
4429b1aec48SLars Fredriksen     alarm(1);
4439b1aec48SLars Fredriksen     alarmed = 1;		/* Reset alarm to avoid race window */
4449b1aec48SLars Fredriksen     signal(SIGALRM, sigalrm);	/* that can cause hanging in read() */
4459b1aec48SLars Fredriksen 
4469b1aec48SLars Fredriksen     if ((flags = fcntl(0, F_GETFL, 0)) == -1)
44701c855caSPeter Wemm 	fatal(2, "Can't get file mode flags on stdin: %m");
44801c855caSPeter Wemm 
4499f65f104SPeter Wemm     if (fcntl(0, F_SETFL, flags | O_NONBLOCK) == -1)
45001c855caSPeter Wemm 	fatal(2, "Can't set file mode flags on stdin: %m");
4519b1aec48SLars Fredriksen 
4529b1aec48SLars Fredriksen     if (verbose)
4538491f234STim Kientzle 	chat_logf("alarm");
4549b1aec48SLars Fredriksen }
4559b1aec48SLars Fredriksen 
456ee6b974cSMark Murray SIGTYPE sigint(int signo __unused)
4579b1aec48SLars Fredriksen {
45801c855caSPeter Wemm     fatal(2, "SIGINT");
4599b1aec48SLars Fredriksen }
4609b1aec48SLars Fredriksen 
461ee6b974cSMark Murray SIGTYPE sigterm(int signo __unused)
4629b1aec48SLars Fredriksen {
46301c855caSPeter Wemm     fatal(2, "SIGTERM");
4649b1aec48SLars Fredriksen }
4659b1aec48SLars Fredriksen 
466ee6b974cSMark Murray SIGTYPE sighup(int signo __unused)
4679b1aec48SLars Fredriksen {
46801c855caSPeter Wemm     fatal(2, "SIGHUP");
4699b1aec48SLars Fredriksen }
4709b1aec48SLars Fredriksen 
471ee6b974cSMark Murray void init(void)
4729b1aec48SLars Fredriksen {
4739b1aec48SLars Fredriksen     signal(SIGINT, sigint);
4749b1aec48SLars Fredriksen     signal(SIGTERM, sigterm);
4759b1aec48SLars Fredriksen     signal(SIGHUP, sighup);
4769b1aec48SLars Fredriksen 
4779b1aec48SLars Fredriksen     set_tty_parameters();
4789b1aec48SLars Fredriksen     signal(SIGALRM, sigalrm);
4799b1aec48SLars Fredriksen     alarm(0);
4809b1aec48SLars Fredriksen     alarmed = 0;
4819b1aec48SLars Fredriksen }
4829b1aec48SLars Fredriksen 
483ee6b974cSMark Murray void set_tty_parameters(void)
4849b1aec48SLars Fredriksen {
4859f65f104SPeter Wemm #if defined(get_term_param)
4869f65f104SPeter Wemm     term_parms t;
4879b1aec48SLars Fredriksen 
4889f65f104SPeter Wemm     if (get_term_param (&t) < 0)
48901c855caSPeter Wemm 	fatal(2, "Can't get terminal parameters: %m");
4909b1aec48SLars Fredriksen 
4919b1aec48SLars Fredriksen     saved_tty_parameters = t;
4929b1aec48SLars Fredriksen     have_tty_parameters  = 1;
4939b1aec48SLars Fredriksen 
4949b1aec48SLars Fredriksen     t.c_iflag     |= IGNBRK | ISTRIP | IGNPAR;
4959b1aec48SLars Fredriksen     t.c_oflag      = 0;
4969b1aec48SLars Fredriksen     t.c_lflag      = 0;
4979f65f104SPeter Wemm     t.c_cc[VERASE] =
4989f65f104SPeter Wemm     t.c_cc[VKILL]  = 0;
4999b1aec48SLars Fredriksen     t.c_cc[VMIN]   = 1;
5009b1aec48SLars Fredriksen     t.c_cc[VTIME]  = 0;
5019b1aec48SLars Fredriksen 
5029f65f104SPeter Wemm     if (set_term_param (&t) < 0)
50301c855caSPeter Wemm 	fatal(2, "Can't set terminal parameters: %m");
5049b1aec48SLars Fredriksen #endif
5059b1aec48SLars Fredriksen }
5069b1aec48SLars Fredriksen 
507ee6b974cSMark Murray void break_sequence(void)
5089b1aec48SLars Fredriksen {
5099b1aec48SLars Fredriksen     tcsendbreak (0, 0);
5109b1aec48SLars Fredriksen }
5119b1aec48SLars Fredriksen 
512ee6b974cSMark Murray void terminate(int status)
5139b1aec48SLars Fredriksen {
5143d793cf1SPeter Wemm     echo_stderr(-1);
51501c855caSPeter Wemm     if (report_file != (char *) 0 && report_fp != (FILE *) NULL) {
5163d793cf1SPeter Wemm /*
5173d793cf1SPeter Wemm  * Allow the last of the report string to be gathered before we terminate.
5183d793cf1SPeter Wemm  */
5193d793cf1SPeter Wemm 	if (report_gathering) {
520ee6b974cSMark Murray 	    int c;
521ee6b974cSMark Murray 	    size_t rep_len;
5223d793cf1SPeter Wemm 
5233d793cf1SPeter Wemm 	    rep_len = strlen(report_buffer);
524*d2c82c0cSDon Lewis 	    while (rep_len + 1 < sizeof(report_buffer)) {
5253d793cf1SPeter Wemm 		alarm(1);
5263d793cf1SPeter Wemm 		c = get_char();
5273d793cf1SPeter Wemm 		alarm(0);
5283d793cf1SPeter Wemm 		if (c < 0 || iscntrl(c))
5293d793cf1SPeter Wemm 		    break;
5303d793cf1SPeter Wemm 		report_buffer[rep_len] = c;
5313d793cf1SPeter Wemm 		++rep_len;
5323d793cf1SPeter Wemm 	    }
5333d793cf1SPeter Wemm 	    report_buffer[rep_len] = 0;
5343d793cf1SPeter Wemm 	    fprintf (report_fp, "chat:  %s\n", report_buffer);
5353d793cf1SPeter Wemm 	}
5369f65f104SPeter Wemm 	if (verbose)
5379f65f104SPeter Wemm 	    fprintf (report_fp, "Closing \"%s\".\n", report_file);
5389f65f104SPeter Wemm 	fclose (report_fp);
5399f65f104SPeter Wemm 	report_fp = (FILE *) NULL;
5409f65f104SPeter Wemm     }
5419f65f104SPeter Wemm 
5429f65f104SPeter Wemm #if defined(get_term_param)
54301c855caSPeter Wemm     if (have_tty_parameters) {
5449f65f104SPeter Wemm 	if (set_term_param (&saved_tty_parameters) < 0)
54501c855caSPeter Wemm 	    fatal(2, "Can't restore terminal parameters: %m");
5469f65f104SPeter Wemm     }
5479f65f104SPeter Wemm #endif
5489f65f104SPeter Wemm 
5499b1aec48SLars Fredriksen     exit(status);
5509b1aec48SLars Fredriksen }
5519b1aec48SLars Fredriksen 
5529b1aec48SLars Fredriksen /*
5539b1aec48SLars Fredriksen  *	'Clean up' this string.
5549b1aec48SLars Fredriksen  */
555ee6b974cSMark Murray char *
556ee6b974cSMark Murray clean(char *s, int sending)
5579b1aec48SLars Fredriksen {
5589b1aec48SLars Fredriksen     char temp[STR_LEN], cur_chr;
559ee6b974cSMark Murray     char *s1, *phchar;
5609b1aec48SLars Fredriksen     int add_return = sending;
5619b1aec48SLars Fredriksen #define isoctal(chr) (((chr) >= '0') && ((chr) <= '7'))
5629b1aec48SLars Fredriksen 
5639b1aec48SLars Fredriksen     s1 = temp;
5644e83a8feSKris Kennaway     /* Don't overflow buffer, leave room for chars we append later */
565ee6b974cSMark Murray     while (*s && s1 - temp < (off_t)(sizeof(temp) - 2 - add_return)) {
5669b1aec48SLars Fredriksen 	cur_chr = *s++;
56701c855caSPeter Wemm 	if (cur_chr == '^') {
5689b1aec48SLars Fredriksen 	    cur_chr = *s++;
56901c855caSPeter Wemm 	    if (cur_chr == '\0') {
5709b1aec48SLars Fredriksen 		*s1++ = '^';
5719b1aec48SLars Fredriksen 		break;
5729b1aec48SLars Fredriksen 	    }
5739b1aec48SLars Fredriksen 	    cur_chr &= 0x1F;
57401c855caSPeter Wemm 	    if (cur_chr != 0) {
5759b1aec48SLars Fredriksen 		*s1++ = cur_chr;
5769f65f104SPeter Wemm 	    }
5779b1aec48SLars Fredriksen 	    continue;
5789b1aec48SLars Fredriksen 	}
5799b1aec48SLars Fredriksen 
58001c855caSPeter Wemm 	if (cur_chr != '\\') {
5819b1aec48SLars Fredriksen 	    *s1++ = cur_chr;
5829b1aec48SLars Fredriksen 	    continue;
5839b1aec48SLars Fredriksen 	}
5849b1aec48SLars Fredriksen 
5859b1aec48SLars Fredriksen 	cur_chr = *s++;
58601c855caSPeter Wemm 	if (cur_chr == '\0') {
58701c855caSPeter Wemm 	    if (sending) {
5889b1aec48SLars Fredriksen 		*s1++ = '\\';
5899b1aec48SLars Fredriksen 		*s1++ = '\\';
5909b1aec48SLars Fredriksen 	    }
5919b1aec48SLars Fredriksen 	    break;
5929b1aec48SLars Fredriksen 	}
5939b1aec48SLars Fredriksen 
59401c855caSPeter Wemm 	switch (cur_chr) {
5959b1aec48SLars Fredriksen 	case 'b':
5969b1aec48SLars Fredriksen 	    *s1++ = '\b';
5979b1aec48SLars Fredriksen 	    break;
5989b1aec48SLars Fredriksen 
5999b1aec48SLars Fredriksen 	case 'c':
6009b1aec48SLars Fredriksen 	    if (sending && *s == '\0')
6019b1aec48SLars Fredriksen 		add_return = 0;
6029b1aec48SLars Fredriksen 	    else
6039b1aec48SLars Fredriksen 		*s1++ = cur_chr;
6049b1aec48SLars Fredriksen 	    break;
6059b1aec48SLars Fredriksen 
6069b1aec48SLars Fredriksen 	case '\\':
6079b1aec48SLars Fredriksen 	case 'K':
6089b1aec48SLars Fredriksen 	case 'p':
6099b1aec48SLars Fredriksen 	case 'd':
6109b1aec48SLars Fredriksen 	    if (sending)
6119b1aec48SLars Fredriksen 		*s1++ = '\\';
6129b1aec48SLars Fredriksen 
6139b1aec48SLars Fredriksen 	    *s1++ = cur_chr;
6149b1aec48SLars Fredriksen 	    break;
6159b1aec48SLars Fredriksen 
61601c855caSPeter Wemm 	case 'T':
61701c855caSPeter Wemm 	    if (sending && phone_num) {
61801c855caSPeter Wemm 		for ( phchar = phone_num; *phchar != '\0'; phchar++)
61901c855caSPeter Wemm 		    *s1++ = *phchar;
62001c855caSPeter Wemm 	    }
62101c855caSPeter Wemm 	    else {
62201c855caSPeter Wemm 		*s1++ = '\\';
62301c855caSPeter Wemm 		*s1++ = 'T';
62401c855caSPeter Wemm 	    }
62501c855caSPeter Wemm 	    break;
62601c855caSPeter Wemm 
62701c855caSPeter Wemm 	case 'U':
62801c855caSPeter Wemm 	    if (sending && phone_num2) {
62901c855caSPeter Wemm 		for ( phchar = phone_num2; *phchar != '\0'; phchar++)
63001c855caSPeter Wemm 		    *s1++ = *phchar;
63101c855caSPeter Wemm 	    }
63201c855caSPeter Wemm 	    else {
63301c855caSPeter Wemm 		*s1++ = '\\';
63401c855caSPeter Wemm 		*s1++ = 'U';
63501c855caSPeter Wemm 	    }
63601c855caSPeter Wemm 	    break;
63701c855caSPeter Wemm 
6389b1aec48SLars Fredriksen 	case 'q':
6393d793cf1SPeter Wemm 	    quiet = 1;
6409b1aec48SLars Fredriksen 	    break;
6419b1aec48SLars Fredriksen 
6429b1aec48SLars Fredriksen 	case 'r':
6439b1aec48SLars Fredriksen 	    *s1++ = '\r';
6449b1aec48SLars Fredriksen 	    break;
6459b1aec48SLars Fredriksen 
6469b1aec48SLars Fredriksen 	case 'n':
6479b1aec48SLars Fredriksen 	    *s1++ = '\n';
6489b1aec48SLars Fredriksen 	    break;
6499b1aec48SLars Fredriksen 
6509b1aec48SLars Fredriksen 	case 's':
6519b1aec48SLars Fredriksen 	    *s1++ = ' ';
6529b1aec48SLars Fredriksen 	    break;
6539b1aec48SLars Fredriksen 
6549b1aec48SLars Fredriksen 	case 't':
6559b1aec48SLars Fredriksen 	    *s1++ = '\t';
6569b1aec48SLars Fredriksen 	    break;
6579b1aec48SLars Fredriksen 
6589b1aec48SLars Fredriksen 	case 'N':
65901c855caSPeter Wemm 	    if (sending) {
6609b1aec48SLars Fredriksen 		*s1++ = '\\';
6619b1aec48SLars Fredriksen 		*s1++ = '\0';
6629b1aec48SLars Fredriksen 	    }
6639b1aec48SLars Fredriksen 	    else
6649b1aec48SLars Fredriksen 		*s1++ = 'N';
6659b1aec48SLars Fredriksen 	    break;
6669b1aec48SLars Fredriksen 
6679b1aec48SLars Fredriksen 	default:
66801c855caSPeter Wemm 	    if (isoctal (cur_chr)) {
6699b1aec48SLars Fredriksen 		cur_chr &= 0x07;
67001c855caSPeter Wemm 		if (isoctal (*s)) {
6719b1aec48SLars Fredriksen 		    cur_chr <<= 3;
6729b1aec48SLars Fredriksen 		    cur_chr |= *s++ - '0';
67301c855caSPeter Wemm 		    if (isoctal (*s)) {
6749b1aec48SLars Fredriksen 			cur_chr <<= 3;
6759b1aec48SLars Fredriksen 			cur_chr |= *s++ - '0';
6769b1aec48SLars Fredriksen 		    }
6779b1aec48SLars Fredriksen 		}
6789b1aec48SLars Fredriksen 
67901c855caSPeter Wemm 		if (cur_chr != 0 || sending) {
6809b1aec48SLars Fredriksen 		    if (sending && (cur_chr == '\\' || cur_chr == 0))
6819b1aec48SLars Fredriksen 			*s1++ = '\\';
6829b1aec48SLars Fredriksen 		    *s1++ = cur_chr;
6839b1aec48SLars Fredriksen 		}
6849b1aec48SLars Fredriksen 		break;
6859b1aec48SLars Fredriksen 	    }
6869b1aec48SLars Fredriksen 
6879b1aec48SLars Fredriksen 	    if (sending)
6889b1aec48SLars Fredriksen 		*s1++ = '\\';
6899b1aec48SLars Fredriksen 	    *s1++ = cur_chr;
6909b1aec48SLars Fredriksen 	    break;
6919b1aec48SLars Fredriksen 	}
6929b1aec48SLars Fredriksen     }
6939b1aec48SLars Fredriksen 
6949b1aec48SLars Fredriksen     if (add_return)
6959b1aec48SLars Fredriksen 	*s1++ = '\r';
6969b1aec48SLars Fredriksen 
6979b1aec48SLars Fredriksen     *s1++ = '\0'; /* guarantee closure */
6989b1aec48SLars Fredriksen     *s1++ = '\0'; /* terminate the string */
6999b1aec48SLars Fredriksen     return dup_mem (temp, (size_t) (s1 - temp)); /* may have embedded nuls */
7009b1aec48SLars Fredriksen }
7019b1aec48SLars Fredriksen 
7029b1aec48SLars Fredriksen /*
7033d793cf1SPeter Wemm  * A modified version of 'strtok'. This version skips \ sequences.
7043d793cf1SPeter Wemm  */
7053d793cf1SPeter Wemm 
706ee6b974cSMark Murray char *
707ee6b974cSMark Murray expect_strtok (char *s, const char *term)
7083d793cf1SPeter Wemm {
709ee6b974cSMark Murray     static  char *str   = blank;
7103d793cf1SPeter Wemm     int	    escape_flag = 0;
7113d793cf1SPeter Wemm     char   *result;
71201c855caSPeter Wemm 
7133d793cf1SPeter Wemm /*
7143d793cf1SPeter Wemm  * If a string was specified then do initial processing.
7153d793cf1SPeter Wemm  */
7163d793cf1SPeter Wemm     if (s)
7173d793cf1SPeter Wemm 	str = s;
71801c855caSPeter Wemm 
7193d793cf1SPeter Wemm /*
7203d793cf1SPeter Wemm  * If this is the escape flag then reset it and ignore the character.
7213d793cf1SPeter Wemm  */
7223d793cf1SPeter Wemm     if (*str)
7233d793cf1SPeter Wemm 	result = str;
7243d793cf1SPeter Wemm     else
7253d793cf1SPeter Wemm 	result = (char *) 0;
7263d793cf1SPeter Wemm 
72701c855caSPeter Wemm     while (*str) {
72801c855caSPeter Wemm 	if (escape_flag) {
7293d793cf1SPeter Wemm 	    escape_flag = 0;
7303d793cf1SPeter Wemm 	    ++str;
7313d793cf1SPeter Wemm 	    continue;
7323d793cf1SPeter Wemm 	}
7333d793cf1SPeter Wemm 
73401c855caSPeter Wemm 	if (*str == '\\') {
7353d793cf1SPeter Wemm 	    ++str;
7363d793cf1SPeter Wemm 	    escape_flag = 1;
7373d793cf1SPeter Wemm 	    continue;
7383d793cf1SPeter Wemm 	}
73901c855caSPeter Wemm 
7403d793cf1SPeter Wemm /*
7413d793cf1SPeter Wemm  * If this is not in the termination string, continue.
7423d793cf1SPeter Wemm  */
74301c855caSPeter Wemm 	if (strchr (term, *str) == (char *) 0) {
7443d793cf1SPeter Wemm 	    ++str;
7453d793cf1SPeter Wemm 	    continue;
7463d793cf1SPeter Wemm 	}
74701c855caSPeter Wemm 
7483d793cf1SPeter Wemm /*
7493d793cf1SPeter Wemm  * This is the terminator. Mark the end of the string and stop.
7503d793cf1SPeter Wemm  */
7513d793cf1SPeter Wemm 	*str++ = '\0';
7523d793cf1SPeter Wemm 	break;
7533d793cf1SPeter Wemm     }
7543d793cf1SPeter Wemm     return (result);
7553d793cf1SPeter Wemm }
7563d793cf1SPeter Wemm 
7573d793cf1SPeter Wemm /*
7589b1aec48SLars Fredriksen  * Process the expect string
7599b1aec48SLars Fredriksen  */
7603d793cf1SPeter Wemm 
761ee6b974cSMark Murray void
762ee6b974cSMark Murray chat_expect(char *s)
7639b1aec48SLars Fredriksen {
7643d793cf1SPeter Wemm     char *expect;
7653d793cf1SPeter Wemm     char *reply;
7663d793cf1SPeter Wemm 
76701c855caSPeter Wemm     if (strcmp(s, "HANGUP") == 0) {
7683d793cf1SPeter Wemm 	++hup_next;
7693d793cf1SPeter Wemm         return;
7703d793cf1SPeter Wemm     }
7713d793cf1SPeter Wemm 
77201c855caSPeter Wemm     if (strcmp(s, "ABORT") == 0) {
7739b1aec48SLars Fredriksen 	++abort_next;
7749b1aec48SLars Fredriksen 	return;
7759b1aec48SLars Fredriksen     }
7769b1aec48SLars Fredriksen 
77701c855caSPeter Wemm     if (strcmp(s, "CLR_ABORT") == 0) {
7783d793cf1SPeter Wemm 	++clear_abort_next;
7793d793cf1SPeter Wemm 	return;
7803d793cf1SPeter Wemm     }
7813d793cf1SPeter Wemm 
78201c855caSPeter Wemm     if (strcmp(s, "REPORT") == 0) {
7839f65f104SPeter Wemm 	++report_next;
7849f65f104SPeter Wemm 	return;
7859f65f104SPeter Wemm     }
7869f65f104SPeter Wemm 
78701c855caSPeter Wemm     if (strcmp(s, "CLR_REPORT") == 0) {
7883d793cf1SPeter Wemm 	++clear_report_next;
7893d793cf1SPeter Wemm 	return;
7903d793cf1SPeter Wemm     }
7913d793cf1SPeter Wemm 
79201c855caSPeter Wemm     if (strcmp(s, "TIMEOUT") == 0) {
7939b1aec48SLars Fredriksen 	++timeout_next;
7949b1aec48SLars Fredriksen 	return;
7959b1aec48SLars Fredriksen     }
7969b1aec48SLars Fredriksen 
79701c855caSPeter Wemm     if (strcmp(s, "ECHO") == 0) {
7983d793cf1SPeter Wemm 	++echo_next;
7993d793cf1SPeter Wemm 	return;
8003d793cf1SPeter Wemm     }
80101c855caSPeter Wemm 
80201c855caSPeter Wemm     if (strcmp(s, "SAY") == 0) {
8033d793cf1SPeter Wemm 	++say_next;
8043d793cf1SPeter Wemm 	return;
8053d793cf1SPeter Wemm     }
80601c855caSPeter Wemm 
8073d793cf1SPeter Wemm /*
8083d793cf1SPeter Wemm  * Fetch the expect and reply string.
8093d793cf1SPeter Wemm  */
81001c855caSPeter Wemm     for (;;) {
8113d793cf1SPeter Wemm 	expect = expect_strtok (s, "-");
8123d793cf1SPeter Wemm 	s      = (char *) 0;
8139b1aec48SLars Fredriksen 
8143d793cf1SPeter Wemm 	if (expect == (char *) 0)
8153d793cf1SPeter Wemm 	    return;
8163d793cf1SPeter Wemm 
8173d793cf1SPeter Wemm 	reply = expect_strtok (s, "-");
81801c855caSPeter Wemm 
8193d793cf1SPeter Wemm /*
8203d793cf1SPeter Wemm  * Handle the expect string. If successful then exit.
8213d793cf1SPeter Wemm  */
8223d793cf1SPeter Wemm 	if (get_string (expect))
8233d793cf1SPeter Wemm 	    return;
82401c855caSPeter Wemm 
8253d793cf1SPeter Wemm /*
8263d793cf1SPeter Wemm  * If there is a sub-reply string then send it. Otherwise any condition
8273d793cf1SPeter Wemm  * is terminal.
8283d793cf1SPeter Wemm  */
8293d793cf1SPeter Wemm 	if (reply == (char *) 0 || exit_code != 3)
8309b1aec48SLars Fredriksen 	    break;
8319b1aec48SLars Fredriksen 
8323d793cf1SPeter Wemm 	chat_send (reply);
8339f65f104SPeter Wemm     }
83401c855caSPeter Wemm 
8353d793cf1SPeter Wemm /*
8363d793cf1SPeter Wemm  * The expectation did not occur. This is terminal.
8373d793cf1SPeter Wemm  */
8389b1aec48SLars Fredriksen     if (fail_reason)
8398491f234STim Kientzle 	chat_logf("Failed (%s)", fail_reason);
8409b1aec48SLars Fredriksen     else
8418491f234STim Kientzle 	chat_logf("Failed");
8429f65f104SPeter Wemm     terminate(exit_code);
8439f65f104SPeter Wemm }
8443d793cf1SPeter Wemm 
8453d793cf1SPeter Wemm /*
8463d793cf1SPeter Wemm  * Translate the input character to the appropriate string for printing
8473d793cf1SPeter Wemm  * the data.
8483d793cf1SPeter Wemm  */
8499b1aec48SLars Fredriksen 
850ee6b974cSMark Murray char *
851ee6b974cSMark Murray character(int c)
8529b1aec48SLars Fredriksen {
8539b1aec48SLars Fredriksen     static char string[10];
854ee6b974cSMark Murray     const char *meta;
8559b1aec48SLars Fredriksen 
8569b1aec48SLars Fredriksen     meta = (c & 0x80) ? "M-" : "";
8579b1aec48SLars Fredriksen     c &= 0x7F;
8589b1aec48SLars Fredriksen 
8599b1aec48SLars Fredriksen     if (c < 32)
8609b1aec48SLars Fredriksen 	sprintf(string, "%s^%c", meta, (int)c + '@');
86101c855caSPeter Wemm     else if (c == 127)
8629b1aec48SLars Fredriksen 	sprintf(string, "%s^?", meta);
8639b1aec48SLars Fredriksen     else
8649b1aec48SLars Fredriksen 	sprintf(string, "%s%c", meta, c);
8659b1aec48SLars Fredriksen 
8669b1aec48SLars Fredriksen     return (string);
8679b1aec48SLars Fredriksen }
8689b1aec48SLars Fredriksen 
8699b1aec48SLars Fredriksen /*
8709b1aec48SLars Fredriksen  *  process the reply string
8719b1aec48SLars Fredriksen  */
872ee6b974cSMark Murray void
873ee6b974cSMark Murray chat_send(char *s)
8749b1aec48SLars Fredriksen {
87501c855caSPeter Wemm     if (say_next) {
8763d793cf1SPeter Wemm 	say_next = 0;
8773d793cf1SPeter Wemm 	s = clean(s,0);
878e1b4d8d0SSheldon Hearn 	write(STDERR_FILENO, s, strlen(s));
8793d793cf1SPeter Wemm         free(s);
8803d793cf1SPeter Wemm 	return;
8813d793cf1SPeter Wemm     }
88201c855caSPeter Wemm 
88301c855caSPeter Wemm     if (hup_next) {
8843d793cf1SPeter Wemm         hup_next = 0;
8853d793cf1SPeter Wemm 	if (strcmp(s, "OFF") == 0)
8863d793cf1SPeter Wemm            signal(SIGHUP, SIG_IGN);
8873d793cf1SPeter Wemm         else
8883d793cf1SPeter Wemm            signal(SIGHUP, sighup);
8893d793cf1SPeter Wemm         return;
8903d793cf1SPeter Wemm     }
89101c855caSPeter Wemm 
89201c855caSPeter Wemm     if (echo_next) {
8933d793cf1SPeter Wemm 	echo_next = 0;
8943d793cf1SPeter Wemm 	echo = (strcmp(s, "ON") == 0);
8953d793cf1SPeter Wemm 	return;
8963d793cf1SPeter Wemm     }
89701c855caSPeter Wemm 
89801c855caSPeter Wemm     if (abort_next) {
8999b1aec48SLars Fredriksen 	char *s1;
9009b1aec48SLars Fredriksen 
9019b1aec48SLars Fredriksen 	abort_next = 0;
9029b1aec48SLars Fredriksen 
9039b1aec48SLars Fredriksen 	if (n_aborts >= MAX_ABORTS)
90401c855caSPeter Wemm 	    fatal(2, "Too many ABORT strings");
9059b1aec48SLars Fredriksen 
9069b1aec48SLars Fredriksen 	s1 = clean(s, 0);
9079b1aec48SLars Fredriksen 
9089f65f104SPeter Wemm 	if (strlen(s1) > strlen(s)
9099f65f104SPeter Wemm 	    || strlen(s1) + 1 > sizeof(fail_buffer))
91001c855caSPeter Wemm 	    fatal(1, "Illegal or too-long ABORT string ('%v')", s);
9119b1aec48SLars Fredriksen 
9129b1aec48SLars Fredriksen 	abort_string[n_aborts++] = s1;
9139b1aec48SLars Fredriksen 
9149b1aec48SLars Fredriksen 	if (verbose)
9158491f234STim Kientzle 	    chat_logf("abort on (%v)", s);
9169f65f104SPeter Wemm 	return;
9179b1aec48SLars Fredriksen     }
9189f65f104SPeter Wemm 
91901c855caSPeter Wemm     if (clear_abort_next) {
9203d793cf1SPeter Wemm 	char *s1;
9213d793cf1SPeter Wemm 	int   i;
9223d793cf1SPeter Wemm         int   old_max;
9233d793cf1SPeter Wemm 	int   pack = 0;
9243d793cf1SPeter Wemm 
9253d793cf1SPeter Wemm 	clear_abort_next = 0;
9263d793cf1SPeter Wemm 
9273d793cf1SPeter Wemm 	s1 = clean(s, 0);
9283d793cf1SPeter Wemm 
9293d793cf1SPeter Wemm 	if (strlen(s1) > strlen(s)
9303d793cf1SPeter Wemm 	    || strlen(s1) + 1 > sizeof(fail_buffer))
93101c855caSPeter Wemm 	    fatal(1, "Illegal or too-long CLR_ABORT string ('%v')", s);
9323d793cf1SPeter Wemm 
9333d793cf1SPeter Wemm         old_max = n_aborts;
93401c855caSPeter Wemm 	for (i=0; i < n_aborts; i++) {
93501c855caSPeter Wemm 	    if ( strcmp(s1,abort_string[i]) == 0 ) {
9363d793cf1SPeter Wemm 		free(abort_string[i]);
9373d793cf1SPeter Wemm 		abort_string[i] = NULL;
9383d793cf1SPeter Wemm 		pack++;
9393d793cf1SPeter Wemm 		n_aborts--;
9403d793cf1SPeter Wemm 		if (verbose)
9418491f234STim Kientzle 		    chat_logf("clear abort on (%v)", s);
9423d793cf1SPeter Wemm 	    }
9433d793cf1SPeter Wemm 	}
9443d793cf1SPeter Wemm         free(s1);
94501c855caSPeter Wemm 	if (pack)
94601c855caSPeter Wemm 	    pack_array(abort_string,old_max);
9473d793cf1SPeter Wemm 	return;
9483d793cf1SPeter Wemm     }
9493d793cf1SPeter Wemm 
95001c855caSPeter Wemm     if (report_next) {
9519f65f104SPeter Wemm 	char *s1;
9529f65f104SPeter Wemm 
9539f65f104SPeter Wemm 	report_next = 0;
9549f65f104SPeter Wemm 	if (n_reports >= MAX_REPORTS)
95501c855caSPeter Wemm 	    fatal(2, "Too many REPORT strings");
9569f65f104SPeter Wemm 
9579f65f104SPeter Wemm 	s1 = clean(s, 0);
9589f65f104SPeter Wemm 
9599f65f104SPeter Wemm 	if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1)
96001c855caSPeter Wemm 	    fatal(1, "Illegal or too-long REPORT string ('%v')", s);
9619f65f104SPeter Wemm 
9629f65f104SPeter Wemm 	report_string[n_reports++] = s1;
9639f65f104SPeter Wemm 
9649f65f104SPeter Wemm 	if (verbose)
9658491f234STim Kientzle 	    chat_logf("report (%v)", s);
9669f65f104SPeter Wemm 	return;
9679f65f104SPeter Wemm     }
9689f65f104SPeter Wemm 
96901c855caSPeter Wemm     if (clear_report_next) {
9703d793cf1SPeter Wemm 	char *s1;
9713d793cf1SPeter Wemm 	int   i;
9723d793cf1SPeter Wemm 	int   old_max;
9733d793cf1SPeter Wemm 	int   pack = 0;
9743d793cf1SPeter Wemm 
9753d793cf1SPeter Wemm 	clear_report_next = 0;
9763d793cf1SPeter Wemm 
9773d793cf1SPeter Wemm 	s1 = clean(s, 0);
9783d793cf1SPeter Wemm 
9793d793cf1SPeter Wemm 	if (strlen(s1) > strlen(s) || strlen(s1) > sizeof fail_buffer - 1)
98001c855caSPeter Wemm 	    fatal(1, "Illegal or too-long REPORT string ('%v')", s);
9813d793cf1SPeter Wemm 
9823d793cf1SPeter Wemm 	old_max = n_reports;
98301c855caSPeter Wemm 	for (i=0; i < n_reports; i++) {
98401c855caSPeter Wemm 	    if ( strcmp(s1,report_string[i]) == 0 ) {
9853d793cf1SPeter Wemm 		free(report_string[i]);
9863d793cf1SPeter Wemm 		report_string[i] = NULL;
9873d793cf1SPeter Wemm 		pack++;
9883d793cf1SPeter Wemm 		n_reports--;
9893d793cf1SPeter Wemm 		if (verbose)
9908491f234STim Kientzle 		    chat_logf("clear report (%v)", s);
9913d793cf1SPeter Wemm 	    }
9923d793cf1SPeter Wemm 	}
9933d793cf1SPeter Wemm         free(s1);
99401c855caSPeter Wemm         if (pack)
99501c855caSPeter Wemm 	    pack_array(report_string,old_max);
9963d793cf1SPeter Wemm 
9973d793cf1SPeter Wemm 	return;
9983d793cf1SPeter Wemm     }
9993d793cf1SPeter Wemm 
100001c855caSPeter Wemm     if (timeout_next) {
10019b1aec48SLars Fredriksen 	timeout_next = 0;
10029b1aec48SLars Fredriksen 	timeout = atoi(s);
10039b1aec48SLars Fredriksen 
10049b1aec48SLars Fredriksen 	if (timeout <= 0)
10059b1aec48SLars Fredriksen 	    timeout = DEFAULT_CHAT_TIMEOUT;
10069b1aec48SLars Fredriksen 
10079b1aec48SLars Fredriksen 	if (verbose)
10088491f234STim Kientzle 	    chat_logf("timeout set to %d seconds", timeout);
100901c855caSPeter Wemm 
10109f65f104SPeter Wemm 	return;
10119f65f104SPeter Wemm     }
10129f65f104SPeter Wemm 
10139f65f104SPeter Wemm     if (strcmp(s, "EOT") == 0)
1014ee6b974cSMark Murray 	s = strdup("^D\\c");
101501c855caSPeter Wemm     else if (strcmp(s, "BREAK") == 0)
1016ee6b974cSMark Murray 	s = strdup("\\K\\c");
10179f65f104SPeter Wemm 
10189b1aec48SLars Fredriksen     if (!put_string(s))
101901c855caSPeter Wemm 	fatal(1, "Failed");
10209b1aec48SLars Fredriksen }
10219b1aec48SLars Fredriksen 
1022ee6b974cSMark Murray int
1023ee6b974cSMark Murray get_char(void)
10249b1aec48SLars Fredriksen {
10259b1aec48SLars Fredriksen     int status;
10269b1aec48SLars Fredriksen     char c;
10279b1aec48SLars Fredriksen 
1028e1b4d8d0SSheldon Hearn     status = read(STDIN_FILENO, &c, 1);
10299b1aec48SLars Fredriksen 
103001c855caSPeter Wemm     switch (status) {
10319b1aec48SLars Fredriksen     case 1:
10329b1aec48SLars Fredriksen 	return ((int)c & 0x7F);
10339b1aec48SLars Fredriksen 
10349b1aec48SLars Fredriksen     default:
10358491f234STim Kientzle 	chat_logf("warning: read() on stdin returned %d", status);
10369b1aec48SLars Fredriksen 
10379b1aec48SLars Fredriksen     case -1:
10389b1aec48SLars Fredriksen 	if ((status = fcntl(0, F_GETFL, 0)) == -1)
103901c855caSPeter Wemm 	    fatal(2, "Can't get file mode flags on stdin: %m");
104001c855caSPeter Wemm 
10419f65f104SPeter Wemm 	if (fcntl(0, F_SETFL, status & ~O_NONBLOCK) == -1)
104201c855caSPeter Wemm 	    fatal(2, "Can't set file mode flags on stdin: %m");
10439b1aec48SLars Fredriksen 
10449b1aec48SLars Fredriksen 	return (-1);
10459b1aec48SLars Fredriksen     }
10469b1aec48SLars Fredriksen }
10479b1aec48SLars Fredriksen 
1048ee6b974cSMark Murray int put_char(int c)
10499b1aec48SLars Fredriksen {
10509b1aec48SLars Fredriksen     int status;
10519f65f104SPeter Wemm     char ch = c;
10529b1aec48SLars Fredriksen 
10539f65f104SPeter Wemm     usleep(10000);		/* inter-character typing delay (?) */
10549b1aec48SLars Fredriksen 
1055e1b4d8d0SSheldon Hearn     status = write(STDOUT_FILENO, &ch, 1);
10569b1aec48SLars Fredriksen 
105701c855caSPeter Wemm     switch (status) {
10589b1aec48SLars Fredriksen     case 1:
10599b1aec48SLars Fredriksen 	return (0);
10609b1aec48SLars Fredriksen 
10619b1aec48SLars Fredriksen     default:
10628491f234STim Kientzle 	chat_logf("warning: write() on stdout returned %d", status);
10639b1aec48SLars Fredriksen 
10649b1aec48SLars Fredriksen     case -1:
10659b1aec48SLars Fredriksen 	if ((status = fcntl(0, F_GETFL, 0)) == -1)
106601c855caSPeter Wemm 	    fatal(2, "Can't get file mode flags on stdin, %m");
106701c855caSPeter Wemm 
10689f65f104SPeter Wemm 	if (fcntl(0, F_SETFL, status & ~O_NONBLOCK) == -1)
106901c855caSPeter Wemm 	    fatal(2, "Can't set file mode flags on stdin: %m");
10709b1aec48SLars Fredriksen 
10719b1aec48SLars Fredriksen 	return (-1);
10729b1aec48SLars Fredriksen     }
10739b1aec48SLars Fredriksen }
10749b1aec48SLars Fredriksen 
1075ee6b974cSMark Murray int
1076ee6b974cSMark Murray write_char(int c)
10779b1aec48SLars Fredriksen {
107801c855caSPeter Wemm     if (alarmed || put_char(c) < 0) {
10799f65f104SPeter Wemm 	alarm(0);
10809f65f104SPeter Wemm 	alarmed = 0;
10819b1aec48SLars Fredriksen 
108201c855caSPeter Wemm 	if (verbose) {
10839b1aec48SLars Fredriksen 	    if (errno == EINTR || errno == EWOULDBLOCK)
10848491f234STim Kientzle 		chat_logf(" -- write timed out");
10859b1aec48SLars Fredriksen 	    else
10868491f234STim Kientzle 		chat_logf(" -- write failed: %m");
10879f65f104SPeter Wemm 	}
10889b1aec48SLars Fredriksen 	return (0);
10899b1aec48SLars Fredriksen     }
10909b1aec48SLars Fredriksen     return (1);
10919b1aec48SLars Fredriksen }
10929b1aec48SLars Fredriksen 
1093ee6b974cSMark Murray int
1094ee6b974cSMark Murray put_string(char *s)
10959b1aec48SLars Fredriksen {
10963d793cf1SPeter Wemm     quiet = 0;
10979b1aec48SLars Fredriksen     s = clean(s, 1);
10989b1aec48SLars Fredriksen 
1099ee6b974cSMark Murray     if (verbose)
11008491f234STim Kientzle         chat_logf("send (%v)", quiet ? "??????" : s);
11019b1aec48SLars Fredriksen 
11029b1aec48SLars Fredriksen     alarm(timeout); alarmed = 0;
11039b1aec48SLars Fredriksen 
110401c855caSPeter Wemm     while (*s) {
1105ee6b974cSMark Murray 	char c = *s++;
11069b1aec48SLars Fredriksen 
110701c855caSPeter Wemm 	if (c != '\\') {
11089b1aec48SLars Fredriksen 	    if (!write_char (c))
11099b1aec48SLars Fredriksen 		return 0;
11109b1aec48SLars Fredriksen 	    continue;
11119b1aec48SLars Fredriksen 	}
11129b1aec48SLars Fredriksen 
11139b1aec48SLars Fredriksen 	c = *s++;
111401c855caSPeter Wemm 	switch (c) {
11159b1aec48SLars Fredriksen 	case 'd':
11169b1aec48SLars Fredriksen 	    sleep(1);
11179b1aec48SLars Fredriksen 	    break;
11189b1aec48SLars Fredriksen 
11199b1aec48SLars Fredriksen 	case 'K':
11209b1aec48SLars Fredriksen 	    break_sequence();
11219b1aec48SLars Fredriksen 	    break;
11229b1aec48SLars Fredriksen 
11239b1aec48SLars Fredriksen 	case 'p':
11249f65f104SPeter Wemm 	    usleep(10000); 	/* 1/100th of a second (arg is microseconds) */
11259b1aec48SLars Fredriksen 	    break;
11269b1aec48SLars Fredriksen 
11279b1aec48SLars Fredriksen 	default:
11289b1aec48SLars Fredriksen 	    if (!write_char (c))
11299b1aec48SLars Fredriksen 		return 0;
11309b1aec48SLars Fredriksen 	    break;
11319b1aec48SLars Fredriksen 	}
11329b1aec48SLars Fredriksen     }
11339b1aec48SLars Fredriksen 
11349b1aec48SLars Fredriksen     alarm(0);
11359b1aec48SLars Fredriksen     alarmed = 0;
11369b1aec48SLars Fredriksen     return (1);
11379b1aec48SLars Fredriksen }
11389b1aec48SLars Fredriksen 
11399b1aec48SLars Fredriksen /*
11403d793cf1SPeter Wemm  *	Echo a character to stderr.
11413d793cf1SPeter Wemm  *	When called with -1, a '\n' character is generated when
11423d793cf1SPeter Wemm  *	the cursor is not at the beginning of a line.
11433d793cf1SPeter Wemm  */
1144ee6b974cSMark Murray void
1145ee6b974cSMark Murray echo_stderr(int n)
11463d793cf1SPeter Wemm {
11473d793cf1SPeter Wemm     static int need_lf;
11483d793cf1SPeter Wemm     char *s;
11493d793cf1SPeter Wemm 
115001c855caSPeter Wemm     switch (n) {
11513d793cf1SPeter Wemm     case '\r':		/* ignore '\r' */
11523d793cf1SPeter Wemm 	break;
11533d793cf1SPeter Wemm     case -1:
11543d793cf1SPeter Wemm 	if (need_lf == 0)
11553d793cf1SPeter Wemm 	    break;
115693b0017fSPhilippe Charnier 	/* FALLTHROUGH */
11573d793cf1SPeter Wemm     case '\n':
1158e1b4d8d0SSheldon Hearn 	write(STDERR_FILENO, "\n", 1);
11593d793cf1SPeter Wemm 	need_lf = 0;
11603d793cf1SPeter Wemm 	break;
11613d793cf1SPeter Wemm     default:
11623d793cf1SPeter Wemm 	s = character(n);
1163e1b4d8d0SSheldon Hearn 	write(STDERR_FILENO, s, strlen(s));
11643d793cf1SPeter Wemm 	need_lf = 1;
11653d793cf1SPeter Wemm 	break;
11663d793cf1SPeter Wemm     }
11673d793cf1SPeter Wemm }
11683d793cf1SPeter Wemm 
11693d793cf1SPeter Wemm /*
11709b1aec48SLars Fredriksen  *	'Wait for' this string to appear on this file descriptor.
11719b1aec48SLars Fredriksen  */
1172ee6b974cSMark Murray int
1173ee6b974cSMark Murray get_string(char *string)
11749b1aec48SLars Fredriksen {
11759b1aec48SLars Fredriksen     char temp[STR_LEN];
1176ee6b974cSMark Murray     int c, printed = 0;
1177ee6b974cSMark Murray     size_t len, minlen;
1178ee6b974cSMark Murray     char *s = temp, *end = s + STR_LEN;
117901c855caSPeter Wemm     char *logged = temp;
11809b1aec48SLars Fredriksen 
11819b1aec48SLars Fredriksen     fail_reason = (char *)0;
11824e83a8feSKris Kennaway 
11834e83a8feSKris Kennaway     if (strlen(string) > STR_LEN) {
11848491f234STim Kientzle 	chat_logf("expect string is too long");
11854e83a8feSKris Kennaway 	exit_code = 1;
11864e83a8feSKris Kennaway 	return 0;
11874e83a8feSKris Kennaway     }
11884e83a8feSKris Kennaway 
11899b1aec48SLars Fredriksen     string = clean(string, 0);
11909b1aec48SLars Fredriksen     len = strlen(string);
11919b1aec48SLars Fredriksen     minlen = (len > sizeof(fail_buffer)? len: sizeof(fail_buffer)) - 1;
11929b1aec48SLars Fredriksen 
11939b1aec48SLars Fredriksen     if (verbose)
11948491f234STim Kientzle 	chat_logf("expect (%v)", string);
11959b1aec48SLars Fredriksen 
119601c855caSPeter Wemm     if (len == 0) {
11979b1aec48SLars Fredriksen 	if (verbose)
11988491f234STim Kientzle 	    chat_logf("got it");
11999b1aec48SLars Fredriksen 	return (1);
12009b1aec48SLars Fredriksen     }
12019b1aec48SLars Fredriksen 
12029f65f104SPeter Wemm     alarm(timeout);
12039f65f104SPeter Wemm     alarmed = 0;
12049b1aec48SLars Fredriksen 
120501c855caSPeter Wemm     while ( ! alarmed && (c = get_char()) >= 0) {
12069f65f104SPeter Wemm 	int n, abort_len, report_len;
12079b1aec48SLars Fredriksen 
12083d793cf1SPeter Wemm 	if (echo)
12093d793cf1SPeter Wemm 	    echo_stderr(c);
121001c855caSPeter Wemm 	if (verbose && c == '\n') {
121101c855caSPeter Wemm 	    if (s == logged)
12128491f234STim Kientzle 		chat_logf("");	/* blank line */
12139b1aec48SLars Fredriksen 	    else
12148491f234STim Kientzle 		chat_logf("%0.*v", s - logged, logged);
121501c855caSPeter Wemm 	    logged = s + 1;
12163d793cf1SPeter Wemm 	}
12173d793cf1SPeter Wemm 
12189b1aec48SLars Fredriksen 	*s++ = c;
12199b1aec48SLars Fredriksen 
122001c855caSPeter Wemm 	if (verbose && s >= logged + 80) {
12218491f234STim Kientzle 	    chat_logf("%0.*v", s - logged, logged);
122201c855caSPeter Wemm 	    logged = s;
122301c855caSPeter Wemm 	}
122401c855caSPeter Wemm 
122501c855caSPeter Wemm 	if (Verbose) {
122601c855caSPeter Wemm 	   if (c == '\n')
122701c855caSPeter Wemm 	       fputc( '\n', stderr );
122801c855caSPeter Wemm 	   else if (c != '\r')
122901c855caSPeter Wemm 	       fprintf( stderr, "%s", character(c) );
123001c855caSPeter Wemm 	}
123101c855caSPeter Wemm 
123201c855caSPeter Wemm 	if (!report_gathering) {
123301c855caSPeter Wemm 	    for (n = 0; n < n_reports; ++n) {
12349f65f104SPeter Wemm 		if ((report_string[n] != (char*) NULL) &&
12359f65f104SPeter Wemm 		    s - temp >= (report_len = strlen(report_string[n])) &&
123601c855caSPeter Wemm 		    strncmp(s - report_len, report_string[n], report_len) == 0) {
12379f65f104SPeter Wemm 		    time_t time_now   = time ((time_t*) NULL);
12389f65f104SPeter Wemm 		    struct tm* tm_now = localtime (&time_now);
12399f65f104SPeter Wemm 
12409f65f104SPeter Wemm 		    strftime (report_buffer, 20, "%b %d %H:%M:%S ", tm_now);
12419f65f104SPeter Wemm 		    strcat (report_buffer, report_string[n]);
12429f65f104SPeter Wemm 
12439f65f104SPeter Wemm 		    report_string[n] = (char *) NULL;
12449f65f104SPeter Wemm 		    report_gathering = 1;
12459f65f104SPeter Wemm 		    break;
12469f65f104SPeter Wemm 		}
12479f65f104SPeter Wemm 	    }
12489f65f104SPeter Wemm 	}
124901c855caSPeter Wemm 	else {
125001c855caSPeter Wemm 	    if (!iscntrl (c)) {
12519f65f104SPeter Wemm 		int rep_len = strlen (report_buffer);
12529f65f104SPeter Wemm 		report_buffer[rep_len]     = c;
12539f65f104SPeter Wemm 		report_buffer[rep_len + 1] = '\0';
12549f65f104SPeter Wemm 	    }
125501c855caSPeter Wemm 	    else {
12569f65f104SPeter Wemm 		report_gathering = 0;
12579f65f104SPeter Wemm 		fprintf (report_fp, "chat:  %s\n", report_buffer);
12589f65f104SPeter Wemm 	    }
12599f65f104SPeter Wemm 	}
12609b1aec48SLars Fredriksen 
1261ee6b974cSMark Murray 	if ((size_t)(s - temp) >= len &&
12623d793cf1SPeter Wemm 	    c == string[len - 1] &&
126301c855caSPeter Wemm 	    strncmp(s - len, string, len) == 0) {
126401c855caSPeter Wemm 	    if (verbose) {
126501c855caSPeter Wemm 		if (s > logged)
12668491f234STim Kientzle 		    chat_logf("%0.*v", s - logged, logged);
12678491f234STim Kientzle 		chat_logf(" -- got it\n");
12683d793cf1SPeter Wemm 	    }
12693d793cf1SPeter Wemm 
12703d793cf1SPeter Wemm 	    alarm(0);
12713d793cf1SPeter Wemm 	    alarmed = 0;
12723d793cf1SPeter Wemm 	    return (1);
12733d793cf1SPeter Wemm 	}
12743d793cf1SPeter Wemm 
127501c855caSPeter Wemm 	for (n = 0; n < n_aborts; ++n) {
12763d793cf1SPeter Wemm 	    if (s - temp >= (abort_len = strlen(abort_string[n])) &&
127701c855caSPeter Wemm 		strncmp(s - abort_len, abort_string[n], abort_len) == 0) {
127801c855caSPeter Wemm 		if (verbose) {
127901c855caSPeter Wemm 		    if (s > logged)
12808491f234STim Kientzle 			chat_logf("%0.*v", s - logged, logged);
12818491f234STim Kientzle 		    chat_logf(" -- failed");
12823d793cf1SPeter Wemm 		}
12833d793cf1SPeter Wemm 
12843d793cf1SPeter Wemm 		alarm(0);
12853d793cf1SPeter Wemm 		alarmed = 0;
12863d793cf1SPeter Wemm 		exit_code = n + 4;
12873d793cf1SPeter Wemm 		strcpy(fail_reason = fail_buffer, abort_string[n]);
12883d793cf1SPeter Wemm 		return (0);
12893d793cf1SPeter Wemm 	    }
12903d793cf1SPeter Wemm 	}
12913d793cf1SPeter Wemm 
129201c855caSPeter Wemm 	if (s >= end) {
129301c855caSPeter Wemm 	    if (logged < s - minlen) {
12948491f234STim Kientzle 		chat_logf("%0.*v", s - logged, logged);
129501c855caSPeter Wemm 		logged = s;
129601c855caSPeter Wemm 	    }
129701c855caSPeter Wemm 	    s -= minlen;
129801c855caSPeter Wemm 	    memmove(temp, s, minlen);
129901c855caSPeter Wemm 	    logged = temp + (logged - s);
13009b1aec48SLars Fredriksen 	    s = temp + minlen;
13019b1aec48SLars Fredriksen 	}
13029b1aec48SLars Fredriksen 
13039b1aec48SLars Fredriksen 	if (alarmed && verbose)
13048491f234STim Kientzle 	    chat_logf("warning: alarm synchronization problem");
13059f65f104SPeter Wemm     }
13069b1aec48SLars Fredriksen 
13079b1aec48SLars Fredriksen     alarm(0);
13089b1aec48SLars Fredriksen 
130901c855caSPeter Wemm     if (verbose && printed) {
13109b1aec48SLars Fredriksen 	if (alarmed)
13118491f234STim Kientzle 	    chat_logf(" -- read timed out");
13129b1aec48SLars Fredriksen 	else
13138491f234STim Kientzle 	    chat_logf(" -- read failed: %m");
13149b1aec48SLars Fredriksen     }
13159b1aec48SLars Fredriksen 
13169f65f104SPeter Wemm     exit_code = 3;
13179b1aec48SLars Fredriksen     alarmed   = 0;
13189b1aec48SLars Fredriksen     return (0);
13199b1aec48SLars Fredriksen }
13209b1aec48SLars Fredriksen 
13213d793cf1SPeter Wemm void
1322ee6b974cSMark Murray pack_array(char **array, int end)
13233d793cf1SPeter Wemm {
13243d793cf1SPeter Wemm     int i, j;
13253d793cf1SPeter Wemm 
13263d793cf1SPeter Wemm     for (i = 0; i < end; i++) {
13273d793cf1SPeter Wemm 	if (array[i] == NULL) {
13283d793cf1SPeter Wemm 	    for (j = i+1; j < end; ++j)
13293d793cf1SPeter Wemm 		if (array[j] != NULL)
13303d793cf1SPeter Wemm 		    array[i++] = array[j];
13313d793cf1SPeter Wemm 	    for (; i < end; ++i)
13323d793cf1SPeter Wemm 		array[i] = NULL;
13333d793cf1SPeter Wemm 	    break;
13343d793cf1SPeter Wemm 	}
13353d793cf1SPeter Wemm     }
13363d793cf1SPeter Wemm }
133701c855caSPeter Wemm 
133801c855caSPeter Wemm /*
133901c855caSPeter Wemm  * vfmtmsg - format a message into a buffer.  Like vsprintf except we
134001c855caSPeter Wemm  * also specify the length of the output buffer, and we handle the
134101c855caSPeter Wemm  * %m (error message) format.
134201c855caSPeter Wemm  * Doesn't do floating-point formats.
134301c855caSPeter Wemm  * Returns the number of chars put into buf.
134401c855caSPeter Wemm  */
134501c855caSPeter Wemm #define OUTCHAR(c)	(buflen > 0? (--buflen, *buf++ = (c)): 0)
134601c855caSPeter Wemm 
134701c855caSPeter Wemm int
1348ee6b974cSMark Murray vfmtmsg(char *buf, int buflen, const char *fmt, va_list args)
134901c855caSPeter Wemm {
135001c855caSPeter Wemm     int c, i, n;
135101c855caSPeter Wemm     int width, prec, fillch;
135201c855caSPeter Wemm     int base, len, neg, quoted;
135301c855caSPeter Wemm     unsigned long val = 0;
135401c855caSPeter Wemm     char *str, *buf0;
135501c855caSPeter Wemm     const char *f;
135601c855caSPeter Wemm     unsigned char *p;
135701c855caSPeter Wemm     char num[32];
135801c855caSPeter Wemm     static char hexchars[] = "0123456789abcdef";
135901c855caSPeter Wemm 
136001c855caSPeter Wemm     buf0 = buf;
136101c855caSPeter Wemm     --buflen;
136201c855caSPeter Wemm     while (buflen > 0) {
136301c855caSPeter Wemm 	for (f = fmt; *f != '%' && *f != 0; ++f)
136401c855caSPeter Wemm 	    ;
136501c855caSPeter Wemm 	if (f > fmt) {
136601c855caSPeter Wemm 	    len = f - fmt;
136701c855caSPeter Wemm 	    if (len > buflen)
136801c855caSPeter Wemm 		len = buflen;
136901c855caSPeter Wemm 	    memcpy(buf, fmt, len);
137001c855caSPeter Wemm 	    buf += len;
137101c855caSPeter Wemm 	    buflen -= len;
137201c855caSPeter Wemm 	    fmt = f;
137301c855caSPeter Wemm 	}
137401c855caSPeter Wemm 	if (*fmt == 0)
137501c855caSPeter Wemm 	    break;
137601c855caSPeter Wemm 	c = *++fmt;
137701c855caSPeter Wemm 	width = prec = 0;
137801c855caSPeter Wemm 	fillch = ' ';
137901c855caSPeter Wemm 	if (c == '0') {
138001c855caSPeter Wemm 	    fillch = '0';
138101c855caSPeter Wemm 	    c = *++fmt;
138201c855caSPeter Wemm 	}
138301c855caSPeter Wemm 	if (c == '*') {
138401c855caSPeter Wemm 	    width = va_arg(args, int);
138501c855caSPeter Wemm 	    c = *++fmt;
138601c855caSPeter Wemm 	} else {
138701c855caSPeter Wemm 	    while (isdigit(c)) {
138801c855caSPeter Wemm 		width = width * 10 + c - '0';
138901c855caSPeter Wemm 		c = *++fmt;
139001c855caSPeter Wemm 	    }
139101c855caSPeter Wemm 	}
139201c855caSPeter Wemm 	if (c == '.') {
139301c855caSPeter Wemm 	    c = *++fmt;
139401c855caSPeter Wemm 	    if (c == '*') {
139501c855caSPeter Wemm 		prec = va_arg(args, int);
139601c855caSPeter Wemm 		c = *++fmt;
139701c855caSPeter Wemm 	    } else {
139801c855caSPeter Wemm 		while (isdigit(c)) {
139901c855caSPeter Wemm 		    prec = prec * 10 + c - '0';
140001c855caSPeter Wemm 		    c = *++fmt;
140101c855caSPeter Wemm 		}
140201c855caSPeter Wemm 	    }
140301c855caSPeter Wemm 	}
140459009de8SPedro F. Giffuni 	str = NULL;
140501c855caSPeter Wemm 	base = 0;
140601c855caSPeter Wemm 	neg = 0;
140701c855caSPeter Wemm 	++fmt;
140801c855caSPeter Wemm 	switch (c) {
140901c855caSPeter Wemm 	case 'd':
141001c855caSPeter Wemm 	    i = va_arg(args, int);
141101c855caSPeter Wemm 	    if (i < 0) {
141201c855caSPeter Wemm 		neg = 1;
141301c855caSPeter Wemm 		val = -i;
141401c855caSPeter Wemm 	    } else
141501c855caSPeter Wemm 		val = i;
141601c855caSPeter Wemm 	    base = 10;
141701c855caSPeter Wemm 	    break;
141801c855caSPeter Wemm 	case 'o':
141901c855caSPeter Wemm 	    val = va_arg(args, unsigned int);
142001c855caSPeter Wemm 	    base = 8;
142101c855caSPeter Wemm 	    break;
142201c855caSPeter Wemm 	case 'x':
142301c855caSPeter Wemm 	    val = va_arg(args, unsigned int);
142401c855caSPeter Wemm 	    base = 16;
142501c855caSPeter Wemm 	    break;
142601c855caSPeter Wemm 	case 'p':
142701c855caSPeter Wemm 	    val = (unsigned long) va_arg(args, void *);
142801c855caSPeter Wemm 	    base = 16;
142901c855caSPeter Wemm 	    neg = 2;
143001c855caSPeter Wemm 	    break;
143101c855caSPeter Wemm 	case 's':
143201c855caSPeter Wemm 	    str = va_arg(args, char *);
143301c855caSPeter Wemm 	    break;
143401c855caSPeter Wemm 	case 'c':
143501c855caSPeter Wemm 	    num[0] = va_arg(args, int);
143601c855caSPeter Wemm 	    num[1] = 0;
143701c855caSPeter Wemm 	    str = num;
143801c855caSPeter Wemm 	    break;
143901c855caSPeter Wemm 	case 'm':
144001c855caSPeter Wemm 	    str = strerror(errno);
144101c855caSPeter Wemm 	    break;
144201c855caSPeter Wemm 	case 'v':		/* "visible" string */
144301c855caSPeter Wemm 	case 'q':		/* quoted string */
144401c855caSPeter Wemm 	    quoted = c == 'q';
144501c855caSPeter Wemm 	    p = va_arg(args, unsigned char *);
144601c855caSPeter Wemm 	    if (fillch == '0' && prec > 0) {
144701c855caSPeter Wemm 		n = prec;
144801c855caSPeter Wemm 	    } else {
144901c855caSPeter Wemm 		n = strlen((char *)p);
145001c855caSPeter Wemm 		if (prec > 0 && prec < n)
145101c855caSPeter Wemm 		    n = prec;
145201c855caSPeter Wemm 	    }
145301c855caSPeter Wemm 	    while (n > 0 && buflen > 0) {
145401c855caSPeter Wemm 		c = *p++;
145501c855caSPeter Wemm 		--n;
145601c855caSPeter Wemm 		if (!quoted && c >= 0x80) {
145701c855caSPeter Wemm 		    OUTCHAR('M');
145801c855caSPeter Wemm 		    OUTCHAR('-');
145901c855caSPeter Wemm 		    c -= 0x80;
146001c855caSPeter Wemm 		}
146101c855caSPeter Wemm 		if (quoted && (c == '"' || c == '\\'))
146201c855caSPeter Wemm 		    OUTCHAR('\\');
146301c855caSPeter Wemm 		if (c < 0x20 || (0x7f <= c && c < 0xa0)) {
146401c855caSPeter Wemm 		    if (quoted) {
146501c855caSPeter Wemm 			OUTCHAR('\\');
146601c855caSPeter Wemm 			switch (c) {
146701c855caSPeter Wemm 			case '\t':	OUTCHAR('t');	break;
146801c855caSPeter Wemm 			case '\n':	OUTCHAR('n');	break;
146901c855caSPeter Wemm 			case '\b':	OUTCHAR('b');	break;
147001c855caSPeter Wemm 			case '\f':	OUTCHAR('f');	break;
147101c855caSPeter Wemm 			default:
147201c855caSPeter Wemm 			    OUTCHAR('x');
147301c855caSPeter Wemm 			    OUTCHAR(hexchars[c >> 4]);
147401c855caSPeter Wemm 			    OUTCHAR(hexchars[c & 0xf]);
147501c855caSPeter Wemm 			}
147601c855caSPeter Wemm 		    } else {
147701c855caSPeter Wemm 			if (c == '\t')
147801c855caSPeter Wemm 			    OUTCHAR(c);
147901c855caSPeter Wemm 			else {
148001c855caSPeter Wemm 			    OUTCHAR('^');
148101c855caSPeter Wemm 			    OUTCHAR(c ^ 0x40);
148201c855caSPeter Wemm 			}
148301c855caSPeter Wemm 		    }
148401c855caSPeter Wemm 		} else
148501c855caSPeter Wemm 		    OUTCHAR(c);
148601c855caSPeter Wemm 	    }
148701c855caSPeter Wemm 	    continue;
148801c855caSPeter Wemm 	default:
148901c855caSPeter Wemm 	    *buf++ = '%';
149001c855caSPeter Wemm 	    if (c != '%')
149101c855caSPeter Wemm 		--fmt;		/* so %z outputs %z etc. */
149201c855caSPeter Wemm 	    --buflen;
149301c855caSPeter Wemm 	    continue;
149401c855caSPeter Wemm 	}
149501c855caSPeter Wemm 	if (base != 0) {
149601c855caSPeter Wemm 	    str = num + sizeof(num);
149701c855caSPeter Wemm 	    *--str = 0;
149801c855caSPeter Wemm 	    while (str > num + neg) {
149901c855caSPeter Wemm 		*--str = hexchars[val % base];
150001c855caSPeter Wemm 		val = val / base;
150101c855caSPeter Wemm 		if (--prec <= 0 && val == 0)
150201c855caSPeter Wemm 		    break;
150301c855caSPeter Wemm 	    }
150401c855caSPeter Wemm 	    switch (neg) {
150501c855caSPeter Wemm 	    case 1:
150601c855caSPeter Wemm 		*--str = '-';
150701c855caSPeter Wemm 		break;
150801c855caSPeter Wemm 	    case 2:
150901c855caSPeter Wemm 		*--str = 'x';
151001c855caSPeter Wemm 		*--str = '0';
151101c855caSPeter Wemm 		break;
151201c855caSPeter Wemm 	    }
151301c855caSPeter Wemm 	    len = num + sizeof(num) - 1 - str;
151401c855caSPeter Wemm 	} else {
151501c855caSPeter Wemm 	    len = strlen(str);
151601c855caSPeter Wemm 	    if (prec > 0 && len > prec)
151701c855caSPeter Wemm 		len = prec;
151801c855caSPeter Wemm 	}
151901c855caSPeter Wemm 	if (width > 0) {
152001c855caSPeter Wemm 	    if (width > buflen)
152101c855caSPeter Wemm 		width = buflen;
152201c855caSPeter Wemm 	    if ((n = width - len) > 0) {
152301c855caSPeter Wemm 		buflen -= n;
152401c855caSPeter Wemm 		for (; n > 0; --n)
152501c855caSPeter Wemm 		    *buf++ = fillch;
152601c855caSPeter Wemm 	    }
152701c855caSPeter Wemm 	}
152801c855caSPeter Wemm 	if (len > buflen)
152901c855caSPeter Wemm 	    len = buflen;
153001c855caSPeter Wemm 	memcpy(buf, str, len);
153101c855caSPeter Wemm 	buf += len;
153201c855caSPeter Wemm 	buflen -= len;
153301c855caSPeter Wemm     }
153401c855caSPeter Wemm     *buf = 0;
153501c855caSPeter Wemm     return buf - buf0;
153601c855caSPeter Wemm }
1537