op public repos

Blob

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