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