op public repos

Blob

Date:: Sun Jan 9 15:33:55 2022 UTC
Message:: restructure project and switch build system use by default the OpenBSD mk infrastructure to build and test all the kamid components.
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2021 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  */
16 
17 #include <sys/types.h>
18 #include <sys/socket.h>
19 
20 #include <netdb.h>
21 
22 #include <assert.h>
23 #include <endian.h>
24 #include <err.h>
25 #include <errno.h>
26 #include <event.h>
27 #include <fcntl.h>
28 #include <inttypes.h>
29 #include <signal.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <syslog.h>
34 #include <tls.h>
35 #include <unistd.h>
36 #include <vis.h>
37 
38 #include "9pclib.h"
39 #include "kami.h"
40 #include "log.h"
41 #include "utils.h"
42 
43 #define DEBUG_PACKETS 0
44 
45 #define PROMPT "=% "
46 
47 /* flags */
48 int			 verbose;
49 int			 tls;
50 const char		*keypath;
51 const char		*crtpath;
52 const char		*host;
53 const char		*port;
54 
55 /* state */
56 struct tls_config	*tlsconf;
57 struct tls		*ctx;
58 struct bufferevent	*bev, *inbev;
59 
60 static void __dead	 usage(int);
61 
62 static void		 sig_handler(int, short, void *);
63 
64 static int		 openconn(void);
65 static void		 mark_nonblock(int);
66 
67 static void		 tls_readcb(int, short, void *);
68 static void		 tls_writecb(int, short, void *);
69 
70 static void		 client_read(struct bufferevent *, void *);
71 static void		 client_write(struct bufferevent *, void *);
72 static void		 client_error(struct bufferevent *, short, void *);
73 
74 static void		 repl_read(struct bufferevent *, void *);
75 static void		 repl_error(struct bufferevent *, short, void *);
76 
77 static void		 excmd_version(const char **, int);
78 static void		 excmd_attach(const char **, int);
79 static void		 excmd_clunk(const char **, int);
80 static void		 excmd_flush(const char **, int);
81 static void		 excmd_walk(const char ** , int);
82 static void		 excmd_open(const char ** , int);
83 static void		 excmd_create(const char ** , int);
84 static void		 excmd_read(const char ** , int);
85 static void		 excmd_write(const char **, int);
86 static void		 excmd(const char **, int);
87 
88 static void		 pp_qid(const uint8_t *, uint32_t);
89 static void		 pp_msg(uint32_t, uint8_t, uint16_t, const uint8_t *);
90 static void		 handle_9p(const uint8_t *, size_t);
91 static void		 clr(void);
92 static void		 prompt(void);
93 
94 static void __dead
95 usage(int ret)
96 {
97 	fprintf(stderr,
98 	    "usage: %s [-chv] [-C crt] [-K key] [-H host] [-P port]\n",
99 	    getprogname());
100 	fprintf(stderr, "kamid suite version " KAMID_VERSION "\n");
101 	exit(ret);
102 }
103 
104 static void
105 sig_handler(int sig, short event, void *d)
106 {
107 	/*
108 	 * Normal signal handler rules don't apply because libevent
109 	 * decouples for us.
110 	 */
111 
112 	switch (sig) {
113 	case SIGINT:
114 	case SIGTERM:
115 		clr();
116 		log_warnx("Shutting down...");
117 		event_loopbreak();
118 		return;
119 	default:
120 		fatalx("unexpected signal %d", sig);
121 	}
122 }
123 
124 static int
125 openconn(void)
126 {
127 	struct addrinfo hints, *res, *res0;
128 	int error;
129 	int save_errno;
130 	int s;
131 	const char *cause = NULL;
132 
133 	memset(&hints, 0, sizeof(hints));
134 	hints.ai_family = AF_UNSPEC;
135 	hints.ai_socktype = SOCK_STREAM;
136 	if ((error = getaddrinfo(host, port, &hints, &res0))) {
137 		warnx("%s", gai_strerror(error));
138 		return -1;
139 	}
140 
141 	s = -1;
142 	for (res = res0; res; res = res->ai_next) {
143 		s = socket(res->ai_family, res->ai_socktype,
144 		    res->ai_protocol);
145 		if (s == -1) {
146 			cause = "socket";
147 			continue;
148 		}
149 
150 		if (connect(s, res->ai_addr, res->ai_addrlen) == -1) {
151 			cause = "connect";
152 			save_errno = errno;
153 			close(s);
154 			errno = save_errno;
155 			s = -1;
156 			continue;
157 		}
158 
159 		break;
160 	}
161 
162 	freeaddrinfo(res0);
163 
164 	if (s == -1)
165 		warn("%s", cause);
166 
167 	return s;
168 }
169 
170 static void
171 mark_nonblock(int fd)
172 {
173 	int flags;
174 
175 	if ((flags = fcntl(fd, F_GETFL)) == -1)
176 		fatal("fcntl(F_GETFL)");
177 	if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
178 		fatal("fcntl(F_SETFL)");
179 }
180 
181 static void
182 tls_readcb(int fd, short event, void *d)
183 {
184 	struct bufferevent	*bufev = d;
185 	char			 buf[IBUF_READ_SIZE];
186 	int			 what = EVBUFFER_READ;
187 	int			 howmuch = IBUF_READ_SIZE;
188 	ssize_t			 ret;
189 	size_t			 len;
190 
191 	if (event == EV_TIMEOUT) {
192 		what |= EVBUFFER_TIMEOUT;
193 		goto err;
194 	}
195 
196 	if (bufev->wm_read.high != 0)
197 		howmuch = MIN(sizeof(buf), bufev->wm_read.high);
198 
199 	switch (ret = tls_read(ctx, buf, howmuch)) {
200 	case TLS_WANT_POLLIN:
201 	case TLS_WANT_POLLOUT:
202 		goto retry;
203 	case -1:
204 		what |= EVBUFFER_ERROR;
205 		goto err;
206 	}
207 	len = ret;
208 
209 	if (len == 0) {
210 		what |= EVBUFFER_EOF;
211 		goto err;
212 	}
213 
214 	if (evbuffer_add(bufev->input, buf, len) == -1) {
215 		what |= EVBUFFER_ERROR;
216 		goto err;
217 	}
218 
219 	event_add(&bufev->ev_read, NULL);
220 
221 	len = EVBUFFER_LENGTH(bufev->input);
222 	if (bufev->wm_read.low != 0 && len < bufev->wm_read.low)
223 		return;
224 	if (bufev->readcb != NULL)
225 		(*bufev->readcb)(bufev, bufev->cbarg);
226 	return;
227 
228 retry:
229 	event_add(&bufev->ev_read, NULL);
230 	return;
231 
232 err:
233 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
234 }
235 
236 static void
237 tls_writecb(int fd, short event, void *d)
238 {
239 	struct bufferevent	*bufev = d;
240 	ssize_t			 ret;
241 	size_t			 len;
242 	short			 what = EVBUFFER_WRITE;
243 	void			*data;
244 
245 	if (event == EV_TIMEOUT) {
246 		what |= EVBUFFER_TIMEOUT;
247 		goto err;
248 	}
249 
250 	len = EVBUFFER_LENGTH(bufev->output);
251 	if (len != 0) {
252 		data = EVBUFFER_DATA(bufev->output);
253 
254 #if DEBUG_PACKETS
255 		hexdump("outgoing msg", data, len);
256 #endif
257 
258 		switch (ret = tls_write(ctx, data, len)) {
259 		case TLS_WANT_POLLIN:
260 		case TLS_WANT_POLLOUT:
261 			goto retry;
262 		case -1:
263 			what |= EVBUFFER_ERROR;
264 			goto err;
265 		}
266 		evbuffer_drain(bufev->output, ret);
267 	}
268 
269 	if (EVBUFFER_LENGTH(bufev->output) != 0)
270 		event_add(&bufev->ev_write, NULL);
271 
272 	if (bufev->writecb != NULL &&
273 	    EVBUFFER_LENGTH(bufev->output) <= bufev->wm_write.low)
274 		(*bufev->writecb)(bufev, bufev->cbarg);
275 	return;
276 
277 retry:
278 	event_add(&bufev->ev_write, NULL);
279 	return;
280 err:
281 	(*bufev->errorcb)(bufev, what, bufev->cbarg);
282 }
283 
284 static void
285 client_read(struct bufferevent *bev, void *d)
286 {
287 	struct evbuffer	*src = EVBUFFER_INPUT(bev);
288 	uint32_t	 len;
289 	uint8_t		*data;
290 
291 	for (;;) {
292 		if (EVBUFFER_LENGTH(src) < sizeof(len))
293 			return;
294 
295 		data = EVBUFFER_DATA(src);
296 
297 		memcpy(&len, data, sizeof(len));
298 		len = le32toh(len);
299 
300 		if (len < HEADERSIZE)
301 			fatal("incoming message is too small! (%d bytes)",
302 			    len);
303 
304 		if (len > EVBUFFER_LENGTH(src))
305 			return;
306 
307 #if DEBUG_PACKETS
308 		hexdump("incoming msg", data, len);
309 #endif
310 
311 		handle_9p(data, len);
312 		evbuffer_drain(src, len);
313 	}
314 }
315 
316 static void
317 client_write(struct bufferevent *bev, void *data)
318 {
319 	return; /* nothing to do */
320 }
321 
322 static void
323 client_error(struct bufferevent *bev, short err, void *data)
324 {
325 	if (err & EVBUFFER_ERROR)
326 		fatal("buffer event error");
327 
328 	if (err & EVBUFFER_EOF) {
329 		clr();
330 		log_info("EOF");
331 		event_loopbreak();
332 		return;
333 	}
334 
335 	clr();
336 	log_warnx("unknown event error");
337 	event_loopbreak();
338 }
339 
340 static void
341 repl_read(struct bufferevent *bev, void *d)
342 {
343 	size_t		 len;
344 	int		 argc;
345 	const char	*argv[10], **ap;
346 	char		*line;
347 
348 	line = evbuffer_readln(bev->input, &len, EVBUFFER_EOL_LF);
349 	if (line == NULL)
350 		return;
351 
352 	for (argc = 0, ap = argv; ap < &argv[9] &&
353 	    (*ap = strsep(&line, " \t")) != NULL;) {
354 		if (**ap != '\0')
355 			ap++, argc++;
356 	}
357 
358 	clr();
359 	excmd(argv, argc);
360 	prompt();
361 
362 	free(line);
363 }
364 
365 static void
366 repl_error(struct bufferevent *bev, short error, void *d)
367 {
368 	fatalx("an error occurred");
369 }
370 
371 static inline void
372 do_send(void)
373 {
374 	bufferevent_write_buffer(bev, evb);
375 }
376 
377 /* version [version-str] */
378 static void
379 excmd_version(const char **argv, int argc)
380 {
381 	const char	*s;
382 
383 	s = VERSION9P;
384 	if (argc == 2)
385 		s = argv[1];
386 
387 	tversion(s, MSIZE9P);
388 	do_send();
389 }
390 
391 /* attach fid uname aname */
392 static void
393 excmd_attach(const char **argv, int argc)
394 {
395 	uint32_t	 fid;
396 	const char	*errstr;
397 
398 	if (argc != 4)
399 		goto usage;
400 
401         fid = strtonum(argv[1], 0, UINT32_MAX, &errstr);
402 	if (errstr != NULL) {
403 		log_warnx("fid is %s: %s", errstr, argv[1]);
404 		return;
405 	}
406 
407 	tattach(fid, NOFID, argv[2], argv[3]);
408 	do_send();
409 	return;
410 
411 usage:
412 	log_warnx("usage: attach fid uname aname");
413 }
414 
415 /* clunk fid */
416 static void
417 excmd_clunk(const char **argv, int argc)
418 {
419 	uint32_t	 fid;
420 	const char	*errstr;
421 
422 	if (argc != 2)
423 		goto usage;
424 
425 	fid = strtonum(argv[1], 0, UINT32_MAX, &errstr);
426 	if (errstr != NULL) {
427 		log_warnx("fid is %s: %s", errstr, argv[1]);
428 		return;
429 	}
430 
431 	tclunk(fid);
432 	do_send();
433 	return;
434 
435 usage:
436 	log_warnx("usage: clunk fid");
437 }
438 
439 /* flush oldtag */
440 static void
441 excmd_flush(const char **argv, int argc)
442 {
443 	uint16_t	 oldtag;
444 	const char	*errstr;
445 
446 	if (argc != 2)
447 		goto usage;
448 
449 	oldtag = strtonum(argv[1], 0, UINT16_MAX, &errstr);
450 	if (errstr != NULL) {
451 		log_warnx("oldtag is %s: %s", errstr, argv[1]);
452 		return;
453 	}
454 
455 	tflush(oldtag);
456 	do_send();
457 	return;
458 
459 usage:
460 	log_warnx("usage: flush oldtag");
461 }
462 
463 /* walk fid newfid wnames... */
464 static void
465 excmd_walk(const char **argv, int argc)
466 {
467 	uint32_t	 fid, newfid;
468 	const char	*errstr;
469 
470 	if (argc < 3)
471 		goto usage;
472 
473 	fid = strtonum(argv[1], 0, UINT32_MAX, &errstr);
474 	if (errstr != NULL) {
475 		log_warnx("fid is %s: %s", errstr, argv[1]);
476 		return;
477 	}
478 
479 	newfid = strtonum(argv[2], 0, UINT32_MAX, &errstr);
480 	if (errstr != NULL) {
481 		log_warnx("newfid is %s: %s", errstr, argv[1]);
482 		return;
483 	}
484 
485 	twalk(fid, newfid, argv + 3, argc - 3);
486 	do_send();
487 	return;
488 
489 usage:
490 	log_warnx("usage: walk fid newfid wnames...");
491 }
492 
493 /* open fid mode [flag] */
494 static void
495 excmd_open(const char **argv, int argc)
496 {
497 	const char	*errstr;
498 	uint32_t	 fid;
499 	uint8_t		 mode = 0;
500 
501 	if (argc != 3 && argc != 4)
502 		goto usage;
503 
504 	fid = strtonum(argv[1], 0, UINT32_MAX, &errstr);
505 	if (errstr != NULL) {
506 		log_warnx("fid is %s: %s", errstr, argv[1]);
507 		return;
508 	}
509 
510 	/* parse mode */
511 	if (!strcmp("read", argv[2]) || !strcmp("r", argv[2]))
512 		mode = KOREAD;
513 	else if (!strcmp("write", argv[2]) || !strcmp("w", argv[2]))
514 		mode = KOWRITE;
515 	else if (!strcmp("readwrite", argv[2]) || !strcmp("rw", argv[2]))
516 		mode = KORDWR;
517 	else {
518 		log_warnx("invalid mode %s", argv[2]);
519 		return;
520 	}
521 
522 	/* parse flag */
523 	if (argv[3] != NULL) {
524 		if (!strcmp("trunc", argv[3]))
525 			mode |= KOTRUNC;
526 		else if (!strcmp("rclose", argv[3]))
527 			mode |= KORCLOSE;
528 		else {
529 			log_warnx("invalid flag %s", argv[3]);
530 			return;
531 		}
532 	}
533 
534 	topen(fid, mode);
535 	do_send();
536 	return;
537 
538 usage:
539 	log_warnx("usage: open fid mode [flag]");
540 }
541 
542 /* create fid path perm mode */
543 static void
544 excmd_create(const char **argv, int argc)
545 {
546 	const char	*errstr;
547 	uint32_t	 fid;
548 	uint8_t		 mode = 0;
549 
550 	if (argc != 5)
551 		goto usage;
552 
553 	fid = strtonum(argv[1], 0, UINT32_MAX, &errstr);
554 	if (errstr != NULL) {
555 		log_warnx("fid is %s: %s", errstr, argv[1]);
556 		return;
557 	}
558 
559 	/* parse mode */
560 	if (!strcmp("write", argv[4]) || !strcmp("w", argv[4]))
561 		mode = KOWRITE;
562 	else if (!strcmp("readwrite", argv[4]) || !strcmp("rw", argv[4]))
563 		mode = KORDWR;
564 	else {	    
565 		log_warnx("invalid mode %s for create", argv[4]);
566 		return;
567 	}
568 
569 	tcreate(fid, argv[2], 0, mode);
570 	do_send();
571 	return;
572 
573 usage:
574 	log_warnx("usage: create fid path perm mode ; perm is unused");
575 }
576 
577 
578 /* read fid offset count */
579 static void
580 excmd_read(const char **argv, int argc)
581 {
582 	uint64_t	 off;
583 	uint32_t	 fid, count;
584 	const char	*errstr;
585 
586 	if (argc != 4)
587 		goto usage;
588 
589 	fid = strtonum(argv[1], 0, UINT32_MAX, &errstr);
590 	if (errstr != NULL) {
591 		log_warnx("fid is %s: %s", errstr, argv[1]);
592 		return;
593 	}
594 
595 	/* should really be UNT64_MAX but it fails... */
596 	off = strtonum(argv[2], -1, UINT32_MAX, &errstr);
597 	if (errstr != NULL) {
598 		log_warnx("offset is %s: %s", errstr, argv[2]);
599 		return;
600 	}
601 
602 	count = strtonum(argv[3], 0, UINT32_MAX, &errstr);
603 	if (errstr != NULL) {
604 		log_warnx("count is %s: %s", errstr, argv[3]);
605 		return;
606 	}
607 
608 	tread(fid, off, count);
609 	do_send();
610 	return;
611 
612 usage:
613 	log_warnx("usage: read fid offset count");
614 }
615 
616 /* write fid offset content */
617 static void
618 excmd_write(const char **argv, int argc)
619 {
620 	uint64_t	 off;
621 	uint32_t	 fid, count;
622 	const char	*errstr;
623 
624 	if (argc != 4)
625 		goto usage;
626 
627 	fid = strtonum(argv[1], 0, UINT32_MAX, &errstr);
628 	if (errstr != NULL) {
629 		log_warnx("fid is %s: %s", errstr, argv[1]);
630 		return;
631 	}
632 
633 	/* should really be UINT64_MAX but... */
634 	off = strtonum(argv[2], 0, UINT32_MAX, &errstr);
635 	if (errstr != NULL) {
636 		log_warnx("offset is %s: %s", errstr, argv[2]);
637 		return;
638 	}
639 
640 	count = strlen(argv[3]);
641 	twrite(fid, off, argv[3], count);
642 	do_send();
643 	return;
644 
645 usage:
646 	log_warnx("usage: write fid offset content");
647 }
648 
649 /* remove fid */
650 static void
651 excmd_remove(const char **argv, int argc)
652 {
653 	const char	*errstr;
654 	uint32_t	 fid;
655 
656 	if (argc != 2)
657 		goto usage;
658 
659 	fid = strtonum(argv[1], 0, UINT32_MAX, &errstr);
660 	if (errstr != NULL) {
661 		log_warnx("fid is %s: %s", errstr, argv[1]);
662 		return;
663 	}
664 
665 	tremove(fid);
666 	do_send();
667 	return;
668 
669 usage:
670 	log_warnx("usage: remove fid");
671 }
672 
673 static void
674 excmd(const char **argv, int argc)
675 {
676 	struct cmd {
677 		const char	*name;
678 		void		(*fn)(const char **, int);
679 	} cmds[] = {
680 		{"version",	excmd_version},
681 		{"attach",	excmd_attach},
682 		{"clunk",	excmd_clunk},
683 		{"flush",	excmd_flush},
684 		{"walk",	excmd_walk},
685 		{"open",	excmd_open},
686 		{"create",	excmd_create},
687 		{"read",	excmd_read},
688 		{"write",	excmd_write},
689 		/* TODO: stat */
690 		{"remove",	excmd_remove},
691 	};
692 	size_t i;
693 
694 	if (argc == 0)
695 		return;
696 
697 	for (i = 0; i < sizeof(cmds)/sizeof(cmds[0]); ++i) {
698 		if (!strcmp(cmds[i].name, argv[0])) {
699 			cmds[i].fn(argv, argc);
700 			return;
701 		}
702 	}
703 
704 	log_warnx("Unknown command %s", *argv);
705 }
706 
707 static void
708 pp_qid(const uint8_t *d, uint32_t len)
709 {
710 	uint64_t	path;
711 	uint32_t	vers;
712 	uint8_t		type;
713 
714 	if (len < 13) {
715 		printf("invalid");
716 		return;
717 	}
718 
719 	type = *d++;
720 
721 	memcpy(&vers, d, sizeof(vers));
722 	d += sizeof(vers);
723 	vers = le64toh(vers);
724 
725 	memcpy(&path, d, sizeof(path));
726 	d += sizeof(path);
727 	path = le64toh(path);
728 
729 	printf("qid{path=%"PRIu64" version=%"PRIu32" type=0x%x\"%s\"}",
730 	    path, vers, type, pp_qid_type(type));
731 }
732 
733 static void
734 pp_msg(uint32_t len, uint8_t type, uint16_t tag, const uint8_t *d)
735 {
736 	uint32_t	 msize, iounit, count;
737 	uint16_t	 slen;
738 	char		*v;
739 
740 	printf("len=%"PRIu32" type=%d[%s] tag=0x%x[%d] ", len,
741 	    type, pp_msg_type(type), tag, tag);
742 
743 	len -= HEADERSIZE;
744 
745 	switch (type) {
746 	case Rversion:
747 		if (len < 6) {
748 			printf("invalid: not enough space for msize "
749 			    "and version provided.");
750 			break;
751 		}
752 
753 		memcpy(&msize, d, sizeof(msize));
754 		d += sizeof(msize);
755 		len -= sizeof(msize);
756 		msize = le32toh(msize);
757 
758 		memcpy(&slen, d, sizeof(slen));
759 		d += sizeof(slen);
760 		len -= sizeof(slen);
761 		slen = le16toh(slen);
762 
763 		if (len != slen) {
764 			printf("invalid: version string length doesn't "
765 			    "match.  Got %d; want %d", slen, len);
766 			break;
767 		}
768 
769 		printf("msize=%"PRIu32" version[%"PRIu16"]=\"",
770 		    msize, slen);
771 		fwrite(d, 1, slen, stdout);
772 		printf("\"");
773 
774 		break;
775 
776 	case Rattach:
777 		pp_qid(d, len);
778 		break;
779 
780 	case Rclunk:
781 	case Rflush:
782 	case Rremove:
783 		if (len != 0)
784 			printf("invalid %s: %"PRIu32" extra bytes", 
785 			    pp_msg_type(type), len);
786 		break;
787 
788 	case Rwalk:
789 		if (len < 2) {
790 			printf("invaild Rwalk: less than two bytes (%d)",
791 			    (int)len);
792 			break;
793 		}
794 
795 		memcpy(&slen, d, sizeof(slen));
796 		d += sizeof(slen);
797 		len -= sizeof(slen);
798 		slen = le16toh(slen);
799 
800 		if (len != QIDSIZE * slen) {
801 			printf("invalid Rwalk: wanted %d bytes for %d qids "
802 			    "but got %"PRIu32" bytes instead",
803 			    QIDSIZE*slen, slen, len);
804 			break;
805 		}
806 
807 		printf("nwqid=%"PRIu16, slen);
808 
809 		for (; slen != 0; slen--) {
810 			printf(" ");
811 			pp_qid(d, len);
812 			d += QIDSIZE;
813 			len -= QIDSIZE;
814 		}
815 
816 		break;
817 
818 	case Ropen:
819 	case Rcreate:
820 		if (len != QIDSIZE + 4) {
821 			printf("invalid %s: expected %d bytes; "
822 			    "got %u\n", pp_msg_type(type), QIDSIZE + 4, len);
823 			break;
824 		}
825 
826 		pp_qid(d, len);
827 		d += QIDSIZE;
828 		len -= QIDSIZE;
829 
830 		memcpy(&iounit, d, sizeof(iounit));
831 		d += sizeof(iounit);
832 		len -= sizeof(iounit);
833 		iounit = le32toh(iounit);
834 		printf(" iounit=%"PRIu32, iounit);
835 		break;
836 
837 	case Rread:
838 		if (len < sizeof(count)) {
839 			printf("invalid Rread: expected %zu bytes at least; "
840 			    "got %u\n", sizeof(count), len);
841 			break;
842 		}
843 
844 		memcpy(&count, d, sizeof(count));
845 		d += sizeof(count);
846 		len -= sizeof(count);
847 		count = le32toh(count);
848 
849 		if (len != count) {
850 			printf("invalid Rread: expected %d data bytes; "
851 			    "got %u\n", count, len);
852 			break;
853 		}
854 
855 		/* allocates three extra bytes, oh well... */
856 		if ((v = calloc(count + 1, 4)) == NULL)
857 			fatal("calloc");
858 		strvisx(v, d, count, VIS_SAFE | VIS_TAB | VIS_NL | VIS_CSTYLE);
859 		printf("data=%s", v);
860 		free(v);
861 
862 		break;
863 
864 	case Rwrite:
865 		if (len != sizeof(count)) {
866 			printf("invalid Rwrite: expected %zu data bytes; "
867 			    "got %u\n", sizeof(count), len);
868 			break;
869 		}
870 
871 		memcpy(&count, d, sizeof(count));
872 		d += sizeof(count);
873 		len -= sizeof(count);
874 		count = le32toh(count);
875 
876 		printf("count=%d", count);
877 		break;
878 
879 	case Rerror:
880 		memcpy(&slen, d, sizeof(slen));
881 		d += sizeof(slen);
882 		len -= sizeof(slen);
883 		slen = le16toh(slen);
884 
885 		if (slen != len) {
886 			printf("invalid: error string length doesn't "
887 			    "match.  Got %d; want %d", slen, len);
888 			break;
889 		}
890 
891 		printf("error=\"");
892 		fwrite(d, 1, slen, stdout);
893 		printf("\"");
894 
895 		break;
896 
897 	default:
898 		if ((v = calloc(len + 1, 4)) == NULL)
899 			fatal("calloc");
900 		strvisx(v, d, len, VIS_SAFE | VIS_TAB | VIS_NL | VIS_CSTYLE);
901 		printf("body=%s", v);
902 		free(v);
903 	}
904 
905 	printf("\n");
906 }
907 
908 static void
909 handle_9p(const uint8_t *data, size_t size)
910 {
911         uint32_t len;
912 	uint16_t tag;
913 	uint8_t type;
914 
915 	assert(size >= HEADERSIZE);
916 
917 	memcpy(&len, data, sizeof(len));
918 	data += sizeof(len);
919 
920 	memcpy(&type, data, sizeof(type));
921 	data += sizeof(type);
922 
923 	memcpy(&tag, data, sizeof(tag));
924 	data += sizeof(tag);
925 
926 	len = le32toh(len);
927 	/* type is one byte long, no endianness issues */
928 	tag = le16toh(tag);
929 
930 	clr();
931 	pp_msg(len, type, tag, data);
932 	prompt();
933 }
934 
935 static void
936 clr(void)
937 {
938 	printf("\r");
939 	fflush(stdout);
940 }
941 
942 static void
943 prompt(void)
944 {
945 	printf("%s", PROMPT);
946 	fflush(stdout);
947 }
948 
949 int
950 main(int argc, char **argv)
951 {
952 	int		 ch, sock, handshake;
953 	struct event	 ev_sigint, ev_sigterm;
954 
955 	signal(SIGPIPE, SIG_IGN);
956 
957 	while ((ch = getopt(argc, argv, "C:cH:hK:P:v")) != -1) {
958 		switch (ch) {
959 		case 'C':
960 			crtpath = optarg;
961 			break;
962 		case 'c':
963 			tls = 1;
964 			break;
965 		case 'H':
966 			host = optarg;
967 			break;
968 		case 'h':
969 			usage(0);
970 			break;
971 		case 'K':
972 			keypath = optarg;
973 			break;
974 		case 'P':
975 			port = optarg;
976 			break;
977 		case 'v':
978 			verbose = 1;
979 			break;
980 		default:
981 			usage(1);
982 		}
983 	}
984 
985 	if (host == NULL)
986 		host = "localhost";
987 	if (port == NULL)
988 		port = "1337";
989 
990 	argc -= optind;
991 	argv += optind;
992 
993 	if (argc != 0)
994 		usage(1);
995 	/* if (!tls || (crtpath != NULL || keypath != NULL)) */
996 		/* usage(1); */
997 	if (!tls)
998                 errx(1, "must enable tls (for now)");
999 
1000 	log_init(1, LOG_DAEMON);
1001 	log_setverbose(verbose);
1002 	log_procinit(getprogname());
1003 
1004 	if ((tlsconf = tls_config_new()) == NULL)
1005 		fatalx("tls_config_new");
1006 	tls_config_insecure_noverifycert(tlsconf);
1007 	tls_config_insecure_noverifyname(tlsconf);
1008 	if (tls_config_set_keypair_file(tlsconf, crtpath, keypath) == -1)
1009 		fatalx("can't load certs (%s, %s)", crtpath, keypath);
1010 
1011 	if ((ctx = tls_client()) == NULL)
1012 		fatal("tls_client");
1013 	if (tls_configure(ctx, tlsconf) == -1)
1014 		fatalx("tls_configure: %s", tls_error(ctx));
1015 
1016 	log_info("connecting to %s:%s...", host, port);
1017 
1018 	if ((sock = openconn()) == -1)
1019 		fatalx("can't connect to %s:%s", host, port);
1020 
1021 	if (tls_connect_socket(ctx, sock, host) == -1)
1022 		fatalx("tls_connect_socket: %s", tls_error(ctx));
1023 
1024 	for (handshake = 0; !handshake;) {
1025 		switch (tls_handshake(ctx)) {
1026 		case -1:
1027 			fatalx("tls_handshake: %s", tls_error(ctx));
1028 		case 0:
1029 			handshake = 1;
1030 			break;
1031 		}
1032 	}
1033 
1034 	log_info("connected!");
1035 
1036 	mark_nonblock(sock);
1037 
1038 	event_init();
1039 
1040 	/* initialize global evb */
1041 	if ((evb = evbuffer_new()) == NULL)
1042 		fatal("evbuffer_new");
1043 
1044 	signal_set(&ev_sigint, SIGINT, sig_handler, NULL);
1045 	signal_set(&ev_sigterm, SIGINT, sig_handler, NULL);
1046 
1047 	signal_add(&ev_sigint, NULL);
1048 	signal_add(&ev_sigterm, NULL);
1049 
1050 	bev = bufferevent_new(sock, client_read, client_write, client_error,
1051 	    NULL);
1052 	if (bev == NULL)
1053 		fatal("bufferevent_new");
1054 
1055 	/* setup tls/io */
1056 	event_set(&bev->ev_read, sock, EV_READ, tls_readcb, bev);
1057 	event_set(&bev->ev_write, sock, EV_WRITE, tls_writecb, bev);
1058 
1059 	bufferevent_enable(bev, EV_READ|EV_WRITE);
1060 
1061 	mark_nonblock(0);
1062 	inbev = bufferevent_new(0, repl_read, NULL, repl_error, NULL);
1063 	bufferevent_enable(inbev, EV_READ);
1064 
1065 	prompt();
1066 	event_dispatch();
1067 
1068 	bufferevent_free(bev);
1069 	tls_free(ctx);
1070 	tls_config_free(tlsconf);
1071 	close(sock);
1072 
1073 	return 0;
1074 }