sftp-client.c

   1 /*
   2  * Copyright (c) 2001 Damien Miller.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 /* XXX: memleaks */
  26 /* XXX: signed vs unsigned */
  27 /* XXX: redesign to allow concurrent overlapped operations */
  28 /* XXX: we use fatal too much, error may be more appropriate in places */
  29 /* XXX: copy between two remote sites */
  30
  31 #include "includes.h"
  32 RCSID("$OpenBSD: sftp-client.c,v 1.11 2001/03/07 10:11:22 djm Exp $");
  33
  34 #include "ssh.h"
  35 #include "buffer.h"
  36 #include "bufaux.h"
  37 #include "getput.h"
  38 #include "xmalloc.h"
  39 #include "log.h"
  40 #include "atomicio.h"
  41 #include "pathnames.h"
  42
  43 #include "sftp.h"
  44 #include "sftp-common.h"
  45 #include "sftp-client.h"
  46
  47 /* How much data to read/write at at time during copies */
  48 /* XXX: what should this be? */
  49 #define COPY_SIZE       8192
  50
  51 /* Message ID */
  52 static u_int msg_id = 1;
  53
  54 void
  55 send_msg(int fd, Buffer *m)
  56 {
  57         int mlen = buffer_len(m);
  58         int len;
  59         Buffer oqueue;
  60
  61         buffer_init(&oqueue);
  62         buffer_put_int(&oqueue, mlen);
  63         buffer_append(&oqueue, buffer_ptr(m), mlen);
  64         buffer_consume(m, mlen);
  65
  66         len = atomicio(write, fd, buffer_ptr(&oqueue), buffer_len(&oqueue));
  67         if (len <= 0)
  68                 fatal("Couldn't send packet: %s", strerror(errno));
  69
  70         buffer_free(&oqueue);
  71 }
  72
  73 void
  74 get_msg(int fd, Buffer *m)
  75 {
  76         u_int len, msg_len;
  77         unsigned char buf[4096];
  78
  79         len = atomicio(read, fd, buf, 4);
  80         if (len != 4)
  81                 fatal("Couldn't read packet: %s", strerror(errno));
  82
  83         msg_len = GET_32BIT(buf);
  84         if (msg_len > 256 * 1024)
  85                 fatal("Received message too long %d", msg_len);
  86
  87         while (msg_len) {
  88                 len = atomicio(read, fd, buf, MIN(msg_len, sizeof(buf)));
  89                 if (len <= 0)
  90                         fatal("Couldn't read packet: %s", strerror(errno));
  91
  92                 msg_len -= len;
  93                 buffer_append(m, buf, len);
  94         }
  95 }
  96
  97 void
  98 send_string_request(int fd, u_int id, u_int code, char *s,
  99     u_int len)
 100 {
 101         Buffer msg;
 102
 103         buffer_init(&msg);
 104         buffer_put_char(&msg, code);
 105         buffer_put_int(&msg, id);
 106         buffer_put_string(&msg, s, len);
 107         send_msg(fd, &msg);
 108         debug3("Sent message fd %d T:%d I:%d", fd, code, id);
 109         buffer_free(&msg);
 110 }
 111
 112 void
 113 send_string_attrs_request(int fd, u_int id, u_int code, char *s,
 114     u_int len, Attrib *a)
 115 {
 116         Buffer msg;
 117
 118         buffer_init(&msg);
 119         buffer_put_char(&msg, code);
 120         buffer_put_int(&msg, id);
 121         buffer_put_string(&msg, s, len);
 122         encode_attrib(&msg, a);
 123         send_msg(fd, &msg);
 124         debug3("Sent message fd %d T:%d I:%d", fd, code, id);
 125         buffer_free(&msg);
 126 }
 127
 128 u_int
 129 get_status(int fd, int expected_id)
 130 {
 131         Buffer msg;
 132         u_int type, id, status;
 133
 134         buffer_init(&msg);
 135         get_msg(fd, &msg);
 136         type = buffer_get_char(&msg);
 137         id = buffer_get_int(&msg);
 138
 139         if (id != expected_id)
 140                 fatal("ID mismatch (%d != %d)", id, expected_id);
 141         if (type != SSH2_FXP_STATUS)
 142                 fatal("Expected SSH2_FXP_STATUS(%d) packet, got %d",
 143                     SSH2_FXP_STATUS, type);
 144
 145         status = buffer_get_int(&msg);
 146         buffer_free(&msg);
 147
 148         debug3("SSH2_FXP_STATUS %d", status);
 149
 150         return(status);
 151 }
 152
 153 char *
 154 get_handle(int fd, u_int expected_id, u_int *len)
 155 {
 156         Buffer msg;
 157         u_int type, id;
 158         char *handle;
 159
 160         buffer_init(&msg);
 161         get_msg(fd, &msg);
 162         type = buffer_get_char(&msg);
 163         id = buffer_get_int(&msg);
 164
 165         if (id != expected_id)
 166                 fatal("ID mismatch (%d != %d)", id, expected_id);
 167         if (type == SSH2_FXP_STATUS) {
 168                 int status = buffer_get_int(&msg);
 169
 170                 error("Couldn't get handle: %s", fx2txt(status));
 171                 return(NULL);
 172         } else if (type != SSH2_FXP_HANDLE)
 173                 fatal("Expected SSH2_FXP_HANDLE(%d) packet, got %d",
 174                     SSH2_FXP_HANDLE, type);
 175
 176         handle = buffer_get_string(&msg, len);
 177         buffer_free(&msg);
 178
 179         return(handle);
 180 }
 181
 182 Attrib *
 183 get_decode_stat(int fd, u_int expected_id)
 184 {
 185         Buffer msg;
 186         u_int type, id;
 187         Attrib *a;
 188
 189         buffer_init(&msg);
 190         get_msg(fd, &msg);
 191
 192         type = buffer_get_char(&msg);
 193         id = buffer_get_int(&msg);
 194
 195         debug3("Received stat reply T:%d I:%d", type, id);
 196         if (id != expected_id)
 197                 fatal("ID mismatch (%d != %d)", id, expected_id);
 198         if (type == SSH2_FXP_STATUS) {
 199                 int status = buffer_get_int(&msg);
 200
 201                 error("Couldn't stat remote file: %s", fx2txt(status));
 202                 return(NULL);
 203         } else if (type != SSH2_FXP_ATTRS) {
 204                 fatal("Expected SSH2_FXP_ATTRS(%d) packet, got %d",
 205                     SSH2_FXP_ATTRS, type);
 206         }
 207         a = decode_attrib(&msg);
 208         buffer_free(&msg);
 209
 210         return(a);
 211 }
 212
 213 int
 214 do_init(int fd_in, int fd_out)
 215 {
 216         int type, version;
 217         Buffer msg;
 218
 219         buffer_init(&msg);
 220         buffer_put_char(&msg, SSH2_FXP_INIT);
 221         buffer_put_int(&msg, SSH2_FILEXFER_VERSION);
 222         send_msg(fd_out, &msg);
 223
 224         buffer_clear(&msg);
 225
 226         get_msg(fd_in, &msg);
 227
 228         /* Expecting a VERSION reply */
 229         if ((type = buffer_get_char(&msg)) != SSH2_FXP_VERSION) {
 230                 error("Invalid packet back from SSH2_FXP_INIT (type %d)",
 231                     type);
 232                 buffer_free(&msg);
 233                 return(-1);
 234         }
 235         version = buffer_get_int(&msg);
 236
 237         debug2("Remote version: %d", version);
 238
 239         /* Check for extensions */
 240         while (buffer_len(&msg) > 0) {
 241                 char *name = buffer_get_string(&msg, NULL);
 242                 char *value = buffer_get_string(&msg, NULL);
 243
 244                 debug2("Init extension: \"%s\"", name);
 245                 xfree(name);
 246                 xfree(value);
 247         }
 248
 249         buffer_free(&msg);
 250
 251         return(version);
 252 }
 253
 254 int
 255 do_close(int fd_in, int fd_out, char *handle, u_int handle_len)
 256 {
 257         u_int id, status;
 258         Buffer msg;
 259
 260         buffer_init(&msg);
 261
 262         id = msg_id++;
 263         buffer_put_char(&msg, SSH2_FXP_CLOSE);
 264         buffer_put_int(&msg, id);
 265         buffer_put_string(&msg, handle, handle_len);
 266         send_msg(fd_out, &msg);
 267         debug3("Sent message SSH2_FXP_CLOSE I:%d", id);
 268
 269         status = get_status(fd_in, id);
 270         if (status != SSH2_FX_OK)
 271                 error("Couldn't close file: %s", fx2txt(status));
 272
 273         buffer_free(&msg);
 274
 275         return(status);
 276 }
 277
 278 int
 279 do_ls(int fd_in, int fd_out, char *path)
 280 {
 281         Buffer msg;
 282         u_int type, id, handle_len, i, expected_id;
 283         char *handle;
 284
 285         id = msg_id++;
 286
 287         buffer_init(&msg);
 288         buffer_put_char(&msg, SSH2_FXP_OPENDIR);
 289         buffer_put_int(&msg, id);
 290         buffer_put_cstring(&msg, path);
 291         send_msg(fd_out, &msg);
 292
 293         buffer_clear(&msg);
 294
 295         handle = get_handle(fd_in, id, &handle_len);
 296         if (handle == NULL)
 297                 return(-1);
 298
 299         for(;;) {
 300                 int count;
 301
 302                 id = expected_id = msg_id++;
 303
 304                 debug3("Sending SSH2_FXP_READDIR I:%d", id);
 305
 306                 buffer_clear(&msg);
 307                 buffer_put_char(&msg, SSH2_FXP_READDIR);
 308                 buffer_put_int(&msg, id);
 309                 buffer_put_string(&msg, handle, handle_len);
 310                 send_msg(fd_out, &msg);
 311
 312                 buffer_clear(&msg);
 313
 314                 get_msg(fd_in, &msg);
 315
 316                 type = buffer_get_char(&msg);
 317                 id = buffer_get_int(&msg);
 318
 319                 debug3("Received reply T:%d I:%d", type, id);
 320
 321                 if (id != expected_id)
 322                         fatal("ID mismatch (%d != %d)", id, expected_id);
 323
 324                 if (type == SSH2_FXP_STATUS) {
 325                         int status = buffer_get_int(&msg);
 326
 327                         debug3("Received SSH2_FXP_STATUS %d", status);
 328
 329                         if (status == SSH2_FX_EOF) {
 330                                 break;
 331                         } else {
 332                                 error("Couldn't read directory: %s",
 333                                     fx2txt(status));
 334                                 do_close(fd_in, fd_out, handle, handle_len);
 335                                 return(status);
 336                         }
 337                 } else if (type != SSH2_FXP_NAME)
 338                         fatal("Expected SSH2_FXP_NAME(%d) packet, got %d",
 339                             SSH2_FXP_NAME, type);
 340
 341                 count = buffer_get_int(&msg);
 342                 if (count == 0)
 343                         break;
 344                 debug3("Received %d SSH2_FXP_NAME responses", count);
 345                 for(i = 0; i < count; i++) {
 346                         char *filename, *longname;
 347                         Attrib *a;
 348
 349                         filename = buffer_get_string(&msg, NULL);
 350                         longname = buffer_get_string(&msg, NULL);
 351                         a = decode_attrib(&msg);
 352
 353                         printf("%s\n", longname);
 354
 355                         xfree(filename);
 356                         xfree(longname);
 357                 }
 358         }
 359
 360         buffer_free(&msg);
 361         do_close(fd_in, fd_out, handle, handle_len);
 362         xfree(handle);
 363
 364         return(0);
 365 }
 366
 367 int
 368 do_rm(int fd_in, int fd_out, char *path)
 369 {
 370         u_int status, id;
 371
 372         debug2("Sending SSH2_FXP_REMOVE \"%s\"", path);
 373
 374         id = msg_id++;
 375         send_string_request(fd_out, id, SSH2_FXP_REMOVE, path, strlen(path));
 376         status = get_status(fd_in, id);
 377         if (status != SSH2_FX_OK)
 378                 error("Couldn't delete file: %s", fx2txt(status));
 379         return(status);
 380 }
 381
 382 int
 383 do_mkdir(int fd_in, int fd_out, char *path, Attrib *a)
 384 {
 385         u_int status, id;
 386
 387         id = msg_id++;
 388         send_string_attrs_request(fd_out, id, SSH2_FXP_MKDIR, path,
 389             strlen(path), a);
 390
 391         status = get_status(fd_in, id);
 392         if (status != SSH2_FX_OK)
 393                 error("Couldn't create directory: %s", fx2txt(status));
 394
 395         return(status);
 396 }
 397
 398 int
 399 do_rmdir(int fd_in, int fd_out, char *path)
 400 {
 401         u_int status, id;
 402
 403         id = msg_id++;
 404         send_string_request(fd_out, id, SSH2_FXP_RMDIR, path, strlen(path));
 405
 406         status = get_status(fd_in, id);
 407         if (status != SSH2_FX_OK)
 408                 error("Couldn't remove directory: %s", fx2txt(status));
 409
 410         return(status);
 411 }
 412
 413 Attrib *
 414 do_stat(int fd_in, int fd_out, char *path)
 415 {
 416         u_int id;
 417
 418         id = msg_id++;
 419         send_string_request(fd_out, id, SSH2_FXP_STAT, path, strlen(path));
 420         return(get_decode_stat(fd_in, id));
 421 }
 422
 423 Attrib *
 424 do_lstat(int fd_in, int fd_out, char *path)
 425 {
 426         u_int id;
 427
 428         id = msg_id++;
 429         send_string_request(fd_out, id, SSH2_FXP_LSTAT, path, strlen(path));
 430         return(get_decode_stat(fd_in, id));
 431 }
 432
 433 Attrib *
 434 do_fstat(int fd_in, int fd_out, char *handle,
 435     u_int handle_len)
 436 {
 437         u_int id;
 438
 439         id = msg_id++;
 440         send_string_request(fd_out, id, SSH2_FXP_FSTAT, handle, handle_len);
 441         return(get_decode_stat(fd_in, id));
 442 }
 443
 444 int
 445 do_setstat(int fd_in, int fd_out, char *path, Attrib *a)
 446 {
 447         u_int status, id;
 448
 449         id = msg_id++;
 450         send_string_attrs_request(fd_out, id, SSH2_FXP_SETSTAT, path,
 451             strlen(path), a);
 452
 453         status = get_status(fd_in, id);
 454         if (status != SSH2_FX_OK)
 455                 error("Couldn't setstat on \"%s\": %s", path,
 456                     fx2txt(status));
 457
 458         return(status);
 459 }
 460
 461 int
 462 do_fsetstat(int fd_in, int fd_out, char *handle, u_int handle_len,
 463     Attrib *a)
 464 {
 465         u_int status, id;
 466
 467         id = msg_id++;
 468         send_string_attrs_request(fd_out, id, SSH2_FXP_FSETSTAT, handle,
 469             handle_len, a);
 470
 471         status = get_status(fd_in, id);
 472         if (status != SSH2_FX_OK)
 473                 error("Couldn't fsetstat: %s", fx2txt(status));
 474
 475         return(status);
 476 }
 477
 478 char *
 479 do_realpath(int fd_in, int fd_out, char *path)
 480 {
 481         Buffer msg;
 482         u_int type, expected_id, count, id;
 483         char *filename, *longname;
 484         Attrib *a;
 485
 486         expected_id = id = msg_id++;
 487         send_string_request(fd_out, id, SSH2_FXP_REALPATH, path, strlen(path));
 488
 489         buffer_init(&msg);
 490
 491         get_msg(fd_in, &msg);
 492         type = buffer_get_char(&msg);
 493         id = buffer_get_int(&msg);
 494
 495         if (id != expected_id)
 496                 fatal("ID mismatch (%d != %d)", id, expected_id);
 497
 498         if (type == SSH2_FXP_STATUS) {
 499                 u_int status = buffer_get_int(&msg);
 500
 501                 error("Couldn't canonicalise: %s", fx2txt(status));
 502                 return(NULL);
 503         } else if (type != SSH2_FXP_NAME)
 504                 fatal("Expected SSH2_FXP_NAME(%d) packet, got %d",
 505                     SSH2_FXP_NAME, type);
 506
 507         count = buffer_get_int(&msg);
 508         if (count != 1)
 509                 fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count);
 510
 511         filename = buffer_get_string(&msg, NULL);
 512         longname = buffer_get_string(&msg, NULL);
 513         a = decode_attrib(&msg);
 514
 515         debug3("SSH_FXP_REALPATH %s -> %s", path, filename);
 516
 517         xfree(longname);
 518
 519         buffer_free(&msg);
 520
 521         return(filename);
 522 }
 523
 524 int
 525 do_rename(int fd_in, int fd_out, char *oldpath, char *newpath)
 526 {
 527         Buffer msg;
 528         u_int status, id;
 529
 530         buffer_init(&msg);
 531
 532         /* Send rename request */
 533         id = msg_id++;
 534         buffer_put_char(&msg, SSH2_FXP_RENAME);
 535         buffer_put_int(&msg, id);
 536         buffer_put_cstring(&msg, oldpath);
 537         buffer_put_cstring(&msg, newpath);
 538         send_msg(fd_out, &msg);
 539         debug3("Sent message SSH2_FXP_RENAME \"%s\" -> \"%s\"", oldpath,
 540             newpath);
 541         buffer_free(&msg);
 542
 543         status = get_status(fd_in, id);
 544         if (status != SSH2_FX_OK)
 545                 error("Couldn't rename file \"%s\" to \"%s\": %s", oldpath, newpath,
 546                     fx2txt(status));
 547
 548         return(status);
 549 }
 550
 551 int
 552 do_symlink(int fd_in, int fd_out, char *oldpath, char *newpath)
 553 {
 554         Buffer msg;
 555         u_int status, id;
 556
 557         buffer_init(&msg);
 558
 559         /* Send rename request */
 560         id = msg_id++;
 561         buffer_put_char(&msg, SSH2_FXP_SYMLINK);
 562         buffer_put_int(&msg, id);
 563         buffer_put_cstring(&msg, oldpath);
 564         buffer_put_cstring(&msg, newpath);
 565         send_msg(fd_out, &msg);
 566         debug3("Sent message SSH2_FXP_SYMLINK \"%s\" -> \"%s\"", oldpath,
 567             newpath);
 568         buffer_free(&msg);
 569
 570         status = get_status(fd_in, id);
 571         if (status != SSH2_FX_OK)
 572                 error("Couldn't rename file \"%s\" to \"%s\": %s", oldpath, newpath,
 573                     fx2txt(status));
 574
 575         return(status);
 576 }
 577
 578 char *
 579 do_readlink(int fd_in, int fd_out, char *path)
 580 {
 581         Buffer msg;
 582         u_int type, expected_id, count, id;
 583         char *filename, *longname;
 584         Attrib *a;
 585
 586         expected_id = id = msg_id++;
 587         send_string_request(fd_out, id, SSH2_FXP_READLINK, path, strlen(path));
 588
 589         buffer_init(&msg);
 590
 591         get_msg(fd_in, &msg);
 592         type = buffer_get_char(&msg);
 593         id = buffer_get_int(&msg);
 594
 595         if (id != expected_id)
 596                 fatal("ID mismatch (%d != %d)", id, expected_id);
 597
 598         if (type == SSH2_FXP_STATUS) {
 599                 u_int status = buffer_get_int(&msg);
 600
 601                 error("Couldn't readlink: %s", fx2txt(status));
 602                 return(NULL);
 603         } else if (type != SSH2_FXP_NAME)
 604                 fatal("Expected SSH2_FXP_NAME(%d) packet, got %d",
 605                     SSH2_FXP_NAME, type);
 606
 607         count = buffer_get_int(&msg);
 608         if (count != 1)
 609                 fatal("Got multiple names (%d) from SSH_FXP_READLINK", count);
 610
 611         filename = buffer_get_string(&msg, NULL);
 612         longname = buffer_get_string(&msg, NULL);
 613         a = decode_attrib(&msg);
 614
 615         debug3("SSH_FXP_READLINK %s -> %s", path, filename);
 616
 617         xfree(longname);
 618
 619         buffer_free(&msg);
 620
 621         return(filename);
 622 }
 623
 624 int
 625 do_download(int fd_in, int fd_out, char *remote_path, char *local_path,
 626     int pflag)
 627 {
 628         int local_fd;
 629         u_int expected_id, handle_len, mode, type, id;
 630         u_int64_t offset;
 631         char *handle;
 632         Buffer msg;
 633         Attrib junk, *a;
 634         int status;
 635
 636         a = do_stat(fd_in, fd_out, remote_path);
 637         if (a == NULL)
 638                 return(-1);
 639
 640         /* XXX: should we preserve set[ug]id? */
 641         if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS)
 642                 mode = S_IWRITE | (a->perm & 0777);
 643         else
 644                 mode = 0666;
 645
 646         local_fd = open(local_path, O_WRONLY | O_CREAT | O_TRUNC, mode);
 647         if (local_fd == -1) {
 648                 error("Couldn't open local file \"%s\" for writing: %s",
 649                     local_path, strerror(errno));
 650                 return(errno);
 651         }
 652
 653         buffer_init(&msg);
 654
 655         /* Send open request */
 656         id = msg_id++;
 657         buffer_put_char(&msg, SSH2_FXP_OPEN);
 658         buffer_put_int(&msg, id);
 659         buffer_put_cstring(&msg, remote_path);
 660         buffer_put_int(&msg, SSH2_FXF_READ);
 661         attrib_clear(&junk); /* Send empty attributes */
 662         encode_attrib(&msg, &junk);
 663         send_msg(fd_out, &msg);
 664         debug3("Sent message SSH2_FXP_OPEN I:%d P:%s", id, remote_path);
 665
 666         handle = get_handle(fd_in, id, &handle_len);
 667         if (handle == NULL) {
 668                 buffer_free(&msg);
 669                 close(local_fd);
 670                 return(-1);
 671         }
 672
 673         /* Read from remote and write to local */
 674         offset = 0;
 675         for(;;) {
 676                 u_int len;
 677                 char *data;
 678
 679                 id = expected_id = msg_id++;
 680
 681                 buffer_clear(&msg);
 682                 buffer_put_char(&msg, SSH2_FXP_READ);
 683                 buffer_put_int(&msg, id);
 684                 buffer_put_string(&msg, handle, handle_len);
 685                 buffer_put_int64(&msg, offset);
 686                 buffer_put_int(&msg, COPY_SIZE);
 687                 send_msg(fd_out, &msg);
 688                 debug3("Sent message SSH2_FXP_READ I:%d O:%llu S:%u",
 689                     id, (u_int64_t)offset, COPY_SIZE);
 690
 691                 buffer_clear(&msg);
 692
 693                 get_msg(fd_in, &msg);
 694                 type = buffer_get_char(&msg);
 695                 id = buffer_get_int(&msg);
 696                 debug3("Received reply T:%d I:%d", type, id);
 697                 if (id != expected_id)
 698                         fatal("ID mismatch (%d != %d)", id, expected_id);
 699                 if (type == SSH2_FXP_STATUS) {
 700                         status = buffer_get_int(&msg);
 701
 702                         if (status == SSH2_FX_EOF)
 703                                 break;
 704                         else {
 705                                 error("Couldn't read from remote "
 706                                     "file \"%s\" : %s", remote_path,
 707                                      fx2txt(status));
 708                                 do_close(fd_in, fd_out, handle, handle_len);
 709                                 goto done;
 710                         }
 711                 } else if (type != SSH2_FXP_DATA) {
 712                         fatal("Expected SSH2_FXP_DATA(%d) packet, got %d",
 713                             SSH2_FXP_DATA, type);
 714                 }
 715
 716                 data = buffer_get_string(&msg, &len);
 717                 if (len > COPY_SIZE)
 718                         fatal("Received more data than asked for %d > %d",
 719                             len, COPY_SIZE);
 720
 721                 debug3("In read loop, got %d offset %llu", len,
 722                     (u_int64_t)offset);
 723                 if (atomicio(write, local_fd, data, len) != len) {
 724                         error("Couldn't write to \"%s\": %s", local_path,
 725                             strerror(errno));
 726                         do_close(fd_in, fd_out, handle, handle_len);
 727                         status = -1;
 728                         xfree(data);
 729                         goto done;
 730                 }
 731
 732                 offset += len;
 733                 xfree(data);
 734         }
 735         status = do_close(fd_in, fd_out, handle, handle_len);
 736
 737         /* Override umask and utimes if asked */
 738 #ifdef HAVE_FCHMOD
 739         if (pflag && fchmod(local_fd, mode) == -1)
 740 #else
 741         if (pflag && chmod(local_path, mode) == -1)
 742 #endif /* HAVE_FCHMOD */
 743                 error("Couldn't set mode on \"%s\": %s", local_path,
 744                     strerror(errno));
 745         if (pflag && (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME)) {
 746                 struct timeval tv[2];
 747                 tv[0].tv_sec = a->atime;
 748                 tv[1].tv_sec = a->mtime;
 749                 tv[0].tv_usec = tv[1].tv_usec = 0;
 750                 if (utimes(local_path, tv) == -1)
 751                         error("Can't set times on \"%s\": %s", local_path,
 752                             strerror(errno));
 753         }
 754
 755 done:
 756         close(local_fd);
 757         buffer_free(&msg);
 758         xfree(handle);
 759         return status;
 760 }
 761
 762 int
 763 do_upload(int fd_in, int fd_out, char *local_path, char *remote_path,
 764     int pflag)
 765 {
 766         int local_fd;
 767         u_int handle_len, id;
 768         u_int64_t offset;
 769         char *handle;
 770         Buffer msg;
 771         struct stat sb;
 772         Attrib a;
 773         int status;
 774
 775         if ((local_fd = open(local_path, O_RDONLY, 0)) == -1) {
 776                 error("Couldn't open local file \"%s\" for reading: %s",
 777                     local_path, strerror(errno));
 778                 return(-1);
 779         }
 780         if (fstat(local_fd, &sb) == -1) {
 781                 error("Couldn't fstat local file \"%s\": %s",
 782                     local_path, strerror(errno));
 783                 close(local_fd);
 784                 return(-1);
 785         }
 786         stat_to_attrib(&sb, &a);
 787
 788         a.flags &= ~SSH2_FILEXFER_ATTR_SIZE;
 789         a.flags &= ~SSH2_FILEXFER_ATTR_UIDGID;
 790         a.perm &= 0777;
 791         if (!pflag)
 792                 a.flags &= ~SSH2_FILEXFER_ATTR_ACMODTIME;
 793
 794         buffer_init(&msg);
 795
 796         /* Send open request */
 797         id = msg_id++;
 798         buffer_put_char(&msg, SSH2_FXP_OPEN);
 799         buffer_put_int(&msg, id);
 800         buffer_put_cstring(&msg, remote_path);
 801         buffer_put_int(&msg, SSH2_FXF_WRITE|SSH2_FXF_CREAT|SSH2_FXF_TRUNC);
 802         encode_attrib(&msg, &a);
 803         send_msg(fd_out, &msg);
 804         debug3("Sent message SSH2_FXP_OPEN I:%d P:%s", id, remote_path);
 805
 806         buffer_clear(&msg);
 807
 808         handle = get_handle(fd_in, id, &handle_len);
 809         if (handle == NULL) {
 810                 close(local_fd);
 811                 buffer_free(&msg);
 812                 return(-1);
 813         }
 814
 815         /* Read from local and write to remote */
 816         offset = 0;
 817         for(;;) {
 818                 int len;
 819                 char data[COPY_SIZE];
 820
 821                 /*
 822                  * Can't use atomicio here because it returns 0 on EOF, thus losing
 823                  * the last block of the file
 824                  */
 825                 do
 826                         len = read(local_fd, data, COPY_SIZE);
 827                 while ((len == -1) && (errno == EINTR || errno == EAGAIN));
 828
 829                 if (len == -1)
 830                         fatal("Couldn't read from \"%s\": %s", local_path,
 831                             strerror(errno));
 832                 if (len == 0)
 833                         break;
 834
 835                 buffer_clear(&msg);
 836                 buffer_put_char(&msg, SSH2_FXP_WRITE);
 837                 buffer_put_int(&msg, ++id);
 838                 buffer_put_string(&msg, handle, handle_len);
 839                 buffer_put_int64(&msg, offset);
 840                 buffer_put_string(&msg, data, len);
 841                 send_msg(fd_out, &msg);
 842                 debug3("Sent message SSH2_FXP_WRITE I:%d O:%llu S:%u",
 843                     id, (u_int64_t)offset, len);
 844
 845                 status = get_status(fd_in, id);
 846                 if (status != SSH2_FX_OK) {
 847                         error("Couldn't write to remote file \"%s\": %s",
 848                             remote_path, fx2txt(status));
 849                         do_close(fd_in, fd_out, handle, handle_len);
 850                         close(local_fd);
 851                         goto done;
 852                 }
 853                 debug3("In write loop, got %d offset %llu", len,
 854                     (u_int64_t)offset);
 855
 856                 offset += len;
 857         }
 858
 859         if (close(local_fd) == -1) {
 860                 error("Couldn't close local file \"%s\": %s", local_path,
 861                     strerror(errno));
 862                 do_close(fd_in, fd_out, handle, handle_len);
 863                 status = -1;
 864                 goto done;
 865         }
 866
 867         /* Override umask and utimes if asked */
 868         if (pflag)
 869                 do_fsetstat(fd_in, fd_out, handle, handle_len, &a);
 870
 871         status = do_close(fd_in, fd_out, handle, handle_len);
 872
 873 done:
 874         xfree(handle);
 875         buffer_free(&msg);
 876         return status;
 877 }