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