blob: afbd1e6f3784a224c1ce5fbdd7c8928c8a178731 [file] [log] [blame]
Damien Miller33804262001-02-04 23:20:18 +11001/*
Damien Miller4e60ed72004-02-17 17:07:59 +11002 * Copyright (c) 2001-2004 Damien Miller <djm@openbsd.org>
Damien Miller33804262001-02-04 23:20:18 +11003 *
Damien Miller4e60ed72004-02-17 17:07:59 +11004 * Permission to use, copy, modify, and distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
Damien Miller33804262001-02-04 23:20:18 +11007 *
Damien Miller4e60ed72004-02-17 17:07:59 +11008 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Damien Miller33804262001-02-04 23:20:18 +110015 */
16
17/* XXX: memleaks */
18/* XXX: signed vs unsigned */
Damien Miller3db5f532002-02-13 14:10:32 +110019/* XXX: remove all logging, only return status codes */
Damien Miller33804262001-02-04 23:20:18 +110020/* XXX: copy between two remote sites */
21
22#include "includes.h"
Darren Tucker40858532005-08-02 17:07:07 +100023RCSID("$OpenBSD: sftp-client.c,v 1.57 2005/07/27 10:39:03 dtucker Exp $");
Damien Miller16a13332002-02-13 14:03:56 +110024
Damien Miller9b481512002-09-12 10:43:29 +100025#include "openbsd-compat/sys-queue.h"
Damien Miller33804262001-02-04 23:20:18 +110026
Damien Miller33804262001-02-04 23:20:18 +110027#include "buffer.h"
28#include "bufaux.h"
29#include "getput.h"
30#include "xmalloc.h"
31#include "log.h"
32#include "atomicio.h"
Damien Miller62d57f62003-01-10 21:43:24 +110033#include "progressmeter.h"
Damien Miller33804262001-02-04 23:20:18 +110034
35#include "sftp.h"
36#include "sftp-common.h"
37#include "sftp-client.h"
38
Darren Tuckercdf547a2004-05-24 10:12:19 +100039extern volatile sig_atomic_t interrupted;
Damien Miller62d57f62003-01-10 21:43:24 +110040extern int showprogress;
41
Damien Miller16a13332002-02-13 14:03:56 +110042/* Minimum amount of data to read at at time */
43#define MIN_READ_SIZE 512
44
Damien Millera7f3aaa2003-01-10 21:43:58 +110045/* Maximum packet size */
46#define MAX_MSG_LENGTH (256 * 1024)
47
Damien Miller3db5f532002-02-13 14:10:32 +110048struct sftp_conn {
49 int fd_in;
50 int fd_out;
51 u_int transfer_buflen;
52 u_int num_requests;
53 u_int version;
54 u_int msg_id;
55};
Ben Lindstrom288cc392001-02-09 02:58:04 +000056
Ben Lindstrombba81212001-06-25 05:01:22 +000057static void
Damien Miller33804262001-02-04 23:20:18 +110058send_msg(int fd, Buffer *m)
59{
Damien Millera7f3aaa2003-01-10 21:43:58 +110060 u_char mlen[4];
Damien Miller33804262001-02-04 23:20:18 +110061
Damien Millera7f3aaa2003-01-10 21:43:58 +110062 if (buffer_len(m) > MAX_MSG_LENGTH)
63 fatal("Outbound message too long %u", buffer_len(m));
Damien Miller33804262001-02-04 23:20:18 +110064
Damien Millera7f3aaa2003-01-10 21:43:58 +110065 /* Send length first */
66 PUT_32BIT(mlen, buffer_len(m));
Damien Millerb253cc42005-05-26 12:23:44 +100067 if (atomicio(vwrite, fd, mlen, sizeof(mlen)) != sizeof(mlen))
Damien Miller33804262001-02-04 23:20:18 +110068 fatal("Couldn't send packet: %s", strerror(errno));
69
Damien Millerb253cc42005-05-26 12:23:44 +100070 if (atomicio(vwrite, fd, buffer_ptr(m), buffer_len(m)) != buffer_len(m))
Damien Millera7f3aaa2003-01-10 21:43:58 +110071 fatal("Couldn't send packet: %s", strerror(errno));
72
73 buffer_clear(m);
Damien Miller33804262001-02-04 23:20:18 +110074}
75
Ben Lindstrombba81212001-06-25 05:01:22 +000076static void
Damien Miller33804262001-02-04 23:20:18 +110077get_msg(int fd, Buffer *m)
78{
Damien Millera7f3aaa2003-01-10 21:43:58 +110079 u_int msg_len;
Damien Miller33804262001-02-04 23:20:18 +110080
Damien Millera7f3aaa2003-01-10 21:43:58 +110081 buffer_append_space(m, 4);
Damien Millerb253cc42005-05-26 12:23:44 +100082 if (atomicio(read, fd, buffer_ptr(m), 4) != 4) {
83 if (errno == EPIPE)
84 fatal("Connection closed");
85 else
86 fatal("Couldn't read packet: %s", strerror(errno));
87 }
Damien Miller33804262001-02-04 23:20:18 +110088
Damien Millera7f3aaa2003-01-10 21:43:58 +110089 msg_len = buffer_get_int(m);
90 if (msg_len > MAX_MSG_LENGTH)
Ben Lindstromb1f483f2002-06-23 21:27:18 +000091 fatal("Received message too long %u", msg_len);
Damien Miller33804262001-02-04 23:20:18 +110092
Damien Millera7f3aaa2003-01-10 21:43:58 +110093 buffer_append_space(m, msg_len);
Damien Millerb253cc42005-05-26 12:23:44 +100094 if (atomicio(read, fd, buffer_ptr(m), msg_len) != msg_len) {
95 if (errno == EPIPE)
96 fatal("Connection closed");
97 else
98 fatal("Read packet: %s", strerror(errno));
99 }
Damien Miller33804262001-02-04 23:20:18 +1100100}
101
Ben Lindstrombba81212001-06-25 05:01:22 +0000102static void
Damien Miller33804262001-02-04 23:20:18 +1100103send_string_request(int fd, u_int id, u_int code, char *s,
104 u_int len)
105{
106 Buffer msg;
107
108 buffer_init(&msg);
109 buffer_put_char(&msg, code);
110 buffer_put_int(&msg, id);
111 buffer_put_string(&msg, s, len);
112 send_msg(fd, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000113 debug3("Sent message fd %d T:%u I:%u", fd, code, id);
Damien Miller33804262001-02-04 23:20:18 +1100114 buffer_free(&msg);
115}
116
Ben Lindstrombba81212001-06-25 05:01:22 +0000117static void
Damien Miller33804262001-02-04 23:20:18 +1100118send_string_attrs_request(int fd, u_int id, u_int code, char *s,
119 u_int len, Attrib *a)
120{
121 Buffer msg;
122
123 buffer_init(&msg);
124 buffer_put_char(&msg, code);
125 buffer_put_int(&msg, id);
126 buffer_put_string(&msg, s, len);
127 encode_attrib(&msg, a);
128 send_msg(fd, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000129 debug3("Sent message fd %d T:%u I:%u", fd, code, id);
Damien Miller33804262001-02-04 23:20:18 +1100130 buffer_free(&msg);
131}
132
Ben Lindstrombba81212001-06-25 05:01:22 +0000133static u_int
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000134get_status(int fd, u_int expected_id)
Damien Miller33804262001-02-04 23:20:18 +1100135{
136 Buffer msg;
137 u_int type, id, status;
138
139 buffer_init(&msg);
140 get_msg(fd, &msg);
141 type = buffer_get_char(&msg);
142 id = buffer_get_int(&msg);
143
144 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000145 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100146 if (type != SSH2_FXP_STATUS)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000147 fatal("Expected SSH2_FXP_STATUS(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100148 SSH2_FXP_STATUS, type);
149
150 status = buffer_get_int(&msg);
151 buffer_free(&msg);
152
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000153 debug3("SSH2_FXP_STATUS %u", status);
Damien Miller33804262001-02-04 23:20:18 +1100154
155 return(status);
156}
157
Ben Lindstrombba81212001-06-25 05:01:22 +0000158static char *
Damien Miller33804262001-02-04 23:20:18 +1100159get_handle(int fd, u_int expected_id, u_int *len)
160{
161 Buffer msg;
162 u_int type, id;
163 char *handle;
164
165 buffer_init(&msg);
166 get_msg(fd, &msg);
167 type = buffer_get_char(&msg);
168 id = buffer_get_int(&msg);
169
170 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000171 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100172 if (type == SSH2_FXP_STATUS) {
173 int status = buffer_get_int(&msg);
174
175 error("Couldn't get handle: %s", fx2txt(status));
Darren Tuckercd516ef2004-12-06 22:43:43 +1100176 buffer_free(&msg);
Damien Miller33804262001-02-04 23:20:18 +1100177 return(NULL);
178 } else if (type != SSH2_FXP_HANDLE)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000179 fatal("Expected SSH2_FXP_HANDLE(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100180 SSH2_FXP_HANDLE, type);
181
182 handle = buffer_get_string(&msg, len);
183 buffer_free(&msg);
184
185 return(handle);
186}
187
Ben Lindstrombba81212001-06-25 05:01:22 +0000188static Attrib *
Ben Lindstromc8d1c302001-03-17 00:34:46 +0000189get_decode_stat(int fd, u_int expected_id, int quiet)
Damien Miller33804262001-02-04 23:20:18 +1100190{
191 Buffer msg;
192 u_int type, id;
193 Attrib *a;
194
195 buffer_init(&msg);
196 get_msg(fd, &msg);
197
198 type = buffer_get_char(&msg);
199 id = buffer_get_int(&msg);
200
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000201 debug3("Received stat reply T:%u I:%u", type, id);
Damien Miller33804262001-02-04 23:20:18 +1100202 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000203 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100204 if (type == SSH2_FXP_STATUS) {
205 int status = buffer_get_int(&msg);
206
Ben Lindstromc8d1c302001-03-17 00:34:46 +0000207 if (quiet)
208 debug("Couldn't stat remote file: %s", fx2txt(status));
209 else
210 error("Couldn't stat remote file: %s", fx2txt(status));
Darren Tuckercd516ef2004-12-06 22:43:43 +1100211 buffer_free(&msg);
Damien Miller33804262001-02-04 23:20:18 +1100212 return(NULL);
213 } else if (type != SSH2_FXP_ATTRS) {
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000214 fatal("Expected SSH2_FXP_ATTRS(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100215 SSH2_FXP_ATTRS, type);
216 }
217 a = decode_attrib(&msg);
218 buffer_free(&msg);
219
220 return(a);
221}
222
Damien Miller3db5f532002-02-13 14:10:32 +1100223struct sftp_conn *
224do_init(int fd_in, int fd_out, u_int transfer_buflen, u_int num_requests)
Damien Miller33804262001-02-04 23:20:18 +1100225{
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000226 u_int type;
227 int version;
Damien Miller33804262001-02-04 23:20:18 +1100228 Buffer msg;
Damien Miller3db5f532002-02-13 14:10:32 +1100229 struct sftp_conn *ret;
Damien Miller33804262001-02-04 23:20:18 +1100230
231 buffer_init(&msg);
232 buffer_put_char(&msg, SSH2_FXP_INIT);
233 buffer_put_int(&msg, SSH2_FILEXFER_VERSION);
234 send_msg(fd_out, &msg);
235
236 buffer_clear(&msg);
237
238 get_msg(fd_in, &msg);
239
Kevin Stevesef4eea92001-02-05 12:42:17 +0000240 /* Expecting a VERSION reply */
Damien Miller33804262001-02-04 23:20:18 +1100241 if ((type = buffer_get_char(&msg)) != SSH2_FXP_VERSION) {
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000242 error("Invalid packet back from SSH2_FXP_INIT (type %u)",
Damien Miller33804262001-02-04 23:20:18 +1100243 type);
244 buffer_free(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +1100245 return(NULL);
Damien Miller33804262001-02-04 23:20:18 +1100246 }
247 version = buffer_get_int(&msg);
248
249 debug2("Remote version: %d", version);
250
251 /* Check for extensions */
252 while (buffer_len(&msg) > 0) {
253 char *name = buffer_get_string(&msg, NULL);
254 char *value = buffer_get_string(&msg, NULL);
255
256 debug2("Init extension: \"%s\"", name);
257 xfree(name);
258 xfree(value);
259 }
260
261 buffer_free(&msg);
Damien Miller058316f2001-03-08 10:08:49 +1100262
Damien Miller3db5f532002-02-13 14:10:32 +1100263 ret = xmalloc(sizeof(*ret));
264 ret->fd_in = fd_in;
265 ret->fd_out = fd_out;
266 ret->transfer_buflen = transfer_buflen;
267 ret->num_requests = num_requests;
268 ret->version = version;
269 ret->msg_id = 1;
270
271 /* Some filexfer v.0 servers don't support large packets */
272 if (version == 0)
Ben Lindstroma1d81142002-04-02 20:58:11 +0000273 ret->transfer_buflen = MIN(ret->transfer_buflen, 20480);
Damien Miller3db5f532002-02-13 14:10:32 +1100274
275 return(ret);
276}
277
278u_int
279sftp_proto_version(struct sftp_conn *conn)
280{
281 return(conn->version);
Damien Miller33804262001-02-04 23:20:18 +1100282}
283
284int
Damien Miller3db5f532002-02-13 14:10:32 +1100285do_close(struct sftp_conn *conn, char *handle, u_int handle_len)
Damien Miller33804262001-02-04 23:20:18 +1100286{
287 u_int id, status;
288 Buffer msg;
289
290 buffer_init(&msg);
291
Damien Miller3db5f532002-02-13 14:10:32 +1100292 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100293 buffer_put_char(&msg, SSH2_FXP_CLOSE);
294 buffer_put_int(&msg, id);
295 buffer_put_string(&msg, handle, handle_len);
Damien Miller3db5f532002-02-13 14:10:32 +1100296 send_msg(conn->fd_out, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000297 debug3("Sent message SSH2_FXP_CLOSE I:%u", id);
Damien Miller33804262001-02-04 23:20:18 +1100298
Damien Miller3db5f532002-02-13 14:10:32 +1100299 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100300 if (status != SSH2_FX_OK)
301 error("Couldn't close file: %s", fx2txt(status));
302
303 buffer_free(&msg);
304
305 return(status);
306}
307
Damien Miller4870afd2001-03-14 10:27:09 +1100308
Ben Lindstrombba81212001-06-25 05:01:22 +0000309static int
Damien Miller3db5f532002-02-13 14:10:32 +1100310do_lsreaddir(struct sftp_conn *conn, char *path, int printflag,
Damien Miller4870afd2001-03-14 10:27:09 +1100311 SFTP_DIRENT ***dir)
Damien Miller33804262001-02-04 23:20:18 +1100312{
313 Buffer msg;
Damien Millereccb9de2005-06-17 12:59:34 +1000314 u_int count, type, id, handle_len, i, expected_id, ents = 0;
Damien Miller33804262001-02-04 23:20:18 +1100315 char *handle;
316
Damien Miller3db5f532002-02-13 14:10:32 +1100317 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100318
319 buffer_init(&msg);
320 buffer_put_char(&msg, SSH2_FXP_OPENDIR);
321 buffer_put_int(&msg, id);
322 buffer_put_cstring(&msg, path);
Damien Miller3db5f532002-02-13 14:10:32 +1100323 send_msg(conn->fd_out, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100324
325 buffer_clear(&msg);
326
Damien Miller3db5f532002-02-13 14:10:32 +1100327 handle = get_handle(conn->fd_in, id, &handle_len);
Damien Miller33804262001-02-04 23:20:18 +1100328 if (handle == NULL)
329 return(-1);
330
Damien Miller4870afd2001-03-14 10:27:09 +1100331 if (dir) {
332 ents = 0;
333 *dir = xmalloc(sizeof(**dir));
334 (*dir)[0] = NULL;
335 }
Damien Miller4870afd2001-03-14 10:27:09 +1100336
Darren Tuckercdf547a2004-05-24 10:12:19 +1000337 for (; !interrupted;) {
Damien Miller3db5f532002-02-13 14:10:32 +1100338 id = expected_id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100339
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000340 debug3("Sending SSH2_FXP_READDIR I:%u", id);
Damien Miller33804262001-02-04 23:20:18 +1100341
342 buffer_clear(&msg);
343 buffer_put_char(&msg, SSH2_FXP_READDIR);
344 buffer_put_int(&msg, id);
345 buffer_put_string(&msg, handle, handle_len);
Damien Miller3db5f532002-02-13 14:10:32 +1100346 send_msg(conn->fd_out, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100347
348 buffer_clear(&msg);
349
Damien Miller3db5f532002-02-13 14:10:32 +1100350 get_msg(conn->fd_in, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100351
352 type = buffer_get_char(&msg);
353 id = buffer_get_int(&msg);
354
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000355 debug3("Received reply T:%u I:%u", type, id);
Damien Miller33804262001-02-04 23:20:18 +1100356
357 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000358 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100359
360 if (type == SSH2_FXP_STATUS) {
361 int status = buffer_get_int(&msg);
362
363 debug3("Received SSH2_FXP_STATUS %d", status);
364
365 if (status == SSH2_FX_EOF) {
366 break;
367 } else {
368 error("Couldn't read directory: %s",
369 fx2txt(status));
Damien Miller3db5f532002-02-13 14:10:32 +1100370 do_close(conn, handle, handle_len);
Damien Miller00111382003-03-10 11:21:17 +1100371 xfree(handle);
Ben Lindstrom10ac33f2001-02-10 21:53:40 +0000372 return(status);
Damien Miller33804262001-02-04 23:20:18 +1100373 }
374 } else if (type != SSH2_FXP_NAME)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000375 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100376 SSH2_FXP_NAME, type);
377
378 count = buffer_get_int(&msg);
Damien Millerd7686fd2001-02-10 00:40:03 +1100379 if (count == 0)
380 break;
381 debug3("Received %d SSH2_FXP_NAME responses", count);
Damien Miller9f0f5c62001-12-21 14:45:46 +1100382 for (i = 0; i < count; i++) {
Damien Miller33804262001-02-04 23:20:18 +1100383 char *filename, *longname;
384 Attrib *a;
385
386 filename = buffer_get_string(&msg, NULL);
387 longname = buffer_get_string(&msg, NULL);
388 a = decode_attrib(&msg);
389
Damien Miller4870afd2001-03-14 10:27:09 +1100390 if (printflag)
391 printf("%s\n", longname);
392
393 if (dir) {
Ben Lindstroma3700052001-04-05 23:26:32 +0000394 *dir = xrealloc(*dir, sizeof(**dir) *
Damien Miller4870afd2001-03-14 10:27:09 +1100395 (ents + 2));
396 (*dir)[ents] = xmalloc(sizeof(***dir));
397 (*dir)[ents]->filename = xstrdup(filename);
398 (*dir)[ents]->longname = xstrdup(longname);
399 memcpy(&(*dir)[ents]->a, a, sizeof(*a));
400 (*dir)[++ents] = NULL;
401 }
Damien Miller33804262001-02-04 23:20:18 +1100402
403 xfree(filename);
404 xfree(longname);
405 }
406 }
407
408 buffer_free(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +1100409 do_close(conn, handle, handle_len);
Damien Miller33804262001-02-04 23:20:18 +1100410 xfree(handle);
411
Darren Tuckercdf547a2004-05-24 10:12:19 +1000412 /* Don't return partial matches on interrupt */
413 if (interrupted && dir != NULL && *dir != NULL) {
414 free_sftp_dirents(*dir);
415 *dir = xmalloc(sizeof(**dir));
416 **dir = NULL;
417 }
418
Damien Miller33804262001-02-04 23:20:18 +1100419 return(0);
420}
421
422int
Damien Miller3db5f532002-02-13 14:10:32 +1100423do_readdir(struct sftp_conn *conn, char *path, SFTP_DIRENT ***dir)
Damien Miller4870afd2001-03-14 10:27:09 +1100424{
Damien Miller3db5f532002-02-13 14:10:32 +1100425 return(do_lsreaddir(conn, path, 0, dir));
Damien Miller4870afd2001-03-14 10:27:09 +1100426}
427
428void free_sftp_dirents(SFTP_DIRENT **s)
429{
430 int i;
Damien Miller9f0f5c62001-12-21 14:45:46 +1100431
432 for (i = 0; s[i]; i++) {
Damien Miller4870afd2001-03-14 10:27:09 +1100433 xfree(s[i]->filename);
434 xfree(s[i]->longname);
435 xfree(s[i]);
436 }
437 xfree(s);
438}
439
440int
Damien Miller3db5f532002-02-13 14:10:32 +1100441do_rm(struct sftp_conn *conn, char *path)
Damien Miller33804262001-02-04 23:20:18 +1100442{
443 u_int status, id;
444
445 debug2("Sending SSH2_FXP_REMOVE \"%s\"", path);
446
Damien Miller3db5f532002-02-13 14:10:32 +1100447 id = conn->msg_id++;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000448 send_string_request(conn->fd_out, id, SSH2_FXP_REMOVE, path,
Damien Miller3db5f532002-02-13 14:10:32 +1100449 strlen(path));
450 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100451 if (status != SSH2_FX_OK)
452 error("Couldn't delete file: %s", fx2txt(status));
453 return(status);
454}
455
456int
Damien Miller3db5f532002-02-13 14:10:32 +1100457do_mkdir(struct sftp_conn *conn, char *path, Attrib *a)
Damien Miller33804262001-02-04 23:20:18 +1100458{
459 u_int status, id;
460
Damien Miller3db5f532002-02-13 14:10:32 +1100461 id = conn->msg_id++;
462 send_string_attrs_request(conn->fd_out, id, SSH2_FXP_MKDIR, path,
Damien Miller33804262001-02-04 23:20:18 +1100463 strlen(path), a);
464
Damien Miller3db5f532002-02-13 14:10:32 +1100465 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100466 if (status != SSH2_FX_OK)
467 error("Couldn't create directory: %s", fx2txt(status));
468
469 return(status);
470}
471
472int
Damien Miller3db5f532002-02-13 14:10:32 +1100473do_rmdir(struct sftp_conn *conn, char *path)
Damien Miller33804262001-02-04 23:20:18 +1100474{
475 u_int status, id;
476
Damien Miller3db5f532002-02-13 14:10:32 +1100477 id = conn->msg_id++;
478 send_string_request(conn->fd_out, id, SSH2_FXP_RMDIR, path,
479 strlen(path));
Damien Miller33804262001-02-04 23:20:18 +1100480
Damien Miller3db5f532002-02-13 14:10:32 +1100481 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100482 if (status != SSH2_FX_OK)
483 error("Couldn't remove directory: %s", fx2txt(status));
484
485 return(status);
486}
487
488Attrib *
Damien Miller3db5f532002-02-13 14:10:32 +1100489do_stat(struct sftp_conn *conn, char *path, int quiet)
Damien Miller33804262001-02-04 23:20:18 +1100490{
491 u_int id;
492
Damien Miller3db5f532002-02-13 14:10:32 +1100493 id = conn->msg_id++;
494
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000495 send_string_request(conn->fd_out, id,
496 conn->version == 0 ? SSH2_FXP_STAT_VERSION_0 : SSH2_FXP_STAT,
Damien Miller3db5f532002-02-13 14:10:32 +1100497 path, strlen(path));
498
499 return(get_decode_stat(conn->fd_in, id, quiet));
Damien Miller33804262001-02-04 23:20:18 +1100500}
501
502Attrib *
Damien Miller3db5f532002-02-13 14:10:32 +1100503do_lstat(struct sftp_conn *conn, char *path, int quiet)
Damien Miller33804262001-02-04 23:20:18 +1100504{
505 u_int id;
506
Damien Miller3db5f532002-02-13 14:10:32 +1100507 if (conn->version == 0) {
508 if (quiet)
509 debug("Server version does not support lstat operation");
510 else
Damien Miller996acd22003-04-09 20:59:48 +1000511 logit("Server version does not support lstat operation");
Ben Lindstromf26ff5b2002-04-02 21:00:31 +0000512 return(do_stat(conn, path, quiet));
Damien Miller3db5f532002-02-13 14:10:32 +1100513 }
514
515 id = conn->msg_id++;
516 send_string_request(conn->fd_out, id, SSH2_FXP_LSTAT, path,
517 strlen(path));
518
519 return(get_decode_stat(conn->fd_in, id, quiet));
Damien Miller33804262001-02-04 23:20:18 +1100520}
521
522Attrib *
Damien Miller3db5f532002-02-13 14:10:32 +1100523do_fstat(struct sftp_conn *conn, char *handle, u_int handle_len, int quiet)
Damien Miller33804262001-02-04 23:20:18 +1100524{
525 u_int id;
526
Damien Miller3db5f532002-02-13 14:10:32 +1100527 id = conn->msg_id++;
528 send_string_request(conn->fd_out, id, SSH2_FXP_FSTAT, handle,
529 handle_len);
530
531 return(get_decode_stat(conn->fd_in, id, quiet));
Damien Miller33804262001-02-04 23:20:18 +1100532}
533
534int
Damien Miller3db5f532002-02-13 14:10:32 +1100535do_setstat(struct sftp_conn *conn, char *path, Attrib *a)
Damien Miller33804262001-02-04 23:20:18 +1100536{
537 u_int status, id;
538
Damien Miller3db5f532002-02-13 14:10:32 +1100539 id = conn->msg_id++;
540 send_string_attrs_request(conn->fd_out, id, SSH2_FXP_SETSTAT, path,
Damien Miller33804262001-02-04 23:20:18 +1100541 strlen(path), a);
542
Damien Miller3db5f532002-02-13 14:10:32 +1100543 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100544 if (status != SSH2_FX_OK)
545 error("Couldn't setstat on \"%s\": %s", path,
546 fx2txt(status));
547
548 return(status);
549}
550
551int
Damien Miller3db5f532002-02-13 14:10:32 +1100552do_fsetstat(struct sftp_conn *conn, char *handle, u_int handle_len,
Damien Miller33804262001-02-04 23:20:18 +1100553 Attrib *a)
554{
555 u_int status, id;
556
Damien Miller3db5f532002-02-13 14:10:32 +1100557 id = conn->msg_id++;
558 send_string_attrs_request(conn->fd_out, id, SSH2_FXP_FSETSTAT, handle,
Damien Miller33804262001-02-04 23:20:18 +1100559 handle_len, a);
560
Damien Miller3db5f532002-02-13 14:10:32 +1100561 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100562 if (status != SSH2_FX_OK)
563 error("Couldn't fsetstat: %s", fx2txt(status));
564
565 return(status);
566}
567
568char *
Damien Miller3db5f532002-02-13 14:10:32 +1100569do_realpath(struct sftp_conn *conn, char *path)
Damien Miller33804262001-02-04 23:20:18 +1100570{
571 Buffer msg;
572 u_int type, expected_id, count, id;
573 char *filename, *longname;
574 Attrib *a;
575
Damien Miller3db5f532002-02-13 14:10:32 +1100576 expected_id = id = conn->msg_id++;
577 send_string_request(conn->fd_out, id, SSH2_FXP_REALPATH, path,
578 strlen(path));
Damien Miller33804262001-02-04 23:20:18 +1100579
580 buffer_init(&msg);
581
Damien Miller3db5f532002-02-13 14:10:32 +1100582 get_msg(conn->fd_in, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100583 type = buffer_get_char(&msg);
584 id = buffer_get_int(&msg);
585
586 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000587 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100588
589 if (type == SSH2_FXP_STATUS) {
590 u_int status = buffer_get_int(&msg);
591
592 error("Couldn't canonicalise: %s", fx2txt(status));
593 return(NULL);
594 } else if (type != SSH2_FXP_NAME)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000595 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100596 SSH2_FXP_NAME, type);
597
598 count = buffer_get_int(&msg);
599 if (count != 1)
600 fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count);
601
602 filename = buffer_get_string(&msg, NULL);
603 longname = buffer_get_string(&msg, NULL);
604 a = decode_attrib(&msg);
605
606 debug3("SSH_FXP_REALPATH %s -> %s", path, filename);
607
608 xfree(longname);
609
610 buffer_free(&msg);
611
612 return(filename);
613}
614
615int
Damien Miller3db5f532002-02-13 14:10:32 +1100616do_rename(struct sftp_conn *conn, char *oldpath, char *newpath)
Damien Miller33804262001-02-04 23:20:18 +1100617{
618 Buffer msg;
619 u_int status, id;
620
621 buffer_init(&msg);
622
623 /* Send rename request */
Damien Miller3db5f532002-02-13 14:10:32 +1100624 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100625 buffer_put_char(&msg, SSH2_FXP_RENAME);
626 buffer_put_int(&msg, id);
627 buffer_put_cstring(&msg, oldpath);
628 buffer_put_cstring(&msg, newpath);
Damien Miller3db5f532002-02-13 14:10:32 +1100629 send_msg(conn->fd_out, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100630 debug3("Sent message SSH2_FXP_RENAME \"%s\" -> \"%s\"", oldpath,
631 newpath);
632 buffer_free(&msg);
633
Damien Miller3db5f532002-02-13 14:10:32 +1100634 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100635 if (status != SSH2_FX_OK)
Damien Miller3db5f532002-02-13 14:10:32 +1100636 error("Couldn't rename file \"%s\" to \"%s\": %s", oldpath,
637 newpath, fx2txt(status));
Damien Miller33804262001-02-04 23:20:18 +1100638
639 return(status);
640}
641
642int
Damien Miller3db5f532002-02-13 14:10:32 +1100643do_symlink(struct sftp_conn *conn, char *oldpath, char *newpath)
Damien Miller058316f2001-03-08 10:08:49 +1100644{
645 Buffer msg;
646 u_int status, id;
647
Damien Miller3db5f532002-02-13 14:10:32 +1100648 if (conn->version < 3) {
649 error("This server does not support the symlink operation");
650 return(SSH2_FX_OP_UNSUPPORTED);
651 }
652
Damien Miller058316f2001-03-08 10:08:49 +1100653 buffer_init(&msg);
654
Darren Tuckerdca6a4d2004-04-19 22:10:52 +1000655 /* Send symlink request */
Damien Miller3db5f532002-02-13 14:10:32 +1100656 id = conn->msg_id++;
Damien Miller058316f2001-03-08 10:08:49 +1100657 buffer_put_char(&msg, SSH2_FXP_SYMLINK);
658 buffer_put_int(&msg, id);
659 buffer_put_cstring(&msg, oldpath);
660 buffer_put_cstring(&msg, newpath);
Damien Miller3db5f532002-02-13 14:10:32 +1100661 send_msg(conn->fd_out, &msg);
Damien Miller058316f2001-03-08 10:08:49 +1100662 debug3("Sent message SSH2_FXP_SYMLINK \"%s\" -> \"%s\"", oldpath,
663 newpath);
664 buffer_free(&msg);
665
Damien Miller3db5f532002-02-13 14:10:32 +1100666 status = get_status(conn->fd_in, id);
Damien Miller058316f2001-03-08 10:08:49 +1100667 if (status != SSH2_FX_OK)
Ben Lindstrom8e879cf2002-11-09 15:48:49 +0000668 error("Couldn't symlink file \"%s\" to \"%s\": %s", oldpath,
Damien Miller3db5f532002-02-13 14:10:32 +1100669 newpath, fx2txt(status));
Damien Miller058316f2001-03-08 10:08:49 +1100670
671 return(status);
672}
673
674char *
Damien Miller3db5f532002-02-13 14:10:32 +1100675do_readlink(struct sftp_conn *conn, char *path)
Damien Miller058316f2001-03-08 10:08:49 +1100676{
677 Buffer msg;
678 u_int type, expected_id, count, id;
679 char *filename, *longname;
680 Attrib *a;
681
Damien Miller3db5f532002-02-13 14:10:32 +1100682 expected_id = id = conn->msg_id++;
683 send_string_request(conn->fd_out, id, SSH2_FXP_READLINK, path,
684 strlen(path));
Damien Miller058316f2001-03-08 10:08:49 +1100685
686 buffer_init(&msg);
687
Damien Miller3db5f532002-02-13 14:10:32 +1100688 get_msg(conn->fd_in, &msg);
Damien Miller058316f2001-03-08 10:08:49 +1100689 type = buffer_get_char(&msg);
690 id = buffer_get_int(&msg);
691
692 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000693 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller058316f2001-03-08 10:08:49 +1100694
695 if (type == SSH2_FXP_STATUS) {
696 u_int status = buffer_get_int(&msg);
697
698 error("Couldn't readlink: %s", fx2txt(status));
699 return(NULL);
700 } else if (type != SSH2_FXP_NAME)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000701 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u",
Damien Miller058316f2001-03-08 10:08:49 +1100702 SSH2_FXP_NAME, type);
703
704 count = buffer_get_int(&msg);
705 if (count != 1)
706 fatal("Got multiple names (%d) from SSH_FXP_READLINK", count);
707
708 filename = buffer_get_string(&msg, NULL);
709 longname = buffer_get_string(&msg, NULL);
710 a = decode_attrib(&msg);
711
712 debug3("SSH_FXP_READLINK %s -> %s", path, filename);
713
714 xfree(longname);
715
716 buffer_free(&msg);
717
718 return(filename);
719}
720
Damien Miller16a13332002-02-13 14:03:56 +1100721static void
722send_read_request(int fd_out, u_int id, u_int64_t offset, u_int len,
723 char *handle, u_int handle_len)
724{
725 Buffer msg;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000726
Damien Miller16a13332002-02-13 14:03:56 +1100727 buffer_init(&msg);
728 buffer_clear(&msg);
729 buffer_put_char(&msg, SSH2_FXP_READ);
730 buffer_put_int(&msg, id);
731 buffer_put_string(&msg, handle, handle_len);
732 buffer_put_int64(&msg, offset);
733 buffer_put_int(&msg, len);
734 send_msg(fd_out, &msg);
735 buffer_free(&msg);
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000736}
Damien Miller16a13332002-02-13 14:03:56 +1100737
Damien Miller058316f2001-03-08 10:08:49 +1100738int
Damien Miller3db5f532002-02-13 14:10:32 +1100739do_download(struct sftp_conn *conn, char *remote_path, char *local_path,
740 int pflag)
Damien Miller33804262001-02-04 23:20:18 +1100741{
Damien Miller33804262001-02-04 23:20:18 +1100742 Attrib junk, *a;
Damien Miller16a13332002-02-13 14:03:56 +1100743 Buffer msg;
744 char *handle;
Darren Tucker40858532005-08-02 17:07:07 +1000745 int local_fd, status = 0, write_error;
Damien Miller16a13332002-02-13 14:03:56 +1100746 int read_error, write_errno;
747 u_int64_t offset, size;
Damien Millereccb9de2005-06-17 12:59:34 +1000748 u_int handle_len, mode, type, id, buflen, num_req, max_req;
Damien Miller62d57f62003-01-10 21:43:24 +1100749 off_t progress_counter;
Damien Miller16a13332002-02-13 14:03:56 +1100750 struct request {
751 u_int id;
752 u_int len;
753 u_int64_t offset;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000754 TAILQ_ENTRY(request) tq;
Damien Miller16a13332002-02-13 14:03:56 +1100755 };
756 TAILQ_HEAD(reqhead, request) requests;
757 struct request *req;
758
759 TAILQ_INIT(&requests);
Damien Miller33804262001-02-04 23:20:18 +1100760
Damien Miller3db5f532002-02-13 14:10:32 +1100761 a = do_stat(conn, remote_path, 0);
Damien Miller33804262001-02-04 23:20:18 +1100762 if (a == NULL)
763 return(-1);
764
765 /* XXX: should we preserve set[ug]id? */
766 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS)
Damien Miller770b3742003-01-08 14:04:53 +1100767 mode = a->perm & 0777;
Damien Miller33804262001-02-04 23:20:18 +1100768 else
769 mode = 0666;
770
Ben Lindstromc8d1c302001-03-17 00:34:46 +0000771 if ((a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) &&
Damien Miller5fa01fd2003-01-14 22:24:47 +1100772 (!S_ISREG(a->perm))) {
773 error("Cannot download non-regular file: %s", remote_path);
Ben Lindstromc8d1c302001-03-17 00:34:46 +0000774 return(-1);
775 }
776
Damien Miller16a13332002-02-13 14:03:56 +1100777 if (a->flags & SSH2_FILEXFER_ATTR_SIZE)
778 size = a->size;
779 else
780 size = 0;
781
Damien Miller3db5f532002-02-13 14:10:32 +1100782 buflen = conn->transfer_buflen;
Damien Miller33804262001-02-04 23:20:18 +1100783 buffer_init(&msg);
784
785 /* Send open request */
Damien Miller3db5f532002-02-13 14:10:32 +1100786 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100787 buffer_put_char(&msg, SSH2_FXP_OPEN);
788 buffer_put_int(&msg, id);
789 buffer_put_cstring(&msg, remote_path);
790 buffer_put_int(&msg, SSH2_FXF_READ);
791 attrib_clear(&junk); /* Send empty attributes */
792 encode_attrib(&msg, &junk);
Damien Miller3db5f532002-02-13 14:10:32 +1100793 send_msg(conn->fd_out, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000794 debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path);
Damien Miller33804262001-02-04 23:20:18 +1100795
Damien Miller3db5f532002-02-13 14:10:32 +1100796 handle = get_handle(conn->fd_in, id, &handle_len);
Damien Miller33804262001-02-04 23:20:18 +1100797 if (handle == NULL) {
798 buffer_free(&msg);
Damien Miller33804262001-02-04 23:20:18 +1100799 return(-1);
800 }
801
Damien Millera8e06ce2003-11-21 23:48:55 +1100802 local_fd = open(local_path, O_WRONLY | O_CREAT | O_TRUNC,
Damien Miller770b3742003-01-08 14:04:53 +1100803 mode | S_IWRITE);
Damien Miller3db5f532002-02-13 14:10:32 +1100804 if (local_fd == -1) {
805 error("Couldn't open local file \"%s\" for writing: %s",
806 local_path, strerror(errno));
Ben Lindstrom021fcd32002-02-26 18:02:43 +0000807 buffer_free(&msg);
808 xfree(handle);
Damien Miller3db5f532002-02-13 14:10:32 +1100809 return(-1);
810 }
811
Damien Miller33804262001-02-04 23:20:18 +1100812 /* Read from remote and write to local */
Damien Miller16a13332002-02-13 14:03:56 +1100813 write_error = read_error = write_errno = num_req = offset = 0;
814 max_req = 1;
Damien Miller62d57f62003-01-10 21:43:24 +1100815 progress_counter = 0;
816
Damien Miller9ba30692004-03-08 23:12:02 +1100817 if (showprogress && size != 0)
818 start_progress_meter(remote_path, size, &progress_counter);
Damien Miller62d57f62003-01-10 21:43:24 +1100819
Damien Miller16a13332002-02-13 14:03:56 +1100820 while (num_req > 0 || max_req > 0) {
Damien Miller33804262001-02-04 23:20:18 +1100821 char *data;
Damien Miller16a13332002-02-13 14:03:56 +1100822 u_int len;
Damien Miller33804262001-02-04 23:20:18 +1100823
Darren Tuckercdf547a2004-05-24 10:12:19 +1000824 /*
Darren Tuckerfc959702004-07-17 16:12:08 +1000825 * Simulate EOF on interrupt: stop sending new requests and
Darren Tuckercdf547a2004-05-24 10:12:19 +1000826 * allow outstanding requests to drain gracefully
827 */
828 if (interrupted) {
829 if (num_req == 0) /* If we haven't started yet... */
830 break;
831 max_req = 0;
832 }
833
Damien Miller16a13332002-02-13 14:03:56 +1100834 /* Send some more requests */
835 while (num_req < max_req) {
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000836 debug3("Request range %llu -> %llu (%d/%d)",
Ben Lindstromd45f28c2002-03-22 01:00:57 +0000837 (unsigned long long)offset,
838 (unsigned long long)offset + buflen - 1,
839 num_req, max_req);
Damien Miller16a13332002-02-13 14:03:56 +1100840 req = xmalloc(sizeof(*req));
Damien Miller3db5f532002-02-13 14:10:32 +1100841 req->id = conn->msg_id++;
Damien Miller16a13332002-02-13 14:03:56 +1100842 req->len = buflen;
843 req->offset = offset;
844 offset += buflen;
845 num_req++;
846 TAILQ_INSERT_TAIL(&requests, req, tq);
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000847 send_read_request(conn->fd_out, req->id, req->offset,
Damien Miller16a13332002-02-13 14:03:56 +1100848 req->len, handle, handle_len);
849 }
Damien Miller33804262001-02-04 23:20:18 +1100850
851 buffer_clear(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +1100852 get_msg(conn->fd_in, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100853 type = buffer_get_char(&msg);
854 id = buffer_get_int(&msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000855 debug3("Received reply T:%u I:%u R:%d", type, id, max_req);
Damien Miller33804262001-02-04 23:20:18 +1100856
Damien Miller16a13332002-02-13 14:03:56 +1100857 /* Find the request in our queue */
Darren Tucker47eede72005-03-14 23:08:12 +1100858 for (req = TAILQ_FIRST(&requests);
Damien Miller16a13332002-02-13 14:03:56 +1100859 req != NULL && req->id != id;
860 req = TAILQ_NEXT(req, tq))
861 ;
862 if (req == NULL)
863 fatal("Unexpected reply %u", id);
864
865 switch (type) {
866 case SSH2_FXP_STATUS:
867 status = buffer_get_int(&msg);
868 if (status != SSH2_FX_EOF)
869 read_error = 1;
870 max_req = 0;
871 TAILQ_REMOVE(&requests, req, tq);
872 xfree(req);
873 num_req--;
874 break;
875 case SSH2_FXP_DATA:
876 data = buffer_get_string(&msg, &len);
Ben Lindstromeb505452002-03-22 01:03:15 +0000877 debug3("Received data %llu -> %llu",
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000878 (unsigned long long)req->offset,
Ben Lindstromeb505452002-03-22 01:03:15 +0000879 (unsigned long long)req->offset + len - 1);
Damien Miller16a13332002-02-13 14:03:56 +1100880 if (len > req->len)
881 fatal("Received more data than asked for "
Ben Lindstrom93576d92002-12-23 02:06:19 +0000882 "%u > %u", len, req->len);
Damien Miller16a13332002-02-13 14:03:56 +1100883 if ((lseek(local_fd, req->offset, SEEK_SET) == -1 ||
Darren Tucker9f63f222003-07-03 13:46:56 +1000884 atomicio(vwrite, local_fd, data, len) != len) &&
Damien Miller16a13332002-02-13 14:03:56 +1100885 !write_error) {
886 write_errno = errno;
887 write_error = 1;
888 max_req = 0;
Damien Miller33804262001-02-04 23:20:18 +1100889 }
Damien Miller62d57f62003-01-10 21:43:24 +1100890 progress_counter += len;
Damien Miller16a13332002-02-13 14:03:56 +1100891 xfree(data);
892
893 if (len == req->len) {
894 TAILQ_REMOVE(&requests, req, tq);
895 xfree(req);
896 num_req--;
897 } else {
898 /* Resend the request for the missing data */
899 debug3("Short data block, re-requesting "
Ben Lindstromeb505452002-03-22 01:03:15 +0000900 "%llu -> %llu (%2d)",
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000901 (unsigned long long)req->offset + len,
Ben Lindstrom83b79e42002-03-22 01:05:27 +0000902 (unsigned long long)req->offset +
903 req->len - 1, num_req);
Damien Miller3db5f532002-02-13 14:10:32 +1100904 req->id = conn->msg_id++;
Damien Miller16a13332002-02-13 14:03:56 +1100905 req->len -= len;
906 req->offset += len;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000907 send_read_request(conn->fd_out, req->id,
Damien Miller3db5f532002-02-13 14:10:32 +1100908 req->offset, req->len, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +1100909 /* Reduce the request size */
910 if (len < buflen)
911 buflen = MAX(MIN_READ_SIZE, len);
912 }
913 if (max_req > 0) { /* max_req = 0 iff EOF received */
914 if (size > 0 && offset > size) {
915 /* Only one request at a time
916 * after the expected EOF */
917 debug3("Finish at %llu (%2d)",
Ben Lindstromeb505452002-03-22 01:03:15 +0000918 (unsigned long long)offset,
919 num_req);
Damien Miller16a13332002-02-13 14:03:56 +1100920 max_req = 1;
Darren Tuckercdf547a2004-05-24 10:12:19 +1000921 } else if (max_req <= conn->num_requests) {
Damien Miller16a13332002-02-13 14:03:56 +1100922 ++max_req;
923 }
924 }
925 break;
926 default:
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000927 fatal("Expected SSH2_FXP_DATA(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100928 SSH2_FXP_DATA, type);
929 }
Damien Miller33804262001-02-04 23:20:18 +1100930 }
Damien Miller33804262001-02-04 23:20:18 +1100931
Damien Miller62d57f62003-01-10 21:43:24 +1100932 if (showprogress && size)
933 stop_progress_meter();
934
Damien Miller16a13332002-02-13 14:03:56 +1100935 /* Sanity check */
936 if (TAILQ_FIRST(&requests) != NULL)
937 fatal("Transfer complete, but requests still in queue");
938
939 if (read_error) {
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000940 error("Couldn't read from remote file \"%s\" : %s",
Damien Miller3db5f532002-02-13 14:10:32 +1100941 remote_path, fx2txt(status));
942 do_close(conn, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +1100943 } else if (write_error) {
Damien Miller3db5f532002-02-13 14:10:32 +1100944 error("Couldn't write to \"%s\": %s", local_path,
945 strerror(write_errno));
946 status = -1;
947 do_close(conn, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +1100948 } else {
Damien Miller3db5f532002-02-13 14:10:32 +1100949 status = do_close(conn, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +1100950
951 /* Override umask and utimes if asked */
Ben Lindstrom6dc75f52001-02-17 16:47:47 +0000952#ifdef HAVE_FCHMOD
Damien Miller16a13332002-02-13 14:03:56 +1100953 if (pflag && fchmod(local_fd, mode) == -1)
Damien Millera8e06ce2003-11-21 23:48:55 +1100954#else
Damien Miller16a13332002-02-13 14:03:56 +1100955 if (pflag && chmod(local_path, mode) == -1)
Ben Lindstrom6dc75f52001-02-17 16:47:47 +0000956#endif /* HAVE_FCHMOD */
Damien Miller16a13332002-02-13 14:03:56 +1100957 error("Couldn't set mode on \"%s\": %s", local_path,
Ben Lindstrom93576d92002-12-23 02:06:19 +0000958 strerror(errno));
Damien Miller16a13332002-02-13 14:03:56 +1100959 if (pflag && (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME)) {
960 struct timeval tv[2];
961 tv[0].tv_sec = a->atime;
962 tv[1].tv_sec = a->mtime;
963 tv[0].tv_usec = tv[1].tv_usec = 0;
964 if (utimes(local_path, tv) == -1)
965 error("Can't set times on \"%s\": %s",
Ben Lindstrom93576d92002-12-23 02:06:19 +0000966 local_path, strerror(errno));
Damien Miller16a13332002-02-13 14:03:56 +1100967 }
Ben Lindstrom9d4f2c82001-02-15 03:22:45 +0000968 }
Damien Millerd7686fd2001-02-10 00:40:03 +1100969 close(local_fd);
970 buffer_free(&msg);
971 xfree(handle);
Damien Miller3db5f532002-02-13 14:10:32 +1100972
973 return(status);
Damien Miller33804262001-02-04 23:20:18 +1100974}
975
976int
Damien Miller3db5f532002-02-13 14:10:32 +1100977do_upload(struct sftp_conn *conn, char *local_path, char *remote_path,
978 int pflag)
Damien Miller33804262001-02-04 23:20:18 +1100979{
Damien Miller8829d362002-02-08 22:04:05 +1100980 int local_fd, status;
Damien Miller5873dfd2002-02-13 14:04:37 +1100981 u_int handle_len, id, type;
Damien Miller33804262001-02-04 23:20:18 +1100982 u_int64_t offset;
Damien Miller8829d362002-02-08 22:04:05 +1100983 char *handle, *data;
Damien Miller33804262001-02-04 23:20:18 +1100984 Buffer msg;
985 struct stat sb;
986 Attrib a;
Damien Miller16a13332002-02-13 14:03:56 +1100987 u_int32_t startid;
988 u_int32_t ackid;
Damien Miller5873dfd2002-02-13 14:04:37 +1100989 struct outstanding_ack {
990 u_int id;
991 u_int len;
992 u_int64_t offset;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000993 TAILQ_ENTRY(outstanding_ack) tq;
Damien Miller5873dfd2002-02-13 14:04:37 +1100994 };
995 TAILQ_HEAD(ackhead, outstanding_ack) acks;
Damien Miller7cf17eb2004-06-15 10:28:56 +1000996 struct outstanding_ack *ack = NULL;
Damien Miller5873dfd2002-02-13 14:04:37 +1100997
998 TAILQ_INIT(&acks);
Damien Miller33804262001-02-04 23:20:18 +1100999
1000 if ((local_fd = open(local_path, O_RDONLY, 0)) == -1) {
1001 error("Couldn't open local file \"%s\" for reading: %s",
1002 local_path, strerror(errno));
1003 return(-1);
1004 }
1005 if (fstat(local_fd, &sb) == -1) {
1006 error("Couldn't fstat local file \"%s\": %s",
1007 local_path, strerror(errno));
1008 close(local_fd);
1009 return(-1);
1010 }
Damien Miller5fa01fd2003-01-14 22:24:47 +11001011 if (!S_ISREG(sb.st_mode)) {
1012 error("%s is not a regular file", local_path);
1013 close(local_fd);
1014 return(-1);
1015 }
Damien Miller33804262001-02-04 23:20:18 +11001016 stat_to_attrib(&sb, &a);
1017
1018 a.flags &= ~SSH2_FILEXFER_ATTR_SIZE;
1019 a.flags &= ~SSH2_FILEXFER_ATTR_UIDGID;
1020 a.perm &= 0777;
1021 if (!pflag)
1022 a.flags &= ~SSH2_FILEXFER_ATTR_ACMODTIME;
1023
1024 buffer_init(&msg);
1025
1026 /* Send open request */
Damien Miller3db5f532002-02-13 14:10:32 +11001027 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +11001028 buffer_put_char(&msg, SSH2_FXP_OPEN);
1029 buffer_put_int(&msg, id);
1030 buffer_put_cstring(&msg, remote_path);
1031 buffer_put_int(&msg, SSH2_FXF_WRITE|SSH2_FXF_CREAT|SSH2_FXF_TRUNC);
1032 encode_attrib(&msg, &a);
Damien Miller3db5f532002-02-13 14:10:32 +11001033 send_msg(conn->fd_out, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +00001034 debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path);
Damien Miller33804262001-02-04 23:20:18 +11001035
1036 buffer_clear(&msg);
1037
Damien Miller3db5f532002-02-13 14:10:32 +11001038 handle = get_handle(conn->fd_in, id, &handle_len);
Damien Miller33804262001-02-04 23:20:18 +11001039 if (handle == NULL) {
1040 close(local_fd);
1041 buffer_free(&msg);
1042 return(-1);
1043 }
1044
Damien Miller16a13332002-02-13 14:03:56 +11001045 startid = ackid = id + 1;
Damien Miller3db5f532002-02-13 14:10:32 +11001046 data = xmalloc(conn->transfer_buflen);
Damien Miller8829d362002-02-08 22:04:05 +11001047
Damien Miller33804262001-02-04 23:20:18 +11001048 /* Read from local and write to remote */
1049 offset = 0;
Damien Miller62d57f62003-01-10 21:43:24 +11001050 if (showprogress)
1051 start_progress_meter(local_path, sb.st_size, &offset);
Damien Miller62d57f62003-01-10 21:43:24 +11001052
Damien Miller9f0f5c62001-12-21 14:45:46 +11001053 for (;;) {
Damien Miller33804262001-02-04 23:20:18 +11001054 int len;
Damien Miller33804262001-02-04 23:20:18 +11001055
1056 /*
Darren Tuckerfc959702004-07-17 16:12:08 +10001057 * Can't use atomicio here because it returns 0 on EOF,
Darren Tuckercdf547a2004-05-24 10:12:19 +10001058 * thus losing the last block of the file.
Darren Tuckerfc959702004-07-17 16:12:08 +10001059 * Simulate an EOF on interrupt, allowing ACKs from the
Darren Tuckercdf547a2004-05-24 10:12:19 +10001060 * server to drain.
Damien Miller33804262001-02-04 23:20:18 +11001061 */
Darren Tuckercdf547a2004-05-24 10:12:19 +10001062 if (interrupted)
1063 len = 0;
1064 else do
Damien Miller3db5f532002-02-13 14:10:32 +11001065 len = read(local_fd, data, conn->transfer_buflen);
Damien Miller33804262001-02-04 23:20:18 +11001066 while ((len == -1) && (errno == EINTR || errno == EAGAIN));
1067
1068 if (len == -1)
1069 fatal("Couldn't read from \"%s\": %s", local_path,
1070 strerror(errno));
Damien Miller16a13332002-02-13 14:03:56 +11001071
1072 if (len != 0) {
Damien Miller5873dfd2002-02-13 14:04:37 +11001073 ack = xmalloc(sizeof(*ack));
1074 ack->id = ++id;
1075 ack->offset = offset;
1076 ack->len = len;
1077 TAILQ_INSERT_TAIL(&acks, ack, tq);
1078
Damien Miller16a13332002-02-13 14:03:56 +11001079 buffer_clear(&msg);
1080 buffer_put_char(&msg, SSH2_FXP_WRITE);
Damien Miller5873dfd2002-02-13 14:04:37 +11001081 buffer_put_int(&msg, ack->id);
Damien Miller16a13332002-02-13 14:03:56 +11001082 buffer_put_string(&msg, handle, handle_len);
1083 buffer_put_int64(&msg, offset);
1084 buffer_put_string(&msg, data, len);
Damien Miller3db5f532002-02-13 14:10:32 +11001085 send_msg(conn->fd_out, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +00001086 debug3("Sent message SSH2_FXP_WRITE I:%u O:%llu S:%u",
Ben Lindstrom93576d92002-12-23 02:06:19 +00001087 id, (unsigned long long)offset, len);
Damien Miller5873dfd2002-02-13 14:04:37 +11001088 } else if (TAILQ_FIRST(&acks) == NULL)
Damien Miller33804262001-02-04 23:20:18 +11001089 break;
1090
Damien Miller5873dfd2002-02-13 14:04:37 +11001091 if (ack == NULL)
1092 fatal("Unexpected ACK %u", id);
1093
Ben Lindstrom6328ab32002-03-22 02:54:23 +00001094 if (id == startid || len == 0 ||
Damien Miller3db5f532002-02-13 14:10:32 +11001095 id - ackid >= conn->num_requests) {
Ben Lindstrom5a6abda2002-06-09 19:41:48 +00001096 u_int r_id;
Ben Lindstrom06e95152002-04-06 04:16:45 +00001097
Damien Miller5873dfd2002-02-13 14:04:37 +11001098 buffer_clear(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +11001099 get_msg(conn->fd_in, &msg);
Damien Miller5873dfd2002-02-13 14:04:37 +11001100 type = buffer_get_char(&msg);
Ben Lindstrom06e95152002-04-06 04:16:45 +00001101 r_id = buffer_get_int(&msg);
Damien Miller5873dfd2002-02-13 14:04:37 +11001102
1103 if (type != SSH2_FXP_STATUS)
1104 fatal("Expected SSH2_FXP_STATUS(%d) packet, "
1105 "got %d", SSH2_FXP_STATUS, type);
1106
1107 status = buffer_get_int(&msg);
1108 debug3("SSH2_FXP_STATUS %d", status);
1109
1110 /* Find the request in our queue */
Darren Tucker47eede72005-03-14 23:08:12 +11001111 for (ack = TAILQ_FIRST(&acks);
Ben Lindstrom06e95152002-04-06 04:16:45 +00001112 ack != NULL && ack->id != r_id;
Damien Miller5873dfd2002-02-13 14:04:37 +11001113 ack = TAILQ_NEXT(ack, tq))
1114 ;
1115 if (ack == NULL)
Ben Lindstromb1f483f2002-06-23 21:27:18 +00001116 fatal("Can't find request for ID %u", r_id);
Damien Miller5873dfd2002-02-13 14:04:37 +11001117 TAILQ_REMOVE(&acks, ack, tq);
1118
Damien Miller16a13332002-02-13 14:03:56 +11001119 if (status != SSH2_FX_OK) {
1120 error("Couldn't write to remote file \"%s\": %s",
Ben Lindstrom93576d92002-12-23 02:06:19 +00001121 remote_path, fx2txt(status));
Damien Miller3db5f532002-02-13 14:10:32 +11001122 do_close(conn, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +11001123 close(local_fd);
Damien Miller00111382003-03-10 11:21:17 +11001124 xfree(data);
1125 xfree(ack);
Damien Miller16a13332002-02-13 14:03:56 +11001126 goto done;
1127 }
Ben Lindstromb1f483f2002-06-23 21:27:18 +00001128 debug3("In write loop, ack for %u %u bytes at %llu",
Damien Miller0dc1bef2005-07-17 17:22:45 +10001129 ack->id, ack->len, (unsigned long long)ack->offset);
Damien Miller16a13332002-02-13 14:03:56 +11001130 ++ackid;
Ben Lindstromeec16fc2002-07-04 00:06:15 +00001131 xfree(ack);
Damien Miller33804262001-02-04 23:20:18 +11001132 }
Damien Miller33804262001-02-04 23:20:18 +11001133 offset += len;
1134 }
Damien Miller62d57f62003-01-10 21:43:24 +11001135 if (showprogress)
1136 stop_progress_meter();
Damien Miller8829d362002-02-08 22:04:05 +11001137 xfree(data);
Damien Miller33804262001-02-04 23:20:18 +11001138
1139 if (close(local_fd) == -1) {
1140 error("Couldn't close local file \"%s\": %s", local_path,
1141 strerror(errno));
Damien Miller3db5f532002-02-13 14:10:32 +11001142 do_close(conn, handle, handle_len);
Damien Millerd7686fd2001-02-10 00:40:03 +11001143 status = -1;
1144 goto done;
Damien Miller33804262001-02-04 23:20:18 +11001145 }
1146
Ben Lindstrom9d4f2c82001-02-15 03:22:45 +00001147 /* Override umask and utimes if asked */
1148 if (pflag)
Damien Miller3db5f532002-02-13 14:10:32 +11001149 do_fsetstat(conn, handle, handle_len, &a);
Ben Lindstrom9d4f2c82001-02-15 03:22:45 +00001150
Damien Miller3db5f532002-02-13 14:10:32 +11001151 status = do_close(conn, handle, handle_len);
Damien Millerd7686fd2001-02-10 00:40:03 +11001152
1153done:
1154 xfree(handle);
1155 buffer_free(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +11001156 return(status);
Damien Miller33804262001-02-04 23:20:18 +11001157}