busybox/miscutils/chat.c

/* vi: set sw=4 ts=4: */
/*
 * bare bones chat utility
 * inspired by ppp's chat
 *
 * Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
 *
 * Licensed under GPLv2, see file LICENSE in this tarball for details.
 */
#include "libbb.h"

/*
#define ENABLE_FEATURE_CHAT_NOFAIL              1 // +126 bytes
#define ENABLE_FEATURE_CHAT_TTY_HIFI            0 // + 70 bytes
#define ENABLE_FEATURE_CHAT_IMPLICIT_CR         1 // + 44 bytes
#define ENABLE_FEATURE_CHAT_SEND_ESCAPES        0 // +103 bytes
#define ENABLE_FEATURE_CHAT_VAR_ABORT_LEN       0 // + 70 bytes
#define ENABLE_FEATURE_CHAT_CLR_ABORT           0 // +113 bytes
#define ENABLE_FEATURE_CHAT_SWALLOW_OPTS        0 // + 23 bytes
*/

// default timeout: 45 sec
#define	DEFAULT_CHAT_TIMEOUT 45*1000
// max length of "abort string",
// i.e. device reply which causes termination
#define MAX_ABORT_LEN 50

// possible exit codes
enum {
	ERR_OK = 0,     // all's well
	ERR_MEM,        // read too much while expecting
	ERR_IO,         // signalled or I/O error
	ERR_TIMEOUT,    // timed out while expecting
	ERR_ABORT,      // first abort condition was met
//	ERR_ABORT2,     // second abort condition was met
//	...
};

// exit code
// N.B> 10 bytes for volatile. Why all these signals?!
static /*volatile*/ smallint exitcode;

// trap for critical signals
static void signal_handler(UNUSED_PARAM int signo)
{
	// report I/O error condition
	exitcode = ERR_IO;
}

#if !ENABLE_FEATURE_CHAT_IMPLICIT_CR
#define unescape(s, nocr) unescape(s)
#endif
static size_t unescape(char *s, int *nocr)
{
	char *start = s;
	char *p = s;

	while (*s) {
		char c = *s;
		// do we need special processing?
		// standard escapes + \s for space and \N for \0
		// \c inhibits terminating \r for commands and is noop for expects
		if ('\\' == c) {
			c = *++s;
			if (c) {
#if ENABLE_FEATURE_CHAT_IMPLICIT_CR
				if ('c' == c) {
					*nocr = 1;
					goto next;
				}
#endif
				if ('N' == c) {
					c = '\0';
				} else if ('s' == c) {
					c = ' ';
#if ENABLE_FEATURE_CHAT_NOFAIL
				// unescape leading dash only
				// TODO: and only for expect, not command string
				} else if ('-' == c && (start + 1 == s)) {
					//c = '-';
#endif
				} else {
					c = bb_process_escape_sequence((const char **)&s);
					s--;
				}
			}
		// ^A becomes \001, ^B -- \002 and so on...
		} else if ('^' == c) {
			c = *++s-'@';
		}
		// put unescaped char
		*p++ = c;
#if ENABLE_FEATURE_CHAT_IMPLICIT_CR
 next:
#endif
		// next char
		s++;
	}
	*p = '\0';

	return p - start;
}


int chat_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int chat_main(int argc UNUSED_PARAM, char **argv)
{
// should we dump device output? to what fd? by default no.
// this can be controlled later via ECHO {ON|OFF} chat directive
//	int echo_fd;
	bool echo = 0;
	// collection of device replies which cause unconditional termination
	llist_t *aborts = NULL;
	// inactivity period
	int timeout = DEFAULT_CHAT_TIMEOUT;
	// maximum length of abort string
#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
	size_t max_abort_len = 0;
#else
#define max_abort_len MAX_ABORT_LEN
#endif
#if ENABLE_FEATURE_CHAT_TTY_HIFI
	struct termios tio0, tio;
#endif
	// directive names
	enum {
		DIR_HANGUP = 0,
		DIR_ABORT,
#if ENABLE_FEATURE_CHAT_CLR_ABORT
		DIR_CLR_ABORT,
#endif
		DIR_TIMEOUT,
		DIR_ECHO,
		DIR_SAY,
	};

	// make x* functions fail with correct exitcode
	xfunc_error_retval = ERR_IO;

	// trap vanilla signals to prevent process from being killed suddenly
	bb_signals(0
		+ (1 << SIGHUP)
		+ (1 << SIGINT)
		+ (1 << SIGTERM)
		+ (1 << SIGPIPE)
		, signal_handler);

#if ENABLE_FEATURE_CHAT_TTY_HIFI
	tcgetattr(STDIN_FILENO, &tio);
	tio0 = tio;
	cfmakeraw(&tio);
	tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio);
#endif

#if ENABLE_FEATURE_CHAT_SWALLOW_OPTS
	getopt32(argv, "vVsSE");
	argv += optind;
#else
	argv++; // goto first arg
#endif
	// handle chat expect-send pairs
	while (*argv) {
		// directive given? process it
		int key = index_in_strings(
			"HANGUP\0" "ABORT\0"
#if ENABLE_FEATURE_CHAT_CLR_ABORT
			"CLR_ABORT\0"
#endif
			"TIMEOUT\0" "ECHO\0" "SAY\0"
			, *argv
		);
		if (key >= 0) {
			// cache directive value
			char *arg = *++argv;
			// ON -> 1, anything else -> 0
			bool onoff = !strcmp("ON", arg);
			// process directive
			if (DIR_HANGUP == key) {
				// turn SIGHUP on/off
				signal(SIGHUP, onoff ? signal_handler : SIG_IGN);
			} else if (DIR_ABORT == key) {
				// append the string to abort conditions
#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
				size_t len = strlen(arg);
				if (len > max_abort_len)
					max_abort_len = len;
#endif
				llist_add_to_end(&aborts, arg);
#if ENABLE_FEATURE_CHAT_CLR_ABORT
			} else if (DIR_CLR_ABORT == key) {
				// remove the string from abort conditions
				// N.B. gotta refresh maximum length too...
#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
				max_abort_len = 0;
#endif
				for (llist_t *l = aborts; l; l = l->link) {
#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
					size_t len = strlen(l->data);
#endif
					if (!strcmp(arg, l->data)) {
						llist_unlink(&aborts, l);
						continue;
					}
#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
					if (len > max_abort_len)
						max_abort_len = len;
#endif
				}
#endif
			} else if (DIR_TIMEOUT == key) {
				// set new timeout
				// -1 means OFF
				timeout = atoi(arg) * 1000;
				// 0 means default
				// >0 means value in msecs
				if (!timeout)
					timeout = DEFAULT_CHAT_TIMEOUT;
			} else if (DIR_ECHO == key) {
				// turn echo on/off
				// N.B. echo means dumping output
				// from stdin (device) to stderr
				echo = onoff;
//TODO?				echo_fd = onoff * STDERR_FILENO;
//TODO?				echo_fd = xopen(arg, O_WRONLY|O_CREAT|O_TRUNC);
			} else if (DIR_SAY == key) {
				// just print argument verbatim
				fprintf(stderr, arg);
			}
			// next, please!
			argv++;
		// ordinary expect-send pair!
		} else {
			//-----------------------
			// do expect
			//-----------------------
			int expect_len;
			size_t buf_len = 0;
			size_t max_len = max_abort_len;

			struct pollfd pfd;
#if ENABLE_FEATURE_CHAT_NOFAIL
			int nofail = 0;
#endif
			char *expect = *argv++;

			// sanity check: shall we really expect something?
			if (!expect)
				goto expect_done;

#if ENABLE_FEATURE_CHAT_NOFAIL
			// if expect starts with -
			if ('-' == *expect) {
				// swallow -
				expect++;
				// and enter nofail mode
				nofail++;
			}
#endif

#ifdef ___TEST___BUF___ // test behaviour with a small buffer
#	undef COMMON_BUFSIZE
#	define COMMON_BUFSIZE 6
#endif
			// expand escape sequences in expect
			expect_len = unescape(expect, &expect_len /*dummy*/);
			if (expect_len > max_len)
				max_len = expect_len;
			// sanity check:
			// we should expect more than nothing but not more than input buffer
			// TODO: later we'll get rid of fixed-size buffer
			if (!expect_len)
				goto expect_done;
			if (max_len >= COMMON_BUFSIZE) {
				exitcode = ERR_MEM;
				goto expect_done;
			}

			// get reply
			pfd.fd = STDIN_FILENO;
			pfd.events = POLLIN;
			while (!exitcode
			    && poll(&pfd, 1, timeout) > 0
			    && (pfd.revents & POLLIN)
			) {
#define buf bb_common_bufsiz1
				llist_t *l;
				ssize_t delta;

				// read next char from device
				if (safe_read(STDIN_FILENO, buf+buf_len, 1) > 0) {
					// dump device output if ECHO ON or RECORD fname
//TODO?					if (echo_fd > 0) {
//TODO?						full_write(echo_fd, buf+buf_len, 1);
//TODO?					}
					if (echo > 0)
						full_write(STDERR_FILENO, buf+buf_len, 1);
					buf_len++;
					// move input frame if we've reached higher bound
					if (buf_len > COMMON_BUFSIZE) {
						memmove(buf, buf+buf_len-max_len, max_len);
						buf_len = max_len;
					}
				}
				// N.B. rule of thumb: values being looked for can
				// be found only at the end of input buffer
				// this allows to get rid of strstr() and memmem()

				// TODO: make expect and abort strings processed uniformly
				// abort condition is met? -> bail out
				for (l = aborts, exitcode = ERR_ABORT; l; l = l->link, ++exitcode) {
					size_t len = strlen(l->data);
					delta = buf_len-len;
					if (delta >= 0 && !memcmp(buf+delta, l->data, len))
						goto expect_done;
				}
				exitcode = ERR_OK;

				// expected reply received? -> goto next command
				delta = buf_len - expect_len;
				if (delta >= 0 && !memcmp(buf+delta, expect, expect_len))
					goto expect_done;
#undef buf
			}

			// device timed out or unexpected reply received
			exitcode = ERR_TIMEOUT;
 expect_done:
#if ENABLE_FEATURE_CHAT_NOFAIL
			// on success and when in nofail mode
			// we should skip following subsend-subexpect pairs
			if (nofail) {
				if (!exitcode) {
					// find last send before non-dashed expect
					while (*argv && argv[1] && '-' == argv[1][0])
						argv += 2;
					// skip the pair
					// N.B. do we really need this?!
					if (!*argv++ || !*argv++)
						break;
				}
				// nofail mode also clears all but IO errors (or signals)
				if (ERR_IO != exitcode)
					exitcode = ERR_OK;
			}
#endif
			// bail out unless we expected successfully
			if (exitcode)
				break;

			//-----------------------
			// do send
			//-----------------------
			if (*argv) {
#if ENABLE_FEATURE_CHAT_IMPLICIT_CR
				int nocr = 0; // inhibit terminating command with \r
#endif
				char *loaded = NULL; // loaded command
				size_t len;
				char *buf = *argv++;

				// if command starts with @
				// load "real" command from file named after @
				if ('@' == *buf) {
					// skip the @ and any following white-space
					trim(++buf);
					buf = loaded = xmalloc_xopen_read_close(buf, NULL);
				}

				// expand escape sequences in command
				len = unescape(buf, &nocr);

				// send command
#if ENABLE_FEATURE_CHAT_SEND_ESCAPES
				pfd.fd = STDOUT_FILENO;
				pfd.events = POLLOUT;
				while (len && !exitcode
				    && poll(&pfd, 1, timeout) > 0
				    && (pfd.revents & POLLOUT)
				) {
					// ugly! ugly! ugly!
					// gotta send char by char to achieve this!
					// Brrr...
					// "\\d" means 1 sec delay, "\\p" means 0.01 sec delay
					// "\\K" means send BREAK
					char c = *buf;
					if ('\\' == c) {
						c = *++buf;
						if ('d' == c) {
							sleep(1);
							len--;
							continue;
						} else if ('p' == c) {
							usleep(10000);
							len--;
							continue;
						} else if ('K' == c) {
							tcsendbreak(STDOUT_FILENO, 0);
							len--;
							continue;
						} else {
							buf--;
						}
					}
					if (safe_write(STDOUT_FILENO, buf, 1) > 0) {
						len--;
						buf++;
					} else
						break;
				}
#else
//				if (len) {
					alarm(timeout);
					len -= full_write(STDOUT_FILENO, buf, len);
					alarm(0);
//				}
#endif

				// report I/O error if there still exists at least one non-sent char
				if (len)
					exitcode = ERR_IO;

				// free loaded command (if any)
				if (loaded)
					free(loaded);
#if ENABLE_FEATURE_CHAT_IMPLICIT_CR
				// or terminate command with \r (if not inhibited)
				else if (!nocr)
					xwrite(STDOUT_FILENO, "\r", 1);
#endif

				// bail out unless we sent command successfully
				if (exitcode)
					break;

			}
		}
	}

#if ENABLE_FEATURE_CHAT_TTY_HIFI
	tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio0);
#endif

	return exitcode;
}
1	niro	816	/* vi: set sw=4 ts=4: */
2			/*
3			* bare bones chat utility
4			* inspired by ppp's chat
5			*
6			* Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
7			*
8			* Licensed under GPLv2, see file LICENSE in this tarball for details.
9			*/
10			#include "libbb.h"
11
12			/*
13			#define ENABLE_FEATURE_CHAT_NOFAIL 1 // +126 bytes
14			#define ENABLE_FEATURE_CHAT_TTY_HIFI 0 // + 70 bytes
15			#define ENABLE_FEATURE_CHAT_IMPLICIT_CR 1 // + 44 bytes
16			#define ENABLE_FEATURE_CHAT_SEND_ESCAPES 0 // +103 bytes
17			#define ENABLE_FEATURE_CHAT_VAR_ABORT_LEN 0 // + 70 bytes
18			#define ENABLE_FEATURE_CHAT_CLR_ABORT 0 // +113 bytes
19			#define ENABLE_FEATURE_CHAT_SWALLOW_OPTS 0 // + 23 bytes
20			*/
21
22			// default timeout: 45 sec
23			#define DEFAULT_CHAT_TIMEOUT 45*1000
24			// max length of "abort string",
25			// i.e. device reply which causes termination
26			#define MAX_ABORT_LEN 50
27
28			// possible exit codes
29			enum {
30			ERR_OK = 0, // all's well
31			ERR_MEM, // read too much while expecting
32			ERR_IO, // signalled or I/O error
33			ERR_TIMEOUT, // timed out while expecting
34			ERR_ABORT, // first abort condition was met
35			// ERR_ABORT2, // second abort condition was met
36			// ...
37			};
38
39			// exit code
40			// N.B> 10 bytes for volatile. Why all these signals?!
41			static /volatile/ smallint exitcode;
42
43			// trap for critical signals
44			static void signal_handler(UNUSED_PARAM int signo)
45			{
46			// report I/O error condition
47			exitcode = ERR_IO;
48			}
49
50			#if !ENABLE_FEATURE_CHAT_IMPLICIT_CR
51			#define unescape(s, nocr) unescape(s)
52			#endif
53			static size_t unescape(char s, int nocr)
54			{
55			char *start = s;
56			char *p = s;
57
58			while (*s) {
59			char c = *s;
60			// do we need special processing?
61			// standard escapes + \s for space and \N for \0
62			// \c inhibits terminating \r for commands and is noop for expects
63			if ('\\' == c) {
64			c = *++s;
65			if (c) {
66			#if ENABLE_FEATURE_CHAT_IMPLICIT_CR
67			if ('c' == c) {
68			*nocr = 1;
69			goto next;
70			}
71			#endif
72			if ('N' == c) {
73			c = '\0';
74			} else if ('s' == c) {
75			c = ' ';
76			#if ENABLE_FEATURE_CHAT_NOFAIL
77			// unescape leading dash only
78			// TODO: and only for expect, not command string
79			} else if ('-' == c && (start + 1 == s)) {
80			//c = '-';
81			#endif
82			} else {
83			c = bb_process_escape_sequence((const char **)&s);
84			s--;
85			}
86			}
87			// ^A becomes \001, ^B -- \002 and so on...
88			} else if ('^' == c) {
89			c = *++s-'@';
90			}
91			// put unescaped char
92			*p++ = c;
93			#if ENABLE_FEATURE_CHAT_IMPLICIT_CR
94			next:
95			#endif
96			// next char
97			s++;
98			}
99			*p = '\0';
100
101			return p - start;
102			}
103
104
105			int chat_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
106			int chat_main(int argc UNUSED_PARAM, char **argv)
107			{
108			// should we dump device output? to what fd? by default no.
109			// this can be controlled later via ECHO {ON\|OFF} chat directive
110			// int echo_fd;
111			bool echo = 0;
112			// collection of device replies which cause unconditional termination
113			llist_t *aborts = NULL;
114			// inactivity period
115			int timeout = DEFAULT_CHAT_TIMEOUT;
116			// maximum length of abort string
117			#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
118			size_t max_abort_len = 0;
119			#else
120			#define max_abort_len MAX_ABORT_LEN
121			#endif
122			#if ENABLE_FEATURE_CHAT_TTY_HIFI
123			struct termios tio0, tio;
124			#endif
125			// directive names
126			enum {
127			DIR_HANGUP = 0,
128			DIR_ABORT,
129			#if ENABLE_FEATURE_CHAT_CLR_ABORT
130			DIR_CLR_ABORT,
131			#endif
132			DIR_TIMEOUT,
133			DIR_ECHO,
134			DIR_SAY,
135			};
136
137			// make x* functions fail with correct exitcode
138			xfunc_error_retval = ERR_IO;
139
140			// trap vanilla signals to prevent process from being killed suddenly
141			bb_signals(0
142			+ (1 << SIGHUP)
143			+ (1 << SIGINT)
144			+ (1 << SIGTERM)
145			+ (1 << SIGPIPE)
146			, signal_handler);
147
148			#if ENABLE_FEATURE_CHAT_TTY_HIFI
149			tcgetattr(STDIN_FILENO, &tio);
150			tio0 = tio;
151			cfmakeraw(&tio);
152			tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio);
153			#endif
154
155			#if ENABLE_FEATURE_CHAT_SWALLOW_OPTS
156			getopt32(argv, "vVsSE");
157			argv += optind;
158			#else
159			argv++; // goto first arg
160			#endif
161			// handle chat expect-send pairs
162			while (*argv) {
163			// directive given? process it
164			int key = index_in_strings(
165			"HANGUP\0" "ABORT\0"
166			#if ENABLE_FEATURE_CHAT_CLR_ABORT
167			"CLR_ABORT\0"
168			#endif
169			"TIMEOUT\0" "ECHO\0" "SAY\0"
170			, *argv
171			);
172			if (key >= 0) {
173			// cache directive value
174			char arg = ++argv;
175			// ON -> 1, anything else -> 0
176			bool onoff = !strcmp("ON", arg);
177			// process directive
178			if (DIR_HANGUP == key) {
179			// turn SIGHUP on/off
180			signal(SIGHUP, onoff ? signal_handler : SIG_IGN);
181			} else if (DIR_ABORT == key) {
182			// append the string to abort conditions
183			#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
184			size_t len = strlen(arg);
185			if (len > max_abort_len)
186			max_abort_len = len;
187			#endif
188			llist_add_to_end(&aborts, arg);
189			#if ENABLE_FEATURE_CHAT_CLR_ABORT
190			} else if (DIR_CLR_ABORT == key) {
191			// remove the string from abort conditions
192			// N.B. gotta refresh maximum length too...
193			#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
194			max_abort_len = 0;
195			#endif
196			for (llist_t *l = aborts; l; l = l->link) {
197			#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
198			size_t len = strlen(l->data);
199			#endif
200			if (!strcmp(arg, l->data)) {
201			llist_unlink(&aborts, l);
202			continue;
203			}
204			#if ENABLE_FEATURE_CHAT_VAR_ABORT_LEN
205			if (len > max_abort_len)
206			max_abort_len = len;
207			#endif
208			}
209			#endif
210			} else if (DIR_TIMEOUT == key) {
211			// set new timeout
212			// -1 means OFF
213			timeout = atoi(arg) * 1000;
214			// 0 means default
215			// >0 means value in msecs
216			if (!timeout)
217			timeout = DEFAULT_CHAT_TIMEOUT;
218			} else if (DIR_ECHO == key) {
219			// turn echo on/off
220			// N.B. echo means dumping output
221			// from stdin (device) to stderr
222			echo = onoff;
223			//TODO? echo_fd = onoff * STDERR_FILENO;
224			//TODO? echo_fd = xopen(arg, O_WRONLY\|O_CREAT\|O_TRUNC);
225			} else if (DIR_SAY == key) {
226			// just print argument verbatim
227			fprintf(stderr, arg);
228			}
229			// next, please!
230			argv++;
231			// ordinary expect-send pair!
232			} else {
233			//-----------------------
234			// do expect
235			//-----------------------
236			int expect_len;
237			size_t buf_len = 0;
238			size_t max_len = max_abort_len;
239
240			struct pollfd pfd;
241			#if ENABLE_FEATURE_CHAT_NOFAIL
242			int nofail = 0;
243			#endif
244			char expect = argv++;
245
246			// sanity check: shall we really expect something?
247			if (!expect)
248			goto expect_done;
249
250			#if ENABLE_FEATURE_CHAT_NOFAIL
251			// if expect starts with -
252			if ('-' == *expect) {
253			// swallow -
254			expect++;
255			// and enter nofail mode
256			nofail++;
257			}
258			#endif
259
260			#ifdef ___TEST___BUF___ // test behaviour with a small buffer
261			# undef COMMON_BUFSIZE
262			# define COMMON_BUFSIZE 6
263			#endif
264			// expand escape sequences in expect
265			expect_len = unescape(expect, &expect_len /dummy/);
266			if (expect_len > max_len)
267			max_len = expect_len;
268			// sanity check:
269			// we should expect more than nothing but not more than input buffer
270			// TODO: later we'll get rid of fixed-size buffer
271			if (!expect_len)
272			goto expect_done;
273			if (max_len >= COMMON_BUFSIZE) {
274			exitcode = ERR_MEM;
275			goto expect_done;
276			}
277
278			// get reply
279			pfd.fd = STDIN_FILENO;
280			pfd.events = POLLIN;
281			while (!exitcode
282			&& poll(&pfd, 1, timeout) > 0
283			&& (pfd.revents & POLLIN)
284			) {
285			#define buf bb_common_bufsiz1
286			llist_t *l;
287			ssize_t delta;
288
289			// read next char from device
290			if (safe_read(STDIN_FILENO, buf+buf_len, 1) > 0) {
291			// dump device output if ECHO ON or RECORD fname
292			//TODO? if (echo_fd > 0) {
293			//TODO? full_write(echo_fd, buf+buf_len, 1);
294			//TODO? }
295			if (echo > 0)
296			full_write(STDERR_FILENO, buf+buf_len, 1);
297			buf_len++;
298			// move input frame if we've reached higher bound
299			if (buf_len > COMMON_BUFSIZE) {
300			memmove(buf, buf+buf_len-max_len, max_len);
301			buf_len = max_len;
302			}
303			}
304			// N.B. rule of thumb: values being looked for can
305			// be found only at the end of input buffer
306			// this allows to get rid of strstr() and memmem()
307
308			// TODO: make expect and abort strings processed uniformly
309			// abort condition is met? -> bail out
310			for (l = aborts, exitcode = ERR_ABORT; l; l = l->link, ++exitcode) {
311			size_t len = strlen(l->data);
312			delta = buf_len-len;
313			if (delta >= 0 && !memcmp(buf+delta, l->data, len))
314			goto expect_done;
315			}
316			exitcode = ERR_OK;
317
318			// expected reply received? -> goto next command
319			delta = buf_len - expect_len;
320			if (delta >= 0 && !memcmp(buf+delta, expect, expect_len))
321			goto expect_done;
322			#undef buf
323			}
324
325			// device timed out or unexpected reply received
326			exitcode = ERR_TIMEOUT;
327			expect_done:
328			#if ENABLE_FEATURE_CHAT_NOFAIL
329			// on success and when in nofail mode
330			// we should skip following subsend-subexpect pairs
331			if (nofail) {
332			if (!exitcode) {
333			// find last send before non-dashed expect
334			while (*argv && argv[1] && '-' == argv[1][0])
335			argv += 2;
336			// skip the pair
337			// N.B. do we really need this?!
338			if (!argv++ \|\| !argv++)
339			break;
340			}
341			// nofail mode also clears all but IO errors (or signals)
342			if (ERR_IO != exitcode)
343			exitcode = ERR_OK;
344			}
345			#endif
346			// bail out unless we expected successfully
347			if (exitcode)
348			break;
349
350			//-----------------------
351			// do send
352			//-----------------------
353			if (*argv) {
354			#if ENABLE_FEATURE_CHAT_IMPLICIT_CR
355			int nocr = 0; // inhibit terminating command with \r
356			#endif
357			char *loaded = NULL; // loaded command
358			size_t len;
359			char buf = argv++;
360
361			// if command starts with @
362			// load "real" command from file named after @
363			if ('@' == *buf) {
364			// skip the @ and any following white-space
365			trim(++buf);
366			buf = loaded = xmalloc_xopen_read_close(buf, NULL);
367			}
368
369			// expand escape sequences in command
370			len = unescape(buf, &nocr);
371
372			// send command
373			#if ENABLE_FEATURE_CHAT_SEND_ESCAPES
374			pfd.fd = STDOUT_FILENO;
375			pfd.events = POLLOUT;
376			while (len && !exitcode
377			&& poll(&pfd, 1, timeout) > 0
378			&& (pfd.revents & POLLOUT)
379			) {
380			// ugly! ugly! ugly!
381			// gotta send char by char to achieve this!
382			// Brrr...
383			// "\\d" means 1 sec delay, "\\p" means 0.01 sec delay
384			// "\\K" means send BREAK
385			char c = *buf;
386			if ('\\' == c) {
387			c = *++buf;
388			if ('d' == c) {
389			sleep(1);
390			len--;
391			continue;
392			} else if ('p' == c) {
393			usleep(10000);
394			len--;
395			continue;
396			} else if ('K' == c) {
397			tcsendbreak(STDOUT_FILENO, 0);
398			len--;
399			continue;
400			} else {
401			buf--;
402			}
403			}
404			if (safe_write(STDOUT_FILENO, buf, 1) > 0) {
405			len--;
406			buf++;
407			} else
408			break;
409			}
410			#else
411			// if (len) {
412			alarm(timeout);
413			len -= full_write(STDOUT_FILENO, buf, len);
414			alarm(0);
415			// }
416			#endif
417
418			// report I/O error if there still exists at least one non-sent char
419			if (len)
420			exitcode = ERR_IO;
421
422			// free loaded command (if any)
423			if (loaded)
424			free(loaded);
425			#if ENABLE_FEATURE_CHAT_IMPLICIT_CR
426			// or terminate command with \r (if not inhibited)
427			else if (!nocr)
428			xwrite(STDOUT_FILENO, "\r", 1);
429			#endif
430
431			// bail out unless we sent command successfully
432			if (exitcode)
433			break;
434
435			}
436			}
437			}
438
439			#if ENABLE_FEATURE_CHAT_TTY_HIFI
440			tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio0);
441			#endif
442
443			return exitcode;
444			}