Blob


1 /*
2 * Copyright (c) 2021, 2022 Omar Polo <op@omarpolo.com>
3 *
4 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
7 *
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 */
17 #include "compat.h"
19 #include <sys/stat.h>
20 #include <sys/types.h>
21 #include <sys/uio.h>
23 #include <dirent.h>
24 #include <endian.h>
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <inttypes.h>
28 #include <libgen.h>
29 #include <pwd.h>
30 #include <signal.h>
31 #include <stdint.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <syslog.h>
36 #include <unistd.h>
38 #include "client.h"
39 #include "kami.h"
40 #include "kamid.h"
41 #include "log.h"
42 #include "sandbox.h"
43 #include "utils.h"
45 /*
46 * XXX: atm is difficult to accept messages bigger than MAX_IMSGSIZE
47 * minus IMSG_HEADER_SIZE, we need something to split messages into
48 * chunks and receive them one by the other.
49 *
50 * CLIENT_MSIZE is thus the maximum message size we can handle now.
51 */
52 #define CLIENT_MSIZE (MAX_IMSGSIZE - IMSG_HEADER_SIZE)
54 #define DEBUG_PACKETS 0
56 /* straight outta /src/usr.bin/ssh/scp.c */
57 #define TYPE_OVERFLOW(type, val) \
58 ((sizeof(type) == 4 && (val) > INT32_MAX) || \
59 (sizeof(type) == 8 && (val) > INT64_MAX) || \
60 (sizeof(type) != 4 && sizeof(type) != 8))
62 STAILQ_HEAD(dirhead, dir) dirs;
63 struct dir {
64 int refcount;
65 int fd;
66 STAILQ_ENTRY(dir) entries;
67 };
69 STAILQ_HEAD(fidhead, fid) fids;
70 struct fid {
71 uint32_t fid;
73 char fname[NAME_MAX];
75 /*
76 * the flags passed to open(2). O_CLOEXEC means ORCLOSE, that
77 * is to unlink the file upon Tclunk.
78 */
79 int iomode;
81 /*
82 * if fd is not -1 this fid was opened, fd represents its
83 * file descriptor and iomode the flags passed to open(2).
84 */
85 int fd;
86 DIR *d;
87 struct evbuffer *evb;
89 /*
90 * expected offset for Tread against a directory.
91 */
92 uint64_t offset;
94 struct qid qid;
95 struct dir *dir;
96 STAILQ_ENTRY(fid) entries;
97 };
99 static struct imsgev *iev_listener;
100 static struct evbuffer *evb;
101 static uint32_t peerid;
103 static int handshaked;
104 uint32_t msize;
106 static __dead void client_shutdown(void);
107 static void client_sig_handler(int, short, void *);
108 static void client_dispatch_listener(int, short, void *);
109 static void client_privdrop(const char *, const char *);
111 static int client_send_listenerp(int, uint32_t, const void *, uint16_t);
112 static int client_send_listener(int, const void *, uint16_t);
114 static void qid_update_from_sb(struct qid *, struct stat *);
116 static struct dir *new_dir(int);
117 static struct dir *dir_incref(struct dir *);
118 static void dir_decref(struct dir *);
120 static struct fid *new_fid(struct dir *, uint32_t, const char *, struct qid *);
121 static struct fid *fid_by_id(uint32_t);
122 static void free_fid(struct fid *);
124 static void parse_message(const uint8_t *, size_t,
125 struct np_msg_header *, uint8_t **);
127 static void np_write16(struct evbuffer *, uint16_t);
128 static void np_write32(struct evbuffer *, uint32_t);
129 static void np_write64(struct evbuffer *, uint64_t);
130 static void np_header(uint32_t, uint8_t, uint16_t);
131 static void np_string(struct evbuffer *, uint16_t, const char *);
132 static void np_qid(struct evbuffer *, struct qid *);
133 static void do_send(void);
135 static void np_version(uint16_t, uint32_t, const char *);
136 static void np_attach(uint16_t, struct qid *);
137 static void np_clunk(uint16_t);
138 static void np_flush(uint16_t);
139 static void np_walk(uint16_t, int, struct qid *);
140 static void np_open(uint16_t, struct qid *, uint32_t);
141 static void np_create(uint16_t, struct qid *, uint32_t);
142 static void np_read(uint16_t, uint32_t, void *);
143 static void np_write(uint16_t, uint32_t);
144 static void np_stat(uint16_t, uint16_t, void *);
145 static void np_wstat(uint16_t);
146 static void np_remove(uint16_t);
147 static void np_error(uint16_t, const char *);
148 static void np_errno(uint16_t);
150 static int np_read8(const char *, const char *, uint8_t *,
151 const uint8_t **, size_t *);
152 static int np_read16(const char *, const char *, uint16_t *,
153 const uint8_t **, size_t *);
154 static int np_read32(const char *, const char *, uint32_t *,
155 const uint8_t **, size_t *);
156 static int np_read64(const char *, const char *, uint64_t *,
157 const uint8_t **, size_t *);
159 #define READSTRERR -1
160 #define READSTRTRUNC -2
161 static int np_readstr(const char *, const char *, char *, size_t,
162 const uint8_t **, size_t *);
164 static int np_readst(const char *, const char *, struct np_stat *,
165 char *, size_t, const uint8_t **, size_t *);
167 #define NPREAD8(f, dst, src, len) np_read8(__func__, f, dst, src, len)
168 #define NPREAD16(f, dst, src, len) np_read16(__func__, f, dst, src, len)
169 #define NPREAD32(f, dst, src, len) np_read32(__func__, f, dst, src, len)
170 #define NPREAD64(f, dst, src, len) np_read64(__func__, f, dst, src, len)
172 #define NPREADSTR(f, b, bl, src, len) np_readstr(__func__, f, b, bl, src, len)
174 #define NPREADST(f, dst, n, nl, src, len) np_readst(__func__, f, dst, n, nl, src, len)
176 static void tversion(struct np_msg_header *, const uint8_t *, size_t);
177 static void tattach(struct np_msg_header *, const uint8_t *, size_t);
178 static void tclunk(struct np_msg_header *, const uint8_t *, size_t);
179 static void tflush(struct np_msg_header *, const uint8_t *, size_t);
180 static void twalk(struct np_msg_header *, const uint8_t *, size_t);
181 static void topen(struct np_msg_header *, const uint8_t *, size_t);
182 static void tcreate(struct np_msg_header *, const uint8_t *, size_t);
183 static void tread(struct np_msg_header *, const uint8_t *, size_t);
184 static void twrite(struct np_msg_header *, const uint8_t *, size_t);
185 static void tstat(struct np_msg_header *, const uint8_t *, size_t);
186 static void twstat(struct np_msg_header *, const uint8_t *, size_t);
187 static void tremove(struct np_msg_header *, const uint8_t *, size_t);
188 static void handle_message(struct imsg *, size_t);
190 __dead void
191 client(int debug, int verbose)
193 struct event ev_sigint, ev_sigterm;
195 log_init(debug, LOG_DAEMON);
196 log_setverbose(verbose);
198 setproctitle("client");
199 log_procinit("client");
201 log_debug("warming up");
203 event_init();
205 /* Setup signal handlers */
206 signal_set(&ev_sigint, SIGINT, client_sig_handler, NULL);
207 signal_set(&ev_sigterm, SIGTERM, client_sig_handler, NULL);
209 signal_add(&ev_sigint, NULL);
210 signal_add(&ev_sigterm, NULL);
212 signal(SIGPIPE, SIG_IGN);
213 signal(SIGHUP, SIG_IGN);
215 /* Setup pipe and event handler to the listener process */
216 if ((iev_listener = malloc(sizeof(*iev_listener))) == NULL)
217 fatal(NULL);
219 imsg_init(&iev_listener->ibuf, 3);
220 iev_listener->handler = client_dispatch_listener;
222 /* Setup event handlers. */
223 iev_listener->events = EV_READ;
224 event_set(&iev_listener->ev, iev_listener->ibuf.fd,
225 iev_listener->events, iev_listener->handler, iev_listener);
226 event_add(&iev_listener->ev, NULL);
228 event_dispatch();
229 client_shutdown();
232 static __dead void
233 client_shutdown(void)
235 if (evb != NULL)
236 evbuffer_free(evb);
238 msgbuf_clear(&iev_listener->ibuf.w);
239 close(iev_listener->ibuf.fd);
241 free(iev_listener);
243 log_debug("client exiting");
244 exit(0);
247 static void
248 client_sig_handler(int sig, short event, void *d)
250 /*
251 * Normal signal handler rules don't apply because libevent
252 * decouples for us.
253 */
255 switch (sig) {
256 case SIGINT:
257 case SIGTERM:
258 client_shutdown();
259 default:
260 fatalx("unexpected signal %d", sig);
264 static void
265 client_dispatch_listener(int fd, short event, void *d)
267 static int auth = 0;
268 struct kd_auth_proc rauth;
269 struct kd_debug_info debug;
270 struct fid *f;
271 struct imsg imsg;
272 struct imsgev *iev = d;
273 struct imsgbuf *ibuf;
274 ssize_t n;
275 int shut = 0;
277 ibuf = &iev->ibuf;
279 if (event & EV_READ) {
280 if ((n = imsg_read(ibuf)) == -1 && errno != EAGAIN)
281 fatal("imsg_read error");
282 if (n == 0) /* Connection closed */
283 shut = 1;
285 if (event & EV_WRITE) {
286 if ((n = msgbuf_write(&ibuf->w)) == -1 && errno != EAGAIN)
287 fatal("msgbuf_write");
288 if (n == 0) /* Connection closed */
289 shut = 1;
292 for (;;) {
293 if ((n = imsg_get(ibuf, &imsg)) == -1)
294 fatal("%s: imsg_get error", __func__);
295 if (n == 0) /* No more messages. */
296 break;
298 switch (imsg.hdr.type) {
299 case IMSG_CTL_LOG_VERBOSE:
300 if (IMSG_DATA_SIZE(imsg) != sizeof(verbose))
301 fatalx("%s: IMSG_CTL_LOG_VERBOSE wrong size",
302 __func__);
303 memcpy(&verbose, imsg.data, sizeof(verbose));
304 log_setverbose(verbose);
305 break;
306 case IMSG_CTL_DEBUG:
307 STAILQ_FOREACH(f, &fids, entries) {
308 memset(&debug, 0, sizeof(debug));
309 debug.fid = f->fid;
310 strlcpy(debug.path, f->fname,
311 sizeof(debug.path));
312 client_send_listenerp(IMSG_CTL_DEBUG_BACK,
313 imsg.hdr.peerid, &debug, sizeof(debug));
315 client_send_listenerp(IMSG_CTL_DEBUG_END,
316 imsg.hdr.peerid, NULL, 0);
317 break;
318 case IMSG_AUTH:
319 peerid = imsg.hdr.peerid;
320 if (auth)
321 fatalx("%s: IMSG_AUTH already done", __func__);
322 auth = 1;
324 if (IMSG_DATA_SIZE(imsg) != sizeof(rauth))
325 fatalx("mismatching size for IMSG_AUTH");
326 memcpy(&rauth, imsg.data, sizeof(rauth));
327 if (rauth.uname[sizeof(rauth.uname)-1] != '\0' ||
328 rauth.dir[sizeof(rauth.dir)-1] != '\0')
329 fatalx("IMSG_AUTH strings not NUL-terminated");
331 client_privdrop(rauth.uname, rauth.dir);
332 explicit_bzero(&rauth, sizeof(rauth));
333 break;
334 case IMSG_BUF:
335 if (!auth)
336 fatalx("%s: can't handle messages before"
337 " doing the auth", __func__);
338 handle_message(&imsg, IMSG_DATA_SIZE(imsg));
339 break;
340 case IMSG_CONN_GONE:
341 log_debug("closing");
342 shut = 1;
343 break;
344 default:
345 log_debug("%s: unexpected imsg %d",
346 __func__, imsg.hdr.type);
347 break;
349 imsg_free(&imsg);
352 if (!shut)
353 imsg_event_add(iev);
354 else {
355 /* This pipe is dead. Remove its event handler. */
356 event_del(&iev->ev);
357 log_debug("pipe closed, shutting down...");
358 event_loopexit(NULL);
362 static void
363 client_privdrop(const char *username, const char *dir)
365 struct passwd *pw;
367 setproctitle("client %s", username);
369 if ((pw = getpwnam(username)) == NULL)
370 fatalx("getpwnam(%s) failed", username);
372 if (chroot(dir) == -1)
373 fatal("chroot");
374 if (chdir("/") == -1)
375 fatal("chdir(\"/\")");
377 if (setgroups(1, &pw->pw_gid) ||
378 setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
379 setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
380 fatal("can't drop privileges");
382 sandbox_client();
383 log_debug("client ready; user=%s dir=%s", username, dir);
385 if ((evb = evbuffer_new()) == NULL)
386 fatal("evbuffer_new");
389 static int
390 client_send_listenerp(int type, uint32_t peerid, const void *data, uint16_t len)
392 int ret;
394 if ((ret = imsg_compose(&iev_listener->ibuf, type, peerid, 0, -1,
395 data, len)) != -1)
396 imsg_event_add(iev_listener);
398 return ret;
401 static int
402 client_send_listener(int type, const void *data, uint16_t len)
404 return client_send_listenerp(type, peerid, data, len);
407 /* set qid fields from sb */
408 static void
409 qid_update_from_sb(struct qid *qid, struct stat *sb)
411 qid->path = sb->st_ino;
413 /*
414 * Theoretically (and hopefully!) this should be a 64 bit
415 * number. Unfortunately, 9P uses 32 bit timestamps.
416 */
417 qid->vers = sb->st_mtim.tv_sec;
419 if (S_ISREG(sb->st_mode))
420 qid->type = QTFILE;
421 else if (S_ISDIR(sb->st_mode))
422 qid->type = QTDIR;
423 else if (S_ISLNK(sb->st_mode))
424 qid->type = QTSYMLINK;
427 /* creates a qid given a fd */
428 static struct dir *
429 new_dir(int fd)
431 struct dir *dir;
433 if ((dir = calloc(1, sizeof(*dir))) == NULL)
434 return NULL;
436 dir->fd = fd;
437 STAILQ_INSERT_HEAD(&dirs, dir, entries);
438 return dir;
441 static struct dir *
442 dir_incref(struct dir *dir)
444 dir->refcount++;
445 return dir;
448 static void
449 dir_decref(struct dir *dir)
451 if (--dir->refcount > 0)
452 return;
454 STAILQ_REMOVE(&dirs, dir, dir, entries);
456 close(dir->fd);
457 free(dir);
460 static struct fid *
461 new_fid(struct dir *dir, uint32_t fid, const char *path, struct qid *qid)
463 struct fid *f;
464 struct qid q;
465 struct stat sb;
467 if (qid == NULL) {
468 if (fstatat(dir->fd, path, &sb, 0)) {
469 log_warn("fstatat(%s)", path);
470 return NULL;
472 qid_update_from_sb(&q, &sb);
473 qid = &q;
476 if ((f = calloc(1, sizeof(*f))) == NULL)
477 return NULL;
479 f->dir = dir_incref(dir);
480 f->fid = fid;
481 f->fd = -1;
483 strlcpy(f->fname, path, sizeof(f->fname));
485 memcpy(&f->qid, qid, sizeof(f->qid));
487 STAILQ_INSERT_HEAD(&fids, f, entries);
489 return f;
492 static struct fid *
493 fid_by_id(uint32_t fid)
495 struct fid *f;
497 STAILQ_FOREACH(f, &fids, entries) {
498 if (f->fid == fid)
499 return f;
502 return NULL;
505 static void
506 free_fid(struct fid *f)
508 int r;
510 if (f->fd != -1) {
511 if (f->d != NULL)
512 r = closedir(f->d);
513 else
514 r = close(f->fd);
516 if (r == -1)
517 fatal("can't close fid %d", f->fid);
519 if (f->evb != NULL)
520 evbuffer_free(f->evb);
522 /* try to honour ORCLOSE if requested */
523 if (f->iomode & O_CLOEXEC)
524 unlinkat(f->dir->fd, f->fname, 0);
527 dir_decref(f->dir);
529 STAILQ_REMOVE(&fids, f, fid, entries);
530 free(f);
533 static void
534 parse_message(const uint8_t *data, size_t len, struct np_msg_header *hdr,
535 uint8_t **cnt)
537 size_t olen = len;
539 if (!NPREAD32("len", &hdr->len, &data, &len) ||
540 !NPREAD8("type", &hdr->type, &data, &len) ||
541 !NPREAD16("tag", &hdr->tag, &data, &len))
542 goto err;
544 if (olen != hdr->len)
545 goto err;
547 if (hdr->type < Tversion ||
548 hdr->type >= Tmax ||
549 hdr->type == Terror ||
550 (hdr->type & 0x1) != 0) /* cannot recv a R* */
551 goto err;
553 hdr->tag = le32toh(hdr->tag);
555 *cnt = (uint8_t *)data;
556 return;
558 err:
559 /* TODO: send a proper message to terminate the connection. */
560 fatalx("got invalid message");
563 static void
564 np_write16(struct evbuffer *e, uint16_t x)
566 x = htole16(x);
567 evbuffer_add(e, &x, sizeof(x));
570 static void
571 np_write32(struct evbuffer *e, uint32_t x)
573 x = htole32(x);
574 evbuffer_add(e, &x, sizeof(x));
577 static void
578 np_write64(struct evbuffer *e, uint64_t x)
580 x = htole64(x);
581 evbuffer_add(e, &x, sizeof(x));
584 static void
585 np_writebuf(struct evbuffer *e, size_t len, void *data)
587 evbuffer_add(e, data, len);
590 static void
591 np_header(uint32_t len, uint8_t type, uint16_t tag)
593 len += HEADERSIZE;
595 len = htole32(len);
596 tag = htole16(tag);
598 evbuffer_add(evb, &len, sizeof(len));
599 evbuffer_add(evb, &type, sizeof(type));
600 evbuffer_add(evb, &tag, sizeof(tag));
603 static void
604 np_string(struct evbuffer *e, uint16_t len, const char *str)
606 uint16_t l = len;
608 len = htole16(len);
609 evbuffer_add(e, &len, sizeof(len));
610 evbuffer_add(e, str, l);
613 static void
614 np_qid(struct evbuffer *e, struct qid *qid)
616 uint64_t path;
617 uint32_t vers;
619 path = htole64(qid->path);
620 vers = htole32(qid->vers);
622 evbuffer_add(e, &qid->type, sizeof(qid->type));
623 evbuffer_add(e, &vers, sizeof(vers));
624 evbuffer_add(e, &path, sizeof(path));
627 static void
628 do_send(void)
630 size_t len;
631 void *data;
633 len = EVBUFFER_LENGTH(evb);
634 data = EVBUFFER_DATA(evb);
636 #if DEBUG_PACKETS
637 hexdump("outgoing packet", data, len);
638 #endif
639 client_send_listener(IMSG_BUF, data, len);
640 evbuffer_drain(evb, len);
643 static void
644 np_version(uint16_t tag, uint32_t msize, const char *version)
646 uint16_t l;
648 l = strlen(version);
650 msize = htole32(msize);
652 np_header(sizeof(msize) + sizeof(l) + l, Rversion, tag);
653 evbuffer_add(evb, &msize, sizeof(msize));
654 np_string(evb, l, version);
655 do_send();
658 static void
659 np_attach(uint16_t tag, struct qid *qid)
661 np_header(QIDSIZE, Rattach, tag);
662 np_qid(evb, qid);
663 do_send();
666 static void
667 np_clunk(uint16_t tag)
669 np_header(0, Rclunk, tag);
670 do_send();
673 static void
674 np_flush(uint16_t tag)
676 np_header(0, Rflush, tag);
677 do_send();
680 static void
681 np_walk(uint16_t tag, int nwqid, struct qid *wqid)
683 int i;
685 /* two bytes for the counter */
686 np_header(2 + QIDSIZE * nwqid, Rwalk, tag);
687 np_write16(evb, nwqid);
688 for (i = 0; i < nwqid; ++i)
689 np_qid(evb, wqid + i);
691 do_send();
694 static void
695 np_open(uint16_t tag, struct qid *qid, uint32_t iounit)
697 np_header(QIDSIZE + sizeof(iounit), Ropen, tag);
698 np_qid(evb, qid);
699 np_write32(evb, iounit);
700 do_send();
703 static void
704 np_create(uint16_t tag, struct qid *qid, uint32_t iounit)
706 np_header(QIDSIZE + sizeof(iounit), Rcreate, tag);
707 np_qid(evb, qid);
708 np_write32(evb, iounit);
709 do_send();
712 static void
713 np_read(uint16_t tag, uint32_t count, void *data)
715 if (sizeof(count) + count + HEADERSIZE >= msize) {
716 np_error(tag, "Rread would overflow");
717 return;
720 np_header(sizeof(count) + count, Rread, tag);
721 np_write32(evb, count);
722 np_writebuf(evb, count, data);
723 do_send();
726 static void
727 np_write(uint16_t tag, uint32_t count)
729 np_header(sizeof(count), Rwrite, tag);
730 np_write32(evb, count);
731 do_send();
734 static void
735 np_stat(uint16_t tag, uint16_t count, void *data)
737 if (sizeof(count) + count + HEADERSIZE >= msize) {
738 np_error(tag, "Rstat would overflow");
739 return;
742 np_header(sizeof(count) + count, Rstat, tag);
743 np_write16(evb, count);
744 np_writebuf(evb, count, data);
745 do_send();
748 static void
749 np_wstat(uint16_t tag)
751 np_header(0, Rwstat, tag);
752 do_send();
755 static void
756 np_remove(uint16_t tag)
758 np_header(0, Rremove, tag);
759 do_send();
762 static void
763 np_error(uint16_t tag, const char *errstr)
765 uint16_t l;
767 l = strlen(errstr);
769 np_header(sizeof(l) + l, Rerror, tag);
770 np_string(evb, l, errstr);
771 do_send();
774 static void
775 np_errno(uint16_t tag)
777 int saved_errno;
778 char buf[NL_TEXTMAX] = {0};
780 saved_errno = errno;
782 strerror_r(errno, buf, sizeof(buf));
783 np_error(tag, buf);
785 errno = saved_errno;
788 static int
789 np_read8(const char *t, const char *f, uint8_t *dst, const uint8_t **src,
790 size_t *len)
792 if (*len < sizeof(*dst)) {
793 log_warnx("%s: wanted %zu bytes for the %s field but only "
794 "%zu are available.", t, sizeof(*dst), f, *len);
795 return 0;
798 memcpy(dst, *src, sizeof(*dst));
799 *src += sizeof(*dst);
800 *len -= sizeof(*dst);
802 return 1;
805 static int
806 np_read16(const char *t, const char *f, uint16_t *dst, const uint8_t **src,
807 size_t *len)
809 if (*len < sizeof(*dst)) {
810 log_warnx("%s: wanted %zu bytes for the %s field but only "
811 "%zu are available.", t, sizeof(*dst), f, *len);
812 return 0;
815 memcpy(dst, *src, sizeof(*dst));
816 *src += sizeof(*dst);
817 *len -= sizeof(*dst);
818 *dst = le16toh(*dst);
820 return 1;
823 static int
824 np_read32(const char *t, const char *f, uint32_t *dst, const uint8_t **src,
825 size_t *len)
827 if (*len < sizeof(*dst)) {
828 log_warnx("%s: wanted %zu bytes for the %s field but only "
829 "%zu are available.", t, sizeof(*dst), f, *len);
830 return 0;
833 memcpy(dst, *src, sizeof(*dst));
834 *src += sizeof(*dst);
835 *len -= sizeof(*dst);
836 *dst = le32toh(*dst);
838 return 1;
841 static int
842 np_read64(const char *t, const char *f, uint64_t *dst, const uint8_t **src,
843 size_t *len)
845 if (*len < sizeof(*dst)) {
846 log_warnx("%s: wanted %zu bytes for the %s field but only "
847 "%zu are available.", t, sizeof(*dst), f, *len);
848 return 0;
851 memcpy(dst, *src, sizeof(*dst));
852 *src += sizeof(*dst);
853 *len -= sizeof(*dst);
854 *dst = le64toh(*dst);
856 return 1;
859 static int
860 np_readstr(const char *t, const char *f, char *res, size_t reslen,
861 const uint8_t **src, size_t *len)
863 uint16_t sl;
864 char buf[32];
866 strlcpy(buf, f, sizeof(buf));
867 strlcat(buf, "-len", sizeof(buf));
869 if (!np_read16(t, buf, &sl, src, len))
870 return READSTRERR;
872 if (*len < sl) {
873 log_warnx("%s: wanted %d bytes for the %s field but only "
874 "%zu are available.", t, sl, f, *len);
875 return READSTRERR;
878 if (*len > reslen-1)
879 return READSTRTRUNC;
881 memcpy(res, *src, sl);
882 res[sl] = '\0';
883 *src += sl;
884 *len -= sl;
886 return 0;
889 static int
890 np_readst(const char *t, const char *f, struct np_stat *st,
891 char *name, size_t namelen, const uint8_t **src, size_t *len)
893 memset(st, 0, sizeof(*st));
895 if (!np_read16(t, "stat.size", &st->size, src, len) ||
896 !np_read16(t, "stat.type", &st->type, src, len) ||
897 !np_read32(t, "stat.dev", &st->dev, src, len) ||
898 !np_read64(t, "stat.qid.path", &st->qid.path, src, len) ||
899 !np_read32(t, "stat.qid.vers", &st->qid.vers, src, len) ||
900 !np_read8(t, "stat.qid.type", &st->qid.type, src, len) ||
901 !np_read32(t, "stat.mode", &st->mode, src, len) ||
902 !np_read32(t, "stat.atime", &st->atime, src, len) ||
903 !np_read32(t, "stat.mtime", &st->mtime, src, len) ||
904 !np_read64(t, "stat.length", &st->length, src, len))
905 return READSTRERR;
907 /*
908 * ignore everything but the name, we don't support
909 * changing those fields anyway
910 */
911 st->name = name;
912 return np_readstr(t, "stat.name", name, namelen, src, len);
915 static void
916 tversion(struct np_msg_header *hdr, const uint8_t *data, size_t len)
918 char *dot, version[32];
920 if (handshaked)
921 goto err;
923 /* msize[4] version[s] */
924 if (!NPREAD32("msize", &msize, &data, &len))
925 goto err;
927 switch (NPREADSTR("version", version, sizeof(version), &data, &len)) {
928 case READSTRERR:
929 goto err;
930 case READSTRTRUNC:
931 log_warnx("9P version string too long, truncated");
932 goto mismatch;
935 if (len != 0)
936 goto err;
938 if ((dot = strchr(version, '.')) != NULL)
939 *dot = '\0';
941 if (strcmp(version, VERSION9P) != 0 ||
942 msize == 0)
943 goto mismatch;
945 /* version matched */
946 handshaked = 1;
947 msize = MIN(msize, CLIENT_MSIZE);
948 client_send_listener(IMSG_MSIZE, &msize, sizeof(msize));
949 np_version(hdr->tag, msize, VERSION9P);
950 return;
952 mismatch:
953 log_warnx("unknown 9P version string: \"%s\", want "VERSION9P,
954 version);
955 np_version(hdr->tag, MSIZE9P, "unknown");
956 return;
958 err:
959 client_send_listener(IMSG_CLOSE, NULL, 0);
960 client_shutdown();
963 static void
964 tattach(struct np_msg_header *hdr, const uint8_t *data, size_t len)
966 struct dir *dir;
967 struct fid *f;
968 uint32_t fid, afid;
969 int fd;
970 char aname[PATH_MAX];
972 /* fid[4] afid[4] uname[s] aname[s] */
974 if (!NPREAD32("fid", &fid, &data, &len) ||
975 !NPREAD32("afid", &afid, &data, &len))
976 goto err;
978 /* read the uname but don't actually use it */
979 switch (NPREADSTR("uname", aname, sizeof(aname), &data, &len)) {
980 case READSTRERR:
981 goto err;
982 case READSTRTRUNC:
983 np_error(hdr->tag, "name too long");
984 return;
987 switch (NPREADSTR("aname", aname, sizeof(aname), &data, &len)) {
988 case READSTRERR:
989 goto err;
990 case READSTRTRUNC:
991 np_error(hdr->tag, "name too long");
992 return;
995 if (*aname == '\0')
996 strlcpy(aname, "/", sizeof(aname));
998 if (len != 0)
999 goto err;
1001 if (fid_by_id(fid) != NULL || afid != NOFID) {
1002 np_error(hdr->tag, "invalid fid or afid");
1003 return;
1006 if ((fd = open(aname, O_RDONLY|O_DIRECTORY)) == -1)
1007 goto fail;
1009 if ((dir = new_dir(fd)) == NULL)
1010 goto fail;
1012 log_debug("attached %s to %d", aname, fid);
1014 if ((f = new_fid(dir, fid, aname, NULL)) == NULL) {
1015 dir_decref(dir);
1016 goto fail;
1019 np_attach(hdr->tag, &f->qid);
1020 return;
1022 fail:
1023 np_errno(hdr->tag);
1024 log_warn("failed to attach %s", aname);
1025 return;
1027 err:
1028 client_send_listener(IMSG_CLOSE, NULL, 0);
1029 client_shutdown();
1032 static void
1033 tclunk(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1035 struct fid *f;
1036 uint32_t fid;
1038 /* fid[4] */
1039 if (!NPREAD32("fid", &fid, &data, &len) ||
1040 len != 0) {
1041 client_send_listener(IMSG_CLOSE, NULL, 0);
1042 client_shutdown();
1043 return;
1046 if ((f = fid_by_id(fid)) == NULL) {
1047 np_error(hdr->tag, "invalid fid");
1048 return;
1051 free_fid(f);
1052 np_clunk(hdr->tag);
1055 static void
1056 tflush(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1058 uint16_t oldtag;
1061 * We're doing only synchronous I/O. Tflush is implemented
1062 * only because it's illegal to reply with a Rerror.
1065 /* oldtag[2] */
1066 if (len != sizeof(oldtag)) {
1067 log_warnx("Tflush with the wrong size: got %zu want %zu",
1068 len, sizeof(oldtag));
1069 client_send_listener(IMSG_CLOSE, NULL, 0);
1070 client_shutdown();
1071 return;
1074 np_flush(hdr->tag);
1077 static void
1078 twalk(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1080 struct stat sb;
1081 struct dir *dir;
1082 struct qid wqid[MAXWELEM] = {0};
1083 struct fid *f, *nf;
1084 uint32_t fid, newfid;
1085 uint16_t nwname;
1086 int fd, oldfd, no, nwqid = 0;
1087 char wnam[PATH_MAX];
1089 if (!NPREAD32("fid", &fid, &data, &len) ||
1090 !NPREAD32("newfid", &newfid, &data, &len) ||
1091 !NPREAD16("nwname", &nwname, &data, &len))
1092 goto err;
1094 if (nwname > MAXWELEM) {
1095 log_warnx("Twalk: more than %d path elements: %d",
1096 MAXWELEM, nwname);
1097 goto err;
1100 if ((f = fid_by_id(fid)) == NULL) {
1101 np_error(hdr->tag, "invalid fid");
1102 return;
1105 if (f->fd != -1) {
1106 np_error(hdr->tag, "fid already opened for I/O");
1107 return;
1110 if (fid == newfid)
1111 nf = f;
1112 else if ((nf = fid_by_id(newfid)) != NULL) {
1113 np_error(hdr->tag, "newfid already in use");
1114 return;
1115 } else
1116 nf = NULL;
1118 /* special case: fid duplication */
1119 if (nwname == 0) {
1121 * TODO: should we forbid fids duplication when fid ==
1122 * newfid?
1124 if (nf == NULL &&
1125 (nf = new_fid(f->dir, newfid, f->fname, &f->qid)) == NULL)
1126 fatal("new_fid duplication");
1128 np_walk(hdr->tag, 0, NULL);
1129 return;
1132 if (!(f->qid.type & QTDIR)) {
1133 np_error(hdr->tag, "fid doesn't represent a directory");
1134 return;
1137 oldfd = f->dir->fd;
1139 for (nwqid = 0; nwqid < nwname; nwqid++) {
1140 switch (NPREADSTR("wname", wnam, sizeof(wnam), &data, &len)) {
1141 case READSTRERR:
1142 goto err;
1143 case READSTRTRUNC:
1144 np_error(hdr->tag, "wname too long");
1145 return;
1148 if (*wnam == '\0' ||
1149 strchr(wnam, '/') != NULL ||
1150 !strcmp(wnam, ".")) {
1151 errno = EINVAL;
1152 goto cantopen;
1155 if ((fd = openat(oldfd, wnam, O_RDONLY|O_DIRECTORY)) == -1 &&
1156 errno != ENOTDIR)
1157 goto cantopen;
1159 if ((fd == -1 && fstatat(oldfd, wnam, &sb, 0) == -1) ||
1160 (fd != -1 && fstat(fd, &sb) == -1))
1161 goto cantopen;
1163 qid_update_from_sb(&wqid[nwqid], &sb);
1165 /* reached a file but we still have other components */
1166 if (fd == -1 && nwqid+1 < nwname)
1167 goto cantopen;
1169 /* reached the end and found a file */
1170 if (fd == -1 && nwqid+1 == nwname)
1171 continue;
1173 if (oldfd != f->dir->fd)
1174 close(oldfd);
1175 oldfd = fd;
1178 if (len != 0)
1179 goto err;
1182 * If fd is -1 we've reached a file, otherwise we've just
1183 * reached another directory. We must pay attention to what
1184 * file descriptor we use to create the dir, because if we've
1185 * reached a file and oldfd is f->dir->fd then we *must* share
1186 * the same dir (it was a walk of one path from a directory to a
1187 * file, otherwise fun is bound to happen as soon as the client
1188 * closes the fid for the directory but keeps the one for the
1189 * file.
1191 if (fd == -1 && oldfd == f->dir->fd)
1192 dir = f->dir;
1193 else if (fd == -1)
1194 dir = new_dir(oldfd);
1195 else
1196 dir = new_dir(fd);
1198 if (dir == NULL)
1199 fatal("new_dir");
1201 if (nf == NULL) {
1202 if ((nf = new_fid(dir, newfid, wnam, &wqid[nwqid-1])) == NULL)
1203 fatal("new fid");
1204 } else {
1205 /* update the dir */
1206 dir_decref(nf->dir);
1207 nf->dir = dir_incref(dir);
1210 np_walk(hdr->tag, nwqid, wqid);
1211 return;
1213 cantopen:
1214 if (oldfd != f->dir->fd)
1215 close(oldfd);
1216 no = errno;
1217 if (nwqid == 0)
1218 np_error(hdr->tag, strerror(no));
1219 else
1220 np_walk(hdr->tag, nwqid, wqid);
1221 return;
1223 err:
1224 client_send_listener(IMSG_CLOSE, NULL, 0);
1225 client_shutdown();
1228 static inline int
1229 npmode_to_unix(uint8_t mode, int *flags)
1231 switch (mode & 0x0F) {
1232 case KOREAD:
1233 *flags = O_RDONLY;
1234 break;
1235 case KOWRITE:
1236 *flags = O_WRONLY;
1237 break;
1238 case KORDWR:
1239 *flags = O_RDWR;
1240 break;
1241 case KOEXEC:
1242 log_warnx("tried to open something with KOEXEC");
1243 /* fallthrough */
1244 default:
1245 return -1;
1248 if (mode & KOTRUNC)
1249 *flags |= O_TRUNC;
1250 if (mode & KORCLOSE)
1251 *flags |= O_CLOEXEC;
1253 return 0;
1256 static void
1257 topen(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1259 struct stat sb;
1260 struct qid qid;
1261 struct fid *f;
1262 uint32_t fid;
1263 uint8_t mode;
1264 const char *path;
1266 /* fid[4] mode[1] */
1267 if (!NPREAD32("fid", &fid, &data, &len) ||
1268 !NPREAD8("mode", &mode, &data, &len) ||
1269 len != 0) {
1270 client_send_listener(IMSG_CLOSE, NULL, 0);
1271 client_shutdown();
1272 return;
1275 if ((f = fid_by_id(fid)) == NULL || f->fd != -1) {
1276 np_error(hdr->tag, "invalid fid");
1277 return;
1280 if (npmode_to_unix(mode, &f->iomode) == -1) {
1281 np_error(hdr->tag, "invalid mode");
1282 return;
1285 path = f->fname;
1286 if (f->qid.type & QTDIR)
1287 path = ".";
1289 if ((f->fd = openat(f->dir->fd, path, f->iomode)) == -1) {
1290 np_error(hdr->tag, strerror(errno));
1291 return;
1294 if (fstat(f->fd, &sb) == -1)
1295 fatal("fstat");
1297 if (S_ISDIR(sb.st_mode)) {
1298 if ((f->d = fdopendir(f->fd)) == NULL) {
1299 np_errno(hdr->tag);
1300 close(f->fd);
1301 f->fd = -1;
1302 return;
1305 if ((f->evb = evbuffer_new()) == NULL) {
1306 np_errno(hdr->tag);
1307 closedir(f->d);
1308 f->d = NULL;
1309 f->fd = -1;
1313 f->offset = 0;
1315 qid_update_from_sb(&qid, &sb);
1316 np_open(hdr->tag, &qid, sb.st_blksize);
1319 static void
1320 tcreate(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1322 struct stat sb;
1323 struct qid qid;
1324 struct fid *f;
1325 uint32_t fid, perm;
1326 uint8_t mode;
1327 char name[PATH_MAX];
1329 /* fid[4] name[s] perm[4] mode[1] */
1330 if (!NPREAD32("fid", &fid, &data, &len))
1331 goto err;
1332 switch (NPREADSTR("name", name, sizeof(name), &data, &len)) {
1333 case READSTRERR:
1334 goto err;
1335 case READSTRTRUNC:
1336 np_error(hdr->tag, "name too long");
1337 return;
1339 if (!NPREAD32("perm", &perm, &data, &len) ||
1340 !NPREAD8("mode", &mode, &data, &len) ||
1341 len != 0)
1342 goto err;
1344 if (!strcmp(name, ".") || !strcmp(name, "..") ||
1345 strchr(name, '/') != NULL) {
1346 np_error(hdr->tag, "invalid name");
1347 return;
1350 if ((f = fid_by_id(fid)) == NULL || f->fd != -1) {
1351 np_error(hdr->tag, "invalid fid");
1352 return;
1355 if (!(f->qid.type & QTDIR)) {
1356 np_error(hdr->tag, "fid doesn't identify a directory");
1357 return;
1360 if (npmode_to_unix(mode, &f->iomode) == -1) {
1361 np_error(hdr->tag, "invalid mode");
1362 return;
1365 if (f->iomode & O_RDONLY) {
1366 np_error(hdr->tag, "can't create a read-only file");
1367 return;
1370 /* TODO: parse the mode */
1372 if (perm & 0x80000000) {
1373 /* create a directory */
1374 f->fd = mkdirat(f->dir->fd, name, 0755);
1375 } else {
1376 /* create a file */
1377 f->fd = openat(f->dir->fd, name, f->iomode | O_CREAT | O_TRUNC,
1378 0644);
1381 if (f->fd == -1) {
1382 np_errno(hdr->tag);
1383 return;
1386 if (fstat(f->fd, &sb) == -1)
1387 fatal("fstat");
1389 if (S_ISDIR(sb.st_mode)) {
1390 if ((f->d = fdopendir(f->fd)) == NULL) {
1391 np_errno(hdr->tag);
1392 close(f->fd);
1393 f->fd = -1;
1394 return;
1397 if ((f->evb = evbuffer_new()) == NULL) {
1398 np_errno(hdr->tag);
1399 closedir(f->d);
1400 f->d = NULL;
1401 f->fd = -1;
1405 f->offset = 0;
1407 qid_update_from_sb(&qid, &sb);
1408 np_create(hdr->tag, &qid, sb.st_blksize);
1410 return;
1412 err:
1413 client_send_listener(IMSG_CLOSE, NULL, 0);
1414 client_shutdown();
1417 static inline int
1418 serialize_stat(const char *fname, struct stat *sb, struct evbuffer *evb)
1420 struct qid qid;
1421 const char *uid, *gid, *muid;
1422 size_t tot;
1423 uint32_t mode;
1424 uint16_t namlen, uidlen, gidlen, ulen;
1426 qid_update_from_sb(&qid, sb);
1428 /* TODO: fill these fields */
1429 uid = "";
1430 gid = "";
1431 muid = "";
1433 namlen = strlen(fname);
1434 uidlen = strlen(uid);
1435 gidlen = strlen(gid);
1436 ulen = strlen(muid);
1438 tot = NPSTATSIZ(namlen, uidlen, gidlen, ulen);
1439 if (tot > UINT16_MAX) {
1440 log_warnx("stat info for dir entry %s would overflow",
1441 fname);
1442 return -1;
1445 mode = sb->st_mode & 0xFFFF;
1446 if (qid.type & QTDIR)
1447 mode |= 0x80000000;
1449 np_write16(evb, tot); /* size[2] */
1450 np_write16(evb, sb->st_rdev); /* type[2] */
1451 np_write32(evb, sb->st_dev); /* dev[4] */
1452 np_qid(evb, &qid); /* qid[13] */
1453 np_write32(evb, mode); /* mode[4] */
1454 np_write32(evb, sb->st_atim.tv_sec); /* atime[4] */
1455 np_write32(evb, sb->st_mtim.tv_sec); /* mtime[4] */
1457 /* special case: directories have size 0 */
1458 if (qid.type & QTDIR)
1459 np_write64(evb, 0);
1460 else
1461 np_write64(evb, sb->st_size); /* length[8] */
1463 np_string(evb, namlen, fname); /* name[s] */
1464 np_string(evb, uidlen, uid); /* uid[s] */
1465 np_string(evb, gidlen, gid); /* gid[s] */
1466 np_string(evb, ulen, muid); /* muid[s] */
1468 return 0;
1471 static void
1472 tread(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1474 struct fid *f;
1475 ssize_t r;
1476 size_t howmuch;
1477 uint64_t off;
1478 uint32_t fid, count;
1479 char buf[2048];
1481 /* fid[4] offset[8] count[4] */
1482 if (!NPREAD32("fid", &fid, &data, &len) ||
1483 !NPREAD64("offset", &off, &data, &len) ||
1484 !NPREAD32("count", &count, &data, &len) ||
1485 len != 0) {
1486 client_send_listener(IMSG_CLOSE, NULL, 0);
1487 client_shutdown();
1488 return;
1491 if ((f = fid_by_id(fid)) == NULL || f->fd == -1) {
1492 np_error(hdr->tag, "invalid fid");
1493 return;
1496 if (TYPE_OVERFLOW(off_t, off)) {
1497 log_warnx("unexpected off_t size");
1498 np_error(hdr->tag, "invalid offset");
1499 return;
1502 if (f->d == NULL) {
1503 /* read a file */
1504 howmuch = MIN(sizeof(buf), count);
1505 r = pread(f->fd, buf, howmuch, (off_t)off);
1506 if (r == -1)
1507 np_errno(hdr->tag);
1508 else
1509 np_read(hdr->tag, r, buf);
1510 } else {
1511 if (off == 0 && f->offset != 0) {
1512 rewinddir(f->d);
1513 f->offset = 0;
1514 evbuffer_drain(f->evb, EVBUFFER_LENGTH(f->evb));
1517 if (off != f->offset) {
1518 np_error(hdr->tag, "can't seek in directories");
1519 return;
1522 while (EVBUFFER_LENGTH(f->evb) < count) {
1523 struct dirent *d;
1524 struct stat sb;
1526 if ((d = readdir(f->d)) == NULL)
1527 break;
1528 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
1529 continue;
1530 if (fstatat(f->fd, d->d_name, &sb, 0) == -1) {
1531 warn("fstatat");
1532 continue;
1534 serialize_stat(d->d_name, &sb, f->evb);
1537 count = MIN(count, EVBUFFER_LENGTH(f->evb));
1538 np_read(hdr->tag, count, EVBUFFER_DATA(f->evb));
1539 evbuffer_drain(f->evb, count);
1541 f->offset += count;
1545 static void
1546 twrite(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1548 struct fid *f;
1549 ssize_t r;
1550 uint64_t off;
1551 uint32_t fid, count;
1553 /* fid[4] offset[8] count[4] data[count] */
1554 if (!NPREAD32("fid", &fid, &data, &len) ||
1555 !NPREAD64("off", &off, &data, &len) ||
1556 !NPREAD32("count", &count, &data, &len) ||
1557 len != count) {
1558 client_send_listener(IMSG_CLOSE, NULL, 0);
1559 client_shutdown();
1560 return;
1563 if ((f = fid_by_id(fid)) == NULL || f->fd == -1) {
1564 np_error(hdr->tag, "invalid fid");
1565 return;
1568 if (!(f->iomode & O_WRONLY) &&
1569 !(f->iomode & O_RDWR)) {
1570 np_error(hdr->tag, "fid not opened for writing");
1571 return;
1574 if (TYPE_OVERFLOW(off_t, off)) {
1575 log_warnx("unexpected off_t size");
1576 np_error(hdr->tag, "invalid offset");
1577 return;
1580 if ((r = pwrite(f->fd, data, len, off)) == -1)
1581 np_errno(hdr->tag);
1582 else
1583 np_write(hdr->tag, r);
1586 static void
1587 tstat(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1589 struct evbuffer *evb;
1590 struct stat sb;
1591 struct fid *f;
1592 int r;
1593 uint32_t fid;
1595 /* fid[4] */
1596 if (!NPREAD32("fid", &fid, &data, &len) ||
1597 len != 0) {
1598 client_send_listener(IMSG_CLOSE, NULL, 0);
1599 client_shutdown();
1600 return;
1604 * plan9' stat(9P) is not clear on whether the stat is allowed
1605 * on opened fids or not. We're allowing stat regardless of the
1606 * status of the fid.
1609 if ((f = fid_by_id(fid)) == NULL) {
1610 np_error(hdr->tag, "invalid fid");
1611 return;
1614 if ((evb = evbuffer_new()) == NULL)
1615 fatal("evbuffer_new");
1617 if (f->fd != -1)
1618 r = fstat(f->fd, &sb);
1619 else if (f->qid.type & QTDIR)
1620 r = fstat(f->dir->fd, &sb);
1621 else
1622 r = fstatat(f->dir->fd, f->fname, &sb, 0);
1624 if (r == -1) {
1625 np_errno(hdr->tag);
1626 evbuffer_free(evb);
1627 return;
1630 if (serialize_stat(f->fname, &sb, evb) == -1)
1631 np_error(hdr->tag, "stat would overflow");
1632 else
1633 np_stat(hdr->tag, EVBUFFER_LENGTH(evb), EVBUFFER_DATA(evb));
1634 evbuffer_free(evb);
1637 static void
1638 twstat(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1640 struct timespec times[2];
1641 struct np_stat st;
1642 struct fid *f;
1643 int r;
1644 uint32_t fid;
1645 char name[PATH_MAX];
1647 /* fid[4] stat[n] */
1648 if (!NPREAD32("fid", &fid, &data, &len))
1649 goto err;
1651 switch (NPREADST("stat", &st, name, sizeof(name), &data, &len)) {
1652 case READSTRERR:
1653 goto err;
1654 case READSTRTRUNC:
1655 log_warnx("wstat new name would overflow");
1656 np_error(hdr->tag, "new name too long");
1657 return;
1661 * We skip the reading of some fields voluntarily because we
1662 * don't support chown, so len will always be > 0!
1664 #ifdef notyet
1665 if (len != 0)
1666 goto err;
1667 #endif
1669 if ((f = fid_by_id(fid)) == NULL) {
1670 np_error(hdr->tag, "invalid fid");
1671 return;
1675 * 9P wants these edits to be done in an atomic fashion,
1676 * something that I don't think it's possible on UNIX without
1677 * some special kernel help. Changing atime or mtime,
1678 * permissions, or rename the file are different syscalls.
1680 * Also, silently ignore stuff we can't/don't want to modify.
1683 /* change the permissions */
1684 if (st.mode != (uint32_t)-1) {
1685 mode_t m = st.mode & 0x7F; /* silently truncate higer bits */
1686 if (f->fd != -1)
1687 r = fchmod(f->fd, m);
1688 else
1689 r = fchmodat(f->dir->fd, f->fname, m, 0);
1691 if (r == -1) {
1692 np_errno(hdr->tag);
1693 return;
1697 /* change the atime/mtime of the fid, opened or not */
1698 if (st.atime != (uint32_t)-1 || st.mtime != (uint32_t)-1) {
1699 times[0].tv_nsec = UTIME_OMIT;
1700 times[1].tv_nsec = UTIME_OMIT;
1702 if (st.atime != (uint32_t)-1) {
1703 times[0].tv_sec = st.atime;
1704 times[0].tv_nsec = 0;
1706 if (st.mtime != (uint32_t)-1) {
1707 times[1].tv_sec = st.mtime;
1708 times[1].tv_nsec = 0;
1711 if (f->fd != -1)
1712 r = futimens(f->fd, times);
1713 else
1714 r = utimensat(f->dir->fd, f->fname, times, 0);
1716 if (r == -1) {
1717 np_errno(hdr->tag);
1718 return;
1722 /* truncate */
1723 if (st.length != (uint64_t)-1) {
1724 if (f->fd == -1) {
1725 np_error(hdr->tag, "can't truncate a non-opened fid");
1726 return;
1729 if (f->qid.type & QTDIR && st.length != 0) {
1730 np_error(hdr->tag, "can't truncate directories");
1731 return;
1734 if (TYPE_OVERFLOW(off_t, st.length)) {
1735 log_warnx("truncate request overflows off_t: %"PRIu64,
1736 st.length);
1737 np_error(hdr->tag, "length overflows");
1738 return;
1741 if (f->qid.type == 0 &&
1742 ftruncate(f->fd, st.length) == -1) {
1743 np_errno(hdr->tag);
1744 return;
1748 /* rename (change the name entry) */
1749 if (*st.name != '\0') {
1750 struct stat sb;
1751 const char *newname;
1754 * XXX: 9P requires that we disallow changing the name
1755 * to that of an existing file. We can't do that
1756 * atomically (rename is happy about stealing names)
1757 * so this is just a best effort.
1759 if (fstatat(f->dir->fd, st.name, &sb, 0) == -1 &&
1760 errno != ENOENT) {
1761 np_error(hdr->tag, "target file exists");
1762 return;
1765 r = renameat(f->dir->fd, f->fname, f->dir->fd, st.name);
1766 if (r == -1) {
1767 np_errno(hdr->tag);
1768 return;
1771 /* fix the fid so it points to the new file */
1773 if ((newname = strchr(st.name, '/')) != NULL)
1774 newname++; /* skip / */
1775 else
1776 newname = st.name;
1777 strlcpy(f->fname, newname, sizeof(f->fname));
1779 if (strchr(st.name, '/') != NULL) {
1780 struct dir *dir;
1781 char *dname;
1782 int fd;
1784 dname = dirname(st.name);
1785 fd = openat(f->dir->fd, dname, O_RDONLY|O_DIRECTORY);
1786 if (fd == -1) {
1787 np_errno(hdr->tag);
1788 free_fid(f);
1789 return;
1792 if ((dir = new_dir(fd)) == NULL) {
1793 np_errno(hdr->tag);
1794 free_fid(f);
1795 return;
1798 dir_decref(f->dir);
1799 f->dir = dir_incref(dir);
1803 np_wstat(hdr->tag);
1804 return;
1806 err:
1807 client_send_listener(IMSG_CLOSE, NULL, 0);
1808 client_shutdown();
1811 static void
1812 tremove(struct np_msg_header *hdr, const uint8_t *data, size_t len)
1814 struct fid *f;
1815 uint32_t fid;
1816 int r;
1817 char dirpath[PATH_MAX + 3];
1819 /* fid[4] */
1820 if (!NPREAD32("fid", &fid, &data, &len) ||
1821 len != 0) {
1822 client_send_listener(IMSG_CLOSE, NULL, 0);
1823 client_shutdown();
1824 return;
1827 if ((f = fid_by_id(fid)) == NULL) {
1828 np_error(hdr->tag, "invalid fid");
1829 return;
1832 if (f->qid.type & QTDIR) { /* directory */
1833 strlcpy(dirpath, "../", sizeof(dirpath));
1834 strlcat(dirpath, f->fname, sizeof(dirpath));
1835 r = unlinkat(f->dir->fd, dirpath, AT_REMOVEDIR);
1836 } else /* file */
1837 r = unlinkat(f->dir->fd, f->fname, 0);
1839 if (r == -1)
1840 np_errno(hdr->tag);
1841 else
1842 np_remove(hdr->tag);
1844 free_fid(f);
1847 static void
1848 handle_message(struct imsg *imsg, size_t len)
1850 struct msg {
1851 uint8_t type;
1852 void (*fn)(struct np_msg_header *, const uint8_t *, size_t);
1853 } msgs[] = {
1854 {Tversion, tversion},
1855 {Tattach, tattach},
1856 {Tclunk, tclunk},
1857 {Tflush, tflush},
1858 {Twalk, twalk},
1859 {Topen, topen},
1860 {Tcreate, tcreate},
1861 {Tread, tread},
1862 {Twrite, twrite},
1863 {Tstat, tstat},
1864 {Twstat, twstat},
1865 {Tremove, tremove},
1867 struct np_msg_header hdr;
1868 size_t i;
1869 uint8_t *data;
1871 #if DEBUG_PACKETS
1872 hexdump("incoming packet", imsg->data, len);
1873 #endif
1875 parse_message(imsg->data, len, &hdr, &data);
1876 len -= HEADERSIZE;
1878 log_debug("got request: len=%d type=%d[%s] tag=%d",
1879 hdr.len, hdr.type, pp_msg_type(hdr.type), hdr.tag);
1881 if (!handshaked && hdr.type != Tversion) {
1882 client_send_listener(IMSG_CLOSE, NULL, 0);
1883 client_shutdown();
1884 return;
1887 for (i = 0; i < sizeof(msgs)/sizeof(msgs[0]); ++i) {
1888 if (msgs[i].type != hdr.type)
1889 continue;
1891 msgs[i].fn(&hdr, data, len);
1892 return;
1895 np_error(hdr.tag, "Not supported.");