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