Subversion Repositories planix.SVN

#include <u.h>

#include <libc.h>

#include <draw.h>

#include <thread.h>

#include <mouse.h>

#include <keyboard.h>

#include <frame.h>

#include <plumb.h>

#include "flayer.h"

#include "samterm.h"

static char exname[64];

void

usage(void)

{

	fprint(2, "usage: samterm [-a]\n");

	threadexitsall("usage");

}

void

getscreen(int argc, char **argv)

{

	char *t;

	ARGBEGIN{

	case 'a':

		autoindent = 1;

		break;

	default:

		usage();

	}ARGEND

	if(initdraw(panic1, nil, "sam") < 0){

		fprint(2, "samterm: initdraw: %r\n");

		threadexitsall("init");

	}

	t = getenv("tabstop");

	if(t != nil)

		maxtab = strtoul(t, nil, 0);

	draw(screen, screen->clipr, display->white, nil, ZP);

}

int

screensize(int *w, int *h)

{

	int fd, n;

	char buf[5*12+1];

	fd = open("/dev/screen", OREAD);

	if(fd < 0)

		return 0;

	n = read(fd, buf, sizeof(buf)-1);

	close(fd);

	if (n != sizeof(buf)-1)

		return 0;

	buf[n] = 0;

	if (h) {

		*h = atoi(buf+4*12)-atoi(buf+2*12);

		if (*h < 0)

			return 0;

	}

	if (w) {

		*w = atoi(buf+3*12)-atoi(buf+1*12);

		if (*w < 0)

			return 0;

	}

	return 1;

}

int

snarfswap(char *fromsam, int nc, char **tosam)

{

	char *s1;

	int f, n, ss;

	f = open("/dev/snarf", 0);

	if(f < 0)

		return -1;

	ss = SNARFSIZE;

	if(hversion < 2)

		ss = 4096;

	*tosam = s1 = alloc(ss);

	n = read(f, s1, ss-1);

	close(f);

	if(n < 0)

		n = 0;

	if (n == 0) {

		*tosam = 0;

		free(s1);

	} else

		s1[n] = 0;

	f = create("/dev/snarf", 1, 0666);

	if(f >= 0){

		write(f, fromsam, nc);

		close(f);

	}

	return n;

}

void

dumperrmsg(int count, int type, int count0, int c)

{

	fprint(2, "samterm: host mesg: count %d %ux %ux %ux %s...ignored\n",

		count, type, count0, c, rcvstring());

}

void

removeextern(void)

{

	remove(exname);

}

Readbuf	hostbuf[2];

Readbuf	plumbbuf[2];

void

extproc(void *argv)

{

	Channel *c;

	int i, n, which, *fdp;

	void **arg;

	arg = argv;

	c = arg[0];

	fdp = arg[1];

	i = 0;

	for(;;){

		i = 1-i;	/* toggle */

		n = read(*fdp, plumbbuf[i].data, sizeof plumbbuf[i].data);

		if(n <= 0){

			fprint(2, "samterm: extern read error: %r\n");

			threadexits("extern");	/* not a fatal error */

		}

		plumbbuf[i].n = n;

		which = i;

		send(c, &which);

	}

}

void

extstart(void)

{

	char buf[32];

	int fd;

	static int p[2];

	static void *arg[2];

	if(pipe(p) < 0)

		return;

	sprint(exname, "/srv/sam.%s", getuser());

	fd = create(exname, 1, 0600);

	if(fd < 0){	/* assume existing guy is more important */

    Err:

		close(p[0]);

		close(p[1]);

		return;

	}

	sprint(buf, "%d", p[0]);

	if(write(fd, buf, strlen(buf)) <= 0)

		goto Err;

	close(fd);

	/*

	 * leave p[0] open so if the file is removed the event

	 * library won't get an error

	 */

	plumbc = chancreate(sizeof(int), 0);

	arg[0] = plumbc;

	arg[1] = &p[1];

	proccreate(extproc, arg, 1024);

	atexit(removeextern);

}

int

plumbformat(int i)

{

	Plumbmsg *m;

	char *addr, *data, *act;

	int n;

	data = (char*)plumbbuf[i].data;

	m = plumbunpack(data, plumbbuf[i].n);

	if(m == nil)

		return 0;

	n = m->ndata;

	if(n == 0){

		plumbfree(m);

		return 0;

	}

	act = plumblookup(m->attr, "action");

	if(act!=nil && strcmp(act, "showfile")!=0){

		/* can't handle other cases yet */

		plumbfree(m);

		return 0;

	}

	addr = plumblookup(m->attr, "addr");

	if(addr){

		if(addr[0] == '\0')

			addr = nil;

		else

			addr = strdup(addr);	/* copy to safe storage; we'll overwrite data */

	}

	memmove(data, "B ", 2);	/* we know there's enough room for this */

	memmove(data+2, m->data, n);

	n += 2;

	if(data[n-1] != '\n')

		data[n++] = '\n';

	if(addr != nil){

		if(n+strlen(addr)+1+1 <= READBUFSIZE)

			n += sprint(data+n, "%s\n", addr);

		free(addr);

	}

	plumbbuf[i].n = n;

	plumbfree(m);

	return 1;

}

void

plumbproc(void *argv)

{

	Channel *c;

	int i, n, which, *fdp;

	void **arg;

	arg = argv;

	c = arg[0];

	fdp = arg[1];

	i = 0;

	for(;;){

		i = 1-i;	/* toggle */

		n = read(*fdp, plumbbuf[i].data, READBUFSIZE);

		if(n <= 0){

			fprint(2, "samterm: plumb read error: %r\n");

			threadexits("plumb");	/* not a fatal error */

		}

		plumbbuf[i].n = n;

		if(plumbformat(i)){

			which = i;

			send(c, &which);

		}

	}

}

int

plumbstart(void)

{

	static int fd;

	static void *arg[2];

	plumbfd = plumbopen("send", OWRITE|OCEXEC);	/* not open is ok */

	fd = plumbopen("edit", OREAD|OCEXEC);

	if(fd < 0)

		return -1;

	plumbc = chancreate(sizeof(int), 0);

	if(plumbc == nil){

		close(fd);

		return -1;

	}

	arg[0] =plumbc;

	arg[1] = &fd;

	proccreate(plumbproc, arg, 4096);

	return 1;

}

void

hostproc(void *arg)

{

	Channel *c;

	int i, n, which;

	c = arg;

	i = 0;

	for(;;){

		i = 1-i;	/* toggle */

		n = read(0, hostbuf[i].data, sizeof hostbuf[i].data);

		if(n <= 0){

			if(n==0){

				if(exiting)

					threadexits(nil);

				werrstr("unexpected eof");

			}

			fprint(2, "samterm: host read error: %r\n");

			threadexitsall("host");

		}

		hostbuf[i].n = n;

		which = i;

		send(c, &which);

	}

}

void

hoststart(void)

{

	hostc = chancreate(sizeof(int), 0);

	proccreate(hostproc, hostc, 1024);

}