crypto/openssh/sftp.c

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