xref: /openssh-portable/sftp.c (revision de37ca90)
1 /* $OpenBSD: sftp.c,v 1.186 2018/09/07 04:26:56 dtucker Exp $ */
2 /*
3  * Copyright (c) 2001-2004 Damien Miller <djm@openbsd.org>
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include "includes.h"
19 
20 #include <sys/types.h>
21 #include <sys/ioctl.h>
22 #ifdef HAVE_SYS_STAT_H
23 # include <sys/stat.h>
24 #endif
25 #include <sys/param.h>
26 #include <sys/socket.h>
27 #include <sys/wait.h>
28 #ifdef HAVE_SYS_STATVFS_H
29 #include <sys/statvfs.h>
30 #endif
31 
32 #include <ctype.h>
33 #include <errno.h>
34 
35 #ifdef HAVE_PATHS_H
36 # include <paths.h>
37 #endif
38 #ifdef HAVE_LIBGEN_H
39 #include <libgen.h>
40 #endif
41 #ifdef HAVE_LOCALE_H
42 # include <locale.h>
43 #endif
44 #ifdef USE_LIBEDIT
45 #include <histedit.h>
46 #else
47 typedef void EditLine;
48 #endif
49 #include <limits.h>
50 #include <signal.h>
51 #include <stdarg.h>
52 #include <stdlib.h>
53 #include <stdio.h>
54 #include <string.h>
55 #include <unistd.h>
56 #include <stdarg.h>
57 
58 #ifdef HAVE_UTIL_H
59 # include <util.h>
60 #endif
61 
62 #include "xmalloc.h"
63 #include "log.h"
64 #include "pathnames.h"
65 #include "misc.h"
66 #include "utf8.h"
67 
68 #include "sftp.h"
69 #include "ssherr.h"
70 #include "sshbuf.h"
71 #include "sftp-common.h"
72 #include "sftp-client.h"
73 
74 #define DEFAULT_COPY_BUFLEN	32768	/* Size of buffer for up/download */
75 #define DEFAULT_NUM_REQUESTS	64	/* # concurrent outstanding requests */
76 
77 /* File to read commands from */
78 FILE* infile;
79 
80 /* Are we in batchfile mode? */
81 int batchmode = 0;
82 
83 /* PID of ssh transport process */
84 static volatile pid_t sshpid = -1;
85 
86 /* Suppress diagnositic messages */
87 int quiet = 0;
88 
89 /* This is set to 0 if the progressmeter is not desired. */
90 int showprogress = 1;
91 
92 /* When this option is set, we always recursively download/upload directories */
93 int global_rflag = 0;
94 
95 /* When this option is set, we resume download or upload if possible */
96 int global_aflag = 0;
97 
98 /* When this option is set, the file transfers will always preserve times */
99 int global_pflag = 0;
100 
101 /* When this option is set, transfers will have fsync() called on each file */
102 int global_fflag = 0;
103 
104 /* SIGINT received during command processing */
105 volatile sig_atomic_t interrupted = 0;
106 
107 /* I wish qsort() took a separate ctx for the comparison function...*/
108 int sort_flag;
109 glob_t *sort_glob;
110 
111 /* Context used for commandline completion */
112 struct complete_ctx {
113 	struct sftp_conn *conn;
114 	char **remote_pathp;
115 };
116 
117 int remote_glob(struct sftp_conn *, const char *, int,
118     int (*)(const char *, int), glob_t *); /* proto for sftp-glob.c */
119 
120 extern char *__progname;
121 
122 /* Separators for interactive commands */
123 #define WHITESPACE " \t\r\n"
124 
125 /* ls flags */
126 #define LS_LONG_VIEW	0x0001	/* Full view ala ls -l */
127 #define LS_SHORT_VIEW	0x0002	/* Single row view ala ls -1 */
128 #define LS_NUMERIC_VIEW	0x0004	/* Long view with numeric uid/gid */
129 #define LS_NAME_SORT	0x0008	/* Sort by name (default) */
130 #define LS_TIME_SORT	0x0010	/* Sort by mtime */
131 #define LS_SIZE_SORT	0x0020	/* Sort by file size */
132 #define LS_REVERSE_SORT	0x0040	/* Reverse sort order */
133 #define LS_SHOW_ALL	0x0080	/* Don't skip filenames starting with '.' */
134 #define LS_SI_UNITS	0x0100	/* Display sizes as K, M, G, etc. */
135 
136 #define VIEW_FLAGS	(LS_LONG_VIEW|LS_SHORT_VIEW|LS_NUMERIC_VIEW|LS_SI_UNITS)
137 #define SORT_FLAGS	(LS_NAME_SORT|LS_TIME_SORT|LS_SIZE_SORT)
138 
139 /* Commands for interactive mode */
140 enum sftp_command {
141 	I_CHDIR = 1,
142 	I_CHGRP,
143 	I_CHMOD,
144 	I_CHOWN,
145 	I_DF,
146 	I_GET,
147 	I_HELP,
148 	I_LCHDIR,
149 	I_LINK,
150 	I_LLS,
151 	I_LMKDIR,
152 	I_LPWD,
153 	I_LS,
154 	I_LUMASK,
155 	I_MKDIR,
156 	I_PUT,
157 	I_PWD,
158 	I_QUIT,
159 	I_REGET,
160 	I_RENAME,
161 	I_REPUT,
162 	I_RM,
163 	I_RMDIR,
164 	I_SHELL,
165 	I_SYMLINK,
166 	I_VERSION,
167 	I_PROGRESS,
168 };
169 
170 struct CMD {
171 	const char *c;
172 	const int n;
173 	const int t;
174 };
175 
176 /* Type of completion */
177 #define NOARGS	0
178 #define REMOTE	1
179 #define LOCAL	2
180 
181 static const struct CMD cmds[] = {
182 	{ "bye",	I_QUIT,		NOARGS	},
183 	{ "cd",		I_CHDIR,	REMOTE	},
184 	{ "chdir",	I_CHDIR,	REMOTE	},
185 	{ "chgrp",	I_CHGRP,	REMOTE	},
186 	{ "chmod",	I_CHMOD,	REMOTE	},
187 	{ "chown",	I_CHOWN,	REMOTE	},
188 	{ "df",		I_DF,		REMOTE	},
189 	{ "dir",	I_LS,		REMOTE	},
190 	{ "exit",	I_QUIT,		NOARGS	},
191 	{ "get",	I_GET,		REMOTE	},
192 	{ "help",	I_HELP,		NOARGS	},
193 	{ "lcd",	I_LCHDIR,	LOCAL	},
194 	{ "lchdir",	I_LCHDIR,	LOCAL	},
195 	{ "lls",	I_LLS,		LOCAL	},
196 	{ "lmkdir",	I_LMKDIR,	LOCAL	},
197 	{ "ln",		I_LINK,		REMOTE	},
198 	{ "lpwd",	I_LPWD,		LOCAL	},
199 	{ "ls",		I_LS,		REMOTE	},
200 	{ "lumask",	I_LUMASK,	NOARGS	},
201 	{ "mkdir",	I_MKDIR,	REMOTE	},
202 	{ "mget",	I_GET,		REMOTE	},
203 	{ "mput",	I_PUT,		LOCAL	},
204 	{ "progress",	I_PROGRESS,	NOARGS	},
205 	{ "put",	I_PUT,		LOCAL	},
206 	{ "pwd",	I_PWD,		REMOTE	},
207 	{ "quit",	I_QUIT,		NOARGS	},
208 	{ "reget",	I_REGET,	REMOTE	},
209 	{ "rename",	I_RENAME,	REMOTE	},
210 	{ "reput",	I_REPUT,	LOCAL	},
211 	{ "rm",		I_RM,		REMOTE	},
212 	{ "rmdir",	I_RMDIR,	REMOTE	},
213 	{ "symlink",	I_SYMLINK,	REMOTE	},
214 	{ "version",	I_VERSION,	NOARGS	},
215 	{ "!",		I_SHELL,	NOARGS	},
216 	{ "?",		I_HELP,		NOARGS	},
217 	{ NULL,		-1,		-1	}
218 };
219 
220 /* ARGSUSED */
221 static void
222 killchild(int signo)
223 {
224 	if (sshpid > 1) {
225 		kill(sshpid, SIGTERM);
226 		waitpid(sshpid, NULL, 0);
227 	}
228 
229 	_exit(1);
230 }
231 
232 /* ARGSUSED */
233 static void
234 suspchild(int signo)
235 {
236 	if (sshpid > 1) {
237 		kill(sshpid, signo);
238 		while (waitpid(sshpid, NULL, WUNTRACED) == -1 && errno == EINTR)
239 			continue;
240 	}
241 	kill(getpid(), SIGSTOP);
242 }
243 
244 /* ARGSUSED */
245 static void
246 cmd_interrupt(int signo)
247 {
248 	const char msg[] = "\rInterrupt  \n";
249 	int olderrno = errno;
250 
251 	(void)write(STDERR_FILENO, msg, sizeof(msg) - 1);
252 	interrupted = 1;
253 	errno = olderrno;
254 }
255 
256 /*ARGSUSED*/
257 static void
258 sigchld_handler(int sig)
259 {
260 	int save_errno = errno;
261 	pid_t pid;
262 	const char msg[] = "\rConnection closed.  \n";
263 
264 	/* Report if ssh transport process dies. */
265 	while ((pid = waitpid(sshpid, NULL, WNOHANG)) == -1 && errno == EINTR)
266 		continue;
267 	if (pid == sshpid) {
268 		(void)write(STDERR_FILENO, msg, sizeof(msg) - 1);
269 		sshpid = -1;
270 	}
271 
272 	errno = save_errno;
273 }
274 
275 static void
276 help(void)
277 {
278 	printf("Available commands:\n"
279 	    "bye                                Quit sftp\n"
280 	    "cd path                            Change remote directory to 'path'\n"
281 	    "chgrp grp path                     Change group of file 'path' to 'grp'\n"
282 	    "chmod mode path                    Change permissions of file 'path' to 'mode'\n"
283 	    "chown own path                     Change owner of file 'path' to 'own'\n"
284 	    "df [-hi] [path]                    Display statistics for current directory or\n"
285 	    "                                   filesystem containing 'path'\n"
286 	    "exit                               Quit sftp\n"
287 	    "get [-afPpRr] remote [local]       Download file\n"
288 	    "reget [-fPpRr] remote [local]      Resume download file\n"
289 	    "reput [-fPpRr] [local] remote      Resume upload file\n"
290 	    "help                               Display this help text\n"
291 	    "lcd path                           Change local directory to 'path'\n"
292 	    "lls [ls-options [path]]            Display local directory listing\n"
293 	    "lmkdir path                        Create local directory\n"
294 	    "ln [-s] oldpath newpath            Link remote file (-s for symlink)\n"
295 	    "lpwd                               Print local working directory\n"
296 	    "ls [-1afhlnrSt] [path]             Display remote directory listing\n"
297 	    "lumask umask                       Set local umask to 'umask'\n"
298 	    "mkdir path                         Create remote directory\n"
299 	    "progress                           Toggle display of progress meter\n"
300 	    "put [-afPpRr] local [remote]       Upload file\n"
301 	    "pwd                                Display remote working directory\n"
302 	    "quit                               Quit sftp\n"
303 	    "rename oldpath newpath             Rename remote file\n"
304 	    "rm path                            Delete remote file\n"
305 	    "rmdir path                         Remove remote directory\n"
306 	    "symlink oldpath newpath            Symlink remote file\n"
307 	    "version                            Show SFTP version\n"
308 	    "!command                           Execute 'command' in local shell\n"
309 	    "!                                  Escape to local shell\n"
310 	    "?                                  Synonym for help\n");
311 }
312 
313 static void
314 local_do_shell(const char *args)
315 {
316 	int status;
317 	char *shell;
318 	pid_t pid;
319 
320 	if (!*args)
321 		args = NULL;
322 
323 	if ((shell = getenv("SHELL")) == NULL || *shell == '\0')
324 		shell = _PATH_BSHELL;
325 
326 	if ((pid = fork()) == -1)
327 		fatal("Couldn't fork: %s", strerror(errno));
328 
329 	if (pid == 0) {
330 		/* XXX: child has pipe fds to ssh subproc open - issue? */
331 		if (args) {
332 			debug3("Executing %s -c \"%s\"", shell, args);
333 			execl(shell, shell, "-c", args, (char *)NULL);
334 		} else {
335 			debug3("Executing %s", shell);
336 			execl(shell, shell, (char *)NULL);
337 		}
338 		fprintf(stderr, "Couldn't execute \"%s\": %s\n", shell,
339 		    strerror(errno));
340 		_exit(1);
341 	}
342 	while (waitpid(pid, &status, 0) == -1)
343 		if (errno != EINTR)
344 			fatal("Couldn't wait for child: %s", strerror(errno));
345 	if (!WIFEXITED(status))
346 		error("Shell exited abnormally");
347 	else if (WEXITSTATUS(status))
348 		error("Shell exited with status %d", WEXITSTATUS(status));
349 }
350 
351 static void
352 local_do_ls(const char *args)
353 {
354 	if (!args || !*args)
355 		local_do_shell(_PATH_LS);
356 	else {
357 		int len = strlen(_PATH_LS " ") + strlen(args) + 1;
358 		char *buf = xmalloc(len);
359 
360 		/* XXX: quoting - rip quoting code from ftp? */
361 		snprintf(buf, len, _PATH_LS " %s", args);
362 		local_do_shell(buf);
363 		free(buf);
364 	}
365 }
366 
367 /* Strip one path (usually the pwd) from the start of another */
368 static char *
369 path_strip(const char *path, const char *strip)
370 {
371 	size_t len;
372 
373 	if (strip == NULL)
374 		return (xstrdup(path));
375 
376 	len = strlen(strip);
377 	if (strncmp(path, strip, len) == 0) {
378 		if (strip[len - 1] != '/' && path[len] == '/')
379 			len++;
380 		return (xstrdup(path + len));
381 	}
382 
383 	return (xstrdup(path));
384 }
385 
386 static char *
387 make_absolute(char *p, const char *pwd)
388 {
389 	char *abs_str;
390 
391 	/* Derelativise */
392 	if (p && p[0] != '/') {
393 		abs_str = path_append(pwd, p);
394 		free(p);
395 		return(abs_str);
396 	} else
397 		return(p);
398 }
399 
400 static int
401 parse_getput_flags(const char *cmd, char **argv, int argc,
402     int *aflag, int *fflag, int *pflag, int *rflag)
403 {
404 	extern int opterr, optind, optopt, optreset;
405 	int ch;
406 
407 	optind = optreset = 1;
408 	opterr = 0;
409 
410 	*aflag = *fflag = *rflag = *pflag = 0;
411 	while ((ch = getopt(argc, argv, "afPpRr")) != -1) {
412 		switch (ch) {
413 		case 'a':
414 			*aflag = 1;
415 			break;
416 		case 'f':
417 			*fflag = 1;
418 			break;
419 		case 'p':
420 		case 'P':
421 			*pflag = 1;
422 			break;
423 		case 'r':
424 		case 'R':
425 			*rflag = 1;
426 			break;
427 		default:
428 			error("%s: Invalid flag -%c", cmd, optopt);
429 			return -1;
430 		}
431 	}
432 
433 	return optind;
434 }
435 
436 static int
437 parse_link_flags(const char *cmd, char **argv, int argc, int *sflag)
438 {
439 	extern int opterr, optind, optopt, optreset;
440 	int ch;
441 
442 	optind = optreset = 1;
443 	opterr = 0;
444 
445 	*sflag = 0;
446 	while ((ch = getopt(argc, argv, "s")) != -1) {
447 		switch (ch) {
448 		case 's':
449 			*sflag = 1;
450 			break;
451 		default:
452 			error("%s: Invalid flag -%c", cmd, optopt);
453 			return -1;
454 		}
455 	}
456 
457 	return optind;
458 }
459 
460 static int
461 parse_rename_flags(const char *cmd, char **argv, int argc, int *lflag)
462 {
463 	extern int opterr, optind, optopt, optreset;
464 	int ch;
465 
466 	optind = optreset = 1;
467 	opterr = 0;
468 
469 	*lflag = 0;
470 	while ((ch = getopt(argc, argv, "l")) != -1) {
471 		switch (ch) {
472 		case 'l':
473 			*lflag = 1;
474 			break;
475 		default:
476 			error("%s: Invalid flag -%c", cmd, optopt);
477 			return -1;
478 		}
479 	}
480 
481 	return optind;
482 }
483 
484 static int
485 parse_ls_flags(char **argv, int argc, int *lflag)
486 {
487 	extern int opterr, optind, optopt, optreset;
488 	int ch;
489 
490 	optind = optreset = 1;
491 	opterr = 0;
492 
493 	*lflag = LS_NAME_SORT;
494 	while ((ch = getopt(argc, argv, "1Safhlnrt")) != -1) {
495 		switch (ch) {
496 		case '1':
497 			*lflag &= ~VIEW_FLAGS;
498 			*lflag |= LS_SHORT_VIEW;
499 			break;
500 		case 'S':
501 			*lflag &= ~SORT_FLAGS;
502 			*lflag |= LS_SIZE_SORT;
503 			break;
504 		case 'a':
505 			*lflag |= LS_SHOW_ALL;
506 			break;
507 		case 'f':
508 			*lflag &= ~SORT_FLAGS;
509 			break;
510 		case 'h':
511 			*lflag |= LS_SI_UNITS;
512 			break;
513 		case 'l':
514 			*lflag &= ~LS_SHORT_VIEW;
515 			*lflag |= LS_LONG_VIEW;
516 			break;
517 		case 'n':
518 			*lflag &= ~LS_SHORT_VIEW;
519 			*lflag |= LS_NUMERIC_VIEW|LS_LONG_VIEW;
520 			break;
521 		case 'r':
522 			*lflag |= LS_REVERSE_SORT;
523 			break;
524 		case 't':
525 			*lflag &= ~SORT_FLAGS;
526 			*lflag |= LS_TIME_SORT;
527 			break;
528 		default:
529 			error("ls: Invalid flag -%c", optopt);
530 			return -1;
531 		}
532 	}
533 
534 	return optind;
535 }
536 
537 static int
538 parse_df_flags(const char *cmd, char **argv, int argc, int *hflag, int *iflag)
539 {
540 	extern int opterr, optind, optopt, optreset;
541 	int ch;
542 
543 	optind = optreset = 1;
544 	opterr = 0;
545 
546 	*hflag = *iflag = 0;
547 	while ((ch = getopt(argc, argv, "hi")) != -1) {
548 		switch (ch) {
549 		case 'h':
550 			*hflag = 1;
551 			break;
552 		case 'i':
553 			*iflag = 1;
554 			break;
555 		default:
556 			error("%s: Invalid flag -%c", cmd, optopt);
557 			return -1;
558 		}
559 	}
560 
561 	return optind;
562 }
563 
564 static int
565 parse_no_flags(const char *cmd, char **argv, int argc)
566 {
567 	extern int opterr, optind, optopt, optreset;
568 	int ch;
569 
570 	optind = optreset = 1;
571 	opterr = 0;
572 
573 	while ((ch = getopt(argc, argv, "")) != -1) {
574 		switch (ch) {
575 		default:
576 			error("%s: Invalid flag -%c", cmd, optopt);
577 			return -1;
578 		}
579 	}
580 
581 	return optind;
582 }
583 
584 static int
585 is_dir(const char *path)
586 {
587 	struct stat sb;
588 
589 	/* XXX: report errors? */
590 	if (stat(path, &sb) == -1)
591 		return(0);
592 
593 	return(S_ISDIR(sb.st_mode));
594 }
595 
596 static int
597 remote_is_dir(struct sftp_conn *conn, const char *path)
598 {
599 	Attrib *a;
600 
601 	/* XXX: report errors? */
602 	if ((a = do_stat(conn, path, 1)) == NULL)
603 		return(0);
604 	if (!(a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS))
605 		return(0);
606 	return(S_ISDIR(a->perm));
607 }
608 
609 /* Check whether path returned from glob(..., GLOB_MARK, ...) is a directory */
610 static int
611 pathname_is_dir(const char *pathname)
612 {
613 	size_t l = strlen(pathname);
614 
615 	return l > 0 && pathname[l - 1] == '/';
616 }
617 
618 static int
619 process_get(struct sftp_conn *conn, const char *src, const char *dst,
620     const char *pwd, int pflag, int rflag, int resume, int fflag)
621 {
622 	char *abs_src = NULL;
623 	char *abs_dst = NULL;
624 	glob_t g;
625 	char *filename, *tmp=NULL;
626 	int i, r, err = 0;
627 
628 	abs_src = xstrdup(src);
629 	abs_src = make_absolute(abs_src, pwd);
630 	memset(&g, 0, sizeof(g));
631 
632 	debug3("Looking up %s", abs_src);
633 	if ((r = remote_glob(conn, abs_src, GLOB_MARK, NULL, &g)) != 0) {
634 		if (r == GLOB_NOSPACE) {
635 			error("Too many matches for \"%s\".", abs_src);
636 		} else {
637 			error("File \"%s\" not found.", abs_src);
638 		}
639 		err = -1;
640 		goto out;
641 	}
642 
643 	/*
644 	 * If multiple matches then dst must be a directory or
645 	 * unspecified.
646 	 */
647 	if (g.gl_matchc > 1 && dst != NULL && !is_dir(dst)) {
648 		error("Multiple source paths, but destination "
649 		    "\"%s\" is not a directory", dst);
650 		err = -1;
651 		goto out;
652 	}
653 
654 	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
655 		tmp = xstrdup(g.gl_pathv[i]);
656 		if ((filename = basename(tmp)) == NULL) {
657 			error("basename %s: %s", tmp, strerror(errno));
658 			free(tmp);
659 			err = -1;
660 			goto out;
661 		}
662 
663 		if (g.gl_matchc == 1 && dst) {
664 			if (is_dir(dst)) {
665 				abs_dst = path_append(dst, filename);
666 			} else {
667 				abs_dst = xstrdup(dst);
668 			}
669 		} else if (dst) {
670 			abs_dst = path_append(dst, filename);
671 		} else {
672 			abs_dst = xstrdup(filename);
673 		}
674 		free(tmp);
675 
676 		resume |= global_aflag;
677 		if (!quiet && resume)
678 			mprintf("Resuming %s to %s\n",
679 			    g.gl_pathv[i], abs_dst);
680 		else if (!quiet && !resume)
681 			mprintf("Fetching %s to %s\n",
682 			    g.gl_pathv[i], abs_dst);
683 		if (pathname_is_dir(g.gl_pathv[i]) && (rflag || global_rflag)) {
684 			if (download_dir(conn, g.gl_pathv[i], abs_dst, NULL,
685 			    pflag || global_pflag, 1, resume,
686 			    fflag || global_fflag) == -1)
687 				err = -1;
688 		} else {
689 			if (do_download(conn, g.gl_pathv[i], abs_dst, NULL,
690 			    pflag || global_pflag, resume,
691 			    fflag || global_fflag) == -1)
692 				err = -1;
693 		}
694 		free(abs_dst);
695 		abs_dst = NULL;
696 	}
697 
698 out:
699 	free(abs_src);
700 	globfree(&g);
701 	return(err);
702 }
703 
704 static int
705 process_put(struct sftp_conn *conn, const char *src, const char *dst,
706     const char *pwd, int pflag, int rflag, int resume, int fflag)
707 {
708 	char *tmp_dst = NULL;
709 	char *abs_dst = NULL;
710 	char *tmp = NULL, *filename = NULL;
711 	glob_t g;
712 	int err = 0;
713 	int i, dst_is_dir = 1;
714 	struct stat sb;
715 
716 	if (dst) {
717 		tmp_dst = xstrdup(dst);
718 		tmp_dst = make_absolute(tmp_dst, pwd);
719 	}
720 
721 	memset(&g, 0, sizeof(g));
722 	debug3("Looking up %s", src);
723 	if (glob(src, GLOB_NOCHECK | GLOB_MARK, NULL, &g)) {
724 		error("File \"%s\" not found.", src);
725 		err = -1;
726 		goto out;
727 	}
728 
729 	/* If we aren't fetching to pwd then stash this status for later */
730 	if (tmp_dst != NULL)
731 		dst_is_dir = remote_is_dir(conn, tmp_dst);
732 
733 	/* If multiple matches, dst may be directory or unspecified */
734 	if (g.gl_matchc > 1 && tmp_dst && !dst_is_dir) {
735 		error("Multiple paths match, but destination "
736 		    "\"%s\" is not a directory", tmp_dst);
737 		err = -1;
738 		goto out;
739 	}
740 
741 	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
742 		if (stat(g.gl_pathv[i], &sb) == -1) {
743 			err = -1;
744 			error("stat %s: %s", g.gl_pathv[i], strerror(errno));
745 			continue;
746 		}
747 
748 		tmp = xstrdup(g.gl_pathv[i]);
749 		if ((filename = basename(tmp)) == NULL) {
750 			error("basename %s: %s", tmp, strerror(errno));
751 			free(tmp);
752 			err = -1;
753 			goto out;
754 		}
755 
756 		if (g.gl_matchc == 1 && tmp_dst) {
757 			/* If directory specified, append filename */
758 			if (dst_is_dir)
759 				abs_dst = path_append(tmp_dst, filename);
760 			else
761 				abs_dst = xstrdup(tmp_dst);
762 		} else if (tmp_dst) {
763 			abs_dst = path_append(tmp_dst, filename);
764 		} else {
765 			abs_dst = make_absolute(xstrdup(filename), pwd);
766 		}
767 		free(tmp);
768 
769                 resume |= global_aflag;
770 		if (!quiet && resume)
771 			mprintf("Resuming upload of %s to %s\n",
772 			    g.gl_pathv[i], abs_dst);
773 		else if (!quiet && !resume)
774 			mprintf("Uploading %s to %s\n",
775 			    g.gl_pathv[i], abs_dst);
776 		if (pathname_is_dir(g.gl_pathv[i]) && (rflag || global_rflag)) {
777 			if (upload_dir(conn, g.gl_pathv[i], abs_dst,
778 			    pflag || global_pflag, 1, resume,
779 			    fflag || global_fflag) == -1)
780 				err = -1;
781 		} else {
782 			if (do_upload(conn, g.gl_pathv[i], abs_dst,
783 			    pflag || global_pflag, resume,
784 			    fflag || global_fflag) == -1)
785 				err = -1;
786 		}
787 	}
788 
789 out:
790 	free(abs_dst);
791 	free(tmp_dst);
792 	globfree(&g);
793 	return(err);
794 }
795 
796 static int
797 sdirent_comp(const void *aa, const void *bb)
798 {
799 	SFTP_DIRENT *a = *(SFTP_DIRENT **)aa;
800 	SFTP_DIRENT *b = *(SFTP_DIRENT **)bb;
801 	int rmul = sort_flag & LS_REVERSE_SORT ? -1 : 1;
802 
803 #define NCMP(a,b) (a == b ? 0 : (a < b ? 1 : -1))
804 	if (sort_flag & LS_NAME_SORT)
805 		return (rmul * strcmp(a->filename, b->filename));
806 	else if (sort_flag & LS_TIME_SORT)
807 		return (rmul * NCMP(a->a.mtime, b->a.mtime));
808 	else if (sort_flag & LS_SIZE_SORT)
809 		return (rmul * NCMP(a->a.size, b->a.size));
810 
811 	fatal("Unknown ls sort type");
812 }
813 
814 /* sftp ls.1 replacement for directories */
815 static int
816 do_ls_dir(struct sftp_conn *conn, const char *path,
817     const char *strip_path, int lflag)
818 {
819 	int n;
820 	u_int c = 1, colspace = 0, columns = 1;
821 	SFTP_DIRENT **d;
822 
823 	if ((n = do_readdir(conn, path, &d)) != 0)
824 		return (n);
825 
826 	if (!(lflag & LS_SHORT_VIEW)) {
827 		u_int m = 0, width = 80;
828 		struct winsize ws;
829 		char *tmp;
830 
831 		/* Count entries for sort and find longest filename */
832 		for (n = 0; d[n] != NULL; n++) {
833 			if (d[n]->filename[0] != '.' || (lflag & LS_SHOW_ALL))
834 				m = MAXIMUM(m, strlen(d[n]->filename));
835 		}
836 
837 		/* Add any subpath that also needs to be counted */
838 		tmp = path_strip(path, strip_path);
839 		m += strlen(tmp);
840 		free(tmp);
841 
842 		if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) != -1)
843 			width = ws.ws_col;
844 
845 		columns = width / (m + 2);
846 		columns = MAXIMUM(columns, 1);
847 		colspace = width / columns;
848 		colspace = MINIMUM(colspace, width);
849 	}
850 
851 	if (lflag & SORT_FLAGS) {
852 		for (n = 0; d[n] != NULL; n++)
853 			;	/* count entries */
854 		sort_flag = lflag & (SORT_FLAGS|LS_REVERSE_SORT);
855 		qsort(d, n, sizeof(*d), sdirent_comp);
856 	}
857 
858 	for (n = 0; d[n] != NULL && !interrupted; n++) {
859 		char *tmp, *fname;
860 
861 		if (d[n]->filename[0] == '.' && !(lflag & LS_SHOW_ALL))
862 			continue;
863 
864 		tmp = path_append(path, d[n]->filename);
865 		fname = path_strip(tmp, strip_path);
866 		free(tmp);
867 
868 		if (lflag & LS_LONG_VIEW) {
869 			if (lflag & (LS_NUMERIC_VIEW|LS_SI_UNITS)) {
870 				char *lname;
871 				struct stat sb;
872 
873 				memset(&sb, 0, sizeof(sb));
874 				attrib_to_stat(&d[n]->a, &sb);
875 				lname = ls_file(fname, &sb, 1,
876 				    (lflag & LS_SI_UNITS));
877 				mprintf("%s\n", lname);
878 				free(lname);
879 			} else
880 				mprintf("%s\n", d[n]->longname);
881 		} else {
882 			mprintf("%-*s", colspace, fname);
883 			if (c >= columns) {
884 				printf("\n");
885 				c = 1;
886 			} else
887 				c++;
888 		}
889 
890 		free(fname);
891 	}
892 
893 	if (!(lflag & LS_LONG_VIEW) && (c != 1))
894 		printf("\n");
895 
896 	free_sftp_dirents(d);
897 	return (0);
898 }
899 
900 static int
901 sglob_comp(const void *aa, const void *bb)
902 {
903 	u_int a = *(const u_int *)aa;
904 	u_int b = *(const u_int *)bb;
905 	const char *ap = sort_glob->gl_pathv[a];
906 	const char *bp = sort_glob->gl_pathv[b];
907 	const struct stat *as = sort_glob->gl_statv[a];
908 	const struct stat *bs = sort_glob->gl_statv[b];
909 	int rmul = sort_flag & LS_REVERSE_SORT ? -1 : 1;
910 
911 #define NCMP(a,b) (a == b ? 0 : (a < b ? 1 : -1))
912 	if (sort_flag & LS_NAME_SORT)
913 		return (rmul * strcmp(ap, bp));
914 	else if (sort_flag & LS_TIME_SORT) {
915 #if defined(HAVE_STRUCT_STAT_ST_MTIM)
916 		return (rmul * timespeccmp(&as->st_mtim, &bs->st_mtim, <));
917 #elif defined(HAVE_STRUCT_STAT_ST_MTIME)
918 		return (rmul * NCMP(as->st_mtime, bs->st_mtime));
919 #else
920 	return rmul * 1;
921 #endif
922 	} else if (sort_flag & LS_SIZE_SORT)
923 		return (rmul * NCMP(as->st_size, bs->st_size));
924 
925 	fatal("Unknown ls sort type");
926 }
927 
928 /* sftp ls.1 replacement which handles path globs */
929 static int
930 do_globbed_ls(struct sftp_conn *conn, const char *path,
931     const char *strip_path, int lflag)
932 {
933 	char *fname, *lname;
934 	glob_t g;
935 	int err, r;
936 	struct winsize ws;
937 	u_int i, j, nentries, *indices = NULL, c = 1;
938 	u_int colspace = 0, columns = 1, m = 0, width = 80;
939 
940 	memset(&g, 0, sizeof(g));
941 
942 	if ((r = remote_glob(conn, path,
943 	    GLOB_MARK|GLOB_NOCHECK|GLOB_BRACE|GLOB_KEEPSTAT|GLOB_NOSORT,
944 	    NULL, &g)) != 0 ||
945 	    (g.gl_pathc && !g.gl_matchc)) {
946 		if (g.gl_pathc)
947 			globfree(&g);
948 		if (r == GLOB_NOSPACE) {
949 			error("Can't ls: Too many matches for \"%s\"", path);
950 		} else {
951 			error("Can't ls: \"%s\" not found", path);
952 		}
953 		return -1;
954 	}
955 
956 	if (interrupted)
957 		goto out;
958 
959 	/*
960 	 * If the glob returns a single match and it is a directory,
961 	 * then just list its contents.
962 	 */
963 	if (g.gl_matchc == 1 && g.gl_statv[0] != NULL &&
964 	    S_ISDIR(g.gl_statv[0]->st_mode)) {
965 		err = do_ls_dir(conn, g.gl_pathv[0], strip_path, lflag);
966 		globfree(&g);
967 		return err;
968 	}
969 
970 	if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) != -1)
971 		width = ws.ws_col;
972 
973 	if (!(lflag & LS_SHORT_VIEW)) {
974 		/* Count entries for sort and find longest filename */
975 		for (i = 0; g.gl_pathv[i]; i++)
976 			m = MAXIMUM(m, strlen(g.gl_pathv[i]));
977 
978 		columns = width / (m + 2);
979 		columns = MAXIMUM(columns, 1);
980 		colspace = width / columns;
981 	}
982 
983 	/*
984 	 * Sorting: rather than mess with the contents of glob_t, prepare
985 	 * an array of indices into it and sort that. For the usual
986 	 * unsorted case, the indices are just the identity 1=1, 2=2, etc.
987 	 */
988 	for (nentries = 0; g.gl_pathv[nentries] != NULL; nentries++)
989 		;	/* count entries */
990 	indices = calloc(nentries, sizeof(*indices));
991 	for (i = 0; i < nentries; i++)
992 		indices[i] = i;
993 
994 	if (lflag & SORT_FLAGS) {
995 		sort_glob = &g;
996 		sort_flag = lflag & (SORT_FLAGS|LS_REVERSE_SORT);
997 		qsort(indices, nentries, sizeof(*indices), sglob_comp);
998 		sort_glob = NULL;
999 	}
1000 
1001 	for (j = 0; j < nentries && !interrupted; j++) {
1002 		i = indices[j];
1003 		fname = path_strip(g.gl_pathv[i], strip_path);
1004 		if (lflag & LS_LONG_VIEW) {
1005 			if (g.gl_statv[i] == NULL) {
1006 				error("no stat information for %s", fname);
1007 				continue;
1008 			}
1009 			lname = ls_file(fname, g.gl_statv[i], 1,
1010 			    (lflag & LS_SI_UNITS));
1011 			mprintf("%s\n", lname);
1012 			free(lname);
1013 		} else {
1014 			mprintf("%-*s", colspace, fname);
1015 			if (c >= columns) {
1016 				printf("\n");
1017 				c = 1;
1018 			} else
1019 				c++;
1020 		}
1021 		free(fname);
1022 	}
1023 
1024 	if (!(lflag & LS_LONG_VIEW) && (c != 1))
1025 		printf("\n");
1026 
1027  out:
1028 	if (g.gl_pathc)
1029 		globfree(&g);
1030 	free(indices);
1031 
1032 	return 0;
1033 }
1034 
1035 static int
1036 do_df(struct sftp_conn *conn, const char *path, int hflag, int iflag)
1037 {
1038 	struct sftp_statvfs st;
1039 	char s_used[FMT_SCALED_STRSIZE], s_avail[FMT_SCALED_STRSIZE];
1040 	char s_root[FMT_SCALED_STRSIZE], s_total[FMT_SCALED_STRSIZE];
1041 	char s_icapacity[16], s_dcapacity[16];
1042 
1043 	if (do_statvfs(conn, path, &st, 1) == -1)
1044 		return -1;
1045 	if (st.f_files == 0)
1046 		strlcpy(s_icapacity, "ERR", sizeof(s_icapacity));
1047 	else {
1048 		snprintf(s_icapacity, sizeof(s_icapacity), "%3llu%%",
1049 		    (unsigned long long)(100 * (st.f_files - st.f_ffree) /
1050 		    st.f_files));
1051 	}
1052 	if (st.f_blocks == 0)
1053 		strlcpy(s_dcapacity, "ERR", sizeof(s_dcapacity));
1054 	else {
1055 		snprintf(s_dcapacity, sizeof(s_dcapacity), "%3llu%%",
1056 		    (unsigned long long)(100 * (st.f_blocks - st.f_bfree) /
1057 		    st.f_blocks));
1058 	}
1059 	if (iflag) {
1060 		printf("     Inodes        Used       Avail      "
1061 		    "(root)    %%Capacity\n");
1062 		printf("%11llu %11llu %11llu %11llu         %s\n",
1063 		    (unsigned long long)st.f_files,
1064 		    (unsigned long long)(st.f_files - st.f_ffree),
1065 		    (unsigned long long)st.f_favail,
1066 		    (unsigned long long)st.f_ffree, s_icapacity);
1067 	} else if (hflag) {
1068 		strlcpy(s_used, "error", sizeof(s_used));
1069 		strlcpy(s_avail, "error", sizeof(s_avail));
1070 		strlcpy(s_root, "error", sizeof(s_root));
1071 		strlcpy(s_total, "error", sizeof(s_total));
1072 		fmt_scaled((st.f_blocks - st.f_bfree) * st.f_frsize, s_used);
1073 		fmt_scaled(st.f_bavail * st.f_frsize, s_avail);
1074 		fmt_scaled(st.f_bfree * st.f_frsize, s_root);
1075 		fmt_scaled(st.f_blocks * st.f_frsize, s_total);
1076 		printf("    Size     Used    Avail   (root)    %%Capacity\n");
1077 		printf("%7sB %7sB %7sB %7sB         %s\n",
1078 		    s_total, s_used, s_avail, s_root, s_dcapacity);
1079 	} else {
1080 		printf("        Size         Used        Avail       "
1081 		    "(root)    %%Capacity\n");
1082 		printf("%12llu %12llu %12llu %12llu         %s\n",
1083 		    (unsigned long long)(st.f_frsize * st.f_blocks / 1024),
1084 		    (unsigned long long)(st.f_frsize *
1085 		    (st.f_blocks - st.f_bfree) / 1024),
1086 		    (unsigned long long)(st.f_frsize * st.f_bavail / 1024),
1087 		    (unsigned long long)(st.f_frsize * st.f_bfree / 1024),
1088 		    s_dcapacity);
1089 	}
1090 	return 0;
1091 }
1092 
1093 /*
1094  * Undo escaping of glob sequences in place. Used to undo extra escaping
1095  * applied in makeargv() when the string is destined for a function that
1096  * does not glob it.
1097  */
1098 static void
1099 undo_glob_escape(char *s)
1100 {
1101 	size_t i, j;
1102 
1103 	for (i = j = 0;;) {
1104 		if (s[i] == '\0') {
1105 			s[j] = '\0';
1106 			return;
1107 		}
1108 		if (s[i] != '\\') {
1109 			s[j++] = s[i++];
1110 			continue;
1111 		}
1112 		/* s[i] == '\\' */
1113 		++i;
1114 		switch (s[i]) {
1115 		case '?':
1116 		case '[':
1117 		case '*':
1118 		case '\\':
1119 			s[j++] = s[i++];
1120 			break;
1121 		case '\0':
1122 			s[j++] = '\\';
1123 			s[j] = '\0';
1124 			return;
1125 		default:
1126 			s[j++] = '\\';
1127 			s[j++] = s[i++];
1128 			break;
1129 		}
1130 	}
1131 }
1132 
1133 /*
1134  * Split a string into an argument vector using sh(1)-style quoting,
1135  * comment and escaping rules, but with some tweaks to handle glob(3)
1136  * wildcards.
1137  * The "sloppy" flag allows for recovery from missing terminating quote, for
1138  * use in parsing incomplete commandlines during tab autocompletion.
1139  *
1140  * Returns NULL on error or a NULL-terminated array of arguments.
1141  *
1142  * If "lastquote" is not NULL, the quoting character used for the last
1143  * argument is placed in *lastquote ("\0", "'" or "\"").
1144  *
1145  * If "terminated" is not NULL, *terminated will be set to 1 when the
1146  * last argument's quote has been properly terminated or 0 otherwise.
1147  * This parameter is only of use if "sloppy" is set.
1148  */
1149 #define MAXARGS 	128
1150 #define MAXARGLEN	8192
1151 static char **
1152 makeargv(const char *arg, int *argcp, int sloppy, char *lastquote,
1153     u_int *terminated)
1154 {
1155 	int argc, quot;
1156 	size_t i, j;
1157 	static char argvs[MAXARGLEN];
1158 	static char *argv[MAXARGS + 1];
1159 	enum { MA_START, MA_SQUOTE, MA_DQUOTE, MA_UNQUOTED } state, q;
1160 
1161 	*argcp = argc = 0;
1162 	if (strlen(arg) > sizeof(argvs) - 1) {
1163  args_too_longs:
1164 		error("string too long");
1165 		return NULL;
1166 	}
1167 	if (terminated != NULL)
1168 		*terminated = 1;
1169 	if (lastquote != NULL)
1170 		*lastquote = '\0';
1171 	state = MA_START;
1172 	i = j = 0;
1173 	for (;;) {
1174 		if ((size_t)argc >= sizeof(argv) / sizeof(*argv)){
1175 			error("Too many arguments.");
1176 			return NULL;
1177 		}
1178 		if (isspace((unsigned char)arg[i])) {
1179 			if (state == MA_UNQUOTED) {
1180 				/* Terminate current argument */
1181 				argvs[j++] = '\0';
1182 				argc++;
1183 				state = MA_START;
1184 			} else if (state != MA_START)
1185 				argvs[j++] = arg[i];
1186 		} else if (arg[i] == '"' || arg[i] == '\'') {
1187 			q = arg[i] == '"' ? MA_DQUOTE : MA_SQUOTE;
1188 			if (state == MA_START) {
1189 				argv[argc] = argvs + j;
1190 				state = q;
1191 				if (lastquote != NULL)
1192 					*lastquote = arg[i];
1193 			} else if (state == MA_UNQUOTED)
1194 				state = q;
1195 			else if (state == q)
1196 				state = MA_UNQUOTED;
1197 			else
1198 				argvs[j++] = arg[i];
1199 		} else if (arg[i] == '\\') {
1200 			if (state == MA_SQUOTE || state == MA_DQUOTE) {
1201 				quot = state == MA_SQUOTE ? '\'' : '"';
1202 				/* Unescape quote we are in */
1203 				/* XXX support \n and friends? */
1204 				if (arg[i + 1] == quot) {
1205 					i++;
1206 					argvs[j++] = arg[i];
1207 				} else if (arg[i + 1] == '?' ||
1208 				    arg[i + 1] == '[' || arg[i + 1] == '*') {
1209 					/*
1210 					 * Special case for sftp: append
1211 					 * double-escaped glob sequence -
1212 					 * glob will undo one level of
1213 					 * escaping. NB. string can grow here.
1214 					 */
1215 					if (j >= sizeof(argvs) - 5)
1216 						goto args_too_longs;
1217 					argvs[j++] = '\\';
1218 					argvs[j++] = arg[i++];
1219 					argvs[j++] = '\\';
1220 					argvs[j++] = arg[i];
1221 				} else {
1222 					argvs[j++] = arg[i++];
1223 					argvs[j++] = arg[i];
1224 				}
1225 			} else {
1226 				if (state == MA_START) {
1227 					argv[argc] = argvs + j;
1228 					state = MA_UNQUOTED;
1229 					if (lastquote != NULL)
1230 						*lastquote = '\0';
1231 				}
1232 				if (arg[i + 1] == '?' || arg[i + 1] == '[' ||
1233 				    arg[i + 1] == '*' || arg[i + 1] == '\\') {
1234 					/*
1235 					 * Special case for sftp: append
1236 					 * escaped glob sequence -
1237 					 * glob will undo one level of
1238 					 * escaping.
1239 					 */
1240 					argvs[j++] = arg[i++];
1241 					argvs[j++] = arg[i];
1242 				} else {
1243 					/* Unescape everything */
1244 					/* XXX support \n and friends? */
1245 					i++;
1246 					argvs[j++] = arg[i];
1247 				}
1248 			}
1249 		} else if (arg[i] == '#') {
1250 			if (state == MA_SQUOTE || state == MA_DQUOTE)
1251 				argvs[j++] = arg[i];
1252 			else
1253 				goto string_done;
1254 		} else if (arg[i] == '\0') {
1255 			if (state == MA_SQUOTE || state == MA_DQUOTE) {
1256 				if (sloppy) {
1257 					state = MA_UNQUOTED;
1258 					if (terminated != NULL)
1259 						*terminated = 0;
1260 					goto string_done;
1261 				}
1262 				error("Unterminated quoted argument");
1263 				return NULL;
1264 			}
1265  string_done:
1266 			if (state == MA_UNQUOTED) {
1267 				argvs[j++] = '\0';
1268 				argc++;
1269 			}
1270 			break;
1271 		} else {
1272 			if (state == MA_START) {
1273 				argv[argc] = argvs + j;
1274 				state = MA_UNQUOTED;
1275 				if (lastquote != NULL)
1276 					*lastquote = '\0';
1277 			}
1278 			if ((state == MA_SQUOTE || state == MA_DQUOTE) &&
1279 			    (arg[i] == '?' || arg[i] == '[' || arg[i] == '*')) {
1280 				/*
1281 				 * Special case for sftp: escape quoted
1282 				 * glob(3) wildcards. NB. string can grow
1283 				 * here.
1284 				 */
1285 				if (j >= sizeof(argvs) - 3)
1286 					goto args_too_longs;
1287 				argvs[j++] = '\\';
1288 				argvs[j++] = arg[i];
1289 			} else
1290 				argvs[j++] = arg[i];
1291 		}
1292 		i++;
1293 	}
1294 	*argcp = argc;
1295 	return argv;
1296 }
1297 
1298 static int
1299 parse_args(const char **cpp, int *ignore_errors, int *aflag,
1300 	  int *fflag, int *hflag, int *iflag, int *lflag, int *pflag,
1301 	  int *rflag, int *sflag,
1302     unsigned long *n_arg, char **path1, char **path2)
1303 {
1304 	const char *cmd, *cp = *cpp;
1305 	char *cp2, **argv;
1306 	int base = 0;
1307 	long l;
1308 	int path1_mandatory = 0, i, cmdnum, optidx, argc;
1309 
1310 	/* Skip leading whitespace */
1311 	cp = cp + strspn(cp, WHITESPACE);
1312 
1313 	/* Check for leading '-' (disable error processing) */
1314 	*ignore_errors = 0;
1315 	if (*cp == '-') {
1316 		*ignore_errors = 1;
1317 		cp++;
1318 		cp = cp + strspn(cp, WHITESPACE);
1319 	}
1320 
1321 	/* Ignore blank lines and lines which begin with comment '#' char */
1322 	if (*cp == '\0' || *cp == '#')
1323 		return (0);
1324 
1325 	if ((argv = makeargv(cp, &argc, 0, NULL, NULL)) == NULL)
1326 		return -1;
1327 
1328 	/* Figure out which command we have */
1329 	for (i = 0; cmds[i].c != NULL; i++) {
1330 		if (argv[0] != NULL && strcasecmp(cmds[i].c, argv[0]) == 0)
1331 			break;
1332 	}
1333 	cmdnum = cmds[i].n;
1334 	cmd = cmds[i].c;
1335 
1336 	/* Special case */
1337 	if (*cp == '!') {
1338 		cp++;
1339 		cmdnum = I_SHELL;
1340 	} else if (cmdnum == -1) {
1341 		error("Invalid command.");
1342 		return -1;
1343 	}
1344 
1345 	/* Get arguments and parse flags */
1346 	*aflag = *fflag = *hflag = *iflag = *lflag = *pflag = 0;
1347 	*rflag = *sflag = 0;
1348 	*path1 = *path2 = NULL;
1349 	optidx = 1;
1350 	switch (cmdnum) {
1351 	case I_GET:
1352 	case I_REGET:
1353 	case I_REPUT:
1354 	case I_PUT:
1355 		if ((optidx = parse_getput_flags(cmd, argv, argc,
1356 		    aflag, fflag, pflag, rflag)) == -1)
1357 			return -1;
1358 		/* Get first pathname (mandatory) */
1359 		if (argc - optidx < 1) {
1360 			error("You must specify at least one path after a "
1361 			    "%s command.", cmd);
1362 			return -1;
1363 		}
1364 		*path1 = xstrdup(argv[optidx]);
1365 		/* Get second pathname (optional) */
1366 		if (argc - optidx > 1) {
1367 			*path2 = xstrdup(argv[optidx + 1]);
1368 			/* Destination is not globbed */
1369 			undo_glob_escape(*path2);
1370 		}
1371 		break;
1372 	case I_LINK:
1373 		if ((optidx = parse_link_flags(cmd, argv, argc, sflag)) == -1)
1374 			return -1;
1375 		goto parse_two_paths;
1376 	case I_RENAME:
1377 		if ((optidx = parse_rename_flags(cmd, argv, argc, lflag)) == -1)
1378 			return -1;
1379 		goto parse_two_paths;
1380 	case I_SYMLINK:
1381 		if ((optidx = parse_no_flags(cmd, argv, argc)) == -1)
1382 			return -1;
1383  parse_two_paths:
1384 		if (argc - optidx < 2) {
1385 			error("You must specify two paths after a %s "
1386 			    "command.", cmd);
1387 			return -1;
1388 		}
1389 		*path1 = xstrdup(argv[optidx]);
1390 		*path2 = xstrdup(argv[optidx + 1]);
1391 		/* Paths are not globbed */
1392 		undo_glob_escape(*path1);
1393 		undo_glob_escape(*path2);
1394 		break;
1395 	case I_RM:
1396 	case I_MKDIR:
1397 	case I_RMDIR:
1398 	case I_LMKDIR:
1399 		path1_mandatory = 1;
1400 		/* FALLTHROUGH */
1401 	case I_CHDIR:
1402 	case I_LCHDIR:
1403 		if ((optidx = parse_no_flags(cmd, argv, argc)) == -1)
1404 			return -1;
1405 		/* Get pathname (mandatory) */
1406 		if (argc - optidx < 1) {
1407 			if (!path1_mandatory)
1408 				break; /* return a NULL path1 */
1409 			error("You must specify a path after a %s command.",
1410 			    cmd);
1411 			return -1;
1412 		}
1413 		*path1 = xstrdup(argv[optidx]);
1414 		/* Only "rm" globs */
1415 		if (cmdnum != I_RM)
1416 			undo_glob_escape(*path1);
1417 		break;
1418 	case I_DF:
1419 		if ((optidx = parse_df_flags(cmd, argv, argc, hflag,
1420 		    iflag)) == -1)
1421 			return -1;
1422 		/* Default to current directory if no path specified */
1423 		if (argc - optidx < 1)
1424 			*path1 = NULL;
1425 		else {
1426 			*path1 = xstrdup(argv[optidx]);
1427 			undo_glob_escape(*path1);
1428 		}
1429 		break;
1430 	case I_LS:
1431 		if ((optidx = parse_ls_flags(argv, argc, lflag)) == -1)
1432 			return(-1);
1433 		/* Path is optional */
1434 		if (argc - optidx > 0)
1435 			*path1 = xstrdup(argv[optidx]);
1436 		break;
1437 	case I_LLS:
1438 		/* Skip ls command and following whitespace */
1439 		cp = cp + strlen(cmd) + strspn(cp, WHITESPACE);
1440 	case I_SHELL:
1441 		/* Uses the rest of the line */
1442 		break;
1443 	case I_LUMASK:
1444 	case I_CHMOD:
1445 		base = 8;
1446 		/* FALLTHROUGH */
1447 	case I_CHOWN:
1448 	case I_CHGRP:
1449 		if ((optidx = parse_no_flags(cmd, argv, argc)) == -1)
1450 			return -1;
1451 		/* Get numeric arg (mandatory) */
1452 		if (argc - optidx < 1)
1453 			goto need_num_arg;
1454 		errno = 0;
1455 		l = strtol(argv[optidx], &cp2, base);
1456 		if (cp2 == argv[optidx] || *cp2 != '\0' ||
1457 		    ((l == LONG_MIN || l == LONG_MAX) && errno == ERANGE) ||
1458 		    l < 0) {
1459  need_num_arg:
1460 			error("You must supply a numeric argument "
1461 			    "to the %s command.", cmd);
1462 			return -1;
1463 		}
1464 		*n_arg = l;
1465 		if (cmdnum == I_LUMASK)
1466 			break;
1467 		/* Get pathname (mandatory) */
1468 		if (argc - optidx < 2) {
1469 			error("You must specify a path after a %s command.",
1470 			    cmd);
1471 			return -1;
1472 		}
1473 		*path1 = xstrdup(argv[optidx + 1]);
1474 		break;
1475 	case I_QUIT:
1476 	case I_PWD:
1477 	case I_LPWD:
1478 	case I_HELP:
1479 	case I_VERSION:
1480 	case I_PROGRESS:
1481 		if ((optidx = parse_no_flags(cmd, argv, argc)) == -1)
1482 			return -1;
1483 		break;
1484 	default:
1485 		fatal("Command not implemented");
1486 	}
1487 
1488 	*cpp = cp;
1489 	return(cmdnum);
1490 }
1491 
1492 static int
1493 parse_dispatch_command(struct sftp_conn *conn, const char *cmd, char **pwd,
1494     const char *startdir, int err_abort)
1495 {
1496 	char *path1, *path2, *tmp;
1497 	int ignore_errors = 0, aflag = 0, fflag = 0, hflag = 0,
1498 	iflag = 0;
1499 	int lflag = 0, pflag = 0, rflag = 0, sflag = 0;
1500 	int cmdnum, i;
1501 	unsigned long n_arg = 0;
1502 	Attrib a, *aa;
1503 	char path_buf[PATH_MAX];
1504 	int err = 0;
1505 	glob_t g;
1506 
1507 	path1 = path2 = NULL;
1508 	cmdnum = parse_args(&cmd, &ignore_errors, &aflag, &fflag, &hflag,
1509 	    &iflag, &lflag, &pflag, &rflag, &sflag, &n_arg, &path1, &path2);
1510 	if (ignore_errors != 0)
1511 		err_abort = 0;
1512 
1513 	memset(&g, 0, sizeof(g));
1514 
1515 	/* Perform command */
1516 	switch (cmdnum) {
1517 	case 0:
1518 		/* Blank line */
1519 		break;
1520 	case -1:
1521 		/* Unrecognized command */
1522 		err = -1;
1523 		break;
1524 	case I_REGET:
1525 		aflag = 1;
1526 		/* FALLTHROUGH */
1527 	case I_GET:
1528 		err = process_get(conn, path1, path2, *pwd, pflag,
1529 		    rflag, aflag, fflag);
1530 		break;
1531 	case I_REPUT:
1532 		aflag = 1;
1533 		/* FALLTHROUGH */
1534 	case I_PUT:
1535 		err = process_put(conn, path1, path2, *pwd, pflag,
1536 		    rflag, aflag, fflag);
1537 		break;
1538 	case I_RENAME:
1539 		path1 = make_absolute(path1, *pwd);
1540 		path2 = make_absolute(path2, *pwd);
1541 		err = do_rename(conn, path1, path2, lflag);
1542 		break;
1543 	case I_SYMLINK:
1544 		sflag = 1;
1545 		/* FALLTHROUGH */
1546 	case I_LINK:
1547 		if (!sflag)
1548 			path1 = make_absolute(path1, *pwd);
1549 		path2 = make_absolute(path2, *pwd);
1550 		err = (sflag ? do_symlink : do_hardlink)(conn, path1, path2);
1551 		break;
1552 	case I_RM:
1553 		path1 = make_absolute(path1, *pwd);
1554 		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
1555 		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1556 			if (!quiet)
1557 				mprintf("Removing %s\n", g.gl_pathv[i]);
1558 			err = do_rm(conn, g.gl_pathv[i]);
1559 			if (err != 0 && err_abort)
1560 				break;
1561 		}
1562 		break;
1563 	case I_MKDIR:
1564 		path1 = make_absolute(path1, *pwd);
1565 		attrib_clear(&a);
1566 		a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
1567 		a.perm = 0777;
1568 		err = do_mkdir(conn, path1, &a, 1);
1569 		break;
1570 	case I_RMDIR:
1571 		path1 = make_absolute(path1, *pwd);
1572 		err = do_rmdir(conn, path1);
1573 		break;
1574 	case I_CHDIR:
1575 		if (path1 == NULL || *path1 == '\0')
1576 			path1 = xstrdup(startdir);
1577 		path1 = make_absolute(path1, *pwd);
1578 		if ((tmp = do_realpath(conn, path1)) == NULL) {
1579 			err = 1;
1580 			break;
1581 		}
1582 		if ((aa = do_stat(conn, tmp, 0)) == NULL) {
1583 			free(tmp);
1584 			err = 1;
1585 			break;
1586 		}
1587 		if (!(aa->flags & SSH2_FILEXFER_ATTR_PERMISSIONS)) {
1588 			error("Can't change directory: Can't check target");
1589 			free(tmp);
1590 			err = 1;
1591 			break;
1592 		}
1593 		if (!S_ISDIR(aa->perm)) {
1594 			error("Can't change directory: \"%s\" is not "
1595 			    "a directory", tmp);
1596 			free(tmp);
1597 			err = 1;
1598 			break;
1599 		}
1600 		free(*pwd);
1601 		*pwd = tmp;
1602 		break;
1603 	case I_LS:
1604 		if (!path1) {
1605 			do_ls_dir(conn, *pwd, *pwd, lflag);
1606 			break;
1607 		}
1608 
1609 		/* Strip pwd off beginning of non-absolute paths */
1610 		tmp = NULL;
1611 		if (*path1 != '/')
1612 			tmp = *pwd;
1613 
1614 		path1 = make_absolute(path1, *pwd);
1615 		err = do_globbed_ls(conn, path1, tmp, lflag);
1616 		break;
1617 	case I_DF:
1618 		/* Default to current directory if no path specified */
1619 		if (path1 == NULL)
1620 			path1 = xstrdup(*pwd);
1621 		path1 = make_absolute(path1, *pwd);
1622 		err = do_df(conn, path1, hflag, iflag);
1623 		break;
1624 	case I_LCHDIR:
1625 		if (path1 == NULL || *path1 == '\0')
1626 			path1 = xstrdup("~");
1627 		tmp = tilde_expand_filename(path1, getuid());
1628 		free(path1);
1629 		path1 = tmp;
1630 		if (chdir(path1) == -1) {
1631 			error("Couldn't change local directory to "
1632 			    "\"%s\": %s", path1, strerror(errno));
1633 			err = 1;
1634 		}
1635 		break;
1636 	case I_LMKDIR:
1637 		if (mkdir(path1, 0777) == -1) {
1638 			error("Couldn't create local directory "
1639 			    "\"%s\": %s", path1, strerror(errno));
1640 			err = 1;
1641 		}
1642 		break;
1643 	case I_LLS:
1644 		local_do_ls(cmd);
1645 		break;
1646 	case I_SHELL:
1647 		local_do_shell(cmd);
1648 		break;
1649 	case I_LUMASK:
1650 		umask(n_arg);
1651 		printf("Local umask: %03lo\n", n_arg);
1652 		break;
1653 	case I_CHMOD:
1654 		path1 = make_absolute(path1, *pwd);
1655 		attrib_clear(&a);
1656 		a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
1657 		a.perm = n_arg;
1658 		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
1659 		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1660 			if (!quiet)
1661 				mprintf("Changing mode on %s\n",
1662 				    g.gl_pathv[i]);
1663 			err = do_setstat(conn, g.gl_pathv[i], &a);
1664 			if (err != 0 && err_abort)
1665 				break;
1666 		}
1667 		break;
1668 	case I_CHOWN:
1669 	case I_CHGRP:
1670 		path1 = make_absolute(path1, *pwd);
1671 		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
1672 		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1673 			if (!(aa = do_stat(conn, g.gl_pathv[i], 0))) {
1674 				if (err_abort) {
1675 					err = -1;
1676 					break;
1677 				} else
1678 					continue;
1679 			}
1680 			if (!(aa->flags & SSH2_FILEXFER_ATTR_UIDGID)) {
1681 				error("Can't get current ownership of "
1682 				    "remote file \"%s\"", g.gl_pathv[i]);
1683 				if (err_abort) {
1684 					err = -1;
1685 					break;
1686 				} else
1687 					continue;
1688 			}
1689 			aa->flags &= SSH2_FILEXFER_ATTR_UIDGID;
1690 			if (cmdnum == I_CHOWN) {
1691 				if (!quiet)
1692 					mprintf("Changing owner on %s\n",
1693 					    g.gl_pathv[i]);
1694 				aa->uid = n_arg;
1695 			} else {
1696 				if (!quiet)
1697 					mprintf("Changing group on %s\n",
1698 					    g.gl_pathv[i]);
1699 				aa->gid = n_arg;
1700 			}
1701 			err = do_setstat(conn, g.gl_pathv[i], aa);
1702 			if (err != 0 && err_abort)
1703 				break;
1704 		}
1705 		break;
1706 	case I_PWD:
1707 		mprintf("Remote working directory: %s\n", *pwd);
1708 		break;
1709 	case I_LPWD:
1710 		if (!getcwd(path_buf, sizeof(path_buf))) {
1711 			error("Couldn't get local cwd: %s", strerror(errno));
1712 			err = -1;
1713 			break;
1714 		}
1715 		mprintf("Local working directory: %s\n", path_buf);
1716 		break;
1717 	case I_QUIT:
1718 		/* Processed below */
1719 		break;
1720 	case I_HELP:
1721 		help();
1722 		break;
1723 	case I_VERSION:
1724 		printf("SFTP protocol version %u\n", sftp_proto_version(conn));
1725 		break;
1726 	case I_PROGRESS:
1727 		showprogress = !showprogress;
1728 		if (showprogress)
1729 			printf("Progress meter enabled\n");
1730 		else
1731 			printf("Progress meter disabled\n");
1732 		break;
1733 	default:
1734 		fatal("%d is not implemented", cmdnum);
1735 	}
1736 
1737 	if (g.gl_pathc)
1738 		globfree(&g);
1739 	free(path1);
1740 	free(path2);
1741 
1742 	/* If an unignored error occurs in batch mode we should abort. */
1743 	if (err_abort && err != 0)
1744 		return (-1);
1745 	else if (cmdnum == I_QUIT)
1746 		return (1);
1747 
1748 	return (0);
1749 }
1750 
1751 #ifdef USE_LIBEDIT
1752 static char *
1753 prompt(EditLine *el)
1754 {
1755 	return ("sftp> ");
1756 }
1757 
1758 /* Display entries in 'list' after skipping the first 'len' chars */
1759 static void
1760 complete_display(char **list, u_int len)
1761 {
1762 	u_int y, m = 0, width = 80, columns = 1, colspace = 0, llen;
1763 	struct winsize ws;
1764 	char *tmp;
1765 
1766 	/* Count entries for sort and find longest */
1767 	for (y = 0; list[y]; y++)
1768 		m = MAXIMUM(m, strlen(list[y]));
1769 
1770 	if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) != -1)
1771 		width = ws.ws_col;
1772 
1773 	m = m > len ? m - len : 0;
1774 	columns = width / (m + 2);
1775 	columns = MAXIMUM(columns, 1);
1776 	colspace = width / columns;
1777 	colspace = MINIMUM(colspace, width);
1778 
1779 	printf("\n");
1780 	m = 1;
1781 	for (y = 0; list[y]; y++) {
1782 		llen = strlen(list[y]);
1783 		tmp = llen > len ? list[y] + len : "";
1784 		mprintf("%-*s", colspace, tmp);
1785 		if (m >= columns) {
1786 			printf("\n");
1787 			m = 1;
1788 		} else
1789 			m++;
1790 	}
1791 	printf("\n");
1792 }
1793 
1794 /*
1795  * Given a "list" of words that begin with a common prefix of "word",
1796  * attempt to find an autocompletion to extends "word" by the next
1797  * characters common to all entries in "list".
1798  */
1799 static char *
1800 complete_ambiguous(const char *word, char **list, size_t count)
1801 {
1802 	if (word == NULL)
1803 		return NULL;
1804 
1805 	if (count > 0) {
1806 		u_int y, matchlen = strlen(list[0]);
1807 
1808 		/* Find length of common stem */
1809 		for (y = 1; list[y]; y++) {
1810 			u_int x;
1811 
1812 			for (x = 0; x < matchlen; x++)
1813 				if (list[0][x] != list[y][x])
1814 					break;
1815 
1816 			matchlen = x;
1817 		}
1818 
1819 		if (matchlen > strlen(word)) {
1820 			char *tmp = xstrdup(list[0]);
1821 
1822 			tmp[matchlen] = '\0';
1823 			return tmp;
1824 		}
1825 	}
1826 
1827 	return xstrdup(word);
1828 }
1829 
1830 /* Autocomplete a sftp command */
1831 static int
1832 complete_cmd_parse(EditLine *el, char *cmd, int lastarg, char quote,
1833     int terminated)
1834 {
1835 	u_int y, count = 0, cmdlen, tmplen;
1836 	char *tmp, **list, argterm[3];
1837 	const LineInfo *lf;
1838 
1839 	list = xcalloc((sizeof(cmds) / sizeof(*cmds)) + 1, sizeof(char *));
1840 
1841 	/* No command specified: display all available commands */
1842 	if (cmd == NULL) {
1843 		for (y = 0; cmds[y].c; y++)
1844 			list[count++] = xstrdup(cmds[y].c);
1845 
1846 		list[count] = NULL;
1847 		complete_display(list, 0);
1848 
1849 		for (y = 0; list[y] != NULL; y++)
1850 			free(list[y]);
1851 		free(list);
1852 		return count;
1853 	}
1854 
1855 	/* Prepare subset of commands that start with "cmd" */
1856 	cmdlen = strlen(cmd);
1857 	for (y = 0; cmds[y].c; y++)  {
1858 		if (!strncasecmp(cmd, cmds[y].c, cmdlen))
1859 			list[count++] = xstrdup(cmds[y].c);
1860 	}
1861 	list[count] = NULL;
1862 
1863 	if (count == 0) {
1864 		free(list);
1865 		return 0;
1866 	}
1867 
1868 	/* Complete ambiguous command */
1869 	tmp = complete_ambiguous(cmd, list, count);
1870 	if (count > 1)
1871 		complete_display(list, 0);
1872 
1873 	for (y = 0; list[y]; y++)
1874 		free(list[y]);
1875 	free(list);
1876 
1877 	if (tmp != NULL) {
1878 		tmplen = strlen(tmp);
1879 		cmdlen = strlen(cmd);
1880 		/* If cmd may be extended then do so */
1881 		if (tmplen > cmdlen)
1882 			if (el_insertstr(el, tmp + cmdlen) == -1)
1883 				fatal("el_insertstr failed.");
1884 		lf = el_line(el);
1885 		/* Terminate argument cleanly */
1886 		if (count == 1) {
1887 			y = 0;
1888 			if (!terminated)
1889 				argterm[y++] = quote;
1890 			if (lastarg || *(lf->cursor) != ' ')
1891 				argterm[y++] = ' ';
1892 			argterm[y] = '\0';
1893 			if (y > 0 && el_insertstr(el, argterm) == -1)
1894 				fatal("el_insertstr failed.");
1895 		}
1896 		free(tmp);
1897 	}
1898 
1899 	return count;
1900 }
1901 
1902 /*
1903  * Determine whether a particular sftp command's arguments (if any)
1904  * represent local or remote files.
1905  */
1906 static int
1907 complete_is_remote(char *cmd) {
1908 	int i;
1909 
1910 	if (cmd == NULL)
1911 		return -1;
1912 
1913 	for (i = 0; cmds[i].c; i++) {
1914 		if (!strncasecmp(cmd, cmds[i].c, strlen(cmds[i].c)))
1915 			return cmds[i].t;
1916 	}
1917 
1918 	return -1;
1919 }
1920 
1921 /* Autocomplete a filename "file" */
1922 static int
1923 complete_match(EditLine *el, struct sftp_conn *conn, char *remote_path,
1924     char *file, int remote, int lastarg, char quote, int terminated)
1925 {
1926 	glob_t g;
1927 	char *tmp, *tmp2, ins[8];
1928 	u_int i, hadglob, pwdlen, len, tmplen, filelen, cesc, isesc, isabs;
1929 	int clen;
1930 	const LineInfo *lf;
1931 
1932 	/* Glob from "file" location */
1933 	if (file == NULL)
1934 		tmp = xstrdup("*");
1935 	else
1936 		xasprintf(&tmp, "%s*", file);
1937 
1938 	/* Check if the path is absolute. */
1939 	isabs = tmp[0] == '/';
1940 
1941 	memset(&g, 0, sizeof(g));
1942 	if (remote != LOCAL) {
1943 		tmp = make_absolute(tmp, remote_path);
1944 		remote_glob(conn, tmp, GLOB_DOOFFS|GLOB_MARK, NULL, &g);
1945 	} else
1946 		glob(tmp, GLOB_DOOFFS|GLOB_MARK, NULL, &g);
1947 
1948 	/* Determine length of pwd so we can trim completion display */
1949 	for (hadglob = tmplen = pwdlen = 0; tmp[tmplen] != 0; tmplen++) {
1950 		/* Terminate counting on first unescaped glob metacharacter */
1951 		if (tmp[tmplen] == '*' || tmp[tmplen] == '?') {
1952 			if (tmp[tmplen] != '*' || tmp[tmplen + 1] != '\0')
1953 				hadglob = 1;
1954 			break;
1955 		}
1956 		if (tmp[tmplen] == '\\' && tmp[tmplen + 1] != '\0')
1957 			tmplen++;
1958 		if (tmp[tmplen] == '/')
1959 			pwdlen = tmplen + 1;	/* track last seen '/' */
1960 	}
1961 	free(tmp);
1962 	tmp = NULL;
1963 
1964 	if (g.gl_matchc == 0)
1965 		goto out;
1966 
1967 	if (g.gl_matchc > 1)
1968 		complete_display(g.gl_pathv, pwdlen);
1969 
1970 	/* Don't try to extend globs */
1971 	if (file == NULL || hadglob)
1972 		goto out;
1973 
1974 	tmp2 = complete_ambiguous(file, g.gl_pathv, g.gl_matchc);
1975 	tmp = path_strip(tmp2, isabs ? NULL : remote_path);
1976 	free(tmp2);
1977 
1978 	if (tmp == NULL)
1979 		goto out;
1980 
1981 	tmplen = strlen(tmp);
1982 	filelen = strlen(file);
1983 
1984 	/* Count the number of escaped characters in the input string. */
1985 	cesc = isesc = 0;
1986 	for (i = 0; i < filelen; i++) {
1987 		if (!isesc && file[i] == '\\' && i + 1 < filelen){
1988 			isesc = 1;
1989 			cesc++;
1990 		} else
1991 			isesc = 0;
1992 	}
1993 
1994 	if (tmplen > (filelen - cesc)) {
1995 		tmp2 = tmp + filelen - cesc;
1996 		len = strlen(tmp2);
1997 		/* quote argument on way out */
1998 		for (i = 0; i < len; i += clen) {
1999 			if ((clen = mblen(tmp2 + i, len - i)) < 0 ||
2000 			    (size_t)clen > sizeof(ins) - 2)
2001 				fatal("invalid multibyte character");
2002 			ins[0] = '\\';
2003 			memcpy(ins + 1, tmp2 + i, clen);
2004 			ins[clen + 1] = '\0';
2005 			switch (tmp2[i]) {
2006 			case '\'':
2007 			case '"':
2008 			case '\\':
2009 			case '\t':
2010 			case '[':
2011 			case ' ':
2012 			case '#':
2013 			case '*':
2014 				if (quote == '\0' || tmp2[i] == quote) {
2015 					if (el_insertstr(el, ins) == -1)
2016 						fatal("el_insertstr "
2017 						    "failed.");
2018 					break;
2019 				}
2020 				/* FALLTHROUGH */
2021 			default:
2022 				if (el_insertstr(el, ins + 1) == -1)
2023 					fatal("el_insertstr failed.");
2024 				break;
2025 			}
2026 		}
2027 	}
2028 
2029 	lf = el_line(el);
2030 	if (g.gl_matchc == 1) {
2031 		i = 0;
2032 		if (!terminated && quote != '\0')
2033 			ins[i++] = quote;
2034 		if (*(lf->cursor - 1) != '/' &&
2035 		    (lastarg || *(lf->cursor) != ' '))
2036 			ins[i++] = ' ';
2037 		ins[i] = '\0';
2038 		if (i > 0 && el_insertstr(el, ins) == -1)
2039 			fatal("el_insertstr failed.");
2040 	}
2041 	free(tmp);
2042 
2043  out:
2044 	globfree(&g);
2045 	return g.gl_matchc;
2046 }
2047 
2048 /* tab-completion hook function, called via libedit */
2049 static unsigned char
2050 complete(EditLine *el, int ch)
2051 {
2052 	char **argv, *line, quote;
2053 	int argc, carg;
2054 	u_int cursor, len, terminated, ret = CC_ERROR;
2055 	const LineInfo *lf;
2056 	struct complete_ctx *complete_ctx;
2057 
2058 	lf = el_line(el);
2059 	if (el_get(el, EL_CLIENTDATA, (void**)&complete_ctx) != 0)
2060 		fatal("%s: el_get failed", __func__);
2061 
2062 	/* Figure out which argument the cursor points to */
2063 	cursor = lf->cursor - lf->buffer;
2064 	line = xmalloc(cursor + 1);
2065 	memcpy(line, lf->buffer, cursor);
2066 	line[cursor] = '\0';
2067 	argv = makeargv(line, &carg, 1, &quote, &terminated);
2068 	free(line);
2069 
2070 	/* Get all the arguments on the line */
2071 	len = lf->lastchar - lf->buffer;
2072 	line = xmalloc(len + 1);
2073 	memcpy(line, lf->buffer, len);
2074 	line[len] = '\0';
2075 	argv = makeargv(line, &argc, 1, NULL, NULL);
2076 
2077 	/* Ensure cursor is at EOL or a argument boundary */
2078 	if (line[cursor] != ' ' && line[cursor] != '\0' &&
2079 	    line[cursor] != '\n') {
2080 		free(line);
2081 		return ret;
2082 	}
2083 
2084 	if (carg == 0) {
2085 		/* Show all available commands */
2086 		complete_cmd_parse(el, NULL, argc == carg, '\0', 1);
2087 		ret = CC_REDISPLAY;
2088 	} else if (carg == 1 && cursor > 0 && line[cursor - 1] != ' ')  {
2089 		/* Handle the command parsing */
2090 		if (complete_cmd_parse(el, argv[0], argc == carg,
2091 		    quote, terminated) != 0)
2092 			ret = CC_REDISPLAY;
2093 	} else if (carg >= 1) {
2094 		/* Handle file parsing */
2095 		int remote = complete_is_remote(argv[0]);
2096 		char *filematch = NULL;
2097 
2098 		if (carg > 1 && line[cursor-1] != ' ')
2099 			filematch = argv[carg - 1];
2100 
2101 		if (remote != 0 &&
2102 		    complete_match(el, complete_ctx->conn,
2103 		    *complete_ctx->remote_pathp, filematch,
2104 		    remote, carg == argc, quote, terminated) != 0)
2105 			ret = CC_REDISPLAY;
2106 	}
2107 
2108 	free(line);
2109 	return ret;
2110 }
2111 #endif /* USE_LIBEDIT */
2112 
2113 static int
2114 interactive_loop(struct sftp_conn *conn, char *file1, char *file2)
2115 {
2116 	char *remote_path;
2117 	char *dir = NULL, *startdir = NULL;
2118 	char cmd[2048];
2119 	int err, interactive;
2120 	EditLine *el = NULL;
2121 #ifdef USE_LIBEDIT
2122 	History *hl = NULL;
2123 	HistEvent hev;
2124 	extern char *__progname;
2125 	struct complete_ctx complete_ctx;
2126 
2127 	if (!batchmode && isatty(STDIN_FILENO)) {
2128 		if ((el = el_init(__progname, stdin, stdout, stderr)) == NULL)
2129 			fatal("Couldn't initialise editline");
2130 		if ((hl = history_init()) == NULL)
2131 			fatal("Couldn't initialise editline history");
2132 		history(hl, &hev, H_SETSIZE, 100);
2133 		el_set(el, EL_HIST, history, hl);
2134 
2135 		el_set(el, EL_PROMPT, prompt);
2136 		el_set(el, EL_EDITOR, "emacs");
2137 		el_set(el, EL_TERMINAL, NULL);
2138 		el_set(el, EL_SIGNAL, 1);
2139 		el_source(el, NULL);
2140 
2141 		/* Tab Completion */
2142 		el_set(el, EL_ADDFN, "ftp-complete",
2143 		    "Context sensitive argument completion", complete);
2144 		complete_ctx.conn = conn;
2145 		complete_ctx.remote_pathp = &remote_path;
2146 		el_set(el, EL_CLIENTDATA, (void*)&complete_ctx);
2147 		el_set(el, EL_BIND, "^I", "ftp-complete", NULL);
2148 		/* enable ctrl-left-arrow and ctrl-right-arrow */
2149 		el_set(el, EL_BIND, "\\e[1;5C", "em-next-word", NULL);
2150 		el_set(el, EL_BIND, "\\e[5C", "em-next-word", NULL);
2151 		el_set(el, EL_BIND, "\\e[1;5D", "ed-prev-word", NULL);
2152 		el_set(el, EL_BIND, "\\e\\e[D", "ed-prev-word", NULL);
2153 		/* make ^w match ksh behaviour */
2154 		el_set(el, EL_BIND, "^w", "ed-delete-prev-word", NULL);
2155 	}
2156 #endif /* USE_LIBEDIT */
2157 
2158 	remote_path = do_realpath(conn, ".");
2159 	if (remote_path == NULL)
2160 		fatal("Need cwd");
2161 	startdir = xstrdup(remote_path);
2162 
2163 	if (file1 != NULL) {
2164 		dir = xstrdup(file1);
2165 		dir = make_absolute(dir, remote_path);
2166 
2167 		if (remote_is_dir(conn, dir) && file2 == NULL) {
2168 			if (!quiet)
2169 				mprintf("Changing to: %s\n", dir);
2170 			snprintf(cmd, sizeof cmd, "cd \"%s\"", dir);
2171 			if (parse_dispatch_command(conn, cmd,
2172 			    &remote_path, startdir, 1) != 0) {
2173 				free(dir);
2174 				free(startdir);
2175 				free(remote_path);
2176 				free(conn);
2177 				return (-1);
2178 			}
2179 		} else {
2180 			/* XXX this is wrong wrt quoting */
2181 			snprintf(cmd, sizeof cmd, "get%s %s%s%s",
2182 			    global_aflag ? " -a" : "", dir,
2183 			    file2 == NULL ? "" : " ",
2184 			    file2 == NULL ? "" : file2);
2185 			err = parse_dispatch_command(conn, cmd,
2186 			    &remote_path, startdir, 1);
2187 			free(dir);
2188 			free(startdir);
2189 			free(remote_path);
2190 			free(conn);
2191 			return (err);
2192 		}
2193 		free(dir);
2194 	}
2195 
2196 	setvbuf(stdout, NULL, _IOLBF, 0);
2197 	setvbuf(infile, NULL, _IOLBF, 0);
2198 
2199 	interactive = !batchmode && isatty(STDIN_FILENO);
2200 	err = 0;
2201 	for (;;) {
2202 		char *cp;
2203 
2204 		signal(SIGINT, SIG_IGN);
2205 
2206 		if (el == NULL) {
2207 			if (interactive)
2208 				printf("sftp> ");
2209 			if (fgets(cmd, sizeof(cmd), infile) == NULL) {
2210 				if (interactive)
2211 					printf("\n");
2212 				break;
2213 			}
2214 			if (!interactive) { /* Echo command */
2215 				mprintf("sftp> %s", cmd);
2216 				if (strlen(cmd) > 0 &&
2217 				    cmd[strlen(cmd) - 1] != '\n')
2218 					printf("\n");
2219 			}
2220 		} else {
2221 #ifdef USE_LIBEDIT
2222 			const char *line;
2223 			int count = 0;
2224 
2225 			if ((line = el_gets(el, &count)) == NULL ||
2226 			    count <= 0) {
2227 				printf("\n");
2228  				break;
2229 			}
2230 			history(hl, &hev, H_ENTER, line);
2231 			if (strlcpy(cmd, line, sizeof(cmd)) >= sizeof(cmd)) {
2232 				fprintf(stderr, "Error: input line too long\n");
2233 				continue;
2234 			}
2235 #endif /* USE_LIBEDIT */
2236 		}
2237 
2238 		cp = strrchr(cmd, '\n');
2239 		if (cp)
2240 			*cp = '\0';
2241 
2242 		/* Handle user interrupts gracefully during commands */
2243 		interrupted = 0;
2244 		signal(SIGINT, cmd_interrupt);
2245 
2246 		err = parse_dispatch_command(conn, cmd, &remote_path,
2247 		    startdir, batchmode);
2248 		if (err != 0)
2249 			break;
2250 	}
2251 	signal(SIGCHLD, SIG_DFL);
2252 	free(remote_path);
2253 	free(startdir);
2254 	free(conn);
2255 
2256 #ifdef USE_LIBEDIT
2257 	if (el != NULL)
2258 		el_end(el);
2259 #endif /* USE_LIBEDIT */
2260 
2261 	/* err == 1 signifies normal "quit" exit */
2262 	return (err >= 0 ? 0 : -1);
2263 }
2264 
2265 static void
2266 connect_to_server(char *path, char **args, int *in, int *out)
2267 {
2268 	int c_in, c_out;
2269 
2270 #ifdef USE_PIPES
2271 	int pin[2], pout[2];
2272 
2273 	if ((pipe(pin) == -1) || (pipe(pout) == -1))
2274 		fatal("pipe: %s", strerror(errno));
2275 	*in = pin[0];
2276 	*out = pout[1];
2277 	c_in = pout[0];
2278 	c_out = pin[1];
2279 #else /* USE_PIPES */
2280 	int inout[2];
2281 
2282 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, inout) == -1)
2283 		fatal("socketpair: %s", strerror(errno));
2284 	*in = *out = inout[0];
2285 	c_in = c_out = inout[1];
2286 #endif /* USE_PIPES */
2287 
2288 	if ((sshpid = fork()) == -1)
2289 		fatal("fork: %s", strerror(errno));
2290 	else if (sshpid == 0) {
2291 		if ((dup2(c_in, STDIN_FILENO) == -1) ||
2292 		    (dup2(c_out, STDOUT_FILENO) == -1)) {
2293 			fprintf(stderr, "dup2: %s\n", strerror(errno));
2294 			_exit(1);
2295 		}
2296 		close(*in);
2297 		close(*out);
2298 		close(c_in);
2299 		close(c_out);
2300 
2301 		/*
2302 		 * The underlying ssh is in the same process group, so we must
2303 		 * ignore SIGINT if we want to gracefully abort commands,
2304 		 * otherwise the signal will make it to the ssh process and
2305 		 * kill it too.  Contrawise, since sftp sends SIGTERMs to the
2306 		 * underlying ssh, it must *not* ignore that signal.
2307 		 */
2308 		signal(SIGINT, SIG_IGN);
2309 		signal(SIGTERM, SIG_DFL);
2310 		execvp(path, args);
2311 		fprintf(stderr, "exec: %s: %s\n", path, strerror(errno));
2312 		_exit(1);
2313 	}
2314 
2315 	signal(SIGTERM, killchild);
2316 	signal(SIGINT, killchild);
2317 	signal(SIGHUP, killchild);
2318 	signal(SIGTSTP, suspchild);
2319 	signal(SIGTTIN, suspchild);
2320 	signal(SIGTTOU, suspchild);
2321 	signal(SIGCHLD, sigchld_handler);
2322 	close(c_in);
2323 	close(c_out);
2324 }
2325 
2326 static void
2327 usage(void)
2328 {
2329 	extern char *__progname;
2330 
2331 	fprintf(stderr,
2332 	    "usage: %s [-46aCfpqrv] [-B buffer_size] [-b batchfile] [-c cipher]\n"
2333 	    "          [-D sftp_server_path] [-F ssh_config] "
2334 	    "[-i identity_file] [-l limit]\n"
2335 	    "          [-o ssh_option] [-P port] [-R num_requests] "
2336 	    "[-S program]\n"
2337 	    "          [-s subsystem | sftp_server] destination\n",
2338 	    __progname);
2339 	exit(1);
2340 }
2341 
2342 int
2343 main(int argc, char **argv)
2344 {
2345 	int in, out, ch, err, tmp, port = -1;
2346 	char *host = NULL, *user, *cp, *file2 = NULL;
2347 	int debug_level = 0, sshver = 2;
2348 	char *file1 = NULL, *sftp_server = NULL;
2349 	char *ssh_program = _PATH_SSH_PROGRAM, *sftp_direct = NULL;
2350 	const char *errstr;
2351 	LogLevel ll = SYSLOG_LEVEL_INFO;
2352 	arglist args;
2353 	extern int optind;
2354 	extern char *optarg;
2355 	struct sftp_conn *conn;
2356 	size_t copy_buffer_len = DEFAULT_COPY_BUFLEN;
2357 	size_t num_requests = DEFAULT_NUM_REQUESTS;
2358 	long long limit_kbps = 0;
2359 
2360 	ssh_malloc_init();	/* must be called before any mallocs */
2361 	/* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
2362 	sanitise_stdfd();
2363 	msetlocale();
2364 
2365 	__progname = ssh_get_progname(argv[0]);
2366 	memset(&args, '\0', sizeof(args));
2367 	args.list = NULL;
2368 	addargs(&args, "%s", ssh_program);
2369 	addargs(&args, "-oForwardX11 no");
2370 	addargs(&args, "-oForwardAgent no");
2371 	addargs(&args, "-oPermitLocalCommand no");
2372 	addargs(&args, "-oClearAllForwardings yes");
2373 
2374 	ll = SYSLOG_LEVEL_INFO;
2375 	infile = stdin;
2376 
2377 	while ((ch = getopt(argc, argv,
2378 	    "1246afhpqrvCc:D:i:l:o:s:S:b:B:F:P:R:")) != -1) {
2379 		switch (ch) {
2380 		/* Passed through to ssh(1) */
2381 		case '4':
2382 		case '6':
2383 		case 'C':
2384 			addargs(&args, "-%c", ch);
2385 			break;
2386 		/* Passed through to ssh(1) with argument */
2387 		case 'F':
2388 		case 'c':
2389 		case 'i':
2390 		case 'o':
2391 			addargs(&args, "-%c", ch);
2392 			addargs(&args, "%s", optarg);
2393 			break;
2394 		case 'q':
2395 			ll = SYSLOG_LEVEL_ERROR;
2396 			quiet = 1;
2397 			showprogress = 0;
2398 			addargs(&args, "-%c", ch);
2399 			break;
2400 		case 'P':
2401 			port = a2port(optarg);
2402 			if (port <= 0)
2403 				fatal("Bad port \"%s\"\n", optarg);
2404 			break;
2405 		case 'v':
2406 			if (debug_level < 3) {
2407 				addargs(&args, "-v");
2408 				ll = SYSLOG_LEVEL_DEBUG1 + debug_level;
2409 			}
2410 			debug_level++;
2411 			break;
2412 		case '1':
2413 			sshver = 1;
2414 			if (sftp_server == NULL)
2415 				sftp_server = _PATH_SFTP_SERVER;
2416 			break;
2417 		case '2':
2418 			sshver = 2;
2419 			break;
2420 		case 'a':
2421 			global_aflag = 1;
2422 			break;
2423 		case 'B':
2424 			copy_buffer_len = strtol(optarg, &cp, 10);
2425 			if (copy_buffer_len == 0 || *cp != '\0')
2426 				fatal("Invalid buffer size \"%s\"", optarg);
2427 			break;
2428 		case 'b':
2429 			if (batchmode)
2430 				fatal("Batch file already specified.");
2431 
2432 			/* Allow "-" as stdin */
2433 			if (strcmp(optarg, "-") != 0 &&
2434 			    (infile = fopen(optarg, "r")) == NULL)
2435 				fatal("%s (%s).", strerror(errno), optarg);
2436 			showprogress = 0;
2437 			quiet = batchmode = 1;
2438 			addargs(&args, "-obatchmode yes");
2439 			break;
2440 		case 'f':
2441 			global_fflag = 1;
2442 			break;
2443 		case 'p':
2444 			global_pflag = 1;
2445 			break;
2446 		case 'D':
2447 			sftp_direct = optarg;
2448 			break;
2449 		case 'l':
2450 			limit_kbps = strtonum(optarg, 1, 100 * 1024 * 1024,
2451 			    &errstr);
2452 			if (errstr != NULL)
2453 				usage();
2454 			limit_kbps *= 1024; /* kbps */
2455 			break;
2456 		case 'r':
2457 			global_rflag = 1;
2458 			break;
2459 		case 'R':
2460 			num_requests = strtol(optarg, &cp, 10);
2461 			if (num_requests == 0 || *cp != '\0')
2462 				fatal("Invalid number of requests \"%s\"",
2463 				    optarg);
2464 			break;
2465 		case 's':
2466 			sftp_server = optarg;
2467 			break;
2468 		case 'S':
2469 			ssh_program = optarg;
2470 			replacearg(&args, 0, "%s", ssh_program);
2471 			break;
2472 		case 'h':
2473 		default:
2474 			usage();
2475 		}
2476 	}
2477 
2478 	if (!isatty(STDERR_FILENO))
2479 		showprogress = 0;
2480 
2481 	log_init(argv[0], ll, SYSLOG_FACILITY_USER, 1);
2482 
2483 	if (sftp_direct == NULL) {
2484 		if (optind == argc || argc > (optind + 2))
2485 			usage();
2486 		argv += optind;
2487 
2488 		switch (parse_uri("sftp", *argv, &user, &host, &tmp, &file1)) {
2489 		case -1:
2490 			usage();
2491 			break;
2492 		case 0:
2493 			if (tmp != -1)
2494 				port = tmp;
2495 			break;
2496 		default:
2497 			if (parse_user_host_path(*argv, &user, &host,
2498 			    &file1) == -1) {
2499 				/* Treat as a plain hostname. */
2500 				host = xstrdup(*argv);
2501 				host = cleanhostname(host);
2502 			}
2503 			break;
2504 		}
2505 		file2 = *(argv + 1);
2506 
2507 		if (!*host) {
2508 			fprintf(stderr, "Missing hostname\n");
2509 			usage();
2510 		}
2511 
2512 		if (port != -1)
2513 			addargs(&args, "-oPort %d", port);
2514 		if (user != NULL) {
2515 			addargs(&args, "-l");
2516 			addargs(&args, "%s", user);
2517 		}
2518 		addargs(&args, "-oProtocol %d", sshver);
2519 
2520 		/* no subsystem if the server-spec contains a '/' */
2521 		if (sftp_server == NULL || strchr(sftp_server, '/') == NULL)
2522 			addargs(&args, "-s");
2523 
2524 		addargs(&args, "--");
2525 		addargs(&args, "%s", host);
2526 		addargs(&args, "%s", (sftp_server != NULL ?
2527 		    sftp_server : "sftp"));
2528 
2529 		connect_to_server(ssh_program, args.list, &in, &out);
2530 	} else {
2531 		args.list = NULL;
2532 		addargs(&args, "sftp-server");
2533 
2534 		connect_to_server(sftp_direct, args.list, &in, &out);
2535 	}
2536 	freeargs(&args);
2537 
2538 	conn = do_init(in, out, copy_buffer_len, num_requests, limit_kbps);
2539 	if (conn == NULL)
2540 		fatal("Couldn't initialise connection to server");
2541 
2542 	if (!quiet) {
2543 		if (sftp_direct == NULL)
2544 			fprintf(stderr, "Connected to %s.\n", host);
2545 		else
2546 			fprintf(stderr, "Attached to %s.\n", sftp_direct);
2547 	}
2548 
2549 	err = interactive_loop(conn, file1, file2);
2550 
2551 #if !defined(USE_PIPES)
2552 	shutdown(in, SHUT_RDWR);
2553 	shutdown(out, SHUT_RDWR);
2554 #endif
2555 
2556 	close(in);
2557 	close(out);
2558 	if (batchmode)
2559 		fclose(infile);
2560 
2561 	while (waitpid(sshpid, NULL, 0) == -1 && sshpid > 1)
2562 		if (errno != EINTR)
2563 			fatal("Couldn't wait for ssh process: %s",
2564 			    strerror(errno));
2565 
2566 	exit(err == 0 ? 0 : 1);
2567 }
2568