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