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