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