/*
* cpu.c - Make a connection to a cpu server
*
*         Invoked by listen as 'cpu -R | -N service net netdir'
*                 by users  as 'cpu [-h system] [-c cmd args ...]'
*/

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

#define Maxfdata 8192
#define MaxStr 128

void    remoteside(void);
void    fatal(char*, ...);
void    lclnoteproc(int);
void    rmtnoteproc(void);
void    catcher(void*, char*);
void    usage(void);
void    writestr(int, char*, char*, int);
int     readstr(int, char*, int);
char    *rexcall(int*, char*, char*);
int     setamalg(char*);
char    *keyspec = "";

int     notechan;
int     exportpid;
char    *system;
int     cflag;
int     nflag;
int     dbg;
char    *user;
char    *patternfile;
char    *origargs;

char    *srvname = "ncpu";
char    *exportfs = "/bin/exportfs";
char    *ealgs = "rc4_256 sha1";

/* message size for exportfs; may be larger so we can do big graphics in CPU window */
int     msgsize = Maxfdata+IOHDRSZ;

/* encryption mechanisms */
static int      clear(int);

int (*encryption)(int) = clear;

/* authentication mechanisms */
static int      netkeyauth(int);
static int      netkeysrvauth(int, char*);
static int      p9auth(int);
static int      srvp9auth(int, char*);
static int      noauth(int);
static int      srvnoauth(int, char*);

typedef struct AuthMethod AuthMethod;
struct AuthMethod {
       char    *name;                  /* name of method */
       int     (*cf)(int);             /* client side authentication */
       int     (*sf)(int, char*);      /* server side authentication */
} authmethod[] = {
       { "p9",         p9auth,         srvp9auth,},
       { "netkey",     netkeyauth,     netkeysrvauth,},
       { "none",       noauth,         srvnoauth,},
       { nil,  nil}
};
AuthMethod *am = authmethod;    /* default is p9 */

int setam(char*);

char    *aan = "/bin/aan";
char    *anstring = "tcp!*!0";
char    *filterp = nil;

int filter(int fd, char *host);

void
usage(void)
{
       fprint(2, "usage: cpu [-p] [-h system] [-u user] [-a authmethod] "
               "[-e 'crypt hash'] [-k keypattern] [-P patternfile] "
               "[-c cmd arg ...]\n");
       exits("usage");
}

/*
* reading /proc/pid/args yields either "name args" or "name [display args]",
* so return only args or display args.
*/
static char *
procgetname(void)
{
       int fd, n;
       char *lp, *rp;
       char buf[256];

       snprint(buf, sizeof buf, "#p/%d/args", getpid());
       if((fd = open(buf, OREAD)) < 0)
               return strdup("");
       *buf = '\0';
       n = read(fd, buf, sizeof buf-1);
       close(fd);
       if (n >= 0)
               buf[n] = '\0';
       if ((lp = strchr(buf, '[')) == nil || (rp = strrchr(buf, ']')) == nil) {
               lp = strchr(buf, ' ');
               if (lp == nil)
                       return strdup("");
               else
                       return strdup(lp+1);
       }
       *rp = '\0';
       return strdup(lp+1);
}

void
main(int argc, char **argv)
{
       char dat[MaxStr], buf[MaxStr], cmd[MaxStr], *p, *s, *err;
       int ac, fd, ms, data;
       char *av[10];

       quotefmtinstall();
       origargs = procgetname();
       /* see if we should use a larger message size */
       fd = open("/dev/draw", OREAD);
       if(fd >= 0){
               ms = iounit(fd);
               if(msgsize < ms+IOHDRSZ)
                       msgsize = ms+IOHDRSZ;
               close(fd);
       }

       user = getuser();
       if(user == nil)
               fatal("can't read user name: %r");
       ARGBEGIN{
       case 'a':
               p = EARGF(usage());
               if(setam(p) < 0)
                       fatal("unknown auth method %s", p);
               break;
       case 'e':
               ealgs = EARGF(usage());
               if(*ealgs == 0 || strcmp(ealgs, "clear") == 0)
                       ealgs = nil;
               break;
       case 'd':
               dbg++;
               break;
       case 'f':
               /* ignored but accepted for compatibility */
               break;
       case 'n':
               /* must be specified before -R/-O */
               nflag++;
               break;
       case 'A':
               anstring = EARGF(usage());
               break;
       case 'R':                               /* From listen */
               remoteside();
               break;
       case 'h':
               system = EARGF(usage());
               break;
       case 'c':
               cflag++;
               s = cmd;
               *s++ = '!';
               *s = 0;
               while(p = ARGF())
                       s = seprint(s, cmd+sizeof(cmd), " %q", p);
               break;
       case 'k':
               keyspec = smprint("%s %s", keyspec, EARGF(usage()));
               break;
       case 'P':
               patternfile = EARGF(usage());
               break;
       case 'u':
               user = EARGF(usage());
               keyspec = smprint("%s user=%s", keyspec, user);
               break;
       case 'p':
               filterp = aan;
               break;
       default:
               usage();
       }ARGEND;


       if(argc != 0)
               usage();

       if(system == nil) {
               p = getenv("cpu");
               if(p == 0)
                       fatal("set $cpu");
               system = p;
       }

       if(err = rexcall(&data, system, srvname))
               fatal("%s: %s: %r", err, system);

       procsetname("%s", origargs);
       /* Tell the remote side the command to execute and where our working directory is */
       if(cflag)
               writestr(data, cmd, "command", 0);
       if(getwd(dat, sizeof(dat)) == 0)
               writestr(data, "NO", "dir", 0);
       else
               writestr(data, dat, "dir", 0);

       /* start up a process to pass along notes */
       lclnoteproc(data);

       /*
        *  Wait for the other end to execute and start our file service
        *  of /mnt/term
        */
       if(readstr(data, buf, sizeof(buf)) < 0)
               fatal("waiting for FS: %r");
       if(strncmp("FS", buf, 2) != 0) {
               print("remote cpu: %s", buf);
               exits(buf);
       }

       /* Begin serving the gnot namespace */
       close(0);
       dup(data, 0);
       close(data);

       sprint(buf, "%d", msgsize);
       ac = 0;
       av[ac++] = exportfs;
       av[ac++] = "-m";
       av[ac++] = buf;
       if(dbg)
               av[ac++] = "-d";
       if(patternfile != nil){
               av[ac++] = "-P";
               av[ac++] = patternfile;
       }
       av[ac] = nil;
       exec(exportfs, av);
       fatal("starting exportfs: %r");
}

void
fatal(char *fmt, ...)
{
       char buf[1024];
       va_list arg;

       va_start(arg, fmt);
       vsnprint(buf, sizeof(buf), fmt, arg);
       va_end(arg);
       fprint(2, "cpu: %s\n", buf);
       syslog(0, "cpu", "%s", buf);
       exits(buf);
}

char *negstr = "negotiating authentication method";

/* Invoked with stdin and stdout connected to the network connection */
void
remoteside(void)
{
       char user[MaxStr], buf[MaxStr], xdir[MaxStr], cmd[MaxStr];
       int i, n, fd, badchdir, gotcmd;

       rfork(RFENVG);
       putenv("service", "cpu");
       fd = 0;

       /* negotiate authentication mechanism */
       n = readstr(fd, cmd, sizeof(cmd));
       if(n < 0)
               fatal("authenticating: %r");
       filterp = nil;
       if(strcmp(cmd, "aan") == 0){
               filterp = aan;
               writestr(fd, "", nil, 1);
               n = readstr(fd, cmd, sizeof(cmd));
               if(n < 0)
                       fatal("authenticating: %r");
       }
       if(setamalg(cmd) < 0 || (nflag == 0 && am->sf == srvnoauth)) {
               writestr(fd, "unsupported auth method", nil, 0);
               fatal("bad auth method %s", cmd);
       } else
               writestr(fd, "", "", 1);

       if((fd = (*am->sf)(fd, user)) < 0)
               fatal("srvauth: %r");
       if((fd = filter(fd, nil)) < 0)
               fatal("filter: %r");
       if((fd = encryption(fd)) < 0)
               fatal("encrypt: %r");

       /* Now collect invoking cpu's current directory or possibly a command */
       gotcmd = 0;
       if(readstr(fd, xdir, sizeof(xdir)) < 0)
               fatal("dir/cmd: %r");
       if(xdir[0] == '!') {
               strcpy(cmd, &xdir[1]);
               gotcmd = 1;
               if(readstr(fd, xdir, sizeof(xdir)) < 0)
                       fatal("dir: %r");
       }

       /* Establish the new process at the current working directory of the gnot */
       badchdir = 0;
       if(strcmp(xdir, "NO") != 0)
               if(chdir(xdir) < 0)
                       badchdir = 1;

       /* Start the gnot serving its namespace */
       writestr(fd, "FS", "FS", 0);
       writestr(fd, "/", "exportfs dir", 0);

       n = read(fd, buf, sizeof(buf));
       if(n != 2 || buf[0] != 'O' || buf[1] != 'K')
               exits("remote tree");

       /* make sure buffers are big by doing fversion explicitly; pick a huge number; other side will trim */
       strcpy(buf, VERSION9P);
       if(fversion(fd, 64*1024, buf, sizeof buf) < 0)
               exits("fversion failed");
       if(mount(fd, -1, "/mnt/term", MCREATE|MREPL, "") == -1)
               exits("mount failed");

       close(fd);

       /* the remote noteproc uses the mount so it must follow it */
       rmtnoteproc();

       for(i = 0; i < 3; i++)
               close(i);

       if(open("/mnt/term/dev/cons", OREAD) != 0)
               exits("open stdin");
       if(open("/mnt/term/dev/cons", OWRITE) != 1)
               exits("open stdout");
       dup(1, 2);

       if(badchdir)
               print("cpu: failed to chdir to '%s'\n", xdir);

       if(gotcmd)
               execl("/bin/rc", "rc", "-lc", cmd, nil);
       else
               execl("/bin/rc", "rc", "-li", nil);
       fatal("exec shell: %r");
}

char*
rexcall(int *fd, char *host, char *service)
{
       char *na;
       char err[ERRMAX];
       char msg[MaxStr];
       int n;

       na = netmkaddr(host, 0, service);
       procsetname("dialing %s", na);
       if((*fd = dial(na, 0, 0, 0)) < 0)
               return "can't dial";

       /* negotiate aan filter extension */
       if(filterp == aan){
               writestr(*fd, "aan", "negotiating aan", 0);
               n = readstr(*fd, err, sizeof err);
               if(n < 0)
                       return "negotiating aan";
               if(*err){
                       errstr(err, sizeof err);
                       return negstr;
               }
       }

       /* negotiate authentication mechanism */
       if(ealgs != nil)
               snprint(msg, sizeof(msg), "%s %s", am->name, ealgs);
       else
               snprint(msg, sizeof(msg), "%s", am->name);
       procsetname("writing %s", msg);
       writestr(*fd, msg, negstr, 0);
       procsetname("awaiting auth method");
       n = readstr(*fd, err, sizeof err);
       if(n < 0)
               return negstr;
       if(*err){
               errstr(err, sizeof err);
               return negstr;
       }

       /* authenticate */
       procsetname("%s: auth via %s", origargs, am->name);
       if((*fd = (*am->cf)(*fd)) < 0)
               return "can't authenticate";
       if((*fd = filter(*fd, system)) < 0)
               return "can't filter";
       if((*fd = encryption(*fd)) < 0)
               return "can't encrypt";
       return nil;
}

void
writestr(int fd, char *str, char *thing, int ignore)
{
       int l, n;

       l = strlen(str);
       n = write(fd, str, l+1);
       if(!ignore && n < 0)
               fatal("writing network: %s: %r", thing);
}

int
readstr(int fd, char *str, int len)
{
       int n;

       while(len) {
               n = read(fd, str, 1);
               if(n < 0)
                       return -1;
               if(*str == '\0')
                       return 0;
               str++;
               len--;
       }
       return -1;
}

static int
readln(char *buf, int n)
{
       int i;
       char *p;

       n--;    /* room for \0 */
       p = buf;
       for(i=0; i<n; i++){
               if(read(0, p, 1) != 1)
                       break;
               if(*p == '\n' || *p == '\r')
                       break;
               p++;
       }
       *p = '\0';
       return p-buf;
}

/*
*  chown network connection
*/
static void
setnetuser(int fd, char *user)
{
       Dir nd;
       nulldir(&nd);
       nd.mode = 0660;
       nd.uid = user;
       dirfwstat(fd, &nd);
}

/*
*  user level challenge/response
*/
static int
netkeyauth(int fd)
{
       char chall[32];
       char resp[32];

       strecpy(chall, chall+sizeof chall, getuser());
       print("user[%s]: ", chall);
       if(readln(resp, sizeof(resp)) < 0)
               return -1;
       if(*resp != 0)
               strcpy(chall, resp);
       writestr(fd, chall, "challenge/response", 1);

       for(;;){
               if(readstr(fd, chall, sizeof chall) < 0)
                       break;
               if(*chall == 0)
                       return fd;
               print("challenge: %s\nresponse: ", chall);
               if(readln(resp, sizeof(resp)) < 0)
                       break;
               writestr(fd, resp, "challenge/response", 1);
       }
       return -1;
}

static int
netkeysrvauth(int fd, char *user)
{
       char response[32];
       Chalstate *ch;
       int tries;
       AuthInfo *ai;

       if(readstr(fd, user, MaxStr) < 0)
               return -1;

       ai = nil;
       ch = nil;
       for(tries = 0; tries < 10; tries++){
               if((ch = auth_challenge("proto=p9cr role=server user=%q", user)) == nil)
                       return -1;
               writestr(fd, ch->chal, "challenge", 1);
               if(readstr(fd, response, sizeof response) < 0)
                       return -1;
               ch->resp = response;
               ch->nresp = strlen(response);
               if((ai = auth_response(ch)) != nil)
                       break;
       }
       auth_freechal(ch);
       if(ai == nil)
               return -1;
       writestr(fd, "", "challenge", 1);
       if(auth_chuid(ai, 0) < 0)
               fatal("newns: %r");
       setnetuser(fd, ai->cuid);
       auth_freeAI(ai);
       return fd;
}

static int
clear(int fd)
{
       return fd;
}

static char sslsecret[2][21];

static int
sslencrypt(int fd)
{
       return pushssl(fd, ealgs, sslsecret[0], sslsecret[1], nil);
}

static void
mksecret(char *t, uchar *f)
{
       sprint(t, "%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux",
               f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7], f[8], f[9]);
}

static int
sslsetup(int fd, uchar *secret, int nsecret, int isclient)
{
       uchar key[16], digest[SHA1dlen];
       int i;

       if(ealgs == nil)
               return fd;

       if(nsecret < 8){
               werrstr("secret too small to ssl");
               return -1;
       }
       memmove(key+4, secret, 8);

       /* exchange random numbers */
       srand(truerand());

       if(isclient){
               for(i = 0; i < 4; i++)
                       key[i] = rand();
               if(write(fd, key, 4) != 4)
                       return -1;
               if(readn(fd, key+12, 4) != 4)
                       return -1;
       } else {
               for(i = 0; i < 4; i++)
                       key[i+12] = rand();
               if(readn(fd, key, 4) != 4)
                       return -1;
               if(write(fd, key+12, 4) != 4)
                       return -1;
       }

       /* scramble into two secrets */
       sha1(key, sizeof(key), digest, nil);
       mksecret(sslsecret[isclient == 0], digest);
       mksecret(sslsecret[isclient != 0], digest+10);

       encryption = sslencrypt;

       return fd;
}

/*
*  plan9 authentication followed by rc4 encryption
*/
static int
p9auth(int fd)
{
       AuthInfo *ai;

       ai = auth_proxy(fd, auth_getkey, "proto=p9any role=client %s", keyspec);
       if(ai == nil)
               return -1;
       fd = sslsetup(fd, ai->secret, ai->nsecret, 1);
       auth_freeAI(ai);
       return fd;
}

static int
noauth(int fd)
{
       ealgs = nil;
       return fd;
}

static int
srvnoauth(int fd, char *user)
{
       strecpy(user, user+MaxStr, getuser());
       ealgs = nil;
       newns(user, nil);
       return fd;
}

static int
srvp9auth(int fd, char *user)
{
       AuthInfo *ai;

       ai = auth_proxy(fd, nil, "proto=p9any role=server %s", keyspec);
       if(ai == nil)
               return -1;
       if(auth_chuid(ai, nil) < 0)
               fatal("newns: %r");
       setnetuser(fd, ai->cuid);
       snprint(user, MaxStr, "%s", ai->cuid);
       fd = sslsetup(fd, ai->secret, ai->nsecret, 0);
       auth_freeAI(ai);
       return fd;
}

/*
*  set authentication mechanism
*/
int
setam(char *name)
{
       for(am = authmethod; am->name != nil; am++)
               if(strcmp(am->name, name) == 0)
                       return 0;
       am = authmethod;
       return -1;
}

/*
*  set authentication mechanism and encryption/hash algs
*/
int
setamalg(char *s)
{
       ealgs = strchr(s, ' ');
       if(ealgs != nil)
               *ealgs++ = 0;
       return setam(s);
}

int
filter(int fd, char *host)
{
       char addr[128], buf[256], *s, *file, *argv[16];
       int p[2], lfd, flags, len, argc;

       if(filterp == nil)
               return fd;
       procsetname("filter %s", filterp);
       flags = RFNOWAIT|RFPROC|RFMEM|RFFDG|RFREND;
       if(host == nil){
               /* remote side */
               if(announce(anstring, addr) < 0)
                       fatal("filter: Cannot announce %s: %r", anstring);
               snprint(buf, sizeof(buf), "%s/local", addr);
               if((lfd = open(buf, OREAD)) < 0)
                       fatal("filter: Cannot open %s: %r", buf);
               if((len = read(lfd, buf, sizeof buf - 1)) < 0)
                       fatal("filter: Cannot read %s: %r", buf);
               close(lfd);
               buf[len] = 0;
               if(s = strchr(buf, '\n'))
                       len = s - buf;
               if(write(fd, buf, len) != len)
                       fatal("filter: cannot write port; %r");
       } else {
               /* client side */
               flags |= RFNOTEG;
               if((len = read(fd, buf, sizeof buf - 1)) < 0)
                       fatal("filter: cannot read port; %r");
               buf[len] = '\0';
               if((s = strrchr(buf, '!')) == nil)
                       fatal("filter: malformed remote port: %s", buf);
               strecpy(addr, addr+sizeof(addr), netmkaddr(host, "tcp", s+1));
               strecpy(strrchr(addr, '!'), addr+sizeof(addr), s);
       }

       snprint(buf, sizeof(buf), "%s", filterp);
       if((argc = tokenize(buf, argv, nelem(argv)-3)) <= 0)
               fatal("filter: empty command");
       if(host)
               argv[argc++] = "-c";
       argv[argc++] = addr;
       argv[argc] = nil;
       file = argv[0];
       if(s = strrchr(argv[0], '/'))
               argv[0] = s+1;

       if(pipe(p) < 0)
               fatal("filter: pipe; %r");

       switch(rfork(flags)) {
       case -1:
               fatal("filter: rfork; %r\n");
       case 0:
               if (dup(p[0], 1) < 0)
                       fatal("filter: Cannot dup to 1; %r");
               if (dup(p[0], 0) < 0)
                       fatal("filter: Cannot dup to 0; %r");
               close(p[0]);
               close(p[1]);
               exec(file, argv);
               fatal("filter: exec; %r");
       default:
               close(fd);
               close(p[0]);
       }
       return p[1];
}

char *rmtnotefile = "/mnt/term/dev/cpunote";

/*
*  loop reading /mnt/term/dev/note looking for notes.
*  The child returns to start the shell.
*/
void
rmtnoteproc(void)
{
       int n, fd, pid, notepid;
       char buf[256];

       /* new proc returns to start shell */
       pid = rfork(RFPROC|RFFDG|RFNOTEG|RFNAMEG|RFMEM);
       switch(pid){
       case -1:
               syslog(0, "cpu", "cpu -R: can't start noteproc: %r");
               return;
       case 0:
               return;
       }

       /* new proc reads notes from other side and posts them to shell */
       switch(notepid = rfork(RFPROC|RFFDG|RFMEM)){
       case -1:
               syslog(0, "cpu", "cpu -R: can't start wait proc: %r");
               _exits(0);
       case 0:
               fd = open(rmtnotefile, OREAD);
               if(fd < 0)
                       _exits(0);

               for(;;){
                       n = read(fd, buf, sizeof(buf)-1);
                       if(n <= 0){
                               postnote(PNGROUP, pid, "hangup");
                               _exits(0);
                       }
                       buf[n] = 0;
                       postnote(PNGROUP, pid, buf);
               }
       }

       /* original proc waits for shell proc to die and kills note proc */
       for(;;){
               n = waitpid();
               if(n < 0 || n == pid)
                       break;
       }
       postnote(PNPROC, notepid, "kill");
       _exits(0);
}

enum
{
       Qdir,
       Qcpunote,

       Nfid = 32,
};

struct {
       char    *name;
       Qid     qid;
       ulong   perm;
} fstab[] =
{
       [Qdir]          { ".",          {Qdir, 0, QTDIR},       DMDIR|0555      },
       [Qcpunote]      { "cpunote",    {Qcpunote, 0},          0444            },
};

typedef struct Note Note;
struct Note
{
       Note *next;
       char msg[ERRMAX];
};

typedef struct Request Request;
struct Request
{
       Request *next;
       Fcall f;
};

typedef struct Fid Fid;
struct Fid
{
       int     fid;
       int     file;
       int     omode;
};
Fid fids[Nfid];

struct {
       Lock;
       Note *nfirst, *nlast;
       Request *rfirst, *rlast;
} nfs;

int
fsreply(int fd, Fcall *f)
{
       uchar buf[IOHDRSZ+Maxfdata];
       int n;

       if(dbg)
               fprint(2, "notefs: <-%F\n", f);
       n = convS2M(f, buf, sizeof buf);
       if(n > 0){
               if(write(fd, buf, n) != n){
                       close(fd);
                       return -1;
               }
       }
       return 0;
}

/* match a note read request with a note, reply to the request */
int
kick(int fd)
{
       Request *rp;
       Note *np;
       int rv;

       for(;;){
               lock(&nfs);
               rp = nfs.rfirst;
               np = nfs.nfirst;
               if(rp == nil || np == nil){
                       unlock(&nfs);
                       break;
               }
               nfs.rfirst = rp->next;
               nfs.nfirst = np->next;
               unlock(&nfs);

               rp->f.type = Rread;
               rp->f.count = strlen(np->msg);
               rp->f.data = np->msg;
               rv = fsreply(fd, &rp->f);
               free(rp);
               free(np);
               if(rv < 0)
                       return -1;
       }
       return 0;
}

void
flushreq(int tag)
{
       Request **l, *rp;

       lock(&nfs);
       for(l = &nfs.rfirst; *l != nil; l = &(*l)->next){
               rp = *l;
               if(rp->f.tag == tag){
                       *l = rp->next;
                       unlock(&nfs);
                       free(rp);
                       return;
               }
       }
       unlock(&nfs);
}

Fid*
getfid(int fid)
{
       int i, freefid;

       freefid = -1;
       for(i = 0; i < Nfid; i++){
               if(freefid < 0 && fids[i].file < 0)
                       freefid = i;
               if(fids[i].fid == fid)
                       return &fids[i];
       }
       if(freefid >= 0){
               fids[freefid].fid = fid;
               return &fids[freefid];
       }
       return nil;
}

int
fsstat(int fd, Fid *fid, Fcall *f)
{
       Dir d;
       uchar statbuf[256];

       memset(&d, 0, sizeof(d));
       d.name = fstab[fid->file].name;
       d.uid = user;
       d.gid = user;
       d.muid = user;
       d.qid = fstab[fid->file].qid;
       d.mode = fstab[fid->file].perm;
       d.atime = d.mtime = time(0);
       f->stat = statbuf;
       f->nstat = convD2M(&d, statbuf, sizeof statbuf);
       return fsreply(fd, f);
}

int
fsread(int fd, Fid *fid, Fcall *f)
{
       Dir d;
       uchar buf[256];
       Request *rp;

       switch(fid->file){
       default:
               return -1;
       case Qdir:
               if(f->offset == 0 && f->count >0){
                       memset(&d, 0, sizeof(d));
                       d.name = fstab[Qcpunote].name;
                       d.uid = user;
                       d.gid = user;
                       d.muid = user;
                       d.qid = fstab[Qcpunote].qid;
                       d.mode = fstab[Qcpunote].perm;
                       d.atime = d.mtime = time(0);
                       f->count = convD2M(&d, buf, sizeof buf);
                       f->data = (char*)buf;
               } else
                       f->count = 0;
               return fsreply(fd, f);
       case Qcpunote:
               rp = mallocz(sizeof(*rp), 1);
               if(rp == nil)
                       return -1;
               rp->f = *f;
               lock(&nfs);
               if(nfs.rfirst == nil)
                       nfs.rfirst = rp;
               else
                       nfs.rlast->next = rp;
               nfs.rlast = rp;
               unlock(&nfs);
               return kick(fd);;
       }
}

char Eperm[] = "permission denied";
char Enofile[] = "out of files";
char Enotdir[] = "not a directory";

void
notefs(int fd)
{
       uchar buf[IOHDRSZ+Maxfdata];
       int i, n, ncpunote;
       Fcall f;
       Qid wqid[MAXWELEM];
       Fid *fid, *nfid;
       int doreply;

       rfork(RFNOTEG);
       fmtinstall('F', fcallfmt);

       for(n = 0; n < Nfid; n++){
               fids[n].file = -1;
               fids[n].omode = -1;
       }

       ncpunote = 0;
       for(;;){
               n = read9pmsg(fd, buf, sizeof(buf));
               if(n <= 0 || convM2S(buf, n, &f) != n)
                       break;
               if(dbg)
                       fprint(2, "notefs: ->%F\n", &f);
               doreply = 1;
               fid = getfid(f.fid);
               if(fid == nil){
nofids:
                       f.type = Rerror;
                       f.ename = Enofile;
                       fsreply(fd, &f);
                       continue;
               }
               switch(f.type++){
               default:
                       f.type = Rerror;
                       f.ename = "unknown type";
                       break;
               case Tflush:
                       flushreq(f.oldtag);
                       break;
               case Tversion:
                       if(f.msize > IOHDRSZ+Maxfdata)
                               f.msize = IOHDRSZ+Maxfdata;
                       break;
               case Tauth:
                       f.type = Rerror;
                       f.ename = "authentication not required";
                       break;
               case Tattach:
                       f.qid = fstab[Qdir].qid;
                       fid->file = Qdir;
                       break;
               case Twalk:
                       nfid = nil;
                       if(f.newfid != f.fid){
                               nfid = getfid(f.newfid);
                               if(nfid == nil)
                                       goto nofids;
                               nfid->file = fid->file;
                               fid = nfid;
                       }
                       for(i=0; i<f.nwname && i<MAXWELEM; i++){
                               if(fid->file != Qdir){
                                       f.type = Rerror;
                                       f.ename = Enotdir;
                                       break;
                               }
                               if(strcmp(f.wname[i], "..") == 0){
                                       wqid[i] = fstab[Qdir].qid;
                                       continue;
                               }
                               if(strcmp(f.wname[i], "cpunote") != 0){
                                       if(i == 0){
                                               f.type = Rerror;
                                               f.ename = "file does not exist";
                                       }
                                       break;
                               }
                               fid->file = Qcpunote;
                               wqid[i] = fstab[Qcpunote].qid;
                       }
                       if(nfid != nil && (f.type == Rerror || i < f.nwname))
                               nfid ->file = -1;
                       if(f.type != Rerror){
                               f.nwqid = i;
                               for(i=0; i<f.nwqid; i++)
                                       f.wqid[i] = wqid[i];
                       }
                       break;
               case Topen:
                       if(f.mode != OREAD){
                               f.type = Rerror;
                               f.ename = Eperm;
                               break;
                       }
                       fid->omode = f.mode;
                       if(fid->file == Qcpunote)
                               ncpunote++;
                       f.qid = fstab[fid->file].qid;
                       f.iounit = 0;
                       break;
               case Tread:
                       if(fsread(fd, fid, &f) < 0)
                               goto err;
                       doreply = 0;
                       break;
               case Tclunk:
                       if(fid->omode != -1 && fid->file == Qcpunote){
                               ncpunote--;
                               if(ncpunote == 0)       /* remote side is done */
                                       goto err;
                       }
                       fid->file = -1;
                       fid->omode = -1;
                       break;
               case Tstat:
                       if(fsstat(fd, fid, &f) < 0)
                               goto err;
                       doreply = 0;
                       break;
               case Tcreate:
               case Twrite:
               case Tremove:
               case Twstat:
                       f.type = Rerror;
                       f.ename = Eperm;
                       break;
               }
               if(doreply)
                       if(fsreply(fd, &f) < 0)
                               break;
       }
err:
       if(dbg)
               fprint(2, "notefs exiting: %r\n");
       werrstr("success");
       postnote(PNGROUP, exportpid, "kill");
       if(dbg)
               fprint(2, "postnote PNGROUP %d: %r\n", exportpid);
       close(fd);
}

char    notebuf[ERRMAX];

void
catcher(void*, char *text)
{
       int n;

       n = strlen(text);
       if(n >= sizeof(notebuf))
               n = sizeof(notebuf)-1;
       memmove(notebuf, text, n);
       notebuf[n] = '\0';
       noted(NCONT);
}

/*
*  mount in /dev a note file for the remote side to read.
*/
void
lclnoteproc(int netfd)
{
       Waitmsg *w;
       Note *np;
       int pfd[2];
       int pid;

       if(pipe(pfd) < 0){
               fprint(2, "cpu: can't start note proc: pipe: %r\n");
               return;
       }

       /* new proc mounts and returns to start exportfs */
       switch(pid = rfork(RFPROC|RFNAMEG|RFFDG|RFMEM)){
       default:
               exportpid = pid;
               break;
       case -1:
               fprint(2, "cpu: can't start note proc: rfork: %r\n");
               return;
       case 0:
               close(pfd[0]);
               if(mount(pfd[1], -1, "/dev", MBEFORE, "") == -1)
                       fprint(2, "cpu: can't mount note proc: %r\n");
               close(pfd[1]);
               return;
       }

       close(netfd);
       close(pfd[1]);

       /* new proc listens for note file system rpc's */
       switch(rfork(RFPROC|RFNAMEG|RFMEM)){
       case -1:
               fprint(2, "cpu: can't start note proc: rfork1: %r\n");
               _exits(0);
       case 0:
               notefs(pfd[0]);
               _exits(0);
       }

       /* original proc waits for notes */
       notify(catcher);
       w = nil;
       for(;;) {
               *notebuf = 0;
               free(w);
               w = wait();
               if(w == nil) {
                       if(*notebuf == 0)
                               break;
                       np = mallocz(sizeof(Note), 1);
                       if(np != nil){
                               strcpy(np->msg, notebuf);
                               lock(&nfs);
                               if(nfs.nfirst == nil)
                                       nfs.nfirst = np;
                               else
                                       nfs.nlast->next = np;
                               nfs.nlast = np;
                               unlock(&nfs);
                               kick(pfd[0]);
                       }
                       unlock(&nfs);
               } else if(w->pid == exportpid)
                       break;
       }

       if(w == nil)
               exits(nil);
       exits(0);
/*      exits(w->msg); */
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.