xref: /openssh-portable/sftp.c (revision b9b0f2ac)
1 /* $OpenBSD: sftp.c,v 1.194 2019/07/10 07:04:27 tb 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 [-h] grp path                Change group of file 'path' to 'grp'\n"
282 	    "chmod [-h] mode path               Change permissions of file 'path' to 'mode'\n"
283 	    "chown [-h] 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 [-afpR] remote [local]         Download file\n"
288 	    "help                               Display this help text\n"
289 	    "lcd path                           Change local directory to 'path'\n"
290 	    "lls [ls-options [path]]            Display local directory listing\n"
291 	    "lmkdir path                        Create local directory\n"
292 	    "ln [-s] oldpath newpath            Link remote file (-s for symlink)\n"
293 	    "lpwd                               Print local working directory\n"
294 	    "ls [-1afhlnrSt] [path]             Display remote directory listing\n"
295 	    "lumask umask                       Set local umask to 'umask'\n"
296 	    "mkdir path                         Create remote directory\n"
297 	    "progress                           Toggle display of progress meter\n"
298 	    "put [-afpR] local [remote]         Upload file\n"
299 	    "pwd                                Display remote working directory\n"
300 	    "quit                               Quit sftp\n"
301 	    "reget [-fpR] remote [local]        Resume download file\n"
302 	    "rename oldpath newpath             Rename remote file\n"
303 	    "reput [-fpR] local [remote]        Resume upload 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 && !path_absolute(p)) {
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_ch_flags(const char *cmd, char **argv, int argc, int *hflag)
566 {
567 	extern int opterr, optind, optopt, optreset;
568 	int ch;
569 
570 	optind = optreset = 1;
571 	opterr = 0;
572 
573 	*hflag = 0;
574 	while ((ch = getopt(argc, argv, "h")) != -1) {
575 		switch (ch) {
576 		case 'h':
577 			*hflag = 1;
578 			break;
579 		default:
580 			error("%s: Invalid flag -%c", cmd, optopt);
581 			return -1;
582 		}
583 	}
584 
585 	return optind;
586 }
587 
588 static int
589 parse_no_flags(const char *cmd, char **argv, int argc)
590 {
591 	extern int opterr, optind, optopt, optreset;
592 	int ch;
593 
594 	optind = optreset = 1;
595 	opterr = 0;
596 
597 	while ((ch = getopt(argc, argv, "")) != -1) {
598 		switch (ch) {
599 		default:
600 			error("%s: Invalid flag -%c", cmd, optopt);
601 			return -1;
602 		}
603 	}
604 
605 	return optind;
606 }
607 
608 static int
609 is_dir(const char *path)
610 {
611 	struct stat sb;
612 
613 	/* XXX: report errors? */
614 	if (stat(path, &sb) == -1)
615 		return(0);
616 
617 	return(S_ISDIR(sb.st_mode));
618 }
619 
620 static int
621 remote_is_dir(struct sftp_conn *conn, const char *path)
622 {
623 	Attrib *a;
624 
625 	/* XXX: report errors? */
626 	if ((a = do_stat(conn, path, 1)) == NULL)
627 		return(0);
628 	if (!(a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS))
629 		return(0);
630 	return(S_ISDIR(a->perm));
631 }
632 
633 /* Check whether path returned from glob(..., GLOB_MARK, ...) is a directory */
634 static int
635 pathname_is_dir(const char *pathname)
636 {
637 	size_t l = strlen(pathname);
638 
639 	return l > 0 && pathname[l - 1] == '/';
640 }
641 
642 static int
643 process_get(struct sftp_conn *conn, const char *src, const char *dst,
644     const char *pwd, int pflag, int rflag, int resume, int fflag)
645 {
646 	char *abs_src = NULL;
647 	char *abs_dst = NULL;
648 	glob_t g;
649 	char *filename, *tmp=NULL;
650 	int i, r, err = 0;
651 
652 	abs_src = xstrdup(src);
653 	abs_src = make_absolute(abs_src, pwd);
654 	memset(&g, 0, sizeof(g));
655 
656 	debug3("Looking up %s", abs_src);
657 	if ((r = remote_glob(conn, abs_src, GLOB_MARK, NULL, &g)) != 0) {
658 		if (r == GLOB_NOSPACE) {
659 			error("Too many matches for \"%s\".", abs_src);
660 		} else {
661 			error("File \"%s\" not found.", abs_src);
662 		}
663 		err = -1;
664 		goto out;
665 	}
666 
667 	/*
668 	 * If multiple matches then dst must be a directory or
669 	 * unspecified.
670 	 */
671 	if (g.gl_matchc > 1 && dst != NULL && !is_dir(dst)) {
672 		error("Multiple source paths, but destination "
673 		    "\"%s\" is not a directory", dst);
674 		err = -1;
675 		goto out;
676 	}
677 
678 	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
679 		tmp = xstrdup(g.gl_pathv[i]);
680 		if ((filename = basename(tmp)) == NULL) {
681 			error("basename %s: %s", tmp, strerror(errno));
682 			free(tmp);
683 			err = -1;
684 			goto out;
685 		}
686 
687 		if (g.gl_matchc == 1 && dst) {
688 			if (is_dir(dst)) {
689 				abs_dst = path_append(dst, filename);
690 			} else {
691 				abs_dst = xstrdup(dst);
692 			}
693 		} else if (dst) {
694 			abs_dst = path_append(dst, filename);
695 		} else {
696 			abs_dst = xstrdup(filename);
697 		}
698 		free(tmp);
699 
700 		resume |= global_aflag;
701 		if (!quiet && resume)
702 			mprintf("Resuming %s to %s\n",
703 			    g.gl_pathv[i], abs_dst);
704 		else if (!quiet && !resume)
705 			mprintf("Fetching %s to %s\n",
706 			    g.gl_pathv[i], abs_dst);
707 		if (pathname_is_dir(g.gl_pathv[i]) && (rflag || global_rflag)) {
708 			if (download_dir(conn, g.gl_pathv[i], abs_dst, NULL,
709 			    pflag || global_pflag, 1, resume,
710 			    fflag || global_fflag) == -1)
711 				err = -1;
712 		} else {
713 			if (do_download(conn, g.gl_pathv[i], abs_dst, NULL,
714 			    pflag || global_pflag, resume,
715 			    fflag || global_fflag) == -1)
716 				err = -1;
717 		}
718 		free(abs_dst);
719 		abs_dst = NULL;
720 	}
721 
722 out:
723 	free(abs_src);
724 	globfree(&g);
725 	return(err);
726 }
727 
728 static int
729 process_put(struct sftp_conn *conn, const char *src, const char *dst,
730     const char *pwd, int pflag, int rflag, int resume, int fflag)
731 {
732 	char *tmp_dst = NULL;
733 	char *abs_dst = NULL;
734 	char *tmp = NULL, *filename = NULL;
735 	glob_t g;
736 	int err = 0;
737 	int i, dst_is_dir = 1;
738 	struct stat sb;
739 
740 	if (dst) {
741 		tmp_dst = xstrdup(dst);
742 		tmp_dst = make_absolute(tmp_dst, pwd);
743 	}
744 
745 	memset(&g, 0, sizeof(g));
746 	debug3("Looking up %s", src);
747 	if (glob(src, GLOB_NOCHECK | GLOB_MARK, NULL, &g)) {
748 		error("File \"%s\" not found.", src);
749 		err = -1;
750 		goto out;
751 	}
752 
753 	/* If we aren't fetching to pwd then stash this status for later */
754 	if (tmp_dst != NULL)
755 		dst_is_dir = remote_is_dir(conn, tmp_dst);
756 
757 	/* If multiple matches, dst may be directory or unspecified */
758 	if (g.gl_matchc > 1 && tmp_dst && !dst_is_dir) {
759 		error("Multiple paths match, but destination "
760 		    "\"%s\" is not a directory", tmp_dst);
761 		err = -1;
762 		goto out;
763 	}
764 
765 	for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
766 		if (stat(g.gl_pathv[i], &sb) == -1) {
767 			err = -1;
768 			error("stat %s: %s", g.gl_pathv[i], strerror(errno));
769 			continue;
770 		}
771 
772 		tmp = xstrdup(g.gl_pathv[i]);
773 		if ((filename = basename(tmp)) == NULL) {
774 			error("basename %s: %s", tmp, strerror(errno));
775 			free(tmp);
776 			err = -1;
777 			goto out;
778 		}
779 
780 		if (g.gl_matchc == 1 && tmp_dst) {
781 			/* If directory specified, append filename */
782 			if (dst_is_dir)
783 				abs_dst = path_append(tmp_dst, filename);
784 			else
785 				abs_dst = xstrdup(tmp_dst);
786 		} else if (tmp_dst) {
787 			abs_dst = path_append(tmp_dst, filename);
788 		} else {
789 			abs_dst = make_absolute(xstrdup(filename), pwd);
790 		}
791 		free(tmp);
792 
793                 resume |= global_aflag;
794 		if (!quiet && resume)
795 			mprintf("Resuming upload of %s to %s\n",
796 			    g.gl_pathv[i], abs_dst);
797 		else if (!quiet && !resume)
798 			mprintf("Uploading %s to %s\n",
799 			    g.gl_pathv[i], abs_dst);
800 		if (pathname_is_dir(g.gl_pathv[i]) && (rflag || global_rflag)) {
801 			if (upload_dir(conn, g.gl_pathv[i], abs_dst,
802 			    pflag || global_pflag, 1, resume,
803 			    fflag || global_fflag) == -1)
804 				err = -1;
805 		} else {
806 			if (do_upload(conn, g.gl_pathv[i], abs_dst,
807 			    pflag || global_pflag, resume,
808 			    fflag || global_fflag) == -1)
809 				err = -1;
810 		}
811 	}
812 
813 out:
814 	free(abs_dst);
815 	free(tmp_dst);
816 	globfree(&g);
817 	return(err);
818 }
819 
820 static int
821 sdirent_comp(const void *aa, const void *bb)
822 {
823 	SFTP_DIRENT *a = *(SFTP_DIRENT **)aa;
824 	SFTP_DIRENT *b = *(SFTP_DIRENT **)bb;
825 	int rmul = sort_flag & LS_REVERSE_SORT ? -1 : 1;
826 
827 #define NCMP(a,b) (a == b ? 0 : (a < b ? 1 : -1))
828 	if (sort_flag & LS_NAME_SORT)
829 		return (rmul * strcmp(a->filename, b->filename));
830 	else if (sort_flag & LS_TIME_SORT)
831 		return (rmul * NCMP(a->a.mtime, b->a.mtime));
832 	else if (sort_flag & LS_SIZE_SORT)
833 		return (rmul * NCMP(a->a.size, b->a.size));
834 
835 	fatal("Unknown ls sort type");
836 }
837 
838 /* sftp ls.1 replacement for directories */
839 static int
840 do_ls_dir(struct sftp_conn *conn, const char *path,
841     const char *strip_path, int lflag)
842 {
843 	int n;
844 	u_int c = 1, colspace = 0, columns = 1;
845 	SFTP_DIRENT **d;
846 
847 	if ((n = do_readdir(conn, path, &d)) != 0)
848 		return (n);
849 
850 	if (!(lflag & LS_SHORT_VIEW)) {
851 		u_int m = 0, width = 80;
852 		struct winsize ws;
853 		char *tmp;
854 
855 		/* Count entries for sort and find longest filename */
856 		for (n = 0; d[n] != NULL; n++) {
857 			if (d[n]->filename[0] != '.' || (lflag & LS_SHOW_ALL))
858 				m = MAXIMUM(m, strlen(d[n]->filename));
859 		}
860 
861 		/* Add any subpath that also needs to be counted */
862 		tmp = path_strip(path, strip_path);
863 		m += strlen(tmp);
864 		free(tmp);
865 
866 		if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) != -1)
867 			width = ws.ws_col;
868 
869 		columns = width / (m + 2);
870 		columns = MAXIMUM(columns, 1);
871 		colspace = width / columns;
872 		colspace = MINIMUM(colspace, width);
873 	}
874 
875 	if (lflag & SORT_FLAGS) {
876 		for (n = 0; d[n] != NULL; n++)
877 			;	/* count entries */
878 		sort_flag = lflag & (SORT_FLAGS|LS_REVERSE_SORT);
879 		qsort(d, n, sizeof(*d), sdirent_comp);
880 	}
881 
882 	for (n = 0; d[n] != NULL && !interrupted; n++) {
883 		char *tmp, *fname;
884 
885 		if (d[n]->filename[0] == '.' && !(lflag & LS_SHOW_ALL))
886 			continue;
887 
888 		tmp = path_append(path, d[n]->filename);
889 		fname = path_strip(tmp, strip_path);
890 		free(tmp);
891 
892 		if (lflag & LS_LONG_VIEW) {
893 			if (lflag & (LS_NUMERIC_VIEW|LS_SI_UNITS)) {
894 				char *lname;
895 				struct stat sb;
896 
897 				memset(&sb, 0, sizeof(sb));
898 				attrib_to_stat(&d[n]->a, &sb);
899 				lname = ls_file(fname, &sb, 1,
900 				    (lflag & LS_SI_UNITS));
901 				mprintf("%s\n", lname);
902 				free(lname);
903 			} else
904 				mprintf("%s\n", d[n]->longname);
905 		} else {
906 			mprintf("%-*s", colspace, fname);
907 			if (c >= columns) {
908 				printf("\n");
909 				c = 1;
910 			} else
911 				c++;
912 		}
913 
914 		free(fname);
915 	}
916 
917 	if (!(lflag & LS_LONG_VIEW) && (c != 1))
918 		printf("\n");
919 
920 	free_sftp_dirents(d);
921 	return (0);
922 }
923 
924 static int
925 sglob_comp(const void *aa, const void *bb)
926 {
927 	u_int a = *(const u_int *)aa;
928 	u_int b = *(const u_int *)bb;
929 	const char *ap = sort_glob->gl_pathv[a];
930 	const char *bp = sort_glob->gl_pathv[b];
931 	const struct stat *as = sort_glob->gl_statv[a];
932 	const struct stat *bs = sort_glob->gl_statv[b];
933 	int rmul = sort_flag & LS_REVERSE_SORT ? -1 : 1;
934 
935 #define NCMP(a,b) (a == b ? 0 : (a < b ? 1 : -1))
936 	if (sort_flag & LS_NAME_SORT)
937 		return (rmul * strcmp(ap, bp));
938 	else if (sort_flag & LS_TIME_SORT) {
939 #if defined(HAVE_STRUCT_STAT_ST_MTIM)
940 		return (rmul * timespeccmp(&as->st_mtim, &bs->st_mtim, <));
941 #elif defined(HAVE_STRUCT_STAT_ST_MTIME)
942 		return (rmul * NCMP(as->st_mtime, bs->st_mtime));
943 #else
944 	return rmul * 1;
945 #endif
946 	} else if (sort_flag & LS_SIZE_SORT)
947 		return (rmul * NCMP(as->st_size, bs->st_size));
948 
949 	fatal("Unknown ls sort type");
950 }
951 
952 /* sftp ls.1 replacement which handles path globs */
953 static int
954 do_globbed_ls(struct sftp_conn *conn, const char *path,
955     const char *strip_path, int lflag)
956 {
957 	char *fname, *lname;
958 	glob_t g;
959 	int err, r;
960 	struct winsize ws;
961 	u_int i, j, nentries, *indices = NULL, c = 1;
962 	u_int colspace = 0, columns = 1, m = 0, width = 80;
963 
964 	memset(&g, 0, sizeof(g));
965 
966 	if ((r = remote_glob(conn, path,
967 	    GLOB_MARK|GLOB_NOCHECK|GLOB_BRACE|GLOB_KEEPSTAT|GLOB_NOSORT,
968 	    NULL, &g)) != 0 ||
969 	    (g.gl_pathc && !g.gl_matchc)) {
970 		if (g.gl_pathc)
971 			globfree(&g);
972 		if (r == GLOB_NOSPACE) {
973 			error("Can't ls: Too many matches for \"%s\"", path);
974 		} else {
975 			error("Can't ls: \"%s\" not found", path);
976 		}
977 		return -1;
978 	}
979 
980 	if (interrupted)
981 		goto out;
982 
983 	/*
984 	 * If the glob returns a single match and it is a directory,
985 	 * then just list its contents.
986 	 */
987 	if (g.gl_matchc == 1 && g.gl_statv[0] != NULL &&
988 	    S_ISDIR(g.gl_statv[0]->st_mode)) {
989 		err = do_ls_dir(conn, g.gl_pathv[0], strip_path, lflag);
990 		globfree(&g);
991 		return err;
992 	}
993 
994 	if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) != -1)
995 		width = ws.ws_col;
996 
997 	if (!(lflag & LS_SHORT_VIEW)) {
998 		/* Count entries for sort and find longest filename */
999 		for (i = 0; g.gl_pathv[i]; i++)
1000 			m = MAXIMUM(m, strlen(g.gl_pathv[i]));
1001 
1002 		columns = width / (m + 2);
1003 		columns = MAXIMUM(columns, 1);
1004 		colspace = width / columns;
1005 	}
1006 
1007 	/*
1008 	 * Sorting: rather than mess with the contents of glob_t, prepare
1009 	 * an array of indices into it and sort that. For the usual
1010 	 * unsorted case, the indices are just the identity 1=1, 2=2, etc.
1011 	 */
1012 	for (nentries = 0; g.gl_pathv[nentries] != NULL; nentries++)
1013 		;	/* count entries */
1014 	indices = calloc(nentries, sizeof(*indices));
1015 	for (i = 0; i < nentries; i++)
1016 		indices[i] = i;
1017 
1018 	if (lflag & SORT_FLAGS) {
1019 		sort_glob = &g;
1020 		sort_flag = lflag & (SORT_FLAGS|LS_REVERSE_SORT);
1021 		qsort(indices, nentries, sizeof(*indices), sglob_comp);
1022 		sort_glob = NULL;
1023 	}
1024 
1025 	for (j = 0; j < nentries && !interrupted; j++) {
1026 		i = indices[j];
1027 		fname = path_strip(g.gl_pathv[i], strip_path);
1028 		if (lflag & LS_LONG_VIEW) {
1029 			if (g.gl_statv[i] == NULL) {
1030 				error("no stat information for %s", fname);
1031 				continue;
1032 			}
1033 			lname = ls_file(fname, g.gl_statv[i], 1,
1034 			    (lflag & LS_SI_UNITS));
1035 			mprintf("%s\n", lname);
1036 			free(lname);
1037 		} else {
1038 			mprintf("%-*s", colspace, fname);
1039 			if (c >= columns) {
1040 				printf("\n");
1041 				c = 1;
1042 			} else
1043 				c++;
1044 		}
1045 		free(fname);
1046 	}
1047 
1048 	if (!(lflag & LS_LONG_VIEW) && (c != 1))
1049 		printf("\n");
1050 
1051  out:
1052 	if (g.gl_pathc)
1053 		globfree(&g);
1054 	free(indices);
1055 
1056 	return 0;
1057 }
1058 
1059 static int
1060 do_df(struct sftp_conn *conn, const char *path, int hflag, int iflag)
1061 {
1062 	struct sftp_statvfs st;
1063 	char s_used[FMT_SCALED_STRSIZE], s_avail[FMT_SCALED_STRSIZE];
1064 	char s_root[FMT_SCALED_STRSIZE], s_total[FMT_SCALED_STRSIZE];
1065 	char s_icapacity[16], s_dcapacity[16];
1066 
1067 	if (do_statvfs(conn, path, &st, 1) == -1)
1068 		return -1;
1069 	if (st.f_files == 0)
1070 		strlcpy(s_icapacity, "ERR", sizeof(s_icapacity));
1071 	else {
1072 		snprintf(s_icapacity, sizeof(s_icapacity), "%3llu%%",
1073 		    (unsigned long long)(100 * (st.f_files - st.f_ffree) /
1074 		    st.f_files));
1075 	}
1076 	if (st.f_blocks == 0)
1077 		strlcpy(s_dcapacity, "ERR", sizeof(s_dcapacity));
1078 	else {
1079 		snprintf(s_dcapacity, sizeof(s_dcapacity), "%3llu%%",
1080 		    (unsigned long long)(100 * (st.f_blocks - st.f_bfree) /
1081 		    st.f_blocks));
1082 	}
1083 	if (iflag) {
1084 		printf("     Inodes        Used       Avail      "
1085 		    "(root)    %%Capacity\n");
1086 		printf("%11llu %11llu %11llu %11llu         %s\n",
1087 		    (unsigned long long)st.f_files,
1088 		    (unsigned long long)(st.f_files - st.f_ffree),
1089 		    (unsigned long long)st.f_favail,
1090 		    (unsigned long long)st.f_ffree, s_icapacity);
1091 	} else if (hflag) {
1092 		strlcpy(s_used, "error", sizeof(s_used));
1093 		strlcpy(s_avail, "error", sizeof(s_avail));
1094 		strlcpy(s_root, "error", sizeof(s_root));
1095 		strlcpy(s_total, "error", sizeof(s_total));
1096 		fmt_scaled((st.f_blocks - st.f_bfree) * st.f_frsize, s_used);
1097 		fmt_scaled(st.f_bavail * st.f_frsize, s_avail);
1098 		fmt_scaled(st.f_bfree * st.f_frsize, s_root);
1099 		fmt_scaled(st.f_blocks * st.f_frsize, s_total);
1100 		printf("    Size     Used    Avail   (root)    %%Capacity\n");
1101 		printf("%7sB %7sB %7sB %7sB         %s\n",
1102 		    s_total, s_used, s_avail, s_root, s_dcapacity);
1103 	} else {
1104 		printf("        Size         Used        Avail       "
1105 		    "(root)    %%Capacity\n");
1106 		printf("%12llu %12llu %12llu %12llu         %s\n",
1107 		    (unsigned long long)(st.f_frsize * st.f_blocks / 1024),
1108 		    (unsigned long long)(st.f_frsize *
1109 		    (st.f_blocks - st.f_bfree) / 1024),
1110 		    (unsigned long long)(st.f_frsize * st.f_bavail / 1024),
1111 		    (unsigned long long)(st.f_frsize * st.f_bfree / 1024),
1112 		    s_dcapacity);
1113 	}
1114 	return 0;
1115 }
1116 
1117 /*
1118  * Undo escaping of glob sequences in place. Used to undo extra escaping
1119  * applied in makeargv() when the string is destined for a function that
1120  * does not glob it.
1121  */
1122 static void
1123 undo_glob_escape(char *s)
1124 {
1125 	size_t i, j;
1126 
1127 	for (i = j = 0;;) {
1128 		if (s[i] == '\0') {
1129 			s[j] = '\0';
1130 			return;
1131 		}
1132 		if (s[i] != '\\') {
1133 			s[j++] = s[i++];
1134 			continue;
1135 		}
1136 		/* s[i] == '\\' */
1137 		++i;
1138 		switch (s[i]) {
1139 		case '?':
1140 		case '[':
1141 		case '*':
1142 		case '\\':
1143 			s[j++] = s[i++];
1144 			break;
1145 		case '\0':
1146 			s[j++] = '\\';
1147 			s[j] = '\0';
1148 			return;
1149 		default:
1150 			s[j++] = '\\';
1151 			s[j++] = s[i++];
1152 			break;
1153 		}
1154 	}
1155 }
1156 
1157 /*
1158  * Split a string into an argument vector using sh(1)-style quoting,
1159  * comment and escaping rules, but with some tweaks to handle glob(3)
1160  * wildcards.
1161  * The "sloppy" flag allows for recovery from missing terminating quote, for
1162  * use in parsing incomplete commandlines during tab autocompletion.
1163  *
1164  * Returns NULL on error or a NULL-terminated array of arguments.
1165  *
1166  * If "lastquote" is not NULL, the quoting character used for the last
1167  * argument is placed in *lastquote ("\0", "'" or "\"").
1168  *
1169  * If "terminated" is not NULL, *terminated will be set to 1 when the
1170  * last argument's quote has been properly terminated or 0 otherwise.
1171  * This parameter is only of use if "sloppy" is set.
1172  */
1173 #define MAXARGS 	128
1174 #define MAXARGLEN	8192
1175 static char **
1176 makeargv(const char *arg, int *argcp, int sloppy, char *lastquote,
1177     u_int *terminated)
1178 {
1179 	int argc, quot;
1180 	size_t i, j;
1181 	static char argvs[MAXARGLEN];
1182 	static char *argv[MAXARGS + 1];
1183 	enum { MA_START, MA_SQUOTE, MA_DQUOTE, MA_UNQUOTED } state, q;
1184 
1185 	*argcp = argc = 0;
1186 	if (strlen(arg) > sizeof(argvs) - 1) {
1187  args_too_longs:
1188 		error("string too long");
1189 		return NULL;
1190 	}
1191 	if (terminated != NULL)
1192 		*terminated = 1;
1193 	if (lastquote != NULL)
1194 		*lastquote = '\0';
1195 	state = MA_START;
1196 	i = j = 0;
1197 	for (;;) {
1198 		if ((size_t)argc >= sizeof(argv) / sizeof(*argv)){
1199 			error("Too many arguments.");
1200 			return NULL;
1201 		}
1202 		if (isspace((unsigned char)arg[i])) {
1203 			if (state == MA_UNQUOTED) {
1204 				/* Terminate current argument */
1205 				argvs[j++] = '\0';
1206 				argc++;
1207 				state = MA_START;
1208 			} else if (state != MA_START)
1209 				argvs[j++] = arg[i];
1210 		} else if (arg[i] == '"' || arg[i] == '\'') {
1211 			q = arg[i] == '"' ? MA_DQUOTE : MA_SQUOTE;
1212 			if (state == MA_START) {
1213 				argv[argc] = argvs + j;
1214 				state = q;
1215 				if (lastquote != NULL)
1216 					*lastquote = arg[i];
1217 			} else if (state == MA_UNQUOTED)
1218 				state = q;
1219 			else if (state == q)
1220 				state = MA_UNQUOTED;
1221 			else
1222 				argvs[j++] = arg[i];
1223 		} else if (arg[i] == '\\') {
1224 			if (state == MA_SQUOTE || state == MA_DQUOTE) {
1225 				quot = state == MA_SQUOTE ? '\'' : '"';
1226 				/* Unescape quote we are in */
1227 				/* XXX support \n and friends? */
1228 				if (arg[i + 1] == quot) {
1229 					i++;
1230 					argvs[j++] = arg[i];
1231 				} else if (arg[i + 1] == '?' ||
1232 				    arg[i + 1] == '[' || arg[i + 1] == '*') {
1233 					/*
1234 					 * Special case for sftp: append
1235 					 * double-escaped glob sequence -
1236 					 * glob will undo one level of
1237 					 * escaping. NB. string can grow here.
1238 					 */
1239 					if (j >= sizeof(argvs) - 5)
1240 						goto args_too_longs;
1241 					argvs[j++] = '\\';
1242 					argvs[j++] = arg[i++];
1243 					argvs[j++] = '\\';
1244 					argvs[j++] = arg[i];
1245 				} else {
1246 					argvs[j++] = arg[i++];
1247 					argvs[j++] = arg[i];
1248 				}
1249 			} else {
1250 				if (state == MA_START) {
1251 					argv[argc] = argvs + j;
1252 					state = MA_UNQUOTED;
1253 					if (lastquote != NULL)
1254 						*lastquote = '\0';
1255 				}
1256 				if (arg[i + 1] == '?' || arg[i + 1] == '[' ||
1257 				    arg[i + 1] == '*' || arg[i + 1] == '\\') {
1258 					/*
1259 					 * Special case for sftp: append
1260 					 * escaped glob sequence -
1261 					 * glob will undo one level of
1262 					 * escaping.
1263 					 */
1264 					argvs[j++] = arg[i++];
1265 					argvs[j++] = arg[i];
1266 				} else {
1267 					/* Unescape everything */
1268 					/* XXX support \n and friends? */
1269 					i++;
1270 					argvs[j++] = arg[i];
1271 				}
1272 			}
1273 		} else if (arg[i] == '#') {
1274 			if (state == MA_SQUOTE || state == MA_DQUOTE)
1275 				argvs[j++] = arg[i];
1276 			else
1277 				goto string_done;
1278 		} else if (arg[i] == '\0') {
1279 			if (state == MA_SQUOTE || state == MA_DQUOTE) {
1280 				if (sloppy) {
1281 					state = MA_UNQUOTED;
1282 					if (terminated != NULL)
1283 						*terminated = 0;
1284 					goto string_done;
1285 				}
1286 				error("Unterminated quoted argument");
1287 				return NULL;
1288 			}
1289  string_done:
1290 			if (state == MA_UNQUOTED) {
1291 				argvs[j++] = '\0';
1292 				argc++;
1293 			}
1294 			break;
1295 		} else {
1296 			if (state == MA_START) {
1297 				argv[argc] = argvs + j;
1298 				state = MA_UNQUOTED;
1299 				if (lastquote != NULL)
1300 					*lastquote = '\0';
1301 			}
1302 			if ((state == MA_SQUOTE || state == MA_DQUOTE) &&
1303 			    (arg[i] == '?' || arg[i] == '[' || arg[i] == '*')) {
1304 				/*
1305 				 * Special case for sftp: escape quoted
1306 				 * glob(3) wildcards. NB. string can grow
1307 				 * here.
1308 				 */
1309 				if (j >= sizeof(argvs) - 3)
1310 					goto args_too_longs;
1311 				argvs[j++] = '\\';
1312 				argvs[j++] = arg[i];
1313 			} else
1314 				argvs[j++] = arg[i];
1315 		}
1316 		i++;
1317 	}
1318 	*argcp = argc;
1319 	return argv;
1320 }
1321 
1322 static int
1323 parse_args(const char **cpp, int *ignore_errors, int *disable_echo, int *aflag,
1324 	  int *fflag, int *hflag, int *iflag, int *lflag, int *pflag,
1325 	  int *rflag, int *sflag,
1326     unsigned long *n_arg, char **path1, char **path2)
1327 {
1328 	const char *cmd, *cp = *cpp;
1329 	char *cp2, **argv;
1330 	int base = 0;
1331 	long l;
1332 	int path1_mandatory = 0, i, cmdnum, optidx, argc;
1333 
1334 	/* Skip leading whitespace */
1335 	cp = cp + strspn(cp, WHITESPACE);
1336 
1337 	/*
1338 	 * Check for leading '-' (disable error processing) and '@' (suppress
1339 	 * command echo)
1340 	 */
1341 	*ignore_errors = 0;
1342 	*disable_echo = 0;
1343 	for (;*cp != '\0'; cp++) {
1344 		if (*cp == '-') {
1345 			*ignore_errors = 1;
1346 		} else if (*cp == '@') {
1347 			*disable_echo = 1;
1348 		} else {
1349 			/* all other characters terminate prefix processing */
1350 			break;
1351 		}
1352 	}
1353 	cp = cp + strspn(cp, WHITESPACE);
1354 
1355 	/* Ignore blank lines and lines which begin with comment '#' char */
1356 	if (*cp == '\0' || *cp == '#')
1357 		return (0);
1358 
1359 	if ((argv = makeargv(cp, &argc, 0, NULL, NULL)) == NULL)
1360 		return -1;
1361 
1362 	/* Figure out which command we have */
1363 	for (i = 0; cmds[i].c != NULL; i++) {
1364 		if (argv[0] != NULL && strcasecmp(cmds[i].c, argv[0]) == 0)
1365 			break;
1366 	}
1367 	cmdnum = cmds[i].n;
1368 	cmd = cmds[i].c;
1369 
1370 	/* Special case */
1371 	if (*cp == '!') {
1372 		cp++;
1373 		cmdnum = I_SHELL;
1374 	} else if (cmdnum == -1) {
1375 		error("Invalid command.");
1376 		return -1;
1377 	}
1378 
1379 	/* Get arguments and parse flags */
1380 	*aflag = *fflag = *hflag = *iflag = *lflag = *pflag = 0;
1381 	*rflag = *sflag = 0;
1382 	*path1 = *path2 = NULL;
1383 	optidx = 1;
1384 	switch (cmdnum) {
1385 	case I_GET:
1386 	case I_REGET:
1387 	case I_REPUT:
1388 	case I_PUT:
1389 		if ((optidx = parse_getput_flags(cmd, argv, argc,
1390 		    aflag, fflag, pflag, rflag)) == -1)
1391 			return -1;
1392 		/* Get first pathname (mandatory) */
1393 		if (argc - optidx < 1) {
1394 			error("You must specify at least one path after a "
1395 			    "%s command.", cmd);
1396 			return -1;
1397 		}
1398 		*path1 = xstrdup(argv[optidx]);
1399 		/* Get second pathname (optional) */
1400 		if (argc - optidx > 1) {
1401 			*path2 = xstrdup(argv[optidx + 1]);
1402 			/* Destination is not globbed */
1403 			undo_glob_escape(*path2);
1404 		}
1405 		break;
1406 	case I_LINK:
1407 		if ((optidx = parse_link_flags(cmd, argv, argc, sflag)) == -1)
1408 			return -1;
1409 		goto parse_two_paths;
1410 	case I_RENAME:
1411 		if ((optidx = parse_rename_flags(cmd, argv, argc, lflag)) == -1)
1412 			return -1;
1413 		goto parse_two_paths;
1414 	case I_SYMLINK:
1415 		if ((optidx = parse_no_flags(cmd, argv, argc)) == -1)
1416 			return -1;
1417  parse_two_paths:
1418 		if (argc - optidx < 2) {
1419 			error("You must specify two paths after a %s "
1420 			    "command.", cmd);
1421 			return -1;
1422 		}
1423 		*path1 = xstrdup(argv[optidx]);
1424 		*path2 = xstrdup(argv[optidx + 1]);
1425 		/* Paths are not globbed */
1426 		undo_glob_escape(*path1);
1427 		undo_glob_escape(*path2);
1428 		break;
1429 	case I_RM:
1430 	case I_MKDIR:
1431 	case I_RMDIR:
1432 	case I_LMKDIR:
1433 		path1_mandatory = 1;
1434 		/* FALLTHROUGH */
1435 	case I_CHDIR:
1436 	case I_LCHDIR:
1437 		if ((optidx = parse_no_flags(cmd, argv, argc)) == -1)
1438 			return -1;
1439 		/* Get pathname (mandatory) */
1440 		if (argc - optidx < 1) {
1441 			if (!path1_mandatory)
1442 				break; /* return a NULL path1 */
1443 			error("You must specify a path after a %s command.",
1444 			    cmd);
1445 			return -1;
1446 		}
1447 		*path1 = xstrdup(argv[optidx]);
1448 		/* Only "rm" globs */
1449 		if (cmdnum != I_RM)
1450 			undo_glob_escape(*path1);
1451 		break;
1452 	case I_DF:
1453 		if ((optidx = parse_df_flags(cmd, argv, argc, hflag,
1454 		    iflag)) == -1)
1455 			return -1;
1456 		/* Default to current directory if no path specified */
1457 		if (argc - optidx < 1)
1458 			*path1 = NULL;
1459 		else {
1460 			*path1 = xstrdup(argv[optidx]);
1461 			undo_glob_escape(*path1);
1462 		}
1463 		break;
1464 	case I_LS:
1465 		if ((optidx = parse_ls_flags(argv, argc, lflag)) == -1)
1466 			return(-1);
1467 		/* Path is optional */
1468 		if (argc - optidx > 0)
1469 			*path1 = xstrdup(argv[optidx]);
1470 		break;
1471 	case I_LLS:
1472 		/* Skip ls command and following whitespace */
1473 		cp = cp + strlen(cmd) + strspn(cp, WHITESPACE);
1474 	case I_SHELL:
1475 		/* Uses the rest of the line */
1476 		break;
1477 	case I_LUMASK:
1478 	case I_CHMOD:
1479 		base = 8;
1480 		/* FALLTHROUGH */
1481 	case I_CHOWN:
1482 	case I_CHGRP:
1483 		if ((optidx = parse_ch_flags(cmd, argv, argc, hflag)) == -1)
1484 			return -1;
1485 		/* Get numeric arg (mandatory) */
1486 		if (argc - optidx < 1)
1487 			goto need_num_arg;
1488 		errno = 0;
1489 		l = strtol(argv[optidx], &cp2, base);
1490 		if (cp2 == argv[optidx] || *cp2 != '\0' ||
1491 		    ((l == LONG_MIN || l == LONG_MAX) && errno == ERANGE) ||
1492 		    l < 0) {
1493  need_num_arg:
1494 			error("You must supply a numeric argument "
1495 			    "to the %s command.", cmd);
1496 			return -1;
1497 		}
1498 		*n_arg = l;
1499 		if (cmdnum == I_LUMASK)
1500 			break;
1501 		/* Get pathname (mandatory) */
1502 		if (argc - optidx < 2) {
1503 			error("You must specify a path after a %s command.",
1504 			    cmd);
1505 			return -1;
1506 		}
1507 		*path1 = xstrdup(argv[optidx + 1]);
1508 		break;
1509 	case I_QUIT:
1510 	case I_PWD:
1511 	case I_LPWD:
1512 	case I_HELP:
1513 	case I_VERSION:
1514 	case I_PROGRESS:
1515 		if ((optidx = parse_no_flags(cmd, argv, argc)) == -1)
1516 			return -1;
1517 		break;
1518 	default:
1519 		fatal("Command not implemented");
1520 	}
1521 
1522 	*cpp = cp;
1523 	return(cmdnum);
1524 }
1525 
1526 static int
1527 parse_dispatch_command(struct sftp_conn *conn, const char *cmd, char **pwd,
1528     const char *startdir, int err_abort, int echo_command)
1529 {
1530 	const char *ocmd = cmd;
1531 	char *path1, *path2, *tmp;
1532 	int ignore_errors = 0, disable_echo = 1;
1533 	int aflag = 0, fflag = 0, hflag = 0, iflag = 0;
1534 	int lflag = 0, pflag = 0, rflag = 0, sflag = 0;
1535 	int cmdnum, i;
1536 	unsigned long n_arg = 0;
1537 	Attrib a, *aa;
1538 	char path_buf[PATH_MAX];
1539 	int err = 0;
1540 	glob_t g;
1541 
1542 	path1 = path2 = NULL;
1543 	cmdnum = parse_args(&cmd, &ignore_errors, &disable_echo, &aflag, &fflag,
1544 	    &hflag, &iflag, &lflag, &pflag, &rflag, &sflag, &n_arg,
1545 	    &path1, &path2);
1546 	if (ignore_errors != 0)
1547 		err_abort = 0;
1548 
1549 	if (echo_command && !disable_echo)
1550 		mprintf("sftp> %s\n", ocmd);
1551 
1552 	memset(&g, 0, sizeof(g));
1553 
1554 	/* Perform command */
1555 	switch (cmdnum) {
1556 	case 0:
1557 		/* Blank line */
1558 		break;
1559 	case -1:
1560 		/* Unrecognized command */
1561 		err = -1;
1562 		break;
1563 	case I_REGET:
1564 		aflag = 1;
1565 		/* FALLTHROUGH */
1566 	case I_GET:
1567 		err = process_get(conn, path1, path2, *pwd, pflag,
1568 		    rflag, aflag, fflag);
1569 		break;
1570 	case I_REPUT:
1571 		aflag = 1;
1572 		/* FALLTHROUGH */
1573 	case I_PUT:
1574 		err = process_put(conn, path1, path2, *pwd, pflag,
1575 		    rflag, aflag, fflag);
1576 		break;
1577 	case I_RENAME:
1578 		path1 = make_absolute(path1, *pwd);
1579 		path2 = make_absolute(path2, *pwd);
1580 		err = do_rename(conn, path1, path2, lflag);
1581 		break;
1582 	case I_SYMLINK:
1583 		sflag = 1;
1584 		/* FALLTHROUGH */
1585 	case I_LINK:
1586 		if (!sflag)
1587 			path1 = make_absolute(path1, *pwd);
1588 		path2 = make_absolute(path2, *pwd);
1589 		err = (sflag ? do_symlink : do_hardlink)(conn, path1, path2);
1590 		break;
1591 	case I_RM:
1592 		path1 = make_absolute(path1, *pwd);
1593 		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
1594 		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1595 			if (!quiet)
1596 				mprintf("Removing %s\n", g.gl_pathv[i]);
1597 			err = do_rm(conn, g.gl_pathv[i]);
1598 			if (err != 0 && err_abort)
1599 				break;
1600 		}
1601 		break;
1602 	case I_MKDIR:
1603 		path1 = make_absolute(path1, *pwd);
1604 		attrib_clear(&a);
1605 		a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
1606 		a.perm = 0777;
1607 		err = do_mkdir(conn, path1, &a, 1);
1608 		break;
1609 	case I_RMDIR:
1610 		path1 = make_absolute(path1, *pwd);
1611 		err = do_rmdir(conn, path1);
1612 		break;
1613 	case I_CHDIR:
1614 		if (path1 == NULL || *path1 == '\0')
1615 			path1 = xstrdup(startdir);
1616 		path1 = make_absolute(path1, *pwd);
1617 		if ((tmp = do_realpath(conn, path1)) == NULL) {
1618 			err = 1;
1619 			break;
1620 		}
1621 		if ((aa = do_stat(conn, tmp, 0)) == NULL) {
1622 			free(tmp);
1623 			err = 1;
1624 			break;
1625 		}
1626 		if (!(aa->flags & SSH2_FILEXFER_ATTR_PERMISSIONS)) {
1627 			error("Can't change directory: Can't check target");
1628 			free(tmp);
1629 			err = 1;
1630 			break;
1631 		}
1632 		if (!S_ISDIR(aa->perm)) {
1633 			error("Can't change directory: \"%s\" is not "
1634 			    "a directory", tmp);
1635 			free(tmp);
1636 			err = 1;
1637 			break;
1638 		}
1639 		free(*pwd);
1640 		*pwd = tmp;
1641 		break;
1642 	case I_LS:
1643 		if (!path1) {
1644 			do_ls_dir(conn, *pwd, *pwd, lflag);
1645 			break;
1646 		}
1647 
1648 		/* Strip pwd off beginning of non-absolute paths */
1649 		tmp = NULL;
1650 		if (!path_absolute(path1))
1651 			tmp = *pwd;
1652 
1653 		path1 = make_absolute(path1, *pwd);
1654 		err = do_globbed_ls(conn, path1, tmp, lflag);
1655 		break;
1656 	case I_DF:
1657 		/* Default to current directory if no path specified */
1658 		if (path1 == NULL)
1659 			path1 = xstrdup(*pwd);
1660 		path1 = make_absolute(path1, *pwd);
1661 		err = do_df(conn, path1, hflag, iflag);
1662 		break;
1663 	case I_LCHDIR:
1664 		if (path1 == NULL || *path1 == '\0')
1665 			path1 = xstrdup("~");
1666 		tmp = tilde_expand_filename(path1, getuid());
1667 		free(path1);
1668 		path1 = tmp;
1669 		if (chdir(path1) == -1) {
1670 			error("Couldn't change local directory to "
1671 			    "\"%s\": %s", path1, strerror(errno));
1672 			err = 1;
1673 		}
1674 		break;
1675 	case I_LMKDIR:
1676 		if (mkdir(path1, 0777) == -1) {
1677 			error("Couldn't create local directory "
1678 			    "\"%s\": %s", path1, strerror(errno));
1679 			err = 1;
1680 		}
1681 		break;
1682 	case I_LLS:
1683 		local_do_ls(cmd);
1684 		break;
1685 	case I_SHELL:
1686 		local_do_shell(cmd);
1687 		break;
1688 	case I_LUMASK:
1689 		umask(n_arg);
1690 		printf("Local umask: %03lo\n", n_arg);
1691 		break;
1692 	case I_CHMOD:
1693 		path1 = make_absolute(path1, *pwd);
1694 		attrib_clear(&a);
1695 		a.flags |= SSH2_FILEXFER_ATTR_PERMISSIONS;
1696 		a.perm = n_arg;
1697 		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
1698 		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1699 			if (!quiet)
1700 				mprintf("Changing mode on %s\n",
1701 				    g.gl_pathv[i]);
1702 			err = (hflag ? do_lsetstat : do_setstat)(conn,
1703 			    g.gl_pathv[i], &a);
1704 			if (err != 0 && err_abort)
1705 				break;
1706 		}
1707 		break;
1708 	case I_CHOWN:
1709 	case I_CHGRP:
1710 		path1 = make_absolute(path1, *pwd);
1711 		remote_glob(conn, path1, GLOB_NOCHECK, NULL, &g);
1712 		for (i = 0; g.gl_pathv[i] && !interrupted; i++) {
1713 			if (!(aa = (hflag ? do_lstat : do_stat)(conn,
1714 			    g.gl_pathv[i], 0))) {
1715 				if (err_abort) {
1716 					err = -1;
1717 					break;
1718 				} else
1719 					continue;
1720 			}
1721 			if (!(aa->flags & SSH2_FILEXFER_ATTR_UIDGID)) {
1722 				error("Can't get current ownership of "
1723 				    "remote file \"%s\"", g.gl_pathv[i]);
1724 				if (err_abort) {
1725 					err = -1;
1726 					break;
1727 				} else
1728 					continue;
1729 			}
1730 			aa->flags &= SSH2_FILEXFER_ATTR_UIDGID;
1731 			if (cmdnum == I_CHOWN) {
1732 				if (!quiet)
1733 					mprintf("Changing owner on %s\n",
1734 					    g.gl_pathv[i]);
1735 				aa->uid = n_arg;
1736 			} else {
1737 				if (!quiet)
1738 					mprintf("Changing group on %s\n",
1739 					    g.gl_pathv[i]);
1740 				aa->gid = n_arg;
1741 			}
1742 			err = (hflag ? do_lsetstat : do_setstat)(conn,
1743 			    g.gl_pathv[i], aa);
1744 			if (err != 0 && err_abort)
1745 				break;
1746 		}
1747 		break;
1748 	case I_PWD:
1749 		mprintf("Remote working directory: %s\n", *pwd);
1750 		break;
1751 	case I_LPWD:
1752 		if (!getcwd(path_buf, sizeof(path_buf))) {
1753 			error("Couldn't get local cwd: %s", strerror(errno));
1754 			err = -1;
1755 			break;
1756 		}
1757 		mprintf("Local working directory: %s\n", path_buf);
1758 		break;
1759 	case I_QUIT:
1760 		/* Processed below */
1761 		break;
1762 	case I_HELP:
1763 		help();
1764 		break;
1765 	case I_VERSION:
1766 		printf("SFTP protocol version %u\n", sftp_proto_version(conn));
1767 		break;
1768 	case I_PROGRESS:
1769 		showprogress = !showprogress;
1770 		if (showprogress)
1771 			printf("Progress meter enabled\n");
1772 		else
1773 			printf("Progress meter disabled\n");
1774 		break;
1775 	default:
1776 		fatal("%d is not implemented", cmdnum);
1777 	}
1778 
1779 	if (g.gl_pathc)
1780 		globfree(&g);
1781 	free(path1);
1782 	free(path2);
1783 
1784 	/* If an unignored error occurs in batch mode we should abort. */
1785 	if (err_abort && err != 0)
1786 		return (-1);
1787 	else if (cmdnum == I_QUIT)
1788 		return (1);
1789 
1790 	return (0);
1791 }
1792 
1793 #ifdef USE_LIBEDIT
1794 static char *
1795 prompt(EditLine *el)
1796 {
1797 	return ("sftp> ");
1798 }
1799 
1800 /* Display entries in 'list' after skipping the first 'len' chars */
1801 static void
1802 complete_display(char **list, u_int len)
1803 {
1804 	u_int y, m = 0, width = 80, columns = 1, colspace = 0, llen;
1805 	struct winsize ws;
1806 	char *tmp;
1807 
1808 	/* Count entries for sort and find longest */
1809 	for (y = 0; list[y]; y++)
1810 		m = MAXIMUM(m, strlen(list[y]));
1811 
1812 	if (ioctl(fileno(stdin), TIOCGWINSZ, &ws) != -1)
1813 		width = ws.ws_col;
1814 
1815 	m = m > len ? m - len : 0;
1816 	columns = width / (m + 2);
1817 	columns = MAXIMUM(columns, 1);
1818 	colspace = width / columns;
1819 	colspace = MINIMUM(colspace, width);
1820 
1821 	printf("\n");
1822 	m = 1;
1823 	for (y = 0; list[y]; y++) {
1824 		llen = strlen(list[y]);
1825 		tmp = llen > len ? list[y] + len : "";
1826 		mprintf("%-*s", colspace, tmp);
1827 		if (m >= columns) {
1828 			printf("\n");
1829 			m = 1;
1830 		} else
1831 			m++;
1832 	}
1833 	printf("\n");
1834 }
1835 
1836 /*
1837  * Given a "list" of words that begin with a common prefix of "word",
1838  * attempt to find an autocompletion to extends "word" by the next
1839  * characters common to all entries in "list".
1840  */
1841 static char *
1842 complete_ambiguous(const char *word, char **list, size_t count)
1843 {
1844 	if (word == NULL)
1845 		return NULL;
1846 
1847 	if (count > 0) {
1848 		u_int y, matchlen = strlen(list[0]);
1849 
1850 		/* Find length of common stem */
1851 		for (y = 1; list[y]; y++) {
1852 			u_int x;
1853 
1854 			for (x = 0; x < matchlen; x++)
1855 				if (list[0][x] != list[y][x])
1856 					break;
1857 
1858 			matchlen = x;
1859 		}
1860 
1861 		if (matchlen > strlen(word)) {
1862 			char *tmp = xstrdup(list[0]);
1863 
1864 			tmp[matchlen] = '\0';
1865 			return tmp;
1866 		}
1867 	}
1868 
1869 	return xstrdup(word);
1870 }
1871 
1872 /* Autocomplete a sftp command */
1873 static int
1874 complete_cmd_parse(EditLine *el, char *cmd, int lastarg, char quote,
1875     int terminated)
1876 {
1877 	u_int y, count = 0, cmdlen, tmplen;
1878 	char *tmp, **list, argterm[3];
1879 	const LineInfo *lf;
1880 
1881 	list = xcalloc((sizeof(cmds) / sizeof(*cmds)) + 1, sizeof(char *));
1882 
1883 	/* No command specified: display all available commands */
1884 	if (cmd == NULL) {
1885 		for (y = 0; cmds[y].c; y++)
1886 			list[count++] = xstrdup(cmds[y].c);
1887 
1888 		list[count] = NULL;
1889 		complete_display(list, 0);
1890 
1891 		for (y = 0; list[y] != NULL; y++)
1892 			free(list[y]);
1893 		free(list);
1894 		return count;
1895 	}
1896 
1897 	/* Prepare subset of commands that start with "cmd" */
1898 	cmdlen = strlen(cmd);
1899 	for (y = 0; cmds[y].c; y++)  {
1900 		if (!strncasecmp(cmd, cmds[y].c, cmdlen))
1901 			list[count++] = xstrdup(cmds[y].c);
1902 	}
1903 	list[count] = NULL;
1904 
1905 	if (count == 0) {
1906 		free(list);
1907 		return 0;
1908 	}
1909 
1910 	/* Complete ambiguous command */
1911 	tmp = complete_ambiguous(cmd, list, count);
1912 	if (count > 1)
1913 		complete_display(list, 0);
1914 
1915 	for (y = 0; list[y]; y++)
1916 		free(list[y]);
1917 	free(list);
1918 
1919 	if (tmp != NULL) {
1920 		tmplen = strlen(tmp);
1921 		cmdlen = strlen(cmd);
1922 		/* If cmd may be extended then do so */
1923 		if (tmplen > cmdlen)
1924 			if (el_insertstr(el, tmp + cmdlen) == -1)
1925 				fatal("el_insertstr failed.");
1926 		lf = el_line(el);
1927 		/* Terminate argument cleanly */
1928 		if (count == 1) {
1929 			y = 0;
1930 			if (!terminated)
1931 				argterm[y++] = quote;
1932 			if (lastarg || *(lf->cursor) != ' ')
1933 				argterm[y++] = ' ';
1934 			argterm[y] = '\0';
1935 			if (y > 0 && el_insertstr(el, argterm) == -1)
1936 				fatal("el_insertstr failed.");
1937 		}
1938 		free(tmp);
1939 	}
1940 
1941 	return count;
1942 }
1943 
1944 /*
1945  * Determine whether a particular sftp command's arguments (if any)
1946  * represent local or remote files.
1947  */
1948 static int
1949 complete_is_remote(char *cmd) {
1950 	int i;
1951 
1952 	if (cmd == NULL)
1953 		return -1;
1954 
1955 	for (i = 0; cmds[i].c; i++) {
1956 		if (!strncasecmp(cmd, cmds[i].c, strlen(cmds[i].c)))
1957 			return cmds[i].t;
1958 	}
1959 
1960 	return -1;
1961 }
1962 
1963 /* Autocomplete a filename "file" */
1964 static int
1965 complete_match(EditLine *el, struct sftp_conn *conn, char *remote_path,
1966     char *file, int remote, int lastarg, char quote, int terminated)
1967 {
1968 	glob_t g;
1969 	char *tmp, *tmp2, ins[8];
1970 	u_int i, hadglob, pwdlen, len, tmplen, filelen, cesc, isesc, isabs;
1971 	int clen;
1972 	const LineInfo *lf;
1973 
1974 	/* Glob from "file" location */
1975 	if (file == NULL)
1976 		tmp = xstrdup("*");
1977 	else
1978 		xasprintf(&tmp, "%s*", file);
1979 
1980 	/* Check if the path is absolute. */
1981 	isabs = path_absolute(tmp);
1982 
1983 	memset(&g, 0, sizeof(g));
1984 	if (remote != LOCAL) {
1985 		tmp = make_absolute(tmp, remote_path);
1986 		remote_glob(conn, tmp, GLOB_DOOFFS|GLOB_MARK, NULL, &g);
1987 	} else
1988 		glob(tmp, GLOB_DOOFFS|GLOB_MARK, NULL, &g);
1989 
1990 	/* Determine length of pwd so we can trim completion display */
1991 	for (hadglob = tmplen = pwdlen = 0; tmp[tmplen] != 0; tmplen++) {
1992 		/* Terminate counting on first unescaped glob metacharacter */
1993 		if (tmp[tmplen] == '*' || tmp[tmplen] == '?') {
1994 			if (tmp[tmplen] != '*' || tmp[tmplen + 1] != '\0')
1995 				hadglob = 1;
1996 			break;
1997 		}
1998 		if (tmp[tmplen] == '\\' && tmp[tmplen + 1] != '\0')
1999 			tmplen++;
2000 		if (tmp[tmplen] == '/')
2001 			pwdlen = tmplen + 1;	/* track last seen '/' */
2002 	}
2003 	free(tmp);
2004 	tmp = NULL;
2005 
2006 	if (g.gl_matchc == 0)
2007 		goto out;
2008 
2009 	if (g.gl_matchc > 1)
2010 		complete_display(g.gl_pathv, pwdlen);
2011 
2012 	/* Don't try to extend globs */
2013 	if (file == NULL || hadglob)
2014 		goto out;
2015 
2016 	tmp2 = complete_ambiguous(file, g.gl_pathv, g.gl_matchc);
2017 	tmp = path_strip(tmp2, isabs ? NULL : remote_path);
2018 	free(tmp2);
2019 
2020 	if (tmp == NULL)
2021 		goto out;
2022 
2023 	tmplen = strlen(tmp);
2024 	filelen = strlen(file);
2025 
2026 	/* Count the number of escaped characters in the input string. */
2027 	cesc = isesc = 0;
2028 	for (i = 0; i < filelen; i++) {
2029 		if (!isesc && file[i] == '\\' && i + 1 < filelen){
2030 			isesc = 1;
2031 			cesc++;
2032 		} else
2033 			isesc = 0;
2034 	}
2035 
2036 	if (tmplen > (filelen - cesc)) {
2037 		tmp2 = tmp + filelen - cesc;
2038 		len = strlen(tmp2);
2039 		/* quote argument on way out */
2040 		for (i = 0; i < len; i += clen) {
2041 			if ((clen = mblen(tmp2 + i, len - i)) < 0 ||
2042 			    (size_t)clen > sizeof(ins) - 2)
2043 				fatal("invalid multibyte character");
2044 			ins[0] = '\\';
2045 			memcpy(ins + 1, tmp2 + i, clen);
2046 			ins[clen + 1] = '\0';
2047 			switch (tmp2[i]) {
2048 			case '\'':
2049 			case '"':
2050 			case '\\':
2051 			case '\t':
2052 			case '[':
2053 			case ' ':
2054 			case '#':
2055 			case '*':
2056 				if (quote == '\0' || tmp2[i] == quote) {
2057 					if (el_insertstr(el, ins) == -1)
2058 						fatal("el_insertstr "
2059 						    "failed.");
2060 					break;
2061 				}
2062 				/* FALLTHROUGH */
2063 			default:
2064 				if (el_insertstr(el, ins + 1) == -1)
2065 					fatal("el_insertstr failed.");
2066 				break;
2067 			}
2068 		}
2069 	}
2070 
2071 	lf = el_line(el);
2072 	if (g.gl_matchc == 1) {
2073 		i = 0;
2074 		if (!terminated && quote != '\0')
2075 			ins[i++] = quote;
2076 		if (*(lf->cursor - 1) != '/' &&
2077 		    (lastarg || *(lf->cursor) != ' '))
2078 			ins[i++] = ' ';
2079 		ins[i] = '\0';
2080 		if (i > 0 && el_insertstr(el, ins) == -1)
2081 			fatal("el_insertstr failed.");
2082 	}
2083 	free(tmp);
2084 
2085  out:
2086 	globfree(&g);
2087 	return g.gl_matchc;
2088 }
2089 
2090 /* tab-completion hook function, called via libedit */
2091 static unsigned char
2092 complete(EditLine *el, int ch)
2093 {
2094 	char **argv, *line, quote;
2095 	int argc, carg;
2096 	u_int cursor, len, terminated, ret = CC_ERROR;
2097 	const LineInfo *lf;
2098 	struct complete_ctx *complete_ctx;
2099 
2100 	lf = el_line(el);
2101 	if (el_get(el, EL_CLIENTDATA, (void**)&complete_ctx) != 0)
2102 		fatal("%s: el_get failed", __func__);
2103 
2104 	/* Figure out which argument the cursor points to */
2105 	cursor = lf->cursor - lf->buffer;
2106 	line = xmalloc(cursor + 1);
2107 	memcpy(line, lf->buffer, cursor);
2108 	line[cursor] = '\0';
2109 	argv = makeargv(line, &carg, 1, &quote, &terminated);
2110 	free(line);
2111 
2112 	/* Get all the arguments on the line */
2113 	len = lf->lastchar - lf->buffer;
2114 	line = xmalloc(len + 1);
2115 	memcpy(line, lf->buffer, len);
2116 	line[len] = '\0';
2117 	argv = makeargv(line, &argc, 1, NULL, NULL);
2118 
2119 	/* Ensure cursor is at EOL or a argument boundary */
2120 	if (line[cursor] != ' ' && line[cursor] != '\0' &&
2121 	    line[cursor] != '\n') {
2122 		free(line);
2123 		return ret;
2124 	}
2125 
2126 	if (carg == 0) {
2127 		/* Show all available commands */
2128 		complete_cmd_parse(el, NULL, argc == carg, '\0', 1);
2129 		ret = CC_REDISPLAY;
2130 	} else if (carg == 1 && cursor > 0 && line[cursor - 1] != ' ')  {
2131 		/* Handle the command parsing */
2132 		if (complete_cmd_parse(el, argv[0], argc == carg,
2133 		    quote, terminated) != 0)
2134 			ret = CC_REDISPLAY;
2135 	} else if (carg >= 1) {
2136 		/* Handle file parsing */
2137 		int remote = complete_is_remote(argv[0]);
2138 		char *filematch = NULL;
2139 
2140 		if (carg > 1 && line[cursor-1] != ' ')
2141 			filematch = argv[carg - 1];
2142 
2143 		if (remote != 0 &&
2144 		    complete_match(el, complete_ctx->conn,
2145 		    *complete_ctx->remote_pathp, filematch,
2146 		    remote, carg == argc, quote, terminated) != 0)
2147 			ret = CC_REDISPLAY;
2148 	}
2149 
2150 	free(line);
2151 	return ret;
2152 }
2153 #endif /* USE_LIBEDIT */
2154 
2155 static int
2156 interactive_loop(struct sftp_conn *conn, char *file1, char *file2)
2157 {
2158 	char *remote_path;
2159 	char *dir = NULL, *startdir = NULL;
2160 	char cmd[2048];
2161 	int err, interactive;
2162 	EditLine *el = NULL;
2163 #ifdef USE_LIBEDIT
2164 	History *hl = NULL;
2165 	HistEvent hev;
2166 	extern char *__progname;
2167 	struct complete_ctx complete_ctx;
2168 
2169 	if (!batchmode && isatty(STDIN_FILENO)) {
2170 		if ((el = el_init(__progname, stdin, stdout, stderr)) == NULL)
2171 			fatal("Couldn't initialise editline");
2172 		if ((hl = history_init()) == NULL)
2173 			fatal("Couldn't initialise editline history");
2174 		history(hl, &hev, H_SETSIZE, 100);
2175 		el_set(el, EL_HIST, history, hl);
2176 
2177 		el_set(el, EL_PROMPT, prompt);
2178 		el_set(el, EL_EDITOR, "emacs");
2179 		el_set(el, EL_TERMINAL, NULL);
2180 		el_set(el, EL_SIGNAL, 1);
2181 		el_source(el, NULL);
2182 
2183 		/* Tab Completion */
2184 		el_set(el, EL_ADDFN, "ftp-complete",
2185 		    "Context sensitive argument completion", complete);
2186 		complete_ctx.conn = conn;
2187 		complete_ctx.remote_pathp = &remote_path;
2188 		el_set(el, EL_CLIENTDATA, (void*)&complete_ctx);
2189 		el_set(el, EL_BIND, "^I", "ftp-complete", NULL);
2190 		/* enable ctrl-left-arrow and ctrl-right-arrow */
2191 		el_set(el, EL_BIND, "\\e[1;5C", "em-next-word", NULL);
2192 		el_set(el, EL_BIND, "\\e\\e[C", "em-next-word", NULL);
2193 		el_set(el, EL_BIND, "\\e[1;5D", "ed-prev-word", NULL);
2194 		el_set(el, EL_BIND, "\\e\\e[D", "ed-prev-word", NULL);
2195 		/* make ^w match ksh behaviour */
2196 		el_set(el, EL_BIND, "^w", "ed-delete-prev-word", NULL);
2197 	}
2198 #endif /* USE_LIBEDIT */
2199 
2200 	remote_path = do_realpath(conn, ".");
2201 	if (remote_path == NULL)
2202 		fatal("Need cwd");
2203 	startdir = xstrdup(remote_path);
2204 
2205 	if (file1 != NULL) {
2206 		dir = xstrdup(file1);
2207 		dir = make_absolute(dir, remote_path);
2208 
2209 		if (remote_is_dir(conn, dir) && file2 == NULL) {
2210 			if (!quiet)
2211 				mprintf("Changing to: %s\n", dir);
2212 			snprintf(cmd, sizeof cmd, "cd \"%s\"", dir);
2213 			if (parse_dispatch_command(conn, cmd,
2214 			    &remote_path, startdir, 1, 0) != 0) {
2215 				free(dir);
2216 				free(startdir);
2217 				free(remote_path);
2218 				free(conn);
2219 				return (-1);
2220 			}
2221 		} else {
2222 			/* XXX this is wrong wrt quoting */
2223 			snprintf(cmd, sizeof cmd, "get%s %s%s%s",
2224 			    global_aflag ? " -a" : "", dir,
2225 			    file2 == NULL ? "" : " ",
2226 			    file2 == NULL ? "" : file2);
2227 			err = parse_dispatch_command(conn, cmd,
2228 			    &remote_path, startdir, 1, 0);
2229 			free(dir);
2230 			free(startdir);
2231 			free(remote_path);
2232 			free(conn);
2233 			return (err);
2234 		}
2235 		free(dir);
2236 	}
2237 
2238 	setvbuf(stdout, NULL, _IOLBF, 0);
2239 	setvbuf(infile, NULL, _IOLBF, 0);
2240 
2241 	interactive = !batchmode && isatty(STDIN_FILENO);
2242 	err = 0;
2243 	for (;;) {
2244 		signal(SIGINT, SIG_IGN);
2245 
2246 		if (el == NULL) {
2247 			if (interactive)
2248 				printf("sftp> ");
2249 			if (fgets(cmd, sizeof(cmd), infile) == NULL) {
2250 				if (interactive)
2251 					printf("\n");
2252 				break;
2253 			}
2254 		} else {
2255 #ifdef USE_LIBEDIT
2256 			const char *line;
2257 			int count = 0;
2258 
2259 			if ((line = el_gets(el, &count)) == NULL ||
2260 			    count <= 0) {
2261 				printf("\n");
2262  				break;
2263 			}
2264 			history(hl, &hev, H_ENTER, line);
2265 			if (strlcpy(cmd, line, sizeof(cmd)) >= sizeof(cmd)) {
2266 				fprintf(stderr, "Error: input line too long\n");
2267 				continue;
2268 			}
2269 #endif /* USE_LIBEDIT */
2270 		}
2271 
2272 		cmd[strcspn(cmd, "\n")] = '\0';
2273 
2274 		/* Handle user interrupts gracefully during commands */
2275 		interrupted = 0;
2276 		signal(SIGINT, cmd_interrupt);
2277 
2278 		err = parse_dispatch_command(conn, cmd, &remote_path,
2279 		    startdir, batchmode, !interactive && el == NULL);
2280 		if (err != 0)
2281 			break;
2282 	}
2283 	signal(SIGCHLD, SIG_DFL);
2284 	free(remote_path);
2285 	free(startdir);
2286 	free(conn);
2287 
2288 #ifdef USE_LIBEDIT
2289 	if (el != NULL)
2290 		el_end(el);
2291 #endif /* USE_LIBEDIT */
2292 
2293 	/* err == 1 signifies normal "quit" exit */
2294 	return (err >= 0 ? 0 : -1);
2295 }
2296 
2297 static void
2298 connect_to_server(char *path, char **args, int *in, int *out)
2299 {
2300 	int c_in, c_out;
2301 
2302 #ifdef USE_PIPES
2303 	int pin[2], pout[2];
2304 
2305 	if ((pipe(pin) == -1) || (pipe(pout) == -1))
2306 		fatal("pipe: %s", strerror(errno));
2307 	*in = pin[0];
2308 	*out = pout[1];
2309 	c_in = pout[0];
2310 	c_out = pin[1];
2311 #else /* USE_PIPES */
2312 	int inout[2];
2313 
2314 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, inout) == -1)
2315 		fatal("socketpair: %s", strerror(errno));
2316 	*in = *out = inout[0];
2317 	c_in = c_out = inout[1];
2318 #endif /* USE_PIPES */
2319 
2320 	if ((sshpid = fork()) == -1)
2321 		fatal("fork: %s", strerror(errno));
2322 	else if (sshpid == 0) {
2323 		if ((dup2(c_in, STDIN_FILENO) == -1) ||
2324 		    (dup2(c_out, STDOUT_FILENO) == -1)) {
2325 			fprintf(stderr, "dup2: %s\n", strerror(errno));
2326 			_exit(1);
2327 		}
2328 		close(*in);
2329 		close(*out);
2330 		close(c_in);
2331 		close(c_out);
2332 
2333 		/*
2334 		 * The underlying ssh is in the same process group, so we must
2335 		 * ignore SIGINT if we want to gracefully abort commands,
2336 		 * otherwise the signal will make it to the ssh process and
2337 		 * kill it too.  Contrawise, since sftp sends SIGTERMs to the
2338 		 * underlying ssh, it must *not* ignore that signal.
2339 		 */
2340 		signal(SIGINT, SIG_IGN);
2341 		signal(SIGTERM, SIG_DFL);
2342 		execvp(path, args);
2343 		fprintf(stderr, "exec: %s: %s\n", path, strerror(errno));
2344 		_exit(1);
2345 	}
2346 
2347 	signal(SIGTERM, killchild);
2348 	signal(SIGINT, killchild);
2349 	signal(SIGHUP, killchild);
2350 	signal(SIGTSTP, suspchild);
2351 	signal(SIGTTIN, suspchild);
2352 	signal(SIGTTOU, suspchild);
2353 	signal(SIGCHLD, sigchld_handler);
2354 	close(c_in);
2355 	close(c_out);
2356 }
2357 
2358 static void
2359 usage(void)
2360 {
2361 	extern char *__progname;
2362 
2363 	fprintf(stderr,
2364 	    "usage: %s [-46aCfpqrv] [-B buffer_size] [-b batchfile] [-c cipher]\n"
2365 	    "          [-D sftp_server_path] [-F ssh_config] [-i identity_file]\n"
2366 	    "          [-J destination] [-l limit] [-o ssh_option] [-P port]\n"
2367 	    "          [-R num_requests] [-S program] [-s subsystem | sftp_server]\n"
2368 	    "          destination\n",
2369 	    __progname);
2370 	exit(1);
2371 }
2372 
2373 int
2374 main(int argc, char **argv)
2375 {
2376 	int in, out, ch, err, tmp, port = -1;
2377 	char *host = NULL, *user, *cp, *file2 = NULL;
2378 	int debug_level = 0, sshver = 2;
2379 	char *file1 = NULL, *sftp_server = NULL;
2380 	char *ssh_program = _PATH_SSH_PROGRAM, *sftp_direct = NULL;
2381 	const char *errstr;
2382 	LogLevel ll = SYSLOG_LEVEL_INFO;
2383 	arglist args;
2384 	extern int optind;
2385 	extern char *optarg;
2386 	struct sftp_conn *conn;
2387 	size_t copy_buffer_len = DEFAULT_COPY_BUFLEN;
2388 	size_t num_requests = DEFAULT_NUM_REQUESTS;
2389 	long long limit_kbps = 0;
2390 
2391 	/* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
2392 	sanitise_stdfd();
2393 	msetlocale();
2394 
2395 	seed_rng();
2396 
2397 	__progname = ssh_get_progname(argv[0]);
2398 	memset(&args, '\0', sizeof(args));
2399 	args.list = NULL;
2400 	addargs(&args, "%s", ssh_program);
2401 	addargs(&args, "-oForwardX11 no");
2402 	addargs(&args, "-oForwardAgent no");
2403 	addargs(&args, "-oPermitLocalCommand no");
2404 	addargs(&args, "-oClearAllForwardings yes");
2405 
2406 	ll = SYSLOG_LEVEL_INFO;
2407 	infile = stdin;
2408 
2409 	while ((ch = getopt(argc, argv,
2410 	    "1246afhpqrvCc:D:i:l:o:s:S:b:B:F:J:P:R:")) != -1) {
2411 		switch (ch) {
2412 		/* Passed through to ssh(1) */
2413 		case '4':
2414 		case '6':
2415 		case 'C':
2416 			addargs(&args, "-%c", ch);
2417 			break;
2418 		/* Passed through to ssh(1) with argument */
2419 		case 'F':
2420 		case 'J':
2421 		case 'c':
2422 		case 'i':
2423 		case 'o':
2424 			addargs(&args, "-%c", ch);
2425 			addargs(&args, "%s", optarg);
2426 			break;
2427 		case 'q':
2428 			ll = SYSLOG_LEVEL_ERROR;
2429 			quiet = 1;
2430 			showprogress = 0;
2431 			addargs(&args, "-%c", ch);
2432 			break;
2433 		case 'P':
2434 			port = a2port(optarg);
2435 			if (port <= 0)
2436 				fatal("Bad port \"%s\"\n", optarg);
2437 			break;
2438 		case 'v':
2439 			if (debug_level < 3) {
2440 				addargs(&args, "-v");
2441 				ll = SYSLOG_LEVEL_DEBUG1 + debug_level;
2442 			}
2443 			debug_level++;
2444 			break;
2445 		case '1':
2446 			sshver = 1;
2447 			if (sftp_server == NULL)
2448 				sftp_server = _PATH_SFTP_SERVER;
2449 			break;
2450 		case '2':
2451 			sshver = 2;
2452 			break;
2453 		case 'a':
2454 			global_aflag = 1;
2455 			break;
2456 		case 'B':
2457 			copy_buffer_len = strtol(optarg, &cp, 10);
2458 			if (copy_buffer_len == 0 || *cp != '\0')
2459 				fatal("Invalid buffer size \"%s\"", optarg);
2460 			break;
2461 		case 'b':
2462 			if (batchmode)
2463 				fatal("Batch file already specified.");
2464 
2465 			/* Allow "-" as stdin */
2466 			if (strcmp(optarg, "-") != 0 &&
2467 			    (infile = fopen(optarg, "r")) == NULL)
2468 				fatal("%s (%s).", strerror(errno), optarg);
2469 			showprogress = 0;
2470 			quiet = batchmode = 1;
2471 			addargs(&args, "-obatchmode yes");
2472 			break;
2473 		case 'f':
2474 			global_fflag = 1;
2475 			break;
2476 		case 'p':
2477 			global_pflag = 1;
2478 			break;
2479 		case 'D':
2480 			sftp_direct = optarg;
2481 			break;
2482 		case 'l':
2483 			limit_kbps = strtonum(optarg, 1, 100 * 1024 * 1024,
2484 			    &errstr);
2485 			if (errstr != NULL)
2486 				usage();
2487 			limit_kbps *= 1024; /* kbps */
2488 			break;
2489 		case 'r':
2490 			global_rflag = 1;
2491 			break;
2492 		case 'R':
2493 			num_requests = strtol(optarg, &cp, 10);
2494 			if (num_requests == 0 || *cp != '\0')
2495 				fatal("Invalid number of requests \"%s\"",
2496 				    optarg);
2497 			break;
2498 		case 's':
2499 			sftp_server = optarg;
2500 			break;
2501 		case 'S':
2502 			ssh_program = optarg;
2503 			replacearg(&args, 0, "%s", ssh_program);
2504 			break;
2505 		case 'h':
2506 		default:
2507 			usage();
2508 		}
2509 	}
2510 
2511 	if (!isatty(STDERR_FILENO))
2512 		showprogress = 0;
2513 
2514 	log_init(argv[0], ll, SYSLOG_FACILITY_USER, 1);
2515 
2516 	if (sftp_direct == NULL) {
2517 		if (optind == argc || argc > (optind + 2))
2518 			usage();
2519 		argv += optind;
2520 
2521 		switch (parse_uri("sftp", *argv, &user, &host, &tmp, &file1)) {
2522 		case -1:
2523 			usage();
2524 			break;
2525 		case 0:
2526 			if (tmp != -1)
2527 				port = tmp;
2528 			break;
2529 		default:
2530 			/* Try with user, host and path. */
2531 			if (parse_user_host_path(*argv, &user, &host,
2532 			    &file1) == 0)
2533 				break;
2534 			/* Try with user and host. */
2535 			if (parse_user_host_port(*argv, &user, &host, NULL)
2536 			    == 0)
2537 				break;
2538 			/* Treat as a plain hostname. */
2539 			host = xstrdup(*argv);
2540 			host = cleanhostname(host);
2541 			break;
2542 		}
2543 		file2 = *(argv + 1);
2544 
2545 		if (!*host) {
2546 			fprintf(stderr, "Missing hostname\n");
2547 			usage();
2548 		}
2549 
2550 		if (port != -1)
2551 			addargs(&args, "-oPort %d", port);
2552 		if (user != NULL) {
2553 			addargs(&args, "-l");
2554 			addargs(&args, "%s", user);
2555 		}
2556 		addargs(&args, "-oProtocol %d", sshver);
2557 
2558 		/* no subsystem if the server-spec contains a '/' */
2559 		if (sftp_server == NULL || strchr(sftp_server, '/') == NULL)
2560 			addargs(&args, "-s");
2561 
2562 		addargs(&args, "--");
2563 		addargs(&args, "%s", host);
2564 		addargs(&args, "%s", (sftp_server != NULL ?
2565 		    sftp_server : "sftp"));
2566 
2567 		connect_to_server(ssh_program, args.list, &in, &out);
2568 	} else {
2569 		args.list = NULL;
2570 		addargs(&args, "sftp-server");
2571 
2572 		connect_to_server(sftp_direct, args.list, &in, &out);
2573 	}
2574 	freeargs(&args);
2575 
2576 	conn = do_init(in, out, copy_buffer_len, num_requests, limit_kbps);
2577 	if (conn == NULL)
2578 		fatal("Couldn't initialise connection to server");
2579 
2580 	if (!quiet) {
2581 		if (sftp_direct == NULL)
2582 			fprintf(stderr, "Connected to %s.\n", host);
2583 		else
2584 			fprintf(stderr, "Attached to %s.\n", sftp_direct);
2585 	}
2586 
2587 	err = interactive_loop(conn, file1, file2);
2588 
2589 #if !defined(USE_PIPES)
2590 	shutdown(in, SHUT_RDWR);
2591 	shutdown(out, SHUT_RDWR);
2592 #endif
2593 
2594 	close(in);
2595 	close(out);
2596 	if (batchmode)
2597 		fclose(infile);
2598 
2599 	while (waitpid(sshpid, NULL, 0) == -1 && sshpid > 1)
2600 		if (errno != EINTR)
2601 			fatal("Couldn't wait for ssh process: %s",
2602 			    strerror(errno));
2603 
2604 	exit(err == 0 ? 0 : 1);
2605 }
2606