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