crypto/openssh/sftp.c

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