harvey/sys/src/cmd/aux/9pcon.c

/*
 * This file is part of the UCB release of Plan 9. It is subject to the license
 * terms in the LICENSE file found in the top-level directory of this
 * distribution and at http://akaros.cs.berkeley.edu/files/Plan9License. No
 * part of the UCB release of Plan 9, including this file, may be copied,
 * modified, propagated, or distributed except according to the terms contained
 * in the LICENSE file.
 */

#include <u.h>
#include <libc.h>
#include <auth.h>
#include <fcall.h>
#include <bio.h>

uint messagesize = 65536;	/* just a buffer size */

void
usage(void)
{
	fprint(2, "usage: aux/9pcon [-m messagesize] /srv/service | -c command | -n networkaddress\n");
	exits("usage");
}

int
connectcmd(char *cmd)
{
	int p[2];

	if(pipe(p) < 0)
		return -1;
	switch(fork()){
	case -1:
		fprint(2, "fork failed: %r\n");
		_exits("exec");
	case 0:
		dup(p[0], 0);
		dup(p[0], 1);
		close(p[1]);
		execl("/bin/rc", "rc", "-c", cmd, nil);
		fprint(2, "exec failed: %r\n");
		_exits("exec");
	default:
		close(p[0]);
		return p[1];
	}
}

void
watch(int fd)
{
	int n;
	uint8_t *buf;
	Fcall f;
	
	buf = malloc(messagesize);
	if(buf == nil)
		sysfatal("out of memory");

	while((n = read9pmsg(fd, buf, messagesize)) > 0){
		if(convM2S(buf, n, &f) == 0){
			print("convM2S: %r\n");
			continue;
		}
		print("\t<- %F\n", &f);
	}
	if(n == 0)
		print("server eof\n");
	else
		print("read9pmsg from server: %r\n");
}

char*
tversion(Fcall *f, int p, char **argv)
{
	f->msize = atoi(argv[0]);
	if(f->msize > messagesize)
		return "message size too big; use -m option on command line";
	f->version = argv[1];
	return nil;
}

char*
tauth(Fcall *f, int p, char **argv)
{
	f->afid = atoi(argv[0]);
	f->uname = argv[1];
	f->aname = argv[2];
	return nil;
}

char*
tflush(Fcall *f, int p, char **argv)
{
	f->oldtag = atoi(argv[0]);
	return nil;
}

char*
tattach(Fcall *f, int p, char **argv)
{
	f->fid = atoi(argv[0]);
	f->afid = atoi(argv[1]);
	f->uname = argv[2];
	f->aname = argv[3];
	return nil;
}

char*
twalk(Fcall *f, int argc, char **argv)
{
	int i;

	if(argc < 2)
		return "usage: Twalk tag fid newfid [name...]";
	f->fid = atoi(argv[0]);
	f->newfid = atoi(argv[1]);
	f->nwname = argc-2;
	if(f->nwname > MAXWELEM)
		return "too many names";
	for(i=0; i<argc-2; i++)
		f->wname[i] = argv[2+i];
	return nil;
}

char*
topen(Fcall *f, int p, char **argv)
{
	f->fid = atoi(argv[0]);
	f->mode = atoi(argv[1]);
	return nil;
}

char*
tcreate(Fcall *f, int p, char **argv)
{
	f->fid = atoi(argv[0]);
	f->name = argv[1];
	f->perm = strtoul(argv[2], 0, 8);
	f->mode = atoi(argv[3]);
	return nil;
}

char*
tread(Fcall *f, int p, char **argv)
{
	f->fid = atoi(argv[0]);
	f->offset = strtoll(argv[1], 0, 0);
	f->count = strtol(argv[2], 0, 0);
	return nil;
}

char*
twrite(Fcall *f, int p, char **argv)
{
	f->fid = atoi(argv[0]);
	f->offset = strtoll(argv[1], 0, 0);
	f->data = argv[2];
	f->count = strlen(argv[2]);
	return nil;
}

char*
tclunk(Fcall *f, int p, char **argv)
{
	f->fid = atoi(argv[0]);
	return nil;
}

char*
tremove(Fcall *f, int p, char **argv)
{
	f->fid = atoi(argv[0]);
	return nil;
}

char*
tstat(Fcall *f, int p, char **argv)
{
	f->fid = atoi(argv[0]);
	return nil;
}

uint32_t
xstrtoul(char *s)
{
	if(strcmp(s, "~0") == 0)
		return ~0U;
	return strtoul(s, 0, 0);
}

uint64_t
xstrtoull(char *s)
{
	if(strcmp(s, "~0") == 0)
		return ~0ULL;
	return strtoull(s, 0, 0);
}

char*
twstat(Fcall *f, int p, char **argv)
{
	static uint8_t buf[DIRMAX];
	Dir d;

	memset(&d, 0, sizeof d);
	nulldir(&d);
	d.name = argv[1];
	d.uid = argv[2];
	d.gid = argv[3];
	d.mode = xstrtoul(argv[4]);
	d.mtime = xstrtoul(argv[5]);
	d.length = xstrtoull(argv[6]);

	f->fid = atoi(argv[0]);
	f->stat = buf;
	f->nstat = convD2M(&d, buf, sizeof buf);
	if(f->nstat < BIT16SZ)
		return "convD2M failed (internal error)";

	return nil;
}

int taggen;

char*
settag(Fcall *f, int p, char **argv)
{
	static char buf[120];

	taggen = atoi(argv[0])-1;
	snprint(buf, sizeof buf, "next tag is %d", taggen+1);
	return buf;
}

typedef struct Cmd Cmd;
struct Cmd {
	char *name;
	int type;
	int argc;
	char *usage;
	char *(*fn)(Fcall *f, int p, char**);
};

Cmd msg9p[] = {
	"Tversion", Tversion, 2, "messagesize version", tversion,
	"Tauth", Tauth, 3, "afid uname aname", tauth,
	"Tflush", Tflush, 1, "oldtag", tflush,
	"Tattach", Tattach, 4, "fid afid uname aname", tattach,
	"Twalk", Twalk, 0, "fid newfid [name...]", twalk,
	"Topen", Topen, 2, "fid mode", topen,
	"Tcreate", Tcreate, 4, "fid name perm mode", tcreate,
	"Tread", Tread, 3, "fid offset count", tread,
	"Twrite", Twrite, 3, "fid offset data", twrite,
	"Tclunk", Tclunk, 1, "fid", tclunk,
	"Tremove", Tremove, 1, "fid", tremove,
	"Tstat", Tstat, 1, "fid", tstat,
	"Twstat", Twstat, 7, "fid name uid gid mode mtime length", twstat,
	"nexttag", 0, 0, "", settag,
};

void
shell9p(int fd)
{
	char *e, *f[10], *p;
	uint8_t *buf;
	int i, n, nf;
	Biobuf b;
	Fcall t;

	buf = malloc(messagesize);
	if(buf == nil){
		fprint(2, "out of memory\n");
		return;
	}

	taggen = 0;
	Binit(&b, 0, OREAD);
	while(p = Brdline(&b, '\n')){
		p[Blinelen(&b)-1] = '\0';
		if(p[0] == '#')
			continue;
		if((nf = tokenize(p, f, nelem(f))) == 0)
			continue;
		for(i=0; i<nelem(msg9p); i++)
			if(strcmp(f[0], msg9p[i].name) == 0)
				break;
		if(i == nelem(msg9p)){
			fprint(2, "?unknown message\n");
			continue;
		}
		memset(&t, 0, sizeof t);
		t.type = msg9p[i].type;
		if(t.type == Tversion)
			t.tag = NOTAG;
		else
			t.tag = ++taggen;
		if(nf < 1 || (msg9p[i].argc && nf != 1+msg9p[i].argc)){
			fprint(2, "?usage: %s %s\n", msg9p[i].name, msg9p[i].usage);
			continue;
		}
		if(e = msg9p[i].fn(&t, nf-1, f+1)){
			fprint(2, "?%s\n", e);
			continue;
		}
		n = convS2M(&t, buf, messagesize);
		if(n <= BIT16SZ){
			fprint(2, "?message too large for buffer\n");
			continue;
		}
		if(write(fd, buf, n) != n){
			fprint(2, "?write fails: %r\n");
			break;
		}
		print("\t-> %F\n", &t);
	}
}
		
void
main(int argc, char **argv)
{
	int fd, pid, cmd, net;

	cmd = 0;
	net = 0;
	ARGBEGIN{
	case 'c':
		cmd = 1;
		break;
	case 'm':
		messagesize = atoi(EARGF(usage()));
		break;
	case 'n':
		net = 1;
		break;
	default:
		usage();
	}ARGEND

	fmtinstall('F', fcallfmt);
	fmtinstall('D', dirfmt);
	fmtinstall('M', dirmodefmt);

	if(argc != 1)
		usage();

	if(cmd && net)
		usage();

	if(cmd)
		fd = connectcmd(argv[0]);
	else if(net){
		fd = dial(netmkaddr(argv[0], "net", "9fs"), 0, 0, 0);
		if(fd < 0)
			sysfatal("dial: %r");
	}else{
		fd = open(argv[0], ORDWR);
		if(fd < 0)
			sysfatal("open: %r");
	}

	switch(pid = rfork(RFPROC|RFMEM)){
	case -1:
		sysfatal("rfork: %r");
		break;
	case 0:
		watch(fd);
		postnote(PNPROC, getppid(), "kill");
		break;
	default:
		shell9p(fd);
		postnote(PNPROC, pid, "kill");
		break;
	}
	exits(nil);
}