op public repos

Blob

Date:: Sun Jan 16 11:07:16 2022 UTC
Message:: simplify fetch_fid: make it a single function again
Actions:: History | Blame | Raw File
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  */
16 
17 #include "compat.h"
18 
19 #include <sys/ioctl.h>
20 #include <sys/types.h>
21 #include <sys/socket.h>
22 #include <sys/wait.h>
23 
24 #include <assert.h>
25 #include <errno.h>
26 #include <fcntl.h>
27 #include <inttypes.h>
28 #include <netdb.h>
29 #include <libgen.h>
30 #include <limits.h>
31 #include <signal.h>
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <syslog.h>
36 #include <tls.h>
37 #include <unistd.h>
38 
39 #ifdef HAVE_READLINE
40 #include <readline/readline.h>
41 #include <readline/history.h>
42 #endif
43 
44 #ifndef nitems
45 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
46 #endif
47 
48 #include "9pclib.h"
49 #include "kami.h"
50 #include "utils.h"
51 #include "log.h"
52 
53 /* flags */
54 int		 tls;
55 const char	*crtpath;
56 const char	*keypath;
57 
58 /* state */
59 struct tls_config	*tlsconf;
60 struct tls		*ctx;
61 int			 sock;
62 struct evbuffer		*buf;
63 struct evbuffer		*dirbuf;
64 uint32_t		 msize;
65 int			 bell;
66 
67 volatile sig_atomic_t	 resized;
68 int			 tty_p;
69 int			 tty_width;
70 
71 struct np_stat {
72 	uint16_t	 type;
73 	uint32_t	 dev;
74 	struct qid	 qid;
75 	uint32_t	 mode;
76 	uint32_t	 atime;
77 	uint32_t	 mtime;
78 	uint64_t	 length;
79 	char		*name;
80 	char		*uid;
81 	char		*gid;
82 	char		*muid;
83 };
84 
85 struct progress {
86 	uint64_t	max;
87 	uint64_t	done;
88 };
89 
90 int pwdfid;
91 
92 #define ASSERT_EMPTYBUF() assert(EVBUFFER_LENGTH(buf) == 0)
93 
94 #if !HAVE_READLINE
95 char *
96 readline(const char *prompt)
97 {
98 	char *ch, *line = NULL;
99 	size_t linesize = 0;
100 	ssize_t linelen;
101 
102 	printf("%s", prompt);
103 	fflush(stdout);
104 
105 	linelen = getline(&line, &linesize, stdin);
106 	if (linelen == -1)
107 		return NULL;
108 
109 	if ((ch = strchr(line, '\n')) != NULL)
110 		*ch = '\0';
111 	return line;
112 }
113 
114 void
115 add_history(const char *line)
116 {
117 	return;
118 }
119 #endif
120 
121 static char *
122 read_line(const char *prompt)
123 {
124 	char *line;
125 
126 again:
127 	if ((line = readline(prompt)) == NULL)
128 		return NULL;
129 	/* XXX: trim spaces? */
130 	if (*line == '\0') {
131 		free(line);
132 		goto again;
133 	}
134 
135 	add_history(line);
136 	return line;
137 }
138 
139 static void
140 spawn(const char *argv0, ...)
141 {
142 	pid_t pid;
143 	size_t i;
144 	int status;
145 	const char *argv[16], *last;
146 	va_list ap;
147 
148 	memset(argv, 0, sizeof(argv));
149 
150 	va_start(ap, argv0);
151 	argv[0] = argv0;
152 	for (i = 1; i < nitems(argv); ++i) {
153 		last = va_arg(ap, const char *);
154 		if (last == NULL)
155 			break;
156 		argv[i] = last;
157 	}
158 	va_end(ap);
159 
160 	assert(last == NULL);
161 
162 	switch (pid = fork()) {
163 	case -1:
164 		err(1, "fork");
165 	case 0: /* child */
166 		execvp(argv[0], (char *const *)argv);
167 		err(1, "execvp");
168 	default:
169 		waitpid(pid, &status, 0);
170 	}
171 }
172 
173 static void
174 tty_resized(int signo)
175 {
176 	resized = 1;
177 }
178 
179 static void __dead
180 usage(int ret)
181 {
182 	fprintf(stderr, "usage: %s [-c] [-C cert] [-K key] "
183 	    "host[:port] [path]\n", getprogname());
184 	fprintf(stderr, "kamid suite version " KAMID_VERSION "\n");
185 	exit(ret);
186 }
187 
188 static void
189 do_send(void)
190 {
191 	const void	*buf;
192 	size_t		 nbytes;
193 	ssize_t		 r;
194 
195 	while (EVBUFFER_LENGTH(evb) != 0) {
196 		buf = EVBUFFER_DATA(evb);
197 		nbytes = EVBUFFER_LENGTH(evb);
198 
199 		if (ctx == NULL) {
200 			r = write(sock, buf, nbytes);
201 			if (r == 0 || r == -1)
202 				errx(1, "EOF");
203 		} else {
204 			r = tls_write(ctx, buf, nbytes);
205 			if (r == TLS_WANT_POLLIN || r == TLS_WANT_POLLOUT)
206 				continue;
207 			if (r == -1)
208 				errx(1, "tls: %s", tls_error(ctx));
209 		}
210 
211 		evbuffer_drain(evb, r);
212 	}
213 }
214 
215 static void
216 mustread(void *d, size_t len)
217 {
218 	ssize_t r;
219 
220 	while (len != 0) {
221 		if (ctx == NULL) {
222 			r = read(sock, d, len);
223 			if (r == 0 || r == -1)
224 				errx(1, "EOF");
225 		} else {
226 			r = tls_read(ctx, d, len);
227 			if (r == TLS_WANT_POLLIN || r == TLS_WANT_POLLOUT)
228 				continue;
229 			if (r == -1)
230 				errx(1, "tls: %s", tls_error(ctx));
231 		}
232 
233 		d += r;
234 		len -= r;
235 	}
236 }
237 
238 static void
239 recv_msg(void)
240 {
241 	uint32_t	len, l;
242 	char		tmp[BUFSIZ];
243 
244 	mustread(&len, sizeof(len));
245 	len = le32toh(len);
246 	if (len < HEADERSIZE)
247 		errx(1, "read message of invalid length %d", len);
248 
249 	len -= 4; /* skip the length just read */
250 
251 	while (len != 0) {
252 		l = MIN(len, sizeof(tmp));
253 		mustread(tmp, l);
254 		len -= l;
255 		evbuffer_add(buf, tmp, l);
256 	}
257 }
258 
259 static uint64_t
260 np_read64(struct evbuffer *buf)
261 {
262 	uint64_t n;
263 
264 	evbuffer_remove(buf, &n, sizeof(n));
265 	return le64toh(n);
266 }
267 
268 static uint32_t
269 np_read32(struct evbuffer *buf)
270 {
271 	uint32_t n;
272 
273 	evbuffer_remove(buf, &n, sizeof(n));
274 	return le32toh(n);
275 }
276 
277 static uint16_t
278 np_read16(struct evbuffer *buf)
279 {
280 	uint16_t n;
281 
282 	evbuffer_remove(buf, &n, sizeof(n));
283 	return le16toh(n);
284 }
285 
286 static uint16_t
287 np_read8(struct evbuffer *buf)
288 {
289 	uint8_t n;
290 
291 	evbuffer_remove(buf, &n, sizeof(n));
292 	return n;
293 }
294 
295 static char *
296 np_readstr(struct evbuffer *buf)
297 {
298 	uint16_t	 len;
299 	char		*str;
300 
301 	len = np_read16(buf);
302 	assert(EVBUFFER_LENGTH(buf) >= len);
303 
304 	if ((str = calloc(1, len+1)) == NULL)
305 		err(1, "calloc");
306 	evbuffer_remove(buf, str, len);
307 	return str;
308 }
309 
310 static void
311 np_read_qid(struct evbuffer *buf, struct qid *qid)
312 {
313 	assert(EVBUFFER_LENGTH(buf) >= QIDSIZE);
314 
315 	qid->type = np_read8(buf);
316 	qid->vers = np_read32(buf);
317 	qid->path = np_read64(buf);
318 }
319 
320 static int
321 np_read_stat(struct evbuffer *buf, struct np_stat *st)
322 {
323 	uint16_t size;
324 
325 	memset(st, 0, sizeof(*st));
326 
327 	size = np_read16(buf);
328 	if (size > EVBUFFER_LENGTH(buf))
329 		return -1;
330 
331 	st->type = np_read16(buf);
332 	st->dev = np_read32(buf);
333 	np_read_qid(buf, &st->qid);
334 	st->mode = np_read32(buf);
335 	st->atime = np_read32(buf);
336 	st->mtime = np_read32(buf);
337 	st->length = np_read64(buf);
338 	st->name = np_readstr(buf);
339 	st->uid = np_readstr(buf);
340 	st->gid = np_readstr(buf);
341 	st->muid = np_readstr(buf);
342 
343 	return 0;
344 }
345 
346 static void
347 expect(uint8_t type)
348 {
349 	uint8_t t;
350 
351 	t = np_read8(buf);
352 	if (t == type)
353 		return;
354 
355 	if (t == Rerror) {
356 		char *err;
357 
358 		/* skip tag */
359 		np_read16(buf);
360 
361 		err = np_readstr(buf);
362 		errx(1, "expected %s, got error %s",
363 		    pp_msg_type(type), err);
364 	}
365 
366 	errx(1, "expected %s, got msg type %s",
367 	    pp_msg_type(type), pp_msg_type(t));
368 }
369 
370 static void
371 expect2(uint8_t type, uint16_t tag)
372 {
373 	uint16_t t;
374 
375 	expect(type);
376 
377 	t = np_read16(buf);
378 	if (t == tag)
379 		return;
380 
381 	errx(1, "expected tag 0x%x, got 0x%x", tag, t);
382 }
383 
384 static void
385 do_version(void)
386 {
387 	char		*version;
388 
389 	tversion(VERSION9P, MSIZE9P);
390 	do_send();
391 	recv_msg();
392 	expect2(Rversion, NOTAG);
393 
394 	msize = np_read32(buf);
395 	version = np_readstr(buf);
396 
397 	if (msize > MSIZE9P)
398 		errx(1, "got unexpected msize: %d", msize);
399 	if (strcmp(version, VERSION9P))
400 		errx(1, "unexpected 9p version: %s", version);
401 
402 	free(version);
403 	ASSERT_EMPTYBUF();
404 }
405 
406 static void
407 do_attach(const char *path)
408 {
409 	const char *user;
410 	struct qid qid;
411 
412 	if (path == NULL)
413 		path = "/";
414 	if ((user = getenv("USER")) == NULL)
415 		user = "flan";
416 
417 	tattach(pwdfid, NOFID, user, path);
418 	do_send();
419 	recv_msg();
420 	expect2(Rattach, iota_tag);
421 	np_read_qid(buf, &qid);
422 
423 	ASSERT_EMPTYBUF();
424 }
425 
426 static uint32_t
427 do_open(uint32_t fid, uint8_t mode)
428 {
429 	struct qid qid;
430 	uint32_t iounit;
431 
432 	topen(fid, mode);
433 	do_send();
434 	recv_msg();
435 	expect2(Ropen, iota_tag);
436 
437 	np_read_qid(buf, &qid);
438 	iounit = np_read32(buf);
439 
440 	ASSERT_EMPTYBUF();
441 
442 	return iounit;
443 }
444 
445 static void
446 do_clunk(uint32_t fid)
447 {
448 	tclunk(fid);
449 	do_send();
450 	recv_msg();
451 	expect2(Rclunk, iota_tag);
452 
453 	ASSERT_EMPTYBUF();
454 }
455 
456 static void
457 dup_fid(int fid, int nfid)
458 {
459 	uint16_t nwqid;
460 
461 	twalk(fid, nfid, NULL, 0);
462 	do_send();
463 	recv_msg();
464 	expect2(Rwalk, iota_tag);
465 
466 	nwqid = np_read16(buf);
467 	assert(nwqid == 0);
468 
469 	ASSERT_EMPTYBUF();
470 }
471 
472 static int
473 walk_path(int fid, int newfid, const char *path, struct qid *qid)
474 {
475 	char *wnames[MAXWELEM], *p, *t;
476 	size_t nwname, i;
477 	uint16_t nwqid;
478 
479 	if ((p = strdup(path)) == NULL)
480 		err(1, "strdup");
481 	t = p;
482 
483 	/* strip initial ./ */
484 	if (t[0] == '.' && t[1] == '/')
485 		t += 2;
486 
487 	for (nwname = 0; nwname < nitems(wnames) &&
488 	    (wnames[nwname] = strsep(&t, "/")) != NULL;) {
489 		if (*wnames[nwname] != '\0')
490 			nwname++;
491 	}
492 
493 	twalk(fid, newfid, (const char **)wnames, nwname);
494 	do_send();
495 	recv_msg();
496 	expect2(Rwalk, iota_tag);
497 
498 	nwqid = np_read16(buf);
499 	assert(nwqid <= nwname);
500 
501 	/* consume all qids */
502 	for (i = 0; i < nwname; ++i)
503 		np_read_qid(buf, qid);
504 
505 	free(p);
506 
507 	return nwqid == nwname;
508 }
509 
510 static void
511 do_stat(int fid, struct np_stat *st)
512 {
513 	tstat(fid);
514 	do_send();
515 	recv_msg();
516 	expect2(Rstat, iota_tag);
517 
518 	if (np_read_stat(buf, st) == -1)
519 		errx(1, "invalid stat struct read");
520 
521 	ASSERT_EMPTYBUF();
522 }
523 
524 static size_t
525 do_read(int fid, uint64_t off, uint32_t count, void *data)
526 {
527 	uint32_t r;
528 
529 	tread(fid, off, count);
530 	do_send();
531 	recv_msg();
532 	expect2(Rread, iota_tag);
533 
534 	r = np_read32(buf);
535 	assert(r == EVBUFFER_LENGTH(buf));
536 	assert(r <= count);
537 	evbuffer_remove(buf, data, r);
538 
539 	ASSERT_EMPTYBUF();
540 
541 	return r;
542 }
543 
544 static void
545 draw_progress(const char *pre, const struct progress *p)
546 {
547 	struct winsize ws;
548 	int i, l, w;
549 	double perc;
550 
551 	perc = 100.0 * p->done / p->max;
552 	if (!tty_p) {
553 		fprintf(stderr, "%s: %d%%\n", pre, (int)perc);
554 		return;
555 	}
556 
557 	if (resized) {
558 		resized = 0;
559 
560 		if (ioctl(0, TIOCGWINSZ, &ws) == -1)
561 			return;
562 		tty_width = ws.ws_col;
563 	}
564 	w = tty_width;
565 
566 	if (pre == NULL ||
567 	    ((l = printf("\r%s ", pre)) == -1 || l >= w))
568 		return;
569 
570 	w -= l + 2 + 5; /* 2 for |, 5 for percentage + \n */
571 	if (w < 0) {
572 		printf("%4d%%\n", (int)perc);
573 		return;
574 	}
575 
576 	printf("|");
577 
578 	l = w * MIN(100.0, perc) / 100.0;
579 	for (i = 0; i < l; i++)
580 		printf("*");
581 	for (; i < w; i++)
582 		printf(" ");
583 	printf("|%4d%%", (int)perc);
584 
585 	fflush(stdout);
586 }
587 
588 static void
589 fetch_fid(int fid, int fd, const char *name)
590 {
591 	struct progress p = {0};
592 	struct np_stat st;
593 	size_t r;
594 	char buf[BUFSIZ];
595 
596 	do_stat(fid, &st);
597 	do_open(fid, KOREAD);
598 
599 	p.max = st.length;
600 	for (;;) {
601 		size_t siz, off;
602 		ssize_t nw;
603 
604 		r = do_read(fid, p.done, sizeof(buf), buf);
605 		if (r == 0)
606 			break;
607 
608 		siz = sizeof(buf);
609 		for (off = 0; off < siz; off += nw)
610 			if ((nw = write(fd, buf + off, siz - off)) == 0 ||
611 			    nw == -1)
612 				err(1, "write");
613 
614 		p.done += r;
615 		draw_progress(name, &p);
616 
617 #if 0
618 		/* throttle, for debugging purpose */
619 		{
620 			struct timespec ts = { 0, 500000000 };
621 			nanosleep(&ts, NULL);
622 		}
623 #endif
624 	}
625 
626 	putchar('\n');
627 
628 	do_clunk(fid);
629 }
630 
631 static void
632 do_tls_connect(const char *host, const char *port)
633 {
634 	int handshake;
635 
636 	if ((tlsconf = tls_config_new()) == NULL)
637 		fatalx("tls_config_new");
638 	tls_config_insecure_noverifycert(tlsconf);
639 	tls_config_insecure_noverifyname(tlsconf);
640 	if (tls_config_set_keypair_file(tlsconf, crtpath, keypath) == -1)
641 		fatalx("can't load certs (%s, %s)", crtpath, keypath);
642 
643 	if ((ctx = tls_client()) == NULL)
644 		fatal("tls_client");
645 	if (tls_configure(ctx, tlsconf) == -1)
646 		fatalx("tls_configure: %s", tls_error(ctx));
647 
648 	if (tls_connect(ctx, host, port) == -1)
649 		fatalx("can't connect to %s:%s: %s", host, port,
650 		    tls_error(ctx));
651 
652 	for (handshake = 0; !handshake;) {
653 		switch (tls_handshake(ctx)) {
654 		case -1:
655 			fatalx("tls_handshake: %s", tls_error(ctx));
656 		case 0:
657 			handshake = 1;
658 			break;
659 		}
660 	}
661 }
662 
663 static void
664 do_ctxt_connect(const char *host, const char *port)
665 {
666 	struct addrinfo hints, *res, *res0;
667 	int error, saved_errno;
668 	const char *cause = NULL;
669 
670 	memset(&hints, 0, sizeof(hints));
671 	hints.ai_family = AF_UNSPEC;
672 	hints.ai_socktype = SOCK_STREAM;
673 	error = getaddrinfo(host, port, &hints, &res0);
674 	if (error)
675 		errx(1, "%s", gai_strerror(error));
676 
677 	sock = -1;
678 	for (res = res0; res != NULL; res = res->ai_next) {
679 		sock = socket(res->ai_family, res->ai_socktype|SOCK_CLOEXEC,
680 		    res->ai_protocol);
681 		if (sock == -1) {
682 			cause = "socket";
683 			continue;
684 		}
685 
686 		if (connect(sock, res->ai_addr, res->ai_addrlen) == -1) {
687 			cause = "connect";
688 			saved_errno = errno;
689 			close(sock);
690 			errno = saved_errno;
691 			sock = -1;
692 			continue;
693 		}
694 
695 		break;
696 	}
697 
698 	if (sock == -1)
699 		err(1, "%s", cause);
700 	freeaddrinfo(res0);
701 }
702 
703 static void
704 do_connect(const char *connspec, const char *path)
705 {
706 	char *host, *colon;
707 	const char *port;
708 
709 	host = xstrdup(connspec);
710 	if ((colon = strchr(host, ':')) != NULL) {
711 		*colon = '\0';
712 		port = ++colon;
713 	} else
714 		port = "1337";
715 
716 	printf("connecting to %s:%s...", host, port);
717 	fflush(stdout);
718 
719 	if (tls)
720 		do_tls_connect(host, port);
721 	else
722 		do_ctxt_connect(host, port);
723 
724 	printf(" done!\n");
725 
726 	do_version();
727 	do_attach(path);
728 
729 	free(host);
730 }
731 
732 static void
733 cmd_bell(int argc, const char **argv)
734 {
735 	if (argc == 0) {
736 		bell = !bell;
737 		if (bell)
738 			puts("bell mode enabled");
739 		else
740 			puts("bell mode disabled");
741 		return;
742 	}
743 
744 	if (argc != 1)
745 		goto usage;
746 
747 	if (!strcmp(*argv, "on")) {
748 		bell = 1;
749 		puts("bell mode enabled");
750 		return;
751 	}
752 
753 	if (!strcmp(*argv, "off")) {
754 		bell = 0;
755 		puts("bell mode disabled");
756 		return;
757 	}
758 
759 usage:
760 	printf("bell [on | off]\n");
761 }
762 
763 static void
764 cmd_bye(int argc, const char **argv)
765 {
766 	log_warnx("bye\n");
767 	exit(0);
768 }
769 
770 static void
771 cmd_cd(int argc, const char **argv)
772 {
773 	struct qid qid;
774 	int nfid;
775 
776 	if (argc != 1) {
777 		printf("usage: cd remote-path\n");
778 		return;
779 	}
780 
781 	nfid = pwdfid+1;
782 	if (walk_path(pwdfid, nfid, argv[0], &qid) == -1 ||
783 	    !(qid.type & QTDIR)) {
784 		printf("can't cd %s\n", argv[0]);
785 		do_clunk(nfid);
786 	} else {
787 		do_clunk(pwdfid);
788 		pwdfid = nfid;
789 	}
790 }
791 
792 static void
793 cmd_get(int argc, const char **argv)
794 {
795 	struct qid qid;
796 	const char *l;
797 	int nfid;
798 	int fd;
799 
800 	if (argc != 1 && argc != 2) {
801 		printf("usage: get remote-file [local-file]\n");
802 		return;
803 	}
804 
805 	if (argc == 2)
806 		l = argv[1];
807 	else if ((l = strrchr(argv[0], '/')) != NULL)
808 		l++; /* skip / */
809 	else
810 		l = argv[0];
811 
812 	nfid = pwdfid+1;
813 	if (walk_path(pwdfid, nfid, argv[0], &qid) == -1) {
814 		printf("can't fetch %s\n", argv[0]);
815 		return;
816 	}
817 
818 	if (qid.type != 0) {
819 		printf("can't fetch %s\n", argv[0]);
820 		do_clunk(nfid);
821 		return;
822 	}
823 
824 	if ((fd = open(l, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, 0644)) == -1) {
825 		warn("can't open %s", l);
826 		do_clunk(nfid);
827 		return;
828 	}
829 
830 	fetch_fid(nfid, fd, l);
831 	close(fd);
832 }
833 
834 static void
835 cmd_lcd(int argc, const char **argv)
836 {
837 	const char *dir;
838 
839 	if (argc > 1) {
840 		printf("lcd takes only one argument\n");
841 		return;
842 	}
843 
844 	if (argc == 1)
845 		dir = *argv;
846 
847 	if (argc == 0 && (dir = getenv("HOME")) == NULL) {
848 		printf("HOME is not defined\n");
849 		return;
850 	}
851 
852 	if (chdir(dir) == -1)
853 		printf("cd: %s: %s\n", dir, strerror(errno));
854 }
855 
856 static void
857 cmd_lpwd(int argc, const char **argv)
858 {
859 	char path[PATH_MAX];
860 
861 	if (getcwd(path, sizeof(path)) == NULL) {
862 		printf("lpwd: %s\n", strerror(errno));
863 		return;
864 	}
865 
866 	printf("%s\n", path);
867 }
868 
869 static void
870 cmd_ls(int argc, const char **argv)
871 {
872 	struct np_stat st;
873 	uint64_t off = 0;
874 	uint32_t len;
875 	char fmt[FMT_SCALED_STRSIZE];
876 
877 	if (argc != 0) {
878 		printf("ls don't take arguments (yet)\n");
879 		return;
880 	}
881 
882 	dup_fid(pwdfid, 1);
883 	do_open(1, KOREAD);
884 
885 	evbuffer_drain(dirbuf, EVBUFFER_LENGTH(dirbuf));
886 
887 	for (;;) {
888 		tread(1, off, BUFSIZ);
889 		do_send();
890 		recv_msg();
891 		expect2(Rread, iota_tag);
892 
893 		len = np_read32(buf);
894 		if (len == 0)
895 			break;
896 
897 		evbuffer_add_buffer(dirbuf, buf);
898 		off += len;
899 
900 		ASSERT_EMPTYBUF();
901 	}
902 
903 	while (EVBUFFER_LENGTH(dirbuf) != 0) {
904 		if (np_read_stat(dirbuf, &st) == -1)
905 			errx(1, "invalid stat struct read");
906 
907 		if (fmt_scaled(st.length, fmt) == -1)
908 			strlcpy(fmt, "xxx", sizeof(fmt));
909 
910 		printf("%4s %8s %s\n", pp_qid_type(st.qid.type), fmt, st.name);
911 
912 		free(st.name);
913 		free(st.uid);
914 		free(st.gid);
915 		free(st.muid);
916 	}
917 
918 	do_clunk(1);
919 }
920 
921 static void
922 cmd_page(int argc, const char **argv)
923 {
924 	struct qid qid;
925 	int nfid, tmpfd;
926 	char sfn[24], p[PATH_MAX], *name;
927 
928 	if (argc != 1) {
929 		puts("usage: page file");
930 		return;
931 	}
932 
933 	nfid = pwdfid+1;
934 	if (walk_path(pwdfid, nfid, *argv, &qid) == -1) {
935 		printf("can't fetch %s\n", *argv);
936 		return;
937 	}
938 
939 	if (qid.type != 0) {
940 		printf("can't page file type %s\n", pp_qid_type(qid.type));
941 		do_clunk(nfid);
942 		return;
943 	}
944 
945 	strlcpy(sfn, "/tmp/kamiftp.XXXXXXXXXX", sizeof(sfn));
946 	if ((tmpfd = mkstemp(sfn)) == -1) {
947 		warn("mkstemp %s", sfn);
948 		do_clunk(nfid);
949 		return;
950 	}
951 
952 	strlcpy(p, *argv, sizeof(p));
953 	name = basename(p);
954 	fetch_fid(nfid, tmpfd, name);
955 	close(tmpfd);
956 	spawn("less", sfn, NULL);
957 	unlink(sfn);
958 }
959 
960 static void
961 cmd_verbose(int argc, const char **argv)
962 {
963 	if (argc == 0) {
964 		log_setverbose(!log_getverbose());
965 		if (log_getverbose())
966 			puts("verbose mode enabled");
967 		else
968 			puts("verbose mode disabled");
969 		return;
970 	}
971 
972 	if (argc != 1)
973 		goto usage;
974 
975 	if (!strcmp(*argv, "on")) {
976 		log_setverbose(1);
977 		puts("verbose mode enabled");
978 		return;
979 	}
980 
981 	if (!strcmp(*argv, "off")) {
982 		log_setverbose(0);
983 		puts("verbose mode disabled");
984 		return;
985 	}
986 
987 usage:
988 	printf("verbose [on | off]\n");
989 }
990 
991 static void
992 excmd(int argc, const char **argv)
993 {
994 	struct cmd {
995 		const char	*name;
996 		void		(*fn)(int, const char **);
997 	} cmds[] = {
998 		{"bell",	cmd_bell},
999 		{"bye",		cmd_bye},
1000 		{"cd",		cmd_cd},
1001 		{"get",		cmd_get},
1002 		{"lcd",		cmd_lcd},
1003 		{"lpwd",	cmd_lpwd},
1004 		{"ls",		cmd_ls},
1005 		{"page",	cmd_page},
1006 		{"quit",	cmd_bye},
1007 		{"verbose",	cmd_verbose},
1008 	};
1009 	size_t i;
1010 
1011 	if (argc == 0)
1012 		return;
1013 	for (i = 0; i < nitems(cmds); ++i) {
1014 		if (!strcmp(cmds[i].name, *argv)) {
1015 			cmds[i].fn(argc-1, argv+1);
1016 			return;
1017 		}
1018 	}
1019 
1020 	log_warnx("unknown command %s", *argv);
1021 }
1022 
1023 int
1024 main(int argc, char **argv)
1025 {
1026 	int	ch;
1027 
1028 	log_init(1, LOG_DAEMON);
1029 	log_setverbose(0);
1030 	log_procinit(getprogname());
1031 
1032 	while ((ch = getopt(argc, argv, "C:cK:")) != -1) {
1033 		switch (ch) {
1034 		case 'C':
1035 			crtpath = optarg;
1036 			break;
1037 		case 'c':
1038 			tls = 1;
1039 			break;
1040 		case 'K':
1041 			keypath = optarg;
1042 			break;
1043 		default:
1044 			usage(1);
1045 		}
1046 	}
1047 	argc -= optind;
1048 	argv += optind;
1049 
1050 	if (argc == 0)
1051 		usage(1);
1052 
1053 	if (isatty(1)) {
1054 		tty_p = 1;
1055 		resized = 1;
1056 		signal(SIGWINCH, tty_resized);
1057 	}
1058 
1059 	if ((evb = evbuffer_new()) == NULL)
1060 		fatal("evbuffer_new");
1061 
1062 	if ((buf = evbuffer_new()) == NULL)
1063 		fatal("evbuffer_new");
1064 
1065 	if ((dirbuf = evbuffer_new()) == NULL)
1066 		fatal("evbuferr_new");
1067 
1068 	do_connect(argv[0], argv[1]);
1069 
1070 	for (;;) {
1071 		int argc = 0;
1072 		char *line, *argv[16] = {0}, **ap;
1073 
1074 		if ((line = read_line("kamiftp> ")) == NULL)
1075 			break;
1076 
1077 		for (argc = 0, ap = argv; ap < &argv[15] &&
1078 		    (*ap = strsep(&line, " \t")) != NULL;) {
1079 			if (**ap != '\0')
1080 				ap++, argc++;
1081 		}
1082 		excmd(argc, (const char **)argv);
1083 
1084 		if (bell) {
1085 			printf("\a");
1086 			fflush(stdout);
1087 		}
1088 
1089 		free(line);
1090 	}
1091 
1092 	printf("\n");
1093 }