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