ref: 09ef6ef8ad39f846530675ecf70c59542fda8cd5
dir: /sys/src/cmd/sshnet.c/
/*
* SSH network file system.
* Presents remote TCP stack as /net-style file system.
*/
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ndb.h>
#include <thread.h>
#include <fcall.h>
#include <9p.h>
typedef struct Client Client;
typedef struct Msg Msg;
enum
{
Qroot,
Qcs,
Qtcp,
Qclone,
Qn,
Qctl,
Qdata,
Qlocal,
Qremote,
Qstatus,
Qlisten,
};
#define PATH(type, n) ((type)|((n)<<8))
#define TYPE(path) ((int)(path) & 0xFF)
#define NUM(path) ((uint)(path)>>8)
int sessionopen = 0;
Channel *sshmsgchan; /* chan(Msg*) */
Channel *fsreqchan; /* chan(Req*) */
Channel *fsreqwaitchan; /* chan(nil) */
Channel *fsclunkchan; /* chan(Fid*) */
Channel *fsclunkwaitchan; /* chan(nil) */
ulong time0;
enum
{
Closed,
Dialing,
Listen,
Established,
Teardown,
Finished,
};
char *statestr[] = {
"Closed",
"Dialing",
"Listen",
"Established",
"Teardown",
"Finished",
};
struct Client
{
int ref;
int state;
int num;
int servernum;
int rport, lport;
char *rhost;
char *lhost;
int sendpkt;
int sendwin;
int recvwin;
int recvacc;
int eof;
Req *wq;
Req **ewq;
Req *rq;
Req **erq;
Msg *mq;
Msg **emq;
};
enum {
MSG_GLOBAL_REQUEST = 80,
MSG_CHANNEL_OPEN = 90,
MSG_CHANNEL_OPEN_CONFIRMATION,
MSG_CHANNEL_OPEN_FAILURE,
MSG_CHANNEL_WINDOW_ADJUST,
MSG_CHANNEL_DATA,
MSG_CHANNEL_EXTENDED_DATA,
MSG_CHANNEL_EOF,
MSG_CHANNEL_CLOSE,
MSG_CHANNEL_REQUEST,
MSG_CHANNEL_SUCCESS,
MSG_CHANNEL_FAILURE,
Overhead = 256,
MaxPacket = (1<<15)-256, /* 32K is maxatomic for pipe */
WinPackets = 8,
SESSIONCHAN = 1<<24,
};
struct Msg
{
Msg *link;
uchar *rp;
uchar *wp;
uchar *ep;
uchar buf[MaxPacket + Overhead];
};
#define PUT4(p, u) (p)[0] = (u)>>24, (p)[1] = (u)>>16, (p)[2] = (u)>>8, (p)[3] = (u)
#define GET4(p) (u32int)(p)[3] | (u32int)(p)[2]<<8 | (u32int)(p)[1]<<16 | (u32int)(p)[0]<<24
int nclient;
Client **client;
char *mtpt, *service;
int sshfd;
int
vpack(uchar *p, int n, char *fmt, va_list a)
{
uchar *p0 = p, *e = p+n;
u32int u;
void *s;
int c;
for(;;){
switch(c = *fmt++){
case '\0':
return p - p0;
case '_':
if(++p > e) goto err;
break;
case '.':
*va_arg(a, void**) = p;
break;
case 'b':
if(p >= e) goto err;
*p++ = va_arg(a, int);
break;
case '[':
case 's':
s = va_arg(a, void*);
u = va_arg(a, int);
if(c == 's'){
if(p+4 > e) goto err;
PUT4(p, u), p += 4;
}
if(u > e-p) goto err;
memmove(p, s, u);
p += u;
break;
case 'u':
u = va_arg(a, int);
if(p+4 > e) goto err;
PUT4(p, u), p += 4;
break;
}
}
err:
return -1;
}
int
vunpack(uchar *p, int n, char *fmt, va_list a)
{
uchar *p0 = p, *e = p+n;
u32int u;
void *s;
for(;;){
switch(*fmt++){
case '\0':
return p - p0;
case '_':
if(++p > e) goto err;
break;
case '.':
*va_arg(a, void**) = p;
break;
case 'b':
if(p >= e) goto err;
*va_arg(a, int*) = *p++;
break;
case 's':
if(p+4 > e) goto err;
u = GET4(p), p += 4;
if(u > e-p) goto err;
*va_arg(a, void**) = p;
*va_arg(a, int*) = u;
p += u;
break;
case '[':
s = va_arg(a, void*);
u = va_arg(a, int);
if(u > e-p) goto err;
memmove(s, p, u);
p += u;
break;
case 'u':
if(p+4 > e) goto err;
u = GET4(p);
*va_arg(a, int*) = u;
p += 4;
break;
}
}
err:
return -1;
}
Msg*
allocmsg(void)
{
Msg *m;
m = emalloc9p(sizeof(Msg));
m->link = nil;
m->rp = m->wp = m->buf;
m->ep = m->rp + sizeof(m->buf);
return m;
}
Msg*
pack(Msg *m, char *fmt, ...)
{
va_list a;
int n;
if(m == nil)
m = allocmsg();
va_start(a, fmt);
n = vpack(m->wp, m->ep - m->wp, fmt, a);
if(n < 0)
sysfatal("pack faild");
m->wp += n;
va_end(a);
return m;
}
int
unpack(Msg *m, char *fmt, ...)
{
va_list a;
int n;
va_start(a, fmt);
n = vunpack(m->rp, m->wp - m->rp, fmt, a);
if(n > 0)
m->rp += n;
va_end(a);
return n;
}
void
sendmsg(Msg *m)
{
int n;
if(m == nil)
return;
n = m->wp - m->rp;
if(n > 0){
if(write(sshfd, m->rp, n) != n)
sysfatal("write to ssh failed: %r");
}
free(m);
}
int
newclient(void)
{
int i;
Client *c;
for(i=0; i<nclient; i++)
if(client[i]->ref==0 && client[i]->state == Closed)
return i;
if(nclient%16 == 0)
client = erealloc9p(client, (nclient+16)*sizeof(client[0]));
c = emalloc9p(sizeof(Client));
memset(c, 0, sizeof(*c));
c->num = nclient;
client[nclient++] = c;
return c->num;
}
Client*
getclient(int num)
{
if(num < 0 || num >= nclient)
return nil;
return client[num];
}
Client*
acceptclient(char *lhost, int lport, char *rhost, int rport)
{
Client *c, *nc;
int i;
for(i = 0; i < nclient; i++){
c = client[i];
if(c->state == Listen && c->lport == lport && c->wq != nil){
nc = client[newclient()];
nc->wq = c->wq;
c->wq = nc->wq->aux;
nc->wq->aux = nil;
free(nc->lhost);
nc->lhost = lhost;
nc->lport = lport;
free(nc->rhost);
nc->rhost = rhost;
nc->rport = rport;
return nc;
}
}
return nil;
}
void
adjustwin(Client *c, int len)
{
c->recvacc += len;
if(c->recvacc >= MaxPacket*WinPackets/2 || c->recvwin < MaxPacket){
sendmsg(pack(nil, "buu", MSG_CHANNEL_WINDOW_ADJUST, c->servernum, c->recvacc));
c->recvacc = 0;
}
c->recvwin += len;
}
void
senddata(Client *c, void *data, int len)
{
sendmsg(pack(nil, "bus", MSG_CHANNEL_DATA, c->servernum, (char*)data, len));
c->sendwin -= len;
}
void
queuerreq(Client *c, Req *r)
{
if(c->rq==nil)
c->erq = &c->rq;
*c->erq = r;
r->aux = nil;
c->erq = (Req**)&r->aux;
}
void
queuermsg(Client *c, Msg *m)
{
if(c->mq==nil)
c->emq = &c->mq;
*c->emq = m;
m->link = nil;
c->emq = (Msg**)&m->link;
}
void
matchrmsgs(Client *c)
{
Req *r;
Msg *m;
int n, rm;
while((r = c->rq) != nil && (m = c->mq) != nil){
c->rq = r->aux;
r->aux = nil;
rm = 0;
n = r->ifcall.count;
if(n >= m->wp - m->rp){
n = m->wp - m->rp;
c->mq = m->link;
rm = 1;
}
memmove(r->ofcall.data, m->rp, n);
if(rm)
free(m);
else
m->rp += n;
r->ofcall.count = n;
respond(r, nil);
adjustwin(c, n);
}
if(c->eof){
while((r = c->rq) != nil){
c->rq = r->aux;
r->aux = nil;
r->ofcall.count = 0;
respond(r, nil);
}
}
}
void
queuewreq(Client *c, Req *r)
{
if(c->wq==nil)
c->ewq = &c->wq;
*c->ewq = r;
r->aux = nil;
c->ewq = (Req**)&r->aux;
}
void
procwreqs(Client *c)
{
Req *r;
int n;
while((r = c->wq) != nil && (n = c->sendwin) > 0){
if(n > c->sendpkt)
n = c->sendpkt;
if(r->ifcall.count > n){
senddata(c, r->ifcall.data, n);
r->ifcall.count -= n;
memmove(r->ifcall.data, (char*)r->ifcall.data + n, r->ifcall.count);
continue;
}
c->wq = (Req*)r->aux;
r->aux = nil;
senddata(c, r->ifcall.data, r->ifcall.count);
r->ofcall.count = r->ifcall.count;
respond(r, nil);
}
}
Req*
findreq(Client *c, Req *r)
{
Req **l;
for(l=&c->rq; *l; l=(Req**)&(*l)->aux){
if(*l == r){
*l = r->aux;
if(*l == nil)
c->erq = l;
return r;
}
}
for(l=&c->wq; *l; l=(Req**)&(*l)->aux){
if(*l == r){
*l = r->aux;
if(*l == nil)
c->ewq = l;
return r;
}
}
return nil;
}
void
hangupclient(Client *c, char *err)
{
Req *r;
c->eof = 1;
c->recvwin = 0;
c->sendwin = 0;
while((r = c->wq) != nil){
c->wq = r->aux;
r->aux = nil;
respond(r, err);
}
matchrmsgs(c);
}
void
teardownclient(Client *c)
{
c->state = Teardown;
hangupclient(c, "i/o on hungup channel");
sendmsg(pack(nil, "bu", MSG_CHANNEL_CLOSE, c->servernum));
}
void
closeclient(Client *c)
{
Msg *m;
if(--c->ref)
return;
switch(c->state){
case Established:
teardownclient(c);
break;
case Finished:
c->state = Closed;
sendmsg(pack(nil, "bu", MSG_CHANNEL_CLOSE, c->servernum));
break;
case Listen:
c->state = Closed;
sendmsg(pack(nil, "bsbsu", MSG_GLOBAL_REQUEST,
"cancel-tcpip-forward", 20,
0,
c->lhost, strlen(c->lhost),
c->lport));
break;
}
while((m = c->mq) != nil){
c->mq = m->link;
free(m);
}
}
void
sshreadproc(void*)
{
Msg *m;
int n;
for(;;){
m = allocmsg();
n = read(sshfd, m->rp, m->ep - m->rp);
if(n <= 0)
sysfatal("eof on ssh connection");
m->wp += n;
sendp(sshmsgchan, m);
}
}
typedef struct Tab Tab;
struct Tab
{
char *name;
ulong mode;
};
Tab tab[] =
{
"/", DMDIR|0555,
"cs", 0666,
"tcp", DMDIR|0555,
"clone", 0666,
nil, DMDIR|0555,
"ctl", 0666,
"data", 0666,
"local", 0444,
"remote", 0444,
"status", 0444,
"listen", 0666,
};
static void
fillstat(Dir *d, uvlong path)
{
Tab *t;
memset(d, 0, sizeof(*d));
d->uid = estrdup9p("ssh");
d->gid = estrdup9p("ssh");
d->qid.path = path;
d->atime = d->mtime = time0;
t = &tab[TYPE(path)];
if(t->name)
d->name = estrdup9p(t->name);
else{
d->name = smprint("%ud", NUM(path));
if(d->name == nil)
sysfatal("out of memory");
}
d->qid.type = t->mode>>24;
d->mode = t->mode;
}
static void
fsattach(Req *r)
{
if(r->ifcall.aname && r->ifcall.aname[0]){
respond(r, "invalid attach specifier");
return;
}
r->fid->qid.path = PATH(Qroot, 0);
r->fid->qid.type = QTDIR;
r->fid->qid.vers = 0;
r->ofcall.qid = r->fid->qid;
respond(r, nil);
}
static void
fsstat(Req *r)
{
fillstat(&r->d, r->fid->qid.path);
respond(r, nil);
}
static int
rootgen(int i, Dir *d, void*)
{
i += Qroot+1;
if(i <= Qtcp){
fillstat(d, i);
return 0;
}
return -1;
}
static int
tcpgen(int i, Dir *d, void*)
{
i += Qtcp+1;
if(i < Qn){
fillstat(d, i);
return 0;
}
i -= Qn;
if(i < nclient){
fillstat(d, PATH(Qn, i));
return 0;
}
return -1;
}
static int
clientgen(int i, Dir *d, void *aux)
{
Client *c;
c = aux;
i += Qn+1;
if(i <= Qstatus){
fillstat(d, PATH(i, c->num));
return 0;
}
return -1;
}
static char*
fswalk1(Fid *fid, char *name, Qid *qid)
{
int i, n;
char buf[32];
ulong path;
path = fid->qid.path;
if(!(fid->qid.type&QTDIR))
return "walk in non-directory";
if(strcmp(name, "..") == 0){
switch(TYPE(path)){
case Qn:
qid->path = PATH(Qtcp, NUM(path));
qid->type = tab[Qtcp].mode>>24;
return nil;
case Qtcp:
qid->path = PATH(Qroot, 0);
qid->type = tab[Qroot].mode>>24;
return nil;
case Qroot:
return nil;
default:
return "bug in fswalk1";
}
}
i = TYPE(path)+1;
for(; i<nelem(tab); i++){
if(i==Qn){
n = atoi(name);
snprint(buf, sizeof buf, "%d", n);
if(n < nclient && strcmp(buf, name) == 0){
qid->path = PATH(i, n);
qid->type = tab[i].mode>>24;
return nil;
}
break;
}
if(strcmp(name, tab[i].name) == 0){
qid->path = PATH(i, NUM(path));
qid->type = tab[i].mode>>24;
return nil;
}
if(tab[i].mode&DMDIR)
break;
}
return "directory entry not found";
}
typedef struct Cs Cs;
struct Cs
{
char *resp;
int isnew;
};
static int
ndbfindport(char *p)
{
char *s, *port;
int n;
static Ndb *db;
if(*p == '\0')
return -1;
n = strtol(p, &s, 0);
if(*s == '\0')
return n;
if(db == nil){
db = ndbopen("/lib/ndb/common");
if(db == nil)
return -1;
}
port = ndbgetvalue(db, nil, "tcp", p, "port", nil);
if(port == nil)
return -1;
n = atoi(port);
free(port);
return n;
}
static void
csread(Req *r)
{
Cs *cs;
cs = r->fid->aux;
if(cs->resp==nil){
respond(r, "cs read without write");
return;
}
if(r->ifcall.offset==0){
if(!cs->isnew){
r->ofcall.count = 0;
respond(r, nil);
return;
}
cs->isnew = 0;
}
readstr(r, cs->resp);
respond(r, nil);
}
static void
cswrite(Req *r)
{
int port, nf;
char err[ERRMAX], *f[4], *s, *ns;
Cs *cs;
cs = r->fid->aux;
s = emalloc9p(r->ifcall.count+1);
memmove(s, r->ifcall.data, r->ifcall.count);
s[r->ifcall.count] = '\0';
nf = getfields(s, f, nelem(f), 0, "!");
if(nf != 3){
free(s);
respond(r, "can't translate");
return;
}
if(strcmp(f[0], "tcp") != 0 && strcmp(f[0], "net") != 0){
free(s);
respond(r, "unknown protocol");
return;
}
port = ndbfindport(f[2]);
if(port < 0){
free(s);
respond(r, "no translation found");
return;
}
ns = smprint("%s/tcp/clone %s!%d", mtpt, f[1], port);
if(ns == nil){
free(s);
rerrstr(err, sizeof err);
respond(r, err);
return;
}
free(s);
free(cs->resp);
cs->resp = ns;
cs->isnew = 1;
r->ofcall.count = r->ifcall.count;
respond(r, nil);
}
static void
ctlread(Req *r, Client *c)
{
char buf[32];
sprint(buf, "%d", c->num);
readstr(r, buf);
respond(r, nil);
}
static void
ctlwrite(Req *r, Client *c)
{
char *f[3], *s;
int nf, port;
s = emalloc9p(r->ifcall.count+1);
r->ofcall.count = r->ifcall.count;
memmove(s, r->ifcall.data, r->ifcall.count);
s[r->ifcall.count] = '\0';
nf = tokenize(s, f, 3);
if(nf == 0){
free(s);
respond(r, nil);
return;
}
if(strcmp(f[0], "hangup") == 0){
if(c->state != Established)
goto Badarg;
if(nf != 1)
goto Badarg;
teardownclient(c);
respond(r, nil);
}else if(strcmp(f[0], "connect") == 0){
if(nf != 2 || c->state != Closed)
goto Badarg;
if(getfields(f[1], f, nelem(f), 0, "!") != 2)
goto Badarg;
if((port = ndbfindport(f[1])) < 0)
goto Badarg;
free(c->lhost);
c->lhost = estrdup9p("::");
c->lport = 0;
free(c->rhost);
c->rhost = estrdup9p(f[0]);
c->rport = port;
c->recvwin = WinPackets*MaxPacket;
c->recvacc = 0;
c->state = Dialing;
queuewreq(c, r);
sendmsg(pack(nil, "bsuuususu", MSG_CHANNEL_OPEN,
"direct-tcpip", 12,
c->num, c->recvwin, MaxPacket,
c->rhost, strlen(c->rhost), c->rport,
c->lhost, strlen(c->lhost), c->lport));
}else if(strcmp(f[0], "announce") == 0){
if(nf != 2 || c->state != Closed)
goto Badarg;
if(getfields(f[1], f, nelem(f), 0, "!") != 2)
goto Badarg;
if((port = ndbfindport(f[1])) < 0)
goto Badarg;
if(strcmp(f[0], "*") == 0)
f[0] = "";
free(c->lhost);
c->lhost = estrdup9p(f[0]);
c->lport = port;
free(c->rhost);
c->rhost = estrdup9p("::");
c->rport = 0;
c->state = Listen;
sendmsg(pack(nil, "bsbsu", MSG_GLOBAL_REQUEST,
"tcpip-forward", 13, 0,
c->lhost, strlen(c->lhost), c->lport));
respond(r, nil);
}else{
Badarg:
respond(r, "bad or inappropriate tcp control message");
}
free(s);
}
static void
dataread(Req *r, Client *c)
{
if(c->state < Established){
respond(r, "not connected");
return;
}
queuerreq(c, r);
matchrmsgs(c);
}
static void
datawrite(Req *r, Client *c)
{
if(c->state != Established){
respond(r, "not connected");
return;
}
if(r->ifcall.count == 0){
r->ofcall.count = r->ifcall.count;
respond(r, nil);
return;
}
queuewreq(c, r);
procwreqs(c);
}
static void
localread(Req *r, Client *c)
{
char buf[128], *s;
s = c->lhost;
if(s == nil)
s = "::";
else if(*s == 0)
s = "*";
snprint(buf, sizeof buf, "%s!%d\n", s, c->lport);
readstr(r, buf);
respond(r, nil);
}
static void
remoteread(Req *r, Client *c)
{
char buf[128], *s;
s = c->rhost;
if(s == nil)
s = "::";
snprint(buf, sizeof buf, "%s!%d\n", s, c->rport);
readstr(r, buf);
respond(r, nil);
}
static void
statusread(Req *r, Client *c)
{
char *s;
s = statestr[c->state];
readstr(r, s);
respond(r, nil);
}
static void
fsread(Req *r)
{
char e[ERRMAX];
ulong path;
path = r->fid->qid.path;
switch(TYPE(path)){
default:
snprint(e, sizeof e, "bug in fsread path=%lux", path);
respond(r, e);
break;
case Qroot:
dirread9p(r, rootgen, nil);
respond(r, nil);
break;
case Qcs:
csread(r);
break;
case Qtcp:
dirread9p(r, tcpgen, nil);
respond(r, nil);
break;
case Qn:
dirread9p(r, clientgen, client[NUM(path)]);
respond(r, nil);
break;
case Qctl:
ctlread(r, client[NUM(path)]);
break;
case Qdata:
dataread(r, client[NUM(path)]);
break;
case Qlocal:
localread(r, client[NUM(path)]);
break;
case Qremote:
remoteread(r, client[NUM(path)]);
break;
case Qstatus:
statusread(r, client[NUM(path)]);
break;
}
}
static void
fswrite(Req *r)
{
ulong path;
char e[ERRMAX];
path = r->fid->qid.path;
switch(TYPE(path)){
default:
snprint(e, sizeof e, "bug in fswrite path=%lux", path);
respond(r, e);
break;
case Qcs:
cswrite(r);
break;
case Qctl:
ctlwrite(r, client[NUM(path)]);
break;
case Qdata:
datawrite(r, client[NUM(path)]);
break;
}
}
static void
fsopen(Req *r)
{
static int need[4] = { 4, 2, 6, 1 };
ulong path;
int n;
Tab *t;
Cs *cs;
/*
* lib9p already handles the blatantly obvious.
* we just have to enforce the permissions we have set.
*/
path = r->fid->qid.path;
t = &tab[TYPE(path)];
n = need[r->ifcall.mode&3];
if((n&t->mode) != n){
respond(r, "permission denied");
return;
}
switch(TYPE(path)){
case Qcs:
cs = emalloc9p(sizeof(Cs));
r->fid->aux = cs;
respond(r, nil);
break;
case Qlisten:
if(client[NUM(path)]->state != Listen){
respond(r, "no address set");
break;
}
queuewreq(client[NUM(path)], r);
break;
case Qclone:
n = newclient();
path = PATH(Qctl, n);
r->fid->qid.path = path;
r->ofcall.qid.path = path;
if(chatty9p)
fprint(2, "open clone => path=%lux\n", path);
t = &tab[Qctl];
/* fall through */
default:
if(t-tab >= Qn)
client[NUM(path)]->ref++;
respond(r, nil);
break;
}
}
static void
fsflush(Req *r)
{
int i;
for(i=0; i<nclient; i++)
if(findreq(client[i], r->oldreq))
respond(r->oldreq, "interrupted");
respond(r, nil);
}
static void
handlemsg(Msg *m)
{
int chan, win, pkt, lport, rport, n, ln, rn;
char *s, *lhost, *rhost;
Client *c;
switch(m->rp[0]){
case MSG_CHANNEL_WINDOW_ADJUST:
if(unpack(m, "_uu", &chan, &n) < 0)
break;
c = getclient(chan);
if(c != nil && c->state == Established){
c->sendwin += n;
procwreqs(c);
}
break;
case MSG_CHANNEL_DATA:
if(unpack(m, "_us", &chan, &s, &n) < 0)
break;
c = getclient(chan);
if(c != nil && c->state == Established){
if(c->recvwin <= 0)
break;
c->recvwin -= n;
m->rp = (uchar*)s;
queuermsg(c, m);
matchrmsgs(c);
return;
}
break;
case MSG_CHANNEL_EOF:
if(unpack(m, "_u", &chan) < 0)
break;
c = getclient(chan);
if(c != nil && c->state == Established){
c->eof = 1;
c->recvwin = 0;
matchrmsgs(c);
}
break;
case MSG_CHANNEL_CLOSE:
if(unpack(m, "_u", &chan) < 0)
break;
c = getclient(chan);
if(c == nil)
break;
switch(c->state){
case Established:
c->state = Finished;
hangupclient(c, "connection closed");
break;
case Teardown:
c->state = Closed;
break;
}
break;
case MSG_CHANNEL_OPEN_CONFIRMATION:
if(unpack(m, "_uuuu", &chan, &n, &win, &pkt) < 0)
break;
if(chan == SESSIONCHAN){
sessionopen++;
break;
}
c = getclient(chan);
if(c == nil || c->state != Dialing)
break;
if(pkt <= 0 || pkt > MaxPacket)
pkt = MaxPacket;
c->eof = 0;
c->sendpkt = pkt;
c->sendwin = win;
c->servernum = n;
if(c->wq == nil){
teardownclient(c);
break;
}
respond(c->wq, nil);
c->wq = nil;
c->state = Established;
break;
case MSG_CHANNEL_OPEN_FAILURE:
if(unpack(m, "_u____s", &chan, &s, &n) < 0)
break;
s = smprint("%.*s", utfnlen(s, n), s);
if(chan == SESSIONCHAN){
sysfatal("ssh failed: %s", s);
break;
}
c = getclient(chan);
if(c != nil && c->state == Dialing){
c->state = Closed;
hangupclient(c, s);
}
free(s);
break;
case MSG_CHANNEL_OPEN:
if(unpack(m, "_suuususu", &s, &n, &chan,
&win, &pkt,
&lhost, &ln, &lport,
&rhost, &rn, &rport) < 0)
break;
if(n != 15 || strncmp(s, "forwarded-tcpip", 15) != 0){
n = 3, s = "unknown open type";
Reject:
sendmsg(pack(nil, "buus", MSG_CHANNEL_OPEN_FAILURE,
chan, n, s, strlen(s)));
break;
}
lhost = smprint("%.*s", utfnlen(lhost, ln), lhost);
rhost = smprint("%.*s", utfnlen(rhost, rn), rhost);
c = acceptclient(lhost, lport, rhost, rport);
if(c == nil){
free(lhost);
free(rhost);
n = 2, s = "connection refused";
goto Reject;
}
c->servernum = chan;
c->recvwin = WinPackets*MaxPacket;
c->recvacc = 0;
c->eof = 0;
c->sendpkt = pkt;
c->sendwin = win;
c->state = Established;
sendmsg(pack(nil, "buuuu", MSG_CHANNEL_OPEN_CONFIRMATION,
c->servernum, c->num, c->recvwin, MaxPacket));
c->ref++;
c->wq->fid->qid.path = PATH(Qctl, c->num);
c->wq->ofcall.qid.path = c->wq->fid->qid.path;
respond(c->wq, nil);
c->wq = nil;
break;
}
free(m);
}
void
fsnetproc(void*)
{
ulong path;
Alt a[4];
Cs *cs;
Fid *fid;
Req *r;
Msg *m;
threadsetname("fsthread");
a[0].op = CHANRCV;
a[0].c = fsclunkchan;
a[0].v = &fid;
a[1].op = CHANRCV;
a[1].c = fsreqchan;
a[1].v = &r;
a[2].op = CHANRCV;
a[2].c = sshmsgchan;
a[2].v = &m;
a[3].op = CHANEND;
for(;;){
switch(alt(a)){
case 0:
path = fid->qid.path;
switch(TYPE(path)){
case Qcs:
cs = fid->aux;
if(cs){
free(cs->resp);
free(cs);
}
break;
}
if(fid->omode != -1 && TYPE(path) >= Qn)
closeclient(client[NUM(path)]);
sendp(fsclunkwaitchan, nil);
break;
case 1:
switch(r->ifcall.type){
case Tattach:
fsattach(r);
break;
case Topen:
fsopen(r);
break;
case Tread:
fsread(r);
break;
case Twrite:
fswrite(r);
break;
case Tstat:
fsstat(r);
break;
case Tflush:
fsflush(r);
break;
default:
respond(r, "bug in fsthread");
break;
}
sendp(fsreqwaitchan, 0);
break;
case 2:
handlemsg(m);
break;
}
}
}
static void
fssend(Req *r)
{
sendp(fsreqchan, r);
recvp(fsreqwaitchan); /* avoids need to deal with spurious flushes */
}
static void
fsdestroyfid(Fid *fid)
{
sendp(fsclunkchan, fid);
recvp(fsclunkwaitchan);
}
static void
startup(Srv*)
{
proccreate(fsnetproc, nil, 8*1024);
}
void
takedown(Srv*)
{
threadexitsall("done");
}
Srv fs =
{
.attach= fssend,
.destroyfid= fsdestroyfid,
.walk1= fswalk1,
.open= fssend,
.read= fssend,
.write= fssend,
.stat= fssend,
.flush= fssend,
.start= startup,
.end= takedown,
};
int pfd[2];
int sshargc;
char **sshargv;
void
startssh(void *)
{
char *f;
close(pfd[0]);
dup(pfd[1], 0);
dup(pfd[1], 1);
close(pfd[1]);
if(strncmp(sshargv[0], "./", 2) != 0)
f = smprint("/bin/%s", sshargv[0]);
else
f = sshargv[0];
procexec(nil, f, sshargv);
sysfatal("exec: %r");
}
void
ssh(int argc, char *argv[])
{
Alt a[4];
Waitmsg *w;
Msg *m;
sshargc = argc + 2;
sshargv = emalloc9p(sizeof(char *) * (sshargc + 1));
sshargv[0] = "ssh";
sshargv[1] = "-X";
memcpy(sshargv + 2, argv, argc * sizeof(char *));
if(pipe(pfd) < 0)
sysfatal("pipe: %r");
sshfd = pfd[0];
procrfork(startssh, nil, 8*1024, RFFDG|RFNOTEG|RFNAMEG);
close(pfd[1]);
procrfork(sshreadproc, nil, 8*1024, RFFDG|RFNOTEG|RFNAMEG);
sendmsg(pack(nil, "bsuuu", MSG_CHANNEL_OPEN,
"session", 7,
SESSIONCHAN,
MaxPacket,
MaxPacket));
a[0].op = CHANRCV;
a[0].c = threadwaitchan();
a[0].v = &w;
a[1].op = CHANRCV;
a[1].c = sshmsgchan;
a[1].v = &m;
a[2].op = CHANEND;
while(!sessionopen){
switch(alt(a)){
case 0:
sysfatal("ssh failed: %s", w->msg);
case 1:
handlemsg(m);
}
}
}
void
usage(void)
{
fprint(2, "usage: sshnet [-m mtpt] [ssh options]\n");
exits("usage");
}
void
threadmain(int argc, char **argv)
{
fmtinstall('H', encodefmt);
mtpt = "/net";
service = nil;
ARGBEGIN{
case 'D':
chatty9p++;
break;
case 'm':
mtpt = EARGF(usage());
break;
case 's':
service = EARGF(usage());
break;
default:
usage();
}ARGEND
if(argc == 0)
usage();
time0 = time(0);
sshmsgchan = chancreate(sizeof(Msg*), 16);
fsreqchan = chancreate(sizeof(Req*), 0);
fsreqwaitchan = chancreate(sizeof(void*), 0);
fsclunkchan = chancreate(sizeof(Fid*), 0);
fsclunkwaitchan = chancreate(sizeof(void*), 0);
ssh(argc, argv);
threadpostmountsrv(&fs, service, mtpt, MREPL);
threadexits(nil);
}