1 /* $OpenBSD: sftp-client.c,v 1.115 2014/04/21 14:36:16 logan 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 /* XXX: memleaks */ 19 /* XXX: signed vs unsigned */ 20 /* XXX: remove all logging, only return status codes */ 21 /* XXX: copy between two remote sites */ 22 23 #include "includes.h" 24 25 #include <sys/types.h> 26 #include <sys/param.h> 27 #ifdef HAVE_SYS_STATVFS_H 28 #include <sys/statvfs.h> 29 #endif 30 #include "openbsd-compat/sys-queue.h" 31 #ifdef HAVE_SYS_STAT_H 32 # include <sys/stat.h> 33 #endif 34 #ifdef HAVE_SYS_TIME_H 35 # include <sys/time.h> 36 #endif 37 #include <sys/uio.h> 38 39 #include <dirent.h> 40 #include <errno.h> 41 #include <fcntl.h> 42 #include <signal.h> 43 #include <stdarg.h> 44 #include <stdio.h> 45 #include <stdlib.h> 46 #include <string.h> 47 #include <unistd.h> 48 49 #include "xmalloc.h" 50 #include "buffer.h" 51 #include "log.h" 52 #include "atomicio.h" 53 #include "progressmeter.h" 54 #include "misc.h" 55 56 #include "sftp.h" 57 #include "sftp-common.h" 58 #include "sftp-client.h" 59 60 extern volatile sig_atomic_t interrupted; 61 extern int showprogress; 62 63 /* Minimum amount of data to read at a time */ 64 #define MIN_READ_SIZE 512 65 66 /* Maximum depth to descend in directory trees */ 67 #define MAX_DIR_DEPTH 64 68 69 struct sftp_conn { 70 int fd_in; 71 int fd_out; 72 u_int transfer_buflen; 73 u_int num_requests; 74 u_int version; 75 u_int msg_id; 76 #define SFTP_EXT_POSIX_RENAME 0x00000001 77 #define SFTP_EXT_STATVFS 0x00000002 78 #define SFTP_EXT_FSTATVFS 0x00000004 79 #define SFTP_EXT_HARDLINK 0x00000008 80 #define SFTP_EXT_FSYNC 0x00000010 81 u_int exts; 82 u_int64_t limit_kbps; 83 struct bwlimit bwlimit_in, bwlimit_out; 84 }; 85 86 static char * 87 get_handle(struct sftp_conn *conn, u_int expected_id, u_int *len, 88 const char *errfmt, ...) __attribute__((format(printf, 4, 5))); 89 90 /* ARGSUSED */ 91 static int 92 sftpio(void *_bwlimit, size_t amount) 93 { 94 struct bwlimit *bwlimit = (struct bwlimit *)_bwlimit; 95 96 bandwidth_limit(bwlimit, amount); 97 return 0; 98 } 99 100 static void 101 send_msg(struct sftp_conn *conn, Buffer *m) 102 { 103 u_char mlen[4]; 104 struct iovec iov[2]; 105 106 if (buffer_len(m) > SFTP_MAX_MSG_LENGTH) 107 fatal("Outbound message too long %u", buffer_len(m)); 108 109 /* Send length first */ 110 put_u32(mlen, buffer_len(m)); 111 iov[0].iov_base = mlen; 112 iov[0].iov_len = sizeof(mlen); 113 iov[1].iov_base = buffer_ptr(m); 114 iov[1].iov_len = buffer_len(m); 115 116 if (atomiciov6(writev, conn->fd_out, iov, 2, 117 conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_out) != 118 buffer_len(m) + sizeof(mlen)) 119 fatal("Couldn't send packet: %s", strerror(errno)); 120 121 buffer_clear(m); 122 } 123 124 static void 125 get_msg(struct sftp_conn *conn, Buffer *m) 126 { 127 u_int msg_len; 128 129 buffer_append_space(m, 4); 130 if (atomicio6(read, conn->fd_in, buffer_ptr(m), 4, 131 conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_in) != 4) { 132 if (errno == EPIPE) 133 fatal("Connection closed"); 134 else 135 fatal("Couldn't read packet: %s", strerror(errno)); 136 } 137 138 msg_len = buffer_get_int(m); 139 if (msg_len > SFTP_MAX_MSG_LENGTH) 140 fatal("Received message too long %u", msg_len); 141 142 buffer_append_space(m, msg_len); 143 if (atomicio6(read, conn->fd_in, buffer_ptr(m), msg_len, 144 conn->limit_kbps > 0 ? sftpio : NULL, &conn->bwlimit_in) 145 != msg_len) { 146 if (errno == EPIPE) 147 fatal("Connection closed"); 148 else 149 fatal("Read packet: %s", strerror(errno)); 150 } 151 } 152 153 static void 154 send_string_request(struct sftp_conn *conn, u_int id, u_int code, char *s, 155 u_int len) 156 { 157 Buffer msg; 158 159 buffer_init(&msg); 160 buffer_put_char(&msg, code); 161 buffer_put_int(&msg, id); 162 buffer_put_string(&msg, s, len); 163 send_msg(conn, &msg); 164 debug3("Sent message fd %d T:%u I:%u", conn->fd_out, code, id); 165 buffer_free(&msg); 166 } 167 168 static void 169 send_string_attrs_request(struct sftp_conn *conn, u_int id, u_int code, 170 char *s, u_int len, Attrib *a) 171 { 172 Buffer msg; 173 174 buffer_init(&msg); 175 buffer_put_char(&msg, code); 176 buffer_put_int(&msg, id); 177 buffer_put_string(&msg, s, len); 178 encode_attrib(&msg, a); 179 send_msg(conn, &msg); 180 debug3("Sent message fd %d T:%u I:%u", conn->fd_out, code, id); 181 buffer_free(&msg); 182 } 183 184 static u_int 185 get_status(struct sftp_conn *conn, u_int expected_id) 186 { 187 Buffer msg; 188 u_int type, id, status; 189 190 buffer_init(&msg); 191 get_msg(conn, &msg); 192 type = buffer_get_char(&msg); 193 id = buffer_get_int(&msg); 194 195 if (id != expected_id) 196 fatal("ID mismatch (%u != %u)", id, expected_id); 197 if (type != SSH2_FXP_STATUS) 198 fatal("Expected SSH2_FXP_STATUS(%u) packet, got %u", 199 SSH2_FXP_STATUS, type); 200 201 status = buffer_get_int(&msg); 202 buffer_free(&msg); 203 204 debug3("SSH2_FXP_STATUS %u", status); 205 206 return status; 207 } 208 209 static char * 210 get_handle(struct sftp_conn *conn, u_int expected_id, u_int *len, 211 const char *errfmt, ...) 212 { 213 Buffer msg; 214 u_int type, id; 215 char *handle, errmsg[256]; 216 va_list args; 217 int status; 218 219 va_start(args, errfmt); 220 if (errfmt != NULL) 221 vsnprintf(errmsg, sizeof(errmsg), errfmt, args); 222 va_end(args); 223 224 buffer_init(&msg); 225 get_msg(conn, &msg); 226 type = buffer_get_char(&msg); 227 id = buffer_get_int(&msg); 228 229 if (id != expected_id) 230 fatal("%s: ID mismatch (%u != %u)", 231 errfmt == NULL ? __func__ : errmsg, id, expected_id); 232 if (type == SSH2_FXP_STATUS) { 233 status = buffer_get_int(&msg); 234 if (errfmt != NULL) 235 error("%s: %s", errmsg, fx2txt(status)); 236 buffer_free(&msg); 237 return(NULL); 238 } else if (type != SSH2_FXP_HANDLE) 239 fatal("%s: Expected SSH2_FXP_HANDLE(%u) packet, got %u", 240 errfmt == NULL ? __func__ : errmsg, SSH2_FXP_HANDLE, type); 241 242 handle = buffer_get_string(&msg, len); 243 buffer_free(&msg); 244 245 return(handle); 246 } 247 248 static Attrib * 249 get_decode_stat(struct sftp_conn *conn, u_int expected_id, int quiet) 250 { 251 Buffer msg; 252 u_int type, id; 253 Attrib *a; 254 255 buffer_init(&msg); 256 get_msg(conn, &msg); 257 258 type = buffer_get_char(&msg); 259 id = buffer_get_int(&msg); 260 261 debug3("Received stat reply T:%u I:%u", type, id); 262 if (id != expected_id) 263 fatal("ID mismatch (%u != %u)", id, expected_id); 264 if (type == SSH2_FXP_STATUS) { 265 int status = buffer_get_int(&msg); 266 267 if (quiet) 268 debug("Couldn't stat remote file: %s", fx2txt(status)); 269 else 270 error("Couldn't stat remote file: %s", fx2txt(status)); 271 buffer_free(&msg); 272 return(NULL); 273 } else if (type != SSH2_FXP_ATTRS) { 274 fatal("Expected SSH2_FXP_ATTRS(%u) packet, got %u", 275 SSH2_FXP_ATTRS, type); 276 } 277 a = decode_attrib(&msg); 278 buffer_free(&msg); 279 280 return(a); 281 } 282 283 static int 284 get_decode_statvfs(struct sftp_conn *conn, struct sftp_statvfs *st, 285 u_int expected_id, int quiet) 286 { 287 Buffer msg; 288 u_int type, id, flag; 289 290 buffer_init(&msg); 291 get_msg(conn, &msg); 292 293 type = buffer_get_char(&msg); 294 id = buffer_get_int(&msg); 295 296 debug3("Received statvfs reply T:%u I:%u", type, id); 297 if (id != expected_id) 298 fatal("ID mismatch (%u != %u)", id, expected_id); 299 if (type == SSH2_FXP_STATUS) { 300 int status = buffer_get_int(&msg); 301 302 if (quiet) 303 debug("Couldn't statvfs: %s", fx2txt(status)); 304 else 305 error("Couldn't statvfs: %s", fx2txt(status)); 306 buffer_free(&msg); 307 return -1; 308 } else if (type != SSH2_FXP_EXTENDED_REPLY) { 309 fatal("Expected SSH2_FXP_EXTENDED_REPLY(%u) packet, got %u", 310 SSH2_FXP_EXTENDED_REPLY, type); 311 } 312 313 memset(st, 0, sizeof(*st)); 314 st->f_bsize = buffer_get_int64(&msg); 315 st->f_frsize = buffer_get_int64(&msg); 316 st->f_blocks = buffer_get_int64(&msg); 317 st->f_bfree = buffer_get_int64(&msg); 318 st->f_bavail = buffer_get_int64(&msg); 319 st->f_files = buffer_get_int64(&msg); 320 st->f_ffree = buffer_get_int64(&msg); 321 st->f_favail = buffer_get_int64(&msg); 322 st->f_fsid = buffer_get_int64(&msg); 323 flag = buffer_get_int64(&msg); 324 st->f_namemax = buffer_get_int64(&msg); 325 326 st->f_flag = (flag & SSH2_FXE_STATVFS_ST_RDONLY) ? ST_RDONLY : 0; 327 st->f_flag |= (flag & SSH2_FXE_STATVFS_ST_NOSUID) ? ST_NOSUID : 0; 328 329 buffer_free(&msg); 330 331 return 0; 332 } 333 334 struct sftp_conn * 335 do_init(int fd_in, int fd_out, u_int transfer_buflen, u_int num_requests, 336 u_int64_t limit_kbps) 337 { 338 u_int type; 339 Buffer msg; 340 struct sftp_conn *ret; 341 342 ret = xcalloc(1, sizeof(*ret)); 343 ret->msg_id = 1; 344 ret->fd_in = fd_in; 345 ret->fd_out = fd_out; 346 ret->transfer_buflen = transfer_buflen; 347 ret->num_requests = num_requests; 348 ret->exts = 0; 349 ret->limit_kbps = 0; 350 351 buffer_init(&msg); 352 buffer_put_char(&msg, SSH2_FXP_INIT); 353 buffer_put_int(&msg, SSH2_FILEXFER_VERSION); 354 send_msg(ret, &msg); 355 356 buffer_clear(&msg); 357 358 get_msg(ret, &msg); 359 360 /* Expecting a VERSION reply */ 361 if ((type = buffer_get_char(&msg)) != SSH2_FXP_VERSION) { 362 error("Invalid packet back from SSH2_FXP_INIT (type %u)", 363 type); 364 buffer_free(&msg); 365 return(NULL); 366 } 367 ret->version = buffer_get_int(&msg); 368 369 debug2("Remote version: %u", ret->version); 370 371 /* Check for extensions */ 372 while (buffer_len(&msg) > 0) { 373 char *name = buffer_get_string(&msg, NULL); 374 char *value = buffer_get_string(&msg, NULL); 375 int known = 0; 376 377 if (strcmp(name, "posix-rename@openssh.com") == 0 && 378 strcmp(value, "1") == 0) { 379 ret->exts |= SFTP_EXT_POSIX_RENAME; 380 known = 1; 381 } else if (strcmp(name, "statvfs@openssh.com") == 0 && 382 strcmp(value, "2") == 0) { 383 ret->exts |= SFTP_EXT_STATVFS; 384 known = 1; 385 } else if (strcmp(name, "fstatvfs@openssh.com") == 0 && 386 strcmp(value, "2") == 0) { 387 ret->exts |= SFTP_EXT_FSTATVFS; 388 known = 1; 389 } else if (strcmp(name, "hardlink@openssh.com") == 0 && 390 strcmp(value, "1") == 0) { 391 ret->exts |= SFTP_EXT_HARDLINK; 392 known = 1; 393 } else if (strcmp(name, "fsync@openssh.com") == 0 && 394 strcmp(value, "1") == 0) { 395 ret->exts |= SFTP_EXT_FSYNC; 396 known = 1; 397 } 398 if (known) { 399 debug2("Server supports extension \"%s\" revision %s", 400 name, value); 401 } else { 402 debug2("Unrecognised server extension \"%s\"", name); 403 } 404 free(name); 405 free(value); 406 } 407 408 buffer_free(&msg); 409 410 /* Some filexfer v.0 servers don't support large packets */ 411 if (ret->version == 0) 412 ret->transfer_buflen = MIN(ret->transfer_buflen, 20480); 413 414 ret->limit_kbps = limit_kbps; 415 if (ret->limit_kbps > 0) { 416 bandwidth_limit_init(&ret->bwlimit_in, ret->limit_kbps, 417 ret->transfer_buflen); 418 bandwidth_limit_init(&ret->bwlimit_out, ret->limit_kbps, 419 ret->transfer_buflen); 420 } 421 422 return ret; 423 } 424 425 u_int 426 sftp_proto_version(struct sftp_conn *conn) 427 { 428 return conn->version; 429 } 430 431 int 432 do_close(struct sftp_conn *conn, char *handle, u_int handle_len) 433 { 434 u_int id, status; 435 Buffer msg; 436 437 buffer_init(&msg); 438 439 id = conn->msg_id++; 440 buffer_put_char(&msg, SSH2_FXP_CLOSE); 441 buffer_put_int(&msg, id); 442 buffer_put_string(&msg, handle, handle_len); 443 send_msg(conn, &msg); 444 debug3("Sent message SSH2_FXP_CLOSE I:%u", id); 445 446 status = get_status(conn, id); 447 if (status != SSH2_FX_OK) 448 error("Couldn't close file: %s", fx2txt(status)); 449 450 buffer_free(&msg); 451 452 return status; 453 } 454 455 456 static int 457 do_lsreaddir(struct sftp_conn *conn, char *path, int print_flag, 458 SFTP_DIRENT ***dir) 459 { 460 Buffer msg; 461 u_int count, type, id, handle_len, i, expected_id, ents = 0; 462 char *handle; 463 int status = SSH2_FX_FAILURE; 464 465 if (dir) 466 *dir = NULL; 467 468 id = conn->msg_id++; 469 470 buffer_init(&msg); 471 buffer_put_char(&msg, SSH2_FXP_OPENDIR); 472 buffer_put_int(&msg, id); 473 buffer_put_cstring(&msg, path); 474 send_msg(conn, &msg); 475 476 handle = get_handle(conn, id, &handle_len, 477 "remote readdir(\"%s\")", path); 478 if (handle == NULL) { 479 buffer_free(&msg); 480 return -1; 481 } 482 483 if (dir) { 484 ents = 0; 485 *dir = xcalloc(1, sizeof(**dir)); 486 (*dir)[0] = NULL; 487 } 488 489 for (; !interrupted;) { 490 id = expected_id = conn->msg_id++; 491 492 debug3("Sending SSH2_FXP_READDIR I:%u", id); 493 494 buffer_clear(&msg); 495 buffer_put_char(&msg, SSH2_FXP_READDIR); 496 buffer_put_int(&msg, id); 497 buffer_put_string(&msg, handle, handle_len); 498 send_msg(conn, &msg); 499 500 buffer_clear(&msg); 501 502 get_msg(conn, &msg); 503 504 type = buffer_get_char(&msg); 505 id = buffer_get_int(&msg); 506 507 debug3("Received reply T:%u I:%u", type, id); 508 509 if (id != expected_id) 510 fatal("ID mismatch (%u != %u)", id, expected_id); 511 512 if (type == SSH2_FXP_STATUS) { 513 status = buffer_get_int(&msg); 514 debug3("Received SSH2_FXP_STATUS %d", status); 515 if (status == SSH2_FX_EOF) 516 break; 517 error("Couldn't read directory: %s", fx2txt(status)); 518 goto out; 519 } else if (type != SSH2_FXP_NAME) 520 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", 521 SSH2_FXP_NAME, type); 522 523 count = buffer_get_int(&msg); 524 if (count == 0) 525 break; 526 debug3("Received %d SSH2_FXP_NAME responses", count); 527 for (i = 0; i < count; i++) { 528 char *filename, *longname; 529 Attrib *a; 530 531 filename = buffer_get_string(&msg, NULL); 532 longname = buffer_get_string(&msg, NULL); 533 a = decode_attrib(&msg); 534 535 if (print_flag) 536 printf("%s\n", longname); 537 538 /* 539 * Directory entries should never contain '/' 540 * These can be used to attack recursive ops 541 * (e.g. send '../../../../etc/passwd') 542 */ 543 if (strchr(filename, '/') != NULL) { 544 error("Server sent suspect path \"%s\" " 545 "during readdir of \"%s\"", filename, path); 546 } else if (dir) { 547 *dir = xrealloc(*dir, ents + 2, sizeof(**dir)); 548 (*dir)[ents] = xcalloc(1, sizeof(***dir)); 549 (*dir)[ents]->filename = xstrdup(filename); 550 (*dir)[ents]->longname = xstrdup(longname); 551 memcpy(&(*dir)[ents]->a, a, sizeof(*a)); 552 (*dir)[++ents] = NULL; 553 } 554 free(filename); 555 free(longname); 556 } 557 } 558 status = 0; 559 560 out: 561 buffer_free(&msg); 562 do_close(conn, handle, handle_len); 563 free(handle); 564 565 if (status != 0 && dir != NULL) { 566 /* Don't return results on error */ 567 free_sftp_dirents(*dir); 568 *dir = NULL; 569 } else if (interrupted && dir != NULL && *dir != NULL) { 570 /* Don't return partial matches on interrupt */ 571 free_sftp_dirents(*dir); 572 *dir = xcalloc(1, sizeof(**dir)); 573 **dir = NULL; 574 } 575 576 return status; 577 } 578 579 int 580 do_readdir(struct sftp_conn *conn, char *path, SFTP_DIRENT ***dir) 581 { 582 return(do_lsreaddir(conn, path, 0, dir)); 583 } 584 585 void free_sftp_dirents(SFTP_DIRENT **s) 586 { 587 int i; 588 589 if (s == NULL) 590 return; 591 for (i = 0; s[i]; i++) { 592 free(s[i]->filename); 593 free(s[i]->longname); 594 free(s[i]); 595 } 596 free(s); 597 } 598 599 int 600 do_rm(struct sftp_conn *conn, char *path) 601 { 602 u_int status, id; 603 604 debug2("Sending SSH2_FXP_REMOVE \"%s\"", path); 605 606 id = conn->msg_id++; 607 send_string_request(conn, id, SSH2_FXP_REMOVE, path, strlen(path)); 608 status = get_status(conn, id); 609 if (status != SSH2_FX_OK) 610 error("Couldn't delete file: %s", fx2txt(status)); 611 return(status); 612 } 613 614 int 615 do_mkdir(struct sftp_conn *conn, char *path, Attrib *a, int print_flag) 616 { 617 u_int status, id; 618 619 id = conn->msg_id++; 620 send_string_attrs_request(conn, id, SSH2_FXP_MKDIR, path, 621 strlen(path), a); 622 623 status = get_status(conn, id); 624 if (status != SSH2_FX_OK && print_flag) 625 error("Couldn't create directory: %s", fx2txt(status)); 626 627 return(status); 628 } 629 630 int 631 do_rmdir(struct sftp_conn *conn, char *path) 632 { 633 u_int status, id; 634 635 id = conn->msg_id++; 636 send_string_request(conn, id, SSH2_FXP_RMDIR, path, 637 strlen(path)); 638 639 status = get_status(conn, id); 640 if (status != SSH2_FX_OK) 641 error("Couldn't remove directory: %s", fx2txt(status)); 642 643 return(status); 644 } 645 646 Attrib * 647 do_stat(struct sftp_conn *conn, char *path, int quiet) 648 { 649 u_int id; 650 651 id = conn->msg_id++; 652 653 send_string_request(conn, id, 654 conn->version == 0 ? SSH2_FXP_STAT_VERSION_0 : SSH2_FXP_STAT, 655 path, strlen(path)); 656 657 return(get_decode_stat(conn, id, quiet)); 658 } 659 660 Attrib * 661 do_lstat(struct sftp_conn *conn, char *path, int quiet) 662 { 663 u_int id; 664 665 if (conn->version == 0) { 666 if (quiet) 667 debug("Server version does not support lstat operation"); 668 else 669 logit("Server version does not support lstat operation"); 670 return(do_stat(conn, path, quiet)); 671 } 672 673 id = conn->msg_id++; 674 send_string_request(conn, id, SSH2_FXP_LSTAT, path, 675 strlen(path)); 676 677 return(get_decode_stat(conn, id, quiet)); 678 } 679 680 #ifdef notyet 681 Attrib * 682 do_fstat(struct sftp_conn *conn, char *handle, u_int handle_len, int quiet) 683 { 684 u_int id; 685 686 id = conn->msg_id++; 687 send_string_request(conn, id, SSH2_FXP_FSTAT, handle, 688 handle_len); 689 690 return(get_decode_stat(conn, id, quiet)); 691 } 692 #endif 693 694 int 695 do_setstat(struct sftp_conn *conn, char *path, Attrib *a) 696 { 697 u_int status, id; 698 699 id = conn->msg_id++; 700 send_string_attrs_request(conn, id, SSH2_FXP_SETSTAT, path, 701 strlen(path), a); 702 703 status = get_status(conn, id); 704 if (status != SSH2_FX_OK) 705 error("Couldn't setstat on \"%s\": %s", path, 706 fx2txt(status)); 707 708 return(status); 709 } 710 711 int 712 do_fsetstat(struct sftp_conn *conn, char *handle, u_int handle_len, 713 Attrib *a) 714 { 715 u_int status, id; 716 717 id = conn->msg_id++; 718 send_string_attrs_request(conn, id, SSH2_FXP_FSETSTAT, handle, 719 handle_len, a); 720 721 status = get_status(conn, id); 722 if (status != SSH2_FX_OK) 723 error("Couldn't fsetstat: %s", fx2txt(status)); 724 725 return(status); 726 } 727 728 char * 729 do_realpath(struct sftp_conn *conn, char *path) 730 { 731 Buffer msg; 732 u_int type, expected_id, count, id; 733 char *filename, *longname; 734 Attrib *a; 735 736 expected_id = id = conn->msg_id++; 737 send_string_request(conn, id, SSH2_FXP_REALPATH, path, 738 strlen(path)); 739 740 buffer_init(&msg); 741 742 get_msg(conn, &msg); 743 type = buffer_get_char(&msg); 744 id = buffer_get_int(&msg); 745 746 if (id != expected_id) 747 fatal("ID mismatch (%u != %u)", id, expected_id); 748 749 if (type == SSH2_FXP_STATUS) { 750 u_int status = buffer_get_int(&msg); 751 752 error("Couldn't canonicalize: %s", fx2txt(status)); 753 buffer_free(&msg); 754 return NULL; 755 } else if (type != SSH2_FXP_NAME) 756 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", 757 SSH2_FXP_NAME, type); 758 759 count = buffer_get_int(&msg); 760 if (count != 1) 761 fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count); 762 763 filename = buffer_get_string(&msg, NULL); 764 longname = buffer_get_string(&msg, NULL); 765 a = decode_attrib(&msg); 766 767 debug3("SSH_FXP_REALPATH %s -> %s size %lu", path, filename, 768 (unsigned long)a->size); 769 770 free(longname); 771 772 buffer_free(&msg); 773 774 return(filename); 775 } 776 777 int 778 do_rename(struct sftp_conn *conn, char *oldpath, char *newpath, 779 int force_legacy) 780 { 781 Buffer msg; 782 u_int status, id; 783 int use_ext = (conn->exts & SFTP_EXT_POSIX_RENAME) && !force_legacy; 784 785 buffer_init(&msg); 786 787 /* Send rename request */ 788 id = conn->msg_id++; 789 if (use_ext) { 790 buffer_put_char(&msg, SSH2_FXP_EXTENDED); 791 buffer_put_int(&msg, id); 792 buffer_put_cstring(&msg, "posix-rename@openssh.com"); 793 } else { 794 buffer_put_char(&msg, SSH2_FXP_RENAME); 795 buffer_put_int(&msg, id); 796 } 797 buffer_put_cstring(&msg, oldpath); 798 buffer_put_cstring(&msg, newpath); 799 send_msg(conn, &msg); 800 debug3("Sent message %s \"%s\" -> \"%s\"", 801 use_ext ? "posix-rename@openssh.com" : "SSH2_FXP_RENAME", 802 oldpath, newpath); 803 buffer_free(&msg); 804 805 status = get_status(conn, id); 806 if (status != SSH2_FX_OK) 807 error("Couldn't rename file \"%s\" to \"%s\": %s", oldpath, 808 newpath, fx2txt(status)); 809 810 return(status); 811 } 812 813 int 814 do_hardlink(struct sftp_conn *conn, char *oldpath, char *newpath) 815 { 816 Buffer msg; 817 u_int status, id; 818 819 if ((conn->exts & SFTP_EXT_HARDLINK) == 0) { 820 error("Server does not support hardlink@openssh.com extension"); 821 return -1; 822 } 823 824 buffer_init(&msg); 825 826 /* Send link request */ 827 id = conn->msg_id++; 828 buffer_put_char(&msg, SSH2_FXP_EXTENDED); 829 buffer_put_int(&msg, id); 830 buffer_put_cstring(&msg, "hardlink@openssh.com"); 831 buffer_put_cstring(&msg, oldpath); 832 buffer_put_cstring(&msg, newpath); 833 send_msg(conn, &msg); 834 debug3("Sent message hardlink@openssh.com \"%s\" -> \"%s\"", 835 oldpath, newpath); 836 buffer_free(&msg); 837 838 status = get_status(conn, id); 839 if (status != SSH2_FX_OK) 840 error("Couldn't link file \"%s\" to \"%s\": %s", oldpath, 841 newpath, fx2txt(status)); 842 843 return(status); 844 } 845 846 int 847 do_symlink(struct sftp_conn *conn, char *oldpath, char *newpath) 848 { 849 Buffer msg; 850 u_int status, id; 851 852 if (conn->version < 3) { 853 error("This server does not support the symlink operation"); 854 return(SSH2_FX_OP_UNSUPPORTED); 855 } 856 857 buffer_init(&msg); 858 859 /* Send symlink request */ 860 id = conn->msg_id++; 861 buffer_put_char(&msg, SSH2_FXP_SYMLINK); 862 buffer_put_int(&msg, id); 863 buffer_put_cstring(&msg, oldpath); 864 buffer_put_cstring(&msg, newpath); 865 send_msg(conn, &msg); 866 debug3("Sent message SSH2_FXP_SYMLINK \"%s\" -> \"%s\"", oldpath, 867 newpath); 868 buffer_free(&msg); 869 870 status = get_status(conn, id); 871 if (status != SSH2_FX_OK) 872 error("Couldn't symlink file \"%s\" to \"%s\": %s", oldpath, 873 newpath, fx2txt(status)); 874 875 return(status); 876 } 877 878 int 879 do_fsync(struct sftp_conn *conn, char *handle, u_int handle_len) 880 { 881 Buffer msg; 882 u_int status, id; 883 884 /* Silently return if the extension is not supported */ 885 if ((conn->exts & SFTP_EXT_FSYNC) == 0) 886 return -1; 887 888 buffer_init(&msg); 889 890 /* Send fsync request */ 891 id = conn->msg_id++; 892 893 buffer_put_char(&msg, SSH2_FXP_EXTENDED); 894 buffer_put_int(&msg, id); 895 buffer_put_cstring(&msg, "fsync@openssh.com"); 896 buffer_put_string(&msg, handle, handle_len); 897 send_msg(conn, &msg); 898 debug3("Sent message fsync@openssh.com I:%u", id); 899 buffer_free(&msg); 900 901 status = get_status(conn, id); 902 if (status != SSH2_FX_OK) 903 error("Couldn't sync file: %s", fx2txt(status)); 904 905 return status; 906 } 907 908 #ifdef notyet 909 char * 910 do_readlink(struct sftp_conn *conn, char *path) 911 { 912 Buffer msg; 913 u_int type, expected_id, count, id; 914 char *filename, *longname; 915 Attrib *a; 916 917 expected_id = id = conn->msg_id++; 918 send_string_request(conn, id, SSH2_FXP_READLINK, path, strlen(path)); 919 920 buffer_init(&msg); 921 922 get_msg(conn, &msg); 923 type = buffer_get_char(&msg); 924 id = buffer_get_int(&msg); 925 926 if (id != expected_id) 927 fatal("ID mismatch (%u != %u)", id, expected_id); 928 929 if (type == SSH2_FXP_STATUS) { 930 u_int status = buffer_get_int(&msg); 931 932 error("Couldn't readlink: %s", fx2txt(status)); 933 buffer_free(&msg); 934 return(NULL); 935 } else if (type != SSH2_FXP_NAME) 936 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", 937 SSH2_FXP_NAME, type); 938 939 count = buffer_get_int(&msg); 940 if (count != 1) 941 fatal("Got multiple names (%d) from SSH_FXP_READLINK", count); 942 943 filename = buffer_get_string(&msg, NULL); 944 longname = buffer_get_string(&msg, NULL); 945 a = decode_attrib(&msg); 946 947 debug3("SSH_FXP_READLINK %s -> %s", path, filename); 948 949 free(longname); 950 951 buffer_free(&msg); 952 953 return(filename); 954 } 955 #endif 956 957 int 958 do_statvfs(struct sftp_conn *conn, const char *path, struct sftp_statvfs *st, 959 int quiet) 960 { 961 Buffer msg; 962 u_int id; 963 964 if ((conn->exts & SFTP_EXT_STATVFS) == 0) { 965 error("Server does not support statvfs@openssh.com extension"); 966 return -1; 967 } 968 969 id = conn->msg_id++; 970 971 buffer_init(&msg); 972 buffer_clear(&msg); 973 buffer_put_char(&msg, SSH2_FXP_EXTENDED); 974 buffer_put_int(&msg, id); 975 buffer_put_cstring(&msg, "statvfs@openssh.com"); 976 buffer_put_cstring(&msg, path); 977 send_msg(conn, &msg); 978 buffer_free(&msg); 979 980 return get_decode_statvfs(conn, st, id, quiet); 981 } 982 983 #ifdef notyet 984 int 985 do_fstatvfs(struct sftp_conn *conn, const char *handle, u_int handle_len, 986 struct sftp_statvfs *st, int quiet) 987 { 988 Buffer msg; 989 u_int id; 990 991 if ((conn->exts & SFTP_EXT_FSTATVFS) == 0) { 992 error("Server does not support fstatvfs@openssh.com extension"); 993 return -1; 994 } 995 996 id = conn->msg_id++; 997 998 buffer_init(&msg); 999 buffer_clear(&msg); 1000 buffer_put_char(&msg, SSH2_FXP_EXTENDED); 1001 buffer_put_int(&msg, id); 1002 buffer_put_cstring(&msg, "fstatvfs@openssh.com"); 1003 buffer_put_string(&msg, handle, handle_len); 1004 send_msg(conn, &msg); 1005 buffer_free(&msg); 1006 1007 return get_decode_statvfs(conn, st, id, quiet); 1008 } 1009 #endif 1010 1011 static void 1012 send_read_request(struct sftp_conn *conn, u_int id, u_int64_t offset, 1013 u_int len, char *handle, u_int handle_len) 1014 { 1015 Buffer msg; 1016 1017 buffer_init(&msg); 1018 buffer_clear(&msg); 1019 buffer_put_char(&msg, SSH2_FXP_READ); 1020 buffer_put_int(&msg, id); 1021 buffer_put_string(&msg, handle, handle_len); 1022 buffer_put_int64(&msg, offset); 1023 buffer_put_int(&msg, len); 1024 send_msg(conn, &msg); 1025 buffer_free(&msg); 1026 } 1027 1028 int 1029 do_download(struct sftp_conn *conn, char *remote_path, char *local_path, 1030 Attrib *a, int preserve_flag, int resume_flag, int fsync_flag) 1031 { 1032 Attrib junk; 1033 Buffer msg; 1034 char *handle; 1035 int local_fd = -1, status = 0, write_error; 1036 int read_error, write_errno, reordered = 0; 1037 u_int64_t offset = 0, size, highwater; 1038 u_int handle_len, mode, type, id, buflen, num_req, max_req; 1039 off_t progress_counter; 1040 struct stat st; 1041 struct request { 1042 u_int id; 1043 u_int len; 1044 u_int64_t offset; 1045 TAILQ_ENTRY(request) tq; 1046 }; 1047 TAILQ_HEAD(reqhead, request) requests; 1048 struct request *req; 1049 1050 TAILQ_INIT(&requests); 1051 1052 if (a == NULL && (a = do_stat(conn, remote_path, 0)) == NULL) 1053 return -1; 1054 1055 /* Do not preserve set[ug]id here, as we do not preserve ownership */ 1056 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) 1057 mode = a->perm & 0777; 1058 else 1059 mode = 0666; 1060 1061 if ((a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) && 1062 (!S_ISREG(a->perm))) { 1063 error("Cannot download non-regular file: %s", remote_path); 1064 return(-1); 1065 } 1066 1067 if (a->flags & SSH2_FILEXFER_ATTR_SIZE) 1068 size = a->size; 1069 else 1070 size = 0; 1071 1072 buflen = conn->transfer_buflen; 1073 buffer_init(&msg); 1074 1075 /* Send open request */ 1076 id = conn->msg_id++; 1077 buffer_put_char(&msg, SSH2_FXP_OPEN); 1078 buffer_put_int(&msg, id); 1079 buffer_put_cstring(&msg, remote_path); 1080 buffer_put_int(&msg, SSH2_FXF_READ); 1081 attrib_clear(&junk); /* Send empty attributes */ 1082 encode_attrib(&msg, &junk); 1083 send_msg(conn, &msg); 1084 debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path); 1085 1086 handle = get_handle(conn, id, &handle_len, 1087 "remote open(\"%s\")", remote_path); 1088 if (handle == NULL) { 1089 buffer_free(&msg); 1090 return(-1); 1091 } 1092 1093 local_fd = open(local_path, 1094 O_WRONLY | O_CREAT | (resume_flag ? 0 : O_TRUNC), mode | S_IWUSR); 1095 if (local_fd == -1) { 1096 error("Couldn't open local file \"%s\" for writing: %s", 1097 local_path, strerror(errno)); 1098 goto fail; 1099 } 1100 offset = highwater = 0; 1101 if (resume_flag) { 1102 if (fstat(local_fd, &st) == -1) { 1103 error("Unable to stat local file \"%s\": %s", 1104 local_path, strerror(errno)); 1105 goto fail; 1106 } 1107 if (st.st_size < 0) { 1108 error("\"%s\" has negative size", local_path); 1109 goto fail; 1110 } 1111 if ((u_int64_t)st.st_size > size) { 1112 error("Unable to resume download of \"%s\": " 1113 "local file is larger than remote", local_path); 1114 fail: 1115 do_close(conn, handle, handle_len); 1116 buffer_free(&msg); 1117 free(handle); 1118 if (local_fd != -1) 1119 close(local_fd); 1120 return -1; 1121 } 1122 offset = highwater = st.st_size; 1123 } 1124 1125 /* Read from remote and write to local */ 1126 write_error = read_error = write_errno = num_req = 0; 1127 max_req = 1; 1128 progress_counter = offset; 1129 1130 if (showprogress && size != 0) 1131 start_progress_meter(remote_path, size, &progress_counter); 1132 1133 while (num_req > 0 || max_req > 0) { 1134 char *data; 1135 u_int len; 1136 1137 /* 1138 * Simulate EOF on interrupt: stop sending new requests and 1139 * allow outstanding requests to drain gracefully 1140 */ 1141 if (interrupted) { 1142 if (num_req == 0) /* If we haven't started yet... */ 1143 break; 1144 max_req = 0; 1145 } 1146 1147 /* Send some more requests */ 1148 while (num_req < max_req) { 1149 debug3("Request range %llu -> %llu (%d/%d)", 1150 (unsigned long long)offset, 1151 (unsigned long long)offset + buflen - 1, 1152 num_req, max_req); 1153 req = xcalloc(1, sizeof(*req)); 1154 req->id = conn->msg_id++; 1155 req->len = buflen; 1156 req->offset = offset; 1157 offset += buflen; 1158 num_req++; 1159 TAILQ_INSERT_TAIL(&requests, req, tq); 1160 send_read_request(conn, req->id, req->offset, 1161 req->len, handle, handle_len); 1162 } 1163 1164 buffer_clear(&msg); 1165 get_msg(conn, &msg); 1166 type = buffer_get_char(&msg); 1167 id = buffer_get_int(&msg); 1168 debug3("Received reply T:%u I:%u R:%d", type, id, max_req); 1169 1170 /* Find the request in our queue */ 1171 for (req = TAILQ_FIRST(&requests); 1172 req != NULL && req->id != id; 1173 req = TAILQ_NEXT(req, tq)) 1174 ; 1175 if (req == NULL) 1176 fatal("Unexpected reply %u", id); 1177 1178 switch (type) { 1179 case SSH2_FXP_STATUS: 1180 status = buffer_get_int(&msg); 1181 if (status != SSH2_FX_EOF) 1182 read_error = 1; 1183 max_req = 0; 1184 TAILQ_REMOVE(&requests, req, tq); 1185 free(req); 1186 num_req--; 1187 break; 1188 case SSH2_FXP_DATA: 1189 data = buffer_get_string(&msg, &len); 1190 debug3("Received data %llu -> %llu", 1191 (unsigned long long)req->offset, 1192 (unsigned long long)req->offset + len - 1); 1193 if (len > req->len) 1194 fatal("Received more data than asked for " 1195 "%u > %u", len, req->len); 1196 if ((lseek(local_fd, req->offset, SEEK_SET) == -1 || 1197 atomicio(vwrite, local_fd, data, len) != len) && 1198 !write_error) { 1199 write_errno = errno; 1200 write_error = 1; 1201 max_req = 0; 1202 } 1203 else if (!reordered && req->offset <= highwater) 1204 highwater = req->offset + len; 1205 else if (!reordered && req->offset > highwater) 1206 reordered = 1; 1207 progress_counter += len; 1208 free(data); 1209 1210 if (len == req->len) { 1211 TAILQ_REMOVE(&requests, req, tq); 1212 free(req); 1213 num_req--; 1214 } else { 1215 /* Resend the request for the missing data */ 1216 debug3("Short data block, re-requesting " 1217 "%llu -> %llu (%2d)", 1218 (unsigned long long)req->offset + len, 1219 (unsigned long long)req->offset + 1220 req->len - 1, num_req); 1221 req->id = conn->msg_id++; 1222 req->len -= len; 1223 req->offset += len; 1224 send_read_request(conn, req->id, 1225 req->offset, req->len, handle, handle_len); 1226 /* Reduce the request size */ 1227 if (len < buflen) 1228 buflen = MAX(MIN_READ_SIZE, len); 1229 } 1230 if (max_req > 0) { /* max_req = 0 iff EOF received */ 1231 if (size > 0 && offset > size) { 1232 /* Only one request at a time 1233 * after the expected EOF */ 1234 debug3("Finish at %llu (%2d)", 1235 (unsigned long long)offset, 1236 num_req); 1237 max_req = 1; 1238 } else if (max_req <= conn->num_requests) { 1239 ++max_req; 1240 } 1241 } 1242 break; 1243 default: 1244 fatal("Expected SSH2_FXP_DATA(%u) packet, got %u", 1245 SSH2_FXP_DATA, type); 1246 } 1247 } 1248 1249 if (showprogress && size) 1250 stop_progress_meter(); 1251 1252 /* Sanity check */ 1253 if (TAILQ_FIRST(&requests) != NULL) 1254 fatal("Transfer complete, but requests still in queue"); 1255 /* Truncate at highest contiguous point to avoid holes on interrupt */ 1256 if (read_error || write_error || interrupted) { 1257 if (reordered && resume_flag) { 1258 error("Unable to resume download of \"%s\": " 1259 "server reordered requests", local_path); 1260 } 1261 debug("truncating at %llu", (unsigned long long)highwater); 1262 ftruncate(local_fd, highwater); 1263 } 1264 if (read_error) { 1265 error("Couldn't read from remote file \"%s\" : %s", 1266 remote_path, fx2txt(status)); 1267 status = -1; 1268 do_close(conn, handle, handle_len); 1269 } else if (write_error) { 1270 error("Couldn't write to \"%s\": %s", local_path, 1271 strerror(write_errno)); 1272 status = -1; 1273 do_close(conn, handle, handle_len); 1274 } else { 1275 status = do_close(conn, handle, handle_len); 1276 if (interrupted || status != SSH2_FX_OK) 1277 status = -1; 1278 /* Override umask and utimes if asked */ 1279 #ifdef HAVE_FCHMOD 1280 if (preserve_flag && fchmod(local_fd, mode) == -1) 1281 #else 1282 if (preserve_flag && chmod(local_path, mode) == -1) 1283 #endif /* HAVE_FCHMOD */ 1284 error("Couldn't set mode on \"%s\": %s", local_path, 1285 strerror(errno)); 1286 if (preserve_flag && 1287 (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME)) { 1288 struct timeval tv[2]; 1289 tv[0].tv_sec = a->atime; 1290 tv[1].tv_sec = a->mtime; 1291 tv[0].tv_usec = tv[1].tv_usec = 0; 1292 if (utimes(local_path, tv) == -1) 1293 error("Can't set times on \"%s\": %s", 1294 local_path, strerror(errno)); 1295 } 1296 if (fsync_flag) { 1297 debug("syncing \"%s\"", local_path); 1298 if (fsync(local_fd) == -1) 1299 error("Couldn't sync file \"%s\": %s", 1300 local_path, strerror(errno)); 1301 } 1302 } 1303 close(local_fd); 1304 buffer_free(&msg); 1305 free(handle); 1306 1307 return(status); 1308 } 1309 1310 static int 1311 download_dir_internal(struct sftp_conn *conn, char *src, char *dst, int depth, 1312 Attrib *dirattrib, int preserve_flag, int print_flag, int resume_flag, 1313 int fsync_flag) 1314 { 1315 int i, ret = 0; 1316 SFTP_DIRENT **dir_entries; 1317 char *filename, *new_src, *new_dst; 1318 mode_t mode = 0777; 1319 1320 if (depth >= MAX_DIR_DEPTH) { 1321 error("Maximum directory depth exceeded: %d levels", depth); 1322 return -1; 1323 } 1324 1325 if (dirattrib == NULL && 1326 (dirattrib = do_stat(conn, src, 1)) == NULL) { 1327 error("Unable to stat remote directory \"%s\"", src); 1328 return -1; 1329 } 1330 if (!S_ISDIR(dirattrib->perm)) { 1331 error("\"%s\" is not a directory", src); 1332 return -1; 1333 } 1334 if (print_flag) 1335 printf("Retrieving %s\n", src); 1336 1337 if (dirattrib->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) 1338 mode = dirattrib->perm & 01777; 1339 else { 1340 debug("Server did not send permissions for " 1341 "directory \"%s\"", dst); 1342 } 1343 1344 if (mkdir(dst, mode) == -1 && errno != EEXIST) { 1345 error("mkdir %s: %s", dst, strerror(errno)); 1346 return -1; 1347 } 1348 1349 if (do_readdir(conn, src, &dir_entries) == -1) { 1350 error("%s: Failed to get directory contents", src); 1351 return -1; 1352 } 1353 1354 for (i = 0; dir_entries[i] != NULL && !interrupted; i++) { 1355 filename = dir_entries[i]->filename; 1356 1357 new_dst = path_append(dst, filename); 1358 new_src = path_append(src, filename); 1359 1360 if (S_ISDIR(dir_entries[i]->a.perm)) { 1361 if (strcmp(filename, ".") == 0 || 1362 strcmp(filename, "..") == 0) 1363 continue; 1364 if (download_dir_internal(conn, new_src, new_dst, 1365 depth + 1, &(dir_entries[i]->a), preserve_flag, 1366 print_flag, resume_flag, fsync_flag) == -1) 1367 ret = -1; 1368 } else if (S_ISREG(dir_entries[i]->a.perm) ) { 1369 if (do_download(conn, new_src, new_dst, 1370 &(dir_entries[i]->a), preserve_flag, 1371 resume_flag, fsync_flag) == -1) { 1372 error("Download of file %s to %s failed", 1373 new_src, new_dst); 1374 ret = -1; 1375 } 1376 } else 1377 logit("%s: not a regular file\n", new_src); 1378 1379 free(new_dst); 1380 free(new_src); 1381 } 1382 1383 if (preserve_flag) { 1384 if (dirattrib->flags & SSH2_FILEXFER_ATTR_ACMODTIME) { 1385 struct timeval tv[2]; 1386 tv[0].tv_sec = dirattrib->atime; 1387 tv[1].tv_sec = dirattrib->mtime; 1388 tv[0].tv_usec = tv[1].tv_usec = 0; 1389 if (utimes(dst, tv) == -1) 1390 error("Can't set times on \"%s\": %s", 1391 dst, strerror(errno)); 1392 } else 1393 debug("Server did not send times for directory " 1394 "\"%s\"", dst); 1395 } 1396 1397 free_sftp_dirents(dir_entries); 1398 1399 return ret; 1400 } 1401 1402 int 1403 download_dir(struct sftp_conn *conn, char *src, char *dst, 1404 Attrib *dirattrib, int preserve_flag, int print_flag, 1405 int resume_flag, int fsync_flag) 1406 { 1407 char *src_canon; 1408 int ret; 1409 1410 if ((src_canon = do_realpath(conn, src)) == NULL) { 1411 error("Unable to canonicalize path \"%s\"", src); 1412 return -1; 1413 } 1414 1415 ret = download_dir_internal(conn, src_canon, dst, 0, 1416 dirattrib, preserve_flag, print_flag, resume_flag, fsync_flag); 1417 free(src_canon); 1418 return ret; 1419 } 1420 1421 int 1422 do_upload(struct sftp_conn *conn, char *local_path, char *remote_path, 1423 int preserve_flag, int resume, int fsync_flag) 1424 { 1425 int local_fd; 1426 int status = SSH2_FX_OK; 1427 u_int handle_len, id, type; 1428 off_t offset, progress_counter; 1429 char *handle, *data; 1430 Buffer msg; 1431 struct stat sb; 1432 Attrib a, *c = NULL; 1433 u_int32_t startid; 1434 u_int32_t ackid; 1435 struct outstanding_ack { 1436 u_int id; 1437 u_int len; 1438 off_t offset; 1439 TAILQ_ENTRY(outstanding_ack) tq; 1440 }; 1441 TAILQ_HEAD(ackhead, outstanding_ack) acks; 1442 struct outstanding_ack *ack = NULL; 1443 1444 TAILQ_INIT(&acks); 1445 1446 if ((local_fd = open(local_path, O_RDONLY, 0)) == -1) { 1447 error("Couldn't open local file \"%s\" for reading: %s", 1448 local_path, strerror(errno)); 1449 return(-1); 1450 } 1451 if (fstat(local_fd, &sb) == -1) { 1452 error("Couldn't fstat local file \"%s\": %s", 1453 local_path, strerror(errno)); 1454 close(local_fd); 1455 return(-1); 1456 } 1457 if (!S_ISREG(sb.st_mode)) { 1458 error("%s is not a regular file", local_path); 1459 close(local_fd); 1460 return(-1); 1461 } 1462 stat_to_attrib(&sb, &a); 1463 1464 a.flags &= ~SSH2_FILEXFER_ATTR_SIZE; 1465 a.flags &= ~SSH2_FILEXFER_ATTR_UIDGID; 1466 a.perm &= 0777; 1467 if (!preserve_flag) 1468 a.flags &= ~SSH2_FILEXFER_ATTR_ACMODTIME; 1469 1470 if (resume) { 1471 /* Get remote file size if it exists */ 1472 if ((c = do_stat(conn, remote_path, 0)) == NULL) { 1473 close(local_fd); 1474 return -1; 1475 } 1476 1477 if ((off_t)c->size >= sb.st_size) { 1478 error("destination file bigger or same size as " 1479 "source file"); 1480 close(local_fd); 1481 return -1; 1482 } 1483 1484 if (lseek(local_fd, (off_t)c->size, SEEK_SET) == -1) { 1485 close(local_fd); 1486 return -1; 1487 } 1488 } 1489 1490 buffer_init(&msg); 1491 1492 /* Send open request */ 1493 id = conn->msg_id++; 1494 buffer_put_char(&msg, SSH2_FXP_OPEN); 1495 buffer_put_int(&msg, id); 1496 buffer_put_cstring(&msg, remote_path); 1497 buffer_put_int(&msg, SSH2_FXF_WRITE|SSH2_FXF_CREAT| 1498 (resume ? SSH2_FXF_APPEND : SSH2_FXF_TRUNC)); 1499 encode_attrib(&msg, &a); 1500 send_msg(conn, &msg); 1501 debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path); 1502 1503 buffer_clear(&msg); 1504 1505 handle = get_handle(conn, id, &handle_len, 1506 "remote open(\"%s\")", remote_path); 1507 if (handle == NULL) { 1508 close(local_fd); 1509 buffer_free(&msg); 1510 return -1; 1511 } 1512 1513 startid = ackid = id + 1; 1514 data = xmalloc(conn->transfer_buflen); 1515 1516 /* Read from local and write to remote */ 1517 offset = progress_counter = (resume ? c->size : 0); 1518 if (showprogress) 1519 start_progress_meter(local_path, sb.st_size, 1520 &progress_counter); 1521 1522 for (;;) { 1523 int len; 1524 1525 /* 1526 * Can't use atomicio here because it returns 0 on EOF, 1527 * thus losing the last block of the file. 1528 * Simulate an EOF on interrupt, allowing ACKs from the 1529 * server to drain. 1530 */ 1531 if (interrupted || status != SSH2_FX_OK) 1532 len = 0; 1533 else do 1534 len = read(local_fd, data, conn->transfer_buflen); 1535 while ((len == -1) && 1536 (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)); 1537 1538 if (len == -1) 1539 fatal("Couldn't read from \"%s\": %s", local_path, 1540 strerror(errno)); 1541 1542 if (len != 0) { 1543 ack = xcalloc(1, sizeof(*ack)); 1544 ack->id = ++id; 1545 ack->offset = offset; 1546 ack->len = len; 1547 TAILQ_INSERT_TAIL(&acks, ack, tq); 1548 1549 buffer_clear(&msg); 1550 buffer_put_char(&msg, SSH2_FXP_WRITE); 1551 buffer_put_int(&msg, ack->id); 1552 buffer_put_string(&msg, handle, handle_len); 1553 buffer_put_int64(&msg, offset); 1554 buffer_put_string(&msg, data, len); 1555 send_msg(conn, &msg); 1556 debug3("Sent message SSH2_FXP_WRITE I:%u O:%llu S:%u", 1557 id, (unsigned long long)offset, len); 1558 } else if (TAILQ_FIRST(&acks) == NULL) 1559 break; 1560 1561 if (ack == NULL) 1562 fatal("Unexpected ACK %u", id); 1563 1564 if (id == startid || len == 0 || 1565 id - ackid >= conn->num_requests) { 1566 u_int r_id; 1567 1568 buffer_clear(&msg); 1569 get_msg(conn, &msg); 1570 type = buffer_get_char(&msg); 1571 r_id = buffer_get_int(&msg); 1572 1573 if (type != SSH2_FXP_STATUS) 1574 fatal("Expected SSH2_FXP_STATUS(%d) packet, " 1575 "got %d", SSH2_FXP_STATUS, type); 1576 1577 status = buffer_get_int(&msg); 1578 debug3("SSH2_FXP_STATUS %d", status); 1579 1580 /* Find the request in our queue */ 1581 for (ack = TAILQ_FIRST(&acks); 1582 ack != NULL && ack->id != r_id; 1583 ack = TAILQ_NEXT(ack, tq)) 1584 ; 1585 if (ack == NULL) 1586 fatal("Can't find request for ID %u", r_id); 1587 TAILQ_REMOVE(&acks, ack, tq); 1588 debug3("In write loop, ack for %u %u bytes at %lld", 1589 ack->id, ack->len, (long long)ack->offset); 1590 ++ackid; 1591 progress_counter += ack->len; 1592 free(ack); 1593 } 1594 offset += len; 1595 if (offset < 0) 1596 fatal("%s: offset < 0", __func__); 1597 } 1598 buffer_free(&msg); 1599 1600 if (showprogress) 1601 stop_progress_meter(); 1602 free(data); 1603 1604 if (status != SSH2_FX_OK) { 1605 error("Couldn't write to remote file \"%s\": %s", 1606 remote_path, fx2txt(status)); 1607 status = -1; 1608 } 1609 1610 if (close(local_fd) == -1) { 1611 error("Couldn't close local file \"%s\": %s", local_path, 1612 strerror(errno)); 1613 status = -1; 1614 } 1615 1616 /* Override umask and utimes if asked */ 1617 if (preserve_flag) 1618 do_fsetstat(conn, handle, handle_len, &a); 1619 1620 if (fsync_flag) 1621 (void)do_fsync(conn, handle, handle_len); 1622 1623 if (do_close(conn, handle, handle_len) != SSH2_FX_OK) 1624 status = -1; 1625 free(handle); 1626 1627 return status; 1628 } 1629 1630 static int 1631 upload_dir_internal(struct sftp_conn *conn, char *src, char *dst, int depth, 1632 int preserve_flag, int print_flag, int resume, int fsync_flag) 1633 { 1634 int ret = 0, status; 1635 DIR *dirp; 1636 struct dirent *dp; 1637 char *filename, *new_src, *new_dst; 1638 struct stat sb; 1639 Attrib a; 1640 1641 if (depth >= MAX_DIR_DEPTH) { 1642 error("Maximum directory depth exceeded: %d levels", depth); 1643 return -1; 1644 } 1645 1646 if (stat(src, &sb) == -1) { 1647 error("Couldn't stat directory \"%s\": %s", 1648 src, strerror(errno)); 1649 return -1; 1650 } 1651 if (!S_ISDIR(sb.st_mode)) { 1652 error("\"%s\" is not a directory", src); 1653 return -1; 1654 } 1655 if (print_flag) 1656 printf("Entering %s\n", src); 1657 1658 attrib_clear(&a); 1659 stat_to_attrib(&sb, &a); 1660 a.flags &= ~SSH2_FILEXFER_ATTR_SIZE; 1661 a.flags &= ~SSH2_FILEXFER_ATTR_UIDGID; 1662 a.perm &= 01777; 1663 if (!preserve_flag) 1664 a.flags &= ~SSH2_FILEXFER_ATTR_ACMODTIME; 1665 1666 status = do_mkdir(conn, dst, &a, 0); 1667 /* 1668 * we lack a portable status for errno EEXIST, 1669 * so if we get a SSH2_FX_FAILURE back we must check 1670 * if it was created successfully. 1671 */ 1672 if (status != SSH2_FX_OK) { 1673 if (status != SSH2_FX_FAILURE) 1674 return -1; 1675 if (do_stat(conn, dst, 0) == NULL) 1676 return -1; 1677 } 1678 1679 if ((dirp = opendir(src)) == NULL) { 1680 error("Failed to open dir \"%s\": %s", src, strerror(errno)); 1681 return -1; 1682 } 1683 1684 while (((dp = readdir(dirp)) != NULL) && !interrupted) { 1685 if (dp->d_ino == 0) 1686 continue; 1687 filename = dp->d_name; 1688 new_dst = path_append(dst, filename); 1689 new_src = path_append(src, filename); 1690 1691 if (lstat(new_src, &sb) == -1) { 1692 logit("%s: lstat failed: %s", filename, 1693 strerror(errno)); 1694 ret = -1; 1695 } else if (S_ISDIR(sb.st_mode)) { 1696 if (strcmp(filename, ".") == 0 || 1697 strcmp(filename, "..") == 0) 1698 continue; 1699 1700 if (upload_dir_internal(conn, new_src, new_dst, 1701 depth + 1, preserve_flag, print_flag, resume, 1702 fsync_flag) == -1) 1703 ret = -1; 1704 } else if (S_ISREG(sb.st_mode)) { 1705 if (do_upload(conn, new_src, new_dst, 1706 preserve_flag, resume, fsync_flag) == -1) { 1707 error("Uploading of file %s to %s failed!", 1708 new_src, new_dst); 1709 ret = -1; 1710 } 1711 } else 1712 logit("%s: not a regular file\n", filename); 1713 free(new_dst); 1714 free(new_src); 1715 } 1716 1717 do_setstat(conn, dst, &a); 1718 1719 (void) closedir(dirp); 1720 return ret; 1721 } 1722 1723 int 1724 upload_dir(struct sftp_conn *conn, char *src, char *dst, int preserve_flag, 1725 int print_flag, int resume, int fsync_flag) 1726 { 1727 char *dst_canon; 1728 int ret; 1729 1730 if ((dst_canon = do_realpath(conn, dst)) == NULL) { 1731 error("Unable to canonicalize path \"%s\"", dst); 1732 return -1; 1733 } 1734 1735 ret = upload_dir_internal(conn, src, dst_canon, 0, preserve_flag, 1736 print_flag, resume, fsync_flag); 1737 1738 free(dst_canon); 1739 return ret; 1740 } 1741 1742 char * 1743 path_append(char *p1, char *p2) 1744 { 1745 char *ret; 1746 size_t len = strlen(p1) + strlen(p2) + 2; 1747 1748 ret = xmalloc(len); 1749 strlcpy(ret, p1, len); 1750 if (p1[0] != '\0' && p1[strlen(p1) - 1] != '/') 1751 strlcat(ret, "/", len); 1752 strlcat(ret, p2, len); 1753 1754 return(ret); 1755 } 1756 1757