/*
 * dial - connect to a service (threaded parallel version)
 */
#include <u.h>
#include <libc.h>
#include <ctype.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>

typedef struct Conn Conn;
typedef struct Dest Dest;
typedef struct DS DS;
typedef struct Kidargs Kidargs;
typedef struct Restup Restup;

enum
{
	Noblock,
	Block,

	Defstksize	= 8192,

	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 {
	/* dial string */
	char	buf[Maxstring];
	char	*netdir;
	char	*proto;
	char	*rem;

	/* other args */
	char	*local;
	char	*dir;
	int	*cfdp;
};

struct Conn {
	int	cfd;
	char	dir[NETPATHLEN+1];
};
struct Dest {
	DS	*ds;

	Channel *reschan;		/* all callprocs send results on this */
	int	nkid;
	int	kidthrids[64];		/* one per addr; ought to be enough */

	int	windfd;
	char	err[ERRMAX];

	long	oalarm;

	int	naddrs;
	char	*nextaddr;
	char	addrlist[Maxcsreply];
};

struct Kidargs {			/* arguments to callproc */
	Dest	*dp;
	int	thridsme;
	char	*clone;
	char	*dest;
};

struct Restup {				/* result tuple from callproc */
	int	dfd;
	int	cfd;
	char	*err;
	char	*conndir;
};

static int	call(char*, char*, Dest*, Conn*);
static int	call1(char*, char*, Dest*, Conn*);
static int	csdial(DS*);
static void	_dial_string_parse(char*, DS*);

/*
 *  the dialstring is of the form '[/net/]proto!dest'
 */
static int
dialimpl(char *dest, 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(strstr(err, "refused") != 0){
		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(strstr(alterr, "translate") || strstr(alterr, "does not exist"))
		werrstr("%s", err);
	else
		werrstr("%s", alterr);
	return rv;
}

/*
 * the thread library can't cope with rfork(RFMEM|RFPROC),
 * so it must override _dial with this version of dial.
 */
int (*_dial)(char *, char *, char *, int *) = dialimpl;

int
dial(char *dest, char *local, char *dir, int *cfdp)
{
	return (*_dial)(dest, local, dir, cfdp);
}

static void
freedest(Dest *dp)
{
	if (dp) {
		if (dp->oalarm >= 0)
			alarm(dp->oalarm);
		free(dp);
	}
}

static void
closeopenfd(int *fdp)
{
	if (*fdp >= 0) {
		close(*fdp);
		*fdp = -1;
	}
}

static int
parsecs(Dest *dp, char **clonep, char **destp)
{
	char *dest, *p;

	dest = strchr(dp->nextaddr, ' ');
	if(dest == nil)
		return -1;
	*dest++ = '\0';
	p = 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[ERRMAX];

	err[0] = '\0';
	errstr(err, ERRMAX);
	if(strstr(err, "does not exist") == 0)
		strcpy(besterr, err);
}

static int
catcher(void *, char *s)
{
	return strstr(s, "alarm") != nil;
}

static void
callproc(void *p)
{
	int dfd;
	char besterr[ERRMAX];
	Conn lconn;
	Conn *conn;
	Kidargs *args;
	Restup *tup;

	threadnotify(catcher, 1);	/* avoid atnotify callbacks in parent */

	conn = &lconn;
	memset(conn, 0, sizeof *conn);
	*besterr = '\0';
	args = (Kidargs *)p;
	dfd = call(args->clone, args->dest, args->dp, conn);
	if(dfd < 0)
		pickuperr(besterr);

	tup = (Restup *)emalloc9p(sizeof *tup);
	*tup = (Restup){dfd, conn->cfd, nil, nil};
	if (dfd >= 0)
		tup->conndir = strdup(conn->dir);
	else
		tup->err = strdup(besterr);
	sendp(args->dp->reschan, tup);

	args->dp->kidthrids[args->thridsme] = -1;
	free(args);
	threadexits(besterr);		/* better be no atexit callbacks */
}

/* interrupt all of our still-live kids */
static void
intrcallprocs(Dest *dp)
{
	int i;

	for (i = 0; i < nelem(dp->kidthrids); i++)
		if (dp->kidthrids[i] >= 0)
			threadint(dp->kidthrids[i]);
}

static int
recvresults(Dest *dp, int block)
{
	DS *ds;
	Restup *tup;

	for (; dp->nkid > 0; dp->nkid--) {
		if (block)
			tup = recvp(dp->reschan);
		else
			tup = nbrecvp(dp->reschan);
		if (tup == nil)
			break;
		if (tup->dfd >= 0)		/* connected? */
			if (dp->windfd < 0) {	/* first connection? */
				ds = dp->ds;
				dp->windfd = tup->dfd;
				if (ds->cfdp)
					*ds->cfdp = tup->cfd;
				if (ds->dir) {
					strncpy(ds->dir, tup->conndir,
						NETPATHLEN);
					ds->dir[NETPATHLEN-1] = '\0';
				}
				intrcallprocs(dp);
			} else {
				close(tup->dfd);
				close(tup->cfd);
			}
		else if (dp->err[0] == '\0' && tup->err) {
			strncpy(dp->err, tup->err, ERRMAX - 1);
			dp->err[ERRMAX - 1] = '\0';
		}
		free(tup->conndir);
		free(tup->err);
		free(tup);
	}
	return dp->windfd;
}

/*
 * 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(Dest *dp)
{
	int kidme;
	char *clone, *dest;
	Kidargs *argp;

	dp->reschan = chancreate(sizeof(void *), 0);
	dp->err[0] = '\0';
	dp->nkid = 0;
	dp->windfd = -1;
	/* if too many addresses for dp->kidthrids, ignore the last few */
	while(dp->windfd < 0 && dp->nkid < nelem(dp->kidthrids) &&
	    *dp->nextaddr != '\0' && parsecs(dp, &clone, &dest) >= 0) {
		kidme = dp->nkid++;

		argp = (Kidargs *)emalloc9p(sizeof *argp);
		*argp = (Kidargs){dp, kidme, clone, dest};

		dp->kidthrids[kidme] = proccreate(callproc, argp, Defstksize);
		if (dp->kidthrids[kidme] < 0)
			--dp->nkid;
	}

	recvresults(dp, Block);
	assert(dp->nkid == 0);

	chanclose(dp->reschan);
	chanfree(dp->reschan);
	if(dp->windfd < 0 && dp->err[0])
		werrstr("%s", dp->err);
	return dp->windfd;
}

/* call a single address and pass back cfd & conn dir after */
static int
call1(char *clone, char *rem, Dest *dp, Conn *conn)
{
	int dfd;
	DS *ds;

	ds = dp->ds;
	dfd = call(clone, rem, dp, conn);
	if (dfd < 0)
		return dfd;

	if (ds->cfdp)
		*ds->cfdp = conn->cfd;
	if (ds->dir) {
		strncpy(ds->dir, conn->dir, NETPATHLEN);
		ds->dir[NETPATHLEN-1] = '\0';
	}
	return dfd;
}

static int
csdial(DS *ds)
{
	int n, fd, dfd, addrs, bleft;
	char c;
	char *addrp, *clone2, *dest;
	char buf[Maxstring], clone[Maxpath], besterr[ERRMAX];
	Conn lconn;
	Conn *conn;
	Dest *dp;

	dp = mallocz(sizeof *dp, 1);
	if(dp == nil)
		return -1;
	conn = &lconn;
	memset(conn, 0, sizeof *conn);
	dp->ds = ds;
	if (ds->cfdp)
		*ds->cfdp = -1;
	if (ds->dir)
		ds->dir[0] = '\0';
	dp->oalarm = alarm(0);

	/*
	 *  open connection server
	 */
	snprint(buf, sizeof(buf), "%s/cs", ds->netdir);
	fd = open(buf, ORDWR);
	if(fd < 0){
		/* no connection server, don't translate */
		snprint(clone, sizeof(clone), "%s/%s/clone", ds->netdir, ds->proto);
		dfd = call1(clone, ds->rem, dp, conn);
		freedest(dp);
		return dfd;
	}

	/*
	 *  ask connection server to translate
	 */
	snprint(buf, sizeof(buf), "%s!%s", ds->proto, ds->rem);
	if(write(fd, buf, strlen(buf)) < 0){
		close(fd);
		freedest(dp);
		return -1;
	}

	/*
	 *  read all addresses from the connection server.
	 */
	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;
	}
	/*
	 * 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;
	dfd = -1;				/* pessimistic default */
	dp->naddrs = addrs;
	if (addrs == 0)
		werrstr("no address to dial");
	else if (addrs == 1) {
		/* common case: dial one address without forking */
		if (parsecs(dp, &clone2, &dest) >= 0 &&
		    (dfd = call1(clone2, dest, dp, conn)) < 0) {
			pickuperr(besterr);
			werrstr("%s", besterr);
		}
	} else
		dfd = dialmulti(dp);

	freedest(dp);
	return dfd;
}

/* returns dfd, stores cfd through cfdp */
static int
call(char *clone, char *dest, Dest *dp, Conn *conn)
{
	int fd, cfd, n, calleralarm, oalarm;
	char cname[Maxpath], name[Maxpath], data[Maxpath], *p;
	DS *ds;

	/* because cs is in a different name space, replace the mount point */
	if(*clone == '/'){
		p = strchr(clone+1, '/');
		if(p == nil)
			p = clone;
		else 
			p++;
	} else
		p = clone;
	ds = dp->ds;
	snprint(cname, sizeof cname, "%s/%s", ds->netdir, p);

	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++)
		;
	snprint(name, sizeof(name), "%ld", strtoul(p, 0, 0));
	p = strrchr(cname, '/');
	*p = 0;
	if(ds->dir)
		snprint(conn->dir, NETPATHLEN, "%s/%s", cname, name);
	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)
		snprint(name, sizeof(name), "connect %s %s", dest, ds->local);
	else
		snprint(name, sizeof(name), "connect %s", dest);
	if(write(cfd, name, 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 */
	fd = open(data, ORDWR);
	if(fd < 0){
		closeopenfd(&conn->cfd);
		alarm(dp->oalarm);
		return -1;
	}
	if(ds->cfdp == nil)
		closeopenfd(&conn->cfd);

	alarm(calleralarm? dp->oalarm: 0);
	return fd;
}

/*
 * assume p points at first '!' in dial string.  st is start of dial string.
 * there could be subdirs of the conn dirs (e.g., ssh/0) that must count as
 * part of the proto string, so skip numeric components.
 * returns pointer to delimiter after right-most non-numeric component.
 */
static char *
backoverchans(char *st, char *p)
{
	char *sl;

	for (sl = p; --p >= st && isascii(*p) && isdigit(*p); sl = p) {
		while (--p >= st && isascii(*p) && isdigit(*p))
			;
		if (p < st || *p != '/')
			break;			/* "net.alt2" or ran off start */
		while (p > st && p[-1] == '/')	/* skip runs of slashes */
			p--;
	}
	return sl;
}

/*
 *  parse a dial string
 */
static void
_dial_string_parse(char *str, DS *ds)
{
	char *p, *p2;

	strncpy(ds->buf, str, Maxstring);
	ds->buf[Maxstring-1] = 0;

	p = 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 {
			p2 = backoverchans(ds->buf, p);

			/* back over last component of netdir (proto) */
			while (--p2 > ds->buf && *p2 != '/')
				;
			*p2++ = 0;
			ds->netdir = ds->buf;
			ds->proto = p2;
		}
		*p = 0;
		ds->rem = p + 1;
	}
}