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"

// 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
#define exitcode bb_got_signal

// 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)
{
	int record_fd = -1;
	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,
		DIR_RECORD,
	};

	// 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" "RECORD\0"
			, *argv
		);
		if (key >= 0) {
			// cache directive value
			char *arg = *++argv;
			// OFF -> 0, anything else -> 1
			bool onoff = (0 != strcmp("OFF", 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 device input/output to stderr
				echo = onoff;
			} else if (DIR_RECORD == key) {
				// turn record on/off
				// N.B. record means dumping device input to a file
					// close previous record_fd
				if (record_fd > 0)
					close(record_fd);
				// N.B. do we have to die here on open error?
				record_fd = (onoff) ? xopen(arg, O_WRONLY|O_CREAT|O_TRUNC) : -1;
			} else if (DIR_SAY == key) {
				// just print argument verbatim
				// TODO: should we use full_write() to avoid unistd/stdio conflict?
				bb_error_msg("%s", 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 input if RECORD fname
					if (record_fd > 0) {
						full_write(record_fd, buf+buf_len, 1);
					}
					// dump device input if ECHO ON
					if (echo > 0) {
//						if (buf[buf_len] < ' ') {
//							full_write(STDERR_FILENO, "^", 1);
//							buf[buf_len] += '@';
//						}
						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
			} /* while (have data) */

			// 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
				alarm(timeout);
				pfd.fd = STDOUT_FILENO;
				pfd.events = POLLOUT;
				while (len && !exitcode
				    && poll(&pfd, 1, -1) > 0
				    && (pfd.revents & POLLOUT)
				) {
#if ENABLE_FEATURE_CHAT_SEND_ESCAPES
					// "\\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;
						}
						if ('p' == c) {
							usleep(10000);
							len--;
							continue;
						}
						if ('K' == c) {
							tcsendbreak(STDOUT_FILENO, 0);
							len--;
							continue;
						}
						buf--;
					}
					if (safe_write(STDOUT_FILENO, buf, 1) != 1)
						break;
					len--;
					buf++;
#else
					len -= full_write(STDOUT_FILENO, buf, len);
#endif
				} /* while (can write) */
				alarm(0);

				// 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 (*argv) */
		}
	} /* while (*argv) */

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

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