/*
 * 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.
 */

/*
 * 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';
	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;
	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 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)
		alarm(oalarm);
}

static void
closeopenfd(int *fdp)
{
	if (*fdp >= 0) {
		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) && 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';
	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 = 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);
			_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 = 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 = 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(write(fd, buf, jehanne_strlen(buf)) < 0){
		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.
	 */
	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 = 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 && read(fd, &c, 1) == 1)
		addrs--;
	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 = open(cname, ORDWR);
	if(cfd < 0)
		return -1;

	/* get directory name */
	n = 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)
		alarm(dp->oalarm);
	else if (dp->naddrs > 1)	/* in a sub-process? */
		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(write(cfd, name, jehanne_strlen(name)) < 0){
		closeopenfd(&conn->cfd);
		return -1;
	}

	oalarm = 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 = open(data, ORDWR);
	if(fd < 0){
		closeopenfd(&conn->cfd);
		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);
	}
	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;
	}
}
