blob: ee0b4a62e6cfb7f3bba39f3e8fd95c8fcbfbc366 [file] [log] [blame]
Damien Miller35e18db2007-09-17 16:11:33 +10001/* $OpenBSD: sftp-server.c,v 1.74 2007/09/13 04:39:04 djm Exp $ */
Damien Miller7b28dc52000-09-05 13:34:53 +11002/*
Darren Tucker37bd3662004-02-24 09:19:15 +11003 * Copyright (c) 2000-2004 Markus Friedl. All rights reserved.
Damien Miller7b28dc52000-09-05 13:34:53 +11004 *
Darren Tucker37bd3662004-02-24 09:19:15 +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 Miller7b28dc52000-09-05 13:34:53 +11008 *
Darren Tucker37bd3662004-02-24 09:19:15 +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 Miller7b28dc52000-09-05 13:34:53 +110016 */
Damien Millerd7834352006-08-05 12:39:39 +100017
Damien Miller7b28dc52000-09-05 13:34:53 +110018#include "includes.h"
Damien Millerf17883e2006-03-15 11:45:54 +110019
20#include <sys/types.h>
Damien Miller8dbffe72006-08-05 11:02:17 +100021#include <sys/param.h>
Damien Millerf17883e2006-03-15 11:45:54 +110022#include <sys/stat.h>
Damien Miller9aec9192006-08-05 10:57:45 +100023#ifdef HAVE_SYS_TIME_H
24# include <sys/time.h>
25#endif
Damien Miller88f254b2006-03-15 11:25:13 +110026
27#include <dirent.h>
Darren Tucker39972492006-07-12 22:22:46 +100028#include <errno.h>
Damien Miller57cf6382006-07-10 21:13:46 +100029#include <fcntl.h>
Damien Miller9f2abc42006-07-10 20:53:08 +100030#include <pwd.h>
Damien Millere7a1e5c2006-08-05 11:34:19 +100031#include <stdlib.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100032#include <stdio.h>
Damien Millere3476ed2006-07-24 14:13:33 +100033#include <string.h>
Damien Millerd7834352006-08-05 12:39:39 +100034#include <pwd.h>
Damien Miller5598b4f2006-07-24 14:09:40 +100035#include <time.h>
Damien Millere3476ed2006-07-24 14:13:33 +100036#include <unistd.h>
Damien Millerd7834352006-08-05 12:39:39 +100037#include <stdarg.h>
Damien Miller7b28dc52000-09-05 13:34:53 +110038
Damien Miller7b28dc52000-09-05 13:34:53 +110039#include "xmalloc.h"
Damien Millerd7834352006-08-05 12:39:39 +100040#include "buffer.h"
41#include "log.h"
Darren Tuckerce321d82005-10-03 18:11:24 +100042#include "misc.h"
Damien Millerfef95ad2006-07-10 20:46:55 +100043#include "uidswap.h"
Damien Miller7b28dc52000-09-05 13:34:53 +110044
Ben Lindstrom2f959b42001-01-11 06:20:23 +000045#include "sftp.h"
Damien Miller33804262001-02-04 23:20:18 +110046#include "sftp-common.h"
Damien Miller7b28dc52000-09-05 13:34:53 +110047
48/* helper */
Ben Lindstrom2f959b42001-01-11 06:20:23 +000049#define get_int64() buffer_get_int64(&iqueue);
Damien Miller7b28dc52000-09-05 13:34:53 +110050#define get_int() buffer_get_int(&iqueue);
51#define get_string(lenp) buffer_get_string(&iqueue, lenp);
Damien Miller7b28dc52000-09-05 13:34:53 +110052
Damien Millerfef95ad2006-07-10 20:46:55 +100053/* Our verbosity */
54LogLevel log_level = SYSLOG_LEVEL_ERROR;
55
56/* Our client */
57struct passwd *pw = NULL;
58char *client_addr = NULL;
Ben Lindstrom49a79c02000-11-17 03:47:20 +000059
Damien Miller7b28dc52000-09-05 13:34:53 +110060/* input and output queue */
61Buffer iqueue;
62Buffer oqueue;
63
Damien Miller058316f2001-03-08 10:08:49 +110064/* Version of client */
65int version;
66
Darren Tuckera6612d42003-06-28 12:39:03 +100067/* portable attributes, etc. */
Damien Miller7b28dc52000-09-05 13:34:53 +110068
Damien Miller7b28dc52000-09-05 13:34:53 +110069typedef struct Stat Stat;
70
Damien Miller33804262001-02-04 23:20:18 +110071struct Stat {
Damien Miller7b28dc52000-09-05 13:34:53 +110072 char *name;
73 char *long_name;
74 Attrib attrib;
75};
76
Ben Lindstrombba81212001-06-25 05:01:22 +000077static int
Damien Miller7b28dc52000-09-05 13:34:53 +110078errno_to_portable(int unixerrno)
79{
80 int ret = 0;
Ben Lindstrom1addabd2001-03-05 07:09:11 +000081
Damien Miller7b28dc52000-09-05 13:34:53 +110082 switch (unixerrno) {
83 case 0:
Ben Lindstrom2f959b42001-01-11 06:20:23 +000084 ret = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +110085 break;
86 case ENOENT:
87 case ENOTDIR:
88 case EBADF:
89 case ELOOP:
Ben Lindstrom2f959b42001-01-11 06:20:23 +000090 ret = SSH2_FX_NO_SUCH_FILE;
Damien Miller7b28dc52000-09-05 13:34:53 +110091 break;
92 case EPERM:
93 case EACCES:
94 case EFAULT:
Ben Lindstrom2f959b42001-01-11 06:20:23 +000095 ret = SSH2_FX_PERMISSION_DENIED;
Damien Miller7b28dc52000-09-05 13:34:53 +110096 break;
97 case ENAMETOOLONG:
98 case EINVAL:
Ben Lindstrom2f959b42001-01-11 06:20:23 +000099 ret = SSH2_FX_BAD_MESSAGE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100100 break;
101 default:
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000102 ret = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100103 break;
104 }
105 return ret;
106}
107
Ben Lindstrombba81212001-06-25 05:01:22 +0000108static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100109flags_from_portable(int pflags)
110{
111 int flags = 0;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000112
Ben Lindstrom36592512001-03-05 05:02:08 +0000113 if ((pflags & SSH2_FXF_READ) &&
114 (pflags & SSH2_FXF_WRITE)) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100115 flags = O_RDWR;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000116 } else if (pflags & SSH2_FXF_READ) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100117 flags = O_RDONLY;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000118 } else if (pflags & SSH2_FXF_WRITE) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100119 flags = O_WRONLY;
120 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000121 if (pflags & SSH2_FXF_CREAT)
Damien Miller7b28dc52000-09-05 13:34:53 +1100122 flags |= O_CREAT;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000123 if (pflags & SSH2_FXF_TRUNC)
Damien Miller7b28dc52000-09-05 13:34:53 +1100124 flags |= O_TRUNC;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000125 if (pflags & SSH2_FXF_EXCL)
Damien Miller7b28dc52000-09-05 13:34:53 +1100126 flags |= O_EXCL;
127 return flags;
128}
129
Damien Millerfef95ad2006-07-10 20:46:55 +1000130static const char *
131string_from_portable(int pflags)
132{
133 static char ret[128];
134
135 *ret = '\0';
136
137#define PAPPEND(str) { \
138 if (*ret != '\0') \
139 strlcat(ret, ",", sizeof(ret)); \
Damien Millerd7834352006-08-05 12:39:39 +1000140 strlcat(ret, str, sizeof(ret)); \
Damien Millerfef95ad2006-07-10 20:46:55 +1000141 }
142
143 if (pflags & SSH2_FXF_READ)
144 PAPPEND("READ")
145 if (pflags & SSH2_FXF_WRITE)
146 PAPPEND("WRITE")
147 if (pflags & SSH2_FXF_CREAT)
148 PAPPEND("CREATE")
149 if (pflags & SSH2_FXF_TRUNC)
150 PAPPEND("TRUNCATE")
151 if (pflags & SSH2_FXF_EXCL)
152 PAPPEND("EXCL")
153
154 return ret;
155}
156
Ben Lindstrombba81212001-06-25 05:01:22 +0000157static Attrib *
Damien Miller7b28dc52000-09-05 13:34:53 +1100158get_attrib(void)
159{
160 return decode_attrib(&iqueue);
161}
162
163/* handle handles */
164
165typedef struct Handle Handle;
166struct Handle {
167 int use;
168 DIR *dirp;
169 int fd;
170 char *name;
Damien Millerfef95ad2006-07-10 20:46:55 +1000171 u_int64_t bytes_read, bytes_write;
Damien Miller7b28dc52000-09-05 13:34:53 +1100172};
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000173
Damien Miller7b28dc52000-09-05 13:34:53 +1100174enum {
175 HANDLE_UNUSED,
176 HANDLE_DIR,
177 HANDLE_FILE
178};
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000179
Damien Miller7b28dc52000-09-05 13:34:53 +1100180Handle handles[100];
181
Ben Lindstrombba81212001-06-25 05:01:22 +0000182static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100183handle_init(void)
184{
Damien Millereccb9de2005-06-17 12:59:34 +1000185 u_int i;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000186
Damien Miller9f0f5c62001-12-21 14:45:46 +1100187 for (i = 0; i < sizeof(handles)/sizeof(Handle); i++)
Damien Miller7b28dc52000-09-05 13:34:53 +1100188 handles[i].use = HANDLE_UNUSED;
189}
190
Ben Lindstrombba81212001-06-25 05:01:22 +0000191static int
Damien Millerf58b58c2003-11-17 21:18:23 +1100192handle_new(int use, const char *name, int fd, DIR *dirp)
Damien Miller7b28dc52000-09-05 13:34:53 +1100193{
Damien Millereccb9de2005-06-17 12:59:34 +1000194 u_int i;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000195
Damien Miller9f0f5c62001-12-21 14:45:46 +1100196 for (i = 0; i < sizeof(handles)/sizeof(Handle); i++) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100197 if (handles[i].use == HANDLE_UNUSED) {
198 handles[i].use = use;
199 handles[i].dirp = dirp;
200 handles[i].fd = fd;
Damien Miller00111382003-03-10 11:21:17 +1100201 handles[i].name = xstrdup(name);
Damien Millerfef95ad2006-07-10 20:46:55 +1000202 handles[i].bytes_read = handles[i].bytes_write = 0;
Damien Miller7b28dc52000-09-05 13:34:53 +1100203 return i;
204 }
205 }
206 return -1;
207}
208
Ben Lindstrombba81212001-06-25 05:01:22 +0000209static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100210handle_is_ok(int i, int type)
211{
Damien Millereccb9de2005-06-17 12:59:34 +1000212 return i >= 0 && (u_int)i < sizeof(handles)/sizeof(Handle) &&
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000213 handles[i].use == type;
Damien Miller7b28dc52000-09-05 13:34:53 +1100214}
215
Ben Lindstrombba81212001-06-25 05:01:22 +0000216static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100217handle_to_string(int handle, char **stringp, int *hlenp)
218{
Damien Miller7b28dc52000-09-05 13:34:53 +1100219 if (stringp == NULL || hlenp == NULL)
220 return -1;
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000221 *stringp = xmalloc(sizeof(int32_t));
Damien Miller3f941882006-03-31 23:13:02 +1100222 put_u32(*stringp, handle);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000223 *hlenp = sizeof(int32_t);
Damien Miller7b28dc52000-09-05 13:34:53 +1100224 return 0;
225}
226
Ben Lindstrombba81212001-06-25 05:01:22 +0000227static int
Damien Millerf58b58c2003-11-17 21:18:23 +1100228handle_from_string(const char *handle, u_int hlen)
Damien Miller7b28dc52000-09-05 13:34:53 +1100229{
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000230 int val;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000231
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000232 if (hlen != sizeof(int32_t))
Damien Miller7b28dc52000-09-05 13:34:53 +1100233 return -1;
Damien Miller3f941882006-03-31 23:13:02 +1100234 val = get_u32(handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100235 if (handle_is_ok(val, HANDLE_FILE) ||
236 handle_is_ok(val, HANDLE_DIR))
237 return val;
238 return -1;
239}
240
Ben Lindstrombba81212001-06-25 05:01:22 +0000241static char *
Damien Miller7b28dc52000-09-05 13:34:53 +1100242handle_to_name(int handle)
243{
244 if (handle_is_ok(handle, HANDLE_DIR)||
245 handle_is_ok(handle, HANDLE_FILE))
246 return handles[handle].name;
247 return NULL;
248}
249
Ben Lindstrombba81212001-06-25 05:01:22 +0000250static DIR *
Damien Miller7b28dc52000-09-05 13:34:53 +1100251handle_to_dir(int handle)
252{
253 if (handle_is_ok(handle, HANDLE_DIR))
254 return handles[handle].dirp;
255 return NULL;
256}
257
Ben Lindstrombba81212001-06-25 05:01:22 +0000258static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100259handle_to_fd(int handle)
260{
Kevin Stevesef4eea92001-02-05 12:42:17 +0000261 if (handle_is_ok(handle, HANDLE_FILE))
Damien Miller7b28dc52000-09-05 13:34:53 +1100262 return handles[handle].fd;
263 return -1;
264}
265
Damien Millerfef95ad2006-07-10 20:46:55 +1000266static void
267handle_update_read(int handle, ssize_t bytes)
268{
269 if (handle_is_ok(handle, HANDLE_FILE) && bytes > 0)
270 handles[handle].bytes_read += bytes;
271}
272
273static void
274handle_update_write(int handle, ssize_t bytes)
275{
276 if (handle_is_ok(handle, HANDLE_FILE) && bytes > 0)
277 handles[handle].bytes_write += bytes;
278}
279
280static u_int64_t
281handle_bytes_read(int handle)
282{
283 if (handle_is_ok(handle, HANDLE_FILE))
284 return (handles[handle].bytes_read);
285 return 0;
286}
287
288static u_int64_t
289handle_bytes_write(int handle)
290{
291 if (handle_is_ok(handle, HANDLE_FILE))
292 return (handles[handle].bytes_write);
293 return 0;
294}
295
Ben Lindstrombba81212001-06-25 05:01:22 +0000296static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100297handle_close(int handle)
298{
299 int ret = -1;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000300
Damien Miller7b28dc52000-09-05 13:34:53 +1100301 if (handle_is_ok(handle, HANDLE_FILE)) {
302 ret = close(handles[handle].fd);
303 handles[handle].use = HANDLE_UNUSED;
Damien Miller00111382003-03-10 11:21:17 +1100304 xfree(handles[handle].name);
Damien Miller7b28dc52000-09-05 13:34:53 +1100305 } else if (handle_is_ok(handle, HANDLE_DIR)) {
306 ret = closedir(handles[handle].dirp);
307 handles[handle].use = HANDLE_UNUSED;
Damien Miller00111382003-03-10 11:21:17 +1100308 xfree(handles[handle].name);
Damien Miller7b28dc52000-09-05 13:34:53 +1100309 } else {
310 errno = ENOENT;
311 }
312 return ret;
313}
314
Damien Millerfef95ad2006-07-10 20:46:55 +1000315static void
316handle_log_close(int handle, char *emsg)
317{
318 if (handle_is_ok(handle, HANDLE_FILE)) {
319 logit("%s%sclose \"%s\" bytes read %llu written %llu",
320 emsg == NULL ? "" : emsg, emsg == NULL ? "" : " ",
321 handle_to_name(handle),
Darren Tucker86473c52007-05-20 14:59:32 +1000322 (unsigned long long)handle_bytes_read(handle),
323 (unsigned long long)handle_bytes_write(handle));
Damien Millerfef95ad2006-07-10 20:46:55 +1000324 } else {
325 logit("%s%sclosedir \"%s\"",
326 emsg == NULL ? "" : emsg, emsg == NULL ? "" : " ",
327 handle_to_name(handle));
328 }
329}
330
331static void
332handle_log_exit(void)
333{
334 u_int i;
335
336 for (i = 0; i < sizeof(handles)/sizeof(Handle); i++)
337 if (handles[i].use != HANDLE_UNUSED)
338 handle_log_close(i, "forced");
339}
340
Ben Lindstrombba81212001-06-25 05:01:22 +0000341static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100342get_handle(void)
343{
344 char *handle;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000345 int val = -1;
Damien Millere4340be2000-09-16 13:29:08 +1100346 u_int hlen;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000347
Damien Miller7b28dc52000-09-05 13:34:53 +1100348 handle = get_string(&hlen);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000349 if (hlen < 256)
350 val = handle_from_string(handle, hlen);
Damien Miller7b28dc52000-09-05 13:34:53 +1100351 xfree(handle);
352 return val;
353}
354
355/* send replies */
356
Ben Lindstrombba81212001-06-25 05:01:22 +0000357static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100358send_msg(Buffer *m)
359{
360 int mlen = buffer_len(m);
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000361
Damien Miller7b28dc52000-09-05 13:34:53 +1100362 buffer_put_int(&oqueue, mlen);
363 buffer_append(&oqueue, buffer_ptr(m), mlen);
364 buffer_consume(m, mlen);
365}
366
Damien Millerfef95ad2006-07-10 20:46:55 +1000367static const char *
368status_to_message(u_int32_t status)
Damien Miller7b28dc52000-09-05 13:34:53 +1100369{
Damien Miller058316f2001-03-08 10:08:49 +1100370 const char *status_messages[] = {
371 "Success", /* SSH_FX_OK */
372 "End of file", /* SSH_FX_EOF */
373 "No such file", /* SSH_FX_NO_SUCH_FILE */
374 "Permission denied", /* SSH_FX_PERMISSION_DENIED */
375 "Failure", /* SSH_FX_FAILURE */
376 "Bad message", /* SSH_FX_BAD_MESSAGE */
377 "No connection", /* SSH_FX_NO_CONNECTION */
378 "Connection lost", /* SSH_FX_CONNECTION_LOST */
379 "Operation unsupported", /* SSH_FX_OP_UNSUPPORTED */
380 "Unknown error" /* Others */
381 };
Damien Millerfef95ad2006-07-10 20:46:55 +1000382 return (status_messages[MIN(status,SSH2_FX_MAX)]);
383}
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000384
Damien Millerfef95ad2006-07-10 20:46:55 +1000385static void
386send_status(u_int32_t id, u_int32_t status)
387{
388 Buffer msg;
389
390 debug3("request %u: sent status %u", id, status);
391 if (log_level > SYSLOG_LEVEL_VERBOSE ||
392 (status != SSH2_FX_OK && status != SSH2_FX_EOF))
393 logit("sent status %s", status_to_message(status));
Damien Miller7b28dc52000-09-05 13:34:53 +1100394 buffer_init(&msg);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000395 buffer_put_char(&msg, SSH2_FXP_STATUS);
Damien Miller7b28dc52000-09-05 13:34:53 +1100396 buffer_put_int(&msg, id);
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000397 buffer_put_int(&msg, status);
Damien Miller058316f2001-03-08 10:08:49 +1100398 if (version >= 3) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000399 buffer_put_cstring(&msg, status_to_message(status));
Damien Miller058316f2001-03-08 10:08:49 +1100400 buffer_put_cstring(&msg, "");
401 }
Damien Miller7b28dc52000-09-05 13:34:53 +1100402 send_msg(&msg);
403 buffer_free(&msg);
404}
Ben Lindstrombba81212001-06-25 05:01:22 +0000405static void
Damien Millerf58b58c2003-11-17 21:18:23 +1100406send_data_or_handle(char type, u_int32_t id, const char *data, int dlen)
Damien Miller7b28dc52000-09-05 13:34:53 +1100407{
408 Buffer msg;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000409
Damien Miller7b28dc52000-09-05 13:34:53 +1100410 buffer_init(&msg);
411 buffer_put_char(&msg, type);
412 buffer_put_int(&msg, id);
413 buffer_put_string(&msg, data, dlen);
414 send_msg(&msg);
415 buffer_free(&msg);
416}
417
Ben Lindstrombba81212001-06-25 05:01:22 +0000418static void
Damien Millerf58b58c2003-11-17 21:18:23 +1100419send_data(u_int32_t id, const char *data, int dlen)
Damien Miller7b28dc52000-09-05 13:34:53 +1100420{
Damien Millerfef95ad2006-07-10 20:46:55 +1000421 debug("request %u: sent data len %d", id, dlen);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000422 send_data_or_handle(SSH2_FXP_DATA, id, data, dlen);
Damien Miller7b28dc52000-09-05 13:34:53 +1100423}
424
Ben Lindstrombba81212001-06-25 05:01:22 +0000425static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100426send_handle(u_int32_t id, int handle)
427{
428 char *string;
429 int hlen;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000430
Damien Miller7b28dc52000-09-05 13:34:53 +1100431 handle_to_string(handle, &string, &hlen);
Damien Millerfef95ad2006-07-10 20:46:55 +1000432 debug("request %u: sent handle handle %d", id, handle);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000433 send_data_or_handle(SSH2_FXP_HANDLE, id, string, hlen);
Damien Miller7b28dc52000-09-05 13:34:53 +1100434 xfree(string);
435}
436
Ben Lindstrombba81212001-06-25 05:01:22 +0000437static void
Damien Millerf58b58c2003-11-17 21:18:23 +1100438send_names(u_int32_t id, int count, const Stat *stats)
Damien Miller7b28dc52000-09-05 13:34:53 +1100439{
440 Buffer msg;
441 int i;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000442
Damien Miller7b28dc52000-09-05 13:34:53 +1100443 buffer_init(&msg);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000444 buffer_put_char(&msg, SSH2_FXP_NAME);
Damien Miller7b28dc52000-09-05 13:34:53 +1100445 buffer_put_int(&msg, id);
446 buffer_put_int(&msg, count);
Damien Millerfef95ad2006-07-10 20:46:55 +1000447 debug("request %u: sent names count %d", id, count);
Damien Miller7b28dc52000-09-05 13:34:53 +1100448 for (i = 0; i < count; i++) {
449 buffer_put_cstring(&msg, stats[i].name);
450 buffer_put_cstring(&msg, stats[i].long_name);
451 encode_attrib(&msg, &stats[i].attrib);
452 }
453 send_msg(&msg);
454 buffer_free(&msg);
455}
456
Ben Lindstrombba81212001-06-25 05:01:22 +0000457static void
Damien Millerf58b58c2003-11-17 21:18:23 +1100458send_attrib(u_int32_t id, const Attrib *a)
Damien Miller7b28dc52000-09-05 13:34:53 +1100459{
460 Buffer msg;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000461
Damien Millerfef95ad2006-07-10 20:46:55 +1000462 debug("request %u: sent attrib have 0x%x", id, a->flags);
Damien Miller7b28dc52000-09-05 13:34:53 +1100463 buffer_init(&msg);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000464 buffer_put_char(&msg, SSH2_FXP_ATTRS);
Damien Miller7b28dc52000-09-05 13:34:53 +1100465 buffer_put_int(&msg, id);
466 encode_attrib(&msg, a);
467 send_msg(&msg);
468 buffer_free(&msg);
469}
470
471/* parse incoming */
472
Ben Lindstrombba81212001-06-25 05:01:22 +0000473static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100474process_init(void)
475{
476 Buffer msg;
Damien Miller7b28dc52000-09-05 13:34:53 +1100477
Ben Lindstrom937df1d2002-06-06 21:58:35 +0000478 version = get_int();
Damien Millerfef95ad2006-07-10 20:46:55 +1000479 verbose("received client version %d", version);
Damien Miller7b28dc52000-09-05 13:34:53 +1100480 buffer_init(&msg);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000481 buffer_put_char(&msg, SSH2_FXP_VERSION);
482 buffer_put_int(&msg, SSH2_FILEXFER_VERSION);
Damien Miller7b28dc52000-09-05 13:34:53 +1100483 send_msg(&msg);
484 buffer_free(&msg);
485}
486
Ben Lindstrombba81212001-06-25 05:01:22 +0000487static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100488process_open(void)
489{
490 u_int32_t id, pflags;
491 Attrib *a;
492 char *name;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000493 int handle, fd, flags, mode, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100494
495 id = get_int();
496 name = get_string(NULL);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000497 pflags = get_int(); /* portable flags */
Damien Miller6444fe92006-07-10 21:31:27 +1000498 debug3("request %u: open flags %d", id, pflags);
Damien Miller7b28dc52000-09-05 13:34:53 +1100499 a = get_attrib();
500 flags = flags_from_portable(pflags);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000501 mode = (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ? a->perm : 0666;
Damien Millerfef95ad2006-07-10 20:46:55 +1000502 logit("open \"%s\" flags %s mode 0%o",
503 name, string_from_portable(pflags), mode);
Damien Miller7b28dc52000-09-05 13:34:53 +1100504 fd = open(name, flags, mode);
505 if (fd < 0) {
506 status = errno_to_portable(errno);
507 } else {
Damien Miller00111382003-03-10 11:21:17 +1100508 handle = handle_new(HANDLE_FILE, name, fd, NULL);
Damien Miller7b28dc52000-09-05 13:34:53 +1100509 if (handle < 0) {
510 close(fd);
511 } else {
512 send_handle(id, handle);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000513 status = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100514 }
515 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000516 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100517 send_status(id, status);
518 xfree(name);
519}
520
Ben Lindstrombba81212001-06-25 05:01:22 +0000521static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100522process_close(void)
523{
524 u_int32_t id;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000525 int handle, ret, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100526
527 id = get_int();
528 handle = get_handle();
Damien Millerfef95ad2006-07-10 20:46:55 +1000529 debug3("request %u: close handle %u", id, handle);
530 handle_log_close(handle, NULL);
Damien Miller7b28dc52000-09-05 13:34:53 +1100531 ret = handle_close(handle);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000532 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100533 send_status(id, status);
534}
535
Ben Lindstrombba81212001-06-25 05:01:22 +0000536static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100537process_read(void)
538{
539 char buf[64*1024];
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000540 u_int32_t id, len;
541 int handle, fd, ret, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100542 u_int64_t off;
543
544 id = get_int();
545 handle = get_handle();
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000546 off = get_int64();
Damien Miller7b28dc52000-09-05 13:34:53 +1100547 len = get_int();
548
Damien Millerfef95ad2006-07-10 20:46:55 +1000549 debug("request %u: read \"%s\" (handle %d) off %llu len %d",
550 id, handle_to_name(handle), handle, (unsigned long long)off, len);
Damien Miller7b28dc52000-09-05 13:34:53 +1100551 if (len > sizeof buf) {
552 len = sizeof buf;
Damien Millerfef95ad2006-07-10 20:46:55 +1000553 debug2("read change len %d", len);
Damien Miller7b28dc52000-09-05 13:34:53 +1100554 }
555 fd = handle_to_fd(handle);
556 if (fd >= 0) {
557 if (lseek(fd, off, SEEK_SET) < 0) {
558 error("process_read: seek failed");
559 status = errno_to_portable(errno);
560 } else {
561 ret = read(fd, buf, len);
562 if (ret < 0) {
563 status = errno_to_portable(errno);
564 } else if (ret == 0) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000565 status = SSH2_FX_EOF;
Damien Miller7b28dc52000-09-05 13:34:53 +1100566 } else {
567 send_data(id, buf, ret);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000568 status = SSH2_FX_OK;
Damien Millerfef95ad2006-07-10 20:46:55 +1000569 handle_update_read(handle, ret);
Damien Miller7b28dc52000-09-05 13:34:53 +1100570 }
571 }
572 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000573 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100574 send_status(id, status);
575}
576
Ben Lindstrombba81212001-06-25 05:01:22 +0000577static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100578process_write(void)
579{
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000580 u_int32_t id;
Damien Miller7b28dc52000-09-05 13:34:53 +1100581 u_int64_t off;
Damien Millere4340be2000-09-16 13:29:08 +1100582 u_int len;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000583 int handle, fd, ret, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100584 char *data;
585
586 id = get_int();
587 handle = get_handle();
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000588 off = get_int64();
Damien Miller7b28dc52000-09-05 13:34:53 +1100589 data = get_string(&len);
590
Damien Millerfef95ad2006-07-10 20:46:55 +1000591 debug("request %u: write \"%s\" (handle %d) off %llu len %d",
592 id, handle_to_name(handle), handle, (unsigned long long)off, len);
Damien Miller7b28dc52000-09-05 13:34:53 +1100593 fd = handle_to_fd(handle);
594 if (fd >= 0) {
595 if (lseek(fd, off, SEEK_SET) < 0) {
596 status = errno_to_portable(errno);
597 error("process_write: seek failed");
598 } else {
599/* XXX ATOMICIO ? */
600 ret = write(fd, data, len);
Damien Millereccb9de2005-06-17 12:59:34 +1000601 if (ret < 0) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100602 error("process_write: write failed");
603 status = errno_to_portable(errno);
Damien Millereccb9de2005-06-17 12:59:34 +1000604 } else if ((size_t)ret == len) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000605 status = SSH2_FX_OK;
Damien Millerfef95ad2006-07-10 20:46:55 +1000606 handle_update_write(handle, ret);
Damien Miller7b28dc52000-09-05 13:34:53 +1100607 } else {
Damien Millerfef95ad2006-07-10 20:46:55 +1000608 debug2("nothing at all written");
Damien Miller7b28dc52000-09-05 13:34:53 +1100609 }
610 }
611 }
612 send_status(id, status);
613 xfree(data);
614}
615
Ben Lindstrombba81212001-06-25 05:01:22 +0000616static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100617process_do_stat(int do_lstat)
618{
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000619 Attrib a;
Damien Miller7b28dc52000-09-05 13:34:53 +1100620 struct stat st;
621 u_int32_t id;
622 char *name;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000623 int ret, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100624
625 id = get_int();
626 name = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +1000627 debug3("request %u: %sstat", id, do_lstat ? "l" : "");
628 verbose("%sstat name \"%s\"", do_lstat ? "l" : "", name);
Damien Miller7b28dc52000-09-05 13:34:53 +1100629 ret = do_lstat ? lstat(name, &st) : stat(name, &st);
630 if (ret < 0) {
631 status = errno_to_portable(errno);
632 } else {
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000633 stat_to_attrib(&st, &a);
634 send_attrib(id, &a);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000635 status = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100636 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000637 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100638 send_status(id, status);
639 xfree(name);
640}
641
Ben Lindstrombba81212001-06-25 05:01:22 +0000642static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100643process_stat(void)
644{
645 process_do_stat(0);
646}
647
Ben Lindstrombba81212001-06-25 05:01:22 +0000648static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100649process_lstat(void)
650{
651 process_do_stat(1);
652}
653
Ben Lindstrombba81212001-06-25 05:01:22 +0000654static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100655process_fstat(void)
656{
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000657 Attrib a;
Damien Miller7b28dc52000-09-05 13:34:53 +1100658 struct stat st;
659 u_int32_t id;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000660 int fd, ret, handle, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100661
662 id = get_int();
663 handle = get_handle();
Damien Millerfef95ad2006-07-10 20:46:55 +1000664 debug("request %u: fstat \"%s\" (handle %u)",
665 id, handle_to_name(handle), handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100666 fd = handle_to_fd(handle);
Damien Millere2334d62007-01-05 16:31:02 +1100667 if (fd >= 0) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100668 ret = fstat(fd, &st);
669 if (ret < 0) {
670 status = errno_to_portable(errno);
671 } else {
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000672 stat_to_attrib(&st, &a);
673 send_attrib(id, &a);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000674 status = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100675 }
676 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000677 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100678 send_status(id, status);
679}
680
Ben Lindstrombba81212001-06-25 05:01:22 +0000681static struct timeval *
Damien Millerf58b58c2003-11-17 21:18:23 +1100682attrib_to_tv(const Attrib *a)
Damien Miller7b28dc52000-09-05 13:34:53 +1100683{
684 static struct timeval tv[2];
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000685
Damien Miller7b28dc52000-09-05 13:34:53 +1100686 tv[0].tv_sec = a->atime;
687 tv[0].tv_usec = 0;
688 tv[1].tv_sec = a->mtime;
689 tv[1].tv_usec = 0;
690 return tv;
691}
692
Ben Lindstrombba81212001-06-25 05:01:22 +0000693static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100694process_setstat(void)
695{
696 Attrib *a;
697 u_int32_t id;
698 char *name;
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000699 int status = SSH2_FX_OK, ret;
Damien Miller7b28dc52000-09-05 13:34:53 +1100700
701 id = get_int();
702 name = get_string(NULL);
703 a = get_attrib();
Damien Millerfef95ad2006-07-10 20:46:55 +1000704 debug("request %u: setstat name \"%s\"", id, name);
Damien Miller00c92172002-02-13 14:05:00 +1100705 if (a->flags & SSH2_FILEXFER_ATTR_SIZE) {
Darren Tucker86473c52007-05-20 14:59:32 +1000706 logit("set \"%s\" size %llu",
707 name, (unsigned long long)a->size);
Damien Miller00c92172002-02-13 14:05:00 +1100708 ret = truncate(name, a->size);
709 if (ret == -1)
710 status = errno_to_portable(errno);
711 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000712 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000713 logit("set \"%s\" mode %04o", name, a->perm);
Damien Miller7b28dc52000-09-05 13:34:53 +1100714 ret = chmod(name, a->perm & 0777);
715 if (ret == -1)
716 status = errno_to_portable(errno);
717 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000718 if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000719 char buf[64];
720 time_t t = a->mtime;
721
722 strftime(buf, sizeof(buf), "%Y%m%d-%H:%M:%S",
723 localtime(&t));
724 logit("set \"%s\" modtime %s", name, buf);
Damien Miller7b28dc52000-09-05 13:34:53 +1100725 ret = utimes(name, attrib_to_tv(a));
726 if (ret == -1)
727 status = errno_to_portable(errno);
728 }
Kevin Steves8e743932001-02-05 13:24:35 +0000729 if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000730 logit("set \"%s\" owner %lu group %lu", name,
731 (u_long)a->uid, (u_long)a->gid);
Kevin Steves8e743932001-02-05 13:24:35 +0000732 ret = chown(name, a->uid, a->gid);
733 if (ret == -1)
734 status = errno_to_portable(errno);
735 }
Damien Miller7b28dc52000-09-05 13:34:53 +1100736 send_status(id, status);
737 xfree(name);
738}
739
Ben Lindstrombba81212001-06-25 05:01:22 +0000740static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100741process_fsetstat(void)
742{
743 Attrib *a;
744 u_int32_t id;
745 int handle, fd, ret;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000746 int status = SSH2_FX_OK;
Kevin Stevesf7ffab32001-01-24 20:11:06 +0000747
Damien Miller7b28dc52000-09-05 13:34:53 +1100748 id = get_int();
749 handle = get_handle();
750 a = get_attrib();
Damien Millerfef95ad2006-07-10 20:46:55 +1000751 debug("request %u: fsetstat handle %d", id, handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100752 fd = handle_to_fd(handle);
Damien Millerfef95ad2006-07-10 20:46:55 +1000753 if (fd < 0) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000754 status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100755 } else {
Damien Millerfef95ad2006-07-10 20:46:55 +1000756 char *name = handle_to_name(handle);
757
Damien Miller00c92172002-02-13 14:05:00 +1100758 if (a->flags & SSH2_FILEXFER_ATTR_SIZE) {
Darren Tucker86473c52007-05-20 14:59:32 +1000759 logit("set \"%s\" size %llu",
760 name, (unsigned long long)a->size);
Damien Miller00c92172002-02-13 14:05:00 +1100761 ret = ftruncate(fd, a->size);
762 if (ret == -1)
763 status = errno_to_portable(errno);
764 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000765 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000766 logit("set \"%s\" mode %04o", name, a->perm);
Ben Lindstrom200e3c92001-01-15 01:56:46 +0000767#ifdef HAVE_FCHMOD
Damien Miller7b28dc52000-09-05 13:34:53 +1100768 ret = fchmod(fd, a->perm & 0777);
Ben Lindstrom200e3c92001-01-15 01:56:46 +0000769#else
Kevin Stevesb6b37ba2001-01-24 20:01:44 +0000770 ret = chmod(name, a->perm & 0777);
Ben Lindstrom200e3c92001-01-15 01:56:46 +0000771#endif
Damien Miller7b28dc52000-09-05 13:34:53 +1100772 if (ret == -1)
773 status = errno_to_portable(errno);
774 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000775 if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000776 char buf[64];
777 time_t t = a->mtime;
778
779 strftime(buf, sizeof(buf), "%Y%m%d-%H:%M:%S",
780 localtime(&t));
781 logit("set \"%s\" modtime %s", name, buf);
Damien Miller7b28dc52000-09-05 13:34:53 +1100782#ifdef HAVE_FUTIMES
783 ret = futimes(fd, attrib_to_tv(a));
784#else
785 ret = utimes(name, attrib_to_tv(a));
786#endif
787 if (ret == -1)
788 status = errno_to_portable(errno);
789 }
Kevin Steves8e743932001-02-05 13:24:35 +0000790 if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000791 logit("set \"%s\" owner %lu group %lu", name,
792 (u_long)a->uid, (u_long)a->gid);
Ben Lindstrom34bb0c72001-02-13 02:40:56 +0000793#ifdef HAVE_FCHOWN
Kevin Steves8e743932001-02-05 13:24:35 +0000794 ret = fchown(fd, a->uid, a->gid);
Ben Lindstrom34bb0c72001-02-13 02:40:56 +0000795#else
796 ret = chown(name, a->uid, a->gid);
797#endif
Kevin Steves8e743932001-02-05 13:24:35 +0000798 if (ret == -1)
799 status = errno_to_portable(errno);
800 }
Damien Miller7b28dc52000-09-05 13:34:53 +1100801 }
802 send_status(id, status);
803}
804
Ben Lindstrombba81212001-06-25 05:01:22 +0000805static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100806process_opendir(void)
807{
808 DIR *dirp = NULL;
809 char *path;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000810 int handle, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100811 u_int32_t id;
812
813 id = get_int();
814 path = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +1000815 debug3("request %u: opendir", id);
816 logit("opendir \"%s\"", path);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000817 dirp = opendir(path);
Damien Miller7b28dc52000-09-05 13:34:53 +1100818 if (dirp == NULL) {
819 status = errno_to_portable(errno);
820 } else {
Damien Miller00111382003-03-10 11:21:17 +1100821 handle = handle_new(HANDLE_DIR, path, 0, dirp);
Damien Miller7b28dc52000-09-05 13:34:53 +1100822 if (handle < 0) {
823 closedir(dirp);
824 } else {
825 send_handle(id, handle);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000826 status = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100827 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000828
Damien Miller7b28dc52000-09-05 13:34:53 +1100829 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000830 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100831 send_status(id, status);
832 xfree(path);
833}
834
Ben Lindstrombba81212001-06-25 05:01:22 +0000835static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100836process_readdir(void)
837{
838 DIR *dirp;
839 struct dirent *dp;
840 char *path;
841 int handle;
842 u_int32_t id;
843
844 id = get_int();
845 handle = get_handle();
Damien Millerfef95ad2006-07-10 20:46:55 +1000846 debug("request %u: readdir \"%s\" (handle %d)", id,
847 handle_to_name(handle), handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100848 dirp = handle_to_dir(handle);
849 path = handle_to_name(handle);
850 if (dirp == NULL || path == NULL) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000851 send_status(id, SSH2_FX_FAILURE);
Damien Miller7b28dc52000-09-05 13:34:53 +1100852 } else {
Damien Miller7b28dc52000-09-05 13:34:53 +1100853 struct stat st;
Damien Millerfef95ad2006-07-10 20:46:55 +1000854 char pathname[MAXPATHLEN];
Damien Miller7b28dc52000-09-05 13:34:53 +1100855 Stat *stats;
856 int nstats = 10, count = 0, i;
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000857
Damien Miller07d86be2006-03-26 14:19:21 +1100858 stats = xcalloc(nstats, sizeof(Stat));
Damien Miller7b28dc52000-09-05 13:34:53 +1100859 while ((dp = readdir(dirp)) != NULL) {
860 if (count >= nstats) {
861 nstats *= 2;
Damien Miller36812092006-03-26 14:22:47 +1100862 stats = xrealloc(stats, nstats, sizeof(Stat));
Damien Miller7b28dc52000-09-05 13:34:53 +1100863 }
864/* XXX OVERFLOW ? */
Ben Lindstrom95148e32001-08-06 21:30:53 +0000865 snprintf(pathname, sizeof pathname, "%s%s%s", path,
866 strcmp(path, "/") ? "/" : "", dp->d_name);
Damien Miller7b28dc52000-09-05 13:34:53 +1100867 if (lstat(pathname, &st) < 0)
868 continue;
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000869 stat_to_attrib(&st, &(stats[count].attrib));
Damien Miller7b28dc52000-09-05 13:34:53 +1100870 stats[count].name = xstrdup(dp->d_name);
Damien Millere1a49812002-09-12 09:54:25 +1000871 stats[count].long_name = ls_file(dp->d_name, &st, 0);
Damien Miller7b28dc52000-09-05 13:34:53 +1100872 count++;
873 /* send up to 100 entries in one message */
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000874 /* XXX check packet size instead */
Damien Miller7b28dc52000-09-05 13:34:53 +1100875 if (count == 100)
876 break;
877 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000878 if (count > 0) {
879 send_names(id, count, stats);
Damien Miller9f0f5c62001-12-21 14:45:46 +1100880 for (i = 0; i < count; i++) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000881 xfree(stats[i].name);
882 xfree(stats[i].long_name);
883 }
884 } else {
885 send_status(id, SSH2_FX_EOF);
Damien Miller7b28dc52000-09-05 13:34:53 +1100886 }
887 xfree(stats);
888 }
889}
890
Ben Lindstrombba81212001-06-25 05:01:22 +0000891static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100892process_remove(void)
893{
894 char *name;
895 u_int32_t id;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000896 int status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100897 int ret;
898
899 id = get_int();
900 name = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +1000901 debug3("request %u: remove", id);
902 logit("remove name \"%s\"", name);
Kevin Stevesa074feb2000-12-21 22:33:45 +0000903 ret = unlink(name);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000904 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100905 send_status(id, status);
906 xfree(name);
907}
908
Ben Lindstrombba81212001-06-25 05:01:22 +0000909static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100910process_mkdir(void)
911{
912 Attrib *a;
913 u_int32_t id;
914 char *name;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000915 int ret, mode, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100916
917 id = get_int();
918 name = get_string(NULL);
919 a = get_attrib();
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000920 mode = (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ?
921 a->perm & 0777 : 0777;
Damien Millerfef95ad2006-07-10 20:46:55 +1000922 debug3("request %u: mkdir", id);
923 logit("mkdir name \"%s\" mode 0%o", name, mode);
Damien Miller7b28dc52000-09-05 13:34:53 +1100924 ret = mkdir(name, mode);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000925 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100926 send_status(id, status);
927 xfree(name);
928}
929
Ben Lindstrombba81212001-06-25 05:01:22 +0000930static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100931process_rmdir(void)
932{
933 u_int32_t id;
934 char *name;
935 int ret, status;
936
937 id = get_int();
938 name = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +1000939 debug3("request %u: rmdir", id);
940 logit("rmdir name \"%s\"", name);
Damien Miller7b28dc52000-09-05 13:34:53 +1100941 ret = rmdir(name);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000942 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100943 send_status(id, status);
944 xfree(name);
945}
946
Ben Lindstrombba81212001-06-25 05:01:22 +0000947static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100948process_realpath(void)
949{
950 char resolvedname[MAXPATHLEN];
951 u_int32_t id;
952 char *path;
953
954 id = get_int();
955 path = get_string(NULL);
Ben Lindstromfa1b3d02000-12-10 01:55:37 +0000956 if (path[0] == '\0') {
957 xfree(path);
958 path = xstrdup(".");
959 }
Damien Millerfef95ad2006-07-10 20:46:55 +1000960 debug3("request %u: realpath", id);
961 verbose("realpath \"%s\"", path);
Damien Miller7b28dc52000-09-05 13:34:53 +1100962 if (realpath(path, resolvedname) == NULL) {
963 send_status(id, errno_to_portable(errno));
964 } else {
965 Stat s;
966 attrib_clear(&s.attrib);
967 s.name = s.long_name = resolvedname;
968 send_names(id, 1, &s);
969 }
970 xfree(path);
971}
972
Ben Lindstrombba81212001-06-25 05:01:22 +0000973static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100974process_rename(void)
975{
976 u_int32_t id;
977 char *oldpath, *newpath;
Damien Miller9e51a732003-02-24 11:58:44 +1100978 int status;
Damien Millerb3207e82003-03-26 16:01:11 +1100979 struct stat sb;
Damien Miller7b28dc52000-09-05 13:34:53 +1100980
981 id = get_int();
982 oldpath = get_string(NULL);
983 newpath = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +1000984 debug3("request %u: rename", id);
985 logit("rename old \"%s\" new \"%s\"", oldpath, newpath);
Damien Millerb3207e82003-03-26 16:01:11 +1100986 status = SSH2_FX_FAILURE;
987 if (lstat(oldpath, &sb) == -1)
Damien Miller9e51a732003-02-24 11:58:44 +1100988 status = errno_to_portable(errno);
Damien Millerb3207e82003-03-26 16:01:11 +1100989 else if (S_ISREG(sb.st_mode)) {
990 /* Race-free rename of regular files */
Darren Tuckeraedc1d62004-06-25 17:06:02 +1000991 if (link(oldpath, newpath) == -1) {
Darren Tuckere59b5082004-06-28 16:01:19 +1000992 if (errno == EOPNOTSUPP
993#ifdef LINK_OPNOTSUPP_ERRNO
994 || errno == LINK_OPNOTSUPP_ERRNO
995#endif
996 ) {
Darren Tuckeraedc1d62004-06-25 17:06:02 +1000997 struct stat st;
998
999 /*
1000 * fs doesn't support links, so fall back to
1001 * stat+rename. This is racy.
1002 */
1003 if (stat(newpath, &st) == -1) {
1004 if (rename(oldpath, newpath) == -1)
1005 status =
1006 errno_to_portable(errno);
1007 else
1008 status = SSH2_FX_OK;
1009 }
1010 } else {
1011 status = errno_to_portable(errno);
1012 }
1013 } else if (unlink(oldpath) == -1) {
Damien Millerb3207e82003-03-26 16:01:11 +11001014 status = errno_to_portable(errno);
1015 /* clean spare link */
1016 unlink(newpath);
1017 } else
1018 status = SSH2_FX_OK;
1019 } else if (stat(newpath, &sb) == -1) {
1020 if (rename(oldpath, newpath) == -1)
1021 status = errno_to_portable(errno);
1022 else
1023 status = SSH2_FX_OK;
1024 }
Damien Miller7b28dc52000-09-05 13:34:53 +11001025 send_status(id, status);
1026 xfree(oldpath);
1027 xfree(newpath);
1028}
1029
Ben Lindstrombba81212001-06-25 05:01:22 +00001030static void
Damien Miller058316f2001-03-08 10:08:49 +11001031process_readlink(void)
1032{
1033 u_int32_t id;
Ben Lindstromabbb73d2001-05-17 03:14:57 +00001034 int len;
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001035 char buf[MAXPATHLEN];
Damien Miller058316f2001-03-08 10:08:49 +11001036 char *path;
1037
1038 id = get_int();
1039 path = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +10001040 debug3("request %u: readlink", id);
1041 verbose("readlink \"%s\"", path);
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001042 if ((len = readlink(path, buf, sizeof(buf) - 1)) == -1)
Damien Miller058316f2001-03-08 10:08:49 +11001043 send_status(id, errno_to_portable(errno));
1044 else {
1045 Stat s;
Damien Miller9f0f5c62001-12-21 14:45:46 +11001046
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001047 buf[len] = '\0';
Damien Miller058316f2001-03-08 10:08:49 +11001048 attrib_clear(&s.attrib);
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001049 s.name = s.long_name = buf;
Damien Miller058316f2001-03-08 10:08:49 +11001050 send_names(id, 1, &s);
1051 }
1052 xfree(path);
1053}
1054
Ben Lindstrombba81212001-06-25 05:01:22 +00001055static void
Damien Miller058316f2001-03-08 10:08:49 +11001056process_symlink(void)
1057{
1058 u_int32_t id;
Damien Miller058316f2001-03-08 10:08:49 +11001059 char *oldpath, *newpath;
Damien Miller9e51a732003-02-24 11:58:44 +11001060 int ret, status;
Damien Miller058316f2001-03-08 10:08:49 +11001061
1062 id = get_int();
1063 oldpath = get_string(NULL);
1064 newpath = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +10001065 debug3("request %u: symlink", id);
1066 logit("symlink old \"%s\" new \"%s\"", oldpath, newpath);
Damien Miller9e51a732003-02-24 11:58:44 +11001067 /* this will fail if 'newpath' exists */
1068 ret = symlink(oldpath, newpath);
1069 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
Damien Miller058316f2001-03-08 10:08:49 +11001070 send_status(id, status);
1071 xfree(oldpath);
1072 xfree(newpath);
1073}
1074
Ben Lindstrombba81212001-06-25 05:01:22 +00001075static void
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001076process_extended(void)
1077{
1078 u_int32_t id;
1079 char *request;
1080
1081 id = get_int();
1082 request = get_string(NULL);
1083 send_status(id, SSH2_FX_OP_UNSUPPORTED); /* MUST */
1084 xfree(request);
1085}
Damien Miller7b28dc52000-09-05 13:34:53 +11001086
1087/* stolen from ssh-agent */
1088
Ben Lindstrombba81212001-06-25 05:01:22 +00001089static void
Damien Miller7b28dc52000-09-05 13:34:53 +11001090process(void)
1091{
Ben Lindstrom46c16222000-12-22 01:43:59 +00001092 u_int msg_len;
Ben Lindstrom2c140472002-06-06 21:57:54 +00001093 u_int buf_len;
1094 u_int consumed;
Ben Lindstrom46c16222000-12-22 01:43:59 +00001095 u_int type;
1096 u_char *cp;
Damien Miller7b28dc52000-09-05 13:34:53 +11001097
Ben Lindstrom2c140472002-06-06 21:57:54 +00001098 buf_len = buffer_len(&iqueue);
1099 if (buf_len < 5)
Damien Miller7b28dc52000-09-05 13:34:53 +11001100 return; /* Incomplete message. */
Damien Miller708d21c2002-01-22 23:18:15 +11001101 cp = buffer_ptr(&iqueue);
Damien Miller3f941882006-03-31 23:13:02 +11001102 msg_len = get_u32(cp);
Damien Miller54446182006-01-02 23:40:50 +11001103 if (msg_len > SFTP_MAX_MSG_LENGTH) {
Damien Millerfef95ad2006-07-10 20:46:55 +10001104 error("bad message from %s local user %s",
1105 client_addr, pw->pw_name);
1106 cleanup_exit(11);
Damien Miller7b28dc52000-09-05 13:34:53 +11001107 }
Ben Lindstrom2c140472002-06-06 21:57:54 +00001108 if (buf_len < msg_len + 4)
Damien Miller7b28dc52000-09-05 13:34:53 +11001109 return;
1110 buffer_consume(&iqueue, 4);
Ben Lindstrom2c140472002-06-06 21:57:54 +00001111 buf_len -= 4;
Damien Miller7b28dc52000-09-05 13:34:53 +11001112 type = buffer_get_char(&iqueue);
1113 switch (type) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001114 case SSH2_FXP_INIT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001115 process_init();
1116 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001117 case SSH2_FXP_OPEN:
Damien Miller7b28dc52000-09-05 13:34:53 +11001118 process_open();
1119 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001120 case SSH2_FXP_CLOSE:
Damien Miller7b28dc52000-09-05 13:34:53 +11001121 process_close();
1122 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001123 case SSH2_FXP_READ:
Damien Miller7b28dc52000-09-05 13:34:53 +11001124 process_read();
1125 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001126 case SSH2_FXP_WRITE:
Damien Miller7b28dc52000-09-05 13:34:53 +11001127 process_write();
1128 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001129 case SSH2_FXP_LSTAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001130 process_lstat();
1131 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001132 case SSH2_FXP_FSTAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001133 process_fstat();
1134 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001135 case SSH2_FXP_SETSTAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001136 process_setstat();
1137 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001138 case SSH2_FXP_FSETSTAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001139 process_fsetstat();
1140 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001141 case SSH2_FXP_OPENDIR:
Damien Miller7b28dc52000-09-05 13:34:53 +11001142 process_opendir();
1143 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001144 case SSH2_FXP_READDIR:
Damien Miller7b28dc52000-09-05 13:34:53 +11001145 process_readdir();
1146 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001147 case SSH2_FXP_REMOVE:
Damien Miller7b28dc52000-09-05 13:34:53 +11001148 process_remove();
1149 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001150 case SSH2_FXP_MKDIR:
Damien Miller7b28dc52000-09-05 13:34:53 +11001151 process_mkdir();
1152 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001153 case SSH2_FXP_RMDIR:
Damien Miller7b28dc52000-09-05 13:34:53 +11001154 process_rmdir();
1155 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001156 case SSH2_FXP_REALPATH:
Damien Miller7b28dc52000-09-05 13:34:53 +11001157 process_realpath();
1158 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001159 case SSH2_FXP_STAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001160 process_stat();
1161 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001162 case SSH2_FXP_RENAME:
Damien Miller7b28dc52000-09-05 13:34:53 +11001163 process_rename();
1164 break;
Damien Miller058316f2001-03-08 10:08:49 +11001165 case SSH2_FXP_READLINK:
1166 process_readlink();
1167 break;
1168 case SSH2_FXP_SYMLINK:
1169 process_symlink();
1170 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001171 case SSH2_FXP_EXTENDED:
1172 process_extended();
1173 break;
Damien Miller7b28dc52000-09-05 13:34:53 +11001174 default:
1175 error("Unknown message %d", type);
1176 break;
1177 }
Ben Lindstrom2c140472002-06-06 21:57:54 +00001178 /* discard the remaining bytes from the current packet */
1179 if (buf_len < buffer_len(&iqueue))
Damien Millerfef95ad2006-07-10 20:46:55 +10001180 fatal("iqueue grew unexpectedly");
Ben Lindstrom2c140472002-06-06 21:57:54 +00001181 consumed = buf_len - buffer_len(&iqueue);
1182 if (msg_len < consumed)
1183 fatal("msg_len %d < consumed %d", msg_len, consumed);
1184 if (msg_len > consumed)
1185 buffer_consume(&iqueue, msg_len - consumed);
Damien Miller7b28dc52000-09-05 13:34:53 +11001186}
1187
Damien Millerfef95ad2006-07-10 20:46:55 +10001188/* Cleanup handler that logs active handles upon normal exit */
1189void
1190cleanup_exit(int i)
1191{
1192 if (pw != NULL && client_addr != NULL) {
1193 handle_log_exit();
1194 logit("session closed for local user %s from [%s]",
1195 pw->pw_name, client_addr);
1196 }
1197 _exit(i);
1198}
1199
1200static void
1201usage(void)
1202{
1203 extern char *__progname;
1204
1205 fprintf(stderr,
1206 "usage: %s [-he] [-l log_level] [-f log_facility]\n", __progname);
1207 exit(1);
1208}
1209
Damien Miller7b28dc52000-09-05 13:34:53 +11001210int
Damien Millerfef95ad2006-07-10 20:46:55 +10001211main(int argc, char **argv)
Damien Miller7b28dc52000-09-05 13:34:53 +11001212{
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001213 fd_set *rset, *wset;
Damien Millerfef95ad2006-07-10 20:46:55 +10001214 int in, out, max, ch, skipargs = 0, log_stderr = 0;
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001215 ssize_t len, olen, set_size;
Damien Millerfef95ad2006-07-10 20:46:55 +10001216 SyslogFacility log_facility = SYSLOG_FACILITY_AUTH;
Darren Tuckere9405982007-05-20 15:09:04 +10001217 char *cp, buf[4*4096];
Damien Millerfef95ad2006-07-10 20:46:55 +10001218
Damien Millerfef95ad2006-07-10 20:46:55 +10001219 extern char *optarg;
1220 extern char *__progname;
Damien Miller7b28dc52000-09-05 13:34:53 +11001221
Darren Tuckerce321d82005-10-03 18:11:24 +10001222 /* Ensure that fds 0, 1 and 2 are open or directed to /dev/null */
1223 sanitise_stdfd();
1224
Damien Millerfef95ad2006-07-10 20:46:55 +10001225 __progname = ssh_get_progname(argv[0]);
1226 log_init(__progname, log_level, log_facility, log_stderr);
Ben Lindstromc7f4ccd2001-03-15 00:09:15 +00001227
Damien Millerfef95ad2006-07-10 20:46:55 +10001228 while (!skipargs && (ch = getopt(argc, argv, "C:f:l:che")) != -1) {
1229 switch (ch) {
1230 case 'c':
1231 /*
1232 * Ignore all arguments if we are invoked as a
Damien Millerd7834352006-08-05 12:39:39 +10001233 * shell using "sftp-server -c command"
Damien Millerfef95ad2006-07-10 20:46:55 +10001234 */
1235 skipargs = 1;
1236 break;
1237 case 'e':
1238 log_stderr = 1;
1239 break;
1240 case 'l':
1241 log_level = log_level_number(optarg);
1242 if (log_level == SYSLOG_LEVEL_NOT_SET)
1243 error("Invalid log level \"%s\"", optarg);
1244 break;
1245 case 'f':
1246 log_facility = log_facility_number(optarg);
Damien Miller35e18db2007-09-17 16:11:33 +10001247 if (log_facility == SYSLOG_FACILITY_NOT_SET)
Damien Millerfef95ad2006-07-10 20:46:55 +10001248 error("Invalid log facility \"%s\"", optarg);
1249 break;
1250 case 'h':
1251 default:
1252 usage();
1253 }
1254 }
1255
1256 log_init(__progname, log_level, log_facility, log_stderr);
1257
1258 if ((cp = getenv("SSH_CONNECTION")) != NULL) {
1259 client_addr = xstrdup(cp);
1260 if ((cp = strchr(client_addr, ' ')) == NULL)
1261 fatal("Malformed SSH_CONNECTION variable: \"%s\"",
1262 getenv("SSH_CONNECTION"));
1263 *cp = '\0';
1264 } else
1265 client_addr = xstrdup("UNKNOWN");
1266
1267 if ((pw = getpwuid(getuid())) == NULL)
1268 fatal("No user found for uid %lu", (u_long)getuid());
1269 pw = pwcopy(pw);
1270
1271 logit("session opened for local user %s from [%s]",
1272 pw->pw_name, client_addr);
1273
Damien Miller7b28dc52000-09-05 13:34:53 +11001274 handle_init();
1275
Damien Miller7b28dc52000-09-05 13:34:53 +11001276 in = dup(STDIN_FILENO);
1277 out = dup(STDOUT_FILENO);
1278
Damien Miller402b3312001-04-14 00:28:42 +10001279#ifdef HAVE_CYGWIN
1280 setmode(in, O_BINARY);
1281 setmode(out, O_BINARY);
1282#endif
1283
Damien Miller7b28dc52000-09-05 13:34:53 +11001284 max = 0;
1285 if (in > max)
1286 max = in;
1287 if (out > max)
1288 max = out;
1289
1290 buffer_init(&iqueue);
1291 buffer_init(&oqueue);
1292
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001293 set_size = howmany(max + 1, NFDBITS) * sizeof(fd_mask);
1294 rset = (fd_set *)xmalloc(set_size);
1295 wset = (fd_set *)xmalloc(set_size);
Damien Miller7b28dc52000-09-05 13:34:53 +11001296
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001297 for (;;) {
1298 memset(rset, 0, set_size);
1299 memset(wset, 0, set_size);
1300
Darren Tuckere9405982007-05-20 15:09:04 +10001301 /*
1302 * Ensure that we can read a full buffer and handle
1303 * the worst-case length packet it can generate,
1304 * otherwise apply backpressure by stopping reads.
1305 */
1306 if (buffer_check_alloc(&iqueue, sizeof(buf)) &&
1307 buffer_check_alloc(&oqueue, SFTP_MAX_MSG_LENGTH))
1308 FD_SET(in, rset);
1309
Damien Miller7b28dc52000-09-05 13:34:53 +11001310 olen = buffer_len(&oqueue);
1311 if (olen > 0)
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001312 FD_SET(out, wset);
Damien Miller7b28dc52000-09-05 13:34:53 +11001313
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001314 if (select(max+1, rset, wset, NULL, NULL) < 0) {
Damien Miller7b28dc52000-09-05 13:34:53 +11001315 if (errno == EINTR)
1316 continue;
Damien Millerfef95ad2006-07-10 20:46:55 +10001317 error("select: %s", strerror(errno));
1318 cleanup_exit(2);
Damien Miller7b28dc52000-09-05 13:34:53 +11001319 }
1320
1321 /* copy stdin to iqueue */
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001322 if (FD_ISSET(in, rset)) {
Damien Miller7b28dc52000-09-05 13:34:53 +11001323 len = read(in, buf, sizeof buf);
1324 if (len == 0) {
1325 debug("read eof");
Damien Millerfef95ad2006-07-10 20:46:55 +10001326 cleanup_exit(0);
Damien Miller7b28dc52000-09-05 13:34:53 +11001327 } else if (len < 0) {
Damien Millerfef95ad2006-07-10 20:46:55 +10001328 error("read: %s", strerror(errno));
1329 cleanup_exit(1);
Damien Miller7b28dc52000-09-05 13:34:53 +11001330 } else {
1331 buffer_append(&iqueue, buf, len);
1332 }
1333 }
1334 /* send oqueue to stdout */
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001335 if (FD_ISSET(out, wset)) {
Damien Miller7b28dc52000-09-05 13:34:53 +11001336 len = write(out, buffer_ptr(&oqueue), olen);
1337 if (len < 0) {
Damien Millerfef95ad2006-07-10 20:46:55 +10001338 error("write: %s", strerror(errno));
1339 cleanup_exit(1);
Damien Miller7b28dc52000-09-05 13:34:53 +11001340 } else {
1341 buffer_consume(&oqueue, len);
1342 }
1343 }
Darren Tuckere9405982007-05-20 15:09:04 +10001344
1345 /*
1346 * Process requests from client if we can fit the results
1347 * into the output buffer, otherwise stop processing input
1348 * and let the output queue drain.
1349 */
1350 if (buffer_check_alloc(&oqueue, SFTP_MAX_MSG_LENGTH))
1351 process();
Damien Miller7b28dc52000-09-05 13:34:53 +11001352 }
1353}