ref: dde3628d54073e0569bf565e6ec861e42cfa35f6
dir: /sys/src/cmd/con/con.c/
#include <u.h>
#include <libc.h>
int debug; /* true if debugging */
int ctl = -1; /* control fd (for break's) */
int raw; /* true if raw is on */
int consctl = -1; /* control fd for cons */
int ttypid; /* pid's if the 2 processes (used to kill them) */
int outfd = 1; /* local output file descriptor */
int cooked; /* non-zero forces cooked mode */
int returns; /* non-zero forces carriage returns not to be filtered out */
int crtonl; /* non-zero forces carriage returns to be converted to nls coming from net */
int strip; /* strip off parity bits */
char firsterr[2*ERRMAX];
char transerr[2*ERRMAX];
int limited;
char *remuser; /* for BSD rlogin authentication */
int verbose;
int baud;
int notkbd;
int nltocr; /* translate kbd nl to cr and vice versa */
static char *srv;
#define MAXMSG (2*8192)
int dodial(char*, char*, char*);
void fromkbd(int);
void fromnet(int);
long iread(int, void*, int);
long iwrite(int, void*, int);
int menu(int);
void notifyf(void*, char*);
void pass(int, int, int);
void rawoff(void);
void rawon(void);
void stdcon(int);
char* system(int, char*);
void dosystem(int, char*);
int wasintr(void);
void punt(char*);
char* syserr(void);
void seterr(char*);
/* protocols */
void device(char*, char*);
void rlogin(char*, char*);
void simple(char*, char*);
void
usage(void)
{
punt("usage: con [-CdnrRsTv] [-b baud] [-l [user]] [-c cmd] [-S svc] "
"net!host[!service]");
}
void
main(int argc, char *argv[])
{
char *dest;
char *cmd = 0;
returns = 1;
ARGBEGIN{
case 'b':
baud = atoi(EARGF(usage()));
break;
case 'C':
cooked = 1;
break;
case 'c':
cmd = EARGF(usage());
break;
case 'd':
debug = 1;
break;
case 'l':
limited = 1;
if(argv[1] != nil && argv[1][0] != '-')
remuser = EARGF(usage());
break;
case 'n':
notkbd = 1;
break;
case 'r':
returns = 0;
break;
case 's':
strip = 1;
break;
case 'S':
srv = EARGF(usage());
break;
case 'R':
nltocr = 1;
break;
case 'T':
crtonl = 1;
break;
case 'v':
verbose = 1;
break;
default:
usage();
}ARGEND
if(argc != 1){
if(remuser == 0)
usage();
dest = remuser;
remuser = 0;
} else
dest = argv[0];
if(*dest == '/' && strchr(dest, '!') == 0)
device(dest, cmd);
else if(limited){
simple(dest, cmd); /* doesn't return if dialout succeeds */
rlogin(dest, cmd); /* doesn't return if dialout succeeds */
} else {
rlogin(dest, cmd); /* doesn't return if dialout succeeds */
simple(dest, cmd); /* doesn't return if dialout succeeds */
}
punt(firsterr);
}
/*
* just dial and use as a byte stream with remote echo
*/
void
simple(char *dest, char *cmd)
{
int net;
net = dodial(dest, 0, 0);
if(net < 0)
return;
if(cmd)
dosystem(net, cmd);
if(!cooked)
rawon();
stdcon(net);
exits(0);
}
/*
* dial, do UCB authentication, use as a byte stream with local echo
*
* return if dial failed
*/
void
rlogin(char *dest, char *cmd)
{
int net;
char buf[128];
char *p;
char *localuser;
/* only useful on TCP */
if(strchr(dest, '!')
&& (strncmp(dest, "tcp!", 4)!=0 && strncmp(dest, "net!", 4)!=0))
return;
net = dodial(dest, "tcp", "login");
if(net < 0)
return;
/*
* do UCB rlogin authentication
*/
localuser = getuser();
if(remuser == 0){
if(limited)
remuser = ":";
else
remuser = localuser;
}
p = getenv("TERM");
if(p == 0)
p = "p9";
if(write(net, "", 1)<0
|| write(net, localuser, strlen(localuser)+1)<0
|| write(net, remuser, strlen(remuser)+1)<0
|| write(net, p, strlen(p)+1)<0){
close(net);
punt("BSD authentication failed");
}
if(read(net, buf, 1) != 1)
punt("BSD authentication failed1");
if(buf[0] != 0){
fprint(2, "con: remote error: ");
while(read(net, buf, 1) == 1){
write(2, buf, 1);
if(buf[0] == '\n')
break;
}
exits("read");
}
if(cmd)
dosystem(net, cmd);
if(!cooked)
rawon();
nltocr = 1;
stdcon(net);
exits(0);
}
/*
* just open a device and use it as a connection
*/
void
device(char *dest, char *cmd)
{
int net;
char cname[128];
net = open(dest, ORDWR);
if(net < 0) {
fprint(2, "con: cannot open %s: %r\n", dest);
exits("open");
}
snprint(cname, sizeof cname, "%sctl", dest);
ctl = open(cname, ORDWR);
if (baud > 0) {
if(ctl >= 0){
/* set speed and use fifos if available */
fprint(ctl, "b%d i1", baud);
}
else
fprint(2, "con: cannot open %s: %r\n", cname);
}
if(cmd)
dosystem(net, cmd);
if(!cooked)
rawon();
stdcon(net);
exits(0);
}
/*
* ignore interrupts
*/
void
notifyf(void *a, char *msg)
{
USED(a);
if(strstr(msg, "yankee"))
noted(NDFLT);
if(strstr(msg, "closed pipe")
|| strcmp(msg, "interrupt") == 0
|| strcmp(msg, "hangup") == 0)
noted(NCONT);
noted(NDFLT);
}
/*
* turn keyboard raw mode on
*/
void
rawon(void)
{
if(debug)
fprint(2, "rawon\n");
if(raw)
return;
if(consctl < 0)
consctl = open("/dev/consctl", OWRITE);
if(consctl < 0){
// fprint(2, "can't open consctl\n");
return;
}
write(consctl, "rawon", 5);
raw = 1;
}
/*
* turn keyboard raw mode off
*/
void
rawoff(void)
{
if(debug)
fprint(2, "rawoff\n");
if(raw == 0)
return;
if(consctl < 0)
consctl = open("/dev/consctl", OWRITE);
if(consctl < 0){
// fprint(2, "can't open consctl\n");
return;
}
write(consctl, "rawoff", 6);
raw = 0;
}
/*
* control menu
*/
#define STDHELP "\t(b)reak, (q)uit, (i)nterrupt, toggle printing (r)eturns, (.)continue, (!cmd)\n"
int
menu(int net)
{
char buf[MAXMSG];
long n;
int done;
int wasraw = raw;
if(wasraw)
rawoff();
fprint(2, ">>> ");
for(done = 0; !done; ){
n = read(0, buf, sizeof(buf)-1);
if(n <= 0)
return -1;
buf[n] = 0;
switch(buf[0]){
case '!':
print(buf);
system(net, buf+1);
print("!\n");
done = 1;
break;
case '.':
done = 1;
break;
case 'q':
return -1;
case 'i':
buf[0] = 0x1c;
write(net, buf, 1);
done = 1;
break;
case 'b':
if(ctl >= 0)
write(ctl, "k", 1);
done = 1;
break;
case 'r':
returns = 1-returns;
done = 1;
break;
default:
fprint(2, STDHELP);
break;
}
if(!done)
fprint(2, ">>> ");
}
if(wasraw)
rawon();
else
rawoff();
return 0;
}
void
post(char *srv, int fd)
{
int f;
char buf[32];
f = create(srv, OWRITE /* |ORCLOSE */ , 0666);
if(f < 0)
sysfatal("create %s: %r", srv);
snprint(buf, sizeof buf, "%d", fd);
if(write(f, buf, strlen(buf)) != strlen(buf))
sysfatal("write %s: %r", srv);
close(f);
}
/*
* the real work. two processes pass bytes back and forth between the
* terminal and the network.
*/
void
stdcon(int net)
{
int netpid;
int p[2];
char *svc;
svc = nil;
if (srv) {
if(pipe(p) < 0)
sysfatal("pipe: %r");
if (srv[0] != '/')
svc = smprint("/srv/%s", srv);
else
svc = srv;
post(svc, p[0]);
close(p[0]);
dup(p[1], 0);
dup(p[1], 1);
/* pipe is now std in & out */
}
ttypid = getpid();
switch(netpid = rfork(RFMEM|RFPROC)){
case -1:
perror("con");
exits("fork");
case 0:
notify(notifyf);
fromnet(net);
if (svc)
remove(svc);
postnote(PNPROC, ttypid, "die yankee dog");
exits(0);
default:
notify(notifyf);
fromkbd(net);
if (svc)
remove(svc);
if(notkbd)
for(;;)
sleep(0);
postnote(PNPROC, netpid, "die yankee dog");
exits(0);
}
}
/*
* Read the keyboard and write it to the network. '^\' gets us into
* the menu.
*/
void
fromkbd(int net)
{
long n;
char buf[MAXMSG];
char *p, *ep;
int eofs;
eofs = 0;
for(;;){
n = read(0, buf, sizeof(buf));
if(n < 0){
if(wasintr()){
if(!raw){
buf[0] = 0x7f;
n = 1;
} else
continue;
} else
return;
}
if(n == 0){
if(++eofs > 32)
return;
} else
eofs = 0;
if(n && memchr(buf, 0x1c, n)){
if(menu(net) < 0)
return;
}else{
if(!raw && n==0){
buf[0] = 0x4;
n = 1;
}
if(nltocr){
ep = buf+n;
for(p = buf; p < ep; p++)
switch(*p){
case '\r':
*p = '\n';
break;
case '\n':
*p = '\r';
break;
}
}
if(iwrite(net, buf, n) != n)
return;
}
}
}
/*
* Read from the network and write to the screen.
* Filter out spurious carriage returns.
*/
void
fromnet(int net)
{
long n;
char buf[MAXMSG];
char *cp, *ep;
for(;;){
n = iread(net, buf, sizeof(buf));
if(n < 0)
return;
if(n == 0)
continue;
if (strip)
for (cp=buf; cp<buf+n; cp++)
*cp &= 0177;
if(crtonl) {
/* convert cr's to nl's */
for (cp = buf; cp < buf + n; cp++)
if (*cp == '\r')
*cp = '\n';
}
else if(!returns){
/* convert cr's to null's */
cp = buf;
ep = buf + n;
while(cp < ep && (cp = memchr(cp, '\r', ep-cp))){
memmove(cp, cp+1, ep-cp-1);
ep--;
n--;
}
}
if(n > 0 && iwrite(outfd, buf, n) != n){
if(outfd == 1)
return;
outfd = 1;
if(iwrite(1, buf, n) != n)
return;
}
}
}
/*
* dial and return a data connection
*/
int
dodial(char *dest, char *net, char *service)
{
char name[128];
char devdir[128];
int data;
devdir[0] = 0;
strcpy(name, netmkaddr(dest, net, service));
data = dial(name, 0, devdir, &ctl);
if(data < 0){
seterr(name);
return -1;
}
fprint(2, "connected to %s on %s\n", name, devdir);
return data;
}
void
dosystem(int fd, char *cmd)
{
char *p;
p = system(fd, cmd);
if(p){
print("con: %s terminated with %s\n", cmd, p);
exits(p);
}
}
/*
* run a command with the network connection as standard IO
*/
char *
system(int fd, char *cmd)
{
int pid;
int p;
static Waitmsg msg;
int pfd[2];
int n;
char buf[4096];
if(pipe(pfd) < 0){
perror("pipe");
return "pipe failed";
}
outfd = pfd[1];
close(consctl);
consctl = -1;
switch(pid = fork()){
case -1:
perror("con");
return "fork failed";
case 0:
close(pfd[1]);
dup(pfd[0], 0);
dup(fd, 1);
close(ctl);
close(fd);
close(pfd[0]);
if(*cmd)
execl("/bin/rc", "rc", "-c", cmd, nil);
else
execl("/bin/rc", "rc", nil);
perror("con");
exits("exec");
break;
default:
close(pfd[0]);
while((n = read(pfd[1], buf, sizeof(buf))) > 0)
if(write(fd, buf, n) != n)
break;
p = waitpid();
outfd = 1;
close(pfd[1]);
if(p < 0 || p != pid)
return "lost child";
break;
}
return msg.msg;
}
int
wasintr(void)
{
return strcmp(syserr(), "interrupted") == 0;
}
void
punt(char *msg)
{
if(*msg == 0)
msg = transerr;
fprint(2, "con: %s\n", msg);
exits(msg);
}
char*
syserr(void)
{
static char err[ERRMAX];
errstr(err, sizeof err);
return err;
}
void
seterr(char *addr)
{
char *se = syserr();
if(verbose)
fprint(2, "'%s' calling %s\n", se, addr);
if(firsterr[0] && (strstr(se, "translate") ||
strstr(se, "file does not exist") ||
strstr(se, "unknown address") ||
strstr(se, "directory entry not found")))
return;
strcpy(firsterr, se);
}
long
iread(int f, void *a, int n)
{
long m;
for(;;){
m = read(f, a, n);
if(m >= 0 || !wasintr())
break;
}
return m;
}
long
iwrite(int f, void *a, int n)
{
long m;
m = write(f, a, n);
if(m < 0 && wasintr())
return n;
return m;
}