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