crypto/openssh/sftp.c

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