op public repos

Blob

Date:: Wed Jan 12 19:03:29 2022 UTC
Message:: CLOEXEC of all opened fds since we may want to spawn other programs, mark every file descriptor as cloexec. Fortunately, we don't end up opening many of them!
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_in_fd(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 
629 static int
630 fetch_fid(int fid, const char *path)
631 {
632 	int fd;
633 
634 	fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, 0644);
635 	if (fd == -1) {
636 		warn("can't open %s", path);
637 		return -1;
638 	}
639 
640 	fetch_fid_in_fd(fid, fd, path);
641 	close(fd);
642 	do_clunk(fid);
643 	return 0;
644 }
645 
646 static void
647 do_tls_connect(const char *host, const char *port)
648 {
649 	int handshake;
650 
651 	if ((tlsconf = tls_config_new()) == NULL)
652 		fatalx("tls_config_new");
653 	tls_config_insecure_noverifycert(tlsconf);
654 	tls_config_insecure_noverifyname(tlsconf);
655 	if (tls_config_set_keypair_file(tlsconf, crtpath, keypath) == -1)
656 		fatalx("can't load certs (%s, %s)", crtpath, keypath);
657 
658 	if ((ctx = tls_client()) == NULL)
659 		fatal("tls_client");
660 	if (tls_configure(ctx, tlsconf) == -1)
661 		fatalx("tls_configure: %s", tls_error(ctx));
662 
663 	if (tls_connect(ctx, host, port) == -1)
664 		fatalx("can't connect to %s:%s: %s", host, port,
665 		    tls_error(ctx));
666 
667 	for (handshake = 0; !handshake;) {
668 		switch (tls_handshake(ctx)) {
669 		case -1:
670 			fatalx("tls_handshake: %s", tls_error(ctx));
671 		case 0:
672 			handshake = 1;
673 			break;
674 		}
675 	}
676 }
677 
678 static void
679 do_ctxt_connect(const char *host, const char *port)
680 {
681 	struct addrinfo hints, *res, *res0;
682 	int error, saved_errno;
683 	const char *cause = NULL;
684 
685 	memset(&hints, 0, sizeof(hints));
686 	hints.ai_family = AF_UNSPEC;
687 	hints.ai_socktype = SOCK_STREAM;
688 	error = getaddrinfo(host, port, &hints, &res0);
689 	if (error)
690 		errx(1, "%s", gai_strerror(error));
691 
692 	sock = -1;
693 	for (res = res0; res != NULL; res = res->ai_next) {
694 		sock = socket(res->ai_family, res->ai_socktype|SOCK_CLOEXEC,
695 		    res->ai_protocol);
696 		if (sock == -1) {
697 			cause = "socket";
698 			continue;
699 		}
700 
701 		if (connect(sock, res->ai_addr, res->ai_addrlen) == -1) {
702 			cause = "connect";
703 			saved_errno = errno;
704 			close(sock);
705 			errno = saved_errno;
706 			sock = -1;
707 			continue;
708 		}
709 
710 		break;
711 	}
712 
713 	if (sock == -1)
714 		err(1, "%s", cause);
715 	freeaddrinfo(res0);
716 }
717 
718 static void
719 do_connect(const char *connspec, const char *path)
720 {
721 	char *host, *colon;
722 	const char *port;
723 
724 	host = xstrdup(connspec);
725 	if ((colon = strchr(host, ':')) != NULL) {
726 		*colon = '\0';
727 		port = ++colon;
728 	} else
729 		port = "1337";
730 
731 	printf("connecting to %s:%s...", host, port);
732 	fflush(stdout);
733 
734 	if (tls)
735 		do_tls_connect(host, port);
736 	else
737 		do_ctxt_connect(host, port);
738 
739 	printf(" done!\n");
740 
741 	do_version();
742 	do_attach(path);
743 
744 	free(host);
745 }
746 
747 static void
748 cmd_bell(int argc, const char **argv)
749 {
750 	if (argc == 0) {
751 		bell = !bell;
752 		if (bell)
753 			puts("bell mode enabled");
754 		else
755 			puts("bell mode disabled");
756 		return;
757 	}
758 
759 	if (argc != 1)
760 		goto usage;
761 
762 	if (!strcmp(*argv, "on")) {
763 		bell = 1;
764 		puts("bell mode enabled");
765 		return;
766 	}
767 
768 	if (!strcmp(*argv, "off")) {
769 		bell = 0;
770 		puts("bell mode disabled");
771 		return;
772 	}
773 
774 usage:
775 	printf("bell [on | off]\n");
776 }
777 
778 static void
779 cmd_bye(int argc, const char **argv)
780 {
781 	log_warnx("bye\n");
782 	exit(0);
783 }
784 
785 static void
786 cmd_cd(int argc, const char **argv)
787 {
788 	struct qid qid;
789 	int nfid;
790 
791 	if (argc != 1) {
792 		printf("usage: cd remote-path\n");
793 		return;
794 	}
795 
796 	nfid = pwdfid+1;
797 	if (walk_path(pwdfid, nfid, argv[0], &qid) == -1 ||
798 	    !(qid.type & QTDIR)) {
799 		printf("can't cd %s\n", argv[0]);
800 		do_clunk(nfid);
801 	} else {
802 		do_clunk(pwdfid);
803 		pwdfid = nfid;
804 	}
805 }
806 
807 static void
808 cmd_get(int argc, const char **argv)
809 {
810 	struct qid qid;
811 	const char *l;
812 	int nfid;
813 
814 	if (argc != 1 && argc != 2) {
815 		printf("usage: get remote-file [local-file]\n");
816 		return;
817 	}
818 
819 	if (argc == 2)
820 		l = argv[1];
821 	else if ((l = strrchr(argv[0], '/')) != NULL)
822 		l++; /* skip / */
823 	else
824 		l = argv[1];
825 
826 	nfid = pwdfid+1;
827 	if (walk_path(pwdfid, nfid, argv[0], &qid) == -1) {
828 		printf("can't fetch %s\n", argv[0]);
829 		return;
830 	}
831 
832 	if (qid.type != 0) {
833 		printf("can't fetch %s\n", argv[0]);
834 		do_clunk(nfid);
835 		return;
836 	}
837 
838 	fetch_fid(nfid, l);
839 }
840 
841 static void
842 cmd_lcd(int argc, const char **argv)
843 {
844 	const char *dir;
845 
846 	if (argc > 1) {
847 		printf("lcd takes only one argument\n");
848 		return;
849 	}
850 
851 	if (argc == 1)
852 		dir = *argv;
853 
854 	if (argc == 0 && (dir = getenv("HOME")) == NULL) {
855 		printf("HOME is not defined\n");
856 		return;
857 	}
858 
859 	if (chdir(dir) == -1)
860 		printf("cd: %s: %s\n", dir, strerror(errno));
861 }
862 
863 static void
864 cmd_lpwd(int argc, const char **argv)
865 {
866 	char path[PATH_MAX];
867 
868 	if (getcwd(path, sizeof(path)) == NULL) {
869 		printf("lpwd: %s\n", strerror(errno));
870 		return;
871 	}
872 
873 	printf("%s\n", path);
874 }
875 
876 static void
877 cmd_ls(int argc, const char **argv)
878 {
879 	struct np_stat st;
880 	uint64_t off = 0;
881 	uint32_t len;
882 	char fmt[FMT_SCALED_STRSIZE];
883 
884 	if (argc != 0) {
885 		printf("ls don't take arguments (yet)\n");
886 		return;
887 	}
888 
889 	dup_fid(pwdfid, 1);
890 	do_open(1, KOREAD);
891 
892 	evbuffer_drain(dirbuf, EVBUFFER_LENGTH(dirbuf));
893 
894 	for (;;) {
895 		tread(1, off, BUFSIZ);
896 		do_send();
897 		recv_msg();
898 		expect2(Rread, iota_tag);
899 
900 		len = np_read32(buf);
901 		if (len == 0)
902 			break;
903 
904 		evbuffer_add_buffer(dirbuf, buf);
905 		off += len;
906 
907 		ASSERT_EMPTYBUF();
908 	}
909 
910 	while (EVBUFFER_LENGTH(dirbuf) != 0) {
911 		if (np_read_stat(dirbuf, &st) == -1)
912 			errx(1, "invalid stat struct read");
913 
914 		if (fmt_scaled(st.length, fmt) == -1)
915 			strlcpy(fmt, "xxx", sizeof(fmt));
916 
917 		printf("%4s %8s %s\n", pp_qid_type(st.qid.type), fmt, st.name);
918 
919 		free(st.name);
920 		free(st.uid);
921 		free(st.gid);
922 		free(st.muid);
923 	}
924 
925 	do_clunk(1);
926 }
927 
928 static void
929 cmd_page(int argc, const char **argv)
930 {
931 	struct qid qid;
932 	int nfid, tmpfd;
933 	char sfn[24], p[PATH_MAX], *name;
934 
935 	if (argc != 1) {
936 		puts("usage: page file");
937 		return;
938 	}
939 
940 	nfid = pwdfid+1;
941 	if (walk_path(pwdfid, nfid, *argv, &qid) == -1) {
942 		printf("can't fetch %s\n", *argv);
943 		return;
944 	}
945 
946 	if (qid.type != 0) {
947 		printf("can't page file type %s\n", pp_qid_type(qid.type));
948 		do_clunk(nfid);
949 		return;
950 	}
951 
952 	strlcpy(sfn, "/tmp/kamiftp.XXXXXXXXXX", sizeof(sfn));
953 	if ((tmpfd = mkstemp(sfn)) == -1) {
954 		warn("mkstemp %s", sfn);
955 		do_clunk(nfid);
956 		return;
957 	}
958 
959 	strlcpy(p, *argv, sizeof(p));
960 	name = basename(p);
961 	fetch_fid_in_fd(nfid, tmpfd, name);
962 	close(tmpfd);
963 	spawn("less", sfn, NULL);
964 	unlink(sfn);
965 }
966 
967 static void
968 cmd_verbose(int argc, const char **argv)
969 {
970 	if (argc == 0) {
971 		log_setverbose(!log_getverbose());
972 		if (log_getverbose())
973 			puts("verbose mode enabled");
974 		else
975 			puts("verbose mode disabled");
976 		return;
977 	}
978 
979 	if (argc != 1)
980 		goto usage;
981 
982 	if (!strcmp(*argv, "on")) {
983 		log_setverbose(1);
984 		puts("verbose mode enabled");
985 		return;
986 	}
987 
988 	if (!strcmp(*argv, "off")) {
989 		log_setverbose(0);
990 		puts("verbose mode disabled");
991 		return;
992 	}
993 
994 usage:
995 	printf("verbose [on | off]\n");
996 }
997 
998 static void
999 excmd(int argc, const char **argv)
1000 {
1001 	struct cmd {
1002 		const char	*name;
1003 		void		(*fn)(int, const char **);
1004 	} cmds[] = {
1005 		{"bell",	cmd_bell},
1006 		{"bye",		cmd_bye},
1007 		{"cd",		cmd_cd},
1008 		{"get",		cmd_get},
1009 		{"lcd",		cmd_lcd},
1010 		{"lpwd",	cmd_lpwd},
1011 		{"ls",		cmd_ls},
1012 		{"page",	cmd_page},
1013 		{"quit",	cmd_bye},
1014 		{"verbose",	cmd_verbose},
1015 	};
1016 	size_t i;
1017 
1018 	if (argc == 0)
1019 		return;
1020 	for (i = 0; i < nitems(cmds); ++i) {
1021 		if (!strcmp(cmds[i].name, *argv)) {
1022 			cmds[i].fn(argc-1, argv+1);
1023 			return;
1024 		}
1025 	}
1026 
1027 	log_warnx("unknown command %s", *argv);
1028 }
1029 
1030 int
1031 main(int argc, char **argv)
1032 {
1033 	int	ch;
1034 
1035 	log_init(1, LOG_DAEMON);
1036 	log_setverbose(0);
1037 	log_procinit(getprogname());
1038 
1039 	while ((ch = getopt(argc, argv, "C:cK:")) != -1) {
1040 		switch (ch) {
1041 		case 'C':
1042 			crtpath = optarg;
1043 			break;
1044 		case 'c':
1045 			tls = 1;
1046 			break;
1047 		case 'K':
1048 			keypath = optarg;
1049 			break;
1050 		default:
1051 			usage(1);
1052 		}
1053 	}
1054 	argc -= optind;
1055 	argv += optind;
1056 
1057 	if (argc == 0)
1058 		usage(1);
1059 
1060 	if (isatty(1)) {
1061 		tty_p = 1;
1062 		resized = 1;
1063 		signal(SIGWINCH, tty_resized);
1064 	}
1065 
1066 	if ((evb = evbuffer_new()) == NULL)
1067 		fatal("evbuffer_new");
1068 
1069 	if ((buf = evbuffer_new()) == NULL)
1070 		fatal("evbuffer_new");
1071 
1072 	if ((dirbuf = evbuffer_new()) == NULL)
1073 		fatal("evbuferr_new");
1074 
1075 	do_connect(argv[0], argv[1]);
1076 
1077 	for (;;) {
1078 		int argc = 0;
1079 		char *line, *argv[16] = {0}, **ap;
1080 
1081 		if ((line = read_line("kamiftp> ")) == NULL)
1082 			break;
1083 
1084 		for (argc = 0, ap = argv; ap < &argv[15] &&
1085 		    (*ap = strsep(&line, " \t")) != NULL;) {
1086 			if (**ap != '\0')
1087 				ap++, argc++;
1088 		}
1089 		excmd(argc, (const char **)argv);
1090 
1091 		if (bell) {
1092 			printf("\a");
1093 			fflush(stdout);
1094 		}
1095 
1096 		free(line);
1097 	}
1098 
1099 	printf("\n");
1100 }