564 lines
12 KiB
C
564 lines
12 KiB
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.
|
|
*/
|
|
/* Portions of this file are Copyright (C) 2015-2018 Giacomo Tesio <giacomo@tesio.it>
|
|
* See /doc/license/gpl-2.0.txt for details about the licensing.
|
|
*/
|
|
|
|
/*
|
|
* dial - connect to a service (parallel version)
|
|
*/
|
|
#include <u.h>
|
|
#include <libc.h>
|
|
|
|
typedef struct Conn Conn;
|
|
typedef struct Dest Dest;
|
|
typedef struct DS DS;
|
|
|
|
enum
|
|
{
|
|
Maxstring = 128,
|
|
Maxpath = 256,
|
|
|
|
Maxcsreply = 64*80, /* this is probably overly generous */
|
|
/*
|
|
* this should be a plausible slight overestimate for non-interactive
|
|
* use even if it's ridiculously long for interactive use.
|
|
*/
|
|
Maxconnms = 2*60*1000, /* 2 minutes */
|
|
};
|
|
|
|
struct DS {
|
|
/* dist string */
|
|
char buf[Maxstring];
|
|
char *netdir;
|
|
char *proto;
|
|
char *rem;
|
|
|
|
/* other args */
|
|
const char *local;
|
|
char *dir;
|
|
int *cfdp;
|
|
};
|
|
|
|
/*
|
|
* malloc these; they need to be writable by this proc & all children.
|
|
* the stack is private to each proc, and static allocation in the data
|
|
* segment would not permit concurrent dials within a multi-process program.
|
|
*/
|
|
struct Conn {
|
|
int pid;
|
|
int dead;
|
|
|
|
int dfd;
|
|
int cfd;
|
|
char dir[NETPATHLEN+1];
|
|
char err[ERRMAX];
|
|
};
|
|
struct Dest {
|
|
Conn *conn; /* allocated array */
|
|
Conn *connend;
|
|
int nkid;
|
|
|
|
int32_t oalarm;
|
|
int naddrs;
|
|
|
|
QLock winlck;
|
|
int winner; /* index into conn[] */
|
|
|
|
char *nextaddr;
|
|
char addrlist[Maxcsreply];
|
|
};
|
|
|
|
static int call(char*, char*, DS*, Dest*, Conn*);
|
|
static int csdial(DS*);
|
|
static void _dial_string_parse(const char*, DS*);
|
|
|
|
|
|
/*
|
|
* the dialstring is of the form '[/net/]proto!dest'
|
|
*/
|
|
static int
|
|
dialimpl(const char *dest, const char *local, char *dir, int *cfdp)
|
|
{
|
|
DS ds;
|
|
int rv;
|
|
char err[ERRMAX], alterr[ERRMAX];
|
|
|
|
ds.local = local;
|
|
ds.dir = dir;
|
|
ds.cfdp = cfdp;
|
|
|
|
_dial_string_parse(dest, &ds);
|
|
if(ds.netdir)
|
|
return csdial(&ds);
|
|
|
|
ds.netdir = "/net";
|
|
rv = csdial(&ds);
|
|
if(rv >= 0)
|
|
return rv;
|
|
err[0] = '\0';
|
|
sys_errstr(err, sizeof err);
|
|
if(jehanne_strstr(err, "refused") != 0){
|
|
jehanne_werrstr("%s", err);
|
|
return rv;
|
|
}
|
|
ds.netdir = "/net.alt";
|
|
rv = csdial(&ds);
|
|
if(rv >= 0)
|
|
return rv;
|
|
|
|
alterr[0] = 0;
|
|
sys_errstr(alterr, sizeof alterr);
|
|
if(jehanne_strstr(alterr, "translate") || jehanne_strstr(alterr, "does not exist"))
|
|
jehanne_werrstr("%s", err);
|
|
else
|
|
jehanne_werrstr("%s", alterr);
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* the thread library can't cope with sys_rfork(RFMEM|RFPROC),
|
|
* so it must override this with a private version of dial.
|
|
*/
|
|
int (*_dial)(const char *, const char *, char *, int *) = dialimpl;
|
|
|
|
int
|
|
jehanne_dial(const char *dest, const char *local, char *dir, int *cfdp)
|
|
{
|
|
return (*_dial)(dest, local, dir, cfdp);
|
|
}
|
|
|
|
static int
|
|
connsalloc(Dest *dp, int addrs)
|
|
{
|
|
Conn *conn;
|
|
|
|
jehanne_free(dp->conn);
|
|
dp->connend = nil;
|
|
assert(addrs > 0);
|
|
|
|
dp->conn = jehanne_mallocz(addrs * sizeof *dp->conn, 1);
|
|
if(dp->conn == nil)
|
|
return -1;
|
|
dp->connend = dp->conn + addrs;
|
|
for(conn = dp->conn; conn < dp->connend; conn++)
|
|
conn->cfd = conn->dfd = -1;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
freedest(Dest *dp)
|
|
{
|
|
int32_t oalarm;
|
|
|
|
if (dp == nil)
|
|
return;
|
|
oalarm = dp->oalarm;
|
|
jehanne_free(dp->conn);
|
|
jehanne_free(dp);
|
|
if (oalarm >= 0)
|
|
sys_alarm(oalarm);
|
|
}
|
|
|
|
static void
|
|
closeopenfd(int *fdp)
|
|
{
|
|
if (*fdp >= 0) {
|
|
sys_close(*fdp);
|
|
*fdp = -1;
|
|
}
|
|
}
|
|
|
|
static void
|
|
notedeath(Dest *dp, char *exitsts)
|
|
{
|
|
int i, n, pid;
|
|
char *fields[5]; /* pid + 3 times + error */
|
|
Conn *conn;
|
|
|
|
for (i = 0; i < nelem(fields); i++)
|
|
fields[i] = "";
|
|
n = jehanne_tokenize(exitsts, fields, nelem(fields));
|
|
if (n < 4)
|
|
return;
|
|
pid = jehanne_atoi(fields[0]);
|
|
if (pid <= 0)
|
|
return;
|
|
for (conn = dp->conn; conn < dp->connend; conn++)
|
|
if (conn->pid == pid && !conn->dead) { /* it's one we know? */
|
|
if (conn - dp->conn != dp->winner) {
|
|
closeopenfd(&conn->dfd);
|
|
closeopenfd(&conn->cfd);
|
|
}
|
|
jehanne_strncpy(conn->err, fields[4], sizeof conn->err - 1);
|
|
conn->err[sizeof conn->err - 1] = '\0';
|
|
conn->dead = 1;
|
|
return;
|
|
}
|
|
/* not a proc that we forked */
|
|
}
|
|
|
|
static int
|
|
outstandingprocs(Dest *dp)
|
|
{
|
|
Conn *conn;
|
|
|
|
for (conn = dp->conn; conn < dp->connend; conn++)
|
|
if (!conn->dead)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
reap(Dest *dp)
|
|
{
|
|
char exitsts[2*ERRMAX];
|
|
|
|
if (outstandingprocs(dp) && sys_await(exitsts, sizeof exitsts) >= 0) {
|
|
notedeath(dp, exitsts);
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static int
|
|
fillinds(DS *ds, Dest *dp)
|
|
{
|
|
Conn *conn;
|
|
|
|
if (dp->winner < 0)
|
|
return -1;
|
|
conn = &dp->conn[dp->winner];
|
|
if (ds->cfdp)
|
|
*ds->cfdp = conn->cfd;
|
|
if (ds->dir) {
|
|
jehanne_strncpy(ds->dir, conn->dir, NETPATHLEN);
|
|
ds->dir[NETPATHLEN-1] = '\0';
|
|
}
|
|
return conn->dfd;
|
|
}
|
|
|
|
static int
|
|
connectwait(Dest *dp, char *besterr)
|
|
{
|
|
Conn *conn;
|
|
|
|
/* wait for a winner or all attempts to time out */
|
|
while (dp->winner < 0 && reap(dp) >= 0)
|
|
;
|
|
|
|
/* kill all of our still-live kids & reap them */
|
|
for (conn = dp->conn; conn < dp->connend; conn++)
|
|
if (!conn->dead)
|
|
jehanne_postnote(PNPROC, conn->pid, "alarm");
|
|
while (reap(dp) >= 0)
|
|
;
|
|
|
|
/* rummage about and report some error string */
|
|
for (conn = dp->conn; conn < dp->connend; conn++)
|
|
if (conn - dp->conn != dp->winner && conn->dead &&
|
|
conn->err[0]) {
|
|
jehanne_strncpy(besterr, conn->err, ERRMAX-1);
|
|
besterr[ERRMAX-1] = '\0';
|
|
break;
|
|
}
|
|
return dp->winner;
|
|
}
|
|
|
|
static int
|
|
parsecs(Dest *dp, char **clonep, char **destp)
|
|
{
|
|
char *dest, *p;
|
|
|
|
dest = jehanne_strchr(dp->nextaddr, ' ');
|
|
if(dest == nil) {
|
|
p = jehanne_strchr(dp->nextaddr, '\n');
|
|
if(p)
|
|
*p = '\0';
|
|
jehanne_werrstr("malformed clone cmd from cs `%s'", dp->nextaddr);
|
|
if(p)
|
|
*p = '\n';
|
|
return -1;
|
|
}
|
|
*dest++ = '\0';
|
|
p = jehanne_strchr(dest, '\n');
|
|
if(p == nil)
|
|
return -1;
|
|
*p++ = '\0';
|
|
*clonep = dp->nextaddr;
|
|
*destp = dest;
|
|
dp->nextaddr = p; /* advance to next line */
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
pickuperr(char *besterr, char *err)
|
|
{
|
|
err[0] = '\0';
|
|
sys_errstr(err, ERRMAX);
|
|
if(jehanne_strstr(err, "does not exist") == 0)
|
|
jehanne_strcpy(besterr, err);
|
|
}
|
|
|
|
static int
|
|
catcher(void *v, char *s)
|
|
{
|
|
return jehanne_strstr(s, "alarm") != nil;
|
|
}
|
|
|
|
/*
|
|
* try all addresses in parallel and take the first one that answers;
|
|
* this helps when systems have ip v4 and v6 addresses but are
|
|
* only reachable from here on one (or some) of them.
|
|
*/
|
|
static int
|
|
dialmulti(DS *ds, Dest *dp)
|
|
{
|
|
int rv, kid, kidme;
|
|
char *clone, *dest;
|
|
char besterr[ERRMAX];
|
|
|
|
dp->winner = -1;
|
|
dp->nkid = 0;
|
|
while(dp->winner < 0 && *dp->nextaddr != '\0' &&
|
|
parsecs(dp, &clone, &dest) >= 0) {
|
|
kidme = dp->nkid++; /* make private copy on stack */
|
|
kid = sys_rfork(RFPROC|RFMEM); /* spin off a call attempt */
|
|
if (kid < 0)
|
|
--dp->nkid;
|
|
else if (kid == 0) {
|
|
char err[ERRMAX];
|
|
|
|
/* only in kid, to avoid atnotify callbacks in parent */
|
|
jehanne_atnotify(catcher, 1);
|
|
|
|
*besterr = '\0';
|
|
rv = call(clone, dest, ds, dp, &dp->conn[kidme]);
|
|
if(rv < 0)
|
|
pickuperr(besterr, err);
|
|
sys__exits(besterr); /* avoid atexit callbacks */
|
|
}
|
|
}
|
|
*besterr = '\0';
|
|
rv = connectwait(dp, besterr);
|
|
if(rv < 0)
|
|
jehanne_werrstr("%s", (*besterr? besterr: "unknown error"));
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
csdial(DS *ds)
|
|
{
|
|
int n, fd, rv, addrs, bleft;
|
|
char c;
|
|
char *addrp, *clone2, *dest;
|
|
char buf[Maxstring], clone[Maxpath], err[ERRMAX], besterr[ERRMAX];
|
|
Dest *dp;
|
|
|
|
jehanne_werrstr("");
|
|
dp = jehanne_mallocz(sizeof *dp, 1);
|
|
if(dp == nil)
|
|
return -1;
|
|
dp->winner = -1;
|
|
dp->oalarm = sys_alarm(0);
|
|
if (connsalloc(dp, 1) < 0) { /* room for a single conn. */
|
|
freedest(dp);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* open connection server
|
|
*/
|
|
jehanne_snprint(buf, sizeof(buf), "%s/cs", ds->netdir);
|
|
fd = sys_open(buf, ORDWR);
|
|
if(fd < 0){
|
|
/* no connection server, don't translate */
|
|
jehanne_snprint(clone, sizeof(clone), "%s/%s/clone", ds->netdir, ds->proto);
|
|
rv = call(clone, ds->rem, ds, dp, &dp->conn[0]);
|
|
fillinds(ds, dp);
|
|
freedest(dp);
|
|
return rv;
|
|
}
|
|
|
|
/*
|
|
* ask connection server to translate
|
|
* e.g., net!cs.bell-labs.com!smtp
|
|
*/
|
|
jehanne_snprint(buf, sizeof(buf), "%s!%s", ds->proto, ds->rem);
|
|
if(jehanne_write(fd, buf, jehanne_strlen(buf)) < 0){
|
|
sys_close(fd);
|
|
freedest(dp);
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* read all addresses from the connection server:
|
|
* /net/tcp/clone 135.104.9.78!25
|
|
* /net/tcp/clone 2620:0:dc0:1805::29!25
|
|
*
|
|
* assumes that we'll get one record per read.
|
|
*/
|
|
sys_seek(fd, 0, 0);
|
|
addrs = 0;
|
|
addrp = dp->nextaddr = dp->addrlist;
|
|
bleft = sizeof dp->addrlist - 2; /* 2 is room for \n\0 */
|
|
while(bleft > 0 && (n = jehanne_read(fd, addrp, bleft)) > 0) {
|
|
if (addrp[n-1] != '\n')
|
|
addrp[n++] = '\n';
|
|
addrs++;
|
|
addrp += n;
|
|
bleft -= n;
|
|
}
|
|
*addrp = '\0';
|
|
|
|
/*
|
|
* if we haven't read all of cs's output, assume the last line might
|
|
* have been truncated and ignore it. we really don't expect this
|
|
* to happen.
|
|
*/
|
|
if (addrs > 0 && bleft <= 0 && jehanne_read(fd, &c, 1) == 1)
|
|
addrs--;
|
|
sys_close(fd);
|
|
|
|
*besterr = 0;
|
|
rv = -1; /* pessimistic default */
|
|
dp->naddrs = addrs;
|
|
if (addrs == 0)
|
|
jehanne_werrstr("no address to dial");
|
|
else if (addrs == 1) {
|
|
/* common case: dial one address without forking */
|
|
if (parsecs(dp, &clone2, &dest) >= 0 &&
|
|
(rv = call(clone2, dest, ds, dp, &dp->conn[0])) < 0) {
|
|
pickuperr(besterr, err);
|
|
jehanne_werrstr("%s", besterr);
|
|
}
|
|
} else if (connsalloc(dp, addrs) >= 0)
|
|
rv = dialmulti(ds, dp);
|
|
|
|
/* fill in results */
|
|
if (rv >= 0 && dp->winner >= 0)
|
|
rv = fillinds(ds, dp);
|
|
|
|
freedest(dp);
|
|
return rv;
|
|
}
|
|
|
|
static int
|
|
call(char *clone, char *dest, DS *ds, Dest *dp, Conn *conn)
|
|
{
|
|
int fd, cfd, n, calleralarm, oalarm;
|
|
char cname[Maxpath], name[Maxpath], data[Maxpath], *p;
|
|
|
|
/* because cs is in a different name space, replace the mount point */
|
|
if(*clone == '/'){
|
|
p = jehanne_strchr(clone+1, '/');
|
|
if(p == nil)
|
|
p = clone;
|
|
else
|
|
p++;
|
|
} else
|
|
p = clone;
|
|
jehanne_snprint(cname, sizeof cname, "%s/%s", ds->netdir, p);
|
|
|
|
conn->pid = jehanne_getpid();
|
|
conn->cfd = cfd = sys_open(cname, ORDWR);
|
|
if(cfd < 0)
|
|
return -1;
|
|
|
|
/* get directory name */
|
|
n = jehanne_read(cfd, name, sizeof(name)-1);
|
|
if(n < 0){
|
|
closeopenfd(&conn->cfd);
|
|
return -1;
|
|
}
|
|
name[n] = 0;
|
|
for(p = name; *p == ' '; p++)
|
|
;
|
|
jehanne_snprint(name, sizeof(name), "%ld", jehanne_strtoul(p, 0, 0));
|
|
p = jehanne_strrchr(cname, '/');
|
|
*p = 0;
|
|
if(ds->dir)
|
|
jehanne_snprint(conn->dir, NETPATHLEN, "%s/%s", cname, name);
|
|
jehanne_snprint(data, sizeof(data), "%s/%s/data", cname, name);
|
|
|
|
/* should be no alarm pending now; re-instate caller's alarm, if any */
|
|
calleralarm = dp->oalarm > 0;
|
|
if (calleralarm)
|
|
sys_alarm(dp->oalarm);
|
|
else if (dp->naddrs > 1) /* in a sub-process? */
|
|
sys_alarm(Maxconnms);
|
|
|
|
/* connect */
|
|
if(ds->local)
|
|
jehanne_snprint(name, sizeof(name), "connect %s %s", dest, ds->local);
|
|
else
|
|
jehanne_snprint(name, sizeof(name), "connect %s", dest);
|
|
if(jehanne_write(cfd, name, jehanne_strlen(name)) < 0){
|
|
closeopenfd(&conn->cfd);
|
|
return -1;
|
|
}
|
|
|
|
oalarm = sys_alarm(0); /* don't let alarm interrupt critical section */
|
|
if (calleralarm)
|
|
dp->oalarm = oalarm; /* time has passed, so update user's */
|
|
|
|
/* open data connection */
|
|
conn->dfd = fd = sys_open(data, ORDWR);
|
|
if(fd < 0){
|
|
closeopenfd(&conn->cfd);
|
|
sys_alarm(dp->oalarm);
|
|
return -1;
|
|
}
|
|
if(ds->cfdp == nil)
|
|
closeopenfd(&conn->cfd);
|
|
|
|
n = conn - dp->conn;
|
|
if (dp->winner < 0) {
|
|
jehanne_qlock(&dp->winlck);
|
|
if (dp->winner < 0 && conn < dp->connend)
|
|
dp->winner = n;
|
|
jehanne_qunlock(&dp->winlck);
|
|
}
|
|
sys_alarm(calleralarm? dp->oalarm: 0);
|
|
return fd;
|
|
}
|
|
|
|
/*
|
|
* parse a dial string
|
|
*/
|
|
static void
|
|
_dial_string_parse(const char *str, DS *ds)
|
|
{
|
|
char *p, *p2;
|
|
|
|
jehanne_strncpy(ds->buf, str, Maxstring);
|
|
ds->buf[Maxstring-1] = 0;
|
|
|
|
p = jehanne_strchr(ds->buf, '!');
|
|
if(p == 0) {
|
|
ds->netdir = 0;
|
|
ds->proto = "net";
|
|
ds->rem = ds->buf;
|
|
} else {
|
|
if(*ds->buf != '/' && *ds->buf != '#'){
|
|
ds->netdir = 0;
|
|
ds->proto = ds->buf;
|
|
} else {
|
|
/* expecting /net.alt/tcp!foo or #I1/tcp!foo */
|
|
for(p2 = p; p2 > ds->buf && *p2 != '/'; p2--)
|
|
;
|
|
*p2++ = 0;
|
|
ds->netdir = ds->buf;
|
|
ds->proto = p2;
|
|
}
|
|
*p = 0;
|
|
ds->rem = p + 1;
|
|
}
|
|
}
|