crypto/openssh/sftp.c

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