freebsd-src/usr.bin/watch/watch.c
Ugen J.S. Antsilevich 7f4c79484b This is watch - programm to work with /dev/snp,
it still lacks manpage-i will commit it today later.
For now to test try: watch [ttyname] :)
1995-02-17 14:36:03 +00:00

405 lines
7.3 KiB
C

/*
* Copyright (c) 1995 Ugen J.S.Antsilevich
*
* Redistribution and use in source forms, with and without modification,
* are permitted provided that this entire comment appears intact.
*
* Redistribution in binary form may occur without any restrictions.
* Obviously, it would be nice if you gave credit where credit is due
* but requiring it would be too onerous.
*
* This software is provided ``AS IS'' without any warranties of any kind.
*
* Snoop stuff.
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/select.h>
#include <sys/fcntl.h>
#include <sys/ioctl.h>
#include <sys/ioctl_compat.h>
#include <sys/snoop.h>
#define MSG_INIT "Snoop started."
#define MSG_OFLOW "Snoop stopped due to overflow.Reconnecting."
#define MSG_CLOSED "Snoop stopped due to tty close.Reconnecting."
#define MSG_CHANGE "Snoop device change by user request."
#define DEV_NAME_LEN 12 /* for /dev/ttyXX++ */
#define MIN_SIZE 256
#define CHR_SWITCH 24 /* Ctrl+X */
#define CHR_CLEAR 23 /* Ctrl+V */
int opt_reconn_close = 0;
int opt_reconn_oflow = 0;
int opt_interactive = 1;
int opt_timestamp = 0;
char dev_name[DEV_NAME_LEN];
int snp_io;
struct snptty snp_tty;
int std_in = 0, std_out = 1;
int clear_ok = 0;
struct sgttyb sgo;
char tbuf[1024], buf[1024];
void
clear()
{
if (clear_ok)
tputs(buf, 1, putchar);
fflush(stdout);
}
void
timestamp(buf)
char *buf;
{
time_t t;
char btmp[1024];
clear();
printf("\n---------------------------------------------\n");
t = time(NULL);
strftime(btmp, 1024, "Time: %d %b %H:%M", localtime(&t));
printf("%s\n", btmp);
printf("%s\n", buf);
printf("---------------------------------------------\n");
fflush(stdout);
}
void
set_tty()
{
struct sgttyb sgn;
ioctl(std_in, TIOCGETP, &sgo);
/* bcopy(&sgn, &sgo, sizeof(struct sgttyb)); */
sgn = sgo;
sgn.sg_flags |= CBREAK;
sgn.sg_flags &= ~ECHO;
ioctl(std_in, TIOCSETP, &sgn);
}
void
unset_tty()
{
ioctl(std_in, TIOCSETP, &sgo);
}
void
fatal(buf)
char *buf;
{
unset_tty();
if (buf)
fprintf(stderr, "Fatal: %s\n", buf);
exit(1);
}
int
open_snp()
{
char snp[DEV_NAME_LEN] = "/dev/snpX";
char c;
int f;
for (c = '0'; c <= '9'; c++) {
snp[8] = c;
if ((f = open(snp, O_RDONLY)) < 0)
continue;
return f;
}
fatal("Cannot open snoop device.");
}
void
cleanup()
{
if (opt_timestamp)
timestamp("Logging Exited.");
close(snp_io);
unset_tty();
exit(0);
}
void
show_usage()
{
printf("watch -[ciot] [tty name]\n");
exit(1);
}
void
setup_scr()
{
char *cbuf = buf, *term;
if (!opt_interactive)
return;
if ((term = getenv("TERM")))
if (tgetent(tbuf, term) == 1)
if (tgetstr("cl", &cbuf))
clear_ok = 1;
clear();
set_tty();
}
int
ctoh(c)
char c;
{
if (c >= '0' && c <= '9')
return (int) (c - '0');
if (c >= 'a' && c <= 'f')
return (int) (c - 'a' + 10);
fatal("Bad tty number.");
}
void
detach_snp()
{
struct snptty st;
st.st_type = -1;
st.st_unit = -1;
ioctl(snp_io, SNPSTTY, &st);
}
void
attach_snp()
{
if (ioctl(snp_io, SNPSTTY, &snp_tty) != 0)
fatal("Cannot attach to tty.");
if (opt_timestamp)
timestamp("Logging Started.");
}
void
set_dev(name)
char *name;
{
char buf[DEV_NAME_LEN], num[DEV_NAME_LEN];
int unitbase = 0;
if (strlen(name) > 5 && !strncmp(name, "/dev/", 5))
strcpy(buf, &(name[5]));
else
strcpy(buf, name);
if (strlen(buf) < 4)
fatal("Bad tty name.");
if (!strncmp(buf, "tty", 3))
switch (buf[3]) {
case 'v':
snp_tty.st_unit = ctoh(buf[4]);
snp_tty.st_type = ST_VTY;
goto got_num;
case 'r':
unitbase += 16;
case 'q':
unitbase += 16;
case 'p':
snp_tty.st_unit = ctoh(buf[4]) + unitbase;
snp_tty.st_type = ST_PTY;
goto got_num;
case '0':
case 'd':
snp_tty.st_unit = ctoh(buf[4]);
snp_tty.st_type = ST_SIO;
goto got_num;
default:
fatal("Bad tty name.");
}
if (!strncmp(buf, "vty", 3)) {
strcpy(num, &(buf[3]));
snp_tty.st_unit = atoi(num);
snp_tty.st_type = ST_VTY;
goto got_num;
}
if (!strncmp(buf, "pty", 3)) {
strcpy(num, &(buf[3]));
snp_tty.st_unit = atoi(num);
snp_tty.st_type = ST_PTY;
goto got_num;
}
if (!strncmp(buf, "sio", 3) || !strncmp(buf, "cua", 3)) {
strcpy(num, &(buf[3]));
snp_tty.st_unit = atoi(num);
snp_tty.st_type = ST_SIO;
goto got_num;
}
fatal("Bad tty name.");
got_num:
attach_snp();
}
void
ask_dev(dev_name, msg)
char *dev_name, *msg;
{
char buf[DEV_NAME_LEN];
int len;
clear();
unset_tty();
if (msg)
printf("%s\n", msg);
if (dev_name)
printf("Enter device name [%s]:", dev_name);
else
printf("Enter device name:");
if (fgets(buf, DEV_NAME_LEN - 1, stdin)) {
len = strlen(buf);
if (buf[len - 1] == '\n')
buf[len - 1] = '\0';
if (buf[0] != '\0' && buf[0] != ' ')
strcpy(dev_name, buf);
}
set_tty();
}
void
main(ac, av)
int ac;
char **av;
{
int res, nread, b_size = MIN_SIZE;
extern int optind;
char ch, *buf;
fd_set fd_s;
if (getuid() != 0)
fatal(NULL);
if (isatty(std_out))
opt_interactive = 1;
else
opt_interactive = 0;
while ((ch = getopt(ac, av, "ciot")) != EOF)
switch (ch) {
case 'c':
opt_reconn_close = 1;
break;
case 'i':
opt_interactive = 1;
break;
case 'o':
opt_reconn_oflow = 1;
break;
case 't':
opt_timestamp = 1;
break;
case '?':
default:
show_usage();
exit(1);
}
signal(SIGINT, cleanup);
setup_scr();
snp_io = open_snp();
if (*(av += optind) == NULL) {
if (opt_interactive)
ask_dev(dev_name, MSG_INIT);
else
fatal("No device name given.");
} else
strncpy(dev_name, *av, DEV_NAME_LEN);
set_dev(dev_name);
if (!(buf = (char *) malloc(b_size)))
fatal("Cannot malloc().");
FD_ZERO(&fd_s);
while (1) {
if (opt_interactive)
FD_SET(std_in, &fd_s);
FD_SET(snp_io, &fd_s);
res = select(snp_io + 1, &fd_s, NULL, NULL, NULL);
if (opt_interactive && FD_ISSET(std_in, &fd_s)) {
switch (ch = getchar()) {
case CHR_CLEAR:
clear();
break;
case CHR_SWITCH:
/* detach_snp(); */
ask_dev(dev_name, MSG_CHANGE);
set_dev(dev_name);
break;
default:
}
}
if (!FD_ISSET(snp_io, &fd_s))
continue;
if ((res = ioctl(snp_io, FIONREAD, &nread)) != 0)
fatal("ioctl() failed.");
switch (nread) {
case SNP_OFLOW:
if (opt_reconn_oflow)
attach_snp();
else if (opt_interactive) {
ask_dev(dev_name, MSG_OFLOW);
set_dev(dev_name);
} else
cleanup();
case SNP_DETACH:
case SNP_TTYCLOSE:
if (opt_reconn_close)
attach_snp();
else if (opt_interactive) {
ask_dev(dev_name, MSG_CLOSED);
set_dev(dev_name);
} else
cleanup();
default:
if (nread < (b_size / 2) && (b_size / 2) > MIN_SIZE) {
free(buf);
if (!(buf = (char *) malloc(b_size / 2)))
fatal("Cannot malloc()");
b_size = b_size / 2;
}
if (nread > b_size) {
b_size = (nread % 2) ? (nread + 1) : (nread);
free(buf);
if (!(buf = (char *) malloc(b_size)))
fatal("Cannot malloc()");
}
if (read(snp_io, buf, nread) < nread)
fatal("read failed.");
if (write(std_out, buf, nread) < nread)
fatal("write failed.");
}
} /* While */
}