 @@ -1,14 +1,14 @@
-/*	$NetBSD: fs.c,v 1.18 2009/02/23 18:43:46 pooka Exp $	*/
+/*	$NetBSD: fs.c,v 1.19 2009/05/20 13:56:36 pooka Exp $	*/
 /*
  * Copyright (c) 2006  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.
+ *
 @@ -17,27 +17,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: fs.c,v 1.18 2009/02/23 18:43:46 pooka Exp $");
+__RCSID("$NetBSD: fs.c,v 1.19 2009/05/20 13:56:36 pooka Exp $");
 #endif /* !lint */
 #include <err.h>
 #include <errno.h>
 #include <puffs.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include "psshfs.h"
 #include "sftp_proto.h"
 @@ -74,91 +74,91 @@ static const struct extunit {
 	"2",
 	SFTP_EXT_STATVFS,
 },{
 	"fstatvfs@openssh.com",
 	"2",
 	SFTP_EXT_FSTATVFS,
 },{
 	NULL,
 	NULL,
 }};
 int
-psshfs_handshake(struct puffs_usermount *pu)
+psshfs_handshake(struct puffs_usermount *pu, int fd)
+{
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	struct puffs_framebuf *pb;
 	struct puffs_pathobj *po_root;
 	struct puffs_node *pn_root;
 	struct vattr va, *rva;
 	const struct extunit *extu;
 	char *rootpath;
 	char *ext, *val;
 	uint32_t count;
 	int rv, done;
 	pb = psbuf_makeout();
 	psbuf_put_1(pb, SSH_FXP_INIT);
 	psbuf_put_4(pb, SFTP_PROTOVERSION);
-	DO_IO(psbuf_write, pu, pb, pctx->sshfd, &done, rv);
+	DO_IO(psbuf_write, pu, pb, fd, &done, rv);
 	puffs_framebuf_recycle(pb);
-	DO_IO(psbuf_read, pu, pb, pctx->sshfd, &done, rv);
+	DO_IO(psbuf_read, pu, pb, fd, &done, rv);
 	if (psbuf_get_type(pb) != SSH_FXP_VERSION)
 		reterr((stderr, "invalid server response: %d",
 		    psbuf_get_type(pb)), EPROTO);
 	pctx->protover = psbuf_get_reqid(pb);
 	/*
 	 * Check out which extensions are available.  Currently
 	 * we are only interested in the openssh statvfs extension.
 	 */
 	for (;;) {
 		if (psbuf_get_str(pb, &ext, NULL) != 0)
 			break;
 		if (psbuf_get_str(pb, &val, NULL) != 0)
 			break;
 		for (extu = exttable; extu->ext; extu++)
 			if (strcmp(ext, extu->ext) == 0
 			    && strcmp(val, extu->val) == 0)
 				pctx->extensions |= extu->extflag;
+	}
 	/* scope out our rootpath */
 	psbuf_recycleout(pb);
 	psbuf_put_1(pb, SSH_FXP_REALPATH);
 	psbuf_put_4(pb, NEXTREQ(pctx));
 	psbuf_put_str(pb, pctx->mountpath);
-	DO_IO(psbuf_write, pu, pb, pctx->sshfd, &done, rv);
+	DO_IO(psbuf_write, pu, pb, fd, &done, rv);
 	puffs_framebuf_recycle(pb);
-	DO_IO(psbuf_read, pu, pb, pctx->sshfd, &done, rv);
+	DO_IO(psbuf_read, pu, pb, fd, &done, rv);
 	if (psbuf_get_type(pb) != SSH_FXP_NAME)
 		reterr((stderr, "invalid server realpath response for \"%s\"",
 		    pctx->mountpath), EPROTO);
 	if (psbuf_get_4(pb, &count) == -1)
 		reterr((stderr, "invalid realpath response: count"), EPROTO);
 	if (psbuf_get_str(pb, &rootpath, NULL) == -1)
 		reterr((stderr, "invalid realpath response: rootpath"), EPROTO);
 	/* stat the rootdir so that we know it's a dir */
 	psbuf_recycleout(pb);
 	psbuf_req_str(pb, SSH_FXP_LSTAT, NEXTREQ(pctx), rootpath);
-	DO_IO(psbuf_write, pu, pb, pctx->sshfd, &done, rv);
+	DO_IO(psbuf_write, pu, pb, fd, &done, rv);
 	puffs_framebuf_recycle(pb);
-	DO_IO(psbuf_read, pu, pb, pctx->sshfd, &done, rv);
+	DO_IO(psbuf_read, pu, pb, fd, &done, rv);
 	rv = psbuf_expect_attrs(pb, &va);
 	if (rv)
 		reterr((stderr, "couldn't stat rootpath"), rv);
 	puffs_framebuf_destroy(pb);
 	if (puffs_mode2vt(va.va_mode) != VDIR)
 		reterr((stderr, "remote path (%s) not a directory", rootpath),
 		    ENOTDIR);
 	pn_root = puffs_getroot(pu);
 	rva = &pn_root->pn_va;
 	puffs_setvattr(rva, &va);
 @@ -177,27 +177,27 @@ psshfs_fs_statvfs(struct puffs_usermount
+{
 	PSSHFSAUTOVAR(pu);
 	uint64_t tmpval;
 	uint8_t type;
 	memset(sbp, 0, sizeof(*sbp));
 	sbp->f_bsize = sbp->f_frsize = sbp->f_iosize = 512;
 	if ((pctx->extensions & SFTP_EXT_STATVFS) == 0)
 		goto out;
 	psbuf_req_str(pb, SSH_FXP_EXTENDED, reqid, "statvfs@openssh.com");
 	psbuf_put_str(pb, pctx->mountpath);
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	type = psbuf_get_type(pb);
 	if (type != SSH_FXP_EXTENDED_REPLY) {
 		/* use the default */
 		goto out;
+	}
 	psbuf_get_8(pb, &tmpval);
 	sbp->f_bsize = tmpval;
 	psbuf_get_8(pb, &tmpval);
 	sbp->f_frsize = tmpval;
 	psbuf_get_8(pb, &sbp->f_blocks);
 	psbuf_get_8(pb, &sbp->f_bfree);
 @@ -212,26 +212,31 @@ psshfs_fs_statvfs(struct puffs_usermount
 	sbp->f_namemax = tmpval;
  out:
 	PSSHFSRETURN(rv);
+}
 int
 psshfs_fs_unmount(struct puffs_usermount *pu, int flags)
+{
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	kill(pctx->sshpid, SIGTERM);
 	close(pctx->sshfd);
 	if (pctx->numconnections == 2) {
 		kill(pctx->sshpid_data, SIGTERM);
 		close(pctx->sshfd_data);
+	}
 	return 0;
+}
 int
 psshfs_fs_nodetofh(struct puffs_usermount *pu, puffs_cookie_t cookie,
 	void *fid, size_t *fidsize)
+{
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	struct puffs_node *pn = cookie;
 	struct psshfs_node *psn = pn->pn_data;
 	struct psshfs_fid *pf = fid;
 	pf->mounttime = pctx->mounttime;

 @@ -1,39 +1,39 @@
-.\"	$NetBSD: mount_psshfs.8,v 1.19 2009/02/26 07:14:36 wiz Exp $
+.\"	$NetBSD: mount_psshfs.8,v 1.20 2009/05/20 13:56:36 pooka Exp $
 .\"
 .\" Copyright (c) 2007 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 AND CONTRIBUTORS ``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.
 .\"
-.Dd February 25, 2009
+.Dd May 20, 2009
 .Dt MOUNT_PSSHFS 8
 .Os
 .Sh NAME
 .Nm mount_psshfs
 .Nd sshfs implementation for puffs
 .Sh SYNOPSIS
 .Nm
 .Op Ar options
 .Ar user@host[:path]
 .Ar mount_point
 .Sh DESCRIPTION
 The
 .Nm
 @@ -46,26 +46,39 @@ This functionality is commonly known as
 The mandatory parameters are the target host name and local mount
 point.
 The target host parameter can optionally contain a username whose
 credentials will be used by the remote sshd, and a relative or
 absolute path for the remote mount point's root.
 If no user is given, the credentials of the user issuing the mount
 command are used.
 If no path is given, the user's home directory on the remote machine
 will be used.
 .Pp
 The following command line options are available:
 .Pp
 .Bl -tag -width xxx
 .It Fl c Ar nconnect
 Opens
 .Ar nconnect
 connections to the server.
 Currently, the value has to be 1 or 2.
 If 2 is specified, a second connection is opened for the reading
 and writing of data, while directory operations are performed on
 their own connection.
 This can greatly increase directory operation performance (ls,
 mkdir, etc.) if
 .Nm
 completely saturates the available bandwidth by doing bulk data copying.
 The default is 1.
 .It Fl e
 Makes the mounted file system NFS exportable.
 If this option is used, it is very important to understand that
 .Nm
 can not provide complete support for NFS due to the limitations in
 the backend.
 Files are valid only for the time that
 .Nm
 is running and in the event of e.g. a server crash, all client retries
 to access files will fail.
 .It Fl F Ar configfile
 Pass a configuration file to
 .Xr ssh 1 .

 @@ -1,14 +1,14 @@
-/*	$NetBSD: node.c,v 1.56 2009/03/29 16:06:53 pooka Exp $	*/
+/*	$NetBSD: node.c,v 1.57 2009/05/20 13:56:36 pooka Exp $	*/
 /*
  * Copyright (c) 2006  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.
+ *
 @@ -17,27 +17,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: node.c,v 1.56 2009/03/29 16:06:53 pooka Exp $");
+__RCSID("$NetBSD: node.c,v 1.57 2009/05/20 13:56:36 pooka Exp $");
 #endif /* !lint */
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "psshfs.h"
 #include "sftp_proto.h"
 int
 psshfs_node_lookup(struct puffs_usermount *pu, puffs_cookie_t opc,
 	struct puffs_newinfo *pni, const struct puffs_cn *pcn)
 @@ -138,79 +138,79 @@ psshfs_node_setattr(struct puffs_usermou
 			kludgeva.va_mtime.tv_sec = pn->pn_va.va_mtime.tv_sec;
 		else
 			kludgeva.va_mtime.tv_sec = va->va_atime.tv_sec;
+	}
 	if (va->va_mtime.tv_sec != PUFFS_VNOVAL
 	    && va->va_atime.tv_sec == PUFFS_VNOVAL) {
 		if (pn->pn_va.va_atime.tv_sec != PUFFS_VNOVAL)
 			kludgeva.va_atime.tv_sec = pn->pn_va.va_atime.tv_sec;
 		else
 			kludgeva.va_atime.tv_sec = va->va_mtime.tv_sec;
+	}
 	psbuf_put_vattr(pb, &kludgeva);
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	rv = psbuf_expect_status(pb);
 	if (rv == 0)
 		puffs_setvattr(&pn->pn_va, &kludgeva);
  out:
 	PSSHFSRETURN(rv);
+}
 int
 psshfs_node_create(struct puffs_usermount *pu, puffs_cookie_t opc,
 	struct puffs_newinfo *pni, const struct puffs_cn *pcn,
 	const struct vattr *va)
+{
 	PSSHFSAUTOVAR(pu);
 	struct puffs_node *pn = opc;
 	struct puffs_node *pn_new;
 	char *fhand = NULL;
 	uint32_t fhandlen;
 	/* Create node on server first */
 	psbuf_req_str(pb, SSH_FXP_OPEN, reqid, PCNPATH(pcn));
 	psbuf_put_4(pb, SSH_FXF_WRITE | SSH_FXF_CREAT | SSH_FXF_TRUNC);
 	psbuf_put_vattr(pb, va);
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	rv = psbuf_expect_handle(pb, &fhand, &fhandlen);
 	if (rv)
 		goto out;
 	/*
 	 * Do *not* create the local node before getting a response
 	 * from the server.  Otherwise we might screw up consistency,
 	 * namely that the node can be looked up before create has
 	 * returned (mind you, the kernel will unlock the directory
 	 * before the create call from userspace returns).
 	 */
 	pn_new = allocnode(pu, pn, pcn->pcn_name, va);
 	if (!pn_new) {
 		struct puffs_framebuf *pb2 = psbuf_makeout();
 		reqid = NEXTREQ(pctx);
 		psbuf_req_str(pb2, SSH_FXP_REMOVE, reqid, PCNPATH(pcn));
-		JUSTSEND(pb2);
+		JUSTSEND(pb2, pctx->sshfd);
 		rv = ENOMEM;
+	}
 	if (pn_new)
 		puffs_newinfo_setcookie(pni, pn_new);
 	reqid = NEXTREQ(pctx);
 	psbuf_recycleout(pb);
 	psbuf_req_data(pb, SSH_FXP_CLOSE, reqid, fhand, fhandlen);
-	JUSTSEND(pb);
+	JUSTSEND(pb, pctx->sshfd);
 	free(fhand);
 	return rv;
  out:
 	free(fhand);
 	PSSHFSRETURN(rv);
+}
 /*
  * Open a file handle.  This is used for read and write.  We do not
  * wait here for the success or failure of this operation.  This is
  * because otherwise opening and closing file handles would block
  * reading potentially cached information.  Rather, we defer the wait
 @@ -238,45 +238,45 @@ psshfs_node_open(struct puffs_usermount
 		return 0;
 	puffs_setback(pcc, PUFFS_SETBACK_INACT_N1);
 	puffs_vattr_null(&va);
 	didread = didwrite = 0;
 	if (mode & FREAD && psn->fhand_r == NULL && psn->lazyopen_r == NULL) {
 		pb = psbuf_makeout();
 		reqid = NEXTREQ(pctx);
 		psbuf_req_str(pb, SSH_FXP_OPEN, reqid, PNPATH(pn));
 		psbuf_put_4(pb, SSH_FXF_READ);
 		psbuf_put_vattr(pb, &va);
-		if (puffs_framev_enqueue_cb(pu, pctx->sshfd, pb,
+		if (puffs_framev_enqueue_cb(pu, pctx->sshfd_data, pb,
 		    lazyopen_rresp, psn, 0) == -1) {
 			rv = errno;
 			puffs_framebuf_destroy(pb);
 			goto out;
+		}
 		psn->lazyopen_r = pb;
 		didread = 1;
+	}
 	if (mode & FWRITE && psn->fhand_w == NULL && psn->lazyopen_w == NULL) {
 		pb2 = psbuf_makeout();
 		reqid = NEXTREQ(pctx);
 		psbuf_req_str(pb2, SSH_FXP_OPEN, reqid, PNPATH(pn));
 		psbuf_put_4(pb2, SSH_FXF_WRITE);
 		psbuf_put_vattr(pb2, &va);
-		if (puffs_framev_enqueue_cb(pu, pctx->sshfd, pb2,
+		if (puffs_framev_enqueue_cb(pu, pctx->sshfd_data, pb2,
 		    lazyopen_wresp, psn, 0) == -1) {
 			rv = errno;
 			puffs_framebuf_destroy(pb2);
 			goto out;
+		}
 		psn->lazyopen_w = pb2;
 		didwrite = 1;
+	}
 	psn->stat &= ~PSN_HANDLECLOSE;
  out:
 	/* wait? */
 @@ -470,27 +470,27 @@ psshfs_node_read(struct puffs_usermount
 	/*
 	 * Do this *after* accessing the file, the handle might not
 	 * exist after blocking.
 	 */
 	if (max_reads && ++psn->readcount > max_reads) {
 		struct psshfs_wait pw;
 		pw.pw_cc = pcc;
 		pw.pw_type = PWTYPE_READ2;
 		TAILQ_INSERT_TAIL(&psn->pw, &pw, pw_entries);
 		puffs_cc_yield(pcc);
+	}
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd_data);
 	rv = psbuf_do_data(pb, buf, &readlen);
 	if (rv == 0)
 		*resid -= readlen;
  out:
 	if (max_reads && --psn->readcount >= max_reads) {
 		TAILQ_FOREACH(pwp, &psn->pw, pw_entries)
 			if (pwp->pw_type == PWTYPE_READ2)
 				break;
 		assert(pwp != NULL);
 		puffs_cc_schedule(pwp->pw_cc);
 		TAILQ_REMOVE(&psn->pw, pwp, pw_entries);
 @@ -564,27 +564,27 @@ psshfs_node_write(struct puffs_usermount
 			goto out;
+	}
 	if (!psn->fhand_w) {
 		abort();
 		rv = EINVAL;
 		goto out;
+	}
 	writelen = *resid;
 	psbuf_req_data(pb, SSH_FXP_WRITE, reqid, psn->fhand_w,psn->fhand_w_len);
 	psbuf_put_8(pb, offset);
 	psbuf_put_data(pb, buf, writelen);
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd_data);
 	rv = psbuf_expect_status(pb);
 	if (rv == 0)
 		*resid = 0;
 	if (pn->pn_va.va_size < offset + writelen)
 		pn->pn_va.va_size = offset + writelen;
  out:
 	/* check if we need a lazyclose */
 	if (psn->stat & PSN_HANDLECLOSE && psn->fhand_w) {
 		TAILQ_FOREACH(pwp, &psn->pw, pw_entries)
 			if (pwp->pw_type == PWTYPE_WRITE)
 @@ -616,27 +616,27 @@ psshfs_node_readlink(struct puffs_usermo
 	 * from the server if we get many requests at once, but that's
 	 * quite harmless as this routine is reentrant.
 	 */
 	if (psn->symlink && !REFRESHTIMEOUT(pctx, time(NULL) - psn->slread))
 		goto copy;
 	if (psn->symlink) {
 		free(psn->symlink);
 		psn->symlink = NULL;
 		psn->slread = 0;
+	}
 	psbuf_req_str(pb, SSH_FXP_READLINK, reqid, PNPATH(pn));
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	rv = psbuf_expect_name(pb, &count);
 	if (rv)
 		goto out;
 	if (count != 1) {
 		rv = EPROTO;
 		goto out;
+	}
 	rv = psbuf_get_str(pb, &psn->symlink, NULL);
 	if (rv)
 		goto out;
 	psn->slread = time(NULL);
 @@ -652,27 +652,27 @@ psshfs_node_readlink(struct puffs_usermo
 static int
 doremove(struct puffs_usermount *pu, struct puffs_node *pn_dir,
 	struct puffs_node *pn, const char *name)
+{
 	PSSHFSAUTOVAR(pu);
 	int op;
 	if (pn->pn_va.va_type == VDIR)
 		op = SSH_FXP_RMDIR;
 	else
 		op = SSH_FXP_REMOVE;
 	psbuf_req_str(pb, op, reqid, PNPATH(pn));
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	rv = psbuf_expect_status(pb);
 	if (rv == 0)
 		nukenode(pn, name, 0);
  out:
 	PSSHFSRETURN(rv);
+}
 int
 psshfs_node_remove(struct puffs_usermount *pu, puffs_cookie_t opc,
 	puffs_cookie_t targ, const struct puffs_cn *pcn)
+{
 @@ -705,41 +705,41 @@ psshfs_node_rmdir(struct puffs_usermount
+}
 int
 psshfs_node_mkdir(struct puffs_usermount *pu, puffs_cookie_t opc,
 	struct puffs_newinfo *pni, const struct puffs_cn *pcn,
 	const struct vattr *va)
+{
 	PSSHFSAUTOVAR(pu);
 	struct puffs_node *pn = opc;
 	struct puffs_node *pn_new;
 	psbuf_req_str(pb, SSH_FXP_MKDIR, reqid, PCNPATH(pcn));
 	psbuf_put_vattr(pb, va);
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	rv = psbuf_expect_status(pb);
 	if (rv)
 		goto out;
 	pn_new = allocnode(pu, pn, pcn->pcn_name, va);
 	if (pn_new) {
 		puffs_newinfo_setcookie(pni, pn_new);
 	} else {
 		struct puffs_framebuf *pb2 = psbuf_makeout();
 		reqid = NEXTREQ(pctx);
 		psbuf_recycleout(pb2);
 		psbuf_req_str(pb2, SSH_FXP_RMDIR, reqid, PCNPATH(pcn));
-		JUSTSEND(pb2);
+		JUSTSEND(pb2, pctx->sshfd);
 		rv = ENOMEM;
+	}
  out:
 	PSSHFSRETURN(rv);
+}
 int
 psshfs_node_symlink(struct puffs_usermount *pu, puffs_cookie_t opc,
 	struct puffs_newinfo *pni, const struct puffs_cn *pcn,
 	const struct vattr *va, const char *link_target)
+{
 	PSSHFSAUTOVAR(pu);
 @@ -747,41 +747,41 @@ psshfs_node_symlink(struct puffs_usermou
 	struct puffs_node *pn_new;
 	if (pctx->protover < 3) {
 		rv = EOPNOTSUPP;
 		goto out;
+	}
 	/*
 	 * XXX: ietf says: source, target.  openssh says: ietf who?
 	 * Let's go with openssh and build quirk tables later if we care
 	 */
 	psbuf_req_str(pb, SSH_FXP_SYMLINK, reqid, link_target);
 	psbuf_put_str(pb, PCNPATH(pcn));
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	rv = psbuf_expect_status(pb);
 	if (rv)
 		goto out;
 	pn_new = allocnode(pu, pn, pcn->pcn_name, va);
 	if (pn_new) {
 		puffs_newinfo_setcookie(pni, pn_new);
 	} else {
 		struct puffs_framebuf *pb2 = psbuf_makeout();
 		reqid = NEXTREQ(pctx);
 		psbuf_recycleout(pb2);
 		psbuf_req_str(pb2, SSH_FXP_REMOVE, reqid, PCNPATH(pcn));
-		JUSTSEND(pb2);
+		JUSTSEND(pb2, pctx->sshfd);
 		rv = ENOMEM;
+	}
  out:
 	PSSHFSRETURN(rv);
+}
 int
 psshfs_node_rename(struct puffs_usermount *pu, puffs_cookie_t opc,
 	puffs_cookie_t src, const struct puffs_cn *pcn_src,
 	puffs_cookie_t targ_dir, puffs_cookie_t targ,
 	const struct puffs_cn *pcn_targ)
+{
 @@ -794,27 +794,27 @@ psshfs_node_rename(struct puffs_usermoun
 	if (pctx->protover < 2) {
 		rv = EOPNOTSUPP;
 		goto out;
+	}
 	if (pn_tf) {
 		rv = doremove(pu, targ_dir, pn_tf, pcn_targ->pcn_name);
 		if (rv)
 			goto out;
+	}
 	psbuf_req_str(pb, SSH_FXP_RENAME, reqid, PCNPATH(pcn_src));
 	psbuf_put_str(pb, PCNPATH(pcn_targ));
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	rv = psbuf_expect_status(pb);
 	if (rv == 0) {
 		struct psshfs_dir *pd;
 		/*
 		 * XXX: interfaces didn't quite work with rename..
 		 * the song remains the same.  go figure .. ;)
 		 */
 		nukenode(pn_sf, pcn_src->pcn_name, 0);
 		pd = direnter(pn_td, pcn_targ->pcn_name);
 		pd->entry = pn_sf;
 		puffs_setvattr(&pd->va, &pn_sf->pn_va);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: psshfs.c,v 1.50 2009/02/23 18:43:46 pooka Exp $	*/
+/*	$NetBSD: psshfs.c,v 1.51 2009/05/20 13:56:36 pooka Exp $	*/
 /*
  * Copyright (c) 2006  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.
+ *
 @@ -31,73 +31,73 @@
  * 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/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: psshfs.c,v 1.50 2009/02/23 18:43:46 pooka Exp $");
+__RCSID("$NetBSD: psshfs.c,v 1.51 2009/05/20 13:56:36 pooka Exp $");
 #endif /* !lint */
 #include <sys/types.h>
 #include <assert.h>
 #include <err.h>
 #include <errno.h>
 #include <mntopts.h>
 #include <paths.h>
 #include <poll.h>
 #include <puffs.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <util.h>
 #include <unistd.h>
 #include "psshfs.h"
-static int	pssh_connect(struct psshfs_ctx *);
+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 *, 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, char *arg)
+{
 	*sshargs = realloc(*sshargs, (*nargs + 2) * sizeof(char*));
 	if (!*sshargs)
 		err(1, "realloc");
 	(*sshargs)[(*nargs)++] = arg;
 	(*sshargs)[*nargs] = NULL;
+}
 static void
 usage()
+{
 	fprintf(stderr, "usage: %s "
-	    "[-es] [-F configfile] [-O sshopt=value] [-o opts] "
+	    "[-ceprst] [-F configfile] [-O sshopt=value] [-o opts] "
 	    "user@host:path mountpath\n",
 	    getprogname());
 	exit(1);
+}
 static void
 takehup(int sig)
+{
 	sighup = 1;
+}
 int
 @@ -106,45 +106,55 @@ 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;
 	mntoptparse_t mp;
 	char **sshargs;
 	char *userhost;
 	char *hostpath;
 	int mntflags, pflags, ch;
 	int detach;
-	int exportfs, refreshival;
+	int exportfs, refreshival, numconnections;
-	int nargs, x;
+	int nargs;
 	setprogname(argv[0]);
 	if (argc < 3)
 		usage();
 	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, "eF:o:O:pr:st:")) != -1) {
+	while ((ch = getopt(argc, argv, "c:eF:o:O:pr:st:")) != -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 'O':
 			add_ssharg(&sshargs, &nargs, "-o");
 			add_ssharg(&sshargs, &nargs, optarg);
 			break;
 		case 'o':
 			mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
 @@ -204,171 +214,201 @@ main(int argc, char *argv[])
 	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");
 	memset(&pctx, 0, sizeof(pctx));
 	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));
 	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(&pctx) == -1)
+	if (pssh_connect(pu, PSSHFD_META) == -1)
-		err(1, "can't connect");
+		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);
 	if (psshfs_handshake(pu) != 0)
 		errx(1, "psshfs_handshake");
 	x = 1;
 	if (ioctl(pctx.sshfd, FIONBIO, &x) == -1)
 		err(1, "nonblocking descriptor");
 	puffs_framev_init(pu, psbuf_read, psbuf_write, psbuf_cmp, NULL, notfn);
 	if (puffs_framev_addfd(pu, pctx.sshfd,
 	    PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
 		err(1, "framebuf addfd");
 	rva = &pn_root->pn_va;
 	rva->va_fileid = pctx.nextino++;
 	rva->va_nlink = 101; /* XXX */
 	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 x, nretry;
+	int x, nretry, which, newfd;
 	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, pctx->sshfd, ECONNRESET);
+		puffs_framev_removefd(pu, fd, ECONNRESET);
 		return;
+	}
-	close(pctx->sshfd);
+	close(fd);
 	for (nretry = 0;;nretry++) {
-		if (pssh_connect(pctx) == -1)
+		if ((newfd = pssh_connect(pu, which)) == -1)
 			goto retry2;
-		if (psshfs_handshake(pu) != 0)
+		if (psshfs_handshake(pu, newfd) != 0)
 			goto retry1;
 		x = 1;
-		if (ioctl(pctx->sshfd, FIONBIO, &x) == -1)
+		if (ioctl(newfd, FIONBIO, &x) == -1)
 			goto retry1;
-		if (puffs_framev_addfd(pu, pctx->sshfd,
+		if (puffs_framev_addfd(pu, newfd,
 		    PUFFS_FBIO_READ | PUFFS_FBIO_WRITE) == -1)
 			goto retry1;
 		break;
  retry1:
 		fprintf(stderr, "reconnect failed... ");
-		close(pctx->sshfd);
+		close(newfd);
  retry2:
 		if (nretry < RETRY_MAX) {
 			fprintf(stderr, "retrying\n");
 			sleep(nretry);
 		} else {
 			fprintf(stderr, "retry count exceeded, going south\n");
 			exit(1); /* XXXXXXX */
+		}
+	}
+}
 static int
-pssh_connect(struct psshfs_ctx *pctx)
+pssh_connect(struct puffs_usermount *pu, int which)
+{
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	char **sshargs = pctx->sshargs;
 	int fds[2];
 	pid_t pid;
-	int dnfd;
+	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:
-		pctx->sshpid = pid;
+		*sshpid = pid;
-		pctx->sshfd = fds[1];
+		*sshfd = fds[1];
 		close(fds[0]);
 		break;
+	}
-	return 0;
+	if (psshfs_handshake(pu, *sshfd) != 0)
 		errx(1, "psshfs_handshake %d", which);
 	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;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: psshfs.h,v 1.35 2009/02/23 18:43:46 pooka Exp $	*/
+/*	$NetBSD: psshfs.h,v 1.36 2009/05/20 13:56:36 pooka Exp $	*/
 /*
  * Copyright (c) 2006, 2007  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.
+ *
 @@ -55,45 +55,45 @@ PUFFSOP_PROTOS(psshfs);
 #define NEXTREQ(pctx) ((pctx->nextreq)++)
 #define PSSHFSAUTOVAR(pu)						\
 	struct puffs_cc *pcc = puffs_cc_getcc(pu);			\
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);		\
 	uint32_t reqid = NEXTREQ(pctx);					\
 	struct puffs_framebuf *pb = psbuf_makeout();			\
 	int rv = 0
 #define PSSHFSRETURN(rv)						\
 	puffs_framebuf_destroy(pb);					\
 	return (rv)
-#define GETRESPONSE(pb)							\
+#define GETRESPONSE(pb, fd)						\
 do {									\
-	if (puffs_framev_enqueue_cc(pcc, pctx->sshfd, pb, 0) == -1) {	\
+	if (puffs_framev_enqueue_cc(pcc, fd, pb, 0) == -1) 	{	\
 		rv = errno;						\
 		goto out;						\
 	}								\
 } while (/*CONSTCOND*/0)
-#define JUSTSEND(pb)							\
+#define JUSTSEND(pb,fd)							\
 do {									\
-	if (puffs_framev_enqueue_justsend(pu,pctx->sshfd,pb,1,0) == -1){\
+	if (puffs_framev_enqueue_justsend(pu, fd, pb, 1, 0) == -1) {	\
 		rv = errno;						\
 		goto out;						\
 	}								\
 } while (/*CONSTCOND*/0)
-#define SENDCB(pb, f, a)						\
+#define SENDCB(pb, fd, f, a)						\
 do {									\
-	if (puffs_framev_enqueue_cb(pu, pctx->sshfd, pb,f,a,0) == -1) {	\
+	if (puffs_framev_enqueue_cb(pu, fd, pb, f, a, 0) == -1) {	\
 		rv = errno;						\
 		goto out;						\
 	}								\
 } while (/*CONSTCOND*/0)
 struct psshfs_dir {
 	int valid;
 	struct puffs_node *entry;
 	char *entryname;
 	struct vattr va;
 	time_t attrread;
 };
 @@ -143,48 +143,54 @@ struct psshfs_node {
 #define PSN_RECLAIMED	0x01
 #define PSN_HASFH	0x02
 #define PSN_READDIR	0x04
 #define PSN_DOLAZY_R	0x08
 #define PSN_DOLAZY_W	0x10
 #define PSN_LAZYWAIT_R	0x20
 #define PSN_LAZYWAIT_W	0x40
 #define PSN_HANDLECLOSE	0x80
 #define HANDLE_READ	0x1
 #define HANDLE_WRITE	0x2
 struct psshfs_ctx {
 	int numconnections;
 	int sshfd;
 	int sshfd_data;
 	pid_t sshpid;
 	pid_t sshpid_data;
 	const char *mountpath;
 	char **sshargs;
 	int protover;
 	int extensions;
 	uint32_t nextreq;
 	struct puffs_framebuf *curpb;
 	struct psshfs_node psn_root;
 	ino_t nextino;
 	int canexport;
 	time_t mounttime;
 	int refreshival;
 };
 #define PSSHFD_META 0
 #define PSSHFD_DATA 1
-int	psshfs_handshake(struct puffs_usermount *);
+int	psshfs_handshake(struct puffs_usermount *, int);
 int	psbuf_read(struct puffs_usermount *, struct puffs_framebuf *,int,int*);
 int	psbuf_write(struct puffs_usermount *, struct puffs_framebuf *,int,int*);
 int	psbuf_cmp(struct puffs_usermount *,
 		  struct puffs_framebuf *, struct puffs_framebuf *, int *);
 struct puffs_framebuf	*psbuf_makeout(void);
 void			psbuf_recycleout(struct puffs_framebuf *);
 void	psbuf_put_1(struct puffs_framebuf *, uint8_t);
 void	psbuf_put_2(struct puffs_framebuf *, uint16_t);
 void	psbuf_put_4(struct puffs_framebuf *, uint32_t);
 void	psbuf_put_8(struct puffs_framebuf *, uint64_t);

 @@ -1,14 +1,14 @@
-/*      $NetBSD: subr.c,v 1.45 2007/12/13 14:59:00 pooka Exp $        */
+/*      $NetBSD: subr.c,v 1.46 2009/05/20 13:56:36 pooka Exp $        */
 /*
  * Copyright (c) 2006  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.
+ *
 @@ -17,27 +17,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: subr.c,v 1.45 2007/12/13 14:59:00 pooka Exp $");
+__RCSID("$NetBSD: subr.c,v 1.46 2009/05/20 13:56:36 pooka Exp $");
 #endif /* !lint */
 #include <assert.h>
 #include <err.h>
 #include <errno.h>
 #include <puffs.h>
 #include <stdlib.h>
 #include <util.h>
 #include "psshfs.h"
 #include "sftp_proto.h"
 static void
 @@ -124,39 +124,39 @@ void
 closehandles(struct puffs_usermount *pu, struct psshfs_node *psn, int which)
+{
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	struct puffs_framebuf *pb1, *pb2;
 	uint32_t reqid;
 	if (psn->fhand_r && (which & HANDLE_READ)) {
 		assert(psn->lazyopen_r == NULL);
 		pb1 = psbuf_makeout();
 		reqid = NEXTREQ(pctx);
 		psbuf_req_data(pb1, SSH_FXP_CLOSE, reqid,
 		    psn->fhand_r, psn->fhand_r_len);
-		puffs_framev_enqueue_justsend(pu, pctx->sshfd, pb1, 1, 0);
+		puffs_framev_enqueue_justsend(pu, pctx->sshfd_data, pb1, 1, 0);
 		free(psn->fhand_r);
 		psn->fhand_r = NULL;
+	}
 	if (psn->fhand_w && (which & HANDLE_WRITE)) {
 		assert(psn->lazyopen_w == NULL);
 		pb2 = psbuf_makeout();
 		reqid = NEXTREQ(pctx);
 		psbuf_req_data(pb2, SSH_FXP_CLOSE, reqid,
 		    psn->fhand_w, psn->fhand_w_len);
-		puffs_framev_enqueue_justsend(pu, pctx->sshfd, pb2, 1, 0);
+		puffs_framev_enqueue_justsend(pu, pctx->sshfd_data, pb2, 1, 0);
 		free(psn->fhand_w);
 		psn->fhand_w = NULL;
+	}
 	psn->stat |= PSN_HANDLECLOSE;
+}
 void
 lazyopen_rresp(struct puffs_usermount *pu, struct puffs_framebuf *pb,
 	void *arg, int error)
+{
 	struct psshfs_node *psn = arg;
 @@ -210,27 +210,27 @@ lazyopen_wresp(struct puffs_usermount *p
 struct readdirattr {
 	struct psshfs_node *psn;
 	int idx;
 	char entryname[MAXPATHLEN+1];
 };
 int
 getpathattr(struct puffs_usermount *pu, const char *path, struct vattr *vap)
+{
 	PSSHFSAUTOVAR(pu);
 	psbuf_req_str(pb, SSH_FXP_LSTAT, reqid, path);
-	GETRESPONSE(pb);
+	GETRESPONSE(pb, pctx->sshfd);
 	rv = psbuf_expect_attrs(pb, vap);
  out:
 	PSSHFSRETURN(rv);
+}
 int
 getnodeattr(struct puffs_usermount *pu, struct puffs_node *pn)
+{
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	struct psshfs_node *psn = pn->pn_data;
 	struct vattr va;
 @@ -297,27 +297,27 @@ sftp_readdir(struct puffs_usermount *pu,
 	 * large directories might expire before the directory itself and
 	 * result in one-by-one attribute fetching.
 	 */
 	psn->dentread = time(NULL);
 	psn->dentnext = 0;
 	psn->denttot = 0;
 	psn->dir = NULL;
 	for (;;) {
 		reqid = NEXTREQ(pctx);
 		psbuf_recycleout(pb);
 		psbuf_req_data(pb, SSH_FXP_READDIR, reqid, dhand, dhandlen);
-		GETRESPONSE(pb);
+		GETRESPONSE(pb, pctx->sshfd);
 		/* check for EOF */
 		if (psbuf_get_type(pb) == SSH_FXP_STATUS) {
 			rv = psbuf_expect_status(pb);
 			goto out;
+		}
 		rv = psbuf_expect_name(pb, &count);
 		if (rv)
 			goto out;
 		for (; count--; idx++) {
 			if (idx == psn->denttot)
 				allocdirs(psn);