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