sftp.c

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