blob: a98ac2b6dd28c9074771181e93a3757d0cebda98 [file] [log] [blame]
Darren Tucker2901e2d2010-01-13 22:44:06 +11001/* $OpenBSD: sftp-server.c,v 1.91 2010/01/13 01:40:16 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
Darren Tucker5b2e2ba2008-06-08 09:25:28 +100026#ifdef HAVE_SYS_MOUNT_H
Damien Millerd671e5a2008-05-19 14:53:33 +100027#include <sys/mount.h>
Darren Tucker5b2e2ba2008-06-08 09:25:28 +100028#endif
29#ifdef HAVE_SYS_STATVFS_H
Damien Millerd671e5a2008-05-19 14:53:33 +100030#include <sys/statvfs.h>
Darren Tucker5b2e2ba2008-06-08 09:25:28 +100031#endif
Damien Miller88f254b2006-03-15 11:25:13 +110032
33#include <dirent.h>
Darren Tucker39972492006-07-12 22:22:46 +100034#include <errno.h>
Damien Miller57cf6382006-07-10 21:13:46 +100035#include <fcntl.h>
Damien Miller9f2abc42006-07-10 20:53:08 +100036#include <pwd.h>
Damien Millere7a1e5c2006-08-05 11:34:19 +100037#include <stdlib.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100038#include <stdio.h>
Damien Millere3476ed2006-07-24 14:13:33 +100039#include <string.h>
Damien Millerd7834352006-08-05 12:39:39 +100040#include <pwd.h>
Damien Miller5598b4f2006-07-24 14:09:40 +100041#include <time.h>
Damien Millere3476ed2006-07-24 14:13:33 +100042#include <unistd.h>
Damien Millerd7834352006-08-05 12:39:39 +100043#include <stdarg.h>
Damien Miller7b28dc52000-09-05 13:34:53 +110044
Damien Miller7b28dc52000-09-05 13:34:53 +110045#include "xmalloc.h"
Damien Millerd7834352006-08-05 12:39:39 +100046#include "buffer.h"
47#include "log.h"
Darren Tuckerce321d82005-10-03 18:11:24 +100048#include "misc.h"
Damien Millerfef95ad2006-07-10 20:46:55 +100049#include "uidswap.h"
Damien Miller7b28dc52000-09-05 13:34:53 +110050
Ben Lindstrom2f959b42001-01-11 06:20:23 +000051#include "sftp.h"
Damien Miller33804262001-02-04 23:20:18 +110052#include "sftp-common.h"
Damien Miller7b28dc52000-09-05 13:34:53 +110053
54/* helper */
Ben Lindstrom2f959b42001-01-11 06:20:23 +000055#define get_int64() buffer_get_int64(&iqueue);
Damien Miller7b28dc52000-09-05 13:34:53 +110056#define get_int() buffer_get_int(&iqueue);
57#define get_string(lenp) buffer_get_string(&iqueue, lenp);
Damien Miller7b28dc52000-09-05 13:34:53 +110058
Damien Millerfef95ad2006-07-10 20:46:55 +100059/* Our verbosity */
60LogLevel log_level = SYSLOG_LEVEL_ERROR;
61
62/* Our client */
63struct passwd *pw = NULL;
64char *client_addr = NULL;
Ben Lindstrom49a79c02000-11-17 03:47:20 +000065
Damien Miller7b28dc52000-09-05 13:34:53 +110066/* input and output queue */
67Buffer iqueue;
68Buffer oqueue;
69
Damien Miller058316f2001-03-08 10:08:49 +110070/* Version of client */
71int version;
72
Darren Tuckerdb7bf822010-01-09 22:24:33 +110073/* Disable writes */
74int readonly;
75
Darren Tuckera6612d42003-06-28 12:39:03 +100076/* portable attributes, etc. */
Damien Miller7b28dc52000-09-05 13:34:53 +110077
Damien Miller7b28dc52000-09-05 13:34:53 +110078typedef struct Stat Stat;
79
Damien Miller33804262001-02-04 23:20:18 +110080struct Stat {
Damien Miller7b28dc52000-09-05 13:34:53 +110081 char *name;
82 char *long_name;
83 Attrib attrib;
84};
85
Ben Lindstrombba81212001-06-25 05:01:22 +000086static int
Damien Miller7b28dc52000-09-05 13:34:53 +110087errno_to_portable(int unixerrno)
88{
89 int ret = 0;
Ben Lindstrom1addabd2001-03-05 07:09:11 +000090
Damien Miller7b28dc52000-09-05 13:34:53 +110091 switch (unixerrno) {
92 case 0:
Ben Lindstrom2f959b42001-01-11 06:20:23 +000093 ret = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +110094 break;
95 case ENOENT:
96 case ENOTDIR:
97 case EBADF:
98 case ELOOP:
Ben Lindstrom2f959b42001-01-11 06:20:23 +000099 ret = SSH2_FX_NO_SUCH_FILE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100100 break;
101 case EPERM:
102 case EACCES:
103 case EFAULT:
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000104 ret = SSH2_FX_PERMISSION_DENIED;
Damien Miller7b28dc52000-09-05 13:34:53 +1100105 break;
106 case ENAMETOOLONG:
107 case EINVAL:
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000108 ret = SSH2_FX_BAD_MESSAGE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100109 break;
Darren Tucker422c34c2008-06-09 22:48:31 +1000110 case ENOSYS:
111 ret = SSH2_FX_OP_UNSUPPORTED;
112 break;
Damien Miller7b28dc52000-09-05 13:34:53 +1100113 default:
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000114 ret = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100115 break;
116 }
117 return ret;
118}
119
Ben Lindstrombba81212001-06-25 05:01:22 +0000120static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100121flags_from_portable(int pflags)
122{
123 int flags = 0;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000124
Ben Lindstrom36592512001-03-05 05:02:08 +0000125 if ((pflags & SSH2_FXF_READ) &&
126 (pflags & SSH2_FXF_WRITE)) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100127 flags = O_RDWR;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000128 } else if (pflags & SSH2_FXF_READ) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100129 flags = O_RDONLY;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000130 } else if (pflags & SSH2_FXF_WRITE) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100131 flags = O_WRONLY;
132 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000133 if (pflags & SSH2_FXF_CREAT)
Damien Miller7b28dc52000-09-05 13:34:53 +1100134 flags |= O_CREAT;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000135 if (pflags & SSH2_FXF_TRUNC)
Damien Miller7b28dc52000-09-05 13:34:53 +1100136 flags |= O_TRUNC;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000137 if (pflags & SSH2_FXF_EXCL)
Damien Miller7b28dc52000-09-05 13:34:53 +1100138 flags |= O_EXCL;
139 return flags;
140}
141
Damien Millerfef95ad2006-07-10 20:46:55 +1000142static const char *
143string_from_portable(int pflags)
144{
145 static char ret[128];
146
147 *ret = '\0';
148
149#define PAPPEND(str) { \
150 if (*ret != '\0') \
151 strlcat(ret, ",", sizeof(ret)); \
Damien Millerd7834352006-08-05 12:39:39 +1000152 strlcat(ret, str, sizeof(ret)); \
Damien Millerfef95ad2006-07-10 20:46:55 +1000153 }
154
155 if (pflags & SSH2_FXF_READ)
156 PAPPEND("READ")
157 if (pflags & SSH2_FXF_WRITE)
158 PAPPEND("WRITE")
159 if (pflags & SSH2_FXF_CREAT)
160 PAPPEND("CREATE")
161 if (pflags & SSH2_FXF_TRUNC)
162 PAPPEND("TRUNCATE")
163 if (pflags & SSH2_FXF_EXCL)
164 PAPPEND("EXCL")
165
166 return ret;
167}
168
Ben Lindstrombba81212001-06-25 05:01:22 +0000169static Attrib *
Damien Miller7b28dc52000-09-05 13:34:53 +1100170get_attrib(void)
171{
172 return decode_attrib(&iqueue);
173}
174
175/* handle handles */
176
177typedef struct Handle Handle;
178struct Handle {
179 int use;
180 DIR *dirp;
181 int fd;
182 char *name;
Damien Millerfef95ad2006-07-10 20:46:55 +1000183 u_int64_t bytes_read, bytes_write;
Damien Miller3397d0e2008-02-10 22:26:51 +1100184 int next_unused;
Damien Miller7b28dc52000-09-05 13:34:53 +1100185};
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000186
Damien Miller7b28dc52000-09-05 13:34:53 +1100187enum {
188 HANDLE_UNUSED,
189 HANDLE_DIR,
190 HANDLE_FILE
191};
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000192
Damien Miller3397d0e2008-02-10 22:26:51 +1100193Handle *handles = NULL;
194u_int num_handles = 0;
195int first_unused_handle = -1;
Damien Miller7b28dc52000-09-05 13:34:53 +1100196
Damien Miller3397d0e2008-02-10 22:26:51 +1100197static void handle_unused(int i)
Damien Miller7b28dc52000-09-05 13:34:53 +1100198{
Damien Miller3397d0e2008-02-10 22:26:51 +1100199 handles[i].use = HANDLE_UNUSED;
200 handles[i].next_unused = first_unused_handle;
201 first_unused_handle = i;
Damien Miller7b28dc52000-09-05 13:34:53 +1100202}
203
Ben Lindstrombba81212001-06-25 05:01:22 +0000204static int
Damien Millerf58b58c2003-11-17 21:18:23 +1100205handle_new(int use, const char *name, int fd, DIR *dirp)
Damien Miller7b28dc52000-09-05 13:34:53 +1100206{
Damien Miller3397d0e2008-02-10 22:26:51 +1100207 int i;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000208
Damien Miller3397d0e2008-02-10 22:26:51 +1100209 if (first_unused_handle == -1) {
210 if (num_handles + 1 <= num_handles)
211 return -1;
212 num_handles++;
213 handles = xrealloc(handles, num_handles, sizeof(Handle));
214 handle_unused(num_handles - 1);
Damien Miller7b28dc52000-09-05 13:34:53 +1100215 }
Damien Miller3397d0e2008-02-10 22:26:51 +1100216
217 i = first_unused_handle;
218 first_unused_handle = handles[i].next_unused;
219
220 handles[i].use = use;
221 handles[i].dirp = dirp;
222 handles[i].fd = fd;
223 handles[i].name = xstrdup(name);
224 handles[i].bytes_read = handles[i].bytes_write = 0;
225
226 return i;
Damien Miller7b28dc52000-09-05 13:34:53 +1100227}
228
Ben Lindstrombba81212001-06-25 05:01:22 +0000229static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100230handle_is_ok(int i, int type)
231{
Damien Miller3397d0e2008-02-10 22:26:51 +1100232 return i >= 0 && (u_int)i < num_handles && handles[i].use == type;
Damien Miller7b28dc52000-09-05 13:34:53 +1100233}
234
Ben Lindstrombba81212001-06-25 05:01:22 +0000235static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100236handle_to_string(int handle, char **stringp, int *hlenp)
237{
Damien Miller7b28dc52000-09-05 13:34:53 +1100238 if (stringp == NULL || hlenp == NULL)
239 return -1;
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000240 *stringp = xmalloc(sizeof(int32_t));
Damien Miller3f941882006-03-31 23:13:02 +1100241 put_u32(*stringp, handle);
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000242 *hlenp = sizeof(int32_t);
Damien Miller7b28dc52000-09-05 13:34:53 +1100243 return 0;
244}
245
Ben Lindstrombba81212001-06-25 05:01:22 +0000246static int
Damien Millerf58b58c2003-11-17 21:18:23 +1100247handle_from_string(const char *handle, u_int hlen)
Damien Miller7b28dc52000-09-05 13:34:53 +1100248{
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000249 int val;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000250
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000251 if (hlen != sizeof(int32_t))
Damien Miller7b28dc52000-09-05 13:34:53 +1100252 return -1;
Damien Miller3f941882006-03-31 23:13:02 +1100253 val = get_u32(handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100254 if (handle_is_ok(val, HANDLE_FILE) ||
255 handle_is_ok(val, HANDLE_DIR))
256 return val;
257 return -1;
258}
259
Ben Lindstrombba81212001-06-25 05:01:22 +0000260static char *
Damien Miller7b28dc52000-09-05 13:34:53 +1100261handle_to_name(int handle)
262{
263 if (handle_is_ok(handle, HANDLE_DIR)||
264 handle_is_ok(handle, HANDLE_FILE))
265 return handles[handle].name;
266 return NULL;
267}
268
Ben Lindstrombba81212001-06-25 05:01:22 +0000269static DIR *
Damien Miller7b28dc52000-09-05 13:34:53 +1100270handle_to_dir(int handle)
271{
272 if (handle_is_ok(handle, HANDLE_DIR))
273 return handles[handle].dirp;
274 return NULL;
275}
276
Ben Lindstrombba81212001-06-25 05:01:22 +0000277static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100278handle_to_fd(int handle)
279{
Kevin Stevesef4eea92001-02-05 12:42:17 +0000280 if (handle_is_ok(handle, HANDLE_FILE))
Damien Miller7b28dc52000-09-05 13:34:53 +1100281 return handles[handle].fd;
282 return -1;
283}
284
Damien Millerfef95ad2006-07-10 20:46:55 +1000285static void
286handle_update_read(int handle, ssize_t bytes)
287{
288 if (handle_is_ok(handle, HANDLE_FILE) && bytes > 0)
289 handles[handle].bytes_read += bytes;
290}
291
292static void
293handle_update_write(int handle, ssize_t bytes)
294{
295 if (handle_is_ok(handle, HANDLE_FILE) && bytes > 0)
296 handles[handle].bytes_write += bytes;
297}
298
299static u_int64_t
300handle_bytes_read(int handle)
301{
302 if (handle_is_ok(handle, HANDLE_FILE))
303 return (handles[handle].bytes_read);
304 return 0;
305}
306
307static u_int64_t
308handle_bytes_write(int handle)
309{
310 if (handle_is_ok(handle, HANDLE_FILE))
311 return (handles[handle].bytes_write);
312 return 0;
313}
314
Ben Lindstrombba81212001-06-25 05:01:22 +0000315static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100316handle_close(int handle)
317{
318 int ret = -1;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000319
Damien Miller7b28dc52000-09-05 13:34:53 +1100320 if (handle_is_ok(handle, HANDLE_FILE)) {
321 ret = close(handles[handle].fd);
Damien Miller00111382003-03-10 11:21:17 +1100322 xfree(handles[handle].name);
Damien Miller3397d0e2008-02-10 22:26:51 +1100323 handle_unused(handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100324 } else if (handle_is_ok(handle, HANDLE_DIR)) {
325 ret = closedir(handles[handle].dirp);
Damien Miller00111382003-03-10 11:21:17 +1100326 xfree(handles[handle].name);
Damien Miller3397d0e2008-02-10 22:26:51 +1100327 handle_unused(handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100328 } else {
329 errno = ENOENT;
330 }
331 return ret;
332}
333
Damien Millerfef95ad2006-07-10 20:46:55 +1000334static void
335handle_log_close(int handle, char *emsg)
336{
337 if (handle_is_ok(handle, HANDLE_FILE)) {
338 logit("%s%sclose \"%s\" bytes read %llu written %llu",
339 emsg == NULL ? "" : emsg, emsg == NULL ? "" : " ",
340 handle_to_name(handle),
Darren Tucker86473c52007-05-20 14:59:32 +1000341 (unsigned long long)handle_bytes_read(handle),
342 (unsigned long long)handle_bytes_write(handle));
Damien Millerfef95ad2006-07-10 20:46:55 +1000343 } else {
344 logit("%s%sclosedir \"%s\"",
345 emsg == NULL ? "" : emsg, emsg == NULL ? "" : " ",
346 handle_to_name(handle));
347 }
348}
349
350static void
351handle_log_exit(void)
352{
353 u_int i;
354
Damien Miller3397d0e2008-02-10 22:26:51 +1100355 for (i = 0; i < num_handles; i++)
Damien Millerfef95ad2006-07-10 20:46:55 +1000356 if (handles[i].use != HANDLE_UNUSED)
357 handle_log_close(i, "forced");
358}
359
Ben Lindstrombba81212001-06-25 05:01:22 +0000360static int
Damien Miller7b28dc52000-09-05 13:34:53 +1100361get_handle(void)
362{
363 char *handle;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000364 int val = -1;
Damien Millere4340be2000-09-16 13:29:08 +1100365 u_int hlen;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000366
Damien Miller7b28dc52000-09-05 13:34:53 +1100367 handle = get_string(&hlen);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000368 if (hlen < 256)
369 val = handle_from_string(handle, hlen);
Damien Miller7b28dc52000-09-05 13:34:53 +1100370 xfree(handle);
371 return val;
372}
373
374/* send replies */
375
Ben Lindstrombba81212001-06-25 05:01:22 +0000376static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100377send_msg(Buffer *m)
378{
379 int mlen = buffer_len(m);
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000380
Damien Miller7b28dc52000-09-05 13:34:53 +1100381 buffer_put_int(&oqueue, mlen);
382 buffer_append(&oqueue, buffer_ptr(m), mlen);
383 buffer_consume(m, mlen);
384}
385
Damien Millerfef95ad2006-07-10 20:46:55 +1000386static const char *
387status_to_message(u_int32_t status)
Damien Miller7b28dc52000-09-05 13:34:53 +1100388{
Damien Miller058316f2001-03-08 10:08:49 +1100389 const char *status_messages[] = {
390 "Success", /* SSH_FX_OK */
391 "End of file", /* SSH_FX_EOF */
392 "No such file", /* SSH_FX_NO_SUCH_FILE */
393 "Permission denied", /* SSH_FX_PERMISSION_DENIED */
394 "Failure", /* SSH_FX_FAILURE */
395 "Bad message", /* SSH_FX_BAD_MESSAGE */
396 "No connection", /* SSH_FX_NO_CONNECTION */
397 "Connection lost", /* SSH_FX_CONNECTION_LOST */
398 "Operation unsupported", /* SSH_FX_OP_UNSUPPORTED */
399 "Unknown error" /* Others */
400 };
Damien Millerfef95ad2006-07-10 20:46:55 +1000401 return (status_messages[MIN(status,SSH2_FX_MAX)]);
402}
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000403
Damien Millerfef95ad2006-07-10 20:46:55 +1000404static void
405send_status(u_int32_t id, u_int32_t status)
406{
407 Buffer msg;
408
409 debug3("request %u: sent status %u", id, status);
410 if (log_level > SYSLOG_LEVEL_VERBOSE ||
411 (status != SSH2_FX_OK && status != SSH2_FX_EOF))
412 logit("sent status %s", status_to_message(status));
Damien Miller7b28dc52000-09-05 13:34:53 +1100413 buffer_init(&msg);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000414 buffer_put_char(&msg, SSH2_FXP_STATUS);
Damien Miller7b28dc52000-09-05 13:34:53 +1100415 buffer_put_int(&msg, id);
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000416 buffer_put_int(&msg, status);
Damien Miller058316f2001-03-08 10:08:49 +1100417 if (version >= 3) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000418 buffer_put_cstring(&msg, status_to_message(status));
Damien Miller058316f2001-03-08 10:08:49 +1100419 buffer_put_cstring(&msg, "");
420 }
Damien Miller7b28dc52000-09-05 13:34:53 +1100421 send_msg(&msg);
422 buffer_free(&msg);
423}
Ben Lindstrombba81212001-06-25 05:01:22 +0000424static void
Damien Millerf58b58c2003-11-17 21:18:23 +1100425send_data_or_handle(char type, u_int32_t id, const char *data, int dlen)
Damien Miller7b28dc52000-09-05 13:34:53 +1100426{
427 Buffer msg;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000428
Damien Miller7b28dc52000-09-05 13:34:53 +1100429 buffer_init(&msg);
430 buffer_put_char(&msg, type);
431 buffer_put_int(&msg, id);
432 buffer_put_string(&msg, data, dlen);
433 send_msg(&msg);
434 buffer_free(&msg);
435}
436
Ben Lindstrombba81212001-06-25 05:01:22 +0000437static void
Damien Millerf58b58c2003-11-17 21:18:23 +1100438send_data(u_int32_t id, const char *data, int dlen)
Damien Miller7b28dc52000-09-05 13:34:53 +1100439{
Damien Millerfef95ad2006-07-10 20:46:55 +1000440 debug("request %u: sent data len %d", id, dlen);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000441 send_data_or_handle(SSH2_FXP_DATA, id, data, dlen);
Damien Miller7b28dc52000-09-05 13:34:53 +1100442}
443
Ben Lindstrombba81212001-06-25 05:01:22 +0000444static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100445send_handle(u_int32_t id, int handle)
446{
447 char *string;
448 int hlen;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000449
Damien Miller7b28dc52000-09-05 13:34:53 +1100450 handle_to_string(handle, &string, &hlen);
Damien Millerfef95ad2006-07-10 20:46:55 +1000451 debug("request %u: sent handle handle %d", id, handle);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000452 send_data_or_handle(SSH2_FXP_HANDLE, id, string, hlen);
Damien Miller7b28dc52000-09-05 13:34:53 +1100453 xfree(string);
454}
455
Ben Lindstrombba81212001-06-25 05:01:22 +0000456static void
Damien Millerf58b58c2003-11-17 21:18:23 +1100457send_names(u_int32_t id, int count, const Stat *stats)
Damien Miller7b28dc52000-09-05 13:34:53 +1100458{
459 Buffer msg;
460 int i;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000461
Damien Miller7b28dc52000-09-05 13:34:53 +1100462 buffer_init(&msg);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000463 buffer_put_char(&msg, SSH2_FXP_NAME);
Damien Miller7b28dc52000-09-05 13:34:53 +1100464 buffer_put_int(&msg, id);
465 buffer_put_int(&msg, count);
Damien Millerfef95ad2006-07-10 20:46:55 +1000466 debug("request %u: sent names count %d", id, count);
Damien Miller7b28dc52000-09-05 13:34:53 +1100467 for (i = 0; i < count; i++) {
468 buffer_put_cstring(&msg, stats[i].name);
469 buffer_put_cstring(&msg, stats[i].long_name);
470 encode_attrib(&msg, &stats[i].attrib);
471 }
472 send_msg(&msg);
473 buffer_free(&msg);
474}
475
Ben Lindstrombba81212001-06-25 05:01:22 +0000476static void
Damien Millerf58b58c2003-11-17 21:18:23 +1100477send_attrib(u_int32_t id, const Attrib *a)
Damien Miller7b28dc52000-09-05 13:34:53 +1100478{
479 Buffer msg;
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000480
Damien Millerfef95ad2006-07-10 20:46:55 +1000481 debug("request %u: sent attrib have 0x%x", id, a->flags);
Damien Miller7b28dc52000-09-05 13:34:53 +1100482 buffer_init(&msg);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000483 buffer_put_char(&msg, SSH2_FXP_ATTRS);
Damien Miller7b28dc52000-09-05 13:34:53 +1100484 buffer_put_int(&msg, id);
485 encode_attrib(&msg, a);
486 send_msg(&msg);
487 buffer_free(&msg);
488}
489
Damien Millerd671e5a2008-05-19 14:53:33 +1000490static void
491send_statvfs(u_int32_t id, struct statvfs *st)
492{
493 Buffer msg;
494 u_int64_t flag;
495
496 flag = (st->f_flag & ST_RDONLY) ? SSH2_FXE_STATVFS_ST_RDONLY : 0;
497 flag |= (st->f_flag & ST_NOSUID) ? SSH2_FXE_STATVFS_ST_NOSUID : 0;
498
499 buffer_init(&msg);
500 buffer_put_char(&msg, SSH2_FXP_EXTENDED_REPLY);
501 buffer_put_int(&msg, id);
Darren Tucker3463aca2008-06-09 23:06:55 +1000502 buffer_put_int64(&msg, st->f_bsize);
503 buffer_put_int64(&msg, st->f_frsize);
Damien Millerd671e5a2008-05-19 14:53:33 +1000504 buffer_put_int64(&msg, st->f_blocks);
505 buffer_put_int64(&msg, st->f_bfree);
506 buffer_put_int64(&msg, st->f_bavail);
507 buffer_put_int64(&msg, st->f_files);
508 buffer_put_int64(&msg, st->f_ffree);
509 buffer_put_int64(&msg, st->f_favail);
Darren Tucker77001382008-06-09 06:17:53 +1000510 buffer_put_int64(&msg, FSID_TO_ULONG(st->f_fsid));
Darren Tucker3463aca2008-06-09 23:06:55 +1000511 buffer_put_int64(&msg, flag);
512 buffer_put_int64(&msg, st->f_namemax);
Damien Millerd671e5a2008-05-19 14:53:33 +1000513 send_msg(&msg);
514 buffer_free(&msg);
515}
516
Damien Miller7b28dc52000-09-05 13:34:53 +1100517/* parse incoming */
518
Ben Lindstrombba81212001-06-25 05:01:22 +0000519static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100520process_init(void)
521{
522 Buffer msg;
Damien Miller7b28dc52000-09-05 13:34:53 +1100523
Ben Lindstrom937df1d2002-06-06 21:58:35 +0000524 version = get_int();
Damien Millerfef95ad2006-07-10 20:46:55 +1000525 verbose("received client version %d", version);
Damien Miller7b28dc52000-09-05 13:34:53 +1100526 buffer_init(&msg);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000527 buffer_put_char(&msg, SSH2_FXP_VERSION);
528 buffer_put_int(&msg, SSH2_FILEXFER_VERSION);
Damien Miller7c296612008-03-07 18:33:53 +1100529 /* POSIX rename extension */
530 buffer_put_cstring(&msg, "posix-rename@openssh.com");
531 buffer_put_cstring(&msg, "1"); /* version */
Damien Millera7e0d5a2008-05-19 16:08:41 +1000532 /* statvfs extension */
Damien Millerd671e5a2008-05-19 14:53:33 +1000533 buffer_put_cstring(&msg, "statvfs@openssh.com");
Darren Tucker294b8412008-06-08 12:57:08 +1000534 buffer_put_cstring(&msg, "2"); /* version */
Damien Millera7e0d5a2008-05-19 16:08:41 +1000535 /* fstatvfs extension */
Damien Millerd671e5a2008-05-19 14:53:33 +1000536 buffer_put_cstring(&msg, "fstatvfs@openssh.com");
Darren Tucker294b8412008-06-08 12:57:08 +1000537 buffer_put_cstring(&msg, "2"); /* version */
Damien Miller7b28dc52000-09-05 13:34:53 +1100538 send_msg(&msg);
539 buffer_free(&msg);
540}
541
Ben Lindstrombba81212001-06-25 05:01:22 +0000542static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100543process_open(void)
544{
545 u_int32_t id, pflags;
546 Attrib *a;
547 char *name;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000548 int handle, fd, flags, mode, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100549
550 id = get_int();
551 name = get_string(NULL);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000552 pflags = get_int(); /* portable flags */
Damien Miller6444fe92006-07-10 21:31:27 +1000553 debug3("request %u: open flags %d", id, pflags);
Damien Miller7b28dc52000-09-05 13:34:53 +1100554 a = get_attrib();
555 flags = flags_from_portable(pflags);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000556 mode = (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ? a->perm : 0666;
Damien Millerfef95ad2006-07-10 20:46:55 +1000557 logit("open \"%s\" flags %s mode 0%o",
558 name, string_from_portable(pflags), mode);
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100559 if (readonly &&
560 ((flags & O_ACCMODE) == O_WRONLY || (flags & O_ACCMODE) == O_RDWR))
561 status = SSH2_FX_PERMISSION_DENIED;
562 else {
563 fd = open(name, flags, mode);
564 if (fd < 0) {
565 status = errno_to_portable(errno);
Damien Miller7b28dc52000-09-05 13:34:53 +1100566 } else {
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100567 handle = handle_new(HANDLE_FILE, name, fd, NULL);
568 if (handle < 0) {
569 close(fd);
570 } else {
571 send_handle(id, handle);
572 status = SSH2_FX_OK;
573 }
Damien Miller7b28dc52000-09-05 13:34:53 +1100574 }
575 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000576 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100577 send_status(id, status);
578 xfree(name);
579}
580
Ben Lindstrombba81212001-06-25 05:01:22 +0000581static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100582process_close(void)
583{
584 u_int32_t id;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000585 int handle, ret, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100586
587 id = get_int();
588 handle = get_handle();
Damien Millerfef95ad2006-07-10 20:46:55 +1000589 debug3("request %u: close handle %u", id, handle);
590 handle_log_close(handle, NULL);
Damien Miller7b28dc52000-09-05 13:34:53 +1100591 ret = handle_close(handle);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000592 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100593 send_status(id, status);
594}
595
Ben Lindstrombba81212001-06-25 05:01:22 +0000596static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100597process_read(void)
598{
599 char buf[64*1024];
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000600 u_int32_t id, len;
601 int handle, fd, ret, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100602 u_int64_t off;
603
604 id = get_int();
605 handle = get_handle();
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000606 off = get_int64();
Damien Miller7b28dc52000-09-05 13:34:53 +1100607 len = get_int();
608
Damien Millerfef95ad2006-07-10 20:46:55 +1000609 debug("request %u: read \"%s\" (handle %d) off %llu len %d",
610 id, handle_to_name(handle), handle, (unsigned long long)off, len);
Damien Miller7b28dc52000-09-05 13:34:53 +1100611 if (len > sizeof buf) {
612 len = sizeof buf;
Damien Millerfef95ad2006-07-10 20:46:55 +1000613 debug2("read change len %d", len);
Damien Miller7b28dc52000-09-05 13:34:53 +1100614 }
615 fd = handle_to_fd(handle);
616 if (fd >= 0) {
617 if (lseek(fd, off, SEEK_SET) < 0) {
618 error("process_read: seek failed");
619 status = errno_to_portable(errno);
620 } else {
621 ret = read(fd, buf, len);
622 if (ret < 0) {
623 status = errno_to_portable(errno);
624 } else if (ret == 0) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000625 status = SSH2_FX_EOF;
Damien Miller7b28dc52000-09-05 13:34:53 +1100626 } else {
627 send_data(id, buf, ret);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000628 status = SSH2_FX_OK;
Damien Millerfef95ad2006-07-10 20:46:55 +1000629 handle_update_read(handle, ret);
Damien Miller7b28dc52000-09-05 13:34:53 +1100630 }
631 }
632 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000633 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100634 send_status(id, status);
635}
636
Ben Lindstrombba81212001-06-25 05:01:22 +0000637static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100638process_write(void)
639{
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000640 u_int32_t id;
Damien Miller7b28dc52000-09-05 13:34:53 +1100641 u_int64_t off;
Damien Millere4340be2000-09-16 13:29:08 +1100642 u_int len;
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100643 int handle, fd, ret, status;
Damien Miller7b28dc52000-09-05 13:34:53 +1100644 char *data;
645
646 id = get_int();
647 handle = get_handle();
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000648 off = get_int64();
Damien Miller7b28dc52000-09-05 13:34:53 +1100649 data = get_string(&len);
650
Damien Millerfef95ad2006-07-10 20:46:55 +1000651 debug("request %u: write \"%s\" (handle %d) off %llu len %d",
652 id, handle_to_name(handle), handle, (unsigned long long)off, len);
Damien Miller7b28dc52000-09-05 13:34:53 +1100653 fd = handle_to_fd(handle);
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100654
655 if (fd < 0)
656 status = SSH2_FX_FAILURE;
657 else if (readonly)
658 status = SSH2_FX_PERMISSION_DENIED;
659 else {
Damien Miller7b28dc52000-09-05 13:34:53 +1100660 if (lseek(fd, off, SEEK_SET) < 0) {
661 status = errno_to_portable(errno);
662 error("process_write: seek failed");
663 } else {
664/* XXX ATOMICIO ? */
665 ret = write(fd, data, len);
Damien Millereccb9de2005-06-17 12:59:34 +1000666 if (ret < 0) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100667 error("process_write: write failed");
668 status = errno_to_portable(errno);
Damien Millereccb9de2005-06-17 12:59:34 +1000669 } else if ((size_t)ret == len) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000670 status = SSH2_FX_OK;
Damien Millerfef95ad2006-07-10 20:46:55 +1000671 handle_update_write(handle, ret);
Damien Miller7b28dc52000-09-05 13:34:53 +1100672 } else {
Damien Millerfef95ad2006-07-10 20:46:55 +1000673 debug2("nothing at all written");
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100674 status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100675 }
676 }
677 }
678 send_status(id, status);
679 xfree(data);
680}
681
Ben Lindstrombba81212001-06-25 05:01:22 +0000682static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100683process_do_stat(int do_lstat)
684{
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000685 Attrib a;
Damien Miller7b28dc52000-09-05 13:34:53 +1100686 struct stat st;
687 u_int32_t id;
688 char *name;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000689 int ret, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100690
691 id = get_int();
692 name = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +1000693 debug3("request %u: %sstat", id, do_lstat ? "l" : "");
694 verbose("%sstat name \"%s\"", do_lstat ? "l" : "", name);
Damien Miller7b28dc52000-09-05 13:34:53 +1100695 ret = do_lstat ? lstat(name, &st) : stat(name, &st);
696 if (ret < 0) {
697 status = errno_to_portable(errno);
698 } else {
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000699 stat_to_attrib(&st, &a);
700 send_attrib(id, &a);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000701 status = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100702 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000703 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100704 send_status(id, status);
705 xfree(name);
706}
707
Ben Lindstrombba81212001-06-25 05:01:22 +0000708static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100709process_stat(void)
710{
711 process_do_stat(0);
712}
713
Ben Lindstrombba81212001-06-25 05:01:22 +0000714static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100715process_lstat(void)
716{
717 process_do_stat(1);
718}
719
Ben Lindstrombba81212001-06-25 05:01:22 +0000720static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100721process_fstat(void)
722{
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000723 Attrib a;
Damien Miller7b28dc52000-09-05 13:34:53 +1100724 struct stat st;
725 u_int32_t id;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000726 int fd, ret, handle, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100727
728 id = get_int();
729 handle = get_handle();
Damien Millerfef95ad2006-07-10 20:46:55 +1000730 debug("request %u: fstat \"%s\" (handle %u)",
731 id, handle_to_name(handle), handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100732 fd = handle_to_fd(handle);
Damien Millere2334d62007-01-05 16:31:02 +1100733 if (fd >= 0) {
Damien Miller7b28dc52000-09-05 13:34:53 +1100734 ret = fstat(fd, &st);
735 if (ret < 0) {
736 status = errno_to_portable(errno);
737 } else {
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000738 stat_to_attrib(&st, &a);
739 send_attrib(id, &a);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000740 status = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100741 }
742 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000743 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100744 send_status(id, status);
745}
746
Ben Lindstrombba81212001-06-25 05:01:22 +0000747static struct timeval *
Damien Millerf58b58c2003-11-17 21:18:23 +1100748attrib_to_tv(const Attrib *a)
Damien Miller7b28dc52000-09-05 13:34:53 +1100749{
750 static struct timeval tv[2];
Ben Lindstrom1addabd2001-03-05 07:09:11 +0000751
Damien Miller7b28dc52000-09-05 13:34:53 +1100752 tv[0].tv_sec = a->atime;
753 tv[0].tv_usec = 0;
754 tv[1].tv_sec = a->mtime;
755 tv[1].tv_usec = 0;
756 return tv;
757}
758
Ben Lindstrombba81212001-06-25 05:01:22 +0000759static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100760process_setstat(void)
761{
762 Attrib *a;
763 u_int32_t id;
764 char *name;
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000765 int status = SSH2_FX_OK, ret;
Damien Miller7b28dc52000-09-05 13:34:53 +1100766
767 id = get_int();
768 name = get_string(NULL);
769 a = get_attrib();
Damien Millerfef95ad2006-07-10 20:46:55 +1000770 debug("request %u: setstat name \"%s\"", id, name);
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100771 if (readonly) {
772 status = SSH2_FX_PERMISSION_DENIED;
773 a->flags = 0;
774 }
Damien Miller00c92172002-02-13 14:05:00 +1100775 if (a->flags & SSH2_FILEXFER_ATTR_SIZE) {
Darren Tucker86473c52007-05-20 14:59:32 +1000776 logit("set \"%s\" size %llu",
777 name, (unsigned long long)a->size);
Damien Miller00c92172002-02-13 14:05:00 +1100778 ret = truncate(name, a->size);
779 if (ret == -1)
780 status = errno_to_portable(errno);
781 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000782 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000783 logit("set \"%s\" mode %04o", name, a->perm);
Damien Miller9e720282008-06-29 22:46:35 +1000784 ret = chmod(name, a->perm & 07777);
Damien Miller7b28dc52000-09-05 13:34:53 +1100785 if (ret == -1)
786 status = errno_to_portable(errno);
787 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000788 if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000789 char buf[64];
790 time_t t = a->mtime;
791
792 strftime(buf, sizeof(buf), "%Y%m%d-%H:%M:%S",
793 localtime(&t));
794 logit("set \"%s\" modtime %s", name, buf);
Damien Miller7b28dc52000-09-05 13:34:53 +1100795 ret = utimes(name, attrib_to_tv(a));
796 if (ret == -1)
797 status = errno_to_portable(errno);
798 }
Kevin Steves8e743932001-02-05 13:24:35 +0000799 if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000800 logit("set \"%s\" owner %lu group %lu", name,
801 (u_long)a->uid, (u_long)a->gid);
Kevin Steves8e743932001-02-05 13:24:35 +0000802 ret = chown(name, a->uid, a->gid);
803 if (ret == -1)
804 status = errno_to_portable(errno);
805 }
Damien Miller7b28dc52000-09-05 13:34:53 +1100806 send_status(id, status);
807 xfree(name);
808}
809
Ben Lindstrombba81212001-06-25 05:01:22 +0000810static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100811process_fsetstat(void)
812{
813 Attrib *a;
814 u_int32_t id;
815 int handle, fd, ret;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000816 int status = SSH2_FX_OK;
Kevin Stevesf7ffab32001-01-24 20:11:06 +0000817
Damien Miller7b28dc52000-09-05 13:34:53 +1100818 id = get_int();
819 handle = get_handle();
820 a = get_attrib();
Damien Millerfef95ad2006-07-10 20:46:55 +1000821 debug("request %u: fsetstat handle %d", id, handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100822 fd = handle_to_fd(handle);
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100823 if (fd < 0)
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000824 status = SSH2_FX_FAILURE;
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100825 else if (readonly)
826 status = SSH2_FX_PERMISSION_DENIED;
827 else {
Damien Millerfef95ad2006-07-10 20:46:55 +1000828 char *name = handle_to_name(handle);
829
Damien Miller00c92172002-02-13 14:05:00 +1100830 if (a->flags & SSH2_FILEXFER_ATTR_SIZE) {
Darren Tucker86473c52007-05-20 14:59:32 +1000831 logit("set \"%s\" size %llu",
832 name, (unsigned long long)a->size);
Damien Miller00c92172002-02-13 14:05:00 +1100833 ret = ftruncate(fd, a->size);
834 if (ret == -1)
835 status = errno_to_portable(errno);
836 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000837 if (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000838 logit("set \"%s\" mode %04o", name, a->perm);
Ben Lindstrom200e3c92001-01-15 01:56:46 +0000839#ifdef HAVE_FCHMOD
Damien Miller9e720282008-06-29 22:46:35 +1000840 ret = fchmod(fd, a->perm & 07777);
Ben Lindstrom200e3c92001-01-15 01:56:46 +0000841#else
Damien Miller9e720282008-06-29 22:46:35 +1000842 ret = chmod(name, a->perm & 07777);
Ben Lindstrom200e3c92001-01-15 01:56:46 +0000843#endif
Damien Miller7b28dc52000-09-05 13:34:53 +1100844 if (ret == -1)
845 status = errno_to_portable(errno);
846 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000847 if (a->flags & SSH2_FILEXFER_ATTR_ACMODTIME) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000848 char buf[64];
849 time_t t = a->mtime;
850
851 strftime(buf, sizeof(buf), "%Y%m%d-%H:%M:%S",
852 localtime(&t));
853 logit("set \"%s\" modtime %s", name, buf);
Damien Miller7b28dc52000-09-05 13:34:53 +1100854#ifdef HAVE_FUTIMES
855 ret = futimes(fd, attrib_to_tv(a));
856#else
857 ret = utimes(name, attrib_to_tv(a));
858#endif
859 if (ret == -1)
860 status = errno_to_portable(errno);
861 }
Kevin Steves8e743932001-02-05 13:24:35 +0000862 if (a->flags & SSH2_FILEXFER_ATTR_UIDGID) {
Damien Millerfef95ad2006-07-10 20:46:55 +1000863 logit("set \"%s\" owner %lu group %lu", name,
864 (u_long)a->uid, (u_long)a->gid);
Ben Lindstrom34bb0c72001-02-13 02:40:56 +0000865#ifdef HAVE_FCHOWN
Kevin Steves8e743932001-02-05 13:24:35 +0000866 ret = fchown(fd, a->uid, a->gid);
Ben Lindstrom34bb0c72001-02-13 02:40:56 +0000867#else
868 ret = chown(name, a->uid, a->gid);
869#endif
Kevin Steves8e743932001-02-05 13:24:35 +0000870 if (ret == -1)
871 status = errno_to_portable(errno);
872 }
Damien Miller7b28dc52000-09-05 13:34:53 +1100873 }
874 send_status(id, status);
875}
876
Ben Lindstrombba81212001-06-25 05:01:22 +0000877static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100878process_opendir(void)
879{
880 DIR *dirp = NULL;
881 char *path;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000882 int handle, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100883 u_int32_t id;
884
885 id = get_int();
886 path = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +1000887 debug3("request %u: opendir", id);
888 logit("opendir \"%s\"", path);
Kevin Stevesef4eea92001-02-05 12:42:17 +0000889 dirp = opendir(path);
Damien Miller7b28dc52000-09-05 13:34:53 +1100890 if (dirp == NULL) {
891 status = errno_to_portable(errno);
892 } else {
Damien Miller00111382003-03-10 11:21:17 +1100893 handle = handle_new(HANDLE_DIR, path, 0, dirp);
Damien Miller7b28dc52000-09-05 13:34:53 +1100894 if (handle < 0) {
895 closedir(dirp);
896 } else {
897 send_handle(id, handle);
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000898 status = SSH2_FX_OK;
Damien Miller7b28dc52000-09-05 13:34:53 +1100899 }
Kevin Stevesef4eea92001-02-05 12:42:17 +0000900
Damien Miller7b28dc52000-09-05 13:34:53 +1100901 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000902 if (status != SSH2_FX_OK)
Damien Miller7b28dc52000-09-05 13:34:53 +1100903 send_status(id, status);
904 xfree(path);
905}
906
Ben Lindstrombba81212001-06-25 05:01:22 +0000907static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100908process_readdir(void)
909{
910 DIR *dirp;
911 struct dirent *dp;
912 char *path;
913 int handle;
914 u_int32_t id;
915
916 id = get_int();
917 handle = get_handle();
Damien Millerfef95ad2006-07-10 20:46:55 +1000918 debug("request %u: readdir \"%s\" (handle %d)", id,
919 handle_to_name(handle), handle);
Damien Miller7b28dc52000-09-05 13:34:53 +1100920 dirp = handle_to_dir(handle);
921 path = handle_to_name(handle);
922 if (dirp == NULL || path == NULL) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000923 send_status(id, SSH2_FX_FAILURE);
Damien Miller7b28dc52000-09-05 13:34:53 +1100924 } else {
Damien Miller7b28dc52000-09-05 13:34:53 +1100925 struct stat st;
Damien Millerfef95ad2006-07-10 20:46:55 +1000926 char pathname[MAXPATHLEN];
Damien Miller7b28dc52000-09-05 13:34:53 +1100927 Stat *stats;
928 int nstats = 10, count = 0, i;
Ben Lindstromb1f483f2002-06-23 21:27:18 +0000929
Damien Miller07d86be2006-03-26 14:19:21 +1100930 stats = xcalloc(nstats, sizeof(Stat));
Damien Miller7b28dc52000-09-05 13:34:53 +1100931 while ((dp = readdir(dirp)) != NULL) {
932 if (count >= nstats) {
933 nstats *= 2;
Damien Miller36812092006-03-26 14:22:47 +1100934 stats = xrealloc(stats, nstats, sizeof(Stat));
Damien Miller7b28dc52000-09-05 13:34:53 +1100935 }
936/* XXX OVERFLOW ? */
Ben Lindstrom95148e32001-08-06 21:30:53 +0000937 snprintf(pathname, sizeof pathname, "%s%s%s", path,
938 strcmp(path, "/") ? "/" : "", dp->d_name);
Damien Miller7b28dc52000-09-05 13:34:53 +1100939 if (lstat(pathname, &st) < 0)
940 continue;
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000941 stat_to_attrib(&st, &(stats[count].attrib));
Damien Miller7b28dc52000-09-05 13:34:53 +1100942 stats[count].name = xstrdup(dp->d_name);
Darren Tucker2901e2d2010-01-13 22:44:06 +1100943 stats[count].long_name = ls_file(dp->d_name, &st, 0, 0);
Damien Miller7b28dc52000-09-05 13:34:53 +1100944 count++;
945 /* send up to 100 entries in one message */
Ben Lindstrombf555ba2001-01-18 02:04:35 +0000946 /* XXX check packet size instead */
Damien Miller7b28dc52000-09-05 13:34:53 +1100947 if (count == 100)
948 break;
949 }
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000950 if (count > 0) {
951 send_names(id, count, stats);
Damien Miller9f0f5c62001-12-21 14:45:46 +1100952 for (i = 0; i < count; i++) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000953 xfree(stats[i].name);
954 xfree(stats[i].long_name);
955 }
956 } else {
957 send_status(id, SSH2_FX_EOF);
Damien Miller7b28dc52000-09-05 13:34:53 +1100958 }
959 xfree(stats);
960 }
961}
962
Ben Lindstrombba81212001-06-25 05:01:22 +0000963static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100964process_remove(void)
965{
966 char *name;
967 u_int32_t id;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000968 int status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100969 int ret;
970
971 id = get_int();
972 name = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +1000973 debug3("request %u: remove", id);
974 logit("remove name \"%s\"", name);
Darren Tuckerdb7bf822010-01-09 22:24:33 +1100975 if (readonly)
976 status = SSH2_FX_PERMISSION_DENIED;
977 else {
978 ret = unlink(name);
979 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
980 }
Damien Miller7b28dc52000-09-05 13:34:53 +1100981 send_status(id, status);
982 xfree(name);
983}
984
Ben Lindstrombba81212001-06-25 05:01:22 +0000985static void
Damien Miller7b28dc52000-09-05 13:34:53 +1100986process_mkdir(void)
987{
988 Attrib *a;
989 u_int32_t id;
990 char *name;
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000991 int ret, mode, status = SSH2_FX_FAILURE;
Damien Miller7b28dc52000-09-05 13:34:53 +1100992
993 id = get_int();
994 name = get_string(NULL);
995 a = get_attrib();
Ben Lindstrom2f959b42001-01-11 06:20:23 +0000996 mode = (a->flags & SSH2_FILEXFER_ATTR_PERMISSIONS) ?
Damien Miller9e720282008-06-29 22:46:35 +1000997 a->perm & 07777 : 0777;
Damien Millerfef95ad2006-07-10 20:46:55 +1000998 debug3("request %u: mkdir", id);
999 logit("mkdir name \"%s\" mode 0%o", name, mode);
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001000 if (readonly)
1001 status = SSH2_FX_PERMISSION_DENIED;
1002 else {
1003 ret = mkdir(name, mode);
1004 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
1005 }
Damien Miller7b28dc52000-09-05 13:34:53 +11001006 send_status(id, status);
1007 xfree(name);
1008}
1009
Ben Lindstrombba81212001-06-25 05:01:22 +00001010static void
Damien Miller7b28dc52000-09-05 13:34:53 +11001011process_rmdir(void)
1012{
1013 u_int32_t id;
1014 char *name;
1015 int ret, status;
1016
1017 id = get_int();
1018 name = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +10001019 debug3("request %u: rmdir", id);
1020 logit("rmdir name \"%s\"", name);
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001021 if (readonly)
1022 status = SSH2_FX_PERMISSION_DENIED;
1023 else {
1024 ret = rmdir(name);
1025 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
1026 }
Damien Miller7b28dc52000-09-05 13:34:53 +11001027 send_status(id, status);
1028 xfree(name);
1029}
1030
Ben Lindstrombba81212001-06-25 05:01:22 +00001031static void
Damien Miller7b28dc52000-09-05 13:34:53 +11001032process_realpath(void)
1033{
1034 char resolvedname[MAXPATHLEN];
1035 u_int32_t id;
1036 char *path;
1037
1038 id = get_int();
1039 path = get_string(NULL);
Ben Lindstromfa1b3d02000-12-10 01:55:37 +00001040 if (path[0] == '\0') {
1041 xfree(path);
1042 path = xstrdup(".");
1043 }
Damien Millerfef95ad2006-07-10 20:46:55 +10001044 debug3("request %u: realpath", id);
1045 verbose("realpath \"%s\"", path);
Damien Miller7b28dc52000-09-05 13:34:53 +11001046 if (realpath(path, resolvedname) == NULL) {
1047 send_status(id, errno_to_portable(errno));
1048 } else {
1049 Stat s;
1050 attrib_clear(&s.attrib);
1051 s.name = s.long_name = resolvedname;
1052 send_names(id, 1, &s);
1053 }
1054 xfree(path);
1055}
1056
Ben Lindstrombba81212001-06-25 05:01:22 +00001057static void
Damien Miller7b28dc52000-09-05 13:34:53 +11001058process_rename(void)
1059{
1060 u_int32_t id;
1061 char *oldpath, *newpath;
Damien Miller9e51a732003-02-24 11:58:44 +11001062 int status;
Damien Millerb3207e82003-03-26 16:01:11 +11001063 struct stat sb;
Damien Miller7b28dc52000-09-05 13:34:53 +11001064
1065 id = get_int();
1066 oldpath = get_string(NULL);
1067 newpath = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +10001068 debug3("request %u: rename", id);
1069 logit("rename old \"%s\" new \"%s\"", oldpath, newpath);
Damien Millerb3207e82003-03-26 16:01:11 +11001070 status = SSH2_FX_FAILURE;
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001071 if (readonly)
1072 status = SSH2_FX_PERMISSION_DENIED;
1073 else if (lstat(oldpath, &sb) == -1)
Damien Miller9e51a732003-02-24 11:58:44 +11001074 status = errno_to_portable(errno);
Damien Millerb3207e82003-03-26 16:01:11 +11001075 else if (S_ISREG(sb.st_mode)) {
1076 /* Race-free rename of regular files */
Darren Tuckeraedc1d62004-06-25 17:06:02 +10001077 if (link(oldpath, newpath) == -1) {
Damien Miller0e265512009-08-28 10:43:13 +10001078 if (errno == EOPNOTSUPP || errno == ENOSYS
Darren Tuckerf7fa7062008-07-04 14:10:19 +10001079#ifdef EXDEV
1080 || errno == EXDEV
1081#endif
Darren Tuckere59b5082004-06-28 16:01:19 +10001082#ifdef LINK_OPNOTSUPP_ERRNO
1083 || errno == LINK_OPNOTSUPP_ERRNO
1084#endif
1085 ) {
Darren Tuckeraedc1d62004-06-25 17:06:02 +10001086 struct stat st;
1087
1088 /*
1089 * fs doesn't support links, so fall back to
1090 * stat+rename. This is racy.
1091 */
1092 if (stat(newpath, &st) == -1) {
1093 if (rename(oldpath, newpath) == -1)
1094 status =
1095 errno_to_portable(errno);
1096 else
1097 status = SSH2_FX_OK;
1098 }
1099 } else {
1100 status = errno_to_portable(errno);
1101 }
1102 } else if (unlink(oldpath) == -1) {
Damien Millerb3207e82003-03-26 16:01:11 +11001103 status = errno_to_portable(errno);
1104 /* clean spare link */
1105 unlink(newpath);
1106 } else
1107 status = SSH2_FX_OK;
1108 } else if (stat(newpath, &sb) == -1) {
1109 if (rename(oldpath, newpath) == -1)
1110 status = errno_to_portable(errno);
1111 else
1112 status = SSH2_FX_OK;
1113 }
Damien Miller7b28dc52000-09-05 13:34:53 +11001114 send_status(id, status);
1115 xfree(oldpath);
1116 xfree(newpath);
1117}
1118
Ben Lindstrombba81212001-06-25 05:01:22 +00001119static void
Damien Miller058316f2001-03-08 10:08:49 +11001120process_readlink(void)
1121{
1122 u_int32_t id;
Ben Lindstromabbb73d2001-05-17 03:14:57 +00001123 int len;
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001124 char buf[MAXPATHLEN];
Damien Miller058316f2001-03-08 10:08:49 +11001125 char *path;
1126
1127 id = get_int();
1128 path = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +10001129 debug3("request %u: readlink", id);
1130 verbose("readlink \"%s\"", path);
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001131 if ((len = readlink(path, buf, sizeof(buf) - 1)) == -1)
Damien Miller058316f2001-03-08 10:08:49 +11001132 send_status(id, errno_to_portable(errno));
1133 else {
1134 Stat s;
Damien Miller9f0f5c62001-12-21 14:45:46 +11001135
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001136 buf[len] = '\0';
Damien Miller058316f2001-03-08 10:08:49 +11001137 attrib_clear(&s.attrib);
Darren Tucker3f9fdc72004-06-22 12:56:01 +10001138 s.name = s.long_name = buf;
Damien Miller058316f2001-03-08 10:08:49 +11001139 send_names(id, 1, &s);
1140 }
1141 xfree(path);
1142}
1143
Ben Lindstrombba81212001-06-25 05:01:22 +00001144static void
Damien Miller058316f2001-03-08 10:08:49 +11001145process_symlink(void)
1146{
1147 u_int32_t id;
Damien Miller058316f2001-03-08 10:08:49 +11001148 char *oldpath, *newpath;
Damien Miller9e51a732003-02-24 11:58:44 +11001149 int ret, status;
Damien Miller058316f2001-03-08 10:08:49 +11001150
1151 id = get_int();
1152 oldpath = get_string(NULL);
1153 newpath = get_string(NULL);
Damien Millerfef95ad2006-07-10 20:46:55 +10001154 debug3("request %u: symlink", id);
1155 logit("symlink old \"%s\" new \"%s\"", oldpath, newpath);
Damien Miller9e51a732003-02-24 11:58:44 +11001156 /* this will fail if 'newpath' exists */
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001157 if (readonly)
1158 status = SSH2_FX_PERMISSION_DENIED;
1159 else {
1160 ret = symlink(oldpath, newpath);
1161 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
1162 }
Damien Miller058316f2001-03-08 10:08:49 +11001163 send_status(id, status);
1164 xfree(oldpath);
1165 xfree(newpath);
1166}
1167
Ben Lindstrombba81212001-06-25 05:01:22 +00001168static void
Damien Miller7c296612008-03-07 18:33:53 +11001169process_extended_posix_rename(u_int32_t id)
1170{
1171 char *oldpath, *newpath;
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001172 int ret, status;
Damien Miller7c296612008-03-07 18:33:53 +11001173
1174 oldpath = get_string(NULL);
1175 newpath = get_string(NULL);
1176 debug3("request %u: posix-rename", id);
1177 logit("posix-rename old \"%s\" new \"%s\"", oldpath, newpath);
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001178 if (readonly)
1179 status = SSH2_FX_PERMISSION_DENIED;
1180 else {
1181 ret = rename(oldpath, newpath);
1182 status = (ret == -1) ? errno_to_portable(errno) : SSH2_FX_OK;
1183 }
1184 send_status(id, status);
Damien Miller7c296612008-03-07 18:33:53 +11001185 xfree(oldpath);
1186 xfree(newpath);
1187}
1188
1189static void
Damien Millerd671e5a2008-05-19 14:53:33 +10001190process_extended_statvfs(u_int32_t id)
1191{
1192 char *path;
1193 struct statvfs st;
1194
1195 path = get_string(NULL);
1196 debug3("request %u: statfs", id);
1197 logit("statfs \"%s\"", path);
1198
1199 if (statvfs(path, &st) != 0)
1200 send_status(id, errno_to_portable(errno));
1201 else
1202 send_statvfs(id, &st);
1203 xfree(path);
1204}
1205
1206static void
1207process_extended_fstatvfs(u_int32_t id)
1208{
1209 int handle, fd;
1210 struct statvfs st;
1211
1212 handle = get_handle();
1213 debug("request %u: fstatvfs \"%s\" (handle %u)",
1214 id, handle_to_name(handle), handle);
1215 if ((fd = handle_to_fd(handle)) < 0) {
1216 send_status(id, SSH2_FX_FAILURE);
1217 return;
1218 }
1219 if (fstatvfs(fd, &st) != 0)
1220 send_status(id, errno_to_portable(errno));
1221 else
1222 send_statvfs(id, &st);
1223}
1224
1225static void
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001226process_extended(void)
1227{
1228 u_int32_t id;
1229 char *request;
1230
1231 id = get_int();
1232 request = get_string(NULL);
Damien Miller7c296612008-03-07 18:33:53 +11001233 if (strcmp(request, "posix-rename@openssh.com") == 0)
1234 process_extended_posix_rename(id);
Damien Millerd671e5a2008-05-19 14:53:33 +10001235 else if (strcmp(request, "statvfs@openssh.com") == 0)
1236 process_extended_statvfs(id);
1237 else if (strcmp(request, "fstatvfs@openssh.com") == 0)
1238 process_extended_fstatvfs(id);
Damien Miller7c296612008-03-07 18:33:53 +11001239 else
1240 send_status(id, SSH2_FX_OP_UNSUPPORTED); /* MUST */
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001241 xfree(request);
1242}
Damien Miller7b28dc52000-09-05 13:34:53 +11001243
1244/* stolen from ssh-agent */
1245
Ben Lindstrombba81212001-06-25 05:01:22 +00001246static void
Damien Miller7b28dc52000-09-05 13:34:53 +11001247process(void)
1248{
Ben Lindstrom46c16222000-12-22 01:43:59 +00001249 u_int msg_len;
Ben Lindstrom2c140472002-06-06 21:57:54 +00001250 u_int buf_len;
1251 u_int consumed;
Ben Lindstrom46c16222000-12-22 01:43:59 +00001252 u_int type;
1253 u_char *cp;
Damien Miller7b28dc52000-09-05 13:34:53 +11001254
Ben Lindstrom2c140472002-06-06 21:57:54 +00001255 buf_len = buffer_len(&iqueue);
1256 if (buf_len < 5)
Damien Miller7b28dc52000-09-05 13:34:53 +11001257 return; /* Incomplete message. */
Damien Miller708d21c2002-01-22 23:18:15 +11001258 cp = buffer_ptr(&iqueue);
Damien Miller3f941882006-03-31 23:13:02 +11001259 msg_len = get_u32(cp);
Damien Miller54446182006-01-02 23:40:50 +11001260 if (msg_len > SFTP_MAX_MSG_LENGTH) {
Damien Millerfef95ad2006-07-10 20:46:55 +10001261 error("bad message from %s local user %s",
1262 client_addr, pw->pw_name);
Damien Millerdfc24252008-02-10 22:29:40 +11001263 sftp_server_cleanup_exit(11);
Damien Miller7b28dc52000-09-05 13:34:53 +11001264 }
Ben Lindstrom2c140472002-06-06 21:57:54 +00001265 if (buf_len < msg_len + 4)
Damien Miller7b28dc52000-09-05 13:34:53 +11001266 return;
1267 buffer_consume(&iqueue, 4);
Ben Lindstrom2c140472002-06-06 21:57:54 +00001268 buf_len -= 4;
Damien Miller7b28dc52000-09-05 13:34:53 +11001269 type = buffer_get_char(&iqueue);
1270 switch (type) {
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001271 case SSH2_FXP_INIT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001272 process_init();
1273 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001274 case SSH2_FXP_OPEN:
Damien Miller7b28dc52000-09-05 13:34:53 +11001275 process_open();
1276 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001277 case SSH2_FXP_CLOSE:
Damien Miller7b28dc52000-09-05 13:34:53 +11001278 process_close();
1279 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001280 case SSH2_FXP_READ:
Damien Miller7b28dc52000-09-05 13:34:53 +11001281 process_read();
1282 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001283 case SSH2_FXP_WRITE:
Damien Miller7b28dc52000-09-05 13:34:53 +11001284 process_write();
1285 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001286 case SSH2_FXP_LSTAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001287 process_lstat();
1288 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001289 case SSH2_FXP_FSTAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001290 process_fstat();
1291 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001292 case SSH2_FXP_SETSTAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001293 process_setstat();
1294 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001295 case SSH2_FXP_FSETSTAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001296 process_fsetstat();
1297 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001298 case SSH2_FXP_OPENDIR:
Damien Miller7b28dc52000-09-05 13:34:53 +11001299 process_opendir();
1300 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001301 case SSH2_FXP_READDIR:
Damien Miller7b28dc52000-09-05 13:34:53 +11001302 process_readdir();
1303 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001304 case SSH2_FXP_REMOVE:
Damien Miller7b28dc52000-09-05 13:34:53 +11001305 process_remove();
1306 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001307 case SSH2_FXP_MKDIR:
Damien Miller7b28dc52000-09-05 13:34:53 +11001308 process_mkdir();
1309 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001310 case SSH2_FXP_RMDIR:
Damien Miller7b28dc52000-09-05 13:34:53 +11001311 process_rmdir();
1312 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001313 case SSH2_FXP_REALPATH:
Damien Miller7b28dc52000-09-05 13:34:53 +11001314 process_realpath();
1315 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001316 case SSH2_FXP_STAT:
Damien Miller7b28dc52000-09-05 13:34:53 +11001317 process_stat();
1318 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001319 case SSH2_FXP_RENAME:
Damien Miller7b28dc52000-09-05 13:34:53 +11001320 process_rename();
1321 break;
Damien Miller058316f2001-03-08 10:08:49 +11001322 case SSH2_FXP_READLINK:
1323 process_readlink();
1324 break;
1325 case SSH2_FXP_SYMLINK:
1326 process_symlink();
1327 break;
Ben Lindstrom2f959b42001-01-11 06:20:23 +00001328 case SSH2_FXP_EXTENDED:
1329 process_extended();
1330 break;
Damien Miller7b28dc52000-09-05 13:34:53 +11001331 default:
1332 error("Unknown message %d", type);
1333 break;
1334 }
Ben Lindstrom2c140472002-06-06 21:57:54 +00001335 /* discard the remaining bytes from the current packet */
Damien Millerdfc24252008-02-10 22:29:40 +11001336 if (buf_len < buffer_len(&iqueue)) {
1337 error("iqueue grew unexpectedly");
1338 sftp_server_cleanup_exit(255);
1339 }
Ben Lindstrom2c140472002-06-06 21:57:54 +00001340 consumed = buf_len - buffer_len(&iqueue);
Damien Millerdfc24252008-02-10 22:29:40 +11001341 if (msg_len < consumed) {
1342 error("msg_len %d < consumed %d", msg_len, consumed);
1343 sftp_server_cleanup_exit(255);
1344 }
Ben Lindstrom2c140472002-06-06 21:57:54 +00001345 if (msg_len > consumed)
1346 buffer_consume(&iqueue, msg_len - consumed);
Damien Miller7b28dc52000-09-05 13:34:53 +11001347}
1348
Damien Millerfef95ad2006-07-10 20:46:55 +10001349/* Cleanup handler that logs active handles upon normal exit */
1350void
Damien Millerdfc24252008-02-10 22:29:40 +11001351sftp_server_cleanup_exit(int i)
Damien Millerfef95ad2006-07-10 20:46:55 +10001352{
1353 if (pw != NULL && client_addr != NULL) {
1354 handle_log_exit();
1355 logit("session closed for local user %s from [%s]",
1356 pw->pw_name, client_addr);
1357 }
1358 _exit(i);
1359}
1360
1361static void
Damien Millerdfc24252008-02-10 22:29:40 +11001362sftp_server_usage(void)
Damien Millerfef95ad2006-07-10 20:46:55 +10001363{
1364 extern char *__progname;
1365
1366 fprintf(stderr,
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001367 "usage: %s [-ehR] [-f log_facility] [-l log_level] [-u umask]\n",
Darren Tucker7dc48502009-10-07 08:44:42 +11001368 __progname);
Damien Millerfef95ad2006-07-10 20:46:55 +10001369 exit(1);
1370}
1371
Damien Miller7b28dc52000-09-05 13:34:53 +11001372int
Damien Millerd8cb1f12008-02-10 22:40:12 +11001373sftp_server_main(int argc, char **argv, struct passwd *user_pw)
Damien Miller7b28dc52000-09-05 13:34:53 +11001374{
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001375 fd_set *rset, *wset;
Damien Millerfef95ad2006-07-10 20:46:55 +10001376 int in, out, max, ch, skipargs = 0, log_stderr = 0;
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001377 ssize_t len, olen, set_size;
Damien Millerfef95ad2006-07-10 20:46:55 +10001378 SyslogFacility log_facility = SYSLOG_FACILITY_AUTH;
Darren Tuckere9405982007-05-20 15:09:04 +10001379 char *cp, buf[4*4096];
Darren Tucker7dc48502009-10-07 08:44:42 +11001380 const char *errmsg;
1381 mode_t mask;
Damien Millerfef95ad2006-07-10 20:46:55 +10001382
Damien Millerfef95ad2006-07-10 20:46:55 +10001383 extern char *optarg;
1384 extern char *__progname;
Damien Miller7b28dc52000-09-05 13:34:53 +11001385
Damien Millerfef95ad2006-07-10 20:46:55 +10001386 __progname = ssh_get_progname(argv[0]);
1387 log_init(__progname, log_level, log_facility, log_stderr);
Ben Lindstromc7f4ccd2001-03-15 00:09:15 +00001388
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001389 while (!skipargs && (ch = getopt(argc, argv, "f:l:u:cehR")) != -1) {
Damien Millerfef95ad2006-07-10 20:46:55 +10001390 switch (ch) {
Darren Tuckerdb7bf822010-01-09 22:24:33 +11001391 case 'R':
1392 readonly = 1;
1393 break;
Damien Millerfef95ad2006-07-10 20:46:55 +10001394 case 'c':
1395 /*
1396 * Ignore all arguments if we are invoked as a
Damien Millerd7834352006-08-05 12:39:39 +10001397 * shell using "sftp-server -c command"
Damien Millerfef95ad2006-07-10 20:46:55 +10001398 */
1399 skipargs = 1;
1400 break;
1401 case 'e':
1402 log_stderr = 1;
1403 break;
1404 case 'l':
1405 log_level = log_level_number(optarg);
1406 if (log_level == SYSLOG_LEVEL_NOT_SET)
1407 error("Invalid log level \"%s\"", optarg);
1408 break;
1409 case 'f':
1410 log_facility = log_facility_number(optarg);
Damien Miller35e18db2007-09-17 16:11:33 +10001411 if (log_facility == SYSLOG_FACILITY_NOT_SET)
Damien Millerfef95ad2006-07-10 20:46:55 +10001412 error("Invalid log facility \"%s\"", optarg);
1413 break;
Darren Tucker7dc48502009-10-07 08:44:42 +11001414 case 'u':
1415 mask = (mode_t)strtonum(optarg, 0, 0777, &errmsg);
Darren Tucker30359e12009-10-07 08:47:24 +11001416 if (errmsg != NULL)
Darren Tucker7dc48502009-10-07 08:44:42 +11001417 fatal("Invalid umask \"%s\": %s",
1418 optarg, errmsg);
1419 (void)umask(mask);
1420 break;
Damien Millerfef95ad2006-07-10 20:46:55 +10001421 case 'h':
1422 default:
Damien Millerdfc24252008-02-10 22:29:40 +11001423 sftp_server_usage();
Damien Millerfef95ad2006-07-10 20:46:55 +10001424 }
1425 }
1426
1427 log_init(__progname, log_level, log_facility, log_stderr);
1428
1429 if ((cp = getenv("SSH_CONNECTION")) != NULL) {
1430 client_addr = xstrdup(cp);
Damien Millerdfc24252008-02-10 22:29:40 +11001431 if ((cp = strchr(client_addr, ' ')) == NULL) {
1432 error("Malformed SSH_CONNECTION variable: \"%s\"",
Damien Millerfef95ad2006-07-10 20:46:55 +10001433 getenv("SSH_CONNECTION"));
Damien Millerdfc24252008-02-10 22:29:40 +11001434 sftp_server_cleanup_exit(255);
1435 }
Damien Millerfef95ad2006-07-10 20:46:55 +10001436 *cp = '\0';
1437 } else
1438 client_addr = xstrdup("UNKNOWN");
1439
Damien Millerd8cb1f12008-02-10 22:40:12 +11001440 pw = pwcopy(user_pw);
Damien Millerfef95ad2006-07-10 20:46:55 +10001441
1442 logit("session opened for local user %s from [%s]",
1443 pw->pw_name, client_addr);
1444
Darren Tuckeraaf51d22010-01-08 19:04:49 +11001445 in = STDIN_FILENO;
1446 out = STDOUT_FILENO;
Damien Miller7b28dc52000-09-05 13:34:53 +11001447
Damien Miller402b3312001-04-14 00:28:42 +10001448#ifdef HAVE_CYGWIN
1449 setmode(in, O_BINARY);
1450 setmode(out, O_BINARY);
1451#endif
1452
Damien Miller7b28dc52000-09-05 13:34:53 +11001453 max = 0;
1454 if (in > max)
1455 max = in;
1456 if (out > max)
1457 max = out;
1458
1459 buffer_init(&iqueue);
1460 buffer_init(&oqueue);
1461
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001462 set_size = howmany(max + 1, NFDBITS) * sizeof(fd_mask);
1463 rset = (fd_set *)xmalloc(set_size);
1464 wset = (fd_set *)xmalloc(set_size);
Damien Miller7b28dc52000-09-05 13:34:53 +11001465
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001466 for (;;) {
1467 memset(rset, 0, set_size);
1468 memset(wset, 0, set_size);
1469
Darren Tuckere9405982007-05-20 15:09:04 +10001470 /*
1471 * Ensure that we can read a full buffer and handle
1472 * the worst-case length packet it can generate,
1473 * otherwise apply backpressure by stopping reads.
1474 */
1475 if (buffer_check_alloc(&iqueue, sizeof(buf)) &&
1476 buffer_check_alloc(&oqueue, SFTP_MAX_MSG_LENGTH))
1477 FD_SET(in, rset);
1478
Damien Miller7b28dc52000-09-05 13:34:53 +11001479 olen = buffer_len(&oqueue);
1480 if (olen > 0)
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001481 FD_SET(out, wset);
Damien Miller7b28dc52000-09-05 13:34:53 +11001482
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001483 if (select(max+1, rset, wset, NULL, NULL) < 0) {
Damien Miller7b28dc52000-09-05 13:34:53 +11001484 if (errno == EINTR)
1485 continue;
Damien Millerfef95ad2006-07-10 20:46:55 +10001486 error("select: %s", strerror(errno));
Damien Millerdfc24252008-02-10 22:29:40 +11001487 sftp_server_cleanup_exit(2);
Damien Miller7b28dc52000-09-05 13:34:53 +11001488 }
1489
1490 /* copy stdin to iqueue */
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001491 if (FD_ISSET(in, rset)) {
Damien Miller7b28dc52000-09-05 13:34:53 +11001492 len = read(in, buf, sizeof buf);
1493 if (len == 0) {
1494 debug("read eof");
Damien Millerdfc24252008-02-10 22:29:40 +11001495 sftp_server_cleanup_exit(0);
Damien Miller7b28dc52000-09-05 13:34:53 +11001496 } else if (len < 0) {
Damien Millerfef95ad2006-07-10 20:46:55 +10001497 error("read: %s", strerror(errno));
Damien Millerdfc24252008-02-10 22:29:40 +11001498 sftp_server_cleanup_exit(1);
Damien Miller7b28dc52000-09-05 13:34:53 +11001499 } else {
1500 buffer_append(&iqueue, buf, len);
1501 }
1502 }
1503 /* send oqueue to stdout */
Ben Lindstromcb80bdf2001-03-05 07:06:12 +00001504 if (FD_ISSET(out, wset)) {
Damien Miller7b28dc52000-09-05 13:34:53 +11001505 len = write(out, buffer_ptr(&oqueue), olen);
1506 if (len < 0) {
Damien Millerfef95ad2006-07-10 20:46:55 +10001507 error("write: %s", strerror(errno));
Damien Millerdfc24252008-02-10 22:29:40 +11001508 sftp_server_cleanup_exit(1);
Damien Miller7b28dc52000-09-05 13:34:53 +11001509 } else {
1510 buffer_consume(&oqueue, len);
1511 }
1512 }
Darren Tuckere9405982007-05-20 15:09:04 +10001513
1514 /*
1515 * Process requests from client if we can fit the results
1516 * into the output buffer, otherwise stop processing input
1517 * and let the output queue drain.
1518 */
1519 if (buffer_check_alloc(&oqueue, SFTP_MAX_MSG_LENGTH))
1520 process();
Damien Miller7b28dc52000-09-05 13:34:53 +11001521 }
1522}