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