crypto/openssh/sftp.c

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