blob: c12d1d38ed4294a072d0db54e274aed3a56bf2f4 [file] [log] [blame]
Damien Miller8b3fdfb2007-09-17 16:12:03 +10001/* $OpenBSD: sftp-client.c,v 1.77 2007/09/16 00:55:52 djm Exp $ */
Damien Miller33804262001-02-04 23:20:18 +11002/*
Damien Miller4e60ed72004-02-17 17:07:59 +11003 * Copyright (c) 2001-2004 Damien Miller <djm@openbsd.org>
Damien Miller33804262001-02-04 23:20:18 +11004 *
Damien Miller4e60ed72004-02-17 17:07:59 +11005 * 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.
Damien Miller33804262001-02-04 23:20:18 +11008 *
Damien Miller4e60ed72004-02-17 17:07:59 +11009 * 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.
Damien Miller33804262001-02-04 23:20:18 +110016 */
17
18/* XXX: memleaks */
19/* XXX: signed vs unsigned */
Damien Miller3db5f532002-02-13 14:10:32 +110020/* XXX: remove all logging, only return status codes */
Damien Miller33804262001-02-04 23:20:18 +110021/* XXX: copy between two remote sites */
22
23#include "includes.h"
Damien Millerf17883e2006-03-15 11:45:54 +110024
25#include <sys/types.h>
Damien Miller8dbffe72006-08-05 11:02:17 +100026#include <sys/param.h>
Damien Millerd7834352006-08-05 12:39:39 +100027#include "openbsd-compat/sys-queue.h"
Damien Millerf17883e2006-03-15 11:45:54 +110028#ifdef HAVE_SYS_STAT_H
29# include <sys/stat.h>
30#endif
Damien Miller9aec9192006-08-05 10:57:45 +100031#ifdef HAVE_SYS_TIME_H
32# include <sys/time.h>
33#endif
Damien Millerd7834352006-08-05 12:39:39 +100034#include <sys/uio.h>
Damien Miller57cf6382006-07-10 21:13:46 +100035
Darren Tucker39972492006-07-12 22:22:46 +100036#include <errno.h>
Damien Miller57cf6382006-07-10 21:13:46 +100037#include <fcntl.h>
38#include <signal.h>
Damien Millerd7834352006-08-05 12:39:39 +100039#include <stdarg.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100040#include <stdio.h>
Damien Millere3476ed2006-07-24 14:13:33 +100041#include <string.h>
Damien Millere6b3b612006-07-24 14:01:23 +100042#include <unistd.h>
Damien Miller16a13332002-02-13 14:03:56 +110043
Damien Miller33804262001-02-04 23:20:18 +110044#include "xmalloc.h"
Damien Millerd7834352006-08-05 12:39:39 +100045#include "buffer.h"
Damien Miller33804262001-02-04 23:20:18 +110046#include "log.h"
47#include "atomicio.h"
Damien Miller62d57f62003-01-10 21:43:24 +110048#include "progressmeter.h"
Damien Miller3f941882006-03-31 23:13:02 +110049#include "misc.h"
Damien Miller33804262001-02-04 23:20:18 +110050
51#include "sftp.h"
52#include "sftp-common.h"
53#include "sftp-client.h"
54
Darren Tuckercdf547a2004-05-24 10:12:19 +100055extern volatile sig_atomic_t interrupted;
Damien Miller62d57f62003-01-10 21:43:24 +110056extern int showprogress;
57
Damien Miller0c8d8f62006-03-15 11:34:25 +110058/* Minimum amount of data to read at a time */
Damien Miller16a13332002-02-13 14:03:56 +110059#define MIN_READ_SIZE 512
60
Damien Miller3db5f532002-02-13 14:10:32 +110061struct sftp_conn {
62 int fd_in;
63 int fd_out;
64 u_int transfer_buflen;
65 u_int num_requests;
66 u_int version;
67 u_int msg_id;
68};
Ben Lindstrom288cc392001-02-09 02:58:04 +000069
Ben Lindstrombba81212001-06-25 05:01:22 +000070static void
Damien Miller33804262001-02-04 23:20:18 +110071send_msg(int fd, Buffer *m)
72{
Damien Millera7f3aaa2003-01-10 21:43:58 +110073 u_char mlen[4];
Damien Miller58ca98b2006-04-23 12:06:35 +100074 struct iovec iov[2];
Damien Miller33804262001-02-04 23:20:18 +110075
Damien Miller54446182006-01-02 23:40:50 +110076 if (buffer_len(m) > SFTP_MAX_MSG_LENGTH)
Damien Millera7f3aaa2003-01-10 21:43:58 +110077 fatal("Outbound message too long %u", buffer_len(m));
Damien Miller33804262001-02-04 23:20:18 +110078
Damien Millera7f3aaa2003-01-10 21:43:58 +110079 /* Send length first */
Damien Miller3f941882006-03-31 23:13:02 +110080 put_u32(mlen, buffer_len(m));
Damien Miller58ca98b2006-04-23 12:06:35 +100081 iov[0].iov_base = mlen;
82 iov[0].iov_len = sizeof(mlen);
83 iov[1].iov_base = buffer_ptr(m);
84 iov[1].iov_len = buffer_len(m);
Damien Millerd7834352006-08-05 12:39:39 +100085
Damien Miller58ca98b2006-04-23 12:06:35 +100086 if (atomiciov(writev, fd, iov, 2) != buffer_len(m) + sizeof(mlen))
Damien Millera7f3aaa2003-01-10 21:43:58 +110087 fatal("Couldn't send packet: %s", strerror(errno));
88
89 buffer_clear(m);
Damien Miller33804262001-02-04 23:20:18 +110090}
91
Ben Lindstrombba81212001-06-25 05:01:22 +000092static void
Damien Miller33804262001-02-04 23:20:18 +110093get_msg(int fd, Buffer *m)
94{
Damien Millera7f3aaa2003-01-10 21:43:58 +110095 u_int msg_len;
Damien Miller33804262001-02-04 23:20:18 +110096
Damien Millera7f3aaa2003-01-10 21:43:58 +110097 buffer_append_space(m, 4);
Damien Millerb253cc42005-05-26 12:23:44 +100098 if (atomicio(read, fd, buffer_ptr(m), 4) != 4) {
99 if (errno == EPIPE)
100 fatal("Connection closed");
101 else
102 fatal("Couldn't read packet: %s", strerror(errno));
103 }
Damien Miller33804262001-02-04 23:20:18 +1100104
Damien Millera7f3aaa2003-01-10 21:43:58 +1100105 msg_len = buffer_get_int(m);
Damien Miller54446182006-01-02 23:40:50 +1100106 if (msg_len > SFTP_MAX_MSG_LENGTH)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000107 fatal("Received message too long %u", msg_len);
Damien Miller33804262001-02-04 23:20:18 +1100108
Damien Millera7f3aaa2003-01-10 21:43:58 +1100109 buffer_append_space(m, msg_len);
Damien Millerb253cc42005-05-26 12:23:44 +1000110 if (atomicio(read, fd, buffer_ptr(m), msg_len) != msg_len) {
111 if (errno == EPIPE)
112 fatal("Connection closed");
113 else
114 fatal("Read packet: %s", strerror(errno));
115 }
Damien Miller33804262001-02-04 23:20:18 +1100116}
117
Ben Lindstrombba81212001-06-25 05:01:22 +0000118static void
Damien Miller33804262001-02-04 23:20:18 +1100119send_string_request(int fd, u_int id, u_int code, char *s,
120 u_int len)
121{
122 Buffer msg;
123
124 buffer_init(&msg);
125 buffer_put_char(&msg, code);
126 buffer_put_int(&msg, id);
127 buffer_put_string(&msg, s, len);
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 void
Damien Miller33804262001-02-04 23:20:18 +1100134send_string_attrs_request(int fd, u_int id, u_int code, char *s,
135 u_int len, Attrib *a)
136{
137 Buffer msg;
138
139 buffer_init(&msg);
140 buffer_put_char(&msg, code);
141 buffer_put_int(&msg, id);
142 buffer_put_string(&msg, s, len);
143 encode_attrib(&msg, a);
144 send_msg(fd, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000145 debug3("Sent message fd %d T:%u I:%u", fd, code, id);
Damien Miller33804262001-02-04 23:20:18 +1100146 buffer_free(&msg);
147}
148
Ben Lindstrombba81212001-06-25 05:01:22 +0000149static u_int
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000150get_status(int fd, u_int expected_id)
Damien Miller33804262001-02-04 23:20:18 +1100151{
152 Buffer msg;
153 u_int type, id, status;
154
155 buffer_init(&msg);
156 get_msg(fd, &msg);
157 type = buffer_get_char(&msg);
158 id = buffer_get_int(&msg);
159
160 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000161 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100162 if (type != SSH2_FXP_STATUS)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000163 fatal("Expected SSH2_FXP_STATUS(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100164 SSH2_FXP_STATUS, type);
165
166 status = buffer_get_int(&msg);
167 buffer_free(&msg);
168
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000169 debug3("SSH2_FXP_STATUS %u", status);
Damien Miller33804262001-02-04 23:20:18 +1100170
171 return(status);
172}
173
Ben Lindstrombba81212001-06-25 05:01:22 +0000174static char *
Damien Miller33804262001-02-04 23:20:18 +1100175get_handle(int fd, u_int expected_id, u_int *len)
176{
177 Buffer msg;
178 u_int type, id;
179 char *handle;
180
181 buffer_init(&msg);
182 get_msg(fd, &msg);
183 type = buffer_get_char(&msg);
184 id = buffer_get_int(&msg);
185
186 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000187 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100188 if (type == SSH2_FXP_STATUS) {
189 int status = buffer_get_int(&msg);
190
191 error("Couldn't get handle: %s", fx2txt(status));
Darren Tuckercd516ef2004-12-06 22:43:43 +1100192 buffer_free(&msg);
Damien Miller33804262001-02-04 23:20:18 +1100193 return(NULL);
194 } else if (type != SSH2_FXP_HANDLE)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000195 fatal("Expected SSH2_FXP_HANDLE(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100196 SSH2_FXP_HANDLE, type);
197
198 handle = buffer_get_string(&msg, len);
199 buffer_free(&msg);
200
201 return(handle);
202}
203
Ben Lindstrombba81212001-06-25 05:01:22 +0000204static Attrib *
Ben Lindstromc8d1c302001-03-17 00:34:46 +0000205get_decode_stat(int fd, u_int expected_id, int quiet)
Damien Miller33804262001-02-04 23:20:18 +1100206{
207 Buffer msg;
208 u_int type, id;
209 Attrib *a;
210
211 buffer_init(&msg);
212 get_msg(fd, &msg);
213
214 type = buffer_get_char(&msg);
215 id = buffer_get_int(&msg);
216
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000217 debug3("Received stat reply T:%u I:%u", type, id);
Damien Miller33804262001-02-04 23:20:18 +1100218 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000219 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100220 if (type == SSH2_FXP_STATUS) {
221 int status = buffer_get_int(&msg);
222
Ben Lindstromc8d1c302001-03-17 00:34:46 +0000223 if (quiet)
224 debug("Couldn't stat remote file: %s", fx2txt(status));
225 else
226 error("Couldn't stat remote file: %s", fx2txt(status));
Darren Tuckercd516ef2004-12-06 22:43:43 +1100227 buffer_free(&msg);
Damien Miller33804262001-02-04 23:20:18 +1100228 return(NULL);
229 } else if (type != SSH2_FXP_ATTRS) {
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000230 fatal("Expected SSH2_FXP_ATTRS(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100231 SSH2_FXP_ATTRS, type);
232 }
233 a = decode_attrib(&msg);
234 buffer_free(&msg);
235
236 return(a);
237}
238
Damien Miller3db5f532002-02-13 14:10:32 +1100239struct sftp_conn *
240do_init(int fd_in, int fd_out, u_int transfer_buflen, u_int num_requests)
Damien Miller33804262001-02-04 23:20:18 +1100241{
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000242 u_int type;
243 int version;
Damien Miller33804262001-02-04 23:20:18 +1100244 Buffer msg;
Damien Miller3db5f532002-02-13 14:10:32 +1100245 struct sftp_conn *ret;
Damien Miller33804262001-02-04 23:20:18 +1100246
247 buffer_init(&msg);
248 buffer_put_char(&msg, SSH2_FXP_INIT);
249 buffer_put_int(&msg, SSH2_FILEXFER_VERSION);
250 send_msg(fd_out, &msg);
251
252 buffer_clear(&msg);
253
254 get_msg(fd_in, &msg);
255
Kevin Stevesef4eea92001-02-05 12:42:17 +0000256 /* Expecting a VERSION reply */
Damien Miller33804262001-02-04 23:20:18 +1100257 if ((type = buffer_get_char(&msg)) != SSH2_FXP_VERSION) {
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000258 error("Invalid packet back from SSH2_FXP_INIT (type %u)",
Damien Miller33804262001-02-04 23:20:18 +1100259 type);
260 buffer_free(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +1100261 return(NULL);
Damien Miller33804262001-02-04 23:20:18 +1100262 }
263 version = buffer_get_int(&msg);
264
265 debug2("Remote version: %d", version);
266
267 /* Check for extensions */
268 while (buffer_len(&msg) > 0) {
269 char *name = buffer_get_string(&msg, NULL);
270 char *value = buffer_get_string(&msg, NULL);
271
272 debug2("Init extension: \"%s\"", name);
273 xfree(name);
274 xfree(value);
275 }
276
277 buffer_free(&msg);
Damien Miller058316f2001-03-08 10:08:49 +1100278
Damien Miller3db5f532002-02-13 14:10:32 +1100279 ret = xmalloc(sizeof(*ret));
280 ret->fd_in = fd_in;
281 ret->fd_out = fd_out;
282 ret->transfer_buflen = transfer_buflen;
283 ret->num_requests = num_requests;
284 ret->version = version;
285 ret->msg_id = 1;
286
287 /* Some filexfer v.0 servers don't support large packets */
288 if (version == 0)
Ben Lindstroma1d81142002-04-02 20:58:11 +0000289 ret->transfer_buflen = MIN(ret->transfer_buflen, 20480);
Damien Miller3db5f532002-02-13 14:10:32 +1100290
291 return(ret);
292}
293
294u_int
295sftp_proto_version(struct sftp_conn *conn)
296{
297 return(conn->version);
Damien Miller33804262001-02-04 23:20:18 +1100298}
299
300int
Damien Miller3db5f532002-02-13 14:10:32 +1100301do_close(struct sftp_conn *conn, char *handle, u_int handle_len)
Damien Miller33804262001-02-04 23:20:18 +1100302{
303 u_int id, status;
304 Buffer msg;
305
306 buffer_init(&msg);
307
Damien Miller3db5f532002-02-13 14:10:32 +1100308 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100309 buffer_put_char(&msg, SSH2_FXP_CLOSE);
310 buffer_put_int(&msg, id);
311 buffer_put_string(&msg, handle, handle_len);
Damien Miller3db5f532002-02-13 14:10:32 +1100312 send_msg(conn->fd_out, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000313 debug3("Sent message SSH2_FXP_CLOSE I:%u", id);
Damien Miller33804262001-02-04 23:20:18 +1100314
Damien Miller3db5f532002-02-13 14:10:32 +1100315 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100316 if (status != SSH2_FX_OK)
317 error("Couldn't close file: %s", fx2txt(status));
318
319 buffer_free(&msg);
320
321 return(status);
322}
323
Damien Miller4870afd2001-03-14 10:27:09 +1100324
Ben Lindstrombba81212001-06-25 05:01:22 +0000325static int
Damien Miller3db5f532002-02-13 14:10:32 +1100326do_lsreaddir(struct sftp_conn *conn, char *path, int printflag,
Damien Miller4870afd2001-03-14 10:27:09 +1100327 SFTP_DIRENT ***dir)
Damien Miller33804262001-02-04 23:20:18 +1100328{
329 Buffer msg;
Damien Millereccb9de2005-06-17 12:59:34 +1000330 u_int count, type, id, handle_len, i, expected_id, ents = 0;
Damien Miller33804262001-02-04 23:20:18 +1100331 char *handle;
332
Damien Miller3db5f532002-02-13 14:10:32 +1100333 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100334
335 buffer_init(&msg);
336 buffer_put_char(&msg, SSH2_FXP_OPENDIR);
337 buffer_put_int(&msg, id);
338 buffer_put_cstring(&msg, path);
Damien Miller3db5f532002-02-13 14:10:32 +1100339 send_msg(conn->fd_out, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100340
341 buffer_clear(&msg);
342
Damien Miller3db5f532002-02-13 14:10:32 +1100343 handle = get_handle(conn->fd_in, id, &handle_len);
Damien Miller33804262001-02-04 23:20:18 +1100344 if (handle == NULL)
345 return(-1);
346
Damien Miller4870afd2001-03-14 10:27:09 +1100347 if (dir) {
348 ents = 0;
349 *dir = xmalloc(sizeof(**dir));
350 (*dir)[0] = NULL;
351 }
Damien Miller4870afd2001-03-14 10:27:09 +1100352
Darren Tuckercdf547a2004-05-24 10:12:19 +1000353 for (; !interrupted;) {
Damien Miller3db5f532002-02-13 14:10:32 +1100354 id = expected_id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100355
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000356 debug3("Sending SSH2_FXP_READDIR I:%u", id);
Damien Miller33804262001-02-04 23:20:18 +1100357
358 buffer_clear(&msg);
359 buffer_put_char(&msg, SSH2_FXP_READDIR);
360 buffer_put_int(&msg, id);
361 buffer_put_string(&msg, handle, handle_len);
Damien Miller3db5f532002-02-13 14:10:32 +1100362 send_msg(conn->fd_out, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100363
364 buffer_clear(&msg);
365
Damien Miller3db5f532002-02-13 14:10:32 +1100366 get_msg(conn->fd_in, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100367
368 type = buffer_get_char(&msg);
369 id = buffer_get_int(&msg);
370
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000371 debug3("Received reply T:%u I:%u", type, id);
Damien Miller33804262001-02-04 23:20:18 +1100372
373 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000374 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100375
376 if (type == SSH2_FXP_STATUS) {
377 int status = buffer_get_int(&msg);
378
379 debug3("Received SSH2_FXP_STATUS %d", status);
380
381 if (status == SSH2_FX_EOF) {
382 break;
383 } else {
384 error("Couldn't read directory: %s",
385 fx2txt(status));
Damien Miller3db5f532002-02-13 14:10:32 +1100386 do_close(conn, handle, handle_len);
Damien Miller00111382003-03-10 11:21:17 +1100387 xfree(handle);
Ben Lindstrom10ac33f2001-02-10 21:53:40 +0000388 return(status);
Damien Miller33804262001-02-04 23:20:18 +1100389 }
390 } else if (type != SSH2_FXP_NAME)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000391 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100392 SSH2_FXP_NAME, type);
393
394 count = buffer_get_int(&msg);
Damien Millerd7686fd2001-02-10 00:40:03 +1100395 if (count == 0)
396 break;
397 debug3("Received %d SSH2_FXP_NAME responses", count);
Damien Miller9f0f5c62001-12-21 14:45:46 +1100398 for (i = 0; i < count; i++) {
Damien Miller33804262001-02-04 23:20:18 +1100399 char *filename, *longname;
400 Attrib *a;
401
402 filename = buffer_get_string(&msg, NULL);
403 longname = buffer_get_string(&msg, NULL);
404 a = decode_attrib(&msg);
405
Damien Miller4870afd2001-03-14 10:27:09 +1100406 if (printflag)
407 printf("%s\n", longname);
408
409 if (dir) {
Damien Miller36812092006-03-26 14:22:47 +1100410 *dir = xrealloc(*dir, ents + 2, sizeof(**dir));
Damien Miller4870afd2001-03-14 10:27:09 +1100411 (*dir)[ents] = xmalloc(sizeof(***dir));
412 (*dir)[ents]->filename = xstrdup(filename);
413 (*dir)[ents]->longname = xstrdup(longname);
414 memcpy(&(*dir)[ents]->a, a, sizeof(*a));
415 (*dir)[++ents] = NULL;
416 }
Damien Miller33804262001-02-04 23:20:18 +1100417
418 xfree(filename);
419 xfree(longname);
420 }
421 }
422
423 buffer_free(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +1100424 do_close(conn, handle, handle_len);
Damien Miller33804262001-02-04 23:20:18 +1100425 xfree(handle);
426
Darren Tuckercdf547a2004-05-24 10:12:19 +1000427 /* Don't return partial matches on interrupt */
428 if (interrupted && dir != NULL && *dir != NULL) {
429 free_sftp_dirents(*dir);
430 *dir = xmalloc(sizeof(**dir));
431 **dir = NULL;
432 }
433
Damien Miller33804262001-02-04 23:20:18 +1100434 return(0);
435}
436
437int
Damien Miller3db5f532002-02-13 14:10:32 +1100438do_readdir(struct sftp_conn *conn, char *path, SFTP_DIRENT ***dir)
Damien Miller4870afd2001-03-14 10:27:09 +1100439{
Damien Miller3db5f532002-02-13 14:10:32 +1100440 return(do_lsreaddir(conn, path, 0, dir));
Damien Miller4870afd2001-03-14 10:27:09 +1100441}
442
443void free_sftp_dirents(SFTP_DIRENT **s)
444{
445 int i;
Damien Miller9f0f5c62001-12-21 14:45:46 +1100446
447 for (i = 0; s[i]; i++) {
Damien Miller4870afd2001-03-14 10:27:09 +1100448 xfree(s[i]->filename);
449 xfree(s[i]->longname);
450 xfree(s[i]);
451 }
452 xfree(s);
453}
454
455int
Damien Miller3db5f532002-02-13 14:10:32 +1100456do_rm(struct sftp_conn *conn, char *path)
Damien Miller33804262001-02-04 23:20:18 +1100457{
458 u_int status, id;
459
460 debug2("Sending SSH2_FXP_REMOVE \"%s\"", path);
461
Damien Miller3db5f532002-02-13 14:10:32 +1100462 id = conn->msg_id++;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000463 send_string_request(conn->fd_out, id, SSH2_FXP_REMOVE, path,
Damien Miller3db5f532002-02-13 14:10:32 +1100464 strlen(path));
465 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100466 if (status != SSH2_FX_OK)
467 error("Couldn't delete file: %s", fx2txt(status));
468 return(status);
469}
470
471int
Damien Miller3db5f532002-02-13 14:10:32 +1100472do_mkdir(struct sftp_conn *conn, char *path, Attrib *a)
Damien Miller33804262001-02-04 23:20:18 +1100473{
474 u_int status, id;
475
Damien Miller3db5f532002-02-13 14:10:32 +1100476 id = conn->msg_id++;
477 send_string_attrs_request(conn->fd_out, id, SSH2_FXP_MKDIR, path,
Damien Miller33804262001-02-04 23:20:18 +1100478 strlen(path), a);
479
Damien Miller3db5f532002-02-13 14:10:32 +1100480 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100481 if (status != SSH2_FX_OK)
482 error("Couldn't create directory: %s", fx2txt(status));
483
484 return(status);
485}
486
487int
Damien Miller3db5f532002-02-13 14:10:32 +1100488do_rmdir(struct sftp_conn *conn, char *path)
Damien Miller33804262001-02-04 23:20:18 +1100489{
490 u_int status, id;
491
Damien Miller3db5f532002-02-13 14:10:32 +1100492 id = conn->msg_id++;
493 send_string_request(conn->fd_out, id, SSH2_FXP_RMDIR, path,
494 strlen(path));
Damien Miller33804262001-02-04 23:20:18 +1100495
Damien Miller3db5f532002-02-13 14:10:32 +1100496 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100497 if (status != SSH2_FX_OK)
498 error("Couldn't remove directory: %s", fx2txt(status));
499
500 return(status);
501}
502
503Attrib *
Damien Miller3db5f532002-02-13 14:10:32 +1100504do_stat(struct sftp_conn *conn, char *path, int quiet)
Damien Miller33804262001-02-04 23:20:18 +1100505{
506 u_int id;
507
Damien Miller3db5f532002-02-13 14:10:32 +1100508 id = conn->msg_id++;
509
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000510 send_string_request(conn->fd_out, id,
511 conn->version == 0 ? SSH2_FXP_STAT_VERSION_0 : SSH2_FXP_STAT,
Damien Miller3db5f532002-02-13 14:10:32 +1100512 path, strlen(path));
513
514 return(get_decode_stat(conn->fd_in, id, quiet));
Damien Miller33804262001-02-04 23:20:18 +1100515}
516
517Attrib *
Damien Miller3db5f532002-02-13 14:10:32 +1100518do_lstat(struct sftp_conn *conn, char *path, int quiet)
Damien Miller33804262001-02-04 23:20:18 +1100519{
520 u_int id;
521
Damien Miller3db5f532002-02-13 14:10:32 +1100522 if (conn->version == 0) {
523 if (quiet)
524 debug("Server version does not support lstat operation");
525 else
Damien Miller996acd22003-04-09 20:59:48 +1000526 logit("Server version does not support lstat operation");
Ben Lindstromf26ff5b2002-04-02 21:00:31 +0000527 return(do_stat(conn, path, quiet));
Damien Miller3db5f532002-02-13 14:10:32 +1100528 }
529
530 id = conn->msg_id++;
531 send_string_request(conn->fd_out, id, SSH2_FXP_LSTAT, path,
532 strlen(path));
533
534 return(get_decode_stat(conn->fd_in, id, quiet));
Damien Miller33804262001-02-04 23:20:18 +1100535}
536
537Attrib *
Damien Miller3db5f532002-02-13 14:10:32 +1100538do_fstat(struct sftp_conn *conn, char *handle, u_int handle_len, int quiet)
Damien Miller33804262001-02-04 23:20:18 +1100539{
540 u_int id;
541
Damien Miller3db5f532002-02-13 14:10:32 +1100542 id = conn->msg_id++;
543 send_string_request(conn->fd_out, id, SSH2_FXP_FSTAT, handle,
544 handle_len);
545
546 return(get_decode_stat(conn->fd_in, id, quiet));
Damien Miller33804262001-02-04 23:20:18 +1100547}
548
549int
Damien Miller3db5f532002-02-13 14:10:32 +1100550do_setstat(struct sftp_conn *conn, char *path, Attrib *a)
Damien Miller33804262001-02-04 23:20:18 +1100551{
552 u_int status, id;
553
Damien Miller3db5f532002-02-13 14:10:32 +1100554 id = conn->msg_id++;
555 send_string_attrs_request(conn->fd_out, id, SSH2_FXP_SETSTAT, path,
Damien Miller33804262001-02-04 23:20:18 +1100556 strlen(path), a);
557
Damien Miller3db5f532002-02-13 14:10:32 +1100558 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100559 if (status != SSH2_FX_OK)
560 error("Couldn't setstat on \"%s\": %s", path,
561 fx2txt(status));
562
563 return(status);
564}
565
566int
Damien Miller3db5f532002-02-13 14:10:32 +1100567do_fsetstat(struct sftp_conn *conn, char *handle, u_int handle_len,
Damien Miller33804262001-02-04 23:20:18 +1100568 Attrib *a)
569{
570 u_int status, id;
571
Damien Miller3db5f532002-02-13 14:10:32 +1100572 id = conn->msg_id++;
573 send_string_attrs_request(conn->fd_out, id, SSH2_FXP_FSETSTAT, handle,
Damien Miller33804262001-02-04 23:20:18 +1100574 handle_len, a);
575
Damien Miller3db5f532002-02-13 14:10:32 +1100576 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100577 if (status != SSH2_FX_OK)
578 error("Couldn't fsetstat: %s", fx2txt(status));
579
580 return(status);
581}
582
583char *
Damien Miller3db5f532002-02-13 14:10:32 +1100584do_realpath(struct sftp_conn *conn, char *path)
Damien Miller33804262001-02-04 23:20:18 +1100585{
586 Buffer msg;
587 u_int type, expected_id, count, id;
588 char *filename, *longname;
589 Attrib *a;
590
Damien Miller3db5f532002-02-13 14:10:32 +1100591 expected_id = id = conn->msg_id++;
592 send_string_request(conn->fd_out, id, SSH2_FXP_REALPATH, path,
593 strlen(path));
Damien Miller33804262001-02-04 23:20:18 +1100594
595 buffer_init(&msg);
596
Damien Miller3db5f532002-02-13 14:10:32 +1100597 get_msg(conn->fd_in, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100598 type = buffer_get_char(&msg);
599 id = buffer_get_int(&msg);
600
601 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000602 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller33804262001-02-04 23:20:18 +1100603
604 if (type == SSH2_FXP_STATUS) {
605 u_int status = buffer_get_int(&msg);
606
607 error("Couldn't canonicalise: %s", fx2txt(status));
608 return(NULL);
609 } else if (type != SSH2_FXP_NAME)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000610 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100611 SSH2_FXP_NAME, type);
612
613 count = buffer_get_int(&msg);
614 if (count != 1)
615 fatal("Got multiple names (%d) from SSH_FXP_REALPATH", count);
616
617 filename = buffer_get_string(&msg, NULL);
618 longname = buffer_get_string(&msg, NULL);
619 a = decode_attrib(&msg);
620
621 debug3("SSH_FXP_REALPATH %s -> %s", path, filename);
622
623 xfree(longname);
624
625 buffer_free(&msg);
626
627 return(filename);
628}
629
630int
Damien Miller3db5f532002-02-13 14:10:32 +1100631do_rename(struct sftp_conn *conn, char *oldpath, char *newpath)
Damien Miller33804262001-02-04 23:20:18 +1100632{
633 Buffer msg;
634 u_int status, id;
635
636 buffer_init(&msg);
637
638 /* Send rename request */
Damien Miller3db5f532002-02-13 14:10:32 +1100639 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100640 buffer_put_char(&msg, SSH2_FXP_RENAME);
641 buffer_put_int(&msg, id);
642 buffer_put_cstring(&msg, oldpath);
643 buffer_put_cstring(&msg, newpath);
Damien Miller3db5f532002-02-13 14:10:32 +1100644 send_msg(conn->fd_out, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100645 debug3("Sent message SSH2_FXP_RENAME \"%s\" -> \"%s\"", oldpath,
646 newpath);
647 buffer_free(&msg);
648
Damien Miller3db5f532002-02-13 14:10:32 +1100649 status = get_status(conn->fd_in, id);
Damien Miller33804262001-02-04 23:20:18 +1100650 if (status != SSH2_FX_OK)
Damien Miller3db5f532002-02-13 14:10:32 +1100651 error("Couldn't rename file \"%s\" to \"%s\": %s", oldpath,
652 newpath, fx2txt(status));
Damien Miller33804262001-02-04 23:20:18 +1100653
654 return(status);
655}
656
657int
Damien Miller3db5f532002-02-13 14:10:32 +1100658do_symlink(struct sftp_conn *conn, char *oldpath, char *newpath)
Damien Miller058316f2001-03-08 10:08:49 +1100659{
660 Buffer msg;
661 u_int status, id;
662
Damien Miller3db5f532002-02-13 14:10:32 +1100663 if (conn->version < 3) {
664 error("This server does not support the symlink operation");
665 return(SSH2_FX_OP_UNSUPPORTED);
666 }
667
Damien Miller058316f2001-03-08 10:08:49 +1100668 buffer_init(&msg);
669
Darren Tuckerdca6a4d2004-04-19 22:10:52 +1000670 /* Send symlink request */
Damien Miller3db5f532002-02-13 14:10:32 +1100671 id = conn->msg_id++;
Damien Miller058316f2001-03-08 10:08:49 +1100672 buffer_put_char(&msg, SSH2_FXP_SYMLINK);
673 buffer_put_int(&msg, id);
674 buffer_put_cstring(&msg, oldpath);
675 buffer_put_cstring(&msg, newpath);
Damien Miller3db5f532002-02-13 14:10:32 +1100676 send_msg(conn->fd_out, &msg);
Damien Miller058316f2001-03-08 10:08:49 +1100677 debug3("Sent message SSH2_FXP_SYMLINK \"%s\" -> \"%s\"", oldpath,
678 newpath);
679 buffer_free(&msg);
680
Damien Miller3db5f532002-02-13 14:10:32 +1100681 status = get_status(conn->fd_in, id);
Damien Miller058316f2001-03-08 10:08:49 +1100682 if (status != SSH2_FX_OK)
Ben Lindstrom8e879cf2002-11-09 15:48:49 +0000683 error("Couldn't symlink file \"%s\" to \"%s\": %s", oldpath,
Damien Miller3db5f532002-02-13 14:10:32 +1100684 newpath, fx2txt(status));
Damien Miller058316f2001-03-08 10:08:49 +1100685
686 return(status);
687}
688
689char *
Damien Miller3db5f532002-02-13 14:10:32 +1100690do_readlink(struct sftp_conn *conn, char *path)
Damien Miller058316f2001-03-08 10:08:49 +1100691{
692 Buffer msg;
693 u_int type, expected_id, count, id;
694 char *filename, *longname;
695 Attrib *a;
696
Damien Miller3db5f532002-02-13 14:10:32 +1100697 expected_id = id = conn->msg_id++;
698 send_string_request(conn->fd_out, id, SSH2_FXP_READLINK, path,
699 strlen(path));
Damien Miller058316f2001-03-08 10:08:49 +1100700
701 buffer_init(&msg);
702
Damien Miller3db5f532002-02-13 14:10:32 +1100703 get_msg(conn->fd_in, &msg);
Damien Miller058316f2001-03-08 10:08:49 +1100704 type = buffer_get_char(&msg);
705 id = buffer_get_int(&msg);
706
707 if (id != expected_id)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000708 fatal("ID mismatch (%u != %u)", id, expected_id);
Damien Miller058316f2001-03-08 10:08:49 +1100709
710 if (type == SSH2_FXP_STATUS) {
711 u_int status = buffer_get_int(&msg);
712
713 error("Couldn't readlink: %s", fx2txt(status));
714 return(NULL);
715 } else if (type != SSH2_FXP_NAME)
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000716 fatal("Expected SSH2_FXP_NAME(%u) packet, got %u",
Damien Miller058316f2001-03-08 10:08:49 +1100717 SSH2_FXP_NAME, type);
718
719 count = buffer_get_int(&msg);
720 if (count != 1)
721 fatal("Got multiple names (%d) from SSH_FXP_READLINK", count);
722
723 filename = buffer_get_string(&msg, NULL);
724 longname = buffer_get_string(&msg, NULL);
725 a = decode_attrib(&msg);
726
727 debug3("SSH_FXP_READLINK %s -> %s", path, filename);
728
729 xfree(longname);
730
731 buffer_free(&msg);
732
733 return(filename);
734}
735
Damien Miller16a13332002-02-13 14:03:56 +1100736static void
737send_read_request(int fd_out, u_int id, u_int64_t offset, u_int len,
738 char *handle, u_int handle_len)
739{
740 Buffer msg;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000741
Damien Miller16a13332002-02-13 14:03:56 +1100742 buffer_init(&msg);
743 buffer_clear(&msg);
744 buffer_put_char(&msg, SSH2_FXP_READ);
745 buffer_put_int(&msg, id);
746 buffer_put_string(&msg, handle, handle_len);
747 buffer_put_int64(&msg, offset);
748 buffer_put_int(&msg, len);
749 send_msg(fd_out, &msg);
750 buffer_free(&msg);
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000751}
Damien Miller16a13332002-02-13 14:03:56 +1100752
Damien Miller058316f2001-03-08 10:08:49 +1100753int
Damien Miller3db5f532002-02-13 14:10:32 +1100754do_download(struct sftp_conn *conn, char *remote_path, char *local_path,
755 int pflag)
Damien Miller33804262001-02-04 23:20:18 +1100756{
Damien Miller33804262001-02-04 23:20:18 +1100757 Attrib junk, *a;
Damien Miller16a13332002-02-13 14:03:56 +1100758 Buffer msg;
759 char *handle;
Darren Tucker40858532005-08-02 17:07:07 +1000760 int local_fd, status = 0, write_error;
Damien Miller16a13332002-02-13 14:03:56 +1100761 int read_error, write_errno;
762 u_int64_t offset, size;
Damien Millereccb9de2005-06-17 12:59:34 +1000763 u_int handle_len, mode, type, id, buflen, num_req, max_req;
Damien Miller62d57f62003-01-10 21:43:24 +1100764 off_t progress_counter;
Damien Miller16a13332002-02-13 14:03:56 +1100765 struct request {
766 u_int id;
767 u_int len;
768 u_int64_t offset;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000769 TAILQ_ENTRY(request) tq;
Damien Miller16a13332002-02-13 14:03:56 +1100770 };
771 TAILQ_HEAD(reqhead, request) requests;
772 struct request *req;
773
774 TAILQ_INIT(&requests);
Damien Miller33804262001-02-04 23:20:18 +1100775
Damien Miller3db5f532002-02-13 14:10:32 +1100776 a = do_stat(conn, remote_path, 0);
Damien Miller33804262001-02-04 23:20:18 +1100777 if (a == NULL)
778 return(-1);
779
780 /* XXX: should we preserve set[ug]id? */
781 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS)
Damien Miller770b3742003-01-08 14:04:53 +1100782 mode = a->perm & 0777;
Damien Miller33804262001-02-04 23:20:18 +1100783 else
784 mode = 0666;
785
Ben Lindstromc8d1c302001-03-17 00:34:46 +0000786 if ((a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) &&
Damien Miller5fa01fd2003-01-14 22:24:47 +1100787 (!S_ISREG(a->perm))) {
788 error("Cannot download non-regular file: %s", remote_path);
Ben Lindstromc8d1c302001-03-17 00:34:46 +0000789 return(-1);
790 }
791
Damien Miller16a13332002-02-13 14:03:56 +1100792 if (a->flags & SSH2_FILEXFER_ATTR_SIZE)
793 size = a->size;
794 else
795 size = 0;
796
Damien Miller3db5f532002-02-13 14:10:32 +1100797 buflen = conn->transfer_buflen;
Damien Miller33804262001-02-04 23:20:18 +1100798 buffer_init(&msg);
799
800 /* Send open request */
Damien Miller3db5f532002-02-13 14:10:32 +1100801 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +1100802 buffer_put_char(&msg, SSH2_FXP_OPEN);
803 buffer_put_int(&msg, id);
804 buffer_put_cstring(&msg, remote_path);
805 buffer_put_int(&msg, SSH2_FXF_READ);
806 attrib_clear(&junk); /* Send empty attributes */
807 encode_attrib(&msg, &junk);
Damien Miller3db5f532002-02-13 14:10:32 +1100808 send_msg(conn->fd_out, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000809 debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path);
Damien Miller33804262001-02-04 23:20:18 +1100810
Damien Miller3db5f532002-02-13 14:10:32 +1100811 handle = get_handle(conn->fd_in, id, &handle_len);
Damien Miller33804262001-02-04 23:20:18 +1100812 if (handle == NULL) {
813 buffer_free(&msg);
Damien Miller33804262001-02-04 23:20:18 +1100814 return(-1);
815 }
816
Damien Millera8e06ce2003-11-21 23:48:55 +1100817 local_fd = open(local_path, O_WRONLY | O_CREAT | O_TRUNC,
Damien Miller770b3742003-01-08 14:04:53 +1100818 mode | S_IWRITE);
Damien Miller3db5f532002-02-13 14:10:32 +1100819 if (local_fd == -1) {
820 error("Couldn't open local file \"%s\" for writing: %s",
821 local_path, strerror(errno));
Ben Lindstrom021fcd32002-02-26 18:02:43 +0000822 buffer_free(&msg);
823 xfree(handle);
Damien Miller3db5f532002-02-13 14:10:32 +1100824 return(-1);
825 }
826
Damien Miller33804262001-02-04 23:20:18 +1100827 /* Read from remote and write to local */
Damien Miller16a13332002-02-13 14:03:56 +1100828 write_error = read_error = write_errno = num_req = offset = 0;
829 max_req = 1;
Damien Miller62d57f62003-01-10 21:43:24 +1100830 progress_counter = 0;
831
Damien Miller9ba30692004-03-08 23:12:02 +1100832 if (showprogress && size != 0)
833 start_progress_meter(remote_path, size, &progress_counter);
Damien Miller62d57f62003-01-10 21:43:24 +1100834
Damien Miller16a13332002-02-13 14:03:56 +1100835 while (num_req > 0 || max_req > 0) {
Damien Miller33804262001-02-04 23:20:18 +1100836 char *data;
Damien Miller16a13332002-02-13 14:03:56 +1100837 u_int len;
Damien Miller33804262001-02-04 23:20:18 +1100838
Darren Tuckercdf547a2004-05-24 10:12:19 +1000839 /*
Darren Tuckerfc959702004-07-17 16:12:08 +1000840 * Simulate EOF on interrupt: stop sending new requests and
Darren Tuckercdf547a2004-05-24 10:12:19 +1000841 * allow outstanding requests to drain gracefully
842 */
843 if (interrupted) {
844 if (num_req == 0) /* If we haven't started yet... */
845 break;
846 max_req = 0;
847 }
848
Damien Miller16a13332002-02-13 14:03:56 +1100849 /* Send some more requests */
850 while (num_req < max_req) {
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000851 debug3("Request range %llu -> %llu (%d/%d)",
Ben Lindstromd45f28c2002-03-22 01:00:57 +0000852 (unsigned long long)offset,
853 (unsigned long long)offset + buflen - 1,
854 num_req, max_req);
Damien Miller16a13332002-02-13 14:03:56 +1100855 req = xmalloc(sizeof(*req));
Damien Miller3db5f532002-02-13 14:10:32 +1100856 req->id = conn->msg_id++;
Damien Miller16a13332002-02-13 14:03:56 +1100857 req->len = buflen;
858 req->offset = offset;
859 offset += buflen;
860 num_req++;
861 TAILQ_INSERT_TAIL(&requests, req, tq);
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000862 send_read_request(conn->fd_out, req->id, req->offset,
Damien Miller16a13332002-02-13 14:03:56 +1100863 req->len, handle, handle_len);
864 }
Damien Miller33804262001-02-04 23:20:18 +1100865
866 buffer_clear(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +1100867 get_msg(conn->fd_in, &msg);
Damien Miller33804262001-02-04 23:20:18 +1100868 type = buffer_get_char(&msg);
869 id = buffer_get_int(&msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000870 debug3("Received reply T:%u I:%u R:%d", type, id, max_req);
Damien Miller33804262001-02-04 23:20:18 +1100871
Damien Miller16a13332002-02-13 14:03:56 +1100872 /* Find the request in our queue */
Darren Tucker47eede72005-03-14 23:08:12 +1100873 for (req = TAILQ_FIRST(&requests);
Damien Miller16a13332002-02-13 14:03:56 +1100874 req != NULL && req->id != id;
875 req = TAILQ_NEXT(req, tq))
876 ;
877 if (req == NULL)
878 fatal("Unexpected reply %u", id);
879
880 switch (type) {
881 case SSH2_FXP_STATUS:
882 status = buffer_get_int(&msg);
883 if (status != SSH2_FX_EOF)
884 read_error = 1;
885 max_req = 0;
886 TAILQ_REMOVE(&requests, req, tq);
887 xfree(req);
888 num_req--;
889 break;
890 case SSH2_FXP_DATA:
891 data = buffer_get_string(&msg, &len);
Ben Lindstromeb505452002-03-22 01:03:15 +0000892 debug3("Received data %llu -> %llu",
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000893 (unsigned long long)req->offset,
Ben Lindstromeb505452002-03-22 01:03:15 +0000894 (unsigned long long)req->offset + len - 1);
Damien Miller16a13332002-02-13 14:03:56 +1100895 if (len > req->len)
896 fatal("Received more data than asked for "
Ben Lindstrom93576d92002-12-23 02:06:19 +0000897 "%u > %u", len, req->len);
Damien Miller16a13332002-02-13 14:03:56 +1100898 if ((lseek(local_fd, req->offset, SEEK_SET) == -1 ||
Darren Tucker9f63f222003-07-03 13:46:56 +1000899 atomicio(vwrite, local_fd, data, len) != len) &&
Damien Miller16a13332002-02-13 14:03:56 +1100900 !write_error) {
901 write_errno = errno;
902 write_error = 1;
903 max_req = 0;
Damien Miller33804262001-02-04 23:20:18 +1100904 }
Damien Miller62d57f62003-01-10 21:43:24 +1100905 progress_counter += len;
Damien Miller16a13332002-02-13 14:03:56 +1100906 xfree(data);
907
908 if (len == req->len) {
909 TAILQ_REMOVE(&requests, req, tq);
910 xfree(req);
911 num_req--;
912 } else {
913 /* Resend the request for the missing data */
914 debug3("Short data block, re-requesting "
Ben Lindstromeb505452002-03-22 01:03:15 +0000915 "%llu -> %llu (%2d)",
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000916 (unsigned long long)req->offset + len,
Ben Lindstrom83b79e42002-03-22 01:05:27 +0000917 (unsigned long long)req->offset +
918 req->len - 1, num_req);
Damien Miller3db5f532002-02-13 14:10:32 +1100919 req->id = conn->msg_id++;
Damien Miller16a13332002-02-13 14:03:56 +1100920 req->len -= len;
921 req->offset += len;
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000922 send_read_request(conn->fd_out, req->id,
Damien Miller3db5f532002-02-13 14:10:32 +1100923 req->offset, req->len, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +1100924 /* Reduce the request size */
925 if (len < buflen)
926 buflen = MAX(MIN_READ_SIZE, len);
927 }
928 if (max_req > 0) { /* max_req = 0 iff EOF received */
929 if (size > 0 && offset > size) {
930 /* Only one request at a time
931 * after the expected EOF */
932 debug3("Finish at %llu (%2d)",
Ben Lindstromeb505452002-03-22 01:03:15 +0000933 (unsigned long long)offset,
934 num_req);
Damien Miller16a13332002-02-13 14:03:56 +1100935 max_req = 1;
Darren Tuckercdf547a2004-05-24 10:12:19 +1000936 } else if (max_req <= conn->num_requests) {
Damien Miller16a13332002-02-13 14:03:56 +1100937 ++max_req;
938 }
939 }
940 break;
941 default:
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000942 fatal("Expected SSH2_FXP_DATA(%u) packet, got %u",
Damien Miller33804262001-02-04 23:20:18 +1100943 SSH2_FXP_DATA, type);
944 }
Damien Miller33804262001-02-04 23:20:18 +1100945 }
Damien Miller33804262001-02-04 23:20:18 +1100946
Damien Miller62d57f62003-01-10 21:43:24 +1100947 if (showprogress && size)
948 stop_progress_meter();
949
Damien Miller16a13332002-02-13 14:03:56 +1100950 /* Sanity check */
951 if (TAILQ_FIRST(&requests) != NULL)
952 fatal("Transfer complete, but requests still in queue");
953
954 if (read_error) {
Ben Lindstrom6328ab32002-03-22 02:54:23 +0000955 error("Couldn't read from remote file \"%s\" : %s",
Damien Miller3db5f532002-02-13 14:10:32 +1100956 remote_path, fx2txt(status));
957 do_close(conn, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +1100958 } else if (write_error) {
Damien Miller3db5f532002-02-13 14:10:32 +1100959 error("Couldn't write to \"%s\": %s", local_path,
960 strerror(write_errno));
961 status = -1;
962 do_close(conn, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +1100963 } else {
Damien Miller3db5f532002-02-13 14:10:32 +1100964 status = do_close(conn, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +1100965
966 /* Override umask and utimes if asked */
Ben Lindstrom6dc75f52001-02-17 16:47:47 +0000967#ifdef HAVE_FCHMOD
Damien Miller16a13332002-02-13 14:03:56 +1100968 if (pflag && fchmod(local_fd, mode) == -1)
Damien Millera8e06ce2003-11-21 23:48:55 +1100969#else
Damien Miller16a13332002-02-13 14:03:56 +1100970 if (pflag && chmod(local_path, mode) == -1)
Ben Lindstrom6dc75f52001-02-17 16:47:47 +0000971#endif /* HAVE_FCHMOD */
Damien Miller16a13332002-02-13 14:03:56 +1100972 error("Couldn't set mode on \"%s\": %s", local_path,
Ben Lindstrom93576d92002-12-23 02:06:19 +0000973 strerror(errno));
Damien Miller16a13332002-02-13 14:03:56 +1100974 if (pflag && (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME)) {
975 struct timeval tv[2];
976 tv[0].tv_sec = a->atime;
977 tv[1].tv_sec = a->mtime;
978 tv[0].tv_usec = tv[1].tv_usec = 0;
979 if (utimes(local_path, tv) == -1)
980 error("Can't set times on \"%s\": %s",
Ben Lindstrom93576d92002-12-23 02:06:19 +0000981 local_path, strerror(errno));
Damien Miller16a13332002-02-13 14:03:56 +1100982 }
Ben Lindstrom9d4f2c82001-02-15 03:22:45 +0000983 }
Damien Millerd7686fd2001-02-10 00:40:03 +1100984 close(local_fd);
985 buffer_free(&msg);
986 xfree(handle);
Damien Miller3db5f532002-02-13 14:10:32 +1100987
988 return(status);
Damien Miller33804262001-02-04 23:20:18 +1100989}
990
991int
Damien Miller3db5f532002-02-13 14:10:32 +1100992do_upload(struct sftp_conn *conn, char *local_path, char *remote_path,
993 int pflag)
Damien Miller33804262001-02-04 23:20:18 +1100994{
Damien Miller8829d362002-02-08 22:04:05 +1100995 int local_fd, status;
Damien Miller5873dfd2002-02-13 14:04:37 +1100996 u_int handle_len, id, type;
Damien Miller8b3fdfb2007-09-17 16:12:03 +1000997 off_t offset;
Damien Miller8829d362002-02-08 22:04:05 +1100998 char *handle, *data;
Damien Miller33804262001-02-04 23:20:18 +1100999 Buffer msg;
1000 struct stat sb;
1001 Attrib a;
Damien Miller16a13332002-02-13 14:03:56 +11001002 u_int32_t startid;
1003 u_int32_t ackid;
Damien Miller5873dfd2002-02-13 14:04:37 +11001004 struct outstanding_ack {
1005 u_int id;
1006 u_int len;
Damien Miller8b3fdfb2007-09-17 16:12:03 +10001007 off_t offset;
Ben Lindstrom6328ab32002-03-22 02:54:23 +00001008 TAILQ_ENTRY(outstanding_ack) tq;
Damien Miller5873dfd2002-02-13 14:04:37 +11001009 };
1010 TAILQ_HEAD(ackhead, outstanding_ack) acks;
Damien Miller7cf17eb2004-06-15 10:28:56 +10001011 struct outstanding_ack *ack = NULL;
Damien Miller5873dfd2002-02-13 14:04:37 +11001012
1013 TAILQ_INIT(&acks);
Damien Miller33804262001-02-04 23:20:18 +11001014
1015 if ((local_fd = open(local_path, O_RDONLY, 0)) == -1) {
1016 error("Couldn't open local file \"%s\" for reading: %s",
1017 local_path, strerror(errno));
1018 return(-1);
1019 }
1020 if (fstat(local_fd, &sb) == -1) {
1021 error("Couldn't fstat local file \"%s\": %s",
1022 local_path, strerror(errno));
1023 close(local_fd);
1024 return(-1);
1025 }
Damien Miller5fa01fd2003-01-14 22:24:47 +11001026 if (!S_ISREG(sb.st_mode)) {
1027 error("%s is not a regular file", local_path);
1028 close(local_fd);
1029 return(-1);
1030 }
Damien Miller33804262001-02-04 23:20:18 +11001031 stat_to_attrib(&sb, &a);
1032
1033 a.flags &= ~SSH2_FILEXFER_ATTR_SIZE;
1034 a.flags &= ~SSH2_FILEXFER_ATTR_UIDGID;
1035 a.perm &= 0777;
1036 if (!pflag)
1037 a.flags &= ~SSH2_FILEXFER_ATTR_ACMODTIME;
1038
1039 buffer_init(&msg);
1040
1041 /* Send open request */
Damien Miller3db5f532002-02-13 14:10:32 +11001042 id = conn->msg_id++;
Damien Miller33804262001-02-04 23:20:18 +11001043 buffer_put_char(&msg, SSH2_FXP_OPEN);
1044 buffer_put_int(&msg, id);
1045 buffer_put_cstring(&msg, remote_path);
1046 buffer_put_int(&msg, SSH2_FXF_WRITE|SSH2_FXF_CREAT|SSH2_FXF_TRUNC);
1047 encode_attrib(&msg, &a);
Damien Miller3db5f532002-02-13 14:10:32 +11001048 send_msg(conn->fd_out, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +00001049 debug3("Sent message SSH2_FXP_OPEN I:%u P:%s", id, remote_path);
Damien Miller33804262001-02-04 23:20:18 +11001050
1051 buffer_clear(&msg);
1052
Damien Miller3db5f532002-02-13 14:10:32 +11001053 handle = get_handle(conn->fd_in, id, &handle_len);
Damien Miller33804262001-02-04 23:20:18 +11001054 if (handle == NULL) {
1055 close(local_fd);
1056 buffer_free(&msg);
1057 return(-1);
1058 }
1059
Damien Miller16a13332002-02-13 14:03:56 +11001060 startid = ackid = id + 1;
Damien Miller3db5f532002-02-13 14:10:32 +11001061 data = xmalloc(conn->transfer_buflen);
Damien Miller8829d362002-02-08 22:04:05 +11001062
Damien Miller33804262001-02-04 23:20:18 +11001063 /* Read from local and write to remote */
1064 offset = 0;
Damien Miller62d57f62003-01-10 21:43:24 +11001065 if (showprogress)
1066 start_progress_meter(local_path, sb.st_size, &offset);
Damien Miller62d57f62003-01-10 21:43:24 +11001067
Damien Miller9f0f5c62001-12-21 14:45:46 +11001068 for (;;) {
Damien Miller33804262001-02-04 23:20:18 +11001069 int len;
Damien Miller33804262001-02-04 23:20:18 +11001070
1071 /*
Darren Tuckerfc959702004-07-17 16:12:08 +10001072 * Can't use atomicio here because it returns 0 on EOF,
Darren Tuckercdf547a2004-05-24 10:12:19 +10001073 * thus losing the last block of the file.
Darren Tuckerfc959702004-07-17 16:12:08 +10001074 * Simulate an EOF on interrupt, allowing ACKs from the
Darren Tuckercdf547a2004-05-24 10:12:19 +10001075 * server to drain.
Damien Miller33804262001-02-04 23:20:18 +11001076 */
Darren Tuckercdf547a2004-05-24 10:12:19 +10001077 if (interrupted)
1078 len = 0;
1079 else do
Damien Miller3db5f532002-02-13 14:10:32 +11001080 len = read(local_fd, data, conn->transfer_buflen);
Damien Miller33804262001-02-04 23:20:18 +11001081 while ((len == -1) && (errno == EINTR || errno == EAGAIN));
1082
1083 if (len == -1)
1084 fatal("Couldn't read from \"%s\": %s", local_path,
1085 strerror(errno));
Damien Miller16a13332002-02-13 14:03:56 +11001086
1087 if (len != 0) {
Damien Miller5873dfd2002-02-13 14:04:37 +11001088 ack = xmalloc(sizeof(*ack));
1089 ack->id = ++id;
1090 ack->offset = offset;
1091 ack->len = len;
1092 TAILQ_INSERT_TAIL(&acks, ack, tq);
1093
Damien Miller16a13332002-02-13 14:03:56 +11001094 buffer_clear(&msg);
1095 buffer_put_char(&msg, SSH2_FXP_WRITE);
Damien Miller5873dfd2002-02-13 14:04:37 +11001096 buffer_put_int(&msg, ack->id);
Damien Miller16a13332002-02-13 14:03:56 +11001097 buffer_put_string(&msg, handle, handle_len);
1098 buffer_put_int64(&msg, offset);
1099 buffer_put_string(&msg, data, len);
Damien Miller3db5f532002-02-13 14:10:32 +11001100 send_msg(conn->fd_out, &msg);
Ben Lindstromb1f483f2002-06-23 21:27:18 +00001101 debug3("Sent message SSH2_FXP_WRITE I:%u O:%llu S:%u",
Ben Lindstrom93576d92002-12-23 02:06:19 +00001102 id, (unsigned long long)offset, len);
Damien Miller5873dfd2002-02-13 14:04:37 +11001103 } else if (TAILQ_FIRST(&acks) == NULL)
Damien Miller33804262001-02-04 23:20:18 +11001104 break;
1105
Damien Miller5873dfd2002-02-13 14:04:37 +11001106 if (ack == NULL)
1107 fatal("Unexpected ACK %u", id);
1108
Ben Lindstrom6328ab32002-03-22 02:54:23 +00001109 if (id == startid || len == 0 ||
Damien Miller3db5f532002-02-13 14:10:32 +11001110 id - ackid >= conn->num_requests) {
Ben Lindstrom5a6abda2002-06-09 19:41:48 +00001111 u_int r_id;
Ben Lindstrom06e95152002-04-06 04:16:45 +00001112
Damien Miller5873dfd2002-02-13 14:04:37 +11001113 buffer_clear(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +11001114 get_msg(conn->fd_in, &msg);
Damien Miller5873dfd2002-02-13 14:04:37 +11001115 type = buffer_get_char(&msg);
Ben Lindstrom06e95152002-04-06 04:16:45 +00001116 r_id = buffer_get_int(&msg);
Damien Miller5873dfd2002-02-13 14:04:37 +11001117
1118 if (type != SSH2_FXP_STATUS)
1119 fatal("Expected SSH2_FXP_STATUS(%d) packet, "
1120 "got %d", SSH2_FXP_STATUS, type);
1121
1122 status = buffer_get_int(&msg);
1123 debug3("SSH2_FXP_STATUS %d", status);
1124
1125 /* Find the request in our queue */
Darren Tucker47eede72005-03-14 23:08:12 +11001126 for (ack = TAILQ_FIRST(&acks);
Ben Lindstrom06e95152002-04-06 04:16:45 +00001127 ack != NULL && ack->id != r_id;
Damien Miller5873dfd2002-02-13 14:04:37 +11001128 ack = TAILQ_NEXT(ack, tq))
1129 ;
1130 if (ack == NULL)
Ben Lindstromb1f483f2002-06-23 21:27:18 +00001131 fatal("Can't find request for ID %u", r_id);
Damien Miller5873dfd2002-02-13 14:04:37 +11001132 TAILQ_REMOVE(&acks, ack, tq);
1133
Damien Miller16a13332002-02-13 14:03:56 +11001134 if (status != SSH2_FX_OK) {
1135 error("Couldn't write to remote file \"%s\": %s",
Ben Lindstrom93576d92002-12-23 02:06:19 +00001136 remote_path, fx2txt(status));
Damien Miller50455892006-10-24 03:03:02 +10001137 if (showprogress)
1138 stop_progress_meter();
Damien Miller3db5f532002-02-13 14:10:32 +11001139 do_close(conn, handle, handle_len);
Damien Miller16a13332002-02-13 14:03:56 +11001140 close(local_fd);
Damien Miller00111382003-03-10 11:21:17 +11001141 xfree(data);
1142 xfree(ack);
Darren Tucker0aa3dbb2007-02-19 22:13:39 +11001143 status = -1;
Damien Miller16a13332002-02-13 14:03:56 +11001144 goto done;
1145 }
Damien Miller8b3fdfb2007-09-17 16:12:03 +10001146 debug3("In write loop, ack for %u %u bytes at %lld",
1147 ack->id, ack->len, (long long)ack->offset);
Damien Miller16a13332002-02-13 14:03:56 +11001148 ++ackid;
Ben Lindstromeec16fc2002-07-04 00:06:15 +00001149 xfree(ack);
Damien Miller33804262001-02-04 23:20:18 +11001150 }
Damien Miller33804262001-02-04 23:20:18 +11001151 offset += len;
Damien Miller8b3fdfb2007-09-17 16:12:03 +10001152 if (offset < 0)
1153 fatal("%s: offset < 0", __func__);
Damien Miller33804262001-02-04 23:20:18 +11001154 }
Damien Miller62d57f62003-01-10 21:43:24 +11001155 if (showprogress)
1156 stop_progress_meter();
Damien Miller8829d362002-02-08 22:04:05 +11001157 xfree(data);
Damien Miller33804262001-02-04 23:20:18 +11001158
1159 if (close(local_fd) == -1) {
1160 error("Couldn't close local file \"%s\": %s", local_path,
1161 strerror(errno));
Damien Miller3db5f532002-02-13 14:10:32 +11001162 do_close(conn, handle, handle_len);
Damien Millerd7686fd2001-02-10 00:40:03 +11001163 status = -1;
1164 goto done;
Damien Miller33804262001-02-04 23:20:18 +11001165 }
1166
Ben Lindstrom9d4f2c82001-02-15 03:22:45 +00001167 /* Override umask and utimes if asked */
1168 if (pflag)
Damien Miller3db5f532002-02-13 14:10:32 +11001169 do_fsetstat(conn, handle, handle_len, &a);
Ben Lindstrom9d4f2c82001-02-15 03:22:45 +00001170
Damien Miller3db5f532002-02-13 14:10:32 +11001171 status = do_close(conn, handle, handle_len);
Damien Millerd7686fd2001-02-10 00:40:03 +11001172
1173done:
1174 xfree(handle);
1175 buffer_free(&msg);
Damien Miller3db5f532002-02-13 14:10:32 +11001176 return(status);
Damien Miller33804262001-02-04 23:20:18 +11001177}