[dragonfly.git] / usr.sbin / puffs / mount_psshfs / psshfs.c

/*	$NetBSD: psshfs.c,v 1.63 2011/05/19 15:07:16 riastradh Exp $	*/

/*
 * Copyright (c) 2006-2009  Antti Kantee.  All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

/*
 * psshfs: puffs sshfs
 *
 * psshfs implements sshfs functionality on top of puffs making it
 * possible to mount a filesystme through the sftp service.
 *
 * psshfs can execute multiple operations in "parallel" by using the
 * puffs_cc framework for continuations.
 *
 * Concurrency control is handled currently by vnode locking (this
 * will change in the future).  Context switch locations are easy to
 * find by grepping for puffs_framebuf_enqueue_cc().
 */

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/uio.h>

#include <assert.h>
#include <err.h>
#include <errno.h>
#include <paths.h>
#include <poll.h>
#include <puffs.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>

#include "psshfs.h"
#include "util_compat.h"

static int	pssh_connect(struct puffs_usermount *, int);
static void	psshfs_loopfn(struct puffs_usermount *);
static void	usage(void);
static void	add_ssharg(char ***, int *, const char *);
static void	psshfs_notify(struct puffs_usermount *, int, int);

#define SSH_PATH "/usr/bin/ssh"

unsigned int max_reads;
static int sighup;

static void
add_ssharg(char ***sshargs, int *nargs, const char *arg)
{

	*sshargs = realloc(*sshargs, (*nargs + 2) * sizeof(char*));
	if (!*sshargs)
		err(1, "realloc");
	(*sshargs)[(*nargs)++] = estrdup(arg);
	(*sshargs)[*nargs] = NULL;
}

static void
usage(void)
{

	fprintf(stderr, "usage: %s "
	    "[-ceprst] [-F configfile] [-O sshopt=value] [-o opts] "
	    "user@host:path mountpath\n",
	    getprogname());
	exit(1);
}

static void
takehup(int sig)
{

	sighup = 1;
}

int
main(int argc, char *argv[])
{
	struct psshfs_ctx pctx;
	struct puffs_usermount *pu;
	struct puffs_ops *pops;
	struct psshfs_node *root = &pctx.psn_root;
	struct puffs_node *pn_root;
	puffs_framev_fdnotify_fn notfn;
	struct vattr *rva;
	char **sshargs;
	char *userhost;
	char *hostpath;
	int mntflags, pflags, ch;
	int detach;
	int exportfs, refreshival, numconnections;
	int nargs;

	setprogname(argv[0]);
	puffs_unmountonsignal(SIGINT, true);
	puffs_unmountonsignal(SIGTERM, true);

	if (argc < 3)
		usage();

	memset(&pctx, 0, sizeof(pctx));
	mntflags = pflags = exportfs = nargs = 0;
	numconnections = 1;
	detach = 1;
	refreshival = DEFAULTREFRESH;
	notfn = puffs_framev_unmountonclose;
	sshargs = NULL;
	add_ssharg(&sshargs, &nargs, SSH_PATH);
	add_ssharg(&sshargs, &nargs, "-axs");
	add_ssharg(&sshargs, &nargs, "-oClearAllForwardings=yes");

	while ((ch = getopt(argc, argv, "c:eF:g:o:O:pr:st:u:")) != -1) {
		switch (ch) {
		case 'c':
			numconnections = atoi(optarg);
			if (numconnections < 1 || numconnections > 2) {
				fprintf(stderr, "%s: only 1 or 2 connections "
				    "permitted currently\n", getprogname());
				usage();
				/*NOTREACHED*/
			}
			break;
		case 'e':
			exportfs = 1;
			break;
		case 'F':
			add_ssharg(&sshargs, &nargs, "-F");
			add_ssharg(&sshargs, &nargs, optarg);
			break;
		case 'g':
			pctx.domanglegid = 1;
			pctx.manglegid = atoi(optarg);
			if (pctx.manglegid == (gid_t)-1)
				errx(1, "-1 not allowed for -g");
			pctx.mygid = getegid();
			break;
		case 'O':
			add_ssharg(&sshargs, &nargs, "-o");
			add_ssharg(&sshargs, &nargs, optarg);
			break;
		case 'o':
			getmntopts(optarg, puffsmopts, &mntflags, &pflags);
			break;
		case 'p':
			notfn = psshfs_notify;
			break;
		case 'r':
			max_reads = atoi(optarg);
			break;
		case 's':
			detach = 0;
			break;
		case 't':
			refreshival = atoi(optarg);
			if (refreshival < 0 && refreshival != -1)
				errx(1, "invalid timeout %d", refreshival);
			break;
		case 'u':
			pctx.domangleuid = 1;
			pctx.mangleuid = atoi(optarg);
			if (pctx.mangleuid == (uid_t)-1)
				errx(1, "-1 not allowed for -u");
			pctx.myuid = geteuid();
			break;
		default:
			usage();
			/*NOTREACHED*/
		}
	}
	argc -= optind;
	argv += optind;

	if (pflags & PUFFS_FLAG_OPDUMP)
		detach = 0;
	pflags |= PUFFS_FLAG_BUILDPATH;
	pflags |= PUFFS_KFLAG_WTCACHE | PUFFS_KFLAG_IAONDEMAND;

	if (argc != 2)
		usage();

	PUFFSOP_INIT(pops);

	PUFFSOP_SET(pops, psshfs, fs, unmount);
	PUFFSOP_SETFSNOP(pops, sync); /* XXX */
	PUFFSOP_SET(pops, psshfs, fs, statvfs);
	PUFFSOP_SET(pops, psshfs, fs, nodetofh);
	PUFFSOP_SET(pops, psshfs, fs, fhtonode);

	PUFFSOP_SET(pops, psshfs, node, lookup);
	PUFFSOP_SET(pops, psshfs, node, create);
	PUFFSOP_SET(pops, psshfs, node, open);
	PUFFSOP_SET(pops, psshfs, node, inactive);
	PUFFSOP_SET(pops, psshfs, node, readdir);
	PUFFSOP_SET(pops, psshfs, node, getattr);
	PUFFSOP_SET(pops, psshfs, node, setattr);
	PUFFSOP_SET(pops, psshfs, node, mkdir);
	PUFFSOP_SET(pops, psshfs, node, remove);
	PUFFSOP_SET(pops, psshfs, node, readlink);
	PUFFSOP_SET(pops, psshfs, node, rmdir);
	PUFFSOP_SET(pops, psshfs, node, link);
	PUFFSOP_SET(pops, psshfs, node, symlink);
	PUFFSOP_SET(pops, psshfs, node, rename);
	PUFFSOP_SET(pops, psshfs, node, read);
	PUFFSOP_SET(pops, psshfs, node, write);
	PUFFSOP_SET(pops, psshfs, node, reclaim);

	pu = puffs_init(pops, argv[0], "psshfs", &pctx, pflags);
	if (pu == NULL)
		err(1, "puffs_init");

	pctx.mounttime = time(NULL);
	pctx.refreshival = refreshival;
	pctx.numconnections = numconnections;

	userhost = argv[0];
	hostpath = strchr(userhost, ':');
	if (hostpath) {
		*hostpath++ = '\0';
		pctx.mountpath = hostpath;
	} else
		pctx.mountpath = ".";

	add_ssharg(&sshargs, &nargs, argv[0]);
	add_ssharg(&sshargs, &nargs, "sftp");
	pctx.sshargs = sshargs;

	pctx.nextino = 2;
	memset(root, 0, sizeof(struct psshfs_node));
	TAILQ_INIT(&root->pw);
	pn_root = puffs_pn_new(pu, root);
	if (pn_root == NULL)
		return errno;
	puffs_setroot(pu, pn_root);

	puffs_framev_init(pu, psbuf_read, psbuf_write, psbuf_cmp, NULL, notfn);

	signal(SIGHUP, takehup);
	puffs_ml_setloopfn(pu, psshfs_loopfn);
	if (pssh_connect(pu, PSSHFD_META) == -1)
		err(1, "can't connect meta");
	if (puffs_framev_addfd(pu, pctx.sshfd,
	    PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
		err(1, "framebuf addfd meta");
	if (numconnections == 2) {
		if (pssh_connect(pu, PSSHFD_DATA) == -1)
			err(1, "can't connect data");
		if (puffs_framev_addfd(pu, pctx.sshfd_data,
		    PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
			err(1, "framebuf addfd data");
	} else {
		pctx.sshfd_data = pctx.sshfd;
	}

	if (exportfs)
		puffs_setfhsize(pu, sizeof(struct psshfs_fid),
		    PUFFS_FHFLAG_NFSV2 | PUFFS_FHFLAG_NFSV3);

	rva = &pn_root->pn_va;
	rva->va_fileid = pctx.nextino++;

	/*
	 * For root link count, just guess something ridiculously high.
	 * Guessing too high has no known adverse effects, but fts(3)
	 * doesn't like too low values.  This guess will be replaced
	 * with the real value when readdir is first called for
	 * the root directory.
	 */
	rva->va_nlink = 8811;

	if (detach)
		if (puffs_daemon(pu, 1, 1) == -1)
			err(1, "puffs_daemon");

	if (puffs_mount(pu, argv[1], mntflags, puffs_getroot(pu)) == -1)
		err(1, "puffs_mount");
	if (puffs_setblockingmode(pu, PUFFSDEV_NONBLOCK) == -1)
		err(1, "setblockingmode");

	if (puffs_mainloop(pu) == -1)
		err(1, "mainloop");
	puffs_exit(pu, 1);

	return 0;
}

#define RETRY_MAX 100

void
psshfs_notify(struct puffs_usermount *pu, int fd, int what)
{
	struct psshfs_ctx *pctx = puffs_getspecific(pu);
	int nretry, which, newfd, dummy;

	if (fd == pctx->sshfd) {
		which = PSSHFD_META;
	} else {
		assert(fd == pctx->sshfd_data);
		which = PSSHFD_DATA;
	}

	if (puffs_getstate(pu) != PUFFS_STATE_RUNNING)
		return;

	if (what != (PUFFS_FBIO_READ | PUFFS_FBIO_WRITE)) {
		puffs_framev_removefd(pu, fd, ECONNRESET);
		return;
	}
	close(fd);

	/* deal with zmobies, beware of half-eaten brain */
	while (waitpid(-1, &dummy, WNOHANG) > 0)
		continue;

	for (nretry = 0;;nretry++) {
		if ((newfd = pssh_connect(pu, which)) == -1)
			goto retry2;

		if (puffs_framev_addfd(pu, newfd,
		    PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
			goto retry1;

		break;
 retry1:
		fprintf(stderr, "reconnect failed... ");
		close(newfd);
 retry2:
		if (nretry < RETRY_MAX) {
			fprintf(stderr, "retry (%d left)\n", RETRY_MAX-nretry);
			sleep(nretry);
		} else {
			fprintf(stderr, "retry count exceeded, going south\n");
			exit(1); /* XXXXXXX */
		}
	}
}

static int
pssh_connect(struct puffs_usermount *pu, int which)
{
	struct psshfs_ctx *pctx = puffs_getspecific(pu);
	char * const *sshargs = pctx->sshargs;
	int fds[2];
	pid_t pid;
	int dnfd, x;
	int *sshfd;
	pid_t *sshpid;

	if (which == PSSHFD_META) {
		sshfd = &pctx->sshfd;
		sshpid = &pctx->sshpid;
	} else {
		assert(which == PSSHFD_DATA);
		sshfd = &pctx->sshfd_data;
		sshpid = &pctx->sshpid_data;
	}

	if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1)
		return -1;

	pid = fork();
	switch (pid) {
	case -1:
		return -1;
		/*NOTREACHED*/
	case 0: /* child */
		if (dup2(fds[0], STDIN_FILENO) == -1)
			err(1, "child dup2");
		if (dup2(fds[0], STDOUT_FILENO) == -1)
			err(1, "child dup2");
		close(fds[0]);
		close(fds[1]);

		dnfd = open(_PATH_DEVNULL, O_RDWR);
		if (dnfd != -1)
			dup2(dnfd, STDERR_FILENO);

		execvp(sshargs[0], sshargs);
		/*NOTREACHED*/
		break;
	default:
		*sshpid = pid;
		*sshfd = fds[1];
		close(fds[0]);
		break;
	}

	if (psshfs_handshake(pu, *sshfd) != 0)
		errx(1, "handshake failed, server does not support sftp?");
	x = 1;
	if (ioctl(*sshfd, FIONBIO, &x) == -1)
		err(1, "nonblocking descriptor %d", which);

	return *sshfd;
}

static void *
invalone(struct puffs_usermount *pu, struct puffs_node *pn, void *arg)
{
	struct psshfs_node *psn = pn->pn_data;

	psn->attrread = 0;
	psn->dentread = 0;
	psn->slread = 0;

	return NULL;
}

static void
psshfs_loopfn(struct puffs_usermount *pu)
{

	if (sighup) {
		puffs_pn_nodewalk(pu, invalone, NULL);
		sighup = 0;
	}
}
Commit	Line	Data
ab5617b3 SW	1	/* $NetBSD: psshfs.c,v 1.63 2011/05/19 15:07:16 riastradh Exp $ */
	2
	3	/*
	4	* Copyright (c) 2006-2009 Antti Kantee. All Rights Reserved.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions
	8	* are met:
	9	* 1. Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* 2. Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	*
	15	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
	16	* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	17	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	18	* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	19	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	20	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	21	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	22	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	23	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	24	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	25	* SUCH DAMAGE.
	26	*/
	27
	28	/*
	29	* psshfs: puffs sshfs
	30	*
	31	* psshfs implements sshfs functionality on top of puffs making it
	32	* possible to mount a filesystme through the sftp service.
	33	*
	34	* psshfs can execute multiple operations in "parallel" by using the
	35	* puffs_cc framework for continuations.
	36	*
	37	* Concurrency control is handled currently by vnode locking (this
	38	* will change in the future). Context switch locations are easy to
	39	* find by grepping for puffs_framebuf_enqueue_cc().
	40	*/
	41
	42	#include <sys/types.h>
	43	#include <sys/wait.h>
	44	#include <sys/ioctl.h>
	45	#include <sys/socket.h>
	46	#include <sys/uio.h>
	47
	48	#include <assert.h>
	49	#include <err.h>
	50	#include <errno.h>
	51	#include <paths.h>
	52	#include <poll.h>
	53	#include <puffs.h>
	54	#include <signal.h>
	55	#include <stdlib.h>
	56	#include <stdio.h>
	57	#include <unistd.h>
	58
	59	#include "psshfs.h"
	60	#include "util_compat.h"
	61
	62	static int pssh_connect(struct puffs_usermount *, int);
	63	static void psshfs_loopfn(struct puffs_usermount *);
	64	static void usage(void);
65	static void add_ssharg(char **, int , const char *);
66	static void psshfs_notify(struct puffs_usermount *, int, int);
67
68	#define SSH_PATH "/usr/bin/ssh"
69
70	unsigned int max_reads;
71	static int sighup;
72
73	static void
74	add_ssharg(char **sshargs, int nargs, const char *arg)
75	{
76
77	sshargs = realloc(sshargs, (nargs + 2) sizeof(char*));
78	if (!*sshargs)
79	err(1, "realloc");
80	(sshargs)[(nargs)++] = estrdup(arg);
81	(sshargs)[nargs] = NULL;
82	}
83
84	static void
89a89091	85	usage(void)
ab5617b3 SW	86	{
	87
	88	fprintf(stderr, "usage: %s "
	89	"[-ceprst] [-F configfile] [-O sshopt=value] [-o opts] "
	90	"user@host:path mountpath\n",
	91	getprogname());
	92	exit(1);
	93	}
	94
	95	static void
	96	takehup(int sig)
	97	{
	98
	99	sighup = 1;
	100	}
	101
	102	int
	103	main(int argc, char *argv[])
	104	{
	105	struct psshfs_ctx pctx;
	106	struct puffs_usermount *pu;
	107	struct puffs_ops *pops;
	108	struct psshfs_node *root = &pctx.psn_root;
	109	struct puffs_node *pn_root;
	110	puffs_framev_fdnotify_fn notfn;
	111	struct vattr *rva;
	112	char **sshargs;
	113	char *userhost;
	114	char *hostpath;
	115	int mntflags, pflags, ch;
	116	int detach;
	117	int exportfs, refreshival, numconnections;
	118	int nargs;
	119
	120	setprogname(argv[0]);
	121	puffs_unmountonsignal(SIGINT, true);
	122	puffs_unmountonsignal(SIGTERM, true);
	123
	124	if (argc < 3)
	125	usage();
	126
	127	memset(&pctx, 0, sizeof(pctx));
	128	mntflags = pflags = exportfs = nargs = 0;
	129	numconnections = 1;
	130	detach = 1;
	131	refreshival = DEFAULTREFRESH;
	132	notfn = puffs_framev_unmountonclose;
	133	sshargs = NULL;
	134	add_ssharg(&sshargs, &nargs, SSH_PATH);
	135	add_ssharg(&sshargs, &nargs, "-axs");
	136	add_ssharg(&sshargs, &nargs, "-oClearAllForwardings=yes");
	137
	138	while ((ch = getopt(argc, argv, "c:eF:g:o:O:pr:st:u:")) != -1) {
	139	switch (ch) {
	140	case 'c':
	141	numconnections = atoi(optarg);
	142	if (numconnections < 1 \|\| numconnections > 2) {
	143	fprintf(stderr, "%s: only 1 or 2 connections "
	144	"permitted currently\n", getprogname());
	145	usage();
	146	/NOTREACHED/
	147	}
	148	break;
	149	case 'e':
150	exportfs = 1;
151	break;
152	case 'F':
153	add_ssharg(&sshargs, &nargs, "-F");
154	add_ssharg(&sshargs, &nargs, optarg);
155	break;
156	case 'g':
157	pctx.domanglegid = 1;
158	pctx.manglegid = atoi(optarg);
159	if (pctx.manglegid == (gid_t)-1)
160	errx(1, "-1 not allowed for -g");
161	pctx.mygid = getegid();
162	break;
163	case 'O':
164	add_ssharg(&sshargs, &nargs, "-o");
165	add_ssharg(&sshargs, &nargs, optarg);
166	break;
167	case 'o':
168	getmntopts(optarg, puffsmopts, &mntflags, &pflags);
169	break;
170	case 'p':
171	notfn = psshfs_notify;
172	break;
173	case 'r':
174	max_reads = atoi(optarg);
175	break;
176	case 's':
177	detach = 0;
178	break;
179	case 't':
180	refreshival = atoi(optarg);
181	if (refreshival < 0 && refreshival != -1)
182	errx(1, "invalid timeout %d", refreshival);
183	break;
184	case 'u':
185	pctx.domangleuid = 1;
186	pctx.mangleuid = atoi(optarg);
187	if (pctx.mangleuid == (uid_t)-1)
188	errx(1, "-1 not allowed for -u");
189	pctx.myuid = geteuid();
190	break;
191	default:
192	usage();
193	/NOTREACHED/
194	}
195	}
196	argc -= optind;
197	argv += optind;
198
199	if (pflags & PUFFS_FLAG_OPDUMP)
200	detach = 0;
201	pflags \|= PUFFS_FLAG_BUILDPATH;
202	pflags \|= PUFFS_KFLAG_WTCACHE \| PUFFS_KFLAG_IAONDEMAND;
203
204	if (argc != 2)
205	usage();
206
207	PUFFSOP_INIT(pops);
208
209	PUFFSOP_SET(pops, psshfs, fs, unmount);
210	PUFFSOP_SETFSNOP(pops, sync); /* XXX */
211	PUFFSOP_SET(pops, psshfs, fs, statvfs);
212	PUFFSOP_SET(pops, psshfs, fs, nodetofh);
213	PUFFSOP_SET(pops, psshfs, fs, fhtonode);
214
215	PUFFSOP_SET(pops, psshfs, node, lookup);
216	PUFFSOP_SET(pops, psshfs, node, create);
217	PUFFSOP_SET(pops, psshfs, node, open);
218	PUFFSOP_SET(pops, psshfs, node, inactive);
219	PUFFSOP_SET(pops, psshfs, node, readdir);
220	PUFFSOP_SET(pops, psshfs, node, getattr);
221	PUFFSOP_SET(pops, psshfs, node, setattr);
222	PUFFSOP_SET(pops, psshfs, node, mkdir);
223	PUFFSOP_SET(pops, psshfs, node, remove);
224	PUFFSOP_SET(pops, psshfs, node, readlink);
225	PUFFSOP_SET(pops, psshfs, node, rmdir);
3f35aa53	226	PUFFSOP_SET(pops, psshfs, node, link);
ab5617b3 SW	227	PUFFSOP_SET(pops, psshfs, node, symlink);
	228	PUFFSOP_SET(pops, psshfs, node, rename);
	229	PUFFSOP_SET(pops, psshfs, node, read);
	230	PUFFSOP_SET(pops, psshfs, node, write);
	231	PUFFSOP_SET(pops, psshfs, node, reclaim);
	232
	233	pu = puffs_init(pops, argv[0], "psshfs", &pctx, pflags);
	234	if (pu == NULL)
	235	err(1, "puffs_init");
	236
	237	pctx.mounttime = time(NULL);
	238	pctx.refreshival = refreshival;
	239	pctx.numconnections = numconnections;
	240
	241	userhost = argv[0];
	242	hostpath = strchr(userhost, ':');
	243	if (hostpath) {
	244	*hostpath++ = '\0';
	245	pctx.mountpath = hostpath;
	246	} else
	247	pctx.mountpath = ".";
	248
	249	add_ssharg(&sshargs, &nargs, argv[0]);
	250	add_ssharg(&sshargs, &nargs, "sftp");
	251	pctx.sshargs = sshargs;
	252
	253	pctx.nextino = 2;
	254	memset(root, 0, sizeof(struct psshfs_node));
	255	TAILQ_INIT(&root->pw);
	256	pn_root = puffs_pn_new(pu, root);
	257	if (pn_root == NULL)
	258	return errno;
	259	puffs_setroot(pu, pn_root);
	260
	261	puffs_framev_init(pu, psbuf_read, psbuf_write, psbuf_cmp, NULL, notfn);
	262
	263	signal(SIGHUP, takehup);
	264	puffs_ml_setloopfn(pu, psshfs_loopfn);
	265	if (pssh_connect(pu, PSSHFD_META) == -1)
	266	err(1, "can't connect meta");
	267	if (puffs_framev_addfd(pu, pctx.sshfd,
	268	PUFFS_FBIO_READ \| PUFFS_FBIO_WRITE) == -1)
	269	err(1, "framebuf addfd meta");
	270	if (numconnections == 2) {
	271	if (pssh_connect(pu, PSSHFD_DATA) == -1)
	272	err(1, "can't connect data");
	273	if (puffs_framev_addfd(pu, pctx.sshfd_data,
	274	PUFFS_FBIO_READ \| PUFFS_FBIO_WRITE) == -1)
	275	err(1, "framebuf addfd data");
	276	} else {
	277	pctx.sshfd_data = pctx.sshfd;
	278	}
	279
	280	if (exportfs)
	281	puffs_setfhsize(pu, sizeof(struct psshfs_fid),
	282	PUFFS_FHFLAG_NFSV2 \| PUFFS_FHFLAG_NFSV3);
	283
	284	rva = &pn_root->pn_va;
	285	rva->va_fileid = pctx.nextino++;
	286
	287	/*
	288	* For root link count, just guess something ridiculously high.
	289	* Guessing too high has no known adverse effects, but fts(3)
	290	* doesn't like too low values. This guess will be replaced
291	* with the real value when readdir is first called for
292	* the root directory.
293	*/
294	rva->va_nlink = 8811;
295
296	if (detach)
297	if (puffs_daemon(pu, 1, 1) == -1)
298	err(1, "puffs_daemon");
299
300	if (puffs_mount(pu, argv[1], mntflags, puffs_getroot(pu)) == -1)
301	err(1, "puffs_mount");
302	if (puffs_setblockingmode(pu, PUFFSDEV_NONBLOCK) == -1)
303	err(1, "setblockingmode");
304
305	if (puffs_mainloop(pu) == -1)
306	err(1, "mainloop");
307	puffs_exit(pu, 1);
308
309	return 0;
310	}
311
312	#define RETRY_MAX 100
313
314	void
315	psshfs_notify(struct puffs_usermount *pu, int fd, int what)
316	{
317	struct psshfs_ctx *pctx = puffs_getspecific(pu);
318	int nretry, which, newfd, dummy;
319
320	if (fd == pctx->sshfd) {
321	which = PSSHFD_META;
322	} else {
323	assert(fd == pctx->sshfd_data);
324	which = PSSHFD_DATA;
325	}
326
327	if (puffs_getstate(pu) != PUFFS_STATE_RUNNING)
328	return;
329
330	if (what != (PUFFS_FBIO_READ \| PUFFS_FBIO_WRITE)) {
331	puffs_framev_removefd(pu, fd, ECONNRESET);
332	return;
333	}
334	close(fd);
335
336	/* deal with zmobies, beware of half-eaten brain */
337	while (waitpid(-1, &dummy, WNOHANG) > 0)
338	continue;
339
340	for (nretry = 0;;nretry++) {
341	if ((newfd = pssh_connect(pu, which)) == -1)
342	goto retry2;
343
344	if (puffs_framev_addfd(pu, newfd,
345	PUFFS_FBIO_READ \| PUFFS_FBIO_WRITE) == -1)
346	goto retry1;
347
348	break;
349	retry1:
350	fprintf(stderr, "reconnect failed... ");
351	close(newfd);
352	retry2:
353	if (nretry < RETRY_MAX) {
354	fprintf(stderr, "retry (%d left)\n", RETRY_MAX-nretry);
355	sleep(nretry);
356	} else {
357	fprintf(stderr, "retry count exceeded, going south\n");
358	exit(1); /* XXXXXXX */
359	}
360	}
361	}
362
363	static int
364	pssh_connect(struct puffs_usermount *pu, int which)
365	{
366	struct psshfs_ctx *pctx = puffs_getspecific(pu);
367	char * const *sshargs = pctx->sshargs;
368	int fds[2];
369	pid_t pid;
370	int dnfd, x;
371	int *sshfd;
372	pid_t *sshpid;
373
374	if (which == PSSHFD_META) {
375	sshfd = &pctx->sshfd;
376	sshpid = &pctx->sshpid;
377	} else {
378	assert(which == PSSHFD_DATA);
379	sshfd = &pctx->sshfd_data;
380	sshpid = &pctx->sshpid_data;
381	}
382
383	if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == -1)
384	return -1;
385
386	pid = fork();
387	switch (pid) {
388	case -1:
389	return -1;
390	/NOTREACHED/
391	case 0: /* child */
392	if (dup2(fds[0], STDIN_FILENO) == -1)
393	err(1, "child dup2");
394	if (dup2(fds[0], STDOUT_FILENO) == -1)
395	err(1, "child dup2");
396	close(fds[0]);
397	close(fds[1]);
398
399	dnfd = open(_PATH_DEVNULL, O_RDWR);
400	if (dnfd != -1)
401	dup2(dnfd, STDERR_FILENO);
402
403	execvp(sshargs[0], sshargs);
404	/NOTREACHED/
405	break;
406	default:
407	*sshpid = pid;
408	*sshfd = fds[1];
409	close(fds[0]);
410	break;
411	}
412
413	if (psshfs_handshake(pu, *sshfd) != 0)
414	errx(1, "handshake failed, server does not support sftp?");
415	x = 1;
416	if (ioctl(*sshfd, FIONBIO, &x) == -1)
417	err(1, "nonblocking descriptor %d", which);
418
419	return *sshfd;
420	}
421
422	static void *
423	invalone(struct puffs_usermount pu, struct puffs_node pn, void *arg)
424	{
425	struct psshfs_node *psn = pn->pn_data;
426
427	psn->attrread = 0;
428	psn->dentread = 0;
429	psn->slread = 0;
430
431	return NULL;
432	}
433
434	static void
435	psshfs_loopfn(struct puffs_usermount *pu)
436	{
437
438	if (sighup) {
439	puffs_pn_nodewalk(pu, invalone, NULL);
440	sighup = 0;
441	}
442	}