int
authdial(char *netroot, char *dom)
{
char *p;
int rv;
if(dom == nil)
/* look for one relative to my machine */
return dial(netmkaddr("$auth", netroot, "ticket"), 0, 0, 0);
/* look up an auth server in an authentication domain */
p = csgetvalue(netroot, "authdom", dom, "auth", nil);
/* if that didn't work, just try the IP domain */
if(p == nil)
p = csgetvalue(netroot, "dom", dom, "auth", nil);
/*
* if that didn't work, try p9auth.$dom. this is very helpful if
* you can't edit /lib/ndb.
*/
if(p == nil)
p = smprint("p9auth.%s", dom);
if(p == nil){ /* should no longer ever happen */
werrstr("no auth server found for %s", dom);
return -1;
}
rv = dial(netmkaddr(p, netroot, "ticket"), 0, 0, 0);
free(p);
return rv;
}
int
_authdial(char *net, char *authdom)
{
int fd, vanilla;
vanilla = net==nil || strcmp(net, "/net")==0;
if(!vanilla || bindnetcs()>=0)
return authdial(net, authdom);
/*
* If we failed to mount /srv/cs, assume that
* we're still bootstrapping the system and dial
* the one auth server passed to us on the command line.
* In normal operation, it is important *not* to do this,
* because the bootstrap auth server is only good for
* a single auth domain.
*
* The ticket request code should really check the
* remote authentication domain too.
*/
/* use the auth server passed to us as an arg */
if(authaddr == nil)
return -1;
fd = dial(netmkaddr(authaddr, "il", "566"), 0, 0, 0);
if(fd >= 0)
return fd;
return dial(netmkaddr(authaddr, "tcp", "567"), 0, 0, 0);
}
/* Taken from imapdial, replaces tlsclient call with stunnel */
static int
smtpdial(char *server)
{
int p[2];
int fd[3];
char *tmp;
char *fpath;
if(pipe(p) < 0)
return -1;
fd[0] = dup(p[0], -1);
fd[1] = dup(p[0], -1);
fd[2] = dup(2, -1);
#ifdef PLAN9PORT
tmp = smprint("%s:587", server);
fpath = searchpath("stunnel3");
if (!fpath) {
werrstr("stunnel not found. it is required for tls support.");
return -1;
}
if(threadspawnl(fd, fpath, "stunnel", "-n", "smtp" , "-c", "-r", tmp, nil) < 0) {
#else
tmp = smprint("tcp!%s!587", server);
if(threadspawnl(fd, "/bin/tlsclient", "tlsclient", tmp, nil) < 0){
#endif
free(tmp);
close(p[0]);
close(p[1]);
close(fd[0]);
close(fd[1]);
close(fd[2]);
return -1;
}
free(tmp);
close(p[0]);
return p[1];
}
int
mxdial(char *addr, char *ddomain, char *gdomain)
{
int fd;
DS ds;
char err[Errlen];
addr = netmkaddr(addr, 0, "smtp");
dial_string_parse(addr, &ds);
/* try connecting to destination or any of it's mail routers */
fd = callmx(&ds, addr, ddomain);
/* try our mail gateway */
rerrstr(err, sizeof(err));
if(fd < 0 && gdomain && strstr(err, "can't translate") != 0)
fd = dial(netmkaddr(gdomain, 0, "smtp"), 0, 0, 0);
return fd;
}
char*
rexcall(int *fd, char *host, char *service)
{
char *na;
char dir[MaxStr];
char err[ERRMAX];
char msg[MaxStr];
int n;
na = netmkaddr(host, "tcp", "17010");
if((*fd = dial(na, 0, dir, 0)) < 0)
return "can't dial";
/* negotiate authentication mechanism */
if(ealgs != nil)
snprint(msg, sizeof(msg), "%s %s", am->name, ealgs);
else
snprint(msg, sizeof(msg), "%s", am->name);
writestr(*fd, msg, negstr, 0);
n = readstr(*fd, err, sizeof err);
if(n < 0)
return negstr;
if(*err){
werrstr(err);
return negstr;
}
/* authenticate */
*fd = (*am->cf)(*fd);
if(*fd < 0)
return "can't authenticate";
return 0;
}
VtSession *
vtDial(char *host, int canfail)
{
VtSession *z;
int fd;
char *na;
char e[ERRMAX];
if(host == nil)
host = getenv("venti");
if(host == nil)
host = "$venti";
if (host == nil) {
if (!canfail)
werrstr("no venti host set");
na = "";
fd = -1;
} else {
na = netmkaddr(host, 0, "venti");
fd = dial(na, 0, 0, 0);
}
if(fd < 0){
rerrstr(e, sizeof e);
if(!canfail){
vtSetError("venti dialstring %s: %s", na, e);
return nil;
}
}
z = vtClientAlloc();
if(fd < 0)
strcpy(z->fderror, e);
vtSetFd(z, fd);
return z;
}
int
authdial(char *net, char *dom)
{
int fd;
fd = dial(netmkaddr(authserver, "tcp", "567"), 0, 0, 0);
//print("authdial %d\n", fd);
return fd;
}
void
main(int argc, char* argv[])
{
char* srv = nil;
char* sname = nil;
char* addr = nil;
int fd;
int p[2];
ARGBEGIN{
case 'D':
debug = 1;
break;
case 'n':
addr = EARGF(usage());
break;
case 'v':
verbose = 1;
break;
case 's':
sname = EARGF(usage());
break;
default:
altspc = ARGC();
}ARGEND;
if (addr == nil){
if (argc < 1)
usage();
srv = *argv;
argc--;
}
if (argc > 0)
usage();
if (sname == nil)
sname = (addr != nil) ? addr : "trfs";
fmtinstall('D', dirfmt);
fmtinstall('M', dirmodefmt);
fmtinstall('F', fcallfmt);
if (addr == nil)
fd = open(srv, ORDWR);
else
fd = dial(netmkaddr(addr, "net", "9fs"), 0, 0, 0);
if (fd < 0 || pipe(p) < 0)
sysfatal("can't connect to server %s: %r\n", (addr?addr:srv));
if (postfd(sname, p[0]) < 0)
sysfatal("can't post srv: %r\n");
rfork(RFNOTEG);
switch(rfork(RFPROC|RFNOTEG)){
case 0:
service(p[1], fd, 2);
break;
case -1:
sysfatal("can't fork server: %r\n");
break;
}
exits(nil);
}
int
mxdial(char *addr, char *ddomain, char *gdomain)
{
int fd;
DS ds;
addr = netmkaddr(addr, 0, "smtp");
dial_string_parse(addr, &ds);
/* try connecting to destination or any of it's mail routers */
fd = callmx(&ds, addr, ddomain);
/* try our mail gateway */
if(fd < 0 && gdomain)
fd = dial(netmkaddr(gdomain, 0, "smtp"), 0, 0, 0);
return fd;
}
int
mxdial(char *addr, char *ddomain, char *gdomain)
{
int fd;
DS ds;
char err[Errlen];
addr = netmkaddr(addr, 0, "smtp");
dial_string_parse(addr, &ds);
/* try connecting to destination or any of it's mail routers */
fd = callmx(&ds, addr, ddomain);
/* try our mail gateway */
rerrstr(err, sizeof(err));
if(fd < 0 && gdomain && strstr(err, "can't translate") != 0)
fd = dial(netmkaddr(gdomain, 0, "smtp"), 0, 0, 0);
return fd;
}
int
secdial(void)
{
char *p, buf[80], *f[3];
int fd, nf;
p = secstore; /* take it from writehostowner, if set there */
if(*p == 0) /* else use the authserver */
p = "$auth";
if(bindnetcs() >= 0)
return dial(netmkaddr(p, "net", "secstore"), 0, 0, 0);
/* translate $auth ourselves.
* authaddr is something like il!host!566 or tcp!host!567.
* extract host, accounting for a change of format to something
* like il!host or tcp!host or host.
*/
if(strcmp(p, "$auth")==0){
if(authaddr == nil)
return -1;
safecpy(buf, authaddr, sizeof buf);
nf = getfields(buf, f, nelem(f), 0, "!");
switch(nf){
default:
return -1;
case 1:
p = f[0];
break;
case 2:
case 3:
p = f[1];
break;
}
}
fd = dial(netmkaddr(p, "tcp", "5356"), 0, 0, 0);
if(fd >= 0)
return fd;
return -1;
}
//
// dial and handshake with the imap server
//
static char*
imap4dial(Imap *imap)
{
char *err, *port;
int sfd;
TLSconn conn;
if(imap->fd >= 0) {
imap4cmd(imap, "noop");
if(isokay(imap4resp(imap)))
return nil;
close(imap->fd);
imap->fd = -1;
}
if(imap->mustssl)
port = "imaps";
else
port = "imap";
if((imap->fd = dial(netmkaddr(imap->host, "net", port), 0, 0, 0)) < 0)
return imaperrstr(imap->host, port);
if(imap->mustssl) {
sfd = starttls(imap, &conn);
if (sfd < 0) {
free(conn.cert);
return imaperrstr(imap->host, port);
}
if(imap->debug) {
char fn[128];
int fd;
snprint(fn, sizeof fn, "%s/ctl", conn.dir);
fd = open(fn, ORDWR);
if(fd < 0)
fprint(2, "opening ctl: %r\n");
if(fprint(fd, "debug") < 0)
fprint(2, "writing ctl: %r\n");
close(fd);
}
}
Binit(&imap->bin, imap->fd, OREAD);
Binit(&imap->bout, imap->fd, OWRITE);
if(err = imap4login(imap)) {
close(imap->fd);
return err;
}
return nil;
}
/* Network on fd1, mount driver on fd0 */
int
filter(int fd, char *cmd, char *host)
{
int p[2], len, argc;
char newport[256], buf[256], *s;
char *argv[16], *file, *pbuf;
if ((len = read(fd, newport, sizeof newport - 1)) < 0)
sysfatal("filter: cannot write port; %r");
newport[len] = '\0';
if ((s = strchr(newport, '!')) == nil)
sysfatal("filter: illegally formatted port %s", newport);
strecpy(buf, buf+sizeof buf, netmkaddr(host, "tcp", "0"));
pbuf = strrchr(buf, '!');
strecpy(pbuf, buf+sizeof buf, s);
if(debug)
fprint(2, "filter: remote port %s\n", newport);
argc = tokenize(cmd, argv, nelem(argv)-2);
if (argc == 0)
sysfatal("filter: empty command");
argv[argc++] = "-c";
argv[argc++] = buf;
argv[argc] = nil;
file = argv[0];
if (s = strrchr(argv[0], '/'))
argv[0] = s+1;
if(pipe(p) < 0)
sysfatal("pipe: %r");
switch(rfork(RFNOWAIT|RFPROC|RFFDG)) {
case -1:
sysfatal("rfork record module: %r");
case 0:
dup(p[0], 1);
dup(p[0], 0);
close(p[0]);
close(p[1]);
exec(file, argv);
sysfatal("exec record module: %r");
default:
close(fd);
close(p[0]);
}
return p[1];
}
/*
* connect to remote server, default network is "tcp/ip"
*/
void
hello(char *dest)
{
char *p;
char dir[Maxpath];
TLSconn conn;
Binit(&stdin, 0, OREAD); /* init for later use */
ctlfd = dial(netmkaddr(dest, "tcp", "ftp"), 0, dir, 0);
if(ctlfd < 0){
fprint(2, "can't dial %s: %r\n", dest);
exits("dialing");
}
Binit(&ctlin, ctlfd, OREAD);
/* remember network for the data connections */
p = strrchr(dir+1, '/');
if(p == 0)
fatal("wrong dial(2) linked with ftp");
*p = 0;
safecpy(net, dir, sizeof(net));
/* wait for hello from other side */
if(getreply(&ctlin, msg, sizeof(msg), 1) != Success)
fatal("bad hello");
if(strstr(msg, "Plan 9"))
os = Plan9;
if(usetls){
sendrequest("AUTH", "TLS");
if(getreply(&ctlin, msg, sizeof(msg), 1) != Success)
fatal("bad auth tls");
ctlfd = tlsClient(ctlfd, &conn);
if(ctlfd < 0)
fatal("starting tls: %r");
free(conn.cert);
Binit(&ctlin, ctlfd, OREAD);
sendrequest("PBSZ", "0");
if(getreply(&ctlin, msg, sizeof(msg), 1) != Success)
fatal("bad pbsz 0");
sendrequest("PROT", "P");
if(getreply(&ctlin, msg, sizeof(msg), 1) != Success)
fatal("bad prot p");
}
}
int
dialhttp(Biobuf *netbio)
{
int netfd;
netfd = dial(netmkaddr(host, net, port), 0, 0, 0);
if(netfd < 0)
sysfatal("dial: %r");
if(usetls)
netfd = dotls(netfd);
Binit(netbio, netfd, OREAD);
return netfd;
}
/*
* dial and return a data connection
*/
int
dodial(char *dest)
{
char *name;
int data;
char devdir[NETPATHLEN];
name = netmkaddr(dest, "tcp", "telnet");
data = dial(name, 0, devdir, 0);
if(data < 0)
fatal("%s: %r", name, 0);
fprint(2, "connected to %s on %s\n", name, devdir);
return data;
}
int
connect(char *system, char *tree, int oldserver)
{
char buf[ERRMAX], dir[128], *na;
int fd, n;
char *authp;
na = netmkaddr(system, 0, "exportfs");
procsetname("dial %s", na);
if((fd = dial(na, 0, dir, 0)) < 0)
sysfatal("can't dial %s: %r", system);
if(doauth){
if(oldserver)
authp = "p9sk2";
else
authp = "p9any";
procsetname("auth_proxy auth_getkey proto=%q role=client %s",
authp, keyspec);
ai = auth_proxy(fd, auth_getkey, "proto=%q role=client %s",
authp, keyspec);
if(ai == nil)
sysfatal("%r: %s", system);
}
if(!skiptree){
procsetname("writing tree name %s", tree);
n = write(fd, tree, strlen(tree));
if(n < 0)
sysfatal("can't write tree: %r");
strcpy(buf, "can't read tree");
procsetname("awaiting OK for %s", tree);
n = read(fd, buf, sizeof buf - 1);
if(n!=2 || buf[0]!='O' || buf[1]!='K'){
if (timedout)
sysfatal("timed out connecting to %s", na);
buf[sizeof buf - 1] = '\0';
sysfatal("bad remote tree: %s", buf);
}
}
if(oldserver)
return old9p(fd);
return fd;
}
int
call(char *host)
{
char *na, *p;
na = netmkaddr(host, 0, "rexexec");
p = utfrune(na, L'!');
if(!p)
return -1;
p = utfrune(p+1, L'!');
if(!p)
return -1;
if(strcmp(p, "!rexexec") != 0)
return -2;
return dial(na, 0, 0, 0);
}
/*
* 9fs
*/
int
connect9fs(char *addr)
{
char dir[256], *na;
int fd;
fprint(2, "connect9fs...");
na = netmkaddr(addr, 0, "9fs");
fprint(2, "dial %s...", na);
if((fd = dial(na, 0, dir, 0)) < 0)
return -1;
fprint(2, "dir %s...", dir);
// if(strstr(dir, "tcp"))
// fd = filter(fd);
return fd;
}
Session *
cifsdial(char *host, char *called, char *sysname)
{
int nbt, fd;
char *addr;
Session *s;
if(Debug)
fprint(2, "cifsdial: host=%s called=%s sysname=%s\n", host, called, sysname);
if((addr = netmkaddr(host, "tcp", "cifs")) == nil)
return nil;
nbt = 0;
if((fd = dial(addr, nil, nil, nil)) == -1){
nbt = 1;
if((fd = nbtdial(host, called, sysname)) == -1)
return nil;
}
s = emalloc9p(sizeof(Session));
memset(s, 0, sizeof(Session));
s->fd = fd;
s->nbt = nbt;
s->mtu = MTU;
s->pid = getpid();
s->mid = time(nil) ^ getpid();
s->uid = NO_UID;
s->seq = 0;
s->seqrun = 0;
s->secmode = SECMODE_SIGN_ENABLED; /* hope for the best */
s->flags2 = FL2_KNOWS_LONG_NAMES | FL2_HAS_LONG_NAMES | FL2_PAGEING_IO;
s->macidx = -1;
if(s->mtu > MTU)
s->mtu = MTU;
return s;
}
int
vtRedial(VtSession *z, char *host)
{
int fd;
char *na;
if(host == nil)
host = getenv("venti");
if(host == nil)
host = "$venti";
na = netmkaddr(host, 0, "venti");
fd = dial(na, 0, 0, 0);
if(fd < 0){
vtOSError();
return 0;
}
vtReset(z);
vtSetFd(z, fd);
return 1;
}
void
threadmain(int argc, char **argv)
{
char *cmd;
int i;
ARGBEGIN{
case 'A':
aname = EARGF(usage());
break;
case 'a':
addr = EARGF(usage());
if(strchr(addr, '!') == nil)
addr = netmkaddr(addr, "tcp", "9fs");
break;
case 'n':
nsmnt = nsmount;
fsmnt = fsmount;
break;
case 'D':
chatty9pclient = 1;
break;
default:
usage();
}ARGEND
signal(SIGINT, SIG_DFL);
if(argc < 1)
usage();
cmd = argv[0];
for(i=0; i<nelem(cmds); i++){
if(strcmp(cmds[i].s, cmd) == 0){
cmds[i].f(argc, argv);
threadexitsall(0);
}
}
usage();
}
/*
* exportfs
*/
int
connectexportfs(char *addr)
{
char buf[ERRMAX], dir[256], *na;
int fd, n;
char *tree;
AuthInfo *ai;
tree = "/";
na = netmkaddr(addr, 0, "exportfs");
if((fd = dial(na, 0, dir, 0)) < 0)
return -1;
ai = auth_proxy(fd, auth_getkey, "proto=p9any role=client");
if(ai == nil)
return -1;
n = write(fd, tree, strlen(tree));
if(n < 0){
close(fd);
return -1;
}
strcpy(buf, "can't read tree");
n = read(fd, buf, sizeof buf - 1);
if(n!=2 || buf[0]!='O' || buf[1]!='K'){
buf[sizeof buf - 1] = '\0';
werrstr("bad remote tree: %s\n", buf);
close(fd);
return -1;
}
// if(strstr(dir, "tcp"))
// fd = filter(fd);
if(oldsystem)
return old9p(fd);
return fd;
}
void
main(int argc, char *argv[])
{
int fd, cfd, r;
Modem *m;
char *addr;
m = &modems[0];
ARGBEGIN{
case 'v':
vflag = 1;
break;
default:
usage();
break;
}ARGEND
if(argc <= 1)
usage();
verbose("send: %s %s...", argv[0], argv[1]);
addr = netmkaddr(*argv, "telco", "fax!9600");
fd = dial(addr, 0, 0, &cfd);
if(fd < 0){
fprint(2, "faxsend: can't dial %s: %r\n", addr);
exits("Retry, can't dial");
}
initmodem(m, fd, cfd, 0, 0);
argc--; argv++;
r = faxsend(m, argc, argv);
if(r != Eok){
fprint(2, "faxsend: %s\n", m->error);
syslog(0, "fax", "failed %s %s: %s", argv[0], argv[1], m->error);
exits(m->error);
}
syslog(0, "fax", "success %s %s", argv[0], argv[1]);
exits(0);
}
char*
netmkvncaddr(char *inserver)
{
char *p, portstr[NETPATHLEN], *server;
int port;
server = strdup(inserver);
assert(server != nil);
port = 5900;
if(tls)
port = 35729;
if(p = strchr(server, ':')) {
*p++ = '\0';
port += atoi(p);
}
snprint(portstr, sizeof portstr, "%d", port);
p = netmkaddr(server, "tcp", portstr);
free(server);
return p;
}
//
// dial and handshake with pop server
//
static char*
pop3dial(Pop *pop)
{
char *err;
if((pop->fd = dial(netmkaddr(pop->host, "net", pop->needssl ? "pop3s" : "pop3"), 0, 0, 0)) < 0)
return geterrstr();
if(pop->needssl){
if((err = pop3pushtls(pop)) != nil)
return err;
}else{
Binit(&pop->bin, pop->fd, OREAD);
Binit(&pop->bout, pop->fd, OWRITE);
}
if(err = pop3login(pop)) {
close(pop->fd);
return err;
}
return nil;
}
char*
rexcall(int *fd, char *host, char *service)
{
char *na;
char dir[MaxStr];
char err[ERRMAX];
char msg[MaxStr];
int n;
na = netmkaddr(host, 0, service);
procsetname("dialing %s", na);
if((*fd = dial(na, 0, dir, 0)) < 0)
return "can't dial";
/* 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){
werrstr(err);
return negstr;
}
/* authenticate */
procsetname("%s: auth via %s", origargs, am->name);
*fd = (*am->cf)(*fd);
if(*fd < 0)
return "can't authenticate";
return 0;
}
int
main(int argc, char **argv)
{
int chpass = 0, pass_stdin = 0, pass_nvram = 0, rc;
int ngfile = 0, npfile = 0, nrfile = 0, Gflag[MAXFILES+1];
char *gfile[MAXFILES], *pfile[MAXFILES], *rfile[MAXFILES];
char *serve, *tcpserve, *user;
AuthConn *c;
serve = getenv("secstore");
if(serve == nil)
serve = "secstore";
user = getuser();
memset(Gflag, 0, sizeof Gflag);
fmtinstall('B', mpfmt);
fmtinstall('H', encodefmt);
ARGBEGIN{
case 'c':
chpass = 1;
break;
case 'G':
Gflag[ngfile]++;
/* fall through */
case 'g':
if(ngfile >= MAXFILES)
exits("too many gfiles");
gfile[ngfile++] = ARGF();
if(gfile[ngfile-1] == nil)
usage();
break;
case 'i':
pass_stdin = 1;
break;
case 'n':
pass_nvram = 1;
break;
case 'p':
if(npfile >= MAXFILES)
exits("too many pfiles");
pfile[npfile++] = ARGF();
if(pfile[npfile-1] == nil)
usage();
break;
case 'r':
if(nrfile >= MAXFILES)
exits("too many rfiles");
rfile[nrfile++] = ARGF();
if(rfile[nrfile-1] == nil)
usage();
break;
case 's':
serve = EARGF(usage());
break;
case 'u':
user = EARGF(usage());
break;
case 'v':
verbose++;
break;
default:
usage();
break;
}ARGEND;
gfile[ngfile] = nil;
pfile[npfile] = nil;
rfile[nrfile] = nil;
if(argc!=0 || user==nil)
usage();
if(chpass && (ngfile || npfile || nrfile)){
fprint(2, "Get, put, and remove invalid with password change.\n");
exits("usage");
}
tcpserve = netmkaddr(serve, "tcp", "secstore");
c = login(user, tcpserve, pass_stdin, pass_nvram);
if(c == nil){
fprint(2, "secstore authentication failed\n");
exits("secstore authentication failed");
}
if(chpass)
rc = chpasswd(c, user);
else
rc = cmd(c, gfile, Gflag, pfile, rfile);
if(rc < 0){
fprint(2, "secstore cmd failed\n");
exits("secstore cmd failed");
}
exits("");
return 0;
}
void
main(int argc, char **argv)
{
int auth, x;
char *mtpt, *service, *where, *user;
Netbuf n;
UserPasswd *up;
mtpt = "/mnt/news";
service = nil;
memset(&n, 0, sizeof n);
user = nil;
auth = 0;
ARGBEGIN{
case 'D':
chatty9p++;
break;
case 'N':
netdebug = 1;
break;
case 'a':
auth = 1;
break;
case 'u':
user = EARGF(usage());
break;
case 's':
service = EARGF(usage());
break;
case 'm':
mtpt = EARGF(usage());
break;
default:
usage();
}ARGEND
if(argc > 1)
usage();
if(argc==0)
where = "$nntp";
else
where = argv[0];
now = time(0);
net = &n;
if(auth) {
n.auth = 1;
if(user)
up = auth_getuserpasswd(auth_getkey, "proto=pass service=nntp server=%q user=%q", where, user);
else
up = auth_getuserpasswd(auth_getkey, "proto=pass service=nntp server=%q", where);
if(up == nil)
sysfatal("no password: %r");
n.user = up->user;
n.pass = up->passwd;
}
n.addr = netmkaddr(where, "tcp", "nntp");
root = emalloc(sizeof *root);
root->name = estrdup("");
root->parent = root;
n.fd = -1;
if(nntpconnect(&n) < 0)
sysfatal("nntpconnect: %s", n.response);
x=netdebug;
netdebug=0;
nntprefreshall(&n);
netdebug=x;
// dumpgroups(root, 0);
postmountsrv(&nntpsrv, service, mtpt, MREPL);
exits(nil);
}
int
httpopen(Client *c, Url *url)
{
int fd, code, redirect, authenticate;
char *cookies;
Ioproc *io;
HttpState *hs;
char *service;
if(httpdebug)
fprint(2, "httpopen\n");
io = c->io;
hs = emalloc(sizeof(*hs));
hs->c = c;
if(url->port)
service = url->port;
else
service = url->scheme;
hs->netaddr = estrdup(netmkaddr(url->host, 0, service));
c->aux = hs;
if(httpdebug){
fprint(2, "dial %s\n", hs->netaddr);
fprint(2, "dial port: %s\n", url->port);
}
fd = iotlsdial(io, hs->netaddr, 0, 0, 0, url->ischeme==UShttps);
if(fd < 0){
Error:
if(httpdebug)
fprint(2, "iodial: %r\n");
free(hs->location);
free(hs->setcookie);
free(hs->netaddr);
free(hs->credentials);
if(fd >= 0)
ioclose(io, hs->fd);
hs->fd = -1;
free(hs);
c->aux = nil;
return -1;
}
hs->fd = fd;
if(httpdebug)
fprint(2, "<- %s %s HTTP/1.0\n<- Host: %s\n",
c->havepostbody? "POST": "GET", url->http.page_spec, url->host);
ioprint(io, fd, "%s %s HTTP/1.0\r\nHost: %s\r\n",
c->havepostbody? "POST" : "GET", url->http.page_spec, url->host);
if(httpdebug)
fprint(2, "<- User-Agent: %s\n", c->ctl.useragent);
if(c->ctl.useragent)
ioprint(io, fd, "User-Agent: %s\r\n", c->ctl.useragent);
if(c->ctl.sendcookies){
/* should we use url->page here? sometimes it is nil. */
cookies = httpcookies(url->host, url->http.page_spec,
url->ischeme == UShttps);
if(cookies && cookies[0])
ioprint(io, fd, "%s", cookies);
if(httpdebug)
fprint(2, "<- %s", cookies);
free(cookies);
}
if(c->havepostbody){
ioprint(io, fd, "Content-type: %s\r\n", PostContentType);
ioprint(io, fd, "Content-length: %ud\r\n", c->npostbody);
if(httpdebug){
fprint(2, "<- Content-type: %s\n", PostContentType);
fprint(2, "<- Content-length: %ud\n", c->npostbody);
}
}
if(c->authenticate){
ioprint(io, fd, "Authorization: %s\r\n", c->authenticate);
if(httpdebug)
fprint(2, "<- Authorization: %s\n", c->authenticate);
}
ioprint(io, fd, "\r\n");
if(c->havepostbody)
if(iowrite(io, fd, c->postbody, c->npostbody) != c->npostbody)
goto Error;
redirect = 0;
authenticate = 0;
initibuf(&hs->b, io, fd);
code = httprcode(hs);
switch(code){
case -1: /* connection timed out */
goto Error;
/*
case Eof:
werrstr("EOF from HTTP server");
goto Error;
*/
case 200: /* OK */
case 201: /* Created */
case 202: /* Accepted */
case 204: /* No Content */
case 205: /* Reset Content */
#ifdef NOT_DEFINED
if(ofile == nil && r->start != 0)
sysfatal("page changed underfoot");
#endif
break;
case 206: /* Partial Content */
werrstr("Partial Content (206)");
goto Error;
case 301: /* Moved Permanently */
case 302: /* Moved Temporarily */
case 303: /* See Other */
case 307: /* Temporary Redirect */
redirect = 1;
break;
case 304: /* Not Modified */
break;
case 400: /* Bad Request */
werrstr("Bad Request (400)");
goto Error;
case 401: /* Unauthorized */
if(c->authenticate){
werrstr("Authentication failed (401)");
goto Error;
}
authenticate = 1;
break;
case 402: /* Payment Required */
werrstr("Payment Required (402)");
goto Error;
case 403: /* Forbidden */
werrstr("Forbidden by server (403)");
goto Error;
case 404: /* Not Found */
werrstr("Not found on server (404)");
goto Error;
case 405: /* Method Not Allowed */
werrstr("Method not allowed (405)");
goto Error;
case 406: /* Not Acceptable */
werrstr("Not Acceptable (406)");
goto Error;
case 407: /* Proxy auth */
werrstr("Proxy authentication required (407)");
goto Error;
case 408: /* Request Timeout */
werrstr("Request Timeout (408)");
goto Error;
case 409: /* Conflict */
werrstr("Conflict (409)");
goto Error;
case 410: /* Gone */
werrstr("Gone (410)");
goto Error;
case 411: /* Length Required */
werrstr("Length Required (411)");
goto Error;
case 412: /* Precondition Failed */
werrstr("Precondition Failed (412)");
goto Error;
case 413: /* Request Entity Too Large */
werrstr("Request Entity Too Large (413)");
goto Error;
case 414: /* Request-URI Too Long */
werrstr("Request-URI Too Long (414)");
goto Error;
case 415: /* Unsupported Media Type */
werrstr("Unsupported Media Type (415)");
goto Error;
case 416: /* Requested Range Not Satisfiable */
werrstr("Requested Range Not Satisfiable (416)");
goto Error;
case 417: /* Expectation Failed */
werrstr("Expectation Failed (417)");
goto Error;
case 500: /* Internal server error */
werrstr("Server choked (500)");
goto Error;
case 501: /* Not implemented */
werrstr("Server can't do it (501)");
goto Error;
case 502: /* Bad gateway */
werrstr("Bad gateway (502)");
goto Error;
case 503: /* Service unavailable */
werrstr("Service unavailable (503)");
goto Error;
default:
/* Bogus: we should treat unknown code XYZ as code X00 */
werrstr("Unknown response code %d", code);
goto Error;
}
if(httpheaders(hs) < 0)
goto Error;
if(c->ctl.acceptcookies && hs->setcookie)
httpsetcookie(hs->setcookie, url->host, url->path);
if(authenticate){
if(!hs->credentials){
if(hs->autherror[0])
werrstr("%s", hs->autherror);
else
werrstr("unauthorized; no www-authenticate: header");
goto Error;
}
c->authenticate = hs->credentials;
hs->credentials = nil;
}else if(c->authenticate)
c->authenticate = 0;
if(redirect){
if(!hs->location){
werrstr("redirection without Location: header");
goto Error;
}
c->redirect = hs->location;
hs->location = nil;
}
return 0;
}
void
threadmain(int argc, char **argv)
{
char *file, *x, *addr;
int fd;
rfork(RFNOTEG);
x = getenv("verbose9pserve");
if(x){
verbose = atoi(x);
fprint(2, "verbose9pserve %s => %d\n", x, verbose);
}
ARGBEGIN{
default:
usage();
case 'A':
attached = 1;
xaname = EARGF(usage());
xafid = atoi(EARGF(usage()));
break;
case 'M':
versioned = 1;
msize = atoi(EARGF(usage()));
break;
case 'c':
addr = netmkaddr(EARGF(usage()), "net", "9fs");
if((fd = dial(addr, nil, nil, nil)) < 0)
sysfatal("dial %s: %r", addr);
dup(fd, 0);
dup(fd, 1);
if(fd > 1)
close(fd);
break;
case 'n':
noauth = 1;
break;
case 'v':
verbose++;
break;
case 'u':
isunix++;
break;
case 'l':
logging++;
break;
}ARGEND
if(attached && !versioned){
fprint(2, "-A must be used with -M\n");
usage();
}
if(argc != 1)
usage();
addr = argv[0];
fmtinstall('T', timefmt);
if((afd = announce(addr, adir)) < 0)
sysfatal("announce %s: %r", addr);
if(logging){
if(strncmp(addr, "unix!", 5) == 0)
addr += 5;
file = smprint("%s.log", addr);
if(file == nil)
sysfatal("smprint log: %r");
if((fd = create(file, OWRITE, 0666)) < 0)
sysfatal("create %s: %r", file);
dup(fd, 2);
if(fd > 2)
close(fd);
}
if(verbose) fprint(2, "%T 9pserve running\n");
proccreate(mainproc, nil, STACK);
}
