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

/*      $NetBSD: psbuf.c,v 1.18 2010/01/08 10:53:31 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.
 */

/*
 * buffering functions for network input/output.  slightly different
 * from the average joe buffer routines, as is usually the case ...
 * these use efuns for now.
 */

#include <sys/types.h>
#include <sys/endian.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/vnode.h>

#include <err.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>

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

#define FAILRV(x) do { int rv; if ((rv=x)) return (rv); } while (/*CONSTCOND*/0)
#define READSTATE_LENGTH(off) (off < 4)

#define SFTP_LENOFF	0
#define SFTP_TYPEOFF	4
#define SFTP_REQIDOFF	5

#define CHECK(v) if (!(v)) abort()

#define HTOBE16(x)	(x) = htobe16((uint16_t)(x))
#define HTOBE32(x)	(x) = htobe32((uint32_t)(x))
#define HTOBE64(x)	(x) = htobe64((uint64_t)(x))
#define BE16TOH(x)	(x) = be16toh((uint16_t)(x))
#define BE32TOH(x)	(x) = be32toh((uint32_t)(x))
#define BE64TOH(x)	(x) = be64toh((uint64_t)(x))

uint8_t
psbuf_get_type(struct puffs_framebuf *pb)
{
	uint8_t type;

	puffs_framebuf_getdata_atoff(pb, SFTP_TYPEOFF, &type, 1);
	return type;
}

uint32_t
psbuf_get_len(struct puffs_framebuf *pb)
{
	uint32_t len;

	puffs_framebuf_getdata_atoff(pb, SFTP_LENOFF, &len, 4);
	return be32toh(len);
}

uint32_t
psbuf_get_reqid(struct puffs_framebuf *pb)
{
	uint32_t req;

	puffs_framebuf_getdata_atoff(pb, SFTP_REQIDOFF, &req, 4);
	return be32toh(req);
}

#define CUROFF(pb) (puffs_framebuf_telloff(pb))
int
psbuf_read(struct puffs_usermount *pu, struct puffs_framebuf *pb,
	int fd, int *done)
{
	void *win;
	ssize_t n;
	size_t howmuch, winlen;
	int lenstate;

 the_next_level:
	if ((lenstate = READSTATE_LENGTH(CUROFF(pb))))
		howmuch = 4 - CUROFF(pb);
	else
		howmuch = psbuf_get_len(pb) - (CUROFF(pb) - 4);

	if (puffs_framebuf_reserve_space(pb, howmuch) == -1)
		return errno;

	while (howmuch) {
		winlen = howmuch;
		if (puffs_framebuf_getwindow(pb, CUROFF(pb), &win, &winlen)==-1)
			return errno;
		n = recv(fd, win, winlen, MSG_NOSIGNAL);
		switch (n) {
		case 0:
			return ECONNRESET;
		case -1:
			if (errno == EAGAIN)
				return 0;
			return errno;
		default:
			howmuch -= n;
			puffs_framebuf_seekset(pb, CUROFF(pb) + n);
			break;
		}
	}

	if (!lenstate) {
		/* XXX: initial exchange shorter.. but don't worry, be happy */
		puffs_framebuf_seekset(pb, 9);
		*done = 1;
		return 0;
	} else
		goto the_next_level;
}

int
psbuf_write(struct puffs_usermount *pu, struct puffs_framebuf *pb,
	int fd, int *done)
{
	void *win;
	ssize_t n;
	size_t winlen, howmuch;

	/* finalize buffer.. could be elsewhere ... */
	if (CUROFF(pb) == 0) {
		uint32_t len;

		len = htobe32(puffs_framebuf_tellsize(pb) - 4);
		puffs_framebuf_putdata_atoff(pb, 0, &len, 4);
	}

	howmuch = puffs_framebuf_tellsize(pb) - CUROFF(pb);
	while (howmuch) {
		winlen = howmuch;
		if (puffs_framebuf_getwindow(pb, CUROFF(pb), &win, &winlen)==-1)
			return errno;
		n = send(fd, win, winlen, MSG_NOSIGNAL);
		switch (n) {
		case 0:
			return ECONNRESET;
		case -1:
			if (errno == EAGAIN)
				return 0;
			return errno;
		default:
			howmuch -= n;
			puffs_framebuf_seekset(pb, CUROFF(pb) + n);
			break;
		}
	}

	*done = 1;
	return 0;
}
#undef CUROFF

int
psbuf_cmp(struct puffs_usermount *pu,
	struct puffs_framebuf *cmp1, struct puffs_framebuf *cmp2, int *notresp)
{

	return psbuf_get_reqid(cmp1) != psbuf_get_reqid(cmp2);
}

struct puffs_framebuf *
psbuf_makeout(void)
{
	struct puffs_framebuf *pb;

	pb = puffs_framebuf_make();
	puffs_framebuf_seekset(pb, 4);
	return pb;
}

void
psbuf_recycleout(struct puffs_framebuf *pb)
{

	puffs_framebuf_recycle(pb);
	puffs_framebuf_seekset(pb, 4);
}

void
psbuf_put_1(struct puffs_framebuf *pb, uint8_t val)
{
	int rv;

	rv = puffs_framebuf_putdata(pb, &val, 1);
	CHECK(rv == 0);
}

void
psbuf_put_2(struct puffs_framebuf *pb, uint16_t val)
{
	int rv;

	HTOBE16(val);
	rv = puffs_framebuf_putdata(pb, &val, 2);
	CHECK(rv == 0);
}

void
psbuf_put_4(struct puffs_framebuf *pb, uint32_t val)
{
	int rv;

	HTOBE32(val);
	rv = puffs_framebuf_putdata(pb, &val, 4);
	CHECK(rv == 0);
}

void
psbuf_put_8(struct puffs_framebuf *pb, uint64_t val)
{
	int rv;

	HTOBE64(val);
	rv = puffs_framebuf_putdata(pb, &val, 8);
	CHECK(rv == 0);
}

void
psbuf_put_data(struct puffs_framebuf *pb, const void *data, uint32_t dlen)
{
	int rv;

	psbuf_put_4(pb, dlen);
	rv = puffs_framebuf_putdata(pb, data, dlen);
	CHECK(rv == 0);
}

void
psbuf_put_str(struct puffs_framebuf *pb, const char *str)
{

	psbuf_put_data(pb, str, strlen(str));
}

void
psbuf_put_vattr(struct puffs_framebuf *pb, const struct vattr *va,
	const struct psshfs_ctx *pctx)
{
	uint32_t flags;
	uint32_t theuid = -1, thegid = -1;
	flags = 0;

	if (va->va_size != (uint64_t)PUFFS_VNOVAL)
		flags |= SSH_FILEXFER_ATTR_SIZE;
	if (va->va_uid != (uid_t)PUFFS_VNOVAL) {
		theuid = va->va_uid;
		if (pctx->domangleuid && theuid == pctx->myuid)
			theuid = pctx->mangleuid;
		flags |= SSH_FILEXFER_ATTR_UIDGID;
	}
	if (va->va_gid != (gid_t)PUFFS_VNOVAL) {
		thegid = va->va_gid;
		if (pctx->domanglegid && thegid == pctx->mygid)
			thegid = pctx->manglegid;
		flags |= SSH_FILEXFER_ATTR_UIDGID;
	}
	if (va->va_mode != (mode_t)PUFFS_VNOVAL)
		flags |= SSH_FILEXFER_ATTR_PERMISSIONS;

	if (va->va_atime.tv_sec != PUFFS_VNOVAL)
		flags |= SSH_FILEXFER_ATTR_ACCESSTIME;

	psbuf_put_4(pb, flags);
	if (flags & SSH_FILEXFER_ATTR_SIZE)
		psbuf_put_8(pb, va->va_size);
	if (flags & SSH_FILEXFER_ATTR_UIDGID) {
		psbuf_put_4(pb, theuid);
		psbuf_put_4(pb, thegid);
	}
	if (flags & SSH_FILEXFER_ATTR_PERMISSIONS)
		psbuf_put_4(pb, va->va_mode);

	/* XXX: this is totally wrong for protocol v3, see OpenSSH */
	if (flags & SSH_FILEXFER_ATTR_ACCESSTIME) {
		psbuf_put_4(pb, va->va_atime.tv_sec);
		psbuf_put_4(pb, va->va_mtime.tv_sec);
	}
}

#define ERETURN(rv) return ((rv) == -1 ? errno : 0)

int
psbuf_get_1(struct puffs_framebuf *pb, uint8_t *val)
{

	ERETURN(puffs_framebuf_getdata(pb, val, 1));
}

int
psbuf_get_2(struct puffs_framebuf *pb, uint16_t *val)
{
	int rv;

	rv = puffs_framebuf_getdata(pb, val, 2);
	BE16TOH(*val);

	ERETURN(rv);
}

int
psbuf_get_4(struct puffs_framebuf *pb, uint32_t *val)
{
	int rv;

	rv = puffs_framebuf_getdata(pb, val, 4);
	BE32TOH(*val);

	ERETURN(rv);
}

int
psbuf_get_8(struct puffs_framebuf *pb, uint64_t *val)
{
	int rv;

	rv = puffs_framebuf_getdata(pb, val, 8);
	BE64TOH(*val);

	ERETURN(rv);
}

int
psbuf_get_str(struct puffs_framebuf *pb, char **strp, uint32_t *strlenp)
{
	char *str;
	uint32_t len;

	FAILRV(psbuf_get_4(pb, &len));

	if (puffs_framebuf_remaining(pb) < len)
		return EPROTO;

	str = emalloc(len+1);
	puffs_framebuf_getdata(pb, str, len);
	str[len] = '\0';
	*strp = str;

	if (strlenp)
		*strlenp = len;

	return 0;
}

int
psbuf_get_vattr(struct puffs_framebuf *pb, struct vattr *vap)
{
	uint32_t flags;
	uint32_t val;
	uint32_t tmpval;

	puffs_vattr_null(vap);

	FAILRV(psbuf_get_4(pb, &flags));

	if (flags & SSH_FILEXFER_ATTR_SIZE) {
		FAILRV(psbuf_get_8(pb, &vap->va_size));
		vap->va_bytes = vap->va_size;
	}
	if (flags & SSH_FILEXFER_ATTR_UIDGID) {
		FAILRV(psbuf_get_4(pb, &vap->va_uid));
		FAILRV(psbuf_get_4(pb, &vap->va_gid));
	}
	if (flags & SSH_FILEXFER_ATTR_PERMISSIONS) {
		FAILRV(psbuf_get_4(pb, &tmpval));
		vap->va_mode = tmpval;
		vap->va_type = puffs_mode2vt(vap->va_mode);
	}
	if (flags & SSH_FILEXFER_ATTR_ACCESSTIME) {
		/*
		 * XXX: this is utterly wrong if we want to speak
		 * protocol version 3, but it seems like the
		 * "internet standard" for doing this
		 */
		FAILRV(psbuf_get_4(pb, &val));
		vap->va_atime.tv_sec = val;
		FAILRV(psbuf_get_4(pb, &val));
		vap->va_mtime.tv_sec = val;
		/* make ctime the same as mtime */
		vap->va_ctime.tv_sec = val;

		vap->va_atime.tv_nsec = 0;
		vap->va_ctime.tv_nsec = 0;
		vap->va_mtime.tv_nsec = 0;
	}

	return 0;
}

/*
 * Buffer content helpers.  Caller frees all data.
 */

/*
 * error mapping.. most are not expected for a file system, but
 * should help with diagnosing a possible error
 */
static int emap[] = {
	0,			/* OK			*/
	0,			/* EOF			*/
	ENOENT,			/* NO_SUCH_FILE		*/
	EPERM,			/* PERMISSION_DENIED	*/
	EIO,			/* FAILURE		*/
	EBADMSG,		/* BAD_MESSAGE		*/
	ENOTCONN,		/* NO_CONNECTION	*/
	ECONNRESET,		/* CONNECTION_LOST	*/
	EOPNOTSUPP,		/* OP_UNSUPPORTED	*/
	EINVAL,			/* INVALID_HANDLE	*/
	ENXIO,			/* NO_SUCH_PATH		*/
	EEXIST,			/* FILE_ALREADY_EXISTS	*/
	ENODEV			/* WRITE_PROTECT	*/
};
#define NERRORS ((int)(sizeof(emap) / sizeof(emap[0])))

static int
sftperr_to_errno(int error)
{

	if (!error)
		return 0;

	if (error >= NERRORS || error < 0)
		return EPROTO;

	return emap[error];
}

#define INVALRESPONSE EPROTO

static int
expectcode(struct puffs_framebuf *pb, int value)
{
	uint32_t error;
	uint8_t type;

	type = psbuf_get_type(pb);
	if (type == value)
		return 0;

	if (type != SSH_FXP_STATUS)
		return INVALRESPONSE;

	FAILRV(psbuf_get_4(pb, &error));

	return sftperr_to_errno(error);
}

#define CHECKCODE(pb,val)						\
do {									\
	int rv;								\
	rv = expectcode(pb, val);					\
	if (rv)								\
		return rv;						\
} while (/*CONSTCOND*/0)

int
psbuf_expect_status(struct puffs_framebuf *pb)
{
	uint32_t error;

	if (psbuf_get_type(pb) != SSH_FXP_STATUS)
		return INVALRESPONSE;

	FAILRV(psbuf_get_4(pb, &error));

	return sftperr_to_errno(error);
}

int
psbuf_expect_handle(struct puffs_framebuf *pb, char **hand, uint32_t *handlen)
{

	CHECKCODE(pb, SSH_FXP_HANDLE);
	FAILRV(psbuf_get_str(pb, hand, handlen));

	return 0;
}

/* no memory allocation, direct copy */
int
psbuf_do_data(struct puffs_framebuf *pb, uint8_t *data, uint32_t *dlen)
{
	void *win;
	size_t bufoff, winlen;
	uint32_t len, dataoff;

	if (psbuf_get_type(pb) != SSH_FXP_DATA) {
		uint32_t val;

		if (psbuf_get_type(pb) != SSH_FXP_STATUS)
			return INVALRESPONSE;

		if (psbuf_get_4(pb, &val) != 0)
			return INVALRESPONSE;

		if (val != SSH_FX_EOF)
			return sftperr_to_errno(val);

		*dlen = 0;
		return 0;
	}
	if (psbuf_get_4(pb, &len) != 0)
		return INVALRESPONSE;

	if (*dlen < len)
		return EINVAL;

	*dlen = 0;

	dataoff = 0;
	while (dataoff < len) {
		winlen = len-dataoff;
		bufoff = puffs_framebuf_telloff(pb);
		if (puffs_framebuf_getwindow(pb, bufoff,
		    &win, &winlen) == -1)
			return EINVAL;
		if (winlen == 0)
			break;

		memcpy(data + dataoff, win, winlen);
		dataoff += winlen;
	}

	*dlen = dataoff;

	return 0;
}

int
psbuf_expect_name(struct puffs_framebuf *pb, uint32_t *count)
{

	CHECKCODE(pb, SSH_FXP_NAME);
	FAILRV(psbuf_get_4(pb, count));

	return 0;
}

int
psbuf_expect_attrs(struct puffs_framebuf *pb, struct vattr *vap)
{

	CHECKCODE(pb, SSH_FXP_ATTRS);
	FAILRV(psbuf_get_vattr(pb, vap));

	return 0;
}

/*
 * More helpers: larger-scale put functions
 */

void
psbuf_req_data(struct puffs_framebuf *pb, int type, uint32_t reqid,
	const void *data, uint32_t dlen)
{

	psbuf_put_1(pb, type);
	psbuf_put_4(pb, reqid);
	psbuf_put_data(pb, data, dlen);
}

void
psbuf_req_str(struct puffs_framebuf *pb, int type, uint32_t reqid,
	const char *str)
{

	psbuf_req_data(pb, type, reqid, str, strlen(str));
}
Commit	Line	Data
ab5617b3 SW	1	/* $NetBSD: psbuf.c,v 1.18 2010/01/08 10:53:31 pooka 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	* buffering functions for network input/output. slightly different
	30	* from the average joe buffer routines, as is usually the case ...
	31	* these use efuns for now.
	32	*/
	33
	34	#include <sys/types.h>
	35	#include <sys/endian.h>
	36	#include <sys/time.h>
	37	#include <sys/socket.h>
	38	#include <sys/vnode.h>
	39
	40	#include <err.h>
	41	#include <errno.h>
	42	#include <stdlib.h>
	43	#include <unistd.h>
	44
	45	#include "psshfs.h"
	46	#include "sftp_proto.h"
	47	#include "util_compat.h"
	48
	49	#define FAILRV(x) do { int rv; if ((rv=x)) return (rv); } while (/CONSTCOND/0)
	50	#define READSTATE_LENGTH(off) (off < 4)
	51
	52	#define SFTP_LENOFF 0
	53	#define SFTP_TYPEOFF 4
	54	#define SFTP_REQIDOFF 5
	55
	56	#define CHECK(v) if (!(v)) abort()
	57
	58	#define HTOBE16(x) (x) = htobe16((uint16_t)(x))
	59	#define HTOBE32(x) (x) = htobe32((uint32_t)(x))
	60	#define HTOBE64(x) (x) = htobe64((uint64_t)(x))
	61	#define BE16TOH(x) (x) = be16toh((uint16_t)(x))
	62	#define BE32TOH(x) (x) = be32toh((uint32_t)(x))
	63	#define BE64TOH(x) (x) = be64toh((uint64_t)(x))
	64
65	uint8_t
66	psbuf_get_type(struct puffs_framebuf *pb)
67	{
68	uint8_t type;
69
70	puffs_framebuf_getdata_atoff(pb, SFTP_TYPEOFF, &type, 1);
71	return type;
72	}
73
74	uint32_t
75	psbuf_get_len(struct puffs_framebuf *pb)
76	{
77	uint32_t len;
78
79	puffs_framebuf_getdata_atoff(pb, SFTP_LENOFF, &len, 4);
80	return be32toh(len);
81	}
82
83	uint32_t
84	psbuf_get_reqid(struct puffs_framebuf *pb)
85	{
86	uint32_t req;
87
88	puffs_framebuf_getdata_atoff(pb, SFTP_REQIDOFF, &req, 4);
89	return be32toh(req);
90	}
91
92	#define CUROFF(pb) (puffs_framebuf_telloff(pb))
93	int
94	psbuf_read(struct puffs_usermount pu, struct puffs_framebuf pb,
95	int fd, int *done)
96	{
97	void *win;
98	ssize_t n;
99	size_t howmuch, winlen;
100	int lenstate;
101
102	the_next_level:
103	if ((lenstate = READSTATE_LENGTH(CUROFF(pb))))
104	howmuch = 4 - CUROFF(pb);
105	else
106	howmuch = psbuf_get_len(pb) - (CUROFF(pb) - 4);
107
108	if (puffs_framebuf_reserve_space(pb, howmuch) == -1)
109	return errno;
110
111	while (howmuch) {
112	winlen = howmuch;
113	if (puffs_framebuf_getwindow(pb, CUROFF(pb), &win, &winlen)==-1)
114	return errno;
115	n = recv(fd, win, winlen, MSG_NOSIGNAL);
116	switch (n) {
117	case 0:
118	return ECONNRESET;
119	case -1:
120	if (errno == EAGAIN)
121	return 0;
122	return errno;
123	default:
124	howmuch -= n;
125	puffs_framebuf_seekset(pb, CUROFF(pb) + n);
126	break;
127	}
128	}
129
130	if (!lenstate) {
131	/* XXX: initial exchange shorter.. but don't worry, be happy */
132	puffs_framebuf_seekset(pb, 9);
133	*done = 1;
134	return 0;
135	} else
136	goto the_next_level;
137	}
138
139	int
140	psbuf_write(struct puffs_usermount pu, struct puffs_framebuf pb,
141	int fd, int *done)
142	{
143	void *win;
144	ssize_t n;
145	size_t winlen, howmuch;
146
147	/* finalize buffer.. could be elsewhere ... */
148	if (CUROFF(pb) == 0) {
149	uint32_t len;
150
151	len = htobe32(puffs_framebuf_tellsize(pb) - 4);
152	puffs_framebuf_putdata_atoff(pb, 0, &len, 4);
153	}
154
155	howmuch = puffs_framebuf_tellsize(pb) - CUROFF(pb);
156	while (howmuch) {
157	winlen = howmuch;
158	if (puffs_framebuf_getwindow(pb, CUROFF(pb), &win, &winlen)==-1)
159	return errno;
160	n = send(fd, win, winlen, MSG_NOSIGNAL);
161	switch (n) {
162	case 0:
163	return ECONNRESET;
164	case -1:
165	if (errno == EAGAIN)
166	return 0;
167	return errno;
168	default:
169	howmuch -= n;
170	puffs_framebuf_seekset(pb, CUROFF(pb) + n);
171	break;
172	}
173	}
174
175	*done = 1;
176	return 0;
177	}
178	#undef CUROFF
179
180	int
181	psbuf_cmp(struct puffs_usermount *pu,
182	struct puffs_framebuf cmp1, struct puffs_framebuf cmp2, int *notresp)
183	{
184
185	return psbuf_get_reqid(cmp1) != psbuf_get_reqid(cmp2);
186	}
187
188	struct puffs_framebuf *
89a89091	189	psbuf_makeout(void)
ab5617b3 SW	190	{
	191	struct puffs_framebuf *pb;
	192
	193	pb = puffs_framebuf_make();
	194	puffs_framebuf_seekset(pb, 4);
	195	return pb;
	196	}
	197
	198	void
	199	psbuf_recycleout(struct puffs_framebuf *pb)
	200	{
	201
	202	puffs_framebuf_recycle(pb);
	203	puffs_framebuf_seekset(pb, 4);
	204	}
	205
	206	void
	207	psbuf_put_1(struct puffs_framebuf *pb, uint8_t val)
	208	{
	209	int rv;
	210
	211	rv = puffs_framebuf_putdata(pb, &val, 1);
	212	CHECK(rv == 0);
	213	}
	214
	215	void
	216	psbuf_put_2(struct puffs_framebuf *pb, uint16_t val)
	217	{
	218	int rv;
	219
	220	HTOBE16(val);
	221	rv = puffs_framebuf_putdata(pb, &val, 2);
	222	CHECK(rv == 0);
	223	}
	224
	225	void
	226	psbuf_put_4(struct puffs_framebuf *pb, uint32_t val)
	227	{
	228	int rv;
	229
	230	HTOBE32(val);
	231	rv = puffs_framebuf_putdata(pb, &val, 4);
	232	CHECK(rv == 0);
	233	}
	234
	235	void
	236	psbuf_put_8(struct puffs_framebuf *pb, uint64_t val)
	237	{
	238	int rv;
	239
	240	HTOBE64(val);
	241	rv = puffs_framebuf_putdata(pb, &val, 8);
	242	CHECK(rv == 0);
	243	}
	244
	245	void
	246	psbuf_put_data(struct puffs_framebuf pb, const void data, uint32_t dlen)
	247	{
	248	int rv;
	249
	250	psbuf_put_4(pb, dlen);
	251	rv = puffs_framebuf_putdata(pb, data, dlen);
	252	CHECK(rv == 0);
	253	}
254
255	void
256	psbuf_put_str(struct puffs_framebuf pb, const char str)
257	{
258
259	psbuf_put_data(pb, str, strlen(str));
260	}
261
262	void
263	psbuf_put_vattr(struct puffs_framebuf pb, const struct vattr va,
264	const struct psshfs_ctx *pctx)
265	{
266	uint32_t flags;
267	uint32_t theuid = -1, thegid = -1;
268	flags = 0;
269
270	if (va->va_size != (uint64_t)PUFFS_VNOVAL)
271	flags \|= SSH_FILEXFER_ATTR_SIZE;
272	if (va->va_uid != (uid_t)PUFFS_VNOVAL) {
273	theuid = va->va_uid;
274	if (pctx->domangleuid && theuid == pctx->myuid)
275	theuid = pctx->mangleuid;
276	flags \|= SSH_FILEXFER_ATTR_UIDGID;
277	}
278	if (va->va_gid != (gid_t)PUFFS_VNOVAL) {
279	thegid = va->va_gid;
280	if (pctx->domanglegid && thegid == pctx->mygid)
281	thegid = pctx->manglegid;
282	flags \|= SSH_FILEXFER_ATTR_UIDGID;
283	}
284	if (va->va_mode != (mode_t)PUFFS_VNOVAL)
285	flags \|= SSH_FILEXFER_ATTR_PERMISSIONS;
286
287	if (va->va_atime.tv_sec != PUFFS_VNOVAL)
288	flags \|= SSH_FILEXFER_ATTR_ACCESSTIME;
289
290	psbuf_put_4(pb, flags);
291	if (flags & SSH_FILEXFER_ATTR_SIZE)
292	psbuf_put_8(pb, va->va_size);
293	if (flags & SSH_FILEXFER_ATTR_UIDGID) {
294	psbuf_put_4(pb, theuid);
295	psbuf_put_4(pb, thegid);
296	}
297	if (flags & SSH_FILEXFER_ATTR_PERMISSIONS)
298	psbuf_put_4(pb, va->va_mode);
299
300	/* XXX: this is totally wrong for protocol v3, see OpenSSH */
301	if (flags & SSH_FILEXFER_ATTR_ACCESSTIME) {
302	psbuf_put_4(pb, va->va_atime.tv_sec);
303	psbuf_put_4(pb, va->va_mtime.tv_sec);
304	}
305	}
306
307	#define ERETURN(rv) return ((rv) == -1 ? errno : 0)
308
309	int
310	psbuf_get_1(struct puffs_framebuf pb, uint8_t val)
311	{
312
313	ERETURN(puffs_framebuf_getdata(pb, val, 1));
314	}
315
316	int
317	psbuf_get_2(struct puffs_framebuf pb, uint16_t val)
318	{
319	int rv;
320
321	rv = puffs_framebuf_getdata(pb, val, 2);
322	BE16TOH(*val);
323
324	ERETURN(rv);
325	}
326
327	int
328	psbuf_get_4(struct puffs_framebuf pb, uint32_t val)
329	{
330	int rv;
331
332	rv = puffs_framebuf_getdata(pb, val, 4);
333	BE32TOH(*val);
334
335	ERETURN(rv);
336	}
337
338	int
339	psbuf_get_8(struct puffs_framebuf pb, uint64_t val)
340	{
341	int rv;
342
343	rv = puffs_framebuf_getdata(pb, val, 8);
344	BE64TOH(*val);
345
346	ERETURN(rv);
347	}
348
349	int
350	psbuf_get_str(struct puffs_framebuf pb, char strp, uint32_t strlenp)
351	{
352	char *str;
353	uint32_t len;
354
355	FAILRV(psbuf_get_4(pb, &len));
356
357	if (puffs_framebuf_remaining(pb) < len)
358	return EPROTO;
359
360	str = emalloc(len+1);
361	puffs_framebuf_getdata(pb, str, len);
362	str[len] = '\0';
363	*strp = str;
364
365	if (strlenp)
366	*strlenp = len;
367
368	return 0;
369	}
370
371	int
372	psbuf_get_vattr(struct puffs_framebuf pb, struct vattr vap)
373	{
374	uint32_t flags;
375	uint32_t val;
376	uint32_t tmpval;
377
378	puffs_vattr_null(vap);
379
380	FAILRV(psbuf_get_4(pb, &flags));
381
382	if (flags & SSH_FILEXFER_ATTR_SIZE) {
383	FAILRV(psbuf_get_8(pb, &vap->va_size));
384	vap->va_bytes = vap->va_size;
385	}
386	if (flags & SSH_FILEXFER_ATTR_UIDGID) {
387	FAILRV(psbuf_get_4(pb, &vap->va_uid));
388	FAILRV(psbuf_get_4(pb, &vap->va_gid));
389	}
390	if (flags & SSH_FILEXFER_ATTR_PERMISSIONS) {
391	FAILRV(psbuf_get_4(pb, &tmpval));
392	vap->va_mode = tmpval;
393	vap->va_type = puffs_mode2vt(vap->va_mode);
394	}
395	if (flags & SSH_FILEXFER_ATTR_ACCESSTIME) {
396	/*
397	* XXX: this is utterly wrong if we want to speak
398	* protocol version 3, but it seems like the
399	* "internet standard" for doing this
400	*/
401	FAILRV(psbuf_get_4(pb, &val));
402	vap->va_atime.tv_sec = val;
403	FAILRV(psbuf_get_4(pb, &val));
404	vap->va_mtime.tv_sec = val;
405	/* make ctime the same as mtime */
406	vap->va_ctime.tv_sec = val;
407
408	vap->va_atime.tv_nsec = 0;
409	vap->va_ctime.tv_nsec = 0;
410	vap->va_mtime.tv_nsec = 0;
411	}
412
413	return 0;
414	}
415
416	/*
417	* Buffer content helpers. Caller frees all data.
418	*/
419
420	/*
421	* error mapping.. most are not expected for a file system, but
422	* should help with diagnosing a possible error
423	*/
424	static int emap[] = {
425	0, /* OK */
426	0, /* EOF */
427	ENOENT, /* NO_SUCH_FILE */
428	EPERM, /* PERMISSION_DENIED */
429	EIO, /* FAILURE */
430	EBADMSG, /* BAD_MESSAGE */
431	ENOTCONN, /* NO_CONNECTION */
432	ECONNRESET, /* CONNECTION_LOST */
433	EOPNOTSUPP, /* OP_UNSUPPORTED */
434	EINVAL, /* INVALID_HANDLE */
435	ENXIO, /* NO_SUCH_PATH */
436	EEXIST, /* FILE_ALREADY_EXISTS */
437	ENODEV /* WRITE_PROTECT */
438	};
439	#define NERRORS ((int)(sizeof(emap) / sizeof(emap[0])))
440
441	static int
442	sftperr_to_errno(int error)
443	{
444
445	if (!error)
446	return 0;
447
448	if (error >= NERRORS \|\| error < 0)
449	return EPROTO;
450
451	return emap[error];
452	}
453
454	#define INVALRESPONSE EPROTO
455
456	static int
457	expectcode(struct puffs_framebuf *pb, int value)
458	{
459	uint32_t error;
460	uint8_t type;
461
462	type = psbuf_get_type(pb);
463	if (type == value)
464	return 0;
465
466	if (type != SSH_FXP_STATUS)
467	return INVALRESPONSE;
468
469	FAILRV(psbuf_get_4(pb, &error));
470
471	return sftperr_to_errno(error);
472	}
473
474	#define CHECKCODE(pb,val) \
475	do { \
476	int rv; \
477	rv = expectcode(pb, val); \
478	if (rv) \
479	return rv; \
480	} while (/CONSTCOND/0)
481
482	int
483	psbuf_expect_status(struct puffs_framebuf *pb)
484	{
485	uint32_t error;
486
487	if (psbuf_get_type(pb) != SSH_FXP_STATUS)
488	return INVALRESPONSE;
489
490	FAILRV(psbuf_get_4(pb, &error));
491
492	return sftperr_to_errno(error);
493	}
494
495	int
496	psbuf_expect_handle(struct puffs_framebuf pb, char hand, uint32_t handlen)
497	{
498
499	CHECKCODE(pb, SSH_FXP_HANDLE);
500	FAILRV(psbuf_get_str(pb, hand, handlen));
501
502	return 0;
503	}
504
505	/* no memory allocation, direct copy */
506	int
507	psbuf_do_data(struct puffs_framebuf pb, uint8_t data, uint32_t *dlen)
508	{
509	void *win;
510	size_t bufoff, winlen;
511	uint32_t len, dataoff;
512
513	if (psbuf_get_type(pb) != SSH_FXP_DATA) {
514	uint32_t val;
515
516	if (psbuf_get_type(pb) != SSH_FXP_STATUS)
517	return INVALRESPONSE;
518
519	if (psbuf_get_4(pb, &val) != 0)
520	return INVALRESPONSE;
521
522	if (val != SSH_FX_EOF)
523	return sftperr_to_errno(val);
524
525	*dlen = 0;
526	return 0;
527	}
528	if (psbuf_get_4(pb, &len) != 0)
529	return INVALRESPONSE;
530
531	if (*dlen < len)
532	return EINVAL;
533
534	*dlen = 0;
535
536	dataoff = 0;
537	while (dataoff < len) {
538	winlen = len-dataoff;
539	bufoff = puffs_framebuf_telloff(pb);
540	if (puffs_framebuf_getwindow(pb, bufoff,
541	&win, &winlen) == -1)
542	return EINVAL;
543	if (winlen == 0)
544	break;
545
546	memcpy(data + dataoff, win, winlen);
547	dataoff += winlen;
548	}
549
550	*dlen = dataoff;
551
552	return 0;
553	}
554
555	int
556	psbuf_expect_name(struct puffs_framebuf pb, uint32_t count)
557	{
558
559	CHECKCODE(pb, SSH_FXP_NAME);
560	FAILRV(psbuf_get_4(pb, count));
561
562	return 0;
563	}
564
565	int
566	psbuf_expect_attrs(struct puffs_framebuf pb, struct vattr vap)
567	{
568
569	CHECKCODE(pb, SSH_FXP_ATTRS);
570	FAILRV(psbuf_get_vattr(pb, vap));
571
572	return 0;
573	}
574
575	/*
576	* More helpers: larger-scale put functions
577	*/
578
579	void
580	psbuf_req_data(struct puffs_framebuf *pb, int type, uint32_t reqid,
581	const void *data, uint32_t dlen)
582	{
583
584	psbuf_put_1(pb, type);
585	psbuf_put_4(pb, reqid);
586	psbuf_put_data(pb, data, dlen);
587	}
588
589	void
590	psbuf_req_str(struct puffs_framebuf *pb, int type, uint32_t reqid,
591	const char *str)
592	{
593
594	psbuf_req_data(pb, type, reqid, str, strlen(str));
595	}