usr.sbin/watch/watch.c

   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
  82 clear(void)
  83 {
  84
  85         if (clear_ok)
  86                 tputs(gbuf, 1, putchar);
  87         fflush(stdout);
  88 }
  89
  90 static void
  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
 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
 132 unset_tty(void)
 133 {
 134
 135         tcsetattr(std_in, TCSANOW, &otty);
 136 }
 137
 138 static void
 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
 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
 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
 181 usage(void)
 182 {
 183
 184         fprintf(stderr, "usage: watch [-ciotnW] [tty name]\n");
 185         exit(EX_USAGE);
 186 }
 187
 188 static 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
 204 detach_snp(void)
 205 {
 206         int             fd;
 207
 208         fd = -1;
 209         ioctl(snp_io, SNPSTTY, &fd);
 210 }
 211
 212 static 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
 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
 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
 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 }