op public repos

Blob

Date:: Fri Jan 21 16:18:52 2022 UTC
Message:: ftp: truncate the file in woc_file The idea behind woc_file is to create or open a file, but it's always used for writing fresh new content, so it's actually an error that it opens a file for writing without truncating it too. It means that if we write less content than what the file already has, we kepp garbage at the end. This adds an extra argument in send_fid (that is actually used only from woc_file now) so that we can pass KOTRUNC for do_open.
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/stat.h>
23 #include <sys/wait.h>
24 
25 #include <assert.h>
26 #include <errno.h>
27 #include <fcntl.h>
28 #include <inttypes.h>
29 #include <netdb.h>
30 #include <libgen.h>
31 #include <limits.h>
32 #include <signal.h>
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <syslog.h>
37 #include <tls.h>
38 #include <unistd.h>
39 
40 #ifdef HAVE_READLINE
41 #include <readline/readline.h>
42 #include <readline/history.h>
43 #endif
44 
45 #ifndef nitems
46 #define nitems(_a)	(sizeof((_a)) / sizeof((_a)[0]))
47 #endif
48 
49 #include "kami.h"
50 #include "utils.h"
51 #include "log.h"
52 #include "9pclib.h"
53 
54 #define TMPFSTR		"/tmp/kamiftp.XXXXXXXXXX"
55 #define TMPFSTRLEN	sizeof(TMPFSTR)
56 
57 /* flags */
58 int		 tls;
59 const char	*crtpath;
60 const char	*keypath;
61 
62 /* state */
63 struct tls_config	*tlsconf;
64 struct tls		*ctx;
65 int			 sock;
66 struct evbuffer		*buf;
67 struct evbuffer		*dirbuf;
68 uint32_t		 msize;
69 int			 bell;
70 
71 volatile sig_atomic_t	 resized;
72 int			 tty_p;
73 int			 tty_width;
74 int			 xdump;
75 
76 struct progress {
77 	uint64_t	max;
78 	uint64_t	done;
79 };
80 
81 int pwdfid;
82 
83 #define ASSERT_EMPTYBUF() assert(EVBUFFER_LENGTH(buf) == 0)
84 
85 #if !HAVE_READLINE
86 char *
87 readline(const char *prompt)
88 {
89 	char *ch, *line = NULL;
90 	size_t linesize = 0;
91 	ssize_t linelen;
92 
93 	printf("%s", prompt);
94 	fflush(stdout);
95 
96 	linelen = getline(&line, &linesize, stdin);
97 	if (linelen == -1)
98 		return NULL;
99 
100 	if ((ch = strchr(line, '\n')) != NULL)
101 		*ch = '\0';
102 	return line;
103 }
104 
105 void
106 add_history(const char *line)
107 {
108 	return;
109 }
110 #endif
111 
112 static char *
113 read_line(const char *prompt)
114 {
115 	char *line;
116 
117 again:
118 	if ((line = readline(prompt)) == NULL)
119 		return NULL;
120 	/* XXX: trim spaces? */
121 	if (*line == '\0') {
122 		free(line);
123 		goto again;
124 	}
125 
126 	add_history(line);
127 	return line;
128 }
129 
130 static void
131 spawn(const char *argv0, ...)
132 {
133 	pid_t pid;
134 	size_t i;
135 	int status;
136 	const char *argv[16], *last;
137 	va_list ap;
138 
139 	memset(argv, 0, sizeof(argv));
140 
141 	va_start(ap, argv0);
142 	argv[0] = argv0;
143 	for (i = 1; i < nitems(argv); ++i) {
144 		last = va_arg(ap, const char *);
145 		if (last == NULL)
146 			break;
147 		argv[i] = last;
148 	}
149 	va_end(ap);
150 
151 	assert(last == NULL);
152 
153 	switch (pid = fork()) {
154 	case -1:
155 		err(1, "fork");
156 	case 0: /* child */
157 		execvp(argv[0], (char *const *)argv);
158 		err(1, "execvp");
159 	default:
160 		waitpid(pid, &status, 0);
161 	}
162 }
163 
164 static void
165 tty_resized(int signo)
166 {
167 	resized = 1;
168 }
169 
170 static void __dead
171 usage(int ret)
172 {
173 	fprintf(stderr, "usage: %s [-c] [-C cert] [-K key] "
174 	    "host[:port] [path]\n", getprogname());
175 	fprintf(stderr, "kamid suite version " KAMID_VERSION "\n");
176 	exit(ret);
177 }
178 
179 static int
180 nextfid(void)
181 {
182 	uint32_t i;
183 
184 	for (i = 0; ; ++i) {
185 		if (i != pwdfid)
186 			return i;
187 	}
188 }
189 
190 static void
191 do_send(void)
192 {
193 	const void	*buf;
194 	size_t		 nbytes;
195 	ssize_t		 r;
196 
197 	if (xdump)
198 		hexdump("outgoing message", EVBUFFER_DATA(evb),
199 		    EVBUFFER_LENGTH(evb));
200 
201 	while (EVBUFFER_LENGTH(evb) != 0) {
202 		buf = EVBUFFER_DATA(evb);
203 		nbytes = EVBUFFER_LENGTH(evb);
204 
205 		if (ctx == NULL) {
206 			r = write(sock, buf, nbytes);
207 			if (r == 0 || r == -1)
208 				errx(1, "EOF");
209 		} else {
210 			r = tls_write(ctx, buf, nbytes);
211 			if (r == TLS_WANT_POLLIN || r == TLS_WANT_POLLOUT)
212 				continue;
213 			if (r == -1)
214 				errx(1, "tls: %s", tls_error(ctx));
215 		}
216 
217 		evbuffer_drain(evb, r);
218 	}
219 }
220 
221 static void
222 mustread(void *d, size_t len)
223 {
224 	ssize_t r;
225 
226 	while (len != 0) {
227 		if (ctx == NULL) {
228 			r = read(sock, d, len);
229 			if (r == 0 || r == -1)
230 				errx(1, "EOF");
231 		} else {
232 			r = tls_read(ctx, d, len);
233 			if (r == TLS_WANT_POLLIN || r == TLS_WANT_POLLOUT)
234 				continue;
235 			if (r == -1)
236 				errx(1, "tls: %s", tls_error(ctx));
237 		}
238 
239 		d += r;
240 		len -= r;
241 	}
242 }
243 
244 static void
245 recv_msg(void)
246 {
247 	uint32_t	len, l;
248 	char		tmp[BUFSIZ];
249 
250 	mustread(&len, sizeof(len));
251 	len = le32toh(len);
252 	if (len < HEADERSIZE)
253 		errx(1, "read message of invalid length %d", len);
254 
255 	len -= 4; /* skip the length just read */
256 
257 	while (len != 0) {
258 		l = MIN(len, sizeof(tmp));
259 		mustread(tmp, l);
260 		len -= l;
261 		evbuffer_add(buf, tmp, l);
262 	}
263 
264 	if (xdump)
265 		hexdump("incoming packet", EVBUFFER_DATA(buf),
266 		    EVBUFFER_LENGTH(buf));
267 }
268 
269 static uint64_t
270 np_read64(struct evbuffer *buf)
271 {
272 	uint64_t n;
273 
274 	evbuffer_remove(buf, &n, sizeof(n));
275 	return le64toh(n);
276 }
277 
278 static uint32_t
279 np_read32(struct evbuffer *buf)
280 {
281 	uint32_t n;
282 
283 	evbuffer_remove(buf, &n, sizeof(n));
284 	return le32toh(n);
285 }
286 
287 static uint16_t
288 np_read16(struct evbuffer *buf)
289 {
290 	uint16_t n;
291 
292 	evbuffer_remove(buf, &n, sizeof(n));
293 	return le16toh(n);
294 }
295 
296 static uint16_t
297 np_read8(struct evbuffer *buf)
298 {
299 	uint8_t n;
300 
301 	evbuffer_remove(buf, &n, sizeof(n));
302 	return n;
303 }
304 
305 static char *
306 np_readstr(struct evbuffer *buf)
307 {
308 	uint16_t	 len;
309 	char		*str;
310 
311 	len = np_read16(buf);
312 	assert(EVBUFFER_LENGTH(buf) >= len);
313 
314 	if ((str = calloc(1, len+1)) == NULL)
315 		err(1, "calloc");
316 	evbuffer_remove(buf, str, len);
317 	return str;
318 }
319 
320 static void
321 np_read_qid(struct evbuffer *buf, struct qid *qid)
322 {
323 	assert(EVBUFFER_LENGTH(buf) >= QIDSIZE);
324 
325 	qid->type = np_read8(buf);
326 	qid->vers = np_read32(buf);
327 	qid->path = np_read64(buf);
328 }
329 
330 static int
331 np_read_stat(struct evbuffer *buf, struct np_stat *st)
332 {
333 	uint16_t size;
334 
335 	memset(st, 0, sizeof(*st));
336 
337 	size = np_read16(buf);
338 	if (size > EVBUFFER_LENGTH(buf))
339 		return -1;
340 
341 	st->type = np_read16(buf);
342 	st->dev = np_read32(buf);
343 	np_read_qid(buf, &st->qid);
344 	st->mode = np_read32(buf);
345 	st->atime = np_read32(buf);
346 	st->mtime = np_read32(buf);
347 	st->length = np_read64(buf);
348 	st->name = np_readstr(buf);
349 	st->uid = np_readstr(buf);
350 	st->gid = np_readstr(buf);
351 	st->muid = np_readstr(buf);
352 
353 	return 0;
354 }
355 
356 static void
357 expect(uint8_t type)
358 {
359 	uint8_t t;
360 
361 	t = np_read8(buf);
362 	if (t == type)
363 		return;
364 
365 	if (t == Rerror) {
366 		char *err;
367 
368 		/* skip tag */
369 		np_read16(buf);
370 
371 		err = np_readstr(buf);
372 		errx(1, "expected %s, got error %s",
373 		    pp_msg_type(type), err);
374 	}
375 
376 	errx(1, "expected %s, got msg type %s",
377 	    pp_msg_type(type), pp_msg_type(t));
378 }
379 
380 static void
381 expect2(uint8_t type, uint16_t tag)
382 {
383 	uint16_t t;
384 
385 	expect(type);
386 
387 	t = np_read16(buf);
388 	if (t == tag)
389 		return;
390 
391 	errx(1, "expected tag 0x%x, got 0x%x", tag, t);
392 }
393 
394 static char *
395 check(uint8_t type, uint16_t tag)
396 {
397 	uint16_t rtag;
398 	uint8_t rtype;
399 
400 	rtype = np_read8(buf);
401 	rtag = np_read16(buf);
402 	if (rtype == type) {
403 		if (rtag != tag)
404 			errx(1, "expected tag 0x%x, got 0x%x", tag, rtag);
405 		return NULL;
406 	}
407 
408 	if (rtype == Rerror)
409 		return np_readstr(buf);
410 
411 	errx(1, "expected %s, got msg type %s",
412 	    pp_msg_type(type), pp_msg_type(rtype));
413 }
414 
415 static void
416 do_version(void)
417 {
418 	char		*version;
419 
420 	tversion(VERSION9P, MSIZE9P);
421 	do_send();
422 	recv_msg();
423 	expect2(Rversion, NOTAG);
424 
425 	msize = np_read32(buf);
426 	version = np_readstr(buf);
427 
428 	if (msize > MSIZE9P)
429 		errx(1, "got unexpected msize: %d", msize);
430 	if (strcmp(version, VERSION9P))
431 		errx(1, "unexpected 9p version: %s", version);
432 
433 	free(version);
434 	ASSERT_EMPTYBUF();
435 }
436 
437 static void
438 do_attach(const char *path)
439 {
440 	const char *user;
441 	struct qid qid;
442 
443 	if (path == NULL)
444 		path = "/";
445 	if ((user = getenv("USER")) == NULL)
446 		user = "flan";
447 
448 	tattach(pwdfid, NOFID, user, path);
449 	do_send();
450 	recv_msg();
451 	expect2(Rattach, iota_tag);
452 	np_read_qid(buf, &qid);
453 
454 	ASSERT_EMPTYBUF();
455 }
456 
457 static uint32_t
458 do_open(uint32_t fid, uint8_t mode)
459 {
460 	struct qid qid;
461 	uint32_t iounit;
462 
463 	topen(fid, mode);
464 	do_send();
465 	recv_msg();
466 	expect2(Ropen, iota_tag);
467 
468 	np_read_qid(buf, &qid);
469 	iounit = np_read32(buf);
470 
471 	ASSERT_EMPTYBUF();
472 
473 	return iounit;
474 }
475 
476 static uint32_t
477 do_create(uint32_t fid, const char *name, uint32_t perm, uint8_t mode)
478 {
479 	struct qid qid;
480 	uint32_t iounit;
481 
482 	tcreate(fid, name, perm, mode);
483 	do_send();
484 	recv_msg();
485 	expect2(Rcreate, iota_tag);
486 
487 	np_read_qid(buf, &qid);
488 	iounit = np_read32(buf);
489 
490 	ASSERT_EMPTYBUF();
491 
492 	return iounit;
493 }
494 
495 static void
496 do_clunk(uint32_t fid)
497 {
498 	tclunk(fid);
499 	do_send();
500 	recv_msg();
501 	expect2(Rclunk, iota_tag);
502 
503 	ASSERT_EMPTYBUF();
504 }
505 
506 static char *
507 dup_fid(int fid, int nfid)
508 {
509 	uint16_t nwqid;
510 	char *errstr;
511 
512 	twalk(fid, nfid, NULL, 0);
513 	do_send();
514 	recv_msg();
515 
516 	if ((errstr = check(Rwalk, iota_tag)) != NULL)
517 		return errstr;
518 
519 	nwqid = np_read16(buf);
520 	assert(nwqid == 0);
521 
522 	ASSERT_EMPTYBUF();
523 
524 	return NULL;
525 }
526 
527 static char *
528 walk_path(int fid, int newfid, const char *path, int *missing,
529     struct qid *qid)
530 {
531 	char *wnames[MAXWELEM], *p, *t, *errstr;
532 	size_t nwname, i;
533 	uint16_t nwqid;
534 
535 	if ((p = strdup(path)) == NULL)
536 		err(1, "strdup");
537 	t = p;
538 
539 	/* strip initial ./ */
540 	if (t[0] == '.' && t[1] == '/')
541 		t += 2;
542 
543 	for (nwname = 0; nwname < nitems(wnames) &&
544 	    (wnames[nwname] = strsep(&t, "/")) != NULL;) {
545 		if (*wnames[nwname] != '\0')
546 			nwname++;
547 	}
548 
549 	twalk(fid, newfid, (const char **)wnames, nwname);
550 	do_send();
551 	recv_msg();
552 
553 	*missing = nwname;
554 	if ((errstr = check(Rwalk, iota_tag)) != NULL) {
555 		free(p);
556 		return errstr;
557 	}
558 
559 	nwqid = np_read16(buf);
560 	assert(nwqid <= nwname);
561 
562 	/* consume all qids */
563 	for (i = 0; i < nwqid; ++i)
564 		np_read_qid(buf, qid);
565 
566 	free(p);
567 
568 	*missing = nwname - nwqid;
569 	return NULL;
570 }
571 
572 static void
573 do_stat(int fid, struct np_stat *st)
574 {
575 	tstat(fid);
576 	do_send();
577 	recv_msg();
578 	expect2(Rstat, iota_tag);
579 
580 	if (np_read_stat(buf, st) == -1)
581 		errx(1, "invalid stat struct read");
582 
583 	ASSERT_EMPTYBUF();
584 }
585 
586 static char *
587 do_wstat(int fid, const struct np_stat *st)
588 {
589 	char *errstr;
590 
591 	twstat(fid, st);
592 	do_send();
593 	recv_msg();
594 
595 	if ((errstr = check(Rwstat, iota_tag)) != NULL)
596 		return errstr;
597 
598 	ASSERT_EMPTYBUF();
599 
600 	return NULL;
601 }
602 
603 static size_t
604 do_read(int fid, uint64_t off, uint32_t count, void *data)
605 {
606 	uint32_t r;
607 
608 	tread(fid, off, count);
609 	do_send();
610 	recv_msg();
611 	expect2(Rread, iota_tag);
612 
613 	r = np_read32(buf);
614 	assert(r == EVBUFFER_LENGTH(buf));
615 	assert(r <= count);
616 	evbuffer_remove(buf, data, r);
617 
618 	ASSERT_EMPTYBUF();
619 
620 	return r;
621 }
622 
623 static size_t
624 do_write(int fid, uint64_t off, uint32_t count, void *data)
625 {
626 	uint32_t r;
627 
628 	twrite(fid, off, data, count);
629 	do_send();
630 	recv_msg();
631 	expect2(Rwrite, iota_tag);
632 
633 	r = np_read32(buf);
634 	assert(r <= count);
635 
636 	ASSERT_EMPTYBUF();
637 
638 	return r;
639 }
640 
641 static void
642 draw_progress(const char *pre, const struct progress *p)
643 {
644 	struct winsize ws;
645 	int i, l, w;
646 	double perc;
647 
648 	if (xdump)
649 		return;
650 
651 	perc = 100.0 * p->done / p->max;
652 	if (!tty_p) {
653 		fprintf(stderr, "%s: %d%%\n", pre, (int)perc);
654 		return;
655 	}
656 
657 	if (resized) {
658 		resized = 0;
659 
660 		if (ioctl(0, TIOCGWINSZ, &ws) == -1)
661 			return;
662 		tty_width = ws.ws_col;
663 	}
664 	w = tty_width;
665 
666 	if (pre == NULL ||
667 	    ((l = printf("\r%s ", pre)) == -1 || l >= w))
668 		return;
669 
670 	w -= l + 2 + 5; /* 2 for |, 5 for percentage + \n */
671 	if (w < 0) {
672 		printf("%4d%%\n", (int)perc);
673 		return;
674 	}
675 
676 	printf("|");
677 
678 	l = w * MIN(100.0, perc) / 100.0;
679 	for (i = 0; i < l; i++)
680 		printf("*");
681 	for (; i < w; i++)
682 		printf(" ");
683 	printf("|%4d%%", (int)perc);
684 
685 	fflush(stdout);
686 }
687 
688 static void
689 fetch_fid(int fid, int fd, const char *name)
690 {
691 	struct progress p = {0};
692 	struct np_stat st;
693 	size_t r;
694 	char buf[BUFSIZ];
695 
696 	do_stat(fid, &st);
697 	do_open(fid, KOREAD);
698 
699 	p.max = st.length;
700 	for (;;) {
701 		size_t off;
702 		ssize_t nw;
703 
704 		r = do_read(fid, p.done, sizeof(buf), buf);
705 		if (r == 0)
706 			break;
707 
708 		for (off = 0; off < r; off += nw)
709 			if ((nw = write(fd, buf + off, r - off)) == 0 ||
710 			    nw == -1)
711 				err(1, "write");
712 
713 		p.done += r;
714 		draw_progress(name, &p);
715 
716 #if 0
717 		/* throttle, for debugging purpose */
718 		{
719 			struct timespec ts = { 0, 500000000 };
720 			nanosleep(&ts, NULL);
721 		}
722 #endif
723 	}
724 
725 	putchar('\n');
726 
727 	do_clunk(fid);
728 }
729 
730 static void
731 send_fid(int fid, const char *fnam, int open_flags, int fd, const char *name)
732 {
733 	struct progress p = {0};
734 	struct stat sb;
735 	ssize_t r;
736 	size_t w;
737 	char buf[BUFSIZ];
738 
739 	if (fstat(fd, &sb) == -1)
740 		err(1, "fstat");
741 
742 	if (fnam != NULL)
743 		do_create(fid, fnam, 0644, KOWRITE);
744 	else
745 		do_open(fid, open_flags | KOWRITE);
746 
747 	p.max = sb.st_size;
748 	for (;;) {
749 		r = read(fd, buf, sizeof(buf));
750 		if (r == 0)
751 			break;
752 		if (r == -1)
753 			err(1, "read");
754 
755 		w = do_write(fid, p.done, r, buf);
756 		p.done += w;
757 
758 		draw_progress(name, &p);
759 
760 #if 0
761 		/* throttle, for debugging purpose */
762 		{
763 			struct timespec ts = { 0, 500000000 };
764 			nanosleep(&ts, NULL);
765 		}
766 #endif
767 	}
768 
769 	putchar('\n');
770 	do_clunk(fid);
771 }
772 
773 static int
774 woc_file(int fd, const char *prompt, const char *path)
775 {
776 	struct qid qid;
777 	const char *n = NULL;
778 	char *errstr;
779 	int nfid, miss;
780 
781 	nfid = nextfid();
782 	errstr = walk_path(pwdfid, nfid, path, &miss, &qid);
783 	if (errstr != NULL && miss > 1) {
784 		printf("%s: %s\n", path, errstr);
785 		free(errstr);
786 		return -1;
787 	}
788 
789 	if (errstr != NULL || miss == 1) {
790 		char p[PATH_MAX], *dn;
791 
792 		/*
793 		 * If it's only one component missing (the file name), walk
794 		 * to the parent directory and try to create the file.
795 		 */
796 
797 		if (strlcpy(p, path, sizeof(p)) >= sizeof(p)) {
798 			printf("path too long: %s\n", path);
799 			return -1;
800 		}
801 		dn = dirname(p);
802 
803 		if (!strcmp(dn, ".")) {
804 			errstr = dup_fid(pwdfid, nfid);
805 			miss = 0;
806 		} else
807 			errstr = walk_path(pwdfid, nfid, dn, &miss, &qid);
808 
809 		if (errstr != NULL) {
810 			printf("%s: %s\n", dn, errstr);
811 			free(errstr);
812 			return -1;
813 		}
814 
815 		if (miss != 0) {
816 			printf("%s: not a directory\n", dn);
817 			return -1;
818 		}
819 
820 		if ((n = strrchr(path, '/')) != NULL)
821 			n++;
822 		else
823 			n = path;
824 	}
825 
826 	free(errstr);
827 
828 	if (miss > 1) {
829 		printf("can't create %s: missing %d path component(s)\n",
830 		    path, miss);
831 		return -1;
832 	}
833 
834 	send_fid(nfid, n, KOTRUNC, fd, prompt);
835 	return 0;
836 }
837 
838 static void
839 do_tls_connect(const char *host, const char *port)
840 {
841 	int handshake;
842 
843 	if ((tlsconf = tls_config_new()) == NULL)
844 		fatalx("tls_config_new");
845 	tls_config_insecure_noverifycert(tlsconf);
846 	tls_config_insecure_noverifyname(tlsconf);
847 	if (tls_config_set_keypair_file(tlsconf, crtpath, keypath) == -1)
848 		fatalx("can't load certs (%s, %s)", crtpath, keypath);
849 
850 	if ((ctx = tls_client()) == NULL)
851 		fatal("tls_client");
852 	if (tls_configure(ctx, tlsconf) == -1)
853 		fatalx("tls_configure: %s", tls_error(ctx));
854 
855 	if (tls_connect(ctx, host, port) == -1)
856 		fatalx("can't connect to %s:%s: %s", host, port,
857 		    tls_error(ctx));
858 
859 	for (handshake = 0; !handshake;) {
860 		switch (tls_handshake(ctx)) {
861 		case -1:
862 			fatalx("tls_handshake: %s", tls_error(ctx));
863 		case 0:
864 			handshake = 1;
865 			break;
866 		}
867 	}
868 }
869 
870 static void
871 do_ctxt_connect(const char *host, const char *port)
872 {
873 	struct addrinfo hints, *res, *res0;
874 	int error, saved_errno;
875 	const char *cause = NULL;
876 
877 	memset(&hints, 0, sizeof(hints));
878 	hints.ai_family = AF_UNSPEC;
879 	hints.ai_socktype = SOCK_STREAM;
880 	error = getaddrinfo(host, port, &hints, &res0);
881 	if (error)
882 		errx(1, "%s", gai_strerror(error));
883 
884 	sock = -1;
885 	for (res = res0; res != NULL; res = res->ai_next) {
886 		sock = socket(res->ai_family, res->ai_socktype|SOCK_CLOEXEC,
887 		    res->ai_protocol);
888 		if (sock == -1) {
889 			cause = "socket";
890 			continue;
891 		}
892 
893 		if (connect(sock, res->ai_addr, res->ai_addrlen) == -1) {
894 			cause = "connect";
895 			saved_errno = errno;
896 			close(sock);
897 			errno = saved_errno;
898 			sock = -1;
899 			continue;
900 		}
901 
902 		break;
903 	}
904 
905 	if (sock == -1)
906 		err(1, "%s", cause);
907 	freeaddrinfo(res0);
908 }
909 
910 static void
911 do_connect(const char *connspec, const char *path)
912 {
913 	char *host, *colon;
914 	const char *port;
915 
916 	host = xstrdup(connspec);
917 	if ((colon = strchr(host, ':')) != NULL) {
918 		*colon = '\0';
919 		port = ++colon;
920 	} else
921 		port = "1337";
922 
923 	printf("connecting to %s:%s...", host, port);
924 	fflush(stdout);
925 
926 	if (tls)
927 		do_tls_connect(host, port);
928 	else
929 		do_ctxt_connect(host, port);
930 
931 	printf(" done!\n");
932 
933 	do_version();
934 	do_attach(path);
935 
936 	free(host);
937 }
938 
939 static int
940 tmp_file(char sfn[TMPFSTRLEN])
941 {
942 	int tmpfd;
943 
944 	strlcpy(sfn, TMPFSTR, TMPFSTRLEN);
945 	if ((tmpfd = mkstemp(sfn)) == -1) {
946 		warn("mkstemp %s", sfn);
947 		return -1;
948 	}
949 
950 	/* set the close-on-exec flag */
951 	if (fcntl(tmpfd, F_SETFD, FD_CLOEXEC) == -1) {
952 		warn("fcntl");
953 		close(tmpfd);
954 		return -1;
955 	}
956 
957 	return tmpfd;
958 }
959 
960 static inline const char *
961 pp_perm(uint8_t x)
962 {
963 	switch (x & 0x7) {
964 	case 0x0:
965 		return "---";
966 	case 0x1:
967 		return "--x";
968 	case 0x2:
969 		return "-w-";
970 	case 0x3:
971 		return "-wx";
972 	case 0x4:
973 		return "r--";
974 	case 0x5:
975 		return "r-x";
976 	case 0x6:
977 		return "rw-";
978 	case 0x7:
979 		return "rwx";
980 	default:
981 		/* unreachable, just for the compiler' happiness */
982 		return "???";
983 	}
984 }
985 
986 static inline void
987 prepare_wstat(struct np_stat *st)
988 {
989 	memset(st, 0xFF, sizeof(*st));
990 	st->name = NULL;
991 	st->uid = NULL;
992 	st->gid = NULL;
993 	st->muid = NULL;
994 }
995 
996 static void
997 cmd_bell(int argc, const char **argv)
998 {
999 	if (argc == 0) {
1000 		bell = !bell;
1001 		if (bell)
1002 			puts("bell mode enabled");
1003 		else
1004 			puts("bell mode disabled");
1005 		return;
1006 	}
1007 
1008 	if (argc != 1)
1009 		goto usage;
1010 
1011 	if (!strcmp(*argv, "on")) {
1012 		bell = 1;
1013 		puts("bell mode enabled");
1014 		return;
1015 	}
1016 
1017 	if (!strcmp(*argv, "off")) {
1018 		bell = 0;
1019 		puts("bell mode disabled");
1020 		return;
1021 	}
1022 
1023 usage:
1024 	printf("bell [on | off]\n");
1025 }
1026 
1027 static void
1028 cmd_bye(int argc, const char **argv)
1029 {
1030 	log_warnx("bye\n");
1031 	exit(0);
1032 }
1033 
1034 static void
1035 cmd_cd(int argc, const char **argv)
1036 {
1037 	struct qid qid;
1038 	int nfid, miss;
1039 	char *errstr;
1040 
1041 	if (argc != 1) {
1042 		printf("usage: cd remote-path\n");
1043 		return;
1044 	}
1045 
1046 	nfid = nextfid();
1047 	errstr = walk_path(pwdfid, nfid, argv[0], &miss, &qid);
1048 	if (errstr != NULL) {
1049 		printf("%s: %s\n", argv[0], errstr);
1050 		free(errstr);
1051 		return;
1052 	}
1053 
1054 	if (miss != 0 || !(qid.type & QTDIR)) {
1055 		printf("%s: not a directory\n", argv[0]);
1056 		if (miss == 0)
1057 			do_clunk(nfid);
1058 		return;
1059 	}
1060 
1061 	do_clunk(pwdfid);
1062 	pwdfid = nfid;
1063 }
1064 
1065 static void
1066 cmd_edit(int argc, const char **argv)
1067 {
1068 	struct qid qid;
1069 	int nfid, tmpfd, miss;
1070 	char sfn[TMPFSTRLEN], p[PATH_MAX], *name, *errstr;
1071 	const char *ed;
1072 
1073 	if (argc != 1) {
1074 		puts("usage: edit file");
1075 		return;
1076 	}
1077 
1078 	if ((ed = getenv("VISUAL")) == NULL &&
1079 	    (ed = getenv("EDITOR")) == NULL)
1080 		ed = "ed";
1081 
1082 	nfid = nextfid();
1083 	errstr = walk_path(pwdfid, nfid, *argv, &miss, &qid);
1084 	if (errstr != NULL) {
1085 		printf("%s: %s\n", *argv, errstr);
1086 		free(errstr);
1087 		return;
1088 	}
1089 
1090 	if (miss != 0 || qid.type != 0) {
1091 		printf("%s: not a file\n", *argv);
1092 		if (miss == 0)
1093 			do_clunk(nfid);
1094 		return;
1095 	}
1096 
1097 	if ((tmpfd = tmp_file(sfn)) == -1) {
1098 		do_clunk(nfid);
1099 		return;
1100 	}
1101 
1102 	strlcpy(p, *argv, sizeof(p));
1103 	name = basename(p);
1104 
1105 	fetch_fid(nfid, tmpfd, name);
1106 	close(tmpfd);
1107 
1108 	spawn(ed, sfn, NULL);
1109 
1110 	/*
1111 	 * Re-open the file because it's not guaranteed that the
1112 	 * file descriptor tmpfd is still associated with the file
1113 	 * pointed by sfn: it's not uncommon for editor to write
1114 	 * a backup file and then rename(2) it to the file name.
1115 	 */
1116 	if ((tmpfd = open(sfn, O_RDONLY)) == -1) {
1117 		warn("can't open %s", sfn);
1118 		goto end;
1119 	}
1120 
1121 	woc_file(tmpfd, *argv, name);
1122 	close(tmpfd);
1123 
1124 end:
1125 	unlink(sfn);
1126 }
1127 
1128 static void
1129 cmd_get(int argc, const char **argv)
1130 {
1131 	struct qid qid;
1132 	const char *l;
1133 	char *errstr;
1134 	int nfid, fd, miss;
1135 
1136 	if (argc != 1 && argc != 2) {
1137 		printf("usage: get remote-file [local-file]\n");
1138 		return;
1139 	}
1140 
1141 	if (argc == 2)
1142 		l = argv[1];
1143 	else if ((l = strrchr(argv[0], '/')) != NULL)
1144 		l++; /* skip / */
1145 	else
1146 		l = argv[0];
1147 
1148 	nfid = nextfid();
1149 	errstr = walk_path(pwdfid, nfid, argv[0], &miss, &qid);
1150 	if (errstr != NULL) {
1151 		printf("%s: %s\n", argv[0], errstr);
1152 		free(errstr);
1153 		return;
1154 	}
1155 
1156 	if (miss != 0 || qid.type != 0) {
1157 		printf("%s: not a file\n", argv[0]);
1158 		if (miss == 0)
1159 			do_clunk(nfid);
1160 		return;
1161 	}
1162 
1163 	if ((fd = open(l, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, 0644)) == -1) {
1164 		warn("can't open %s", l);
1165 		do_clunk(nfid);
1166 		return;
1167 	}
1168 
1169 	fetch_fid(nfid, fd, l);
1170 	close(fd);
1171 }
1172 
1173 static void
1174 cmd_hexdump(int argc, const char **argv)
1175 {
1176 	if (argc == 0) {
1177 		xdump = !xdump;
1178 		if (xdump)
1179 			puts("hexdump mode enabled");
1180 		else
1181 			puts("hexdump mode disabled");
1182 		return;
1183 	}
1184 
1185 	if (argc > 1)
1186 		goto usage;
1187 
1188 	if (!strcmp(*argv, "on")) {
1189 		xdump = 1;
1190 		puts("hexdump mode enabled");
1191 		return;
1192 	}
1193 
1194 	if (!strcmp(*argv, "off")) {
1195 		xdump = 0;
1196 		puts("hexdump mode disabled");
1197 		return;
1198 	}
1199 
1200 usage:
1201 	puts("usage: hexdump [on | off]");
1202 }
1203 
1204 static void
1205 cmd_lcd(int argc, const char **argv)
1206 {
1207 	const char *dir;
1208 
1209 	if (argc > 1) {
1210 		printf("usage: lcd [local-directory]\n");
1211 		return;
1212 	}
1213 
1214 	if (argc == 1)
1215 		dir = *argv;
1216 
1217 	if (argc == 0 && (dir = getenv("HOME")) == NULL) {
1218 		printf("HOME is not defined\n");
1219 		return;
1220 	}
1221 
1222 	if (chdir(dir) == -1)
1223 		printf("cd: %s: %s\n", dir, strerror(errno));
1224 }
1225 
1226 static void
1227 cmd_lpwd(int argc, const char **argv)
1228 {
1229 	char path[PATH_MAX];
1230 
1231 	if (argc != 0) {
1232 		printf("usage: lpwd\n");
1233 		return;
1234 	}
1235 
1236 	if (getcwd(path, sizeof(path)) == NULL) {
1237 		printf("lpwd: %s\n", strerror(errno));
1238 		return;
1239 	}
1240 
1241 	printf("%s\n", path);
1242 }
1243 
1244 static void
1245 cmd_ls(int argc, const char **argv)
1246 {
1247 	struct np_stat st;
1248 	time_t now, mtime;
1249 	struct tm *tm;
1250 	uint64_t off = 0;
1251 	uint32_t len;
1252 	int nfid;
1253 	const char *timfmt;
1254 	char fmt[FMT_SCALED_STRSIZE], tim[13], *errstr;
1255 
1256 	if (argc != 0) {
1257 		printf("ls don't take arguments (yet)\n");
1258 		return;
1259 	}
1260 
1261 	now = time(NULL);
1262 
1263 	nfid = nextfid();
1264 	if ((errstr = dup_fid(pwdfid, nfid)) != NULL) {
1265 		printf(".: %s\n", errstr);
1266 		free(errstr);
1267 		return;
1268 	}
1269 
1270 	do_open(nfid, KOREAD);
1271 
1272 	evbuffer_drain(dirbuf, EVBUFFER_LENGTH(dirbuf));
1273 
1274 	for (;;) {
1275 		tread(nfid, off, BUFSIZ);
1276 		do_send();
1277 		recv_msg();
1278 		expect2(Rread, iota_tag);
1279 
1280 		len = np_read32(buf);
1281 		if (len == 0)
1282 			break;
1283 
1284 		evbuffer_add_buffer(dirbuf, buf);
1285 		off += len;
1286 
1287 		ASSERT_EMPTYBUF();
1288 	}
1289 
1290 	while (EVBUFFER_LENGTH(dirbuf) != 0) {
1291 		if (np_read_stat(dirbuf, &st) == -1)
1292 			errx(1, "invalid stat struct read");
1293 
1294 		if (fmt_scaled(st.length, fmt) == -1)
1295 			strlcpy(fmt, "xxx", sizeof(fmt));
1296 
1297 		mtime = st.mtime;
1298 
1299 		if (now > mtime && (now - mtime) < 365/2 * 24 * 12 * 60)
1300 			timfmt = "%b %e %R";
1301 		else
1302 			timfmt = "%b %e  %Y";
1303 
1304 		if ((tm = localtime(&mtime)) == NULL ||
1305 		    strftime(tim, sizeof(tim), timfmt, tm) == 0)
1306 			strlcpy(tim, "unknown", sizeof(tim));
1307 
1308 		if (st.qid.type & QTDIR)
1309 			printf("d");
1310 		else
1311 			printf("-");
1312 		printf("%s", pp_perm(st.mode >> 6));
1313 		printf("%s", pp_perm(st.mode >> 3));
1314 		printf("%s", pp_perm(st.mode));
1315 		printf(" %8s %12s %s%s\n", fmt, tim, st.name,
1316 		    st.qid.type & QTDIR ? "/" : "");
1317 
1318 		free(st.name);
1319 		free(st.uid);
1320 		free(st.gid);
1321 		free(st.muid);
1322 	}
1323 
1324 	do_clunk(nfid);
1325 }
1326 
1327 static void
1328 cmd_page(int argc, const char **argv)
1329 {
1330 	struct qid qid;
1331 	int nfid, tmpfd, miss;
1332 	char sfn[TMPFSTRLEN], p[PATH_MAX], *name, *errstr;
1333 	const char *pager;
1334 
1335 	if (argc != 1) {
1336 		puts("usage: page file");
1337 		return;
1338 	}
1339 
1340 	if ((pager = getenv("PAGER")) == NULL)
1341 		pager = "less";
1342 
1343 	nfid = nextfid();
1344 	errstr = walk_path(pwdfid, nfid, *argv, &miss, &qid);
1345 	if (errstr != NULL) {
1346 		printf("%s: %s\n", *argv, errstr);
1347 		free(errstr);
1348 		return;
1349 	}
1350 
1351 	if (miss != 0 || qid.type != 0) {
1352 		printf("%s: not a file\n", *argv);
1353 		if (miss == 0)
1354 			do_clunk(nfid);
1355 		return;
1356 	}
1357 
1358 	if ((tmpfd = tmp_file(sfn)) == -1) {
1359 		do_clunk(nfid);
1360 		return;
1361 	}
1362 
1363 	strlcpy(p, *argv, sizeof(p));
1364 	name = basename(p);
1365 	fetch_fid(nfid, tmpfd, name);
1366 	close(tmpfd);
1367 	spawn(pager, sfn, NULL);
1368 	unlink(sfn);
1369 }
1370 
1371 static void
1372 cmd_put(int argc, const char **argv)
1373 {
1374 	struct qid qid;
1375 	const char *l;
1376 	int fd;
1377 
1378 	if (argc != 1 && argc != 2) {
1379 		printf("usage: put local-file [remote-file]\n");
1380 		return;
1381 	}
1382 
1383 	if (argc == 2)
1384 		l = argv[1];
1385 	else if ((l = strrchr(argv[0], '/')) != NULL)
1386 		l++; /* skip / */
1387 	else
1388 		l = argv[0];
1389 
1390 	if ((fd = open(argv[0], O_RDONLY)) == -1) {
1391 		warn("%s", argv[0]);
1392 		return;
1393 	}
1394 
1395 	woc_file(fd, argv[0], l);
1396 	close(fd);
1397 }
1398 
1399 static void
1400 cmd_rename(int argc, const char **argv)
1401 {
1402 	struct np_stat st;
1403 	struct qid qid;
1404 	char *errstr;
1405 	int nfid, miss;
1406 
1407 	if (argc != 2) {
1408 		puts("usage: rename remote-file new-remote-name");
1409 		return;
1410 	}
1411 
1412 	nfid = nextfid();
1413 	errstr = walk_path(pwdfid, nfid, argv[0], &miss, &qid);
1414 	if (errstr != NULL) {
1415 		printf("%s: %s\n", argv[0], errstr);
1416 		free(errstr);
1417 		return;
1418 	}
1419 
1420 	if (miss != 0) {
1421 		printf("%s: not such file or directory\n", argv[0]);
1422 		return;
1423 	}
1424 
1425 	prepare_wstat(&st);
1426 	st.name = (char *)argv[1];
1427 	if ((errstr = do_wstat(nfid, &st)) != NULL) {
1428 		printf("rename: %s\n", errstr);
1429 		free(errstr);
1430 	}
1431 
1432 	do_clunk(nfid);
1433 }
1434 
1435 static void
1436 cmd_verbose(int argc, const char **argv)
1437 {
1438 	if (argc == 0) {
1439 		log_setverbose(!log_getverbose());
1440 		if (log_getverbose())
1441 			puts("verbose mode enabled");
1442 		else
1443 			puts("verbose mode disabled");
1444 		return;
1445 	}
1446 
1447 	if (argc != 1)
1448 		goto usage;
1449 
1450 	if (!strcmp(*argv, "on")) {
1451 		log_setverbose(1);
1452 		puts("verbose mode enabled");
1453 		return;
1454 	}
1455 
1456 	if (!strcmp(*argv, "off")) {
1457 		log_setverbose(0);
1458 		puts("verbose mode disabled");
1459 		return;
1460 	}
1461 
1462 usage:
1463 	printf("verbose [on | off]\n");
1464 }
1465 
1466 static void
1467 excmd(int argc, const char **argv)
1468 {
1469 	struct cmd {
1470 		const char	*name;
1471 		void		(*fn)(int, const char **);
1472 	} cmds[] = {
1473 		{"bell",	cmd_bell},
1474 		{"bye",		cmd_bye},
1475 		{"cd",		cmd_cd},
1476 		{"edit",	cmd_edit},
1477 		{"get",		cmd_get},
1478 		{"hexdump",	cmd_hexdump},
1479 		{"lcd",		cmd_lcd},
1480 		{"lpwd",	cmd_lpwd},
1481 		{"ls",		cmd_ls},
1482 		{"page",	cmd_page},
1483 		{"put",		cmd_put},
1484 		{"quit",	cmd_bye},
1485 		{"rename",	cmd_rename},
1486 		{"verbose",	cmd_verbose},
1487 	};
1488 	size_t i;
1489 
1490 	if (argc == 0)
1491 		return;
1492 	for (i = 0; i < nitems(cmds); ++i) {
1493 		if (!strcmp(cmds[i].name, *argv)) {
1494 			cmds[i].fn(argc-1, argv+1);
1495 			return;
1496 		}
1497 	}
1498 
1499 	log_warnx("unknown command %s", *argv);
1500 }
1501 
1502 int
1503 main(int argc, char **argv)
1504 {
1505 	int	ch;
1506 
1507 	log_init(1, LOG_DAEMON);
1508 	log_setverbose(0);
1509 	log_procinit(getprogname());
1510 
1511 	while ((ch = getopt(argc, argv, "C:cK:")) != -1) {
1512 		switch (ch) {
1513 		case 'C':
1514 			crtpath = optarg;
1515 			break;
1516 		case 'c':
1517 			tls = 1;
1518 			break;
1519 		case 'K':
1520 			keypath = optarg;
1521 			break;
1522 		default:
1523 			usage(1);
1524 		}
1525 	}
1526 	argc -= optind;
1527 	argv += optind;
1528 
1529 	if (argc == 0)
1530 		usage(1);
1531 
1532 	if (isatty(1)) {
1533 		tty_p = 1;
1534 		resized = 1;
1535 		signal(SIGWINCH, tty_resized);
1536 	}
1537 
1538 	if ((evb = evbuffer_new()) == NULL)
1539 		fatal("evbuffer_new");
1540 
1541 	if ((buf = evbuffer_new()) == NULL)
1542 		fatal("evbuffer_new");
1543 
1544 	if ((dirbuf = evbuffer_new()) == NULL)
1545 		fatal("evbuferr_new");
1546 
1547 	do_connect(argv[0], argv[1]);
1548 
1549 	for (;;) {
1550 		int argc = 0;
1551 		char *line, *argv[16] = {0}, **ap;
1552 
1553 		if ((line = read_line("kamiftp> ")) == NULL)
1554 			break;
1555 
1556 		for (argc = 0, ap = argv; ap < &argv[15] &&
1557 		    (*ap = strsep(&line, " \t")) != NULL;) {
1558 			if (**ap != '\0')
1559 				ap++, argc++;
1560 		}
1561 		excmd(argc, (const char **)argv);
1562 
1563 		if (bell) {
1564 			printf("\a");
1565 			fflush(stdout);
1566 		}
1567 
1568 		free(line);
1569 	}
1570 
1571 	printf("\n");
1572 }