 @@ -1,281 +1,279 @@
-/*	$NetBSD: fs.c,v 1.22 2010/04/01 02:34:09 pooka Exp $	*/
+/*	$NetBSD: fs.c,v 1.23 2010/10/29 16:13:51 pooka 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: fs.c,v 1.22 2010/04/01 02:34:09 pooka Exp $");
+__RCSID("$NetBSD: fs.c,v 1.23 2010/10/29 16:13:51 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"
 #define DO_IO(fname, a1, a2, a3, a4, rv)				\
 do {									\
 	puffs_framebuf_seekset(a2, 0);					\
 	*(a4) = 0;							\
 	rv = fname(a1, a2, a3, a4);					\
 	if (rv || a4 == 0) {						\
 		fprintf(stderr, "psshfs_handshake failed %d (%s) %d\n",	\
 		    rv, strerror(rv), *a4);				\
 		return rv ? rv : EPROTO;				\
 	}								\
 } while (/*CONSTCOND*/0)
 #define reterr(str, rv)							\
 do {									\
 	fprintf str;							\
 	return rv;							\
 } while (/*CONSTCOND*/0)
 /* openssh extensions */
 static const struct extunit {
 	const char *ext;
 	const char *val;
 	int extflag;
 } exttable[] = {
+{
 	"posix-rename@openssh.com",
 	"1",
 	SFTP_EXT_POSIX_RENAME,
 },{
 	"statvfs@openssh.com",
 	"2",
 	SFTP_EXT_STATVFS,
 },{
 	"fstatvfs@openssh.com",
 	"2",
 	SFTP_EXT_FSTATVFS,
 },{
 	NULL,
 	NULL,
 }};
 int
 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, fd, &done, rv);
 	puffs_framebuf_recycle(pb);
 	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, fd, &done, rv);
 	puffs_framebuf_recycle(pb);
 	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, fd, &done, rv);
 	puffs_framebuf_recycle(pb);
 	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);
 	po_root = puffs_getrootpathobj(pu);
 	if (po_root == NULL)
 		err(1, "getrootpathobj");
 	po_root->po_path = rootpath;
 	po_root->po_len = strlen(rootpath);
 	return 0;
+}
 int
 psshfs_fs_statvfs(struct puffs_usermount *pu, struct statvfs *sbp)
+{
 	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, 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);
 	psbuf_get_8(pb, &sbp->f_bavail);
 	psbuf_get_8(pb, &sbp->f_files);
 	psbuf_get_8(pb, &sbp->f_ffree);
 	psbuf_get_8(pb, &sbp->f_favail);
 	psbuf_get_8(pb, &tmpval); /* fsid */
 	psbuf_get_8(pb, &tmpval); /* flag */
 	psbuf_get_8(pb, &tmpval);
 	sbp->f_namemax = tmpval;
 	sbp->f_bresvd = sbp->f_bfree - sbp->f_bavail;
 	sbp->f_fresvd = sbp->f_ffree - sbp->f_favail;
  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;
 	pf->node = pn;
 	psn->stat |= PSN_HASFH;
 	return 0;
+}
 int
 psshfs_fs_fhtonode(struct puffs_usermount *pu, void *fid, size_t fidsize,
 	struct puffs_newinfo *pni)
+{
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	struct psshfs_fid *pf = fid;
 	struct puffs_node *pn = pf->node;
 	struct psshfs_node *psn;
 	int rv;
 	if (pf->mounttime != pctx->mounttime)
 		return EINVAL;
 	if (pn == 0)
 		return EINVAL;
 	psn = pn->pn_data;
 	if ((psn->stat & PSN_HASFH) == 0)
 		return EINVAL;
 	/* update node attributes */
 	rv = getnodeattr(pu, pn, NULL);
 	if (rv)
 		return EINVAL;
 	puffs_newinfo_setcookie(pni, pn);
 	puffs_newinfo_setvtype(pni, pn->pn_va.va_type);
 	puffs_newinfo_setsize(pni, pn->pn_va.va_size);
 	return 0;
+}

 @@ -1,887 +1,888 @@
-/*	$NetBSD: node.c,v 1.61 2010/04/01 02:34:09 pooka Exp $	*/
+/*	$NetBSD: node.c,v 1.62 2010/10/29 16:13:51 pooka 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.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: node.c,v 1.61 2010/04/01 02:34:09 pooka Exp $");
+__RCSID("$NetBSD: node.c,v 1.62 2010/10/29 16:13:51 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)
+{
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	struct puffs_node *pn_dir = opc;
 	struct psshfs_node *psn, *psn_dir = pn_dir->pn_data;
 	struct puffs_node *pn;
 	struct psshfs_dir *pd;
 	struct vattr va;
 	int rv;
 	if (PCNISDOTDOT(pcn)) {
 		psn = psn_dir->parent->pn_data;
 		psn->stat &= ~PSN_RECLAIMED;
 		puffs_newinfo_setcookie(pni, psn_dir->parent);
 		puffs_newinfo_setvtype(pni, VDIR);
 		return 0;
+	}
 	rv = sftp_readdir(pu, pctx, pn_dir);
 	if (rv) {
 		if (rv != EPERM)
 			return rv;
 		/*
 		 * Can't read the directory.  We still might be
 		 * able to find the node with getattr in -r+x dirs
 		 */
 		rv = getpathattr(pu, PCNPATH(pcn), &va);
 		if (rv)
 			return rv;
 		/* guess */
 		if (va.va_type == VDIR)
 			va.va_nlink = 2;
 		else
 			va.va_nlink = 1;
 		pn = allocnode(pu, pn_dir, pcn->pcn_name, &va);
 		psn = pn->pn_data;
 		psn->attrread = time(NULL);
 	} else {
 		pd = lookup(psn_dir->dir, psn_dir->dentnext, pcn->pcn_name);
 		if (!pd) {
 			return ENOENT;
+		}
 		if (pd->entry)
 			pn = pd->entry;
 		else
 			pd->entry = pn = makenode(pu, pn_dir, pd, &pd->va);
 		/*
 		 * sure sure we have fresh attributes.  most likely we will
 		 * have them cached.  we might not if we go through:
 		 * create - reclaim - lookup (this).
 		 */
 		rv = getnodeattr(pu, pn, PCNPATH(pcn));
 		if (rv)
 			return rv;
 		psn = pn->pn_data;
+	}
 	psn->stat &= ~PSN_RECLAIMED;
 	puffs_newinfo_setcookie(pni, pn);
 	puffs_newinfo_setvtype(pni, pn->pn_va.va_type);
 	puffs_newinfo_setsize(pni, pn->pn_va.va_size);
 	return 0;
+}
 int
 psshfs_node_getattr(struct puffs_usermount *pu, puffs_cookie_t opc,
 	struct vattr *vap, const struct puffs_cred *pcr)
+{
 	struct puffs_node *pn = opc;
 	int rv;
 	rv = getnodeattr(pu, pn, NULL);
 	if (rv)
 		return rv;
 	memcpy(vap, &pn->pn_va, sizeof(struct vattr));
 	return 0;
+}
 int
 psshfs_node_setattr(struct puffs_usermount *pu, puffs_cookie_t opc,
 	const struct vattr *va, const struct puffs_cred *pcr)
+{
 	PSSHFSAUTOVAR(pu);
 	struct vattr kludgeva;
 	struct puffs_node *pn = opc;
 	psbuf_req_str(pb, SSH_FXP_SETSTAT, reqid, PNPATH(pn));
 	memcpy(&kludgeva, va, sizeof(struct vattr));
 	/* XXX: kludge due to openssh server implementation */
 	if (va->va_atime.tv_sec != PUFFS_VNOVAL
 	    && va->va_mtime.tv_sec == PUFFS_VNOVAL) {
 		if (pn->pn_va.va_mtime.tv_sec != PUFFS_VNOVAL)
 			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, pctx);
 	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, pctx);
 	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, 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, 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
  * to read/write and therefore allow cached access without a wait.
+ *
  * If we have not yet succesfully opened a type of handle, we do wait
  * here.  Also, if a lazy open fails, we revert back to the same
  * state of waiting.
  */
 int
 psshfs_node_open(struct puffs_usermount *pu, puffs_cookie_t opc, int mode,
 	const struct puffs_cred *pcr)
+{
 	struct puffs_cc *pcc = puffs_cc_getcc(pu);
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	struct puffs_framebuf *pb, *pb2;
 	struct vattr va;
 	struct puffs_node *pn = opc;
 	struct psshfs_node *psn = pn->pn_data;
 	uint32_t reqid;
 	int didread, didwrite;
 	int rv = 0;
 	if (pn->pn_va.va_type == VDIR)
 		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, pctx);
 		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, pctx);
 		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? */
 	if (didread && (psn->stat & PSN_DOLAZY_R) == 0) {
 		assert(psn->lazyopen_r);
 		rv = puffs_framev_framebuf_ccpromote(psn->lazyopen_r, pcc);
 		lazyopen_rresp(pu, psn->lazyopen_r, psn, rv);
 		if (psn->fhand_r) {
 			psn->stat |= PSN_DOLAZY_R;
 		} else {
 			if (psn->lazyopen_err_r)
 				return psn->lazyopen_err_r;
 			return EINVAL;
+		}
+	}
 	/* wait? */
 	if (didwrite && (psn->stat & PSN_DOLAZY_W) == 0) {
 		assert(psn->lazyopen_w);
 		rv = puffs_framev_framebuf_ccpromote(psn->lazyopen_w, pcc);
 		lazyopen_wresp(pu, psn->lazyopen_w, psn, rv);
 		if (psn->fhand_w) {
 			psn->stat |= PSN_DOLAZY_W;
 		} else {
 			if (psn->lazyopen_err_w)
 				return psn->lazyopen_err_w;
 			return EINVAL;
+		}
+	}
 	return rv;
+}
 int
 psshfs_node_inactive(struct puffs_usermount *pu, puffs_cookie_t opc)
+{
 	struct puffs_node *pn = opc;
 	closehandles(pu, pn->pn_data, HANDLE_READ | HANDLE_WRITE);
 	return 0;
+}
 int
 psshfs_node_readdir(struct puffs_usermount *pu, puffs_cookie_t opc,
 	struct dirent *dent, off_t *readoff, size_t *reslen,
 	const struct puffs_cred *pcr, int *eofflag,
 	off_t *cookies, size_t *ncookies)
+{
 	struct puffs_cc *pcc = puffs_cc_getcc(pu);
 	struct psshfs_ctx *pctx = puffs_getspecific(pu);
 	struct puffs_node *pn = opc;
 	struct psshfs_node *psn = pn->pn_data;
 	struct psshfs_dir *pd;
 	size_t i;
 	int rv, set_readdir;
  restart:
 	if (psn->stat & PSN_READDIR) {
 		struct psshfs_wait pw;
 		set_readdir = 0;
 		pw.pw_cc = pcc;
 		pw.pw_type = PWTYPE_READDIR;
 		TAILQ_INSERT_TAIL(&psn->pw, &pw, pw_entries);
 		puffs_cc_yield(pcc);
 		goto restart;
 	} else {
 		psn->stat |= PSN_READDIR;
 		set_readdir = 1;
+	}
 	*ncookies = 0;
 	rv = sftp_readdir(pu, pctx, pn);
-	if (rv)
+	if (rv) {
 		goto out;
+	}
 	/* find next dirent */
 	for (i = *readoff;;i++) {
 		if (i >= psn->dentnext)
 			goto out;
 		pd = &psn->dir[i];
 		if (pd->valid)
 			break;
+	}
 	for (;;) {
 		*readoff = i;
 		if (!puffs_nextdent(&dent, pd->entryname,
 		    pd->va.va_fileid, puffs_vtype2dt(pd->va.va_type), reslen)) {
 			rv = 0;
 			goto out;
+		}
 		/* find next entry, store possible nfs key */
 		do {
 			if (++i >= psn->dentnext)
 				goto out;
 			pd = &psn->dir[i];
 		} while (pd->valid == 0);
 		PUFFS_STORE_DCOOKIE(cookies, ncookies, (off_t)i);
+	}
  out:
 	if (rv == 0) {
 		if (i >= psn->dentnext)
 			*eofflag = 1;
 		*readoff = i;
+	}
 	if (set_readdir) {
 		struct psshfs_wait *pw;
 		/* all will likely run to completion because of cache */
 		TAILQ_FOREACH(pw, &psn->pw, pw_entries) {
 			assert(pw->pw_type == PWTYPE_READDIR);
 			puffs_cc_schedule(pw->pw_cc);
 			TAILQ_REMOVE(&psn->pw, pw, pw_entries);
+		}
 		psn->stat &= ~PSN_READDIR;
+	}
 	return rv;
+}
 int
 psshfs_node_read(struct puffs_usermount *pu, puffs_cookie_t opc, uint8_t *buf,
 	off_t offset, size_t *resid, const struct puffs_cred *pcr,
 	int ioflag)
+{
 	PSSHFSAUTOVAR(pu);
 	struct puffs_node *pn = opc;
 	struct psshfs_node *psn = pn->pn_data;
 	struct psshfs_wait *pwp;
 	uint32_t readlen;
 	if (pn->pn_va.va_type == VDIR) {
 		rv = EISDIR;
 		goto farout;
+	}
 	/* check that a lazyopen didn't fail */
 	if (!psn->fhand_r && !psn->lazyopen_r) {
 		rv = psn->lazyopen_err_r;
 		goto farout;
+	}
 	/* if someone is already waiting for the lazyopen, "just" wait */
 	if (psn->stat & PSN_LAZYWAIT_R) {
 		struct psshfs_wait pw;
 		assert(psn->lazyopen_r);
 		pw.pw_cc = pcc;
 		pw.pw_type = PWTYPE_READ1;
 		TAILQ_INSERT_TAIL(&psn->pw, &pw, pw_entries);
 		puffs_cc_yield(pcc);
+	}
 	/* if lazyopening, wait for the result */
 	if (psn->lazyopen_r) {
 		psn->stat |= PSN_LAZYWAIT_R;
 		rv = puffs_framev_framebuf_ccpromote(psn->lazyopen_r, pcc);
 		lazyopen_rresp(pu, psn->lazyopen_r, psn, rv);
 		/* schedule extra waiters */
 		TAILQ_FOREACH(pwp, &psn->pw, pw_entries)
 			if (pwp->pw_type == PWTYPE_READ1) {
 				puffs_cc_schedule(pwp->pw_cc);
 				TAILQ_REMOVE(&psn->pw, pwp, pw_entries);
+			}
 		psn->stat &= ~PSN_LAZYWAIT_R;
 		if ((rv = psn->lazyopen_err_r) != 0)
 			goto farout;
+	}
 	/* if there is still no handle, just refuse to live with this */
 	if (!psn->fhand_r) {
 		rv = EINVAL;
 		goto farout;
+	}
 	readlen = *resid;
 	psbuf_req_data(pb, SSH_FXP_READ, reqid, psn->fhand_r, psn->fhand_r_len);
 	psbuf_put_8(pb, offset);
 	psbuf_put_4(pb, readlen);
 	/*
 	 * 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, 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);
+	}
  farout:
 	/* check if we need a lazyclose */
 	if (psn->stat & PSN_HANDLECLOSE && psn->fhand_r) {
 		TAILQ_FOREACH(pwp, &psn->pw, pw_entries)
 			if (pwp->pw_type == PWTYPE_READ1)
 				break;
 		if (pwp == NULL)
 			closehandles(pu, psn, HANDLE_READ);
+	}
 	PSSHFSRETURN(rv);
+}
 /* XXX: we should getattr for size */
 int
 psshfs_node_write(struct puffs_usermount *pu, puffs_cookie_t opc, uint8_t *buf,
 	off_t offset, size_t *resid, const struct puffs_cred *cred,
 	int ioflag)
+{
 	PSSHFSAUTOVAR(pu);
 	struct psshfs_wait *pwp;
 	struct puffs_node *pn = opc;
 	struct psshfs_node *psn = pn->pn_data;
 	uint32_t writelen;
 	if (pn->pn_va.va_type == VDIR) {
 		rv = EISDIR;
 		goto out;
+	}
 	/* check that a lazyopen didn't fail */
 	if (!psn->fhand_w && !psn->lazyopen_w) {
 		rv = psn->lazyopen_err_w;
 		goto out;
+	}
 	if (psn->stat & PSN_LAZYWAIT_W) {
 		struct psshfs_wait pw;
 		assert(psn->lazyopen_w);
 		pw.pw_cc = pcc;
 		pw.pw_type = PWTYPE_WRITE;
 		TAILQ_INSERT_TAIL(&psn->pw, &pw, pw_entries);
 		puffs_cc_yield(pcc);
+	}
 	/*
 	 * If lazyopening, wait for the result.
 	 * There can still be more than oen writer at a time in case
 	 * the kernel issues write FAFs.
 	 */
 	if (psn->lazyopen_w) {
 		psn->stat |= PSN_LAZYWAIT_W;
 		rv = puffs_framev_framebuf_ccpromote(psn->lazyopen_w, pcc);
 		lazyopen_wresp(pu, psn->lazyopen_w, psn, rv);
 		/* schedule extra waiters */
 		TAILQ_FOREACH(pwp, &psn->pw, pw_entries)
 			if (pwp->pw_type == PWTYPE_WRITE) {
 				puffs_cc_schedule(pwp->pw_cc);
 				TAILQ_REMOVE(&psn->pw, pwp, pw_entries);
+			}
 		psn->stat &= ~PSN_LAZYWAIT_W;
 		if ((rv = psn->lazyopen_err_w) != 0)
 			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, pctx->sshfd_data);
 	rv = psbuf_expect_status(pb);
 	if (rv == 0)
 		*resid = 0;
 	if (pn->pn_va.va_size < (uint64_t)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)
 				break;
 		if (pwp == NULL)
 			closehandles(pu, psn, HANDLE_WRITE);
+	}
 	PSSHFSRETURN(rv);
+}
 int
 psshfs_node_readlink(struct puffs_usermount *pu, puffs_cookie_t opc,
 	const struct puffs_cred *cred, char *linkvalue, size_t *linklen)
+{
 	PSSHFSAUTOVAR(pu);
 	struct puffs_node *pn = opc;
 	struct psshfs_node *psn = pn->pn_data;
 	uint32_t count;
 	if (pctx->protover < 3) {
 		rv = EOPNOTSUPP;
 		goto out;
+	}
 	/*
 	 * check if we can use a cached version
+	 *
 	 * XXX: we might end up reading the same link multiple times
 	 * 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, 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);
  copy:
 	*linklen = strlen(psn->symlink);
 	(void) memcpy(linkvalue, psn->symlink, *linklen);
  out:
 	PSSHFSRETURN(rv);
+}
 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, 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)
+{
 	struct puffs_node *pn_targ = targ;
 	int rv;
 	assert(pn_targ->pn_va.va_type != VDIR);
 	rv = doremove(pu, opc, targ, pcn->pcn_name);
 	if (rv == 0)
 		puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N2);
 	return rv;
+}
 int
 psshfs_node_rmdir(struct puffs_usermount *pu, puffs_cookie_t opc,
 	puffs_cookie_t targ, const struct puffs_cn *pcn)
+{
 	struct puffs_node *pn_targ = targ;
 	int rv;
 	assert(pn_targ->pn_va.va_type == VDIR);
 	rv = doremove(pu, opc, targ, pcn->pcn_name);
 	if (rv == 0)
 		puffs_setback(puffs_cc_getcc(pu), PUFFS_SETBACK_NOREF_N2);
 	return rv;
+}
 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, pctx);
 	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, 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);
 	struct puffs_node *pn = opc;
 	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, 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, 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)
+{
 	PSSHFSAUTOVAR(pu);
 	struct puffs_node *pn_sf = src;
 	struct puffs_node *pn_td = targ_dir, *pn_tf = targ;
 	struct psshfs_node *psn_src = pn_sf->pn_data;
 	struct psshfs_node *psn_targdir = pn_td->pn_data;
 	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, 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);
 		if (opc != targ_dir) {
 			psn_targdir->childcount++;
 			psn_src->parent = pn_td;
 			if (pn_sf->pn_va.va_type == VDIR)
 				pn_td->pn_va.va_nlink++;
+		}
+	}
  out:
 	PSSHFSRETURN(rv);
+}
 /*
  * So this file system happened to be written in such a way that
  * lookup for ".." is hard if we lose the in-memory node.  We'd
  * need to recreate the entire directory structure from the root
  * node up to the ".." node we're looking up.
+ *
  * And since our entire fs structure is purely fictional (i.e. it's
  * only in-memory, not fetchable from the server), the easiest way
  * to deal with it is to not allow nodes with children to be
  * reclaimed.
+ *
  * If a node with children is being attempted to be reclaimed, we
  * just mark it "reclaimed" but leave it as is until all its children
  * have been reclaimed.  If a lookup for that node is done meanwhile,
  * it will be found by lookup() and we just remove the "reclaimed"
  * bit.
  */
 int
 psshfs_node_reclaim(struct puffs_usermount *pu, puffs_cookie_t opc)
+{
 	struct puffs_node *pn = opc, *pn_next, *pn_root;
 	struct psshfs_node *psn = pn->pn_data;
 	/*
 	 * don't reclaim if we have file handle issued, otherwise
 	 * we can't do fhtonode
 	 */
 	if (psn->stat & PSN_HASFH)
 		return 0;
 	psn->stat |= PSN_RECLAIMED;
 	pn_root = puffs_getroot(pu);
 	for (; pn != pn_root; pn = pn_next) {
 		psn = pn->pn_data;
 		if ((psn->stat & PSN_RECLAIMED) == 0 || psn->childcount != 0)
 			break;
 		pn_next = psn->parent;
 		doreclaim(pn);
+	}
 	return 0;
+}

 @@ -1,446 +1,446 @@
-/*	$NetBSD: psshfs.c,v 1.61 2010/02/17 15:54:10 pooka Exp $	*/
+/*	$NetBSD: psshfs.c,v 1.62 2010/10/29 16:13:51 pooka 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/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: psshfs.c,v 1.61 2010/02/17 15:54:10 pooka Exp $");
+__RCSID("$NetBSD: psshfs.c,v 1.62 2010/10/29 16:13:51 pooka Exp $");
 #endif /* !lint */
 #include <sys/types.h>
 #include <sys/wait.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 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()
+{
 	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;
 	mntoptparse_t mp;
 	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':
 			mp = getmntopts(optarg, puffsmopts, &mntflags, &pflags);
 			if (mp == NULL)
 				err(1, "getmntopts");
 			freemntopts(mp);
 			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, 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));
 	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, "psshfs_handshake %d", which);
+		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;
+	}
+}