sftp-client.c revision 204917
1/* $OpenBSD: sftp-client.c,v 1.90 2009/10/11 10:41:26 dtucker 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 59extern volatile sig_atomic_t interrupted; 60extern 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 68struct 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 81static char * 82get_handle(int fd, u_int expected_id, u_int *len, const char *errfmt, ...) 83 __attribute__((format(printf, 4, 5))); 84 85static void 86send_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 107static void 108get_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 133static void 134send_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 148static void 149send_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 164static u_int 165get_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 189static char * 190get_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 227static Attrib * 228get_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 262static int 263get_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 313struct sftp_conn * 314do_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 388u_int 389sftp_proto_version(struct sftp_conn *conn) 390{ 391 return(conn->version); 392} 393 394int 395do_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 419static int 420do_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 543int 544do_readdir(struct sftp_conn *conn, char *path, SFTP_DIRENT ***dir) 545{ 546 return(do_lsreaddir(conn, path, 0, dir)); 547} 548 549void 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 561int 562do_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 577int 578do_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 593int 594do_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 609Attrib * 610do_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 623Attrib * 624do_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 644Attrib * 645do_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 657int 658do_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 674int 675do_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 691char * 692do_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 return(NULL); 717 } else if (type != SSH2_FXP_NAME) 718 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", 719 SSH2_FXP_NAME, type); 720 721 count = buffer_get_int(&msg); 722 if (count != 1) 723 fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count); 724 725 filename = buffer_get_string(&msg, NULL); 726 longname = buffer_get_string(&msg, NULL); 727 a = decode_attrib(&msg); 728 729 debug3("SSH_FXP_REALPATH %s -> %s", path, filename); 730 731 xfree(longname); 732 733 buffer_free(&msg); 734 735 return(filename); 736} 737 738int 739do_rename(struct sftp_conn *conn, char *oldpath, char *newpath) 740{ 741 Buffer msg; 742 u_int status, id; 743 744 buffer_init(&msg); 745 746 /* Send rename request */ 747 id = conn->msg_id++; 748 if ((conn->exts & SFTP_EXT_POSIX_RENAME)) { 749 buffer_put_char(&msg, SSH2_FXP_EXTENDED); 750 buffer_put_int(&msg, id); 751 buffer_put_cstring(&msg, "posix-rename@openssh.com"); 752 } else { 753 buffer_put_char(&msg, SSH2_FXP_RENAME); 754 buffer_put_int(&msg, id); 755 } 756 buffer_put_cstring(&msg, oldpath); 757 buffer_put_cstring(&msg, newpath); 758 send_msg(conn->fd_out, &msg); 759 debug3("Sent message %s \"%s\" -> \"%s\"", 760 (conn->exts & SFTP_EXT_POSIX_RENAME) ? "posix-rename@openssh.com" : 761 "SSH2_FXP_RENAME", oldpath, newpath); 762 buffer_free(&msg); 763 764 status = get_status(conn->fd_in, id); 765 if (status != SSH2_FX_OK) 766 error("Couldn't rename file \"%s\" to \"%s\": %s", oldpath, 767 newpath, fx2txt(status)); 768 769 return(status); 770} 771 772int 773do_symlink(struct sftp_conn *conn, char *oldpath, char *newpath) 774{ 775 Buffer msg; 776 u_int status, id; 777 778 if (conn->version < 3) { 779 error("This server does not support the symlink operation"); 780 return(SSH2_FX_OP_UNSUPPORTED); 781 } 782 783 buffer_init(&msg); 784 785 /* Send symlink request */ 786 id = conn->msg_id++; 787 buffer_put_char(&msg, SSH2_FXP_SYMLINK); 788 buffer_put_int(&msg, id); 789 buffer_put_cstring(&msg, oldpath); 790 buffer_put_cstring(&msg, newpath); 791 send_msg(conn->fd_out, &msg); 792 debug3("Sent message SSH2_FXP_SYMLINK \"%s\" -> \"%s\"", oldpath, 793 newpath); 794 buffer_free(&msg); 795 796 status = get_status(conn->fd_in, id); 797 if (status != SSH2_FX_OK) 798 error("Couldn't symlink file \"%s\" to \"%s\": %s", oldpath, 799 newpath, fx2txt(status)); 800 801 return(status); 802} 803 804#ifdef notyet 805char * 806do_readlink(struct sftp_conn *conn, char *path) 807{ 808 Buffer msg; 809 u_int type, expected_id, count, id; 810 char *filename, *longname; 811 Attrib *a; 812 813 expected_id = id = conn->msg_id++; 814 send_string_request(conn->fd_out, id, SSH2_FXP_READLINK, path, 815 strlen(path)); 816 817 buffer_init(&msg); 818 819 get_msg(conn->fd_in, &msg); 820 type = buffer_get_char(&msg); 821 id = buffer_get_int(&msg); 822 823 if (id != expected_id) 824 fatal("ID mismatch (%u != %u)", id, expected_id); 825 826 if (type == SSH2_FXP_STATUS) { 827 u_int status = buffer_get_int(&msg); 828 829 error("Couldn't readlink: %s", fx2txt(status)); 830 return(NULL); 831 } else if (type != SSH2_FXP_NAME) 832 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u", 833 SSH2_FXP_NAME, type); 834 835 count = buffer_get_int(&msg); 836 if (count != 1) 837 fatal("Got multiple names (%d) from SSH_FXP_READLINK", count); 838 839 filename = buffer_get_string(&msg, NULL); 840 longname = buffer_get_string(&msg, NULL); 841 a = decode_attrib(&msg); 842 843 debug3("SSH_FXP_READLINK %s -> %s", path, filename); 844 845 xfree(longname); 846 847 buffer_free(&msg); 848 849 return(filename); 850} 851#endif 852 853int 854do_statvfs(struct sftp_conn *conn, const char *path, struct sftp_statvfs *st, 855 int quiet) 856{ 857 Buffer msg; 858 u_int id; 859 860 if ((conn->exts & SFTP_EXT_STATVFS) == 0) { 861 error("Server does not support statvfs@openssh.com extension"); 862 return -1; 863 } 864 865 id = conn->msg_id++; 866 867 buffer_init(&msg); 868 buffer_clear(&msg); 869 buffer_put_char(&msg, SSH2_FXP_EXTENDED); 870 buffer_put_int(&msg, id); 871 buffer_put_cstring(&msg, "statvfs@openssh.com"); 872 buffer_put_cstring(&msg, path); 873 send_msg(conn->fd_out, &msg); 874 buffer_free(&msg); 875 876 return get_decode_statvfs(conn->fd_in, st, id, quiet); 877} 878 879#ifdef notyet 880int 881do_fstatvfs(struct sftp_conn *conn, const char *handle, u_int handle_len, 882 struct sftp_statvfs *st, int quiet) 883{ 884 Buffer msg; 885 u_int id; 886 887 if ((conn->exts & SFTP_EXT_FSTATVFS) == 0) { 888 error("Server does not support fstatvfs@openssh.com extension"); 889 return -1; 890 } 891 892 id = conn->msg_id++; 893 894 buffer_init(&msg); 895 buffer_clear(&msg); 896 buffer_put_char(&msg, SSH2_FXP_EXTENDED); 897 buffer_put_int(&msg, id); 898 buffer_put_cstring(&msg, "fstatvfs@openssh.com"); 899 buffer_put_string(&msg, handle, handle_len); 900 send_msg(conn->fd_out, &msg); 901 buffer_free(&msg); 902 903 return get_decode_statvfs(conn->fd_in, st, id, quiet); 904} 905#endif 906 907static void 908send_read_request(int fd_out, u_int id, u_int64_t offset, u_int len, 909 char *handle, u_int handle_len) 910{ 911 Buffer msg; 912 913 buffer_init(&msg); 914 buffer_clear(&msg); 915 buffer_put_char(&msg, SSH2_FXP_READ); 916 buffer_put_int(&msg, id); 917 buffer_put_string(&msg, handle, handle_len); 918 buffer_put_int64(&msg, offset); 919 buffer_put_int(&msg, len); 920 send_msg(fd_out, &msg); 921 buffer_free(&msg); 922} 923 924int 925do_download(struct sftp_conn *conn, char *remote_path, char *local_path, 926 Attrib *a, int pflag) 927{ 928 Attrib junk; 929 Buffer msg; 930 char *handle; 931 int local_fd, status = 0, write_error; 932 int read_error, write_errno; 933 u_int64_t offset, size; 934 u_int handle_len, mode, type, id, buflen, num_req, max_req; 935 off_t progress_counter; 936 struct request { 937 u_int id; 938 u_int len; 939 u_int64_t offset; 940 TAILQ_ENTRY(request) tq; 941 }; 942 TAILQ_HEAD(reqhead, request) requests; 943 struct request *req; 944 945 TAILQ_INIT(&requests); 946 947 if (a == NULL && (a = do_stat(conn, remote_path, 0)) == NULL) 948 return -1; 949 950 /* Do not preserve set[ug]id here, as we do not preserve ownership */ 951 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) 952 mode = a->perm & 0777; 953 else 954 mode = 0666; 955 956 if ((a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) && 957 (!S_ISREG(a->perm))) { 958 error("Cannot download non-regular file: %s", remote_path); 959 return(-1); 960 } 961 962 if (a->flags & SSH2_FILEXFER_ATTR_SIZE) 963 size = a->size; 964 else 965 size = 0; 966 967 buflen = conn->transfer_buflen; 968 buffer_init(&msg); 969 970 /* Send open request */ 971 id = conn->msg_id++; 972 buffer_put_char(&msg, SSH2_FXP_OPEN); 973 buffer_put_int(&msg, id); 974 buffer_put_cstring(&msg, remote_path); 975 buffer_put_int(&msg, SSH2_FXF_READ); 976 attrib_clear(&junk); /* Send empty attributes */ 977 encode_attrib(&msg, &junk); 978 send_msg(conn->fd_out, &msg); 979 debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path); 980 981 handle = get_handle(conn->fd_in, id, &handle_len, 982 "remote open(\"%s\")", remote_path); 983 if (handle == NULL) { 984 buffer_free(&msg); 985 return(-1); 986 } 987 988 local_fd = open(local_path, O_WRONLY | O_CREAT | O_TRUNC, 989 mode | S_IWRITE); 990 if (local_fd == -1) { 991 error("Couldn't open local file \"%s\" for writing: %s", 992 local_path, strerror(errno)); 993 do_close(conn, handle, handle_len); 994 buffer_free(&msg); 995 xfree(handle); 996 return(-1); 997 } 998 999 /* Read from remote and write to local */ 1000 write_error = read_error = write_errno = num_req = offset = 0; 1001 max_req = 1; 1002 progress_counter = 0; 1003 1004 if (showprogress && size != 0) 1005 start_progress_meter(remote_path, size, &progress_counter); 1006 1007 while (num_req > 0 || max_req > 0) { 1008 char *data; 1009 u_int len; 1010 1011 /* 1012 * Simulate EOF on interrupt: stop sending new requests and 1013 * allow outstanding requests to drain gracefully 1014 */ 1015 if (interrupted) { 1016 if (num_req == 0) /* If we haven't started yet... */ 1017 break; 1018 max_req = 0; 1019 } 1020 1021 /* Send some more requests */ 1022 while (num_req < max_req) { 1023 debug3("Request range %llu -> %llu (%d/%d)", 1024 (unsigned long long)offset, 1025 (unsigned long long)offset + buflen - 1, 1026 num_req, max_req); 1027 req = xmalloc(sizeof(*req)); 1028 req->id = conn->msg_id++; 1029 req->len = buflen; 1030 req->offset = offset; 1031 offset += buflen; 1032 num_req++; 1033 TAILQ_INSERT_TAIL(&requests, req, tq); 1034 send_read_request(conn->fd_out, req->id, req->offset, 1035 req->len, handle, handle_len); 1036 } 1037 1038 buffer_clear(&msg); 1039 get_msg(conn->fd_in, &msg); 1040 type = buffer_get_char(&msg); 1041 id = buffer_get_int(&msg); 1042 debug3("Received reply T:%u I:%u R:%d", type, id, max_req); 1043 1044 /* Find the request in our queue */ 1045 for (req = TAILQ_FIRST(&requests); 1046 req != NULL && req->id != id; 1047 req = TAILQ_NEXT(req, tq)) 1048 ; 1049 if (req == NULL) 1050 fatal("Unexpected reply %u", id); 1051 1052 switch (type) { 1053 case SSH2_FXP_STATUS: 1054 status = buffer_get_int(&msg); 1055 if (status != SSH2_FX_EOF) 1056 read_error = 1; 1057 max_req = 0; 1058 TAILQ_REMOVE(&requests, req, tq); 1059 xfree(req); 1060 num_req--; 1061 break; 1062 case SSH2_FXP_DATA: 1063 data = buffer_get_string(&msg, &len); 1064 debug3("Received data %llu -> %llu", 1065 (unsigned long long)req->offset, 1066 (unsigned long long)req->offset + len - 1); 1067 if (len > req->len) 1068 fatal("Received more data than asked for " 1069 "%u > %u", len, req->len); 1070 if ((lseek(local_fd, req->offset, SEEK_SET) == -1 || 1071 atomicio(vwrite, local_fd, data, len) != len) && 1072 !write_error) { 1073 write_errno = errno; 1074 write_error = 1; 1075 max_req = 0; 1076 } 1077 progress_counter += len; 1078 xfree(data); 1079 1080 if (len == req->len) { 1081 TAILQ_REMOVE(&requests, req, tq); 1082 xfree(req); 1083 num_req--; 1084 } else { 1085 /* Resend the request for the missing data */ 1086 debug3("Short data block, re-requesting " 1087 "%llu -> %llu (%2d)", 1088 (unsigned long long)req->offset + len, 1089 (unsigned long long)req->offset + 1090 req->len - 1, num_req); 1091 req->id = conn->msg_id++; 1092 req->len -= len; 1093 req->offset += len; 1094 send_read_request(conn->fd_out, req->id, 1095 req->offset, req->len, handle, handle_len); 1096 /* Reduce the request size */ 1097 if (len < buflen) 1098 buflen = MAX(MIN_READ_SIZE, len); 1099 } 1100 if (max_req > 0) { /* max_req = 0 iff EOF received */ 1101 if (size > 0 && offset > size) { 1102 /* Only one request at a time 1103 * after the expected EOF */ 1104 debug3("Finish at %llu (%2d)", 1105 (unsigned long long)offset, 1106 num_req); 1107 max_req = 1; 1108 } else if (max_req <= conn->num_requests) { 1109 ++max_req; 1110 } 1111 } 1112 break; 1113 default: 1114 fatal("Expected SSH2_FXP_DATA(%u) packet, got %u", 1115 SSH2_FXP_DATA, type); 1116 } 1117 } 1118 1119 if (showprogress && size) 1120 stop_progress_meter(); 1121 1122 /* Sanity check */ 1123 if (TAILQ_FIRST(&requests) != NULL) 1124 fatal("Transfer complete, but requests still in queue"); 1125 1126 if (read_error) { 1127 error("Couldn't read from remote file \"%s\" : %s", 1128 remote_path, fx2txt(status)); 1129 do_close(conn, handle, handle_len); 1130 } else if (write_error) { 1131 error("Couldn't write to \"%s\": %s", local_path, 1132 strerror(write_errno)); 1133 status = -1; 1134 do_close(conn, handle, handle_len); 1135 } else { 1136 status = do_close(conn, handle, handle_len); 1137 1138 /* Override umask and utimes if asked */ 1139#ifdef HAVE_FCHMOD 1140 if (pflag && fchmod(local_fd, mode) == -1) 1141#else 1142 if (pflag && chmod(local_path, mode) == -1) 1143#endif /* HAVE_FCHMOD */ 1144 error("Couldn't set mode on \"%s\": %s", local_path, 1145 strerror(errno)); 1146 if (pflag && (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME)) { 1147 struct timeval tv[2]; 1148 tv[0].tv_sec = a->atime; 1149 tv[1].tv_sec = a->mtime; 1150 tv[0].tv_usec = tv[1].tv_usec = 0; 1151 if (utimes(local_path, tv) == -1) 1152 error("Can't set times on \"%s\": %s", 1153 local_path, strerror(errno)); 1154 } 1155 } 1156 close(local_fd); 1157 buffer_free(&msg); 1158 xfree(handle); 1159 1160 return(status); 1161} 1162 1163static int 1164download_dir_internal(struct sftp_conn *conn, char *src, char *dst, 1165 Attrib *dirattrib, int pflag, int printflag, int depth) 1166{ 1167 int i, ret = 0; 1168 SFTP_DIRENT **dir_entries; 1169 char *filename, *new_src, *new_dst; 1170 mode_t mode = 0777; 1171 1172 if (depth >= MAX_DIR_DEPTH) { 1173 error("Maximum directory depth exceeded: %d levels", depth); 1174 return -1; 1175 } 1176 1177 if (dirattrib == NULL && 1178 (dirattrib = do_stat(conn, src, 1)) == NULL) { 1179 error("Unable to stat remote directory \"%s\"", src); 1180 return -1; 1181 } 1182 if (!S_ISDIR(dirattrib->perm)) { 1183 error("\"%s\" is not a directory", src); 1184 return -1; 1185 } 1186 if (printflag) 1187 printf("Retrieving %s\n", src); 1188 1189 if (dirattrib->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) 1190 mode = dirattrib->perm & 01777; 1191 else { 1192 debug("Server did not send permissions for " 1193 "directory \"%s\"", dst); 1194 } 1195 1196 if (mkdir(dst, mode) == -1 && errno != EEXIST) { 1197 error("mkdir %s: %s", dst, strerror(errno)); 1198 return -1; 1199 } 1200 1201 if (do_readdir(conn, src, &dir_entries) == -1) { 1202 error("%s: Failed to get directory contents", src); 1203 return -1; 1204 } 1205 1206 for (i = 0; dir_entries[i] != NULL && !interrupted; i++) { 1207 filename = dir_entries[i]->filename; 1208 1209 new_dst = path_append(dst, filename); 1210 new_src = path_append(src, filename); 1211 1212 if (S_ISDIR(dir_entries[i]->a.perm)) { 1213 if (strcmp(filename, ".") == 0 || 1214 strcmp(filename, "..") == 0) 1215 continue; 1216 if (download_dir_internal(conn, new_src, new_dst, 1217 &(dir_entries[i]->a), pflag, printflag, 1218 depth + 1) == -1) 1219 ret = -1; 1220 } else if (S_ISREG(dir_entries[i]->a.perm) ) { 1221 if (do_download(conn, new_src, new_dst, 1222 &(dir_entries[i]->a), pflag) == -1) { 1223 error("Download of file %s to %s failed", 1224 new_src, new_dst); 1225 ret = -1; 1226 } 1227 } else 1228 logit("%s: not a regular file\n", new_src); 1229 1230 xfree(new_dst); 1231 xfree(new_src); 1232 } 1233 1234 if (pflag) { 1235 if (dirattrib->flags & SSH2_FILEXFER_ATTR_ACMODTIME) { 1236 struct timeval tv[2]; 1237 tv[0].tv_sec = dirattrib->atime; 1238 tv[1].tv_sec = dirattrib->mtime; 1239 tv[0].tv_usec = tv[1].tv_usec = 0; 1240 if (utimes(dst, tv) == -1) 1241 error("Can't set times on \"%s\": %s", 1242 dst, strerror(errno)); 1243 } else 1244 debug("Server did not send times for directory " 1245 "\"%s\"", dst); 1246 } 1247 1248 free_sftp_dirents(dir_entries); 1249 1250 return ret; 1251} 1252 1253int 1254download_dir(struct sftp_conn *conn, char *src, char *dst, 1255 Attrib *dirattrib, int pflag, int printflag) 1256{ 1257 char *src_canon; 1258 int ret; 1259 1260 if ((src_canon = do_realpath(conn, src)) == NULL) { 1261 error("Unable to canonicalise path \"%s\"", src); 1262 return -1; 1263 } 1264 1265 ret = download_dir_internal(conn, src_canon, dst, 1266 dirattrib, pflag, printflag, 0); 1267 xfree(src_canon); 1268 return ret; 1269} 1270 1271int 1272do_upload(struct sftp_conn *conn, char *local_path, char *remote_path, 1273 int pflag) 1274{ 1275 int local_fd; 1276 int status = SSH2_FX_OK; 1277 u_int handle_len, id, type; 1278 off_t offset; 1279 char *handle, *data; 1280 Buffer msg; 1281 struct stat sb; 1282 Attrib a; 1283 u_int32_t startid; 1284 u_int32_t ackid; 1285 struct outstanding_ack { 1286 u_int id; 1287 u_int len; 1288 off_t offset; 1289 TAILQ_ENTRY(outstanding_ack) tq; 1290 }; 1291 TAILQ_HEAD(ackhead, outstanding_ack) acks; 1292 struct outstanding_ack *ack = NULL; 1293 1294 TAILQ_INIT(&acks); 1295 1296 if ((local_fd = open(local_path, O_RDONLY, 0)) == -1) { 1297 error("Couldn't open local file \"%s\" for reading: %s", 1298 local_path, strerror(errno)); 1299 return(-1); 1300 } 1301 if (fstat(local_fd, &sb) == -1) { 1302 error("Couldn't fstat local file \"%s\": %s", 1303 local_path, strerror(errno)); 1304 close(local_fd); 1305 return(-1); 1306 } 1307 if (!S_ISREG(sb.st_mode)) { 1308 error("%s is not a regular file", local_path); 1309 close(local_fd); 1310 return(-1); 1311 } 1312 stat_to_attrib(&sb, &a); 1313 1314 a.flags &= ~SSH2_FILEXFER_ATTR_SIZE; 1315 a.flags &= ~SSH2_FILEXFER_ATTR_UIDGID; 1316 a.perm &= 0777; 1317 if (!pflag) 1318 a.flags &= ~SSH2_FILEXFER_ATTR_ACMODTIME; 1319 1320 buffer_init(&msg); 1321 1322 /* Send open request */ 1323 id = conn->msg_id++; 1324 buffer_put_char(&msg, SSH2_FXP_OPEN); 1325 buffer_put_int(&msg, id); 1326 buffer_put_cstring(&msg, remote_path); 1327 buffer_put_int(&msg, SSH2_FXF_WRITE|SSH2_FXF_CREAT|SSH2_FXF_TRUNC); 1328 encode_attrib(&msg, &a); 1329 send_msg(conn->fd_out, &msg); 1330 debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path); 1331 1332 buffer_clear(&msg); 1333 1334 handle = get_handle(conn->fd_in, id, &handle_len, 1335 "remote open(\"%s\")", remote_path); 1336 if (handle == NULL) { 1337 close(local_fd); 1338 buffer_free(&msg); 1339 return -1; 1340 } 1341 1342 startid = ackid = id + 1; 1343 data = xmalloc(conn->transfer_buflen); 1344 1345 /* Read from local and write to remote */ 1346 offset = 0; 1347 if (showprogress) 1348 start_progress_meter(local_path, sb.st_size, &offset); 1349 1350 for (;;) { 1351 int len; 1352 1353 /* 1354 * Can't use atomicio here because it returns 0 on EOF, 1355 * thus losing the last block of the file. 1356 * Simulate an EOF on interrupt, allowing ACKs from the 1357 * server to drain. 1358 */ 1359 if (interrupted || status != SSH2_FX_OK) 1360 len = 0; 1361 else do 1362 len = read(local_fd, data, conn->transfer_buflen); 1363 while ((len == -1) && 1364 (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)); 1365 1366 if (len == -1) 1367 fatal("Couldn't read from \"%s\": %s", local_path, 1368 strerror(errno)); 1369 1370 if (len != 0) { 1371 ack = xmalloc(sizeof(*ack)); 1372 ack->id = ++id; 1373 ack->offset = offset; 1374 ack->len = len; 1375 TAILQ_INSERT_TAIL(&acks, ack, tq); 1376 1377 buffer_clear(&msg); 1378 buffer_put_char(&msg, SSH2_FXP_WRITE); 1379 buffer_put_int(&msg, ack->id); 1380 buffer_put_string(&msg, handle, handle_len); 1381 buffer_put_int64(&msg, offset); 1382 buffer_put_string(&msg, data, len); 1383 send_msg(conn->fd_out, &msg); 1384 debug3("Sent message SSH2_FXP_WRITE I:%u O:%llu S:%u", 1385 id, (unsigned long long)offset, len); 1386 } else if (TAILQ_FIRST(&acks) == NULL) 1387 break; 1388 1389 if (ack == NULL) 1390 fatal("Unexpected ACK %u", id); 1391 1392 if (id == startid || len == 0 || 1393 id - ackid >= conn->num_requests) { 1394 u_int r_id; 1395 1396 buffer_clear(&msg); 1397 get_msg(conn->fd_in, &msg); 1398 type = buffer_get_char(&msg); 1399 r_id = buffer_get_int(&msg); 1400 1401 if (type != SSH2_FXP_STATUS) 1402 fatal("Expected SSH2_FXP_STATUS(%d) packet, " 1403 "got %d", SSH2_FXP_STATUS, type); 1404 1405 status = buffer_get_int(&msg); 1406 debug3("SSH2_FXP_STATUS %d", status); 1407 1408 /* Find the request in our queue */ 1409 for (ack = TAILQ_FIRST(&acks); 1410 ack != NULL && ack->id != r_id; 1411 ack = TAILQ_NEXT(ack, tq)) 1412 ; 1413 if (ack == NULL) 1414 fatal("Can't find request for ID %u", r_id); 1415 TAILQ_REMOVE(&acks, ack, tq); 1416 debug3("In write loop, ack for %u %u bytes at %lld", 1417 ack->id, ack->len, (long long)ack->offset); 1418 ++ackid; 1419 xfree(ack); 1420 } 1421 offset += len; 1422 if (offset < 0) 1423 fatal("%s: offset < 0", __func__); 1424 } 1425 buffer_free(&msg); 1426 1427 if (showprogress) 1428 stop_progress_meter(); 1429 xfree(data); 1430 1431 if (status != SSH2_FX_OK) { 1432 error("Couldn't write to remote file \"%s\": %s", 1433 remote_path, fx2txt(status)); 1434 status = -1; 1435 } 1436 1437 if (close(local_fd) == -1) { 1438 error("Couldn't close local file \"%s\": %s", local_path, 1439 strerror(errno)); 1440 status = -1; 1441 } 1442 1443 /* Override umask and utimes if asked */ 1444 if (pflag) 1445 do_fsetstat(conn, handle, handle_len, &a); 1446 1447 if (do_close(conn, handle, handle_len) != SSH2_FX_OK) 1448 status = -1; 1449 xfree(handle); 1450 1451 return status; 1452} 1453 1454static int 1455upload_dir_internal(struct sftp_conn *conn, char *src, char *dst, 1456 int pflag, int printflag, int depth) 1457{ 1458 int ret = 0, status; 1459 DIR *dirp; 1460 struct dirent *dp; 1461 char *filename, *new_src, *new_dst; 1462 struct stat sb; 1463 Attrib a; 1464 1465 if (depth >= MAX_DIR_DEPTH) { 1466 error("Maximum directory depth exceeded: %d levels", depth); 1467 return -1; 1468 } 1469 1470 if (stat(src, &sb) == -1) { 1471 error("Couldn't stat directory \"%s\": %s", 1472 src, strerror(errno)); 1473 return -1; 1474 } 1475 if (!S_ISDIR(sb.st_mode)) { 1476 error("\"%s\" is not a directory", src); 1477 return -1; 1478 } 1479 if (printflag) 1480 printf("Entering %s\n", src); 1481 1482 attrib_clear(&a); 1483 stat_to_attrib(&sb, &a); 1484 a.flags &= ~SSH2_FILEXFER_ATTR_SIZE; 1485 a.flags &= ~SSH2_FILEXFER_ATTR_UIDGID; 1486 a.perm &= 01777; 1487 if (!pflag) 1488 a.flags &= ~SSH2_FILEXFER_ATTR_ACMODTIME; 1489 1490 status = do_mkdir(conn, dst, &a, 0); 1491 /* 1492 * we lack a portable status for errno EEXIST, 1493 * so if we get a SSH2_FX_FAILURE back we must check 1494 * if it was created successfully. 1495 */ 1496 if (status != SSH2_FX_OK) { 1497 if (status != SSH2_FX_FAILURE) 1498 return -1; 1499 if (do_stat(conn, dst, 0) == NULL) 1500 return -1; 1501 } 1502 1503 if ((dirp = opendir(src)) == NULL) { 1504 error("Failed to open dir \"%s\": %s", src, strerror(errno)); 1505 return -1; 1506 } 1507 1508 while (((dp = readdir(dirp)) != NULL) && !interrupted) { 1509 if (dp->d_ino == 0) 1510 continue; 1511 filename = dp->d_name; 1512 new_dst = path_append(dst, filename); 1513 new_src = path_append(src, filename); 1514 1515 if (lstat(new_src, &sb) == -1) { 1516 logit("%s: lstat failed: %s", filename, 1517 strerror(errno)); 1518 ret = -1; 1519 } else if (S_ISDIR(sb.st_mode)) { 1520 if (strcmp(filename, ".") == 0 || 1521 strcmp(filename, "..") == 0) 1522 continue; 1523 1524 if (upload_dir_internal(conn, new_src, new_dst, 1525 pflag, depth + 1, printflag) == -1) 1526 ret = -1; 1527 } else if (S_ISREG(sb.st_mode)) { 1528 if (do_upload(conn, new_src, new_dst, pflag) == -1) { 1529 error("Uploading of file %s to %s failed!", 1530 new_src, new_dst); 1531 ret = -1; 1532 } 1533 } else 1534 logit("%s: not a regular file\n", filename); 1535 xfree(new_dst); 1536 xfree(new_src); 1537 } 1538 1539 do_setstat(conn, dst, &a); 1540 1541 (void) closedir(dirp); 1542 return ret; 1543} 1544 1545int 1546upload_dir(struct sftp_conn *conn, char *src, char *dst, int printflag, 1547 int pflag) 1548{ 1549 char *dst_canon; 1550 int ret; 1551 1552 if ((dst_canon = do_realpath(conn, dst)) == NULL) { 1553 error("Unable to canonicalise path \"%s\"", dst); 1554 return -1; 1555 } 1556 1557 ret = upload_dir_internal(conn, src, dst_canon, pflag, printflag, 0); 1558 xfree(dst_canon); 1559 return ret; 1560} 1561 1562char * 1563path_append(char *p1, char *p2) 1564{ 1565 char *ret; 1566 size_t len = strlen(p1) + strlen(p2) + 2; 1567 1568 ret = xmalloc(len); 1569 strlcpy(ret, p1, len); 1570 if (p1[0] != '\0' && p1[strlen(p1) - 1] != '/') 1571 strlcat(ret, "/", len); 1572 strlcat(ret, p2, len); 1573 1574 return(ret); 1575} 1576 1577