1 | /* $Id: ftp-server.cpp 103117 2024-01-30 09:01:20Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * Generic FTP server (RFC 959) implementation.
|
---|
4 | *
|
---|
5 | * Partly also implements RFC 3659 (Extensions to FTP, for "SIZE", ++).
|
---|
6 | *
|
---|
7 | * Known limitations so far:
|
---|
8 | * - UTF-8 support only.
|
---|
9 | * - Only supports ASCII + binary (image type) file streams for now.
|
---|
10 | * - No directory / file caching yet.
|
---|
11 | * - No support for writing / modifying ("DELE", "MKD", "RMD", "STOR", ++).
|
---|
12 | * - No FTPS / SFTP support.
|
---|
13 | * - No passive mode ("PASV") support.
|
---|
14 | * - No IPv6 support.
|
---|
15 | * - No proxy support.
|
---|
16 | * - No FXP support.
|
---|
17 | */
|
---|
18 |
|
---|
19 | /*
|
---|
20 | * Copyright (C) 2020-2023 Oracle and/or its affiliates.
|
---|
21 | *
|
---|
22 | * This file is part of VirtualBox base platform packages, as
|
---|
23 | * available from https://www.virtualbox.org.
|
---|
24 | *
|
---|
25 | * This program is free software; you can redistribute it and/or
|
---|
26 | * modify it under the terms of the GNU General Public License
|
---|
27 | * as published by the Free Software Foundation, in version 3 of the
|
---|
28 | * License.
|
---|
29 | *
|
---|
30 | * This program is distributed in the hope that it will be useful, but
|
---|
31 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
32 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
33 | * General Public License for more details.
|
---|
34 | *
|
---|
35 | * You should have received a copy of the GNU General Public License
|
---|
36 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
37 | *
|
---|
38 | * The contents of this file may alternatively be used under the terms
|
---|
39 | * of the Common Development and Distribution License Version 1.0
|
---|
40 | * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
|
---|
41 | * in the VirtualBox distribution, in which case the provisions of the
|
---|
42 | * CDDL are applicable instead of those of the GPL.
|
---|
43 | *
|
---|
44 | * You may elect to license modified versions of this file under the
|
---|
45 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
46 | *
|
---|
47 | * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
|
---|
48 | */
|
---|
49 |
|
---|
50 |
|
---|
51 | /*********************************************************************************************************************************
|
---|
52 | * Header Files *
|
---|
53 | *********************************************************************************************************************************/
|
---|
54 | #define LOG_GROUP RTLOGGROUP_FTP
|
---|
55 | #include <iprt/ftp.h>
|
---|
56 | #include "internal/iprt.h"
|
---|
57 | #include "internal/magics.h"
|
---|
58 |
|
---|
59 | #include <iprt/asm.h>
|
---|
60 | #include <iprt/assert.h>
|
---|
61 | #include <iprt/circbuf.h>
|
---|
62 | #include <iprt/err.h>
|
---|
63 | #include <iprt/file.h> /* For file mode flags. */
|
---|
64 | #include <iprt/getopt.h>
|
---|
65 | #include <iprt/mem.h>
|
---|
66 | #include <iprt/log.h>
|
---|
67 | #include <iprt/path.h>
|
---|
68 | #include <iprt/poll.h>
|
---|
69 | #include <iprt/socket.h>
|
---|
70 | #include <iprt/sort.h>
|
---|
71 | #include <iprt/string.h>
|
---|
72 | #include <iprt/system.h>
|
---|
73 | #include <iprt/tcp.h>
|
---|
74 |
|
---|
75 |
|
---|
76 | /*********************************************************************************************************************************
|
---|
77 | * Structures and Typedefs *
|
---|
78 | *********************************************************************************************************************************/
|
---|
79 | /**
|
---|
80 | * Internal FTP server instance.
|
---|
81 | */
|
---|
82 | typedef struct RTFTPSERVERINTERNAL
|
---|
83 | {
|
---|
84 | /** Magic value. */
|
---|
85 | uint32_t u32Magic;
|
---|
86 | /** Callback table. */
|
---|
87 | RTFTPSERVERCALLBACKS Callbacks;
|
---|
88 | /** Pointer to TCP server instance. */
|
---|
89 | PRTTCPSERVER pTCPServer;
|
---|
90 | /** Number of currently connected clients. */
|
---|
91 | uint32_t cClients;
|
---|
92 | /** Pointer to user-specific data. Optional. */
|
---|
93 | void *pvUser;
|
---|
94 | /** Size of user-specific data. Optional. */
|
---|
95 | size_t cbUser;
|
---|
96 | } RTFTPSERVERINTERNAL;
|
---|
97 | /** Pointer to an internal FTP server instance. */
|
---|
98 | typedef RTFTPSERVERINTERNAL *PRTFTPSERVERINTERNAL;
|
---|
99 |
|
---|
100 | /**
|
---|
101 | * FTP directory entry.
|
---|
102 | */
|
---|
103 | typedef struct RTFTPDIRENTRY
|
---|
104 | {
|
---|
105 | /** The information about the entry. */
|
---|
106 | RTFSOBJINFO Info;
|
---|
107 | /** Symbolic link target (allocated after the name). */
|
---|
108 | const char *pszTarget;
|
---|
109 | /** Owner if applicable (allocated after the name). */
|
---|
110 | const char *pszOwner;
|
---|
111 | /** Group if applicable (allocated after the name). */
|
---|
112 | const char *pszGroup;
|
---|
113 | /** The length of szName. */
|
---|
114 | size_t cchName;
|
---|
115 | /** The entry name. */
|
---|
116 | RT_FLEXIBLE_ARRAY_EXTENSION
|
---|
117 | char szName[RT_FLEXIBLE_ARRAY];
|
---|
118 | } RTFTPDIRENTRY;
|
---|
119 | /** Pointer to a FTP directory entry. */
|
---|
120 | typedef RTFTPDIRENTRY *PRTFTPDIRENTRY;
|
---|
121 | /** Pointer to a FTP directory entry pointer. */
|
---|
122 | typedef PRTFTPDIRENTRY *PPRTFTPDIRENTRY;
|
---|
123 |
|
---|
124 | /**
|
---|
125 | * Collection of directory entries.
|
---|
126 | * Used for also caching stuff.
|
---|
127 | */
|
---|
128 | typedef struct RTFTPDIRCOLLECTION
|
---|
129 | {
|
---|
130 | /** Current size of papEntries. */
|
---|
131 | size_t cEntries;
|
---|
132 | /** Memory allocated for papEntries. */
|
---|
133 | size_t cEntriesAllocated;
|
---|
134 | /** Current entries pending sorting and display. */
|
---|
135 | PPRTFTPDIRENTRY papEntries;
|
---|
136 |
|
---|
137 | /** Total number of bytes allocated for the above entries. */
|
---|
138 | uint64_t cbTotalAllocated;
|
---|
139 | /** Total number of file content bytes. */
|
---|
140 | uint64_t cbTotalFiles;
|
---|
141 |
|
---|
142 | } RTFTPDIRCOLLECTION;
|
---|
143 | /** Pointer to a directory collection. */
|
---|
144 | typedef RTFTPDIRCOLLECTION *PRTFTPDIRCOLLECTION;
|
---|
145 | /** Pointer to a directory entry collection pointer. */
|
---|
146 | typedef PRTFTPDIRCOLLECTION *PPRTFTPDIRCOLLECTION;
|
---|
147 |
|
---|
148 |
|
---|
149 | /*********************************************************************************************************************************
|
---|
150 | * Defined Constants And Macros *
|
---|
151 | *********************************************************************************************************************************/
|
---|
152 | /** Validates a handle and returns VERR_INVALID_HANDLE if not valid. */
|
---|
153 | #define RTFTPSERVER_VALID_RETURN_RC(hFTPServer, a_rc) \
|
---|
154 | do { \
|
---|
155 | AssertPtrReturn((hFTPServer), (a_rc)); \
|
---|
156 | AssertReturn((hFTPServer)->u32Magic == RTFTPSERVER_MAGIC, (a_rc)); \
|
---|
157 | } while (0)
|
---|
158 |
|
---|
159 | /** Validates a handle and returns VERR_INVALID_HANDLE if not valid. */
|
---|
160 | #define RTFTPSERVER_VALID_RETURN(hFTPServer) RTFTPSERVER_VALID_RETURN_RC((hFTPServer), VERR_INVALID_HANDLE)
|
---|
161 |
|
---|
162 | /** Validates a handle and returns (void) if not valid. */
|
---|
163 | #define RTFTPSERVER_VALID_RETURN_VOID(hFTPServer) \
|
---|
164 | do { \
|
---|
165 | AssertPtrReturnVoid(hFTPServer); \
|
---|
166 | AssertReturnVoid((hFTPServer)->u32Magic == RTFTPSERVER_MAGIC); \
|
---|
167 | } while (0)
|
---|
168 |
|
---|
169 |
|
---|
170 | /** Handles a FTP server callback with no arguments and returns. */
|
---|
171 | #define RTFTPSERVER_HANDLE_CALLBACK_RET(a_Name) \
|
---|
172 | do \
|
---|
173 | { \
|
---|
174 | PRTFTPSERVERCALLBACKS pCallbacks = &pClient->pServer->Callbacks; \
|
---|
175 | if (pCallbacks->a_Name) \
|
---|
176 | { \
|
---|
177 | RTFTPCALLBACKDATA Data = { &pClient->State }; \
|
---|
178 | return pCallbacks->a_Name(&Data); \
|
---|
179 | } \
|
---|
180 | return VERR_NOT_IMPLEMENTED; \
|
---|
181 | } while (0)
|
---|
182 |
|
---|
183 | /** Handles a FTP server callback with no arguments and sets rc accordingly. */
|
---|
184 | #define RTFTPSERVER_HANDLE_CALLBACK(a_Name) \
|
---|
185 | do \
|
---|
186 | { \
|
---|
187 | PRTFTPSERVERCALLBACKS pCallbacks = &pClient->pServer->Callbacks; \
|
---|
188 | if (pCallbacks->a_Name) \
|
---|
189 | { \
|
---|
190 | RTFTPCALLBACKDATA Data = { &pClient->State, pClient->pServer->pvUser, pClient->pServer->cbUser }; \
|
---|
191 | rc = pCallbacks->a_Name(&Data); \
|
---|
192 | } \
|
---|
193 | else \
|
---|
194 | rc = VERR_NOT_IMPLEMENTED; \
|
---|
195 | } while (0)
|
---|
196 |
|
---|
197 | /** Handles a FTP server callback with arguments and sets rc accordingly. */
|
---|
198 | #define RTFTPSERVER_HANDLE_CALLBACK_VA(a_Name, ...) \
|
---|
199 | do \
|
---|
200 | { \
|
---|
201 | PRTFTPSERVERCALLBACKS pCallbacks = &pClient->pServer->Callbacks; \
|
---|
202 | if (pCallbacks->a_Name) \
|
---|
203 | { \
|
---|
204 | RTFTPCALLBACKDATA Data = { &pClient->State, pClient->pServer->pvUser, pClient->pServer->cbUser }; \
|
---|
205 | rc = pCallbacks->a_Name(&Data, __VA_ARGS__); \
|
---|
206 | } \
|
---|
207 | else \
|
---|
208 | rc = VERR_NOT_IMPLEMENTED; \
|
---|
209 | } while (0)
|
---|
210 |
|
---|
211 | /** Handles a FTP server callback with arguments and returns. */
|
---|
212 | #define RTFTPSERVER_HANDLE_CALLBACK_VA_RET(a_Name, ...) \
|
---|
213 | do \
|
---|
214 | { \
|
---|
215 | PRTFTPSERVERCALLBACKS pCallbacks = &pClient->pServer->Callbacks; \
|
---|
216 | if (pCallbacks->a_Name) \
|
---|
217 | { \
|
---|
218 | RTFTPCALLBACKDATA Data = { &pClient->State, pClient->pServer->pvUser, pClient->pServer->cbUser }; \
|
---|
219 | return pCallbacks->a_Name(&Data, __VA_ARGS__); \
|
---|
220 | } \
|
---|
221 | return VERR_NOT_IMPLEMENTED; \
|
---|
222 | } while (0)
|
---|
223 |
|
---|
224 |
|
---|
225 | /*********************************************************************************************************************************
|
---|
226 | * Structures and Typedefs *
|
---|
227 | *********************************************************************************************************************************/
|
---|
228 | /** Supported FTP server command IDs.
|
---|
229 | * Alphabetically, named after their official command names. */
|
---|
230 | typedef enum RTFTPSERVERCMD
|
---|
231 | {
|
---|
232 | /** Invalid command, do not use. Always must come first. */
|
---|
233 | RTFTPSERVERCMD_INVALID = 0,
|
---|
234 | /** Aborts the current command on the server. */
|
---|
235 | RTFTPSERVERCMD_ABOR,
|
---|
236 | /** Changes the current working directory. */
|
---|
237 | RTFTPSERVERCMD_CDUP,
|
---|
238 | /** Changes the current working directory. */
|
---|
239 | RTFTPSERVERCMD_CWD,
|
---|
240 | /** Reports features supported by the server. */
|
---|
241 | RTFTPSERVERCMD_FEAT,
|
---|
242 | /** Lists a directory. */
|
---|
243 | RTFTPSERVERCMD_LIST,
|
---|
244 | /** Sets the transfer mode. */
|
---|
245 | RTFTPSERVERCMD_MODE,
|
---|
246 | /** Sends a nop ("no operation") to the server. */
|
---|
247 | RTFTPSERVERCMD_NOOP,
|
---|
248 | /** Sets the password for authentication. */
|
---|
249 | RTFTPSERVERCMD_PASS,
|
---|
250 | /** Sets the port to use for the data connection. */
|
---|
251 | RTFTPSERVERCMD_PORT,
|
---|
252 | /** Gets the current working directory. */
|
---|
253 | RTFTPSERVERCMD_PWD,
|
---|
254 | /** Get options. Needed in conjunction with the FEAT command. */
|
---|
255 | RTFTPSERVERCMD_OPTS,
|
---|
256 | /** Terminates the session (connection). */
|
---|
257 | RTFTPSERVERCMD_QUIT,
|
---|
258 | /** Retrieves a specific file. */
|
---|
259 | RTFTPSERVERCMD_RETR,
|
---|
260 | /** Retrieves the size of a file. */
|
---|
261 | RTFTPSERVERCMD_SIZE,
|
---|
262 | /** Retrieves the current status of a transfer. */
|
---|
263 | RTFTPSERVERCMD_STAT,
|
---|
264 | /** Sets the structure type to use. */
|
---|
265 | RTFTPSERVERCMD_STRU,
|
---|
266 | /** Gets the server's OS info. */
|
---|
267 | RTFTPSERVERCMD_SYST,
|
---|
268 | /** Sets the (data) representation type. */
|
---|
269 | RTFTPSERVERCMD_TYPE,
|
---|
270 | /** Sets the user name for authentication. */
|
---|
271 | RTFTPSERVERCMD_USER,
|
---|
272 | /** End marker. */
|
---|
273 | RTFTPSERVERCMD_END,
|
---|
274 | /** The usual 32-bit hack. */
|
---|
275 | RTFTPSERVERCMD_32BIT_HACK = 0x7fffffff
|
---|
276 | } RTFTPSERVERCMD;
|
---|
277 |
|
---|
278 | struct RTFTPSERVERCLIENT;
|
---|
279 |
|
---|
280 | /**
|
---|
281 | * Structure for maintaining a single data connection.
|
---|
282 | */
|
---|
283 | typedef struct RTFTPSERVERDATACONN
|
---|
284 | {
|
---|
285 | /** Pointer to associated client of this data connection. */
|
---|
286 | RTFTPSERVERCLIENT *pClient;
|
---|
287 | /** Data connection IP. */
|
---|
288 | RTNETADDRIPV4 Addr;
|
---|
289 | /** Data connection port number. */
|
---|
290 | uint16_t uPort;
|
---|
291 | /** The current data socket to use.
|
---|
292 | * Can be NIL_RTSOCKET if no data port has been specified (yet) or has been closed. */
|
---|
293 | RTSOCKET hSocket;
|
---|
294 | /** Thread serving the data connection. */
|
---|
295 | RTTHREAD hThread;
|
---|
296 | /** Thread started indicator. */
|
---|
297 | volatile bool fStarted;
|
---|
298 | /** Thread stop indicator. */
|
---|
299 | volatile bool fStop;
|
---|
300 | /** Thread stopped indicator. */
|
---|
301 | volatile bool fStopped;
|
---|
302 | /** Overall result when closing the data connection. */
|
---|
303 | int rc;
|
---|
304 | /** Number of command arguments. */
|
---|
305 | uint8_t cArgs;
|
---|
306 | /** Command arguments array. Optional and can be NULL.
|
---|
307 | * Will be free'd by the data connection thread. */
|
---|
308 | char** papszArgs;
|
---|
309 | /** Circular buffer for caching data before writing. */
|
---|
310 | PRTCIRCBUF pCircBuf;
|
---|
311 | } RTFTPSERVERDATACONN;
|
---|
312 | /** Pointer to a data connection struct. */
|
---|
313 | typedef RTFTPSERVERDATACONN *PRTFTPSERVERDATACONN;
|
---|
314 |
|
---|
315 | /**
|
---|
316 | * Structure for maintaining an internal FTP server client.
|
---|
317 | */
|
---|
318 | typedef struct RTFTPSERVERCLIENT
|
---|
319 | {
|
---|
320 | /** Pointer to internal server state. */
|
---|
321 | PRTFTPSERVERINTERNAL pServer;
|
---|
322 | /** Socket handle the client is bound to. */
|
---|
323 | RTSOCKET hSocket;
|
---|
324 | /** Actual client state. */
|
---|
325 | RTFTPSERVERCLIENTSTATE State;
|
---|
326 | /** The last set data connection IP. */
|
---|
327 | RTNETADDRIPV4 DataConnAddr;
|
---|
328 | /** The last set data connection port number. */
|
---|
329 | uint16_t uDataConnPort;
|
---|
330 | /** Data connection information.
|
---|
331 | * At the moment we only allow one data connection per client at a time. */
|
---|
332 | PRTFTPSERVERDATACONN pDataConn;
|
---|
333 | } RTFTPSERVERCLIENT;
|
---|
334 | /** Pointer to an internal FTP server client state. */
|
---|
335 | typedef RTFTPSERVERCLIENT *PRTFTPSERVERCLIENT;
|
---|
336 |
|
---|
337 | /** Function pointer declaration for a specific FTP server command handler. */
|
---|
338 | typedef DECLCALLBACKTYPE(int, FNRTFTPSERVERCMD,(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs));
|
---|
339 | /** Pointer to a FNRTFTPSERVERCMD(). */
|
---|
340 | typedef FNRTFTPSERVERCMD *PFNRTFTPSERVERCMD;
|
---|
341 |
|
---|
342 |
|
---|
343 | /*********************************************************************************************************************************
|
---|
344 | * Internal Functions *
|
---|
345 | *********************************************************************************************************************************/
|
---|
346 | static int rtFtpServerDataConnOpen(PRTFTPSERVERDATACONN pDataConn, PRTNETADDRIPV4 pAddr, uint16_t uPort);
|
---|
347 | static int rtFtpServerDataConnClose(PRTFTPSERVERDATACONN pDataConn);
|
---|
348 | static void rtFtpServerDataConnReset(PRTFTPSERVERDATACONN pDataConn);
|
---|
349 | static int rtFtpServerDataConnStart(PRTFTPSERVERDATACONN pDataConn, PFNRTTHREAD pfnThread, uint8_t cArgs, const char * const *apszArgs);
|
---|
350 | static int rtFtpServerDataConnStop(PRTFTPSERVERDATACONN pDataConn);
|
---|
351 | static void rtFtpServerDataConnDestroy(PRTFTPSERVERDATACONN pDataConn);
|
---|
352 | static int rtFtpServerDataConnFlush(PRTFTPSERVERDATACONN pDataConn);
|
---|
353 |
|
---|
354 | static void rtFtpServerClientStateReset(PRTFTPSERVERCLIENTSTATE pState);
|
---|
355 |
|
---|
356 | /** @name Command handlers.
|
---|
357 | * @{
|
---|
358 | */
|
---|
359 | static FNRTFTPSERVERCMD rtFtpServerHandleABOR;
|
---|
360 | static FNRTFTPSERVERCMD rtFtpServerHandleCDUP;
|
---|
361 | static FNRTFTPSERVERCMD rtFtpServerHandleCWD;
|
---|
362 | static FNRTFTPSERVERCMD rtFtpServerHandleFEAT;
|
---|
363 | static FNRTFTPSERVERCMD rtFtpServerHandleLIST;
|
---|
364 | static FNRTFTPSERVERCMD rtFtpServerHandleMODE;
|
---|
365 | static FNRTFTPSERVERCMD rtFtpServerHandleNOOP;
|
---|
366 | static FNRTFTPSERVERCMD rtFtpServerHandlePASS;
|
---|
367 | static FNRTFTPSERVERCMD rtFtpServerHandlePORT;
|
---|
368 | static FNRTFTPSERVERCMD rtFtpServerHandlePWD;
|
---|
369 | static FNRTFTPSERVERCMD rtFtpServerHandleOPTS;
|
---|
370 | static FNRTFTPSERVERCMD rtFtpServerHandleQUIT;
|
---|
371 | static FNRTFTPSERVERCMD rtFtpServerHandleRETR;
|
---|
372 | static FNRTFTPSERVERCMD rtFtpServerHandleSIZE;
|
---|
373 | static FNRTFTPSERVERCMD rtFtpServerHandleSTAT;
|
---|
374 | static FNRTFTPSERVERCMD rtFtpServerHandleSTRU;
|
---|
375 | static FNRTFTPSERVERCMD rtFtpServerHandleSYST;
|
---|
376 | static FNRTFTPSERVERCMD rtFtpServerHandleTYPE;
|
---|
377 | static FNRTFTPSERVERCMD rtFtpServerHandleUSER;
|
---|
378 | /** @} */
|
---|
379 |
|
---|
380 | /**
|
---|
381 | * Structure for maintaining a single command entry for the command table.
|
---|
382 | */
|
---|
383 | typedef struct RTFTPSERVERCMD_ENTRY
|
---|
384 | {
|
---|
385 | /** Command ID. */
|
---|
386 | RTFTPSERVERCMD enmCmd;
|
---|
387 | /** Command represented as ASCII string. */
|
---|
388 | char szCmd[RTFTPSERVER_MAX_CMD_LEN];
|
---|
389 | /** Whether the commands needs a logged in (valid) user. */
|
---|
390 | bool fNeedsUser;
|
---|
391 | /** Function pointer invoked to handle the command. */
|
---|
392 | PFNRTFTPSERVERCMD pfnCmd;
|
---|
393 | } RTFTPSERVERCMD_ENTRY;
|
---|
394 | /** Pointer to a command entry. */
|
---|
395 | typedef RTFTPSERVERCMD_ENTRY *PRTFTPSERVERCMD_ENTRY;
|
---|
396 |
|
---|
397 |
|
---|
398 |
|
---|
399 | /*********************************************************************************************************************************
|
---|
400 | * Global Variables *
|
---|
401 | *********************************************************************************************************************************/
|
---|
402 | /**
|
---|
403 | * Table of handled commands.
|
---|
404 | */
|
---|
405 | static const RTFTPSERVERCMD_ENTRY g_aCmdMap[] =
|
---|
406 | {
|
---|
407 | { RTFTPSERVERCMD_ABOR, "ABOR", true, rtFtpServerHandleABOR },
|
---|
408 | { RTFTPSERVERCMD_CDUP, "CDUP", true, rtFtpServerHandleCDUP },
|
---|
409 | { RTFTPSERVERCMD_CWD, "CWD", true, rtFtpServerHandleCWD },
|
---|
410 | { RTFTPSERVERCMD_FEAT, "FEAT", false, rtFtpServerHandleFEAT },
|
---|
411 | { RTFTPSERVERCMD_LIST, "LIST", true, rtFtpServerHandleLIST },
|
---|
412 | { RTFTPSERVERCMD_MODE, "MODE", true, rtFtpServerHandleMODE },
|
---|
413 | { RTFTPSERVERCMD_NOOP, "NOOP", true, rtFtpServerHandleNOOP },
|
---|
414 | { RTFTPSERVERCMD_PASS, "PASS", false, rtFtpServerHandlePASS },
|
---|
415 | { RTFTPSERVERCMD_PORT, "PORT", true, rtFtpServerHandlePORT },
|
---|
416 | { RTFTPSERVERCMD_PWD, "PWD", true, rtFtpServerHandlePWD },
|
---|
417 | { RTFTPSERVERCMD_OPTS, "OPTS", false, rtFtpServerHandleOPTS },
|
---|
418 | { RTFTPSERVERCMD_QUIT, "QUIT", false, rtFtpServerHandleQUIT },
|
---|
419 | { RTFTPSERVERCMD_RETR, "RETR", true, rtFtpServerHandleRETR },
|
---|
420 | { RTFTPSERVERCMD_SIZE, "SIZE", true, rtFtpServerHandleSIZE },
|
---|
421 | { RTFTPSERVERCMD_STAT, "STAT", true, rtFtpServerHandleSTAT },
|
---|
422 | { RTFTPSERVERCMD_STRU, "STRU", true, rtFtpServerHandleSTRU },
|
---|
423 | { RTFTPSERVERCMD_SYST, "SYST", false, rtFtpServerHandleSYST },
|
---|
424 | { RTFTPSERVERCMD_TYPE, "TYPE", true, rtFtpServerHandleTYPE },
|
---|
425 | { RTFTPSERVERCMD_USER, "USER", false, rtFtpServerHandleUSER },
|
---|
426 | { RTFTPSERVERCMD_END, "", false, NULL }
|
---|
427 | };
|
---|
428 |
|
---|
429 | /** RFC-1123 month of the year names. */
|
---|
430 | static const char * const g_apszMonths[1+12] =
|
---|
431 | {
|
---|
432 | "000", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
|
---|
433 | };
|
---|
434 |
|
---|
435 | /** Feature string which represents all commands we support in addition to RFC 959 (see RFC 2398).
|
---|
436 | * Must match the command table above.
|
---|
437 | *
|
---|
438 | * Don't forget the beginning space (" ") at each feature. */
|
---|
439 | #define RTFTPSERVER_FEATURES_STRING \
|
---|
440 | " SIZE\r\n" \
|
---|
441 | " UTF8"
|
---|
442 |
|
---|
443 | /** Maximum length in characters a FTP server path can have (excluding termination). */
|
---|
444 | #define RTFTPSERVER_MAX_PATH RTPATH_MAX
|
---|
445 |
|
---|
446 |
|
---|
447 | /*********************************************************************************************************************************
|
---|
448 | * Protocol Functions *
|
---|
449 | *********************************************************************************************************************************/
|
---|
450 |
|
---|
451 | /**
|
---|
452 | * Replies a (three digit) reply code back to the client.
|
---|
453 | *
|
---|
454 | * @returns VBox status code.
|
---|
455 | * @param pClient Client to reply to.
|
---|
456 | * @param enmReply Reply code to send.
|
---|
457 | */
|
---|
458 | static int rtFtpServerSendReplyRc(PRTFTPSERVERCLIENT pClient, RTFTPSERVER_REPLY enmReply)
|
---|
459 | {
|
---|
460 | /* Note: If we don't supply any additional text, make sure to include an empty stub, as
|
---|
461 | * some clients expect this as part of their parsing code. */
|
---|
462 | char szReply[32];
|
---|
463 | RTStrPrintf2(szReply, sizeof(szReply), "%RU32 -\r\n", enmReply);
|
---|
464 |
|
---|
465 | LogFlowFunc(("Sending reply code %RU32\n", enmReply));
|
---|
466 |
|
---|
467 | return RTTcpWrite(pClient->hSocket, szReply, strlen(szReply));
|
---|
468 | }
|
---|
469 |
|
---|
470 | /**
|
---|
471 | * Replies a (three digit) reply code with a custom message back to the client.
|
---|
472 | *
|
---|
473 | * @returns VBox status code.
|
---|
474 | * @param pClient Client to reply to.
|
---|
475 | * @param enmReply Reply code to send.
|
---|
476 | * @param pszFormat Format string of message to send with the reply code.
|
---|
477 | */
|
---|
478 | static int rtFtpServerSendReplyRcEx(PRTFTPSERVERCLIENT pClient, RTFTPSERVER_REPLY enmReply,
|
---|
479 | const char *pszFormat, ...)
|
---|
480 | {
|
---|
481 | char *pszMsg = NULL;
|
---|
482 |
|
---|
483 | va_list args;
|
---|
484 | va_start(args, pszFormat);
|
---|
485 | char *pszFmt = NULL;
|
---|
486 | const int cch = RTStrAPrintfV(&pszFmt, pszFormat, args);
|
---|
487 | va_end(args);
|
---|
488 | AssertReturn(cch > 0, VERR_NO_MEMORY);
|
---|
489 |
|
---|
490 | int rc = RTStrAPrintf(&pszMsg, "%RU32 -", enmReply);
|
---|
491 | AssertRCReturn(rc, rc);
|
---|
492 |
|
---|
493 | /** @todo Support multi-line replies (see 4.2ff). */
|
---|
494 |
|
---|
495 | if (pszFmt)
|
---|
496 | {
|
---|
497 | rc = RTStrAAppend(&pszMsg, " ");
|
---|
498 | AssertRCReturn(rc, rc);
|
---|
499 |
|
---|
500 | rc = RTStrAAppend(&pszMsg, pszFmt);
|
---|
501 | AssertRCReturn(rc, rc);
|
---|
502 | }
|
---|
503 |
|
---|
504 |
|
---|
505 | rc = RTStrAAppend(&pszMsg, "\r\n");
|
---|
506 | AssertRCReturn(rc, rc);
|
---|
507 |
|
---|
508 | RTStrFree(pszFmt);
|
---|
509 |
|
---|
510 | rc = RTTcpWrite(pClient->hSocket, pszMsg, strlen(pszMsg));
|
---|
511 |
|
---|
512 | RTStrFree(pszMsg);
|
---|
513 |
|
---|
514 | return rc;
|
---|
515 | }
|
---|
516 |
|
---|
517 | /**
|
---|
518 | * Replies a string back to the client.
|
---|
519 | *
|
---|
520 | * @returns VBox status code.
|
---|
521 | * @param pClient Client to reply to.
|
---|
522 | * @param pszFormat Format to reply.
|
---|
523 | * @param ... Format arguments.
|
---|
524 | */
|
---|
525 | static int rtFtpServerSendReplyStr(PRTFTPSERVERCLIENT pClient, const char *pszFormat, ...)
|
---|
526 | {
|
---|
527 | va_list args;
|
---|
528 | va_start(args, pszFormat);
|
---|
529 | char *psz = NULL;
|
---|
530 | const int cch = RTStrAPrintfV(&psz, pszFormat, args);
|
---|
531 | va_end(args);
|
---|
532 | AssertReturn(cch > 0, VERR_NO_MEMORY);
|
---|
533 |
|
---|
534 | int rc = RTStrAAppend(&psz, "\r\n");
|
---|
535 | AssertRCReturn(rc, rc);
|
---|
536 |
|
---|
537 | LogFlowFunc(("Sending reply '%s'\n", psz));
|
---|
538 |
|
---|
539 | rc = RTTcpWrite(pClient->hSocket, psz, strlen(psz));
|
---|
540 |
|
---|
541 | RTStrFree(psz);
|
---|
542 |
|
---|
543 | return rc;
|
---|
544 | }
|
---|
545 |
|
---|
546 | /**
|
---|
547 | * Validates if a given absolute path is valid or not.
|
---|
548 | *
|
---|
549 | * @returns \c true if path is valid, or \c false if not.
|
---|
550 | * @param pszPath Path to check.
|
---|
551 | * @param fIsAbsolute Whether the path to check is an absolute path or not.
|
---|
552 | */
|
---|
553 | static bool rtFtpServerPathIsValid(const char *pszPath, bool fIsAbsolute)
|
---|
554 | {
|
---|
555 | if (!pszPath)
|
---|
556 | return false;
|
---|
557 |
|
---|
558 | bool fIsValid = strlen(pszPath)
|
---|
559 | && RTStrIsValidEncoding(pszPath)
|
---|
560 | && RTStrStr(pszPath, "..") == NULL; /** @todo Very crude for now -- improve this. */
|
---|
561 | if ( fIsValid
|
---|
562 | && fIsAbsolute)
|
---|
563 | {
|
---|
564 | RTFSOBJINFO objInfo;
|
---|
565 | int rc2 = RTPathQueryInfo(pszPath, &objInfo, RTFSOBJATTRADD_NOTHING);
|
---|
566 | if (RT_SUCCESS(rc2))
|
---|
567 | {
|
---|
568 | fIsValid = RTFS_IS_DIRECTORY(objInfo.Attr.fMode)
|
---|
569 | || RTFS_IS_FILE(objInfo.Attr.fMode);
|
---|
570 |
|
---|
571 | /* No symlinks and other stuff not allowed. */
|
---|
572 | }
|
---|
573 | else
|
---|
574 | fIsValid = false;
|
---|
575 | }
|
---|
576 |
|
---|
577 | LogFlowFunc(("pszPath=%s -> %RTbool\n", pszPath, fIsValid));
|
---|
578 | return fIsValid;
|
---|
579 | }
|
---|
580 |
|
---|
581 | /**
|
---|
582 | * Sets the current working directory for a client.
|
---|
583 | *
|
---|
584 | * @returns VBox status code.
|
---|
585 | * @param pState Client state to set current working directory for.
|
---|
586 | * @param pszPath Working directory to set.
|
---|
587 | */
|
---|
588 | static int rtFtpSetCWD(PRTFTPSERVERCLIENTSTATE pState, const char *pszPath)
|
---|
589 | {
|
---|
590 | RTStrFree(pState->pszCWD);
|
---|
591 |
|
---|
592 | if (!rtFtpServerPathIsValid(pszPath, false /* fIsAbsolute */))
|
---|
593 | return VERR_INVALID_PARAMETER;
|
---|
594 |
|
---|
595 | pState->pszCWD = RTStrDup(pszPath);
|
---|
596 |
|
---|
597 | LogFlowFunc(("Current CWD is now '%s'\n", pState->pszCWD));
|
---|
598 |
|
---|
599 | int rc = pState->pszCWD ? VINF_SUCCESS : VERR_NO_MEMORY;
|
---|
600 | AssertRC(rc);
|
---|
601 | return rc;
|
---|
602 | }
|
---|
603 |
|
---|
604 | /**
|
---|
605 | * Looks up an user account.
|
---|
606 | *
|
---|
607 | * @returns VBox status code, or VERR_NOT_FOUND if user has not been found.
|
---|
608 | * @param pClient Client to look up user for.
|
---|
609 | * @param pszUser User name to look up.
|
---|
610 | */
|
---|
611 | static int rtFtpServerLookupUser(PRTFTPSERVERCLIENT pClient, const char *pszUser)
|
---|
612 | {
|
---|
613 | RTFTPSERVER_HANDLE_CALLBACK_VA_RET(pfnOnUserConnect, pszUser);
|
---|
614 | }
|
---|
615 |
|
---|
616 | /**
|
---|
617 | * Handles the actual client authentication.
|
---|
618 | *
|
---|
619 | * @returns VBox status code, or VERR_ACCESS_DENIED if authentication failed.
|
---|
620 | * @param pClient Client to authenticate.
|
---|
621 | * @param pszUser User name to authenticate with.
|
---|
622 | * @param pszPassword Password to authenticate with.
|
---|
623 | */
|
---|
624 | static int rtFtpServerAuthenticate(PRTFTPSERVERCLIENT pClient, const char *pszUser, const char *pszPassword)
|
---|
625 | {
|
---|
626 | RTFTPSERVER_HANDLE_CALLBACK_VA_RET(pfnOnUserAuthenticate, pszUser, pszPassword);
|
---|
627 | }
|
---|
628 |
|
---|
629 | /**
|
---|
630 | * Converts a RTFSOBJINFO struct to a string.
|
---|
631 | *
|
---|
632 | * @returns VBox status code.
|
---|
633 | * @param pObjInfo RTFSOBJINFO object to convert.
|
---|
634 | * @param pszFsObjInfo Where to store the output string.
|
---|
635 | * @param cbFsObjInfo Size of the output string in bytes.
|
---|
636 | */
|
---|
637 | static int rtFtpServerFsObjInfoToStr(PRTFSOBJINFO pObjInfo, char *pszFsObjInfo, size_t cbFsObjInfo)
|
---|
638 | {
|
---|
639 | RTFMODE fMode = pObjInfo->Attr.fMode;
|
---|
640 | char chFileType;
|
---|
641 | switch (fMode & RTFS_TYPE_MASK)
|
---|
642 | {
|
---|
643 | case RTFS_TYPE_FIFO: chFileType = 'f'; break;
|
---|
644 | case RTFS_TYPE_DEV_CHAR: chFileType = 'c'; break;
|
---|
645 | case RTFS_TYPE_DIRECTORY: chFileType = 'd'; break;
|
---|
646 | case RTFS_TYPE_DEV_BLOCK: chFileType = 'b'; break;
|
---|
647 | case RTFS_TYPE_FILE: chFileType = '-'; break;
|
---|
648 | case RTFS_TYPE_SYMLINK: chFileType = 'l'; break;
|
---|
649 | case RTFS_TYPE_SOCKET: chFileType = 's'; break;
|
---|
650 | case RTFS_TYPE_WHITEOUT: chFileType = 'w'; break;
|
---|
651 | default: chFileType = '?'; break;
|
---|
652 | }
|
---|
653 |
|
---|
654 | char szTimeBirth[RTTIME_STR_LEN];
|
---|
655 | char szTimeChange[RTTIME_STR_LEN];
|
---|
656 | char szTimeModification[RTTIME_STR_LEN];
|
---|
657 | char szTimeAccess[RTTIME_STR_LEN];
|
---|
658 |
|
---|
659 | #define INFO_TO_STR(a_Format, ...) \
|
---|
660 | do \
|
---|
661 | { \
|
---|
662 | const ssize_t cchSize = RTStrPrintf2(szTemp, sizeof(szTemp), a_Format, __VA_ARGS__); \
|
---|
663 | AssertReturn(cchSize > 0, VERR_BUFFER_OVERFLOW); \
|
---|
664 | const int rc2 = RTStrCat(pszFsObjInfo, cbFsObjInfo, szTemp); \
|
---|
665 | AssertRCReturn(rc2, rc2); \
|
---|
666 | } while (0);
|
---|
667 |
|
---|
668 | char szTemp[128];
|
---|
669 |
|
---|
670 | INFO_TO_STR("%c", chFileType);
|
---|
671 | INFO_TO_STR("%c%c%c",
|
---|
672 | fMode & RTFS_UNIX_IRUSR ? 'r' : '-',
|
---|
673 | fMode & RTFS_UNIX_IWUSR ? 'w' : '-',
|
---|
674 | fMode & RTFS_UNIX_IXUSR ? 'x' : '-');
|
---|
675 | INFO_TO_STR("%c%c%c",
|
---|
676 | fMode & RTFS_UNIX_IRGRP ? 'r' : '-',
|
---|
677 | fMode & RTFS_UNIX_IWGRP ? 'w' : '-',
|
---|
678 | fMode & RTFS_UNIX_IXGRP ? 'x' : '-');
|
---|
679 | INFO_TO_STR("%c%c%c",
|
---|
680 | fMode & RTFS_UNIX_IROTH ? 'r' : '-',
|
---|
681 | fMode & RTFS_UNIX_IWOTH ? 'w' : '-',
|
---|
682 | fMode & RTFS_UNIX_IXOTH ? 'x' : '-');
|
---|
683 |
|
---|
684 | INFO_TO_STR( " %c%c%c%c%c%c%c%c%c%c%c%c%c%c",
|
---|
685 | fMode & RTFS_DOS_READONLY ? 'R' : '-',
|
---|
686 | fMode & RTFS_DOS_HIDDEN ? 'H' : '-',
|
---|
687 | fMode & RTFS_DOS_SYSTEM ? 'S' : '-',
|
---|
688 | fMode & RTFS_DOS_DIRECTORY ? 'D' : '-',
|
---|
689 | fMode & RTFS_DOS_ARCHIVED ? 'A' : '-',
|
---|
690 | fMode & RTFS_DOS_NT_DEVICE ? 'd' : '-',
|
---|
691 | fMode & RTFS_DOS_NT_NORMAL ? 'N' : '-',
|
---|
692 | fMode & RTFS_DOS_NT_TEMPORARY ? 'T' : '-',
|
---|
693 | fMode & RTFS_DOS_NT_SPARSE_FILE ? 'P' : '-',
|
---|
694 | fMode & RTFS_DOS_NT_REPARSE_POINT ? 'J' : '-',
|
---|
695 | fMode & RTFS_DOS_NT_COMPRESSED ? 'C' : '-',
|
---|
696 | fMode & RTFS_DOS_NT_OFFLINE ? 'O' : '-',
|
---|
697 | fMode & RTFS_DOS_NT_NOT_CONTENT_INDEXED ? 'I' : '-',
|
---|
698 | fMode & RTFS_DOS_NT_ENCRYPTED ? 'E' : '-');
|
---|
699 |
|
---|
700 | INFO_TO_STR( " %d %4d %4d %10lld %10lld",
|
---|
701 | pObjInfo->Attr.u.Unix.cHardlinks,
|
---|
702 | pObjInfo->Attr.u.Unix.uid,
|
---|
703 | pObjInfo->Attr.u.Unix.gid,
|
---|
704 | pObjInfo->cbObject,
|
---|
705 | pObjInfo->cbAllocated);
|
---|
706 |
|
---|
707 | INFO_TO_STR( " %s %s %s %s",
|
---|
708 | RTTimeSpecToString(&pObjInfo->BirthTime, szTimeBirth, sizeof(szTimeBirth)),
|
---|
709 | RTTimeSpecToString(&pObjInfo->ChangeTime, szTimeChange, sizeof(szTimeChange)),
|
---|
710 | RTTimeSpecToString(&pObjInfo->ModificationTime, szTimeModification, sizeof(szTimeModification)),
|
---|
711 | RTTimeSpecToString(&pObjInfo->AccessTime, szTimeAccess, sizeof(szTimeAccess)) );
|
---|
712 |
|
---|
713 | #undef INFO_TO_STR
|
---|
714 |
|
---|
715 | return VINF_SUCCESS;
|
---|
716 | }
|
---|
717 |
|
---|
718 | /**
|
---|
719 | * Parses a string which consists of an IPv4 (ww,xx,yy,zz) and a port number (hi,lo), all separated by comma delimiters.
|
---|
720 | * See RFC 959, 4.1.2.
|
---|
721 | *
|
---|
722 | * @returns VBox status code.
|
---|
723 | * @param pszStr String to parse.
|
---|
724 | * @param pAddr Where to store the IPv4 address on success.
|
---|
725 | * @param puPort Where to store the port number on success.
|
---|
726 | */
|
---|
727 | static int rtFtpParseHostAndPort(const char *pszStr, PRTNETADDRIPV4 pAddr, uint16_t *puPort)
|
---|
728 | {
|
---|
729 | AssertPtrReturn(pszStr, VERR_INVALID_POINTER);
|
---|
730 | AssertPtrReturn(pAddr, VERR_INVALID_POINTER);
|
---|
731 | AssertPtrReturn(puPort, VERR_INVALID_POINTER);
|
---|
732 |
|
---|
733 | char *pszNext;
|
---|
734 | int rc;
|
---|
735 |
|
---|
736 | /* Parse IP (v4). */
|
---|
737 | /** @todo I don't think IPv6 ever will be a thing here, or will it? */
|
---|
738 | rc = RTStrToUInt8Ex(pszStr, &pszNext, 10, &pAddr->au8[0]);
|
---|
739 | if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS)
|
---|
740 | return VERR_INVALID_PARAMETER;
|
---|
741 | if (*pszNext++ != ',')
|
---|
742 | return VERR_INVALID_PARAMETER;
|
---|
743 |
|
---|
744 | rc = RTStrToUInt8Ex(pszNext, &pszNext, 10, &pAddr->au8[1]);
|
---|
745 | if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS)
|
---|
746 | return VERR_INVALID_PARAMETER;
|
---|
747 | if (*pszNext++ != ',')
|
---|
748 | return VERR_INVALID_PARAMETER;
|
---|
749 |
|
---|
750 | rc = RTStrToUInt8Ex(pszNext, &pszNext, 10, &pAddr->au8[2]);
|
---|
751 | if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_CHARS)
|
---|
752 | return VERR_INVALID_PARAMETER;
|
---|
753 | if (*pszNext++ != ',')
|
---|
754 | return VERR_INVALID_PARAMETER;
|
---|
755 |
|
---|
756 | rc = RTStrToUInt8Ex(pszNext, &pszNext, 10, &pAddr->au8[3]);
|
---|
757 | if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_SPACES && rc != VWRN_TRAILING_CHARS)
|
---|
758 | return VERR_INVALID_PARAMETER;
|
---|
759 | if (*pszNext++ != ',')
|
---|
760 | return VERR_INVALID_PARAMETER;
|
---|
761 |
|
---|
762 | /* Parse port. */
|
---|
763 | uint8_t uPortHi;
|
---|
764 | rc = RTStrToUInt8Ex(pszNext, &pszNext, 10, &uPortHi);
|
---|
765 | if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_SPACES && rc != VWRN_TRAILING_CHARS)
|
---|
766 | return VERR_INVALID_PARAMETER;
|
---|
767 | if (*pszNext++ != ',')
|
---|
768 | return VERR_INVALID_PARAMETER;
|
---|
769 | uint8_t uPortLo;
|
---|
770 | rc = RTStrToUInt8Ex(pszNext, &pszNext, 10, &uPortLo);
|
---|
771 | if (rc != VINF_SUCCESS && rc != VWRN_TRAILING_SPACES && rc != VWRN_TRAILING_CHARS)
|
---|
772 | return VERR_INVALID_PARAMETER;
|
---|
773 |
|
---|
774 | *puPort = RT_MAKE_U16(uPortLo, uPortHi);
|
---|
775 |
|
---|
776 | return rc;
|
---|
777 | }
|
---|
778 |
|
---|
779 | /**
|
---|
780 | * Duplicates a command argument vector.
|
---|
781 | *
|
---|
782 | * @returns Duplicated argument vector or NULL if failed or no arguments given. Needs to be free'd with rtFtpCmdArgsFree().
|
---|
783 | * @param cArgs Number of arguments in argument vector.
|
---|
784 | * @param apszArgs Pointer to argument vector to duplicate.
|
---|
785 | */
|
---|
786 | static char** rtFtpCmdArgsDup(uint8_t cArgs, const char * const *apszArgs)
|
---|
787 | {
|
---|
788 | if (!cArgs)
|
---|
789 | return NULL;
|
---|
790 |
|
---|
791 | char **apszArgsDup = (char **)RTMemAlloc(cArgs * sizeof(char *));
|
---|
792 | if (!apszArgsDup)
|
---|
793 | {
|
---|
794 | AssertFailed();
|
---|
795 | return NULL;
|
---|
796 | }
|
---|
797 |
|
---|
798 | int rc2 = VINF_SUCCESS;
|
---|
799 |
|
---|
800 | uint8_t i;
|
---|
801 | for (i = 0; i < cArgs; i++)
|
---|
802 | {
|
---|
803 | apszArgsDup[i] = RTStrDup(apszArgs[i]);
|
---|
804 | if (!apszArgsDup[i])
|
---|
805 | rc2 = VERR_NO_MEMORY;
|
---|
806 | }
|
---|
807 |
|
---|
808 | if (RT_FAILURE(rc2))
|
---|
809 | {
|
---|
810 | while (i--)
|
---|
811 | RTStrFree(apszArgsDup[i]);
|
---|
812 |
|
---|
813 | RTMemFree(apszArgsDup);
|
---|
814 | return NULL;
|
---|
815 | }
|
---|
816 |
|
---|
817 | return apszArgsDup;
|
---|
818 | }
|
---|
819 |
|
---|
820 | /**
|
---|
821 | * Frees a command argument vector.
|
---|
822 | *
|
---|
823 | * @param cArgs Number of arguments in argument vector.
|
---|
824 | * @param papszArgs Pointer to argument vector to free.
|
---|
825 | */
|
---|
826 | static void rtFtpCmdArgsFree(uint8_t cArgs, char **papszArgs)
|
---|
827 | {
|
---|
828 | while (cArgs--)
|
---|
829 | RTStrFree(papszArgs[cArgs]);
|
---|
830 |
|
---|
831 | RTMemFree(papszArgs);
|
---|
832 | }
|
---|
833 |
|
---|
834 | /**
|
---|
835 | * Opens a data connection to the client.
|
---|
836 | *
|
---|
837 | * @returns VBox status code.
|
---|
838 | * @param pDataConn Data connection to open.
|
---|
839 | * @param pAddr Address for the data connection.
|
---|
840 | * @param uPort Port for the data connection.
|
---|
841 | */
|
---|
842 | static int rtFtpServerDataConnOpen(PRTFTPSERVERDATACONN pDataConn, PRTNETADDRIPV4 pAddr, uint16_t uPort)
|
---|
843 | {
|
---|
844 | LogFlowFuncEnter();
|
---|
845 |
|
---|
846 | /** @todo Implement IPv6 handling here. */
|
---|
847 | char szAddress[32];
|
---|
848 | const ssize_t cchAdddress = RTStrPrintf2(szAddress, sizeof(szAddress), "%RU8.%RU8.%RU8.%RU8",
|
---|
849 | pAddr->au8[0], pAddr->au8[1], pAddr->au8[2], pAddr->au8[3]);
|
---|
850 | AssertReturn(cchAdddress > 0, VERR_NO_MEMORY);
|
---|
851 |
|
---|
852 | int rc = VINF_SUCCESS; /* Shut up MSVC. */
|
---|
853 |
|
---|
854 | /* Try a bit harder if the data connection is not ready (yet). */
|
---|
855 | for (int i = 0; i < 10; i++)
|
---|
856 | {
|
---|
857 | rc = RTTcpClientConnect(szAddress, uPort, &pDataConn->hSocket);
|
---|
858 | if (RT_SUCCESS(rc))
|
---|
859 | break;
|
---|
860 | RTThreadSleep(100);
|
---|
861 | }
|
---|
862 |
|
---|
863 | LogFlowFuncLeaveRC(rc);
|
---|
864 | return rc;
|
---|
865 | }
|
---|
866 |
|
---|
867 | /**
|
---|
868 | * Closes a data connection to the client.
|
---|
869 | *
|
---|
870 | * @returns VBox status code.
|
---|
871 | * @param pDataConn Data connection to close.
|
---|
872 | */
|
---|
873 | static int rtFtpServerDataConnClose(PRTFTPSERVERDATACONN pDataConn)
|
---|
874 | {
|
---|
875 | int rc = VINF_SUCCESS;
|
---|
876 |
|
---|
877 | if (pDataConn->hSocket != NIL_RTSOCKET)
|
---|
878 | {
|
---|
879 | LogFlowFuncEnter();
|
---|
880 |
|
---|
881 | rtFtpServerDataConnFlush(pDataConn);
|
---|
882 |
|
---|
883 | rc = RTTcpClientClose(pDataConn->hSocket);
|
---|
884 | pDataConn->hSocket = NIL_RTSOCKET;
|
---|
885 | }
|
---|
886 |
|
---|
887 | LogFlowFuncLeaveRC(rc);
|
---|
888 | return rc;
|
---|
889 | }
|
---|
890 |
|
---|
891 | /**
|
---|
892 | * Writes data to the data connection.
|
---|
893 | *
|
---|
894 | * @returns VBox status code.
|
---|
895 | * @param pDataConn Data connection to write to.
|
---|
896 | * @param pvData Data to write.
|
---|
897 | * @param cbData Size (in bytes) of data to write.
|
---|
898 | * @param pcbWritten How many bytes were written. Optional.
|
---|
899 | */
|
---|
900 | static int rtFtpServerDataConnWrite(PRTFTPSERVERDATACONN pDataConn, const void *pvData, size_t cbData, size_t *pcbWritten)
|
---|
901 | {
|
---|
902 | int rc = RTTcpWrite(pDataConn->hSocket, pvData, cbData);
|
---|
903 | if (RT_SUCCESS(rc))
|
---|
904 | {
|
---|
905 | if (pcbWritten)
|
---|
906 | *pcbWritten = cbData;
|
---|
907 | }
|
---|
908 |
|
---|
909 | return rc;
|
---|
910 | }
|
---|
911 |
|
---|
912 | /**
|
---|
913 | * Flushes a data connection.
|
---|
914 | *
|
---|
915 | * @returns VBox status code.
|
---|
916 | * @param pDataConn Data connection to flush.
|
---|
917 | */
|
---|
918 | static int rtFtpServerDataConnFlush(PRTFTPSERVERDATACONN pDataConn)
|
---|
919 | {
|
---|
920 | int rc = VINF_SUCCESS;
|
---|
921 |
|
---|
922 | size_t cbUsed = RTCircBufUsed(pDataConn->pCircBuf);
|
---|
923 | while (cbUsed)
|
---|
924 | {
|
---|
925 | void *pvBlock;
|
---|
926 | size_t cbBlock;
|
---|
927 | RTCircBufAcquireReadBlock(pDataConn->pCircBuf, cbUsed, &pvBlock, &cbBlock);
|
---|
928 | if (cbBlock)
|
---|
929 | {
|
---|
930 | size_t cbWritten = 0;
|
---|
931 | rc = rtFtpServerDataConnWrite(pDataConn, pvBlock, cbBlock, &cbWritten);
|
---|
932 | if (RT_SUCCESS(rc))
|
---|
933 | {
|
---|
934 | AssertBreak(cbUsed >= cbWritten);
|
---|
935 | cbUsed -= cbWritten;
|
---|
936 | }
|
---|
937 |
|
---|
938 | RTCircBufReleaseReadBlock(pDataConn->pCircBuf, cbWritten);
|
---|
939 |
|
---|
940 | if (RT_FAILURE(rc))
|
---|
941 | break;
|
---|
942 | }
|
---|
943 | }
|
---|
944 |
|
---|
945 | return rc;
|
---|
946 | }
|
---|
947 |
|
---|
948 | /**
|
---|
949 | * Checks if flushing a data connection is necessary, and if so, flush it.
|
---|
950 | *
|
---|
951 | * @returns VBox status code.
|
---|
952 | * @param pDataConn Data connection to check / do flushing for.
|
---|
953 | */
|
---|
954 | static int rtFtpServerDataCheckFlush(PRTFTPSERVERDATACONN pDataConn)
|
---|
955 | {
|
---|
956 | int rc = VINF_SUCCESS;
|
---|
957 |
|
---|
958 | size_t cbUsed = RTCircBufUsed(pDataConn->pCircBuf);
|
---|
959 | if (cbUsed >= _4K) /** @todo Make this more dynamic. */
|
---|
960 | {
|
---|
961 | rc = rtFtpServerDataConnFlush(pDataConn);
|
---|
962 | }
|
---|
963 |
|
---|
964 | return rc;
|
---|
965 | }
|
---|
966 |
|
---|
967 | /**
|
---|
968 | * Adds new data for a data connection to be sent.
|
---|
969 | *
|
---|
970 | * @returns VBox status code.
|
---|
971 | * @param pDataConn Data connection to add new data to.
|
---|
972 | * @param pvData Pointer to data to add.
|
---|
973 | * @param cbData Size (in bytes) of data to add.
|
---|
974 | */
|
---|
975 | static int rtFtpServerDataConnAddData(PRTFTPSERVERDATACONN pDataConn, const void *pvData, size_t cbData)
|
---|
976 | {
|
---|
977 | AssertReturn(cbData <= RTCircBufFree(pDataConn->pCircBuf), VERR_BUFFER_OVERFLOW);
|
---|
978 |
|
---|
979 | int rc = VINF_SUCCESS;
|
---|
980 |
|
---|
981 | size_t cbToWrite = cbData;
|
---|
982 | do
|
---|
983 | {
|
---|
984 | void *pvBlock;
|
---|
985 | size_t cbBlock;
|
---|
986 | RTCircBufAcquireWriteBlock(pDataConn->pCircBuf, cbToWrite, &pvBlock, &cbBlock);
|
---|
987 | if (cbBlock)
|
---|
988 | {
|
---|
989 | AssertBreak(cbData >= cbBlock);
|
---|
990 | memcpy(pvBlock, pvData, cbBlock);
|
---|
991 |
|
---|
992 | AssertBreak(cbToWrite >= cbBlock);
|
---|
993 | cbToWrite -= cbBlock;
|
---|
994 |
|
---|
995 | RTCircBufReleaseWriteBlock(pDataConn->pCircBuf, cbBlock);
|
---|
996 | }
|
---|
997 |
|
---|
998 | } while (cbToWrite);
|
---|
999 |
|
---|
1000 | if (RT_SUCCESS(rc))
|
---|
1001 | rc = rtFtpServerDataCheckFlush(pDataConn);
|
---|
1002 |
|
---|
1003 | return rc;
|
---|
1004 | }
|
---|
1005 |
|
---|
1006 | /**
|
---|
1007 | * Does a printf-style write on a data connection.
|
---|
1008 | *
|
---|
1009 | * @returns VBox status code.
|
---|
1010 | * @param pDataConn Data connection to write to.
|
---|
1011 | * @param pszFormat Format string to send. No (terminal) termination added.
|
---|
1012 | */
|
---|
1013 | static int rtFtpServerDataConnPrintf(PRTFTPSERVERDATACONN pDataConn, const char *pszFormat, ...)
|
---|
1014 | {
|
---|
1015 | va_list args;
|
---|
1016 | va_start(args, pszFormat);
|
---|
1017 | char *pszFmt = NULL;
|
---|
1018 | const int cch = RTStrAPrintfV(&pszFmt, pszFormat, args);
|
---|
1019 | va_end(args);
|
---|
1020 | AssertReturn(cch > 0, VERR_NO_MEMORY);
|
---|
1021 |
|
---|
1022 | char *pszMsg = NULL;
|
---|
1023 | int rc = RTStrAAppend(&pszMsg, pszFmt);
|
---|
1024 | AssertRCReturn(rc, rc);
|
---|
1025 |
|
---|
1026 | RTStrFree(pszFmt);
|
---|
1027 |
|
---|
1028 | rc = rtFtpServerDataConnAddData(pDataConn, pszMsg, strlen(pszMsg));
|
---|
1029 |
|
---|
1030 | RTStrFree(pszMsg);
|
---|
1031 |
|
---|
1032 | return rc;
|
---|
1033 | }
|
---|
1034 |
|
---|
1035 | /**
|
---|
1036 | * Data connection thread for writing (sending) a file to the client.
|
---|
1037 | *
|
---|
1038 | * @returns VBox status code.
|
---|
1039 | * @param ThreadSelf Thread handle. Unused at the moment.
|
---|
1040 | * @param pvUser Pointer to user-provided data. Of type PRTFTPSERVERCLIENT.
|
---|
1041 | */
|
---|
1042 | static DECLCALLBACK(int) rtFtpServerDataConnFileWriteThread(RTTHREAD ThreadSelf, void *pvUser)
|
---|
1043 | {
|
---|
1044 | RT_NOREF(ThreadSelf);
|
---|
1045 |
|
---|
1046 | PRTFTPSERVERCLIENT pClient = (PRTFTPSERVERCLIENT)pvUser;
|
---|
1047 | AssertPtr(pClient);
|
---|
1048 |
|
---|
1049 | PRTFTPSERVERDATACONN pDataConn = pClient->pDataConn;
|
---|
1050 | AssertPtr(pDataConn);
|
---|
1051 |
|
---|
1052 | LogFlowFuncEnter();
|
---|
1053 |
|
---|
1054 | uint32_t cbBuf = _64K; /** @todo Improve this. */
|
---|
1055 | void *pvBuf = RTMemAlloc(cbBuf);
|
---|
1056 | if (!pvBuf)
|
---|
1057 | return VERR_NO_MEMORY;
|
---|
1058 |
|
---|
1059 | int rc;
|
---|
1060 |
|
---|
1061 | /* Set start indicator. */
|
---|
1062 | pDataConn->fStarted = true;
|
---|
1063 |
|
---|
1064 | RTThreadUserSignal(RTThreadSelf());
|
---|
1065 |
|
---|
1066 | AssertPtr(pDataConn->papszArgs);
|
---|
1067 | const char *pszFile = pDataConn->papszArgs[0];
|
---|
1068 | AssertPtr(pszFile);
|
---|
1069 |
|
---|
1070 | void *pvHandle = NULL; /* Opaque handle known to the actual implementation. */
|
---|
1071 |
|
---|
1072 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnFileOpen, pszFile,
|
---|
1073 | RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE, &pvHandle);
|
---|
1074 | if (RT_SUCCESS(rc))
|
---|
1075 | {
|
---|
1076 | LogFlowFunc(("Transfer started\n"));
|
---|
1077 |
|
---|
1078 | do
|
---|
1079 | {
|
---|
1080 | size_t cbRead = 0;
|
---|
1081 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnFileRead, pvHandle, pvBuf, cbBuf, &cbRead);
|
---|
1082 | if ( RT_SUCCESS(rc)
|
---|
1083 | && cbRead)
|
---|
1084 | {
|
---|
1085 | rc = rtFtpServerDataConnWrite(pDataConn, pvBuf, cbRead, NULL /* pcbWritten */);
|
---|
1086 | }
|
---|
1087 |
|
---|
1088 | if ( !cbRead
|
---|
1089 | || ASMAtomicReadBool(&pDataConn->fStop))
|
---|
1090 | {
|
---|
1091 | break;
|
---|
1092 | }
|
---|
1093 | }
|
---|
1094 | while (RT_SUCCESS(rc));
|
---|
1095 |
|
---|
1096 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnFileClose, pvHandle);
|
---|
1097 |
|
---|
1098 | LogFlowFunc(("Transfer done\n"));
|
---|
1099 | }
|
---|
1100 |
|
---|
1101 | RTMemFree(pvBuf);
|
---|
1102 | pvBuf = NULL;
|
---|
1103 |
|
---|
1104 | pDataConn->fStopped = true;
|
---|
1105 | pDataConn->rc = rc;
|
---|
1106 |
|
---|
1107 | LogFlowFuncLeaveRC(rc);
|
---|
1108 | return rc;
|
---|
1109 | }
|
---|
1110 |
|
---|
1111 | /**
|
---|
1112 | * Creates a data connection.
|
---|
1113 | *
|
---|
1114 | * @returns VBox status code.
|
---|
1115 | * @param pClient Client to create data connection for.
|
---|
1116 | * @param ppDataConn Where to return the (allocated) data connection.
|
---|
1117 | */
|
---|
1118 | static int rtFtpServerDataConnCreate(PRTFTPSERVERCLIENT pClient, PRTFTPSERVERDATACONN *ppDataConn)
|
---|
1119 | {
|
---|
1120 | if (pClient->pDataConn)
|
---|
1121 | return VERR_FTP_DATA_CONN_LIMIT_REACHED;
|
---|
1122 |
|
---|
1123 | PRTFTPSERVERDATACONN pDataConn = (PRTFTPSERVERDATACONN)RTMemAllocZ(sizeof(RTFTPSERVERDATACONN));
|
---|
1124 | if (!pDataConn)
|
---|
1125 | return VERR_NO_MEMORY;
|
---|
1126 |
|
---|
1127 | rtFtpServerDataConnReset(pDataConn);
|
---|
1128 |
|
---|
1129 | pDataConn->pClient = pClient;
|
---|
1130 |
|
---|
1131 | /* Use the last configured addr + port. */
|
---|
1132 | pDataConn->Addr = pClient->DataConnAddr;
|
---|
1133 | pDataConn->uPort = pClient->uDataConnPort;
|
---|
1134 |
|
---|
1135 | int rc = RTCircBufCreate(&pDataConn->pCircBuf, _16K); /** @todo Some random value; improve. */
|
---|
1136 | if (RT_SUCCESS(rc))
|
---|
1137 | {
|
---|
1138 | *ppDataConn = pDataConn;
|
---|
1139 | }
|
---|
1140 |
|
---|
1141 | LogFlowFuncLeaveRC(VINF_SUCCESS);
|
---|
1142 | return rc;
|
---|
1143 | }
|
---|
1144 |
|
---|
1145 | /**
|
---|
1146 | * Starts a data connection.
|
---|
1147 | *
|
---|
1148 | * @returns VBox status code.
|
---|
1149 | * @param pDataConn Data connection to start.
|
---|
1150 | * @param pfnThread Thread function for the data connection to use.
|
---|
1151 | * @param cArgs Number of arguments.
|
---|
1152 | * @param apszArgs Array of arguments.
|
---|
1153 | */
|
---|
1154 | static int rtFtpServerDataConnStart(PRTFTPSERVERDATACONN pDataConn, PFNRTTHREAD pfnThread,
|
---|
1155 | uint8_t cArgs, const char * const *apszArgs)
|
---|
1156 | {
|
---|
1157 | AssertPtrReturn(pDataConn, VERR_INVALID_POINTER);
|
---|
1158 | AssertPtrReturn(pfnThread, VERR_INVALID_POINTER);
|
---|
1159 |
|
---|
1160 | AssertReturn(!pDataConn->fStarted, VERR_WRONG_ORDER);
|
---|
1161 | AssertReturn(!pDataConn->fStop, VERR_WRONG_ORDER);
|
---|
1162 | AssertReturn(!pDataConn->fStopped, VERR_WRONG_ORDER);
|
---|
1163 |
|
---|
1164 | int rc = VINF_SUCCESS;
|
---|
1165 |
|
---|
1166 | if (cArgs)
|
---|
1167 | {
|
---|
1168 | pDataConn->papszArgs = rtFtpCmdArgsDup(cArgs, apszArgs);
|
---|
1169 | if (!pDataConn->papszArgs)
|
---|
1170 | rc = VERR_NO_MEMORY;
|
---|
1171 | }
|
---|
1172 |
|
---|
1173 | if (RT_SUCCESS(rc))
|
---|
1174 | {
|
---|
1175 | pDataConn->cArgs = cArgs;
|
---|
1176 |
|
---|
1177 | rc = rtFtpServerDataConnOpen(pDataConn, &pDataConn->Addr, pDataConn->uPort);
|
---|
1178 | if (RT_SUCCESS(rc))
|
---|
1179 | {
|
---|
1180 | rc = RTThreadCreate(&pDataConn->hThread, pfnThread,
|
---|
1181 | pDataConn->pClient, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE,
|
---|
1182 | "ftpdata");
|
---|
1183 | if (RT_SUCCESS(rc))
|
---|
1184 | {
|
---|
1185 | int rc2 = RTThreadUserWait(pDataConn->hThread, 30 * 1000 /* Timeout in ms */);
|
---|
1186 | AssertRC(rc2);
|
---|
1187 |
|
---|
1188 | if (!pDataConn->fStarted) /* Did the thread indicate that it started correctly? */
|
---|
1189 | rc = VERR_FTP_DATA_CONN_INIT_FAILED;
|
---|
1190 | }
|
---|
1191 |
|
---|
1192 | if (RT_FAILURE(rc))
|
---|
1193 | rtFtpServerDataConnClose(pDataConn);
|
---|
1194 | }
|
---|
1195 | }
|
---|
1196 |
|
---|
1197 | if (RT_FAILURE(rc))
|
---|
1198 | {
|
---|
1199 | rtFtpCmdArgsFree(pDataConn->cArgs, pDataConn->papszArgs);
|
---|
1200 |
|
---|
1201 | pDataConn->cArgs = 0;
|
---|
1202 | pDataConn->papszArgs = NULL;
|
---|
1203 | }
|
---|
1204 |
|
---|
1205 | LogFlowFuncLeaveRC(rc);
|
---|
1206 | return rc;
|
---|
1207 | }
|
---|
1208 |
|
---|
1209 | /**
|
---|
1210 | * Stops a data connection.
|
---|
1211 | *
|
---|
1212 | * @returns VBox status code.
|
---|
1213 | * @param pDataConn Data connection to stop.
|
---|
1214 | */
|
---|
1215 | static int rtFtpServerDataConnStop(PRTFTPSERVERDATACONN pDataConn)
|
---|
1216 | {
|
---|
1217 | if (!pDataConn)
|
---|
1218 | return VINF_SUCCESS;
|
---|
1219 |
|
---|
1220 | LogFlowFuncEnter();
|
---|
1221 |
|
---|
1222 | int rc = VINF_SUCCESS;
|
---|
1223 |
|
---|
1224 | if (pDataConn->hThread != NIL_RTTHREAD)
|
---|
1225 | {
|
---|
1226 | /* Set stop indicator. */
|
---|
1227 | pDataConn->fStop = true;
|
---|
1228 |
|
---|
1229 | int rcThread = VERR_WRONG_ORDER;
|
---|
1230 | rc = RTThreadWait(pDataConn->hThread, 30 * 1000 /* Timeout in ms */, &rcThread);
|
---|
1231 | }
|
---|
1232 |
|
---|
1233 | if (RT_SUCCESS(rc))
|
---|
1234 | rtFtpServerDataConnClose(pDataConn);
|
---|
1235 |
|
---|
1236 | LogFlowFuncLeaveRC(rc);
|
---|
1237 | return rc;
|
---|
1238 | }
|
---|
1239 |
|
---|
1240 | /**
|
---|
1241 | * Destroys a data connection.
|
---|
1242 | *
|
---|
1243 | * @param pDataConn Data connection to destroy. The pointer is not valid anymore after successful return.
|
---|
1244 | */
|
---|
1245 | static void rtFtpServerDataConnDestroy(PRTFTPSERVERDATACONN pDataConn)
|
---|
1246 | {
|
---|
1247 | if (!pDataConn)
|
---|
1248 | return;
|
---|
1249 |
|
---|
1250 | LogFlowFuncEnter();
|
---|
1251 |
|
---|
1252 | rtFtpServerDataConnClose(pDataConn);
|
---|
1253 | rtFtpCmdArgsFree(pDataConn->cArgs, pDataConn->papszArgs);
|
---|
1254 |
|
---|
1255 | RTCircBufDestroy(pDataConn->pCircBuf);
|
---|
1256 |
|
---|
1257 | RTMemFree(pDataConn);
|
---|
1258 | pDataConn = NULL;
|
---|
1259 |
|
---|
1260 | LogFlowFuncLeave();
|
---|
1261 | return;
|
---|
1262 | }
|
---|
1263 |
|
---|
1264 | /**
|
---|
1265 | * Resets a data connection structure.
|
---|
1266 | *
|
---|
1267 | * @param pDataConn Data connection structure to reset.
|
---|
1268 | */
|
---|
1269 | static void rtFtpServerDataConnReset(PRTFTPSERVERDATACONN pDataConn)
|
---|
1270 | {
|
---|
1271 | LogFlowFuncEnter();
|
---|
1272 |
|
---|
1273 | pDataConn->hSocket = NIL_RTSOCKET;
|
---|
1274 | pDataConn->uPort = 20; /* Default port to use. */
|
---|
1275 | pDataConn->hThread = NIL_RTTHREAD;
|
---|
1276 | pDataConn->fStarted = false;
|
---|
1277 | pDataConn->fStop = false;
|
---|
1278 | pDataConn->fStopped = false;
|
---|
1279 | pDataConn->rc = VERR_IPE_UNINITIALIZED_STATUS;
|
---|
1280 | }
|
---|
1281 |
|
---|
1282 |
|
---|
1283 | /*********************************************************************************************************************************
|
---|
1284 | * Command Protocol Handlers *
|
---|
1285 | *********************************************************************************************************************************/
|
---|
1286 |
|
---|
1287 | static DECLCALLBACK(int) rtFtpServerHandleABOR(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1288 | {
|
---|
1289 | RT_NOREF(cArgs, apszArgs);
|
---|
1290 |
|
---|
1291 | int rc = rtFtpServerDataConnClose(pClient->pDataConn);
|
---|
1292 | if (RT_SUCCESS(rc))
|
---|
1293 | {
|
---|
1294 | rtFtpServerDataConnDestroy(pClient->pDataConn);
|
---|
1295 | pClient->pDataConn = NULL;
|
---|
1296 |
|
---|
1297 | rc = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_OKAY);
|
---|
1298 | }
|
---|
1299 |
|
---|
1300 | return rc;
|
---|
1301 | }
|
---|
1302 |
|
---|
1303 | static DECLCALLBACK(int) rtFtpServerHandleCDUP(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1304 | {
|
---|
1305 | RT_NOREF(cArgs, apszArgs);
|
---|
1306 |
|
---|
1307 | int rc;
|
---|
1308 |
|
---|
1309 | RTFTPSERVER_HANDLE_CALLBACK(pfnOnPathUp);
|
---|
1310 |
|
---|
1311 | if (RT_SUCCESS(rc))
|
---|
1312 | {
|
---|
1313 | const size_t cbPath = sizeof(char) * RTFTPSERVER_MAX_PATH;
|
---|
1314 | char *pszPath = RTStrAlloc(cbPath);
|
---|
1315 | if (pszPath)
|
---|
1316 | {
|
---|
1317 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnPathGetCurrent, pszPath, cbPath);
|
---|
1318 |
|
---|
1319 | if (RT_SUCCESS(rc))
|
---|
1320 | rc = rtFtpSetCWD(&pClient->State, pszPath);
|
---|
1321 |
|
---|
1322 | RTStrFree(pszPath);
|
---|
1323 |
|
---|
1324 | rc = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_OKAY);
|
---|
1325 | }
|
---|
1326 | else
|
---|
1327 | rc = VERR_NO_MEMORY;
|
---|
1328 | }
|
---|
1329 |
|
---|
1330 | if (RT_FAILURE(rc))
|
---|
1331 | {
|
---|
1332 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_CONN_REQ_FILE_ACTION_NOT_TAKEN);
|
---|
1333 | AssertRC(rc2);
|
---|
1334 | }
|
---|
1335 |
|
---|
1336 | return rc;
|
---|
1337 | }
|
---|
1338 |
|
---|
1339 | static DECLCALLBACK(int) rtFtpServerHandleCWD(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1340 | {
|
---|
1341 | if (cArgs != 1)
|
---|
1342 | return VERR_INVALID_PARAMETER;
|
---|
1343 |
|
---|
1344 | int rc;
|
---|
1345 |
|
---|
1346 | const char *pszPath = apszArgs[0];
|
---|
1347 |
|
---|
1348 | if (!rtFtpServerPathIsValid(pszPath, false /* fIsAbsolute */))
|
---|
1349 | return VERR_INVALID_PARAMETER;
|
---|
1350 |
|
---|
1351 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnPathSetCurrent, pszPath);
|
---|
1352 |
|
---|
1353 | if (RT_SUCCESS(rc))
|
---|
1354 | rc = rtFtpSetCWD(&pClient->State, pszPath);
|
---|
1355 |
|
---|
1356 | return rtFtpServerSendReplyRc(pClient,
|
---|
1357 | RT_SUCCESS(rc)
|
---|
1358 | ? RTFTPSERVER_REPLY_OKAY : RTFTPSERVER_REPLY_CONN_REQ_FILE_ACTION_NOT_TAKEN);
|
---|
1359 | }
|
---|
1360 |
|
---|
1361 | static DECLCALLBACK(int) rtFtpServerHandleFEAT(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1362 | {
|
---|
1363 | RT_NOREF(cArgs, apszArgs);
|
---|
1364 |
|
---|
1365 | int rc = rtFtpServerSendReplyStr(pClient, "211-BEGIN Features:");
|
---|
1366 | if (RT_SUCCESS(rc))
|
---|
1367 | {
|
---|
1368 | rc = rtFtpServerSendReplyStr(pClient, RTFTPSERVER_FEATURES_STRING);
|
---|
1369 | if (RT_SUCCESS(rc))
|
---|
1370 | rc = rtFtpServerSendReplyStr(pClient, "211 END Features");
|
---|
1371 | }
|
---|
1372 |
|
---|
1373 | return rc;
|
---|
1374 | }
|
---|
1375 |
|
---|
1376 | /**
|
---|
1377 | * Formats the given user ID according to the specified options.
|
---|
1378 | *
|
---|
1379 | * @returns pszDst
|
---|
1380 | * @param uid The UID to format.
|
---|
1381 | * @param pszOwner The owner returned by the FS.
|
---|
1382 | * @param pszDst The output buffer.
|
---|
1383 | * @param cbDst The output buffer size.
|
---|
1384 | */
|
---|
1385 | static const char *rtFtpServerDecimalFormatOwner(RTUID uid, const char *pszOwner, char *pszDst, size_t cbDst)
|
---|
1386 | {
|
---|
1387 | if (pszOwner)
|
---|
1388 | {
|
---|
1389 | RTStrCopy(pszDst, cbDst, pszOwner);
|
---|
1390 | return pszDst;
|
---|
1391 | }
|
---|
1392 | if (uid == NIL_RTUID)
|
---|
1393 | return "<Nil>";
|
---|
1394 |
|
---|
1395 | RTStrFormatU64(pszDst, cbDst, uid, 10, 0, 0, 0);
|
---|
1396 | return pszDst;
|
---|
1397 | }
|
---|
1398 |
|
---|
1399 | /**
|
---|
1400 | * Formats the given group ID according to the specified options.
|
---|
1401 | *
|
---|
1402 | * @returns pszDst
|
---|
1403 | * @param gid The GID to format.
|
---|
1404 | * @param pszGroup The group returned by the FS.
|
---|
1405 | * @param pszDst The output buffer.
|
---|
1406 | * @param cbDst The output buffer size.
|
---|
1407 | */
|
---|
1408 | static const char *rtFtpServerDecimalFormatGroup(RTGID gid, const char *pszGroup, char *pszDst, size_t cbDst)
|
---|
1409 | {
|
---|
1410 | if (pszGroup)
|
---|
1411 | {
|
---|
1412 | RTStrCopy(pszDst, cbDst, pszGroup);
|
---|
1413 | return pszDst;
|
---|
1414 | }
|
---|
1415 | if (gid == NIL_RTGID)
|
---|
1416 | return "<Nil>";
|
---|
1417 |
|
---|
1418 | RTStrFormatU64(pszDst, cbDst, gid, 10, 0, 0, 0);
|
---|
1419 | return pszDst;
|
---|
1420 | }
|
---|
1421 |
|
---|
1422 | /**
|
---|
1423 | * Format file size.
|
---|
1424 | */
|
---|
1425 | static const char *rtFtpServerFormatSize(uint64_t cb, char *pszDst, size_t cbDst)
|
---|
1426 | {
|
---|
1427 | RTStrFormatU64(pszDst, cbDst, cb, 10, 0, 0, 0);
|
---|
1428 | return pszDst;
|
---|
1429 | }
|
---|
1430 |
|
---|
1431 | /**
|
---|
1432 | * Formats the given timestamp according to (non-standardized) FTP LIST command.
|
---|
1433 | *
|
---|
1434 | * @returns pszDst
|
---|
1435 | * @param pTimestamp The timestamp to format.
|
---|
1436 | * @param pszDst The output buffer.
|
---|
1437 | * @param cbDst The output buffer size.
|
---|
1438 | */
|
---|
1439 | static const char *rtFtpServerFormatTimestamp(PCRTTIMESPEC pTimestamp, char *pszDst, size_t cbDst)
|
---|
1440 | {
|
---|
1441 | RTTIME Time;
|
---|
1442 | RTTimeExplode(&Time, pTimestamp);
|
---|
1443 |
|
---|
1444 | /* Calc the UTC offset part. */
|
---|
1445 | int32_t offUtc = Time.offUTC;
|
---|
1446 | Assert(offUtc <= 840 && offUtc >= -840);
|
---|
1447 | char chSign;
|
---|
1448 | if (offUtc >= 0)
|
---|
1449 | chSign = '+';
|
---|
1450 | else
|
---|
1451 | {
|
---|
1452 | chSign = '-';
|
---|
1453 | offUtc = -offUtc;
|
---|
1454 | }
|
---|
1455 | uint32_t offUtcHour = (uint32_t)offUtc / 60;
|
---|
1456 | uint32_t offUtcMinute = (uint32_t)offUtc % 60;
|
---|
1457 |
|
---|
1458 | /** @todo Cache this. */
|
---|
1459 | RTTIMESPEC TimeSpecNow;
|
---|
1460 | RTTimeNow(&TimeSpecNow);
|
---|
1461 | RTTIME TimeNow;
|
---|
1462 | RTTimeExplode(&TimeNow, &TimeSpecNow);
|
---|
1463 |
|
---|
1464 | /* Only include the year if it's not the same year as today. */
|
---|
1465 | if (TimeNow.i32Year != Time.i32Year)
|
---|
1466 | {
|
---|
1467 | RTStrPrintf(pszDst, cbDst, "%s %02RU8 %5RU32",
|
---|
1468 | g_apszMonths[Time.u8Month], Time.u8MonthDay, Time.i32Year);
|
---|
1469 | }
|
---|
1470 | else /* ... otherwise include the (rough) time (as GMT). */
|
---|
1471 | {
|
---|
1472 | RTStrPrintf(pszDst, cbDst, "%s %02RU8 %02RU32:%02RU32",
|
---|
1473 | g_apszMonths[Time.u8Month], Time.u8MonthDay, offUtcHour, offUtcMinute);
|
---|
1474 | }
|
---|
1475 |
|
---|
1476 | return pszDst;
|
---|
1477 | }
|
---|
1478 |
|
---|
1479 | /**
|
---|
1480 | * Format name, i.e. escape, hide, quote stuff.
|
---|
1481 | */
|
---|
1482 | static const char *rtFtpServerFormatName(const char *pszName, char *pszDst, size_t cbDst)
|
---|
1483 | {
|
---|
1484 | /** @todo implement name formatting. */
|
---|
1485 | RT_NOREF(pszDst, cbDst);
|
---|
1486 | return pszName;
|
---|
1487 | }
|
---|
1488 |
|
---|
1489 | /**
|
---|
1490 | * Figures out the length for a 32-bit number when formatted as decimal.
|
---|
1491 | * @returns Number of digits.
|
---|
1492 | * @param uValue The number.
|
---|
1493 | */
|
---|
1494 | DECLINLINE(size_t) rtFtpServerDecimalFormatLengthU32(uint32_t uValue)
|
---|
1495 | {
|
---|
1496 | if (uValue < 10)
|
---|
1497 | return 1;
|
---|
1498 | if (uValue < 100)
|
---|
1499 | return 2;
|
---|
1500 | if (uValue < 1000)
|
---|
1501 | return 3;
|
---|
1502 | if (uValue < 10000)
|
---|
1503 | return 4;
|
---|
1504 | if (uValue < 100000)
|
---|
1505 | return 5;
|
---|
1506 | if (uValue < 1000000)
|
---|
1507 | return 6;
|
---|
1508 | if (uValue < 10000000)
|
---|
1509 | return 7;
|
---|
1510 | if (uValue < 100000000)
|
---|
1511 | return 8;
|
---|
1512 | if (uValue < 1000000000)
|
---|
1513 | return 9;
|
---|
1514 | return 10;
|
---|
1515 | }
|
---|
1516 |
|
---|
1517 | /**
|
---|
1518 | * Allocates a new directory collection.
|
---|
1519 | *
|
---|
1520 | * @returns The collection allocated.
|
---|
1521 | */
|
---|
1522 | static PRTFTPDIRCOLLECTION rtFtpServerDataConnDirCollAlloc(void)
|
---|
1523 | {
|
---|
1524 | return (PRTFTPDIRCOLLECTION)RTMemAllocZ(sizeof(RTFTPDIRCOLLECTION));
|
---|
1525 | }
|
---|
1526 |
|
---|
1527 | /**
|
---|
1528 | * Frees a directory collection and its entries.
|
---|
1529 | *
|
---|
1530 | * @param pCollection The collection to free.
|
---|
1531 | */
|
---|
1532 | static void rtFtpServerDataConnDirCollFree(PRTFTPDIRCOLLECTION pCollection)
|
---|
1533 | {
|
---|
1534 | PPRTFTPDIRENTRY papEntries = pCollection->papEntries;
|
---|
1535 | size_t j = pCollection->cEntries;
|
---|
1536 | while (j-- > 0)
|
---|
1537 | {
|
---|
1538 | RTMemFree(papEntries[j]);
|
---|
1539 | papEntries[j] = NULL;
|
---|
1540 | }
|
---|
1541 | RTMemFree(papEntries);
|
---|
1542 | pCollection->papEntries = NULL;
|
---|
1543 | pCollection->cEntries = 0;
|
---|
1544 | pCollection->cEntriesAllocated = 0;
|
---|
1545 | RTMemFree(pCollection);
|
---|
1546 | }
|
---|
1547 |
|
---|
1548 | /**
|
---|
1549 | * Adds one entry to a collection.
|
---|
1550 | *
|
---|
1551 | * @returns VBox status code.
|
---|
1552 | * @param pCollection The collection to add entry to.
|
---|
1553 | * @param pszEntry The entry name.
|
---|
1554 | * @param pInfo The entry info.
|
---|
1555 | * @param pszOwner The owner name if available, otherwise NULL.
|
---|
1556 | * @param pszGroup The group anme if available, otherwise NULL.
|
---|
1557 | * @param pszTarget The symbolic link target if applicable and
|
---|
1558 | * available, otherwise NULL.
|
---|
1559 | */
|
---|
1560 | static int rtFtpServerDataConnDirCollAddEntry(PRTFTPDIRCOLLECTION pCollection, const char *pszEntry, PRTFSOBJINFO pInfo,
|
---|
1561 | const char *pszOwner, const char *pszGroup, const char *pszTarget)
|
---|
1562 | {
|
---|
1563 | /* Filter out entries we don't want to report to the client, even if they were reported by the actual implementation. */
|
---|
1564 | if ( !RTStrCmp(pszEntry, ".")
|
---|
1565 | || !RTStrCmp(pszEntry, ".."))
|
---|
1566 | {
|
---|
1567 | return VINF_SUCCESS;
|
---|
1568 | }
|
---|
1569 |
|
---|
1570 | /* Anything else besides files and directores is not allowed; just don't show them at all for the moment. */
|
---|
1571 | switch (pInfo->Attr.fMode & RTFS_TYPE_MASK)
|
---|
1572 | {
|
---|
1573 | case RTFS_TYPE_DIRECTORY:
|
---|
1574 | RT_FALL_THROUGH();
|
---|
1575 | case RTFS_TYPE_FILE:
|
---|
1576 | break;
|
---|
1577 |
|
---|
1578 | default:
|
---|
1579 | return VINF_SUCCESS;
|
---|
1580 | }
|
---|
1581 |
|
---|
1582 | /* Make sure there is space in the collection for the new entry. */
|
---|
1583 | if (pCollection->cEntries >= pCollection->cEntriesAllocated)
|
---|
1584 | {
|
---|
1585 | size_t cNew = pCollection->cEntriesAllocated ? pCollection->cEntriesAllocated * 2 : 16;
|
---|
1586 | void *pvNew = RTMemRealloc(pCollection->papEntries, cNew * sizeof(pCollection->papEntries[0]));
|
---|
1587 | if (!pvNew)
|
---|
1588 | return VERR_NO_MEMORY;
|
---|
1589 | pCollection->papEntries = (PPRTFTPDIRENTRY)pvNew;
|
---|
1590 | pCollection->cEntriesAllocated = cNew;
|
---|
1591 | }
|
---|
1592 |
|
---|
1593 | /* Create and insert a new entry. */
|
---|
1594 | size_t const cchEntry = strlen(pszEntry);
|
---|
1595 | size_t const cbOwner = pszOwner ? strlen(pszOwner) + 1 : 0;
|
---|
1596 | size_t const cbGroup = pszGroup ? strlen(pszGroup) + 1 : 0;
|
---|
1597 | size_t const cbTarget = pszTarget ? strlen(pszTarget) + 1 : 0;
|
---|
1598 | size_t const cbEntry = RT_UOFFSETOF_DYN(RTFTPDIRENTRY, szName[cchEntry + 1 + cbOwner + cbGroup + cbTarget]);
|
---|
1599 | PRTFTPDIRENTRY pEntry = (PRTFTPDIRENTRY)RTMemAlloc(cbEntry);
|
---|
1600 | if (pEntry)
|
---|
1601 | {
|
---|
1602 | pEntry->Info = *pInfo;
|
---|
1603 | pEntry->pszTarget = NULL; /** @todo symbolic links. */
|
---|
1604 | pEntry->pszOwner = NULL;
|
---|
1605 | pEntry->pszGroup = NULL;
|
---|
1606 | pEntry->cchName = cchEntry;
|
---|
1607 | memcpy(pEntry->szName, pszEntry, cchEntry);
|
---|
1608 | pEntry->szName[cchEntry] = '\0';
|
---|
1609 |
|
---|
1610 | char *psz = &pEntry->szName[cchEntry + 1];
|
---|
1611 | if (pszTarget)
|
---|
1612 | {
|
---|
1613 | pEntry->pszTarget = psz;
|
---|
1614 | memcpy(psz, pszTarget, cbTarget);
|
---|
1615 | psz += cbTarget;
|
---|
1616 | }
|
---|
1617 | if (pszOwner)
|
---|
1618 | {
|
---|
1619 | pEntry->pszOwner = psz;
|
---|
1620 | memcpy(psz, pszOwner, cbOwner);
|
---|
1621 | psz += cbOwner;
|
---|
1622 | }
|
---|
1623 | if (pszGroup)
|
---|
1624 | {
|
---|
1625 | pEntry->pszGroup = psz;
|
---|
1626 | memcpy(psz, pszGroup, cbGroup);
|
---|
1627 | }
|
---|
1628 |
|
---|
1629 | pCollection->papEntries[pCollection->cEntries++] = pEntry;
|
---|
1630 | pCollection->cbTotalAllocated += pEntry->Info.cbAllocated;
|
---|
1631 | pCollection->cbTotalFiles += pEntry->Info.cbObject;
|
---|
1632 | return VINF_SUCCESS;
|
---|
1633 | }
|
---|
1634 | return VERR_NO_MEMORY;
|
---|
1635 | }
|
---|
1636 |
|
---|
1637 | /** @callback_method_impl{FNRTSORTCMP, Name} */
|
---|
1638 | static DECLCALLBACK(int) rtFtpServerCollEntryCmpName(void const *pvElement1, void const *pvElement2, void *pvUser)
|
---|
1639 | {
|
---|
1640 | RT_NOREF(pvUser);
|
---|
1641 | PRTFTPDIRENTRY pEntry1 = (PRTFTPDIRENTRY)pvElement1;
|
---|
1642 | PRTFTPDIRENTRY pEntry2 = (PRTFTPDIRENTRY)pvElement2;
|
---|
1643 | return RTStrCmp(pEntry1->szName, pEntry2->szName);
|
---|
1644 | }
|
---|
1645 |
|
---|
1646 | /** @callback_method_impl{FNRTSORTCMP, Dirs first + Name} */
|
---|
1647 | static DECLCALLBACK(int) rtFtpServerCollEntryCmpDirFirstName(void const *pvElement1, void const *pvElement2, void *pvUser)
|
---|
1648 | {
|
---|
1649 | RT_NOREF(pvUser);
|
---|
1650 | PRTFTPDIRENTRY pEntry1 = (PRTFTPDIRENTRY)pvElement1;
|
---|
1651 | PRTFTPDIRENTRY pEntry2 = (PRTFTPDIRENTRY)pvElement2;
|
---|
1652 | int iDiff = !RTFS_IS_DIRECTORY(pEntry1->Info.Attr.fMode) - !RTFS_IS_DIRECTORY(pEntry2->Info.Attr.fMode);
|
---|
1653 | if (!iDiff)
|
---|
1654 | iDiff = rtFtpServerCollEntryCmpName(pEntry1, pEntry2, pvUser);
|
---|
1655 | return iDiff;
|
---|
1656 | }
|
---|
1657 |
|
---|
1658 | /**
|
---|
1659 | * Sorts a given directory collection according to the FTP server's LIST style.
|
---|
1660 | *
|
---|
1661 | * @param pCollection Collection to sort.
|
---|
1662 | */
|
---|
1663 | static void rtFtpServerCollSort(PRTFTPDIRCOLLECTION pCollection)
|
---|
1664 | {
|
---|
1665 | PFNRTSORTCMP pfnCmp = rtFtpServerCollEntryCmpDirFirstName;
|
---|
1666 | if (pfnCmp)
|
---|
1667 | RTSortApvShell((void **)pCollection->papEntries, pCollection->cEntries, pfnCmp, NULL);
|
---|
1668 | }
|
---|
1669 |
|
---|
1670 | /**
|
---|
1671 | * Writes a directory collection to a specific data connection.
|
---|
1672 | *
|
---|
1673 | * @returns VBox status code.
|
---|
1674 | * @param pDataConn Data connection to write directory collection to.
|
---|
1675 | * @param pCollection Collection to write.
|
---|
1676 | * @param pszTmp Temporary buffer used for writing.
|
---|
1677 | * @param cbTmp Size (in bytes) of temporary buffer used for writing.
|
---|
1678 | */
|
---|
1679 | static int rtFtpServerDataConnDirCollWrite(PRTFTPSERVERDATACONN pDataConn, PRTFTPDIRCOLLECTION pCollection,
|
---|
1680 | char *pszTmp, size_t cbTmp)
|
---|
1681 | {
|
---|
1682 | size_t cchSizeCol = 4;
|
---|
1683 | size_t cchLinkCol = 1;
|
---|
1684 | size_t cchUidCol = 1;
|
---|
1685 | size_t cchGidCol = 1;
|
---|
1686 |
|
---|
1687 | size_t i = pCollection->cEntries;
|
---|
1688 | while (i-- > 0)
|
---|
1689 | {
|
---|
1690 | PRTFTPDIRENTRY pEntry = pCollection->papEntries[i];
|
---|
1691 |
|
---|
1692 | rtFtpServerFormatSize(pEntry->Info.cbObject, pszTmp, cbTmp);
|
---|
1693 | size_t cchTmp = strlen(pszTmp);
|
---|
1694 | if (cchTmp > cchSizeCol)
|
---|
1695 | cchSizeCol = cchTmp;
|
---|
1696 |
|
---|
1697 | cchTmp = rtFtpServerDecimalFormatLengthU32(pEntry->Info.Attr.u.Unix.cHardlinks) + 1;
|
---|
1698 | if (cchTmp > cchLinkCol)
|
---|
1699 | cchLinkCol = cchTmp;
|
---|
1700 |
|
---|
1701 | rtFtpServerDecimalFormatOwner(pEntry->Info.Attr.u.Unix.uid, pEntry->pszOwner, pszTmp, cbTmp);
|
---|
1702 | cchTmp = strlen(pszTmp);
|
---|
1703 | if (cchTmp > cchUidCol)
|
---|
1704 | cchUidCol = cchTmp;
|
---|
1705 |
|
---|
1706 | rtFtpServerDecimalFormatGroup(pEntry->Info.Attr.u.Unix.gid, pEntry->pszGroup, pszTmp, cbTmp);
|
---|
1707 | cchTmp = strlen(pszTmp);
|
---|
1708 | if (cchTmp > cchGidCol)
|
---|
1709 | cchGidCol = cchTmp;
|
---|
1710 | }
|
---|
1711 |
|
---|
1712 | size_t offTime = RT_UOFFSETOF(RTFTPDIRENTRY, Info.ModificationTime);
|
---|
1713 |
|
---|
1714 | /*
|
---|
1715 | * Display the entries.
|
---|
1716 | */
|
---|
1717 | for (i = 0; i < pCollection->cEntries; i++)
|
---|
1718 | {
|
---|
1719 | PRTFTPDIRENTRY pEntry = pCollection->papEntries[i];
|
---|
1720 |
|
---|
1721 | RTFMODE fMode = pEntry->Info.Attr.fMode;
|
---|
1722 | switch (fMode & RTFS_TYPE_MASK)
|
---|
1723 | {
|
---|
1724 | case RTFS_TYPE_FIFO: rtFtpServerDataConnPrintf(pDataConn, "f"); break;
|
---|
1725 | case RTFS_TYPE_DEV_CHAR: rtFtpServerDataConnPrintf(pDataConn, "c"); break;
|
---|
1726 | case RTFS_TYPE_DIRECTORY: rtFtpServerDataConnPrintf(pDataConn, "d"); break;
|
---|
1727 | case RTFS_TYPE_DEV_BLOCK: rtFtpServerDataConnPrintf(pDataConn, "b"); break;
|
---|
1728 | case RTFS_TYPE_FILE: rtFtpServerDataConnPrintf(pDataConn, "-"); break;
|
---|
1729 | case RTFS_TYPE_SYMLINK: rtFtpServerDataConnPrintf(pDataConn, "l"); break;
|
---|
1730 | case RTFS_TYPE_SOCKET: rtFtpServerDataConnPrintf(pDataConn, "s"); break;
|
---|
1731 | case RTFS_TYPE_WHITEOUT: rtFtpServerDataConnPrintf(pDataConn, "w"); break;
|
---|
1732 | default: rtFtpServerDataConnPrintf(pDataConn, "?"); AssertFailed(); break;
|
---|
1733 | }
|
---|
1734 |
|
---|
1735 | rtFtpServerDataConnPrintf(pDataConn, "%c%c%c",
|
---|
1736 | fMode & RTFS_UNIX_IRUSR ? 'r' : '-',
|
---|
1737 | fMode & RTFS_UNIX_IWUSR ? 'w' : '-',
|
---|
1738 | fMode & RTFS_UNIX_IXUSR ? 'x' : '-');
|
---|
1739 | rtFtpServerDataConnPrintf(pDataConn, "%c%c%c",
|
---|
1740 | fMode & RTFS_UNIX_IRGRP ? 'r' : '-',
|
---|
1741 | fMode & RTFS_UNIX_IWGRP ? 'w' : '-',
|
---|
1742 | fMode & RTFS_UNIX_IXGRP ? 'x' : '-');
|
---|
1743 | rtFtpServerDataConnPrintf(pDataConn, "%c%c%c",
|
---|
1744 | fMode & RTFS_UNIX_IROTH ? 'r' : '-',
|
---|
1745 | fMode & RTFS_UNIX_IWOTH ? 'w' : '-',
|
---|
1746 | fMode & RTFS_UNIX_IXOTH ? 'x' : '-');
|
---|
1747 |
|
---|
1748 | rtFtpServerDataConnPrintf(pDataConn, " %*u",
|
---|
1749 | cchLinkCol, pEntry->Info.Attr.u.Unix.cHardlinks);
|
---|
1750 |
|
---|
1751 | if (cchUidCol)
|
---|
1752 | rtFtpServerDataConnPrintf(pDataConn, " %*s", cchUidCol,
|
---|
1753 | rtFtpServerDecimalFormatOwner(pEntry->Info.Attr.u.Unix.uid, pEntry->pszOwner, pszTmp, cbTmp));
|
---|
1754 | if (cchGidCol)
|
---|
1755 | rtFtpServerDataConnPrintf(pDataConn, " %*s", cchGidCol,
|
---|
1756 | rtFtpServerDecimalFormatGroup(pEntry->Info.Attr.u.Unix.gid, pEntry->pszGroup, pszTmp, cbTmp));
|
---|
1757 |
|
---|
1758 | rtFtpServerDataConnPrintf(pDataConn, "%*s", cchSizeCol, rtFtpServerFormatSize(pEntry->Info.cbObject, pszTmp, cbTmp));
|
---|
1759 |
|
---|
1760 | PCRTTIMESPEC pTime = (PCRTTIMESPEC)((uintptr_t)pEntry + offTime);
|
---|
1761 | rtFtpServerDataConnPrintf(pDataConn," %s", rtFtpServerFormatTimestamp(pTime, pszTmp, cbTmp));
|
---|
1762 |
|
---|
1763 | rtFtpServerDataConnPrintf(pDataConn," %s\r\n", rtFtpServerFormatName(pEntry->szName, pszTmp, cbTmp));
|
---|
1764 | }
|
---|
1765 |
|
---|
1766 | return VINF_SUCCESS;
|
---|
1767 | }
|
---|
1768 |
|
---|
1769 | /**
|
---|
1770 | * Thread for handling the LIST command's output in a separate data connection.
|
---|
1771 | *
|
---|
1772 | * @returns VBox status code.
|
---|
1773 | * @param ThreadSelf Thread handle. Unused.
|
---|
1774 | * @param pvUser User-provided arguments. Of type PRTFTPSERVERCLIENT.
|
---|
1775 | */
|
---|
1776 | static DECLCALLBACK(int) rtFtpServerDataConnListThread(RTTHREAD ThreadSelf, void *pvUser)
|
---|
1777 | {
|
---|
1778 | RT_NOREF(ThreadSelf);
|
---|
1779 |
|
---|
1780 | PRTFTPSERVERCLIENT pClient = (PRTFTPSERVERCLIENT)pvUser;
|
---|
1781 | AssertPtr(pClient);
|
---|
1782 |
|
---|
1783 | PRTFTPSERVERDATACONN pDataConn = pClient->pDataConn;
|
---|
1784 | AssertPtr(pDataConn);
|
---|
1785 |
|
---|
1786 | LogFlowFuncEnter();
|
---|
1787 |
|
---|
1788 | int rc;
|
---|
1789 |
|
---|
1790 | char szTmp[RTPATH_MAX * 2];
|
---|
1791 | PRTFTPDIRCOLLECTION pColl = rtFtpServerDataConnDirCollAlloc();
|
---|
1792 | AssertPtrReturn(pColl, VERR_NO_MEMORY);
|
---|
1793 |
|
---|
1794 | /* Set start indicator. */
|
---|
1795 | pDataConn->fStarted = true;
|
---|
1796 |
|
---|
1797 | RTThreadUserSignal(RTThreadSelf());
|
---|
1798 |
|
---|
1799 | /* The first argument might indicate a directory to list.
|
---|
1800 | * If no argument is given, the implementation must use the last directory set. */
|
---|
1801 | char *pszPath = RTStrDup( pDataConn->cArgs == 1
|
---|
1802 | ? pDataConn->papszArgs[0] : pDataConn->pClient->State.pszCWD); /** @todo Needs locking. */
|
---|
1803 | AssertPtrReturnStmt(pszPath, rtFtpServerDataConnDirCollFree(pColl), VERR_NO_MEMORY);
|
---|
1804 | /* The paths already have been validated in the actual command handlers. */
|
---|
1805 |
|
---|
1806 | void *pvHandle = NULL; /* Shut up MSVC. */
|
---|
1807 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnDirOpen, pszPath, &pvHandle);
|
---|
1808 |
|
---|
1809 | for (;;)
|
---|
1810 | {
|
---|
1811 | RTFSOBJINFO objInfo;
|
---|
1812 | RT_ZERO(objInfo);
|
---|
1813 |
|
---|
1814 | char *pszEntry = NULL;
|
---|
1815 | char *pszOwner = NULL;
|
---|
1816 | char *pszGroup = NULL;
|
---|
1817 | char *pszTarget = NULL;
|
---|
1818 |
|
---|
1819 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnDirRead, pvHandle, &pszEntry,
|
---|
1820 | &objInfo, &pszOwner, &pszGroup, &pszTarget);
|
---|
1821 | if (RT_SUCCESS(rc))
|
---|
1822 | {
|
---|
1823 | int rc2 = rtFtpServerDataConnDirCollAddEntry(pColl, pszEntry,
|
---|
1824 | &objInfo, pszOwner, pszGroup, pszTarget);
|
---|
1825 |
|
---|
1826 | RTStrFree(pszEntry);
|
---|
1827 | pszEntry = NULL;
|
---|
1828 |
|
---|
1829 | RTStrFree(pszOwner);
|
---|
1830 | pszOwner = NULL;
|
---|
1831 |
|
---|
1832 | RTStrFree(pszGroup);
|
---|
1833 | pszGroup = NULL;
|
---|
1834 |
|
---|
1835 | RTStrFree(pszTarget);
|
---|
1836 | pszTarget = NULL;
|
---|
1837 |
|
---|
1838 | if (RT_SUCCESS(rc))
|
---|
1839 | rc = rc2;
|
---|
1840 | }
|
---|
1841 | else
|
---|
1842 | {
|
---|
1843 | if (rc == VERR_NO_MORE_FILES)
|
---|
1844 | {
|
---|
1845 | rc = VINF_SUCCESS;
|
---|
1846 | break;
|
---|
1847 | }
|
---|
1848 | }
|
---|
1849 |
|
---|
1850 | if (RT_FAILURE(rc))
|
---|
1851 | break;
|
---|
1852 |
|
---|
1853 | if (ASMAtomicReadBool(&pDataConn->fStop))
|
---|
1854 | break;
|
---|
1855 | }
|
---|
1856 |
|
---|
1857 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnDirClose, pvHandle);
|
---|
1858 | pvHandle = NULL;
|
---|
1859 |
|
---|
1860 | rtFtpServerCollSort(pColl);
|
---|
1861 |
|
---|
1862 | if (RT_SUCCESS(rc))
|
---|
1863 | {
|
---|
1864 | int rc2 = rtFtpServerDataConnDirCollWrite(pDataConn, pColl, szTmp, sizeof(szTmp));
|
---|
1865 | AssertRC(rc2);
|
---|
1866 | }
|
---|
1867 |
|
---|
1868 | rtFtpServerDataConnDirCollFree(pColl);
|
---|
1869 |
|
---|
1870 | RTStrFree(pszPath);
|
---|
1871 |
|
---|
1872 | pDataConn->fStopped = true;
|
---|
1873 | pDataConn->rc = rc;
|
---|
1874 |
|
---|
1875 | LogFlowFuncLeaveRC(rc);
|
---|
1876 | return rc;
|
---|
1877 | }
|
---|
1878 |
|
---|
1879 | static DECLCALLBACK(int) rtFtpServerHandleLIST(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1880 | {
|
---|
1881 | /* If no argument is given, use the server's CWD as the path. */
|
---|
1882 | const char *pszPath = cArgs ? apszArgs[0] : pClient->State.pszCWD;
|
---|
1883 | AssertPtr(pszPath);
|
---|
1884 |
|
---|
1885 | int rc = VINF_SUCCESS;
|
---|
1886 |
|
---|
1887 | if (!rtFtpServerPathIsValid(pszPath, false /* fIsAbsolute */))
|
---|
1888 | {
|
---|
1889 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_CONN_REQ_FILE_ACTION_NOT_TAKEN);
|
---|
1890 | AssertRC(rc2);
|
---|
1891 | }
|
---|
1892 | else
|
---|
1893 | {
|
---|
1894 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnFileStat, pszPath, NULL /* PRTFSOBJINFO */);
|
---|
1895 |
|
---|
1896 | if (RT_SUCCESS(rc))
|
---|
1897 | {
|
---|
1898 | if (pClient->pDataConn == NULL)
|
---|
1899 | {
|
---|
1900 | rc = rtFtpServerDataConnCreate(pClient, &pClient->pDataConn);
|
---|
1901 | if (RT_SUCCESS(rc))
|
---|
1902 | rc = rtFtpServerDataConnStart(pClient->pDataConn, rtFtpServerDataConnListThread, cArgs, apszArgs);
|
---|
1903 |
|
---|
1904 | int rc2 = rtFtpServerSendReplyRc( pClient, RT_SUCCESS(rc)
|
---|
1905 | ? RTFTPSERVER_REPLY_DATACONN_ALREADY_OPEN
|
---|
1906 | : RTFTPSERVER_REPLY_CANT_OPEN_DATA_CONN);
|
---|
1907 | AssertRC(rc2);
|
---|
1908 | }
|
---|
1909 | else
|
---|
1910 | {
|
---|
1911 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_DATACONN_ALREADY_OPEN);
|
---|
1912 | AssertRC(rc2);
|
---|
1913 | }
|
---|
1914 | }
|
---|
1915 | else
|
---|
1916 | {
|
---|
1917 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_CONN_REQ_FILE_ACTION_NOT_TAKEN);
|
---|
1918 | AssertRC(rc2);
|
---|
1919 | }
|
---|
1920 | }
|
---|
1921 |
|
---|
1922 | return rc;
|
---|
1923 | }
|
---|
1924 |
|
---|
1925 | static DECLCALLBACK(int) rtFtpServerHandleMODE(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1926 | {
|
---|
1927 | RT_NOREF(pClient, cArgs, apszArgs);
|
---|
1928 |
|
---|
1929 | /** @todo Anything to do here? */
|
---|
1930 | return VINF_SUCCESS;
|
---|
1931 | }
|
---|
1932 |
|
---|
1933 | static DECLCALLBACK(int) rtFtpServerHandleNOOP(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1934 | {
|
---|
1935 | RT_NOREF(cArgs, apszArgs);
|
---|
1936 |
|
---|
1937 | /* Save timestamp of last command sent. */
|
---|
1938 | pClient->State.tsLastCmdMs = RTTimeMilliTS();
|
---|
1939 |
|
---|
1940 | return rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_OKAY);
|
---|
1941 | }
|
---|
1942 |
|
---|
1943 | static DECLCALLBACK(int) rtFtpServerHandlePASS(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1944 | {
|
---|
1945 | if (cArgs != 1)
|
---|
1946 | return rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_ERROR_INVALID_PARAMETERS);
|
---|
1947 |
|
---|
1948 | const char *pszPassword = apszArgs[0];
|
---|
1949 | AssertPtrReturn(pszPassword, VERR_INVALID_PARAMETER);
|
---|
1950 |
|
---|
1951 | int rc = rtFtpServerAuthenticate(pClient, pClient->State.pszUser, pszPassword);
|
---|
1952 | if (RT_SUCCESS(rc))
|
---|
1953 | {
|
---|
1954 | rc = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_LOGGED_IN_PROCEED);
|
---|
1955 | }
|
---|
1956 | else
|
---|
1957 | {
|
---|
1958 | pClient->State.cFailedLoginAttempts++;
|
---|
1959 |
|
---|
1960 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_NOT_LOGGED_IN);
|
---|
1961 | if (RT_SUCCESS(rc))
|
---|
1962 | rc = rc2;
|
---|
1963 | }
|
---|
1964 |
|
---|
1965 | return rc;
|
---|
1966 | }
|
---|
1967 |
|
---|
1968 | static DECLCALLBACK(int) rtFtpServerHandlePORT(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1969 | {
|
---|
1970 | if (cArgs != 1)
|
---|
1971 | return rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_ERROR_INVALID_PARAMETERS);
|
---|
1972 |
|
---|
1973 | RTFTPSERVER_REPLY rcClient;
|
---|
1974 |
|
---|
1975 | int rc = rtFtpParseHostAndPort(apszArgs[0], &pClient->DataConnAddr, &pClient->uDataConnPort);
|
---|
1976 | if (RT_SUCCESS(rc))
|
---|
1977 | rcClient = RTFTPSERVER_REPLY_OKAY;
|
---|
1978 | else
|
---|
1979 | rcClient = RTFTPSERVER_REPLY_ERROR_INVALID_PARAMETERS;
|
---|
1980 |
|
---|
1981 | int rc2 = rtFtpServerSendReplyRc(pClient, rcClient);
|
---|
1982 | if (RT_SUCCESS(rc))
|
---|
1983 | rc = rc2;
|
---|
1984 |
|
---|
1985 | return rc;
|
---|
1986 | }
|
---|
1987 |
|
---|
1988 | static DECLCALLBACK(int) rtFtpServerHandlePWD(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
1989 | {
|
---|
1990 | RT_NOREF(cArgs, apszArgs);
|
---|
1991 |
|
---|
1992 | int rc;
|
---|
1993 |
|
---|
1994 | char szPWD[RTPATH_MAX];
|
---|
1995 |
|
---|
1996 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnPathGetCurrent, szPWD, sizeof(szPWD));
|
---|
1997 |
|
---|
1998 | if (RT_SUCCESS(rc))
|
---|
1999 | rc = rtFtpServerSendReplyRcEx(pClient, RTFTPSERVER_REPLY_PATHNAME_OK, "\"%s\"", szPWD); /* See RFC 959, APPENDIX II. */
|
---|
2000 |
|
---|
2001 | return rc;
|
---|
2002 | }
|
---|
2003 |
|
---|
2004 | static DECLCALLBACK(int) rtFtpServerHandleOPTS(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2005 | {
|
---|
2006 | RT_NOREF(cArgs, apszArgs);
|
---|
2007 |
|
---|
2008 | int rc = VINF_SUCCESS;
|
---|
2009 |
|
---|
2010 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_OKAY);
|
---|
2011 | if (RT_SUCCESS(rc))
|
---|
2012 | rc = rc2;
|
---|
2013 |
|
---|
2014 | return rc;
|
---|
2015 | }
|
---|
2016 |
|
---|
2017 | static DECLCALLBACK(int) rtFtpServerHandleQUIT(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2018 | {
|
---|
2019 | RT_NOREF(cArgs, apszArgs);
|
---|
2020 |
|
---|
2021 | int rc = VINF_SUCCESS;
|
---|
2022 |
|
---|
2023 | if (pClient->pDataConn)
|
---|
2024 | {
|
---|
2025 | rc = rtFtpServerDataConnClose(pClient->pDataConn);
|
---|
2026 | if (RT_SUCCESS(rc))
|
---|
2027 | {
|
---|
2028 | rtFtpServerDataConnDestroy(pClient->pDataConn);
|
---|
2029 | pClient->pDataConn = NULL;
|
---|
2030 | }
|
---|
2031 | }
|
---|
2032 |
|
---|
2033 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_OKAY);
|
---|
2034 | if (RT_SUCCESS(rc))
|
---|
2035 | rc = rc2;
|
---|
2036 |
|
---|
2037 | return rc;
|
---|
2038 | }
|
---|
2039 |
|
---|
2040 | static DECLCALLBACK(int) rtFtpServerHandleRETR(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2041 | {
|
---|
2042 | if (cArgs != 1) /* File name needs to be present. */
|
---|
2043 | return VERR_INVALID_PARAMETER;
|
---|
2044 |
|
---|
2045 | int rc;
|
---|
2046 |
|
---|
2047 | const char *pszPath = apszArgs[0];
|
---|
2048 |
|
---|
2049 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnFileStat, pszPath, NULL /* PRTFSOBJINFO */);
|
---|
2050 |
|
---|
2051 | if (RT_SUCCESS(rc))
|
---|
2052 | {
|
---|
2053 | if (RT_SUCCESS(rc))
|
---|
2054 | {
|
---|
2055 | if (pClient->pDataConn == NULL)
|
---|
2056 | {
|
---|
2057 | rc = rtFtpServerDataConnCreate(pClient, &pClient->pDataConn);
|
---|
2058 | if (RT_SUCCESS(rc))
|
---|
2059 | rc = rtFtpServerDataConnStart(pClient->pDataConn, rtFtpServerDataConnFileWriteThread, cArgs, apszArgs);
|
---|
2060 |
|
---|
2061 | int rc2 = rtFtpServerSendReplyRc( pClient, RT_SUCCESS(rc)
|
---|
2062 | ? RTFTPSERVER_REPLY_DATACONN_ALREADY_OPEN
|
---|
2063 | : RTFTPSERVER_REPLY_CANT_OPEN_DATA_CONN);
|
---|
2064 | AssertRC(rc2);
|
---|
2065 | }
|
---|
2066 | else
|
---|
2067 | {
|
---|
2068 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_DATACONN_ALREADY_OPEN);
|
---|
2069 | AssertRC(rc2);
|
---|
2070 | }
|
---|
2071 | }
|
---|
2072 | else
|
---|
2073 | {
|
---|
2074 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_CONN_REQ_FILE_ACTION_NOT_TAKEN);
|
---|
2075 | AssertRC(rc2);
|
---|
2076 | }
|
---|
2077 | }
|
---|
2078 |
|
---|
2079 | if (RT_FAILURE(rc))
|
---|
2080 | {
|
---|
2081 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_REQ_ACTION_NOT_TAKEN);
|
---|
2082 | AssertRC(rc2);
|
---|
2083 | }
|
---|
2084 |
|
---|
2085 | return rc;
|
---|
2086 | }
|
---|
2087 |
|
---|
2088 | static DECLCALLBACK(int) rtFtpServerHandleSIZE(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2089 | {
|
---|
2090 | if (cArgs != 1)
|
---|
2091 | return VERR_INVALID_PARAMETER;
|
---|
2092 |
|
---|
2093 | int rc;
|
---|
2094 |
|
---|
2095 | const char *pszPath = apszArgs[0];
|
---|
2096 | uint64_t uSize = 0;
|
---|
2097 |
|
---|
2098 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnFileGetSize, pszPath, &uSize);
|
---|
2099 |
|
---|
2100 | if (RT_SUCCESS(rc))
|
---|
2101 | {
|
---|
2102 | rc = rtFtpServerSendReplyStr(pClient, "213 %RU64\r\n", uSize);
|
---|
2103 | }
|
---|
2104 | else
|
---|
2105 | {
|
---|
2106 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_REQ_ACTION_NOT_TAKEN);
|
---|
2107 | AssertRC(rc2);
|
---|
2108 | }
|
---|
2109 |
|
---|
2110 | return rc;
|
---|
2111 | }
|
---|
2112 |
|
---|
2113 | static DECLCALLBACK(int) rtFtpServerHandleSTAT(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2114 | {
|
---|
2115 | if (cArgs != 1)
|
---|
2116 | return VERR_INVALID_PARAMETER;
|
---|
2117 |
|
---|
2118 | int rc;
|
---|
2119 |
|
---|
2120 | RTFSOBJINFO objInfo;
|
---|
2121 | RT_ZERO(objInfo);
|
---|
2122 |
|
---|
2123 | const char *pszPath = apszArgs[0];
|
---|
2124 |
|
---|
2125 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnFileStat, pszPath, &objInfo);
|
---|
2126 |
|
---|
2127 | if (RT_SUCCESS(rc))
|
---|
2128 | {
|
---|
2129 | char szFsObjInfo[_4K]; /** @todo Check this size. */
|
---|
2130 | rc = rtFtpServerFsObjInfoToStr(&objInfo, szFsObjInfo, sizeof(szFsObjInfo));
|
---|
2131 | if (RT_SUCCESS(rc))
|
---|
2132 | {
|
---|
2133 | char szFsPathInfo[RTPATH_MAX + 16];
|
---|
2134 | const ssize_t cchPathInfo = RTStrPrintf2(szFsPathInfo, sizeof(szFsPathInfo), " %2zu %s\n", strlen(pszPath), pszPath);
|
---|
2135 | if (cchPathInfo > 0)
|
---|
2136 | {
|
---|
2137 | rc = RTStrCat(szFsObjInfo, sizeof(szFsObjInfo), szFsPathInfo);
|
---|
2138 | if (RT_SUCCESS(rc))
|
---|
2139 | rc = rtFtpServerSendReplyStr(pClient, szFsObjInfo);
|
---|
2140 | }
|
---|
2141 | else
|
---|
2142 | rc = VERR_BUFFER_OVERFLOW;
|
---|
2143 | }
|
---|
2144 | }
|
---|
2145 |
|
---|
2146 | if (RT_FAILURE(rc))
|
---|
2147 | {
|
---|
2148 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_REQ_ACTION_NOT_TAKEN);
|
---|
2149 | AssertRC(rc2);
|
---|
2150 | }
|
---|
2151 |
|
---|
2152 | return rc;
|
---|
2153 | }
|
---|
2154 |
|
---|
2155 | static DECLCALLBACK(int) rtFtpServerHandleSTRU(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2156 | {
|
---|
2157 | if (cArgs != 1)
|
---|
2158 | return VERR_INVALID_PARAMETER;
|
---|
2159 |
|
---|
2160 | const char *pszType = apszArgs[0];
|
---|
2161 |
|
---|
2162 | int rc;
|
---|
2163 |
|
---|
2164 | if (!RTStrICmp(pszType, "F"))
|
---|
2165 | {
|
---|
2166 | pClient->State.enmStructType = RTFTPSERVER_STRUCT_TYPE_FILE;
|
---|
2167 |
|
---|
2168 | rc = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_OKAY);
|
---|
2169 | }
|
---|
2170 | else
|
---|
2171 | rc = VERR_NOT_IMPLEMENTED;
|
---|
2172 |
|
---|
2173 | return rc;
|
---|
2174 | }
|
---|
2175 |
|
---|
2176 | static DECLCALLBACK(int) rtFtpServerHandleSYST(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2177 | {
|
---|
2178 | RT_NOREF(cArgs, apszArgs);
|
---|
2179 |
|
---|
2180 | char szOSInfo[64];
|
---|
2181 | int rc = RTSystemQueryOSInfo(RTSYSOSINFO_PRODUCT, szOSInfo, sizeof(szOSInfo));
|
---|
2182 | if (RT_SUCCESS(rc))
|
---|
2183 | rc = rtFtpServerSendReplyStr(pClient, "215 %s", szOSInfo);
|
---|
2184 |
|
---|
2185 | return rc;
|
---|
2186 | }
|
---|
2187 |
|
---|
2188 | static DECLCALLBACK(int) rtFtpServerHandleTYPE(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2189 | {
|
---|
2190 | if (cArgs != 1)
|
---|
2191 | return VERR_INVALID_PARAMETER;
|
---|
2192 |
|
---|
2193 | const char *pszType = apszArgs[0];
|
---|
2194 |
|
---|
2195 | int rc = VINF_SUCCESS;
|
---|
2196 |
|
---|
2197 | if (!RTStrICmp(pszType, "A"))
|
---|
2198 | {
|
---|
2199 | pClient->State.enmDataType = RTFTPSERVER_DATA_TYPE_ASCII;
|
---|
2200 | }
|
---|
2201 | else if (!RTStrICmp(pszType, "I")) /* Image (binary). */
|
---|
2202 | {
|
---|
2203 | pClient->State.enmDataType = RTFTPSERVER_DATA_TYPE_IMAGE;
|
---|
2204 | }
|
---|
2205 | else /** @todo Support "E" (EBCDIC) and/or "L <size>" (custom)? */
|
---|
2206 | rc = VERR_NOT_IMPLEMENTED;
|
---|
2207 |
|
---|
2208 | if (RT_SUCCESS(rc))
|
---|
2209 | rc = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_OKAY);
|
---|
2210 |
|
---|
2211 | return rc;
|
---|
2212 | }
|
---|
2213 |
|
---|
2214 | static DECLCALLBACK(int) rtFtpServerHandleUSER(PRTFTPSERVERCLIENT pClient, uint8_t cArgs, const char * const *apszArgs)
|
---|
2215 | {
|
---|
2216 | if (cArgs != 1)
|
---|
2217 | return VERR_INVALID_PARAMETER;
|
---|
2218 |
|
---|
2219 | const char *pszUser = apszArgs[0];
|
---|
2220 | AssertPtrReturn(pszUser, VERR_INVALID_PARAMETER);
|
---|
2221 |
|
---|
2222 | rtFtpServerClientStateReset(&pClient->State);
|
---|
2223 |
|
---|
2224 | int rc = rtFtpServerLookupUser(pClient, pszUser);
|
---|
2225 | if (RT_SUCCESS(rc))
|
---|
2226 | {
|
---|
2227 | pClient->State.pszUser = RTStrDup(pszUser);
|
---|
2228 | AssertPtrReturn(pClient->State.pszUser, VERR_NO_MEMORY);
|
---|
2229 |
|
---|
2230 | rc = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_USERNAME_OKAY_NEED_PASSWORD);
|
---|
2231 | }
|
---|
2232 | else
|
---|
2233 | {
|
---|
2234 | pClient->State.cFailedLoginAttempts++;
|
---|
2235 |
|
---|
2236 | int rc2 = rtFtpServerSendReplyRc(pClient, RTFTPSERVER_REPLY_NOT_LOGGED_IN);
|
---|
2237 | if (RT_SUCCESS(rc))
|
---|
2238 | rc = rc2;
|
---|
2239 | }
|
---|
2240 |
|
---|
2241 | return rc;
|
---|
2242 | }
|
---|
2243 |
|
---|
2244 |
|
---|
2245 | /*********************************************************************************************************************************
|
---|
2246 | * Internal server functions *
|
---|
2247 | *********************************************************************************************************************************/
|
---|
2248 |
|
---|
2249 | /**
|
---|
2250 | * Parses FTP command arguments handed in by the client.
|
---|
2251 | *
|
---|
2252 | * @returns VBox status code.
|
---|
2253 | * @param pszCmdParms Pointer to command arguments, if any. Can be NULL if no arguments are given.
|
---|
2254 | * @param pcArgs Returns the number of parsed arguments, separated by a space (hex 0x20).
|
---|
2255 | * @param ppapszArgs Returns the string array of parsed arguments. Needs to be free'd with rtFtpServerCmdArgsFree().
|
---|
2256 | */
|
---|
2257 | static int rtFtpServerCmdArgsParse(const char *pszCmdParms, uint8_t *pcArgs, char ***ppapszArgs)
|
---|
2258 | {
|
---|
2259 | *pcArgs = 0;
|
---|
2260 | *ppapszArgs = NULL;
|
---|
2261 |
|
---|
2262 | if (!pszCmdParms) /* No parms given? Bail out early. */
|
---|
2263 | return VINF_SUCCESS;
|
---|
2264 |
|
---|
2265 | /** @todo Anything else to do here? */
|
---|
2266 | /** @todo Check if quoting is correct. */
|
---|
2267 |
|
---|
2268 | int cArgs = 0;
|
---|
2269 | int rc = RTGetOptArgvFromString(ppapszArgs, &cArgs, pszCmdParms, RTGETOPTARGV_CNV_QUOTE_MS_CRT, " " /* Separators */);
|
---|
2270 | if (RT_SUCCESS(rc))
|
---|
2271 | {
|
---|
2272 | if ((unsigned int)cArgs <= UINT8_MAX)
|
---|
2273 | {
|
---|
2274 | *pcArgs = (uint8_t)cArgs;
|
---|
2275 | }
|
---|
2276 | else
|
---|
2277 | rc = VERR_INVALID_PARAMETER;
|
---|
2278 | }
|
---|
2279 |
|
---|
2280 | return rc;
|
---|
2281 | }
|
---|
2282 |
|
---|
2283 | /**
|
---|
2284 | * Frees a formerly argument string array parsed by rtFtpServerCmdArgsParse().
|
---|
2285 | *
|
---|
2286 | * @param ppapszArgs Argument string array to free.
|
---|
2287 | */
|
---|
2288 | static void rtFtpServerCmdArgsFree(char **ppapszArgs)
|
---|
2289 | {
|
---|
2290 | RTGetOptArgvFree(ppapszArgs);
|
---|
2291 | }
|
---|
2292 |
|
---|
2293 | /**
|
---|
2294 | * Main function for processing client commands for the control connection.
|
---|
2295 | *
|
---|
2296 | * @returns VBox status code.
|
---|
2297 | * @param pClient Client to process commands for.
|
---|
2298 | * @param pszCmd Command string to parse and handle.
|
---|
2299 | * @param cbCmd Size (in bytes) of command string.
|
---|
2300 | */
|
---|
2301 | static int rtFtpServerProcessCommands(PRTFTPSERVERCLIENT pClient, char *pszCmd, size_t cbCmd)
|
---|
2302 | {
|
---|
2303 | /* Make sure to terminate the string in any case. */
|
---|
2304 | pszCmd[RT_MIN(RTFTPSERVER_MAX_CMD_LEN, cbCmd)] = '\0';
|
---|
2305 |
|
---|
2306 | /* A tiny bit of sanitation. */
|
---|
2307 | RTStrStripL(pszCmd);
|
---|
2308 |
|
---|
2309 | /* First, terminate string by finding the command end marker (telnet style). */
|
---|
2310 | /** @todo Not sure if this is entirely correct and/or needs tweaking; good enough for now as it seems. */
|
---|
2311 | char *pszCmdEnd = RTStrStr(pszCmd, "\r\n");
|
---|
2312 | if (pszCmdEnd)
|
---|
2313 | *pszCmdEnd = '\0';
|
---|
2314 |
|
---|
2315 | /* Reply which gets sent back to the client. */
|
---|
2316 | RTFTPSERVER_REPLY rcClient = RTFTPSERVER_REPLY_INVALID;
|
---|
2317 |
|
---|
2318 | int rcCmd = VINF_SUCCESS;
|
---|
2319 |
|
---|
2320 | uint8_t cArgs = 0;
|
---|
2321 | char **papszArgs = NULL;
|
---|
2322 | int rc = rtFtpServerCmdArgsParse(pszCmd, &cArgs, &papszArgs);
|
---|
2323 | if ( RT_SUCCESS(rc)
|
---|
2324 | && cArgs) /* At least the actual command (without args) must be present. */
|
---|
2325 | {
|
---|
2326 | LogFlowFunc(("Handling command '%s'\n", papszArgs[0]));
|
---|
2327 | for (uint8_t a = 0; a < cArgs; a++)
|
---|
2328 | LogFlowFunc(("\targ[%RU8] = '%s'\n", a, papszArgs[a]));
|
---|
2329 |
|
---|
2330 | unsigned i = 0;
|
---|
2331 | for (; i < RT_ELEMENTS(g_aCmdMap); i++)
|
---|
2332 | {
|
---|
2333 | const RTFTPSERVERCMD_ENTRY *pCmdEntry = &g_aCmdMap[i];
|
---|
2334 |
|
---|
2335 | if (!RTStrICmp(papszArgs[0], pCmdEntry->szCmd))
|
---|
2336 | {
|
---|
2337 | /* Some commands need a valid user before they can be executed. */
|
---|
2338 | if ( pCmdEntry->fNeedsUser
|
---|
2339 | && pClient->State.pszUser == NULL)
|
---|
2340 | {
|
---|
2341 | rcClient = RTFTPSERVER_REPLY_NOT_LOGGED_IN;
|
---|
2342 | break;
|
---|
2343 | }
|
---|
2344 |
|
---|
2345 | /* Save timestamp of last command sent. */
|
---|
2346 | pClient->State.tsLastCmdMs = RTTimeMilliTS();
|
---|
2347 |
|
---|
2348 | /* Hand in arguments only without the actual command. */
|
---|
2349 | rcCmd = pCmdEntry->pfnCmd(pClient, cArgs - 1, cArgs > 1 ? &papszArgs[1] : NULL);
|
---|
2350 | if (RT_FAILURE(rcCmd))
|
---|
2351 | {
|
---|
2352 | LogFunc(("Handling command '%s' failed with %Rrc\n", papszArgs[0], rcCmd));
|
---|
2353 |
|
---|
2354 | switch (rcCmd)
|
---|
2355 | {
|
---|
2356 | case VERR_INVALID_PARAMETER:
|
---|
2357 | RT_FALL_THROUGH();
|
---|
2358 | case VERR_INVALID_POINTER:
|
---|
2359 | rcClient = RTFTPSERVER_REPLY_ERROR_INVALID_PARAMETERS;
|
---|
2360 | break;
|
---|
2361 |
|
---|
2362 | case VERR_NOT_IMPLEMENTED:
|
---|
2363 | rcClient = RTFTPSERVER_REPLY_ERROR_CMD_NOT_IMPL;
|
---|
2364 | break;
|
---|
2365 |
|
---|
2366 | default:
|
---|
2367 | break;
|
---|
2368 | }
|
---|
2369 | }
|
---|
2370 | break;
|
---|
2371 | }
|
---|
2372 | }
|
---|
2373 |
|
---|
2374 | rtFtpServerCmdArgsFree(papszArgs);
|
---|
2375 |
|
---|
2376 | if (i == RT_ELEMENTS(g_aCmdMap))
|
---|
2377 | {
|
---|
2378 | LogFlowFunc(("Command not implemented\n"));
|
---|
2379 | Assert(rcClient == RTFTPSERVER_REPLY_INVALID);
|
---|
2380 | rcClient = RTFTPSERVER_REPLY_ERROR_CMD_NOT_IMPL;
|
---|
2381 | }
|
---|
2382 |
|
---|
2383 | const bool fDisconnect = g_aCmdMap[i].enmCmd == RTFTPSERVERCMD_QUIT
|
---|
2384 | || pClient->State.cFailedLoginAttempts >= 3; /** @todo Make this dynamic. */
|
---|
2385 | if (fDisconnect)
|
---|
2386 | {
|
---|
2387 | RTFTPSERVER_HANDLE_CALLBACK_VA(pfnOnUserDisconnect, pClient->State.pszUser);
|
---|
2388 |
|
---|
2389 | rtFtpServerClientStateReset(&pClient->State);
|
---|
2390 |
|
---|
2391 | Assert(rcClient == RTFTPSERVER_REPLY_INVALID);
|
---|
2392 | rcClient = RTFTPSERVER_REPLY_CLOSING_CTRL_CONN;
|
---|
2393 | }
|
---|
2394 | }
|
---|
2395 | else
|
---|
2396 | rcClient = RTFTPSERVER_REPLY_ERROR_INVALID_PARAMETERS;
|
---|
2397 |
|
---|
2398 | if (rcClient != RTFTPSERVER_REPLY_INVALID)
|
---|
2399 | {
|
---|
2400 | int rc2 = rtFtpServerSendReplyRc(pClient, rcClient);
|
---|
2401 | if (RT_SUCCESS(rc))
|
---|
2402 | rc = rc2;
|
---|
2403 | }
|
---|
2404 |
|
---|
2405 | LogFlowFuncLeaveRC(rc);
|
---|
2406 | return rc;
|
---|
2407 | }
|
---|
2408 |
|
---|
2409 | /**
|
---|
2410 | * Main loop for processing client commands.
|
---|
2411 | *
|
---|
2412 | * @returns VBox status code.
|
---|
2413 | * @param pClient Client to process commands for.
|
---|
2414 | */
|
---|
2415 | static int rtFtpServerClientMain(PRTFTPSERVERCLIENT pClient)
|
---|
2416 | {
|
---|
2417 | int rc;
|
---|
2418 |
|
---|
2419 | size_t cbRead;
|
---|
2420 | char szCmd[RTFTPSERVER_MAX_CMD_LEN + 1];
|
---|
2421 |
|
---|
2422 | for (;;)
|
---|
2423 | {
|
---|
2424 | rc = RTTcpSelectOne(pClient->hSocket, 200 /* ms */); /** @todo Can we improve here? Using some poll events or so? */
|
---|
2425 | if (RT_SUCCESS(rc))
|
---|
2426 | {
|
---|
2427 | rc = RTTcpReadNB(pClient->hSocket, szCmd, sizeof(szCmd), &cbRead);
|
---|
2428 | if ( RT_SUCCESS(rc)
|
---|
2429 | && cbRead)
|
---|
2430 | {
|
---|
2431 | AssertBreakStmt(cbRead <= sizeof(szCmd), rc = VERR_BUFFER_OVERFLOW);
|
---|
2432 | rc = rtFtpServerProcessCommands(pClient, szCmd, cbRead);
|
---|
2433 | }
|
---|
2434 | }
|
---|
2435 | else if (rc == VERR_TIMEOUT)
|
---|
2436 | rc = VINF_SUCCESS;
|
---|
2437 | else
|
---|
2438 | break;
|
---|
2439 |
|
---|
2440 | /*
|
---|
2441 | * Handle data connection replies.
|
---|
2442 | */
|
---|
2443 | if (pClient->pDataConn)
|
---|
2444 | {
|
---|
2445 | if ( ASMAtomicReadBool(&pClient->pDataConn->fStarted)
|
---|
2446 | && ASMAtomicReadBool(&pClient->pDataConn->fStopped))
|
---|
2447 | {
|
---|
2448 | Assert(pClient->pDataConn->rc != VERR_IPE_UNINITIALIZED_STATUS);
|
---|
2449 |
|
---|
2450 | int rc2 = rtFtpServerSendReplyRc(pClient,
|
---|
2451 | RT_SUCCESS(pClient->pDataConn->rc)
|
---|
2452 | ? RTFTPSERVER_REPLY_CLOSING_DATA_CONN : RTFTPSERVER_REPLY_CONN_REQ_FILE_ACTION_NOT_TAKEN);
|
---|
2453 | AssertRC(rc2);
|
---|
2454 |
|
---|
2455 | rc = rtFtpServerDataConnStop(pClient->pDataConn);
|
---|
2456 | if (RT_SUCCESS(rc))
|
---|
2457 | {
|
---|
2458 | rtFtpServerDataConnDestroy(pClient->pDataConn);
|
---|
2459 | pClient->pDataConn = NULL;
|
---|
2460 | }
|
---|
2461 | }
|
---|
2462 | }
|
---|
2463 | }
|
---|
2464 |
|
---|
2465 | /* Make sure to destroy all data connections. */
|
---|
2466 | rtFtpServerDataConnDestroy(pClient->pDataConn);
|
---|
2467 | pClient->pDataConn = NULL;
|
---|
2468 |
|
---|
2469 | LogFlowFuncLeaveRC(rc);
|
---|
2470 | return rc;
|
---|
2471 | }
|
---|
2472 |
|
---|
2473 | /**
|
---|
2474 | * Resets the client's state.
|
---|
2475 | *
|
---|
2476 | * @param pState Client state to reset.
|
---|
2477 | */
|
---|
2478 | static void rtFtpServerClientStateReset(PRTFTPSERVERCLIENTSTATE pState)
|
---|
2479 | {
|
---|
2480 | LogFlowFuncEnter();
|
---|
2481 |
|
---|
2482 | RTStrFree(pState->pszUser);
|
---|
2483 | pState->pszUser = NULL;
|
---|
2484 |
|
---|
2485 | int rc2 = rtFtpSetCWD(pState, "/");
|
---|
2486 | AssertRC(rc2);
|
---|
2487 |
|
---|
2488 | pState->cFailedLoginAttempts = 0;
|
---|
2489 | pState->tsLastCmdMs = RTTimeMilliTS();
|
---|
2490 | pState->enmDataType = RTFTPSERVER_DATA_TYPE_ASCII;
|
---|
2491 | pState->enmStructType = RTFTPSERVER_STRUCT_TYPE_FILE;
|
---|
2492 | }
|
---|
2493 |
|
---|
2494 | /**
|
---|
2495 | * Per-client thread for serving the server's control connection.
|
---|
2496 | *
|
---|
2497 | * @returns VBox status code.
|
---|
2498 | * @param hSocket Socket handle to use for the control connection.
|
---|
2499 | * @param pvUser User-provided arguments. Of type PRTFTPSERVERINTERNAL.
|
---|
2500 | */
|
---|
2501 | static DECLCALLBACK(int) rtFtpServerClientThread(RTSOCKET hSocket, void *pvUser)
|
---|
2502 | {
|
---|
2503 | PRTFTPSERVERINTERNAL pThis = (PRTFTPSERVERINTERNAL)pvUser;
|
---|
2504 | RTFTPSERVER_VALID_RETURN(pThis);
|
---|
2505 |
|
---|
2506 | RTFTPSERVERCLIENT Client;
|
---|
2507 | RT_ZERO(Client);
|
---|
2508 |
|
---|
2509 | Client.pServer = pThis;
|
---|
2510 | Client.hSocket = hSocket;
|
---|
2511 |
|
---|
2512 | LogFlowFunc(("New client connected\n"));
|
---|
2513 |
|
---|
2514 | rtFtpServerClientStateReset(&Client.State);
|
---|
2515 |
|
---|
2516 | /*
|
---|
2517 | * Send welcome message.
|
---|
2518 | * Note: Some clients (like FileZilla / Firefox) expect a message together with the reply code,
|
---|
2519 | * so make sure to include at least *something*.
|
---|
2520 | */
|
---|
2521 | int rc = rtFtpServerSendReplyRcEx(&Client, RTFTPSERVER_REPLY_READY_FOR_NEW_USER,
|
---|
2522 | "Welcome!");
|
---|
2523 | if (RT_SUCCESS(rc))
|
---|
2524 | {
|
---|
2525 | ASMAtomicIncU32(&pThis->cClients);
|
---|
2526 |
|
---|
2527 | rc = rtFtpServerClientMain(&Client);
|
---|
2528 |
|
---|
2529 | ASMAtomicDecU32(&pThis->cClients);
|
---|
2530 | }
|
---|
2531 |
|
---|
2532 | rtFtpServerClientStateReset(&Client.State);
|
---|
2533 |
|
---|
2534 | return rc;
|
---|
2535 | }
|
---|
2536 |
|
---|
2537 | RTR3DECL(int) RTFtpServerCreate(PRTFTPSERVER phFTPServer, const char *pszAddress, uint16_t uPort,
|
---|
2538 | PRTFTPSERVERCALLBACKS pCallbacks, void *pvUser, size_t cbUser)
|
---|
2539 | {
|
---|
2540 | AssertPtrReturn(phFTPServer, VERR_INVALID_POINTER);
|
---|
2541 | AssertPtrReturn(pszAddress, VERR_INVALID_POINTER);
|
---|
2542 | AssertReturn (uPort, VERR_INVALID_PARAMETER);
|
---|
2543 | AssertPtrReturn(pCallbacks, VERR_INVALID_POINTER);
|
---|
2544 | /* pvUser is optional. */
|
---|
2545 |
|
---|
2546 | int rc;
|
---|
2547 |
|
---|
2548 | PRTFTPSERVERINTERNAL pThis = (PRTFTPSERVERINTERNAL)RTMemAllocZ(sizeof(RTFTPSERVERINTERNAL));
|
---|
2549 | if (pThis)
|
---|
2550 | {
|
---|
2551 | pThis->u32Magic = RTFTPSERVER_MAGIC;
|
---|
2552 | pThis->Callbacks = *pCallbacks;
|
---|
2553 | pThis->pvUser = pvUser;
|
---|
2554 | pThis->cbUser = cbUser;
|
---|
2555 |
|
---|
2556 | rc = RTTcpServerCreate(pszAddress, uPort, RTTHREADTYPE_DEFAULT, "ftpsrv",
|
---|
2557 | rtFtpServerClientThread, pThis /* pvUser */, &pThis->pTCPServer);
|
---|
2558 | if (RT_SUCCESS(rc))
|
---|
2559 | {
|
---|
2560 | *phFTPServer = (RTFTPSERVER)pThis;
|
---|
2561 | }
|
---|
2562 | }
|
---|
2563 | else
|
---|
2564 | rc = VERR_NO_MEMORY;
|
---|
2565 |
|
---|
2566 | return rc;
|
---|
2567 | }
|
---|
2568 |
|
---|
2569 | RTR3DECL(int) RTFtpServerDestroy(RTFTPSERVER hFTPServer)
|
---|
2570 | {
|
---|
2571 | if (hFTPServer == NIL_RTFTPSERVER)
|
---|
2572 | return VINF_SUCCESS;
|
---|
2573 |
|
---|
2574 | PRTFTPSERVERINTERNAL pThis = hFTPServer;
|
---|
2575 | RTFTPSERVER_VALID_RETURN(pThis);
|
---|
2576 |
|
---|
2577 | AssertPtr(pThis->pTCPServer);
|
---|
2578 |
|
---|
2579 | int rc = RTTcpServerDestroy(pThis->pTCPServer);
|
---|
2580 | if (RT_SUCCESS(rc))
|
---|
2581 | {
|
---|
2582 | pThis->u32Magic = RTFTPSERVER_MAGIC_DEAD;
|
---|
2583 |
|
---|
2584 | RTMemFree(pThis);
|
---|
2585 | }
|
---|
2586 |
|
---|
2587 | return rc;
|
---|
2588 | }
|
---|
2589 |
|
---|