watch.c revision 330449 
1/*-
2 * SPDX-License-Identifier: MIT
3 *
4 * Copyright (c) 1995 Ugen J.S.Antsilevich
5 *
6 * Redistribution and use in source forms, with and without modification,
7 * are permitted provided that this entire comment appears intact.
8 *
9 * Redistribution in binary form may occur without any restrictions.
10 * Obviously, it would be nice if you gave credit where credit is due
11 * but requiring it would be too onerous.
12 *
13 * This software is provided ``AS IS'' without any warranties of any kind.
14 *
15 * Snoop stuff.
16 */
17
18#include <sys/cdefs.h>
19__FBSDID("$FreeBSD: stable/11/usr.sbin/watch/watch.c 330449 2018-03-05 07:26:05Z eadler $");
20
21#include <sys/param.h>
22#include <sys/fcntl.h>
23#include <sys/filio.h>
24#include <sys/snoop.h>
25#include <sys/stat.h>
26#include <sys/linker.h>
27#include <sys/module.h>
28
29#include <err.h>
30#include <errno.h>
31#include <locale.h>
32#include <paths.h>
33#include <signal.h>
34#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
37#include <sysexits.h>
38#include <termcap.h>
39#include <termios.h>
40#include <time.h>
41#include <unistd.h>
42
43#define MSG_INIT	"Snoop started."
44#define MSG_OFLOW	"Snoop stopped due to overflow. Reconnecting."
45#define MSG_CLOSED	"Snoop stopped due to tty close. Reconnecting."
46#define MSG_CHANGE	"Snoop device change by user request."
47#define MSG_NOWRITE	"Snoop device change due to write failure."
48
49#define DEV_NAME_LEN	1024	/* for /dev/ttyXX++ */
50#define MIN_SIZE	256
51
52#define CHR_SWITCH	24	/* Ctrl+X	 */
53#define CHR_CLEAR	23	/* Ctrl+V	 */
54
55static void	clear(void);
56static void	timestamp(const char *);
57static void	set_tty(void);
58static void	unset_tty(void);
59static void	fatal(int, const char *);
60static int	open_snp(void);
61static void	cleanup(int);
62static void	usage(void) __dead2;
63static void	setup_scr(void);
64static void	attach_snp(void);
65static void	detach_snp(void);
66static void	set_dev(const char *);
67static void	ask_dev(char *, const char *);
68
69int		opt_reconn_close = 0;
70int		opt_reconn_oflow = 0;
71int		opt_interactive = 1;
72int		opt_timestamp = 0;
73int		opt_write = 0;
74int		opt_no_switch = 0;
75const char	*opt_snpdev;
76
77char		dev_name[DEV_NAME_LEN];
78int		snp_io;
79int		std_in = 0, std_out = 1;
80
81int		clear_ok = 0;
82struct termios	otty;
83char		tbuf[1024], gbuf[1024];
84
85static void
86clear(void)
87{
88
89	if (clear_ok)
90		tputs(gbuf, 1, putchar);
91	fflush(stdout);
92}
93
94static void
95timestamp(const char *buf)
96{
97	time_t		t;
98	char		btmp[1024];
99
100	clear();
101	printf("\n---------------------------------------------\n");
102	t = time(NULL);
103	strftime(btmp, 1024, "Time: %d %b %H:%M", localtime(&t));
104	printf("%s\n", btmp);
105	printf("%s\n", buf);
106	printf("---------------------------------------------\n");
107	fflush(stdout);
108}
109
110static void
111set_tty(void)
112{
113	struct termios	ntty;
114
115	ntty = otty;
116	ntty.c_lflag &= ~ICANON;	/* disable canonical operation */
117	ntty.c_lflag &= ~ECHO;
118#ifdef FLUSHO
119	ntty.c_lflag &= ~FLUSHO;
120#endif
121#ifdef PENDIN
122	ntty.c_lflag &= ~PENDIN;
123#endif
124#ifdef IEXTEN
125	ntty.c_lflag &= ~IEXTEN;
126#endif
127	ntty.c_cc[VMIN] = 1;		/* minimum of one character */
128	ntty.c_cc[VTIME] = 0;		/* timeout value */
129
130	ntty.c_cc[VINTR] = 07;		/* ^G */
131	ntty.c_cc[VQUIT] = 07;		/* ^G */
132	tcsetattr(std_in, TCSANOW, &ntty);
133}
134
135static void
136unset_tty(void)
137{
138
139	tcsetattr(std_in, TCSANOW, &otty);
140}
141
142static void
143fatal(int error, const char *buf)
144{
145
146	unset_tty();
147	if (buf)
148		errx(error, "fatal: %s", buf);
149	else
150		exit(error);
151}
152
153static int
154open_snp(void)
155{
156	int		f, mode;
157
158	if (opt_write)
159		mode = O_RDWR;
160	else
161		mode = O_RDONLY;
162
163	if (opt_snpdev == NULL)
164		f = open(_PATH_DEV "snp", mode);
165	else
166		f = open(opt_snpdev, mode);
167	if (f == -1)
168		fatal(EX_OSFILE, "cannot open snoop device");
169
170	return (f);
171}
172
173static void
174cleanup(int signo __unused)
175{
176
177	if (opt_timestamp)
178		timestamp("Logging Exited.");
179	close(snp_io);
180	unset_tty();
181	exit(EX_OK);
182}
183
184static void
185usage(void)
186{
187
188	fprintf(stderr, "usage: watch [-ciotnW] [tty name]\n");
189	exit(EX_USAGE);
190}
191
192static void
193setup_scr(void)
194{
195	char		*cbuf = gbuf, *term;
196
197	if (!opt_interactive)
198		return;
199	if ((term = getenv("TERM")))
200		if (tgetent(tbuf, term) == 1)
201			if (tgetstr("cl", &cbuf))
202				clear_ok = 1;
203	set_tty();
204	clear();
205}
206
207static void
208detach_snp(void)
209{
210	int		fd;
211
212	fd = -1;
213	ioctl(snp_io, SNPSTTY, &fd);
214}
215
216static void
217attach_snp(void)
218{
219	int		snp_tty;
220
221	snp_tty = open(dev_name, O_RDONLY | O_NONBLOCK);
222	if (snp_tty < 0)
223		fatal(EX_DATAERR, "can't open device");
224	if (ioctl(snp_io, SNPSTTY, &snp_tty) != 0)
225		fatal(EX_UNAVAILABLE, "cannot attach to tty");
226	close(snp_tty);
227	if (opt_timestamp)
228		timestamp("Logging Started.");
229}
230
231static void
232set_dev(const char *name)
233{
234	char		buf[DEV_NAME_LEN];
235	struct stat	sb;
236
237	if (strlen(name) > 5 && !strncmp(name, _PATH_DEV, sizeof _PATH_DEV - 1)) {
238		snprintf(buf, sizeof buf, "%s", name);
239	} else {
240		if (strlen(name) == 2)
241			sprintf(buf, "%s%s", _PATH_TTY, name);
242		else
243			sprintf(buf, "%s%s", _PATH_DEV, name);
244	}
245
246	if (*name == '\0' || stat(buf, &sb) < 0)
247		fatal(EX_DATAERR, "bad device name");
248
249	if ((sb.st_mode & S_IFMT) != S_IFCHR)
250		fatal(EX_DATAERR, "must be a character device");
251
252	strlcpy(dev_name, buf, sizeof(dev_name));
253
254	attach_snp();
255}
256
257void
258ask_dev(char *dbuf, const char *msg)
259{
260	char		buf[DEV_NAME_LEN];
261	int		len;
262
263	clear();
264	unset_tty();
265
266	if (msg)
267		printf("%s\n", msg);
268	if (dbuf)
269		printf("Enter device name [%s]:", dbuf);
270	else
271		printf("Enter device name:");
272
273	if (fgets(buf, DEV_NAME_LEN - 1, stdin)) {
274		len = strlen(buf);
275		if (buf[len - 1] == '\n')
276			buf[len - 1] = '\0';
277		if (buf[0] != '\0' && buf[0] != ' ')
278			strcpy(dbuf, buf);
279	}
280	set_tty();
281}
282
283#define READB_LEN	5
284
285int
286main(int ac, char *av[])
287{
288	int		ch, res, rv, nread;
289	size_t		b_size = MIN_SIZE;
290	char		*buf, chb[READB_LEN];
291	fd_set		fd_s;
292
293	(void) setlocale(LC_TIME, "");
294
295	if (isatty(std_out))
296		opt_interactive = 1;
297	else
298		opt_interactive = 0;
299
300	while ((ch = getopt(ac, av, "Wciotnf:")) != -1)
301		switch (ch) {
302		case 'W':
303			opt_write = 1;
304			break;
305		case 'c':
306			opt_reconn_close = 1;
307			break;
308		case 'i':
309			opt_interactive = 1;
310			break;
311		case 'o':
312			opt_reconn_oflow = 1;
313			break;
314		case 't':
315			opt_timestamp = 1;
316			break;
317		case 'n':
318			opt_no_switch = 1;
319			break;
320		case 'f':
321			opt_snpdev = optarg;
322			break;
323		case '?':
324		default:
325			usage();
326		}
327
328	tcgetattr(std_in, &otty);
329
330	if (modfind("snp") == -1)
331		if (kldload("snp") == -1 || modfind("snp") == -1)
332			warn("snp module not available");
333
334	signal(SIGINT, cleanup);
335
336	snp_io = open_snp();
337	setup_scr();
338
339	if (*(av += optind) == NULL) {
340		if (opt_interactive && !opt_no_switch)
341			ask_dev(dev_name, MSG_INIT);
342		else
343			fatal(EX_DATAERR, "no device name given");
344	} else
345		strlcpy(dev_name, *av, sizeof(dev_name));
346
347	set_dev(dev_name);
348
349	if (!(buf = (char *) malloc(b_size)))
350		fatal(EX_UNAVAILABLE, "malloc failed");
351
352	FD_ZERO(&fd_s);
353
354	for (;;) {
355		if (opt_interactive)
356			FD_SET(std_in, &fd_s);
357		FD_SET(snp_io, &fd_s);
358		res = select(snp_io + 1, &fd_s, NULL, NULL, NULL);
359		if (opt_interactive && FD_ISSET(std_in, &fd_s)) {
360
361			if ((res = ioctl(std_in, FIONREAD, &nread)) != 0)
362				fatal(EX_OSERR, "ioctl(FIONREAD)");
363			if (nread > READB_LEN)
364				nread = READB_LEN;
365			rv = read(std_in, chb, nread);
366			if (rv == -1 || rv != nread)
367				fatal(EX_IOERR, "read (stdin) failed");
368
369			switch (chb[0]) {
370			case CHR_CLEAR:
371				clear();
372				break;
373			case CHR_SWITCH:
374				if (!opt_no_switch) {
375					detach_snp();
376					ask_dev(dev_name, MSG_CHANGE);
377					set_dev(dev_name);
378					break;
379				}
380			default:
381				if (opt_write) {
382					rv = write(snp_io, chb, nread);
383					if (rv == -1 || rv != nread) {
384						detach_snp();
385						if (opt_no_switch)
386							fatal(EX_IOERR,
387							    "write failed");
388						ask_dev(dev_name, MSG_NOWRITE);
389						set_dev(dev_name);
390					}
391				}
392
393			}
394		}
395		if (!FD_ISSET(snp_io, &fd_s))
396			continue;
397
398		if ((res = ioctl(snp_io, FIONREAD, &nread)) != 0)
399			fatal(EX_OSERR, "ioctl(FIONREAD)");
400
401		switch (nread) {
402		case SNP_OFLOW:
403			if (opt_reconn_oflow)
404				attach_snp();
405			else if (opt_interactive && !opt_no_switch) {
406				ask_dev(dev_name, MSG_OFLOW);
407				set_dev(dev_name);
408			} else
409				cleanup(-1);
410			break;
411		case SNP_DETACH:
412		case SNP_TTYCLOSE:
413			if (opt_reconn_close)
414				attach_snp();
415			else if (opt_interactive && !opt_no_switch) {
416				ask_dev(dev_name, MSG_CLOSED);
417				set_dev(dev_name);
418			} else
419				cleanup(-1);
420			break;
421		default:
422			if (nread < (b_size / 2) && (b_size / 2) > MIN_SIZE) {
423				free(buf);
424				if (!(buf = (char *) malloc(b_size / 2)))
425					fatal(EX_UNAVAILABLE, "malloc failed");
426				b_size = b_size / 2;
427			}
428			if (nread > b_size) {
429				b_size = (nread % 2) ? (nread + 1) : (nread);
430				free(buf);
431				if (!(buf = (char *) malloc(b_size)))
432					fatal(EX_UNAVAILABLE, "malloc failed");
433			}
434			rv = read(snp_io, buf, nread);
435			if (rv == -1 || rv != nread)
436				fatal(EX_IOERR, "read failed");
437			rv = write(std_out, buf, nread);
438			if (rv == -1 || rv != nread)
439				fatal(EX_IOERR, "write failed");
440		}
441	}			/* While */
442	return(0);
443}
444