Ansify some function definitions that were previously overlooked.
[dragonfly.git] / usr.sbin / puffs / mount_psshfs / psbuf.c
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 *
189 psbuf_makeout(void)
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 }