1 | /* $Id: RTHttpServer.cpp 87042 2020-12-04 12:10:36Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT - Utility for running a (simple) HTTP server.
|
---|
4 | *
|
---|
5 | * Use this setup to best see what's going on:
|
---|
6 | * VBOX_LOG=rt_http=~0
|
---|
7 | * VBOX_LOG_DEST="nofile stderr"
|
---|
8 | * VBOX_LOG_FLAGS="unbuffered enabled thread msprog"
|
---|
9 | *
|
---|
10 | */
|
---|
11 |
|
---|
12 | /*
|
---|
13 | * Copyright (C) 2020 Oracle Corporation
|
---|
14 | *
|
---|
15 | * This file is part of VirtualBox Open Source Edition (OSE), as
|
---|
16 | * available from http://www.virtualbox.org. This file is free software;
|
---|
17 | * you can redistribute it and/or modify it under the terms of the GNU
|
---|
18 | * General Public License (GPL) as published by the Free Software
|
---|
19 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
20 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
21 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
22 | *
|
---|
23 | * The contents of this file may alternatively be used under the terms
|
---|
24 | * of the Common Development and Distribution License Version 1.0
|
---|
25 | * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
|
---|
26 | * VirtualBox OSE distribution, in which case the provisions of the
|
---|
27 | * CDDL are applicable instead of those of the GPL.
|
---|
28 | *
|
---|
29 | * You may elect to license modified versions of this file under the
|
---|
30 | * terms and conditions of either the GPL or the CDDL or both.
|
---|
31 | */
|
---|
32 |
|
---|
33 |
|
---|
34 | /*********************************************************************************************************************************
|
---|
35 | * Header Files *
|
---|
36 | *********************************************************************************************************************************/
|
---|
37 | #include <signal.h>
|
---|
38 |
|
---|
39 | #include <iprt/http.h>
|
---|
40 | #include <iprt/http-server.h>
|
---|
41 |
|
---|
42 | #include <iprt/net.h> /* To make use of IPv4Addr in RTGETOPTUNION. */
|
---|
43 |
|
---|
44 | #include <iprt/asm.h>
|
---|
45 | #include <iprt/assert.h>
|
---|
46 | #include <iprt/ctype.h>
|
---|
47 | #include <iprt/err.h>
|
---|
48 | #include <iprt/file.h>
|
---|
49 | #include <iprt/getopt.h>
|
---|
50 | #include <iprt/initterm.h>
|
---|
51 | #define LOG_GROUP RTLOGGROUP_HTTP
|
---|
52 | #include <iprt/log.h>
|
---|
53 | #include <iprt/mem.h>
|
---|
54 | #include <iprt/message.h>
|
---|
55 | #include <iprt/path.h>
|
---|
56 | #include <iprt/stream.h>
|
---|
57 | #include <iprt/string.h>
|
---|
58 | #include <iprt/thread.h>
|
---|
59 | #include <iprt/vfs.h>
|
---|
60 |
|
---|
61 | #ifdef RT_OS_WINDOWS
|
---|
62 | # include <iprt/win/windows.h>
|
---|
63 | #endif
|
---|
64 |
|
---|
65 |
|
---|
66 | /*********************************************************************************************************************************
|
---|
67 | * Definitations *
|
---|
68 | *********************************************************************************************************************************/
|
---|
69 | typedef struct HTTPSERVERDATA
|
---|
70 | {
|
---|
71 | /** The absolute path of the HTTP server's root directory. */
|
---|
72 | char szPathRootAbs[RTPATH_MAX];
|
---|
73 | RTFMODE fMode;
|
---|
74 | union
|
---|
75 | {
|
---|
76 | RTFILE File;
|
---|
77 | RTVFSDIR Dir;
|
---|
78 | } h;
|
---|
79 | /** Cached response data. */
|
---|
80 | RTHTTPSERVERRESP Resp;
|
---|
81 | } HTTPSERVERDATA;
|
---|
82 | typedef HTTPSERVERDATA *PHTTPSERVERDATA;
|
---|
83 |
|
---|
84 | /**
|
---|
85 | * Enumeration specifying the VFS handle type of the HTTP server.
|
---|
86 | */
|
---|
87 | typedef enum HTTPSERVERVFSHANDLETYPE
|
---|
88 | {
|
---|
89 | HTTPSERVERVFSHANDLETYPE_INVALID = 0,
|
---|
90 | HTTPSERVERVFSHANDLETYPE_FILE,
|
---|
91 | HTTPSERVERVFSHANDLETYPE_DIR,
|
---|
92 | /** The usual 32-bit hack. */
|
---|
93 | HTTPSERVERVFSHANDLETYPE_32BIT_HACK = 0x7fffffff
|
---|
94 | } HTTPSERVERVFSHANDLETYPE;
|
---|
95 |
|
---|
96 | /**
|
---|
97 | * Structure for keeping a VFS handle of the HTTP server.
|
---|
98 | */
|
---|
99 | typedef struct HTTPSERVERVFSHANDLE
|
---|
100 | {
|
---|
101 | /** The type of the handle, stored in the union below. */
|
---|
102 | HTTPSERVERVFSHANDLETYPE enmType;
|
---|
103 | union
|
---|
104 | {
|
---|
105 | /** The VFS (chain) handle to use for this file. */
|
---|
106 | RTVFSFILE hVfsFile;
|
---|
107 | /** The VFS (chain) handle to use for this directory. */
|
---|
108 | RTVFSDIR hVfsDir;
|
---|
109 | } u;
|
---|
110 | } HTTPSERVERVFSHANDLE;
|
---|
111 | typedef HTTPSERVERVFSHANDLE *PHTTPSERVERVFSHANDLE;
|
---|
112 |
|
---|
113 | /**
|
---|
114 | * HTTP directory entry.
|
---|
115 | */
|
---|
116 | typedef struct RTHTTPDIRENTRY
|
---|
117 | {
|
---|
118 | /** The information about the entry. */
|
---|
119 | RTFSOBJINFO Info;
|
---|
120 | /** Symbolic link target (allocated after the name). */
|
---|
121 | const char *pszTarget;
|
---|
122 | /** Owner if applicable (allocated after the name). */
|
---|
123 | const char *pszOwner;
|
---|
124 | /** Group if applicable (allocated after the name). */
|
---|
125 | const char *pszGroup;
|
---|
126 | /** The length of szName. */
|
---|
127 | size_t cchName;
|
---|
128 | /** The entry name. */
|
---|
129 | RT_FLEXIBLE_ARRAY_EXTENSION
|
---|
130 | char szName[RT_FLEXIBLE_ARRAY];
|
---|
131 | } RTHTTPDIRENTRY;
|
---|
132 | /** Pointer to a HTTP directory entry. */
|
---|
133 | typedef RTHTTPDIRENTRY *PRTHTTPDIRENTRY;
|
---|
134 | /** Pointer to a HTTP directory entry pointer. */
|
---|
135 | typedef PRTHTTPDIRENTRY *PPRTHTTPDIRENTRY;
|
---|
136 |
|
---|
137 | /**
|
---|
138 | * Collection of HTTP directory entries.
|
---|
139 | * Used for also caching stuff.
|
---|
140 | */
|
---|
141 | typedef struct RTHTTPDIRCOLLECTION
|
---|
142 | {
|
---|
143 | /** Current size of papEntries. */
|
---|
144 | size_t cEntries;
|
---|
145 | /** Memory allocated for papEntries. */
|
---|
146 | size_t cEntriesAllocated;
|
---|
147 | /** Current entries pending sorting and display. */
|
---|
148 | PPRTHTTPDIRENTRY papEntries;
|
---|
149 |
|
---|
150 | /** Total number of bytes allocated for the above entries. */
|
---|
151 | uint64_t cbTotalAllocated;
|
---|
152 | /** Total number of file content bytes. */
|
---|
153 | uint64_t cbTotalFiles;
|
---|
154 |
|
---|
155 | } RTHTTPDIRCOLLECTION;
|
---|
156 | /** Pointer to a directory collection. */
|
---|
157 | typedef RTHTTPDIRCOLLECTION *PRTHTTPDIRCOLLECTION;
|
---|
158 | /** Pointer to a directory entry collection pointer. */
|
---|
159 | typedef PRTHTTPDIRCOLLECTION *PPRTHTTPDIRCOLLECTION;
|
---|
160 |
|
---|
161 |
|
---|
162 | /*********************************************************************************************************************************
|
---|
163 | * Global Variables *
|
---|
164 | *********************************************************************************************************************************/
|
---|
165 | /** Set by the signal handler when the HTTP server shall be terminated. */
|
---|
166 | static volatile bool g_fCanceled = false;
|
---|
167 | static HTTPSERVERDATA g_HttpServerData;
|
---|
168 |
|
---|
169 |
|
---|
170 | #ifdef RT_OS_WINDOWS
|
---|
171 | static BOOL WINAPI signalHandler(DWORD dwCtrlType) RT_NOTHROW_DEF
|
---|
172 | {
|
---|
173 | bool fEventHandled = FALSE;
|
---|
174 | switch (dwCtrlType)
|
---|
175 | {
|
---|
176 | /* User pressed CTRL+C or CTRL+BREAK or an external event was sent
|
---|
177 | * via GenerateConsoleCtrlEvent(). */
|
---|
178 | case CTRL_BREAK_EVENT:
|
---|
179 | case CTRL_CLOSE_EVENT:
|
---|
180 | case CTRL_C_EVENT:
|
---|
181 | ASMAtomicWriteBool(&g_fCanceled, true);
|
---|
182 | fEventHandled = TRUE;
|
---|
183 | break;
|
---|
184 | default:
|
---|
185 | break;
|
---|
186 | /** @todo Add other events here. */
|
---|
187 | }
|
---|
188 |
|
---|
189 | return fEventHandled;
|
---|
190 | }
|
---|
191 | #else /* !RT_OS_WINDOWS */
|
---|
192 | /**
|
---|
193 | * Signal handler that sets g_fCanceled.
|
---|
194 | *
|
---|
195 | * This can be executed on any thread in the process, on Windows it may even be
|
---|
196 | * a thread dedicated to delivering this signal. Don't do anything
|
---|
197 | * unnecessary here.
|
---|
198 | */
|
---|
199 | static void signalHandler(int iSignal) RT_NOTHROW_DEF
|
---|
200 | {
|
---|
201 | NOREF(iSignal);
|
---|
202 | ASMAtomicWriteBool(&g_fCanceled, true);
|
---|
203 | }
|
---|
204 | #endif
|
---|
205 |
|
---|
206 | /**
|
---|
207 | * Installs a custom signal handler to get notified
|
---|
208 | * whenever the user wants to intercept the program.
|
---|
209 | *
|
---|
210 | * @todo Make this handler available for all VBoxManage modules?
|
---|
211 | */
|
---|
212 | static int signalHandlerInstall(void)
|
---|
213 | {
|
---|
214 | g_fCanceled = false;
|
---|
215 |
|
---|
216 | int rc = VINF_SUCCESS;
|
---|
217 | #ifdef RT_OS_WINDOWS
|
---|
218 | if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)signalHandler, TRUE /* Add handler */))
|
---|
219 | {
|
---|
220 | rc = RTErrConvertFromWin32(GetLastError());
|
---|
221 | RTMsgError("Unable to install console control handler, rc=%Rrc\n", rc);
|
---|
222 | }
|
---|
223 | #else
|
---|
224 | signal(SIGINT, signalHandler);
|
---|
225 | signal(SIGTERM, signalHandler);
|
---|
226 | # ifdef SIGBREAK
|
---|
227 | signal(SIGBREAK, signalHandler);
|
---|
228 | # endif
|
---|
229 | #endif
|
---|
230 | return rc;
|
---|
231 | }
|
---|
232 |
|
---|
233 | /**
|
---|
234 | * Uninstalls a previously installed signal handler.
|
---|
235 | */
|
---|
236 | static int signalHandlerUninstall(void)
|
---|
237 | {
|
---|
238 | int rc = VINF_SUCCESS;
|
---|
239 | #ifdef RT_OS_WINDOWS
|
---|
240 | if (!SetConsoleCtrlHandler((PHANDLER_ROUTINE)NULL, FALSE /* Remove handler */))
|
---|
241 | {
|
---|
242 | rc = RTErrConvertFromWin32(GetLastError());
|
---|
243 | RTMsgError("Unable to uninstall console control handler, rc=%Rrc\n", rc);
|
---|
244 | }
|
---|
245 | #else
|
---|
246 | signal(SIGINT, SIG_DFL);
|
---|
247 | signal(SIGTERM, SIG_DFL);
|
---|
248 | # ifdef SIGBREAK
|
---|
249 | signal(SIGBREAK, SIG_DFL);
|
---|
250 | # endif
|
---|
251 | #endif
|
---|
252 | return rc;
|
---|
253 | }
|
---|
254 |
|
---|
255 | static int dirOpen(const char *pszPathAbs, PRTVFSDIR phVfsDir)
|
---|
256 | {
|
---|
257 | return RTVfsChainOpenDir(pszPathAbs, 0 /*fFlags*/, phVfsDir, NULL /* poffError */, NULL /* pErrInfo */);
|
---|
258 | }
|
---|
259 |
|
---|
260 | static int dirClose(RTVFSDIR hVfsDir)
|
---|
261 | {
|
---|
262 | RTVfsDirRelease(hVfsDir);
|
---|
263 |
|
---|
264 | return VINF_SUCCESS;
|
---|
265 | }
|
---|
266 |
|
---|
267 | static int dirRead(RTVFSDIR hVfsDir, char **ppszEntry, PRTFSOBJINFO pInfo)
|
---|
268 | {
|
---|
269 | size_t cbDirEntryAlloced = sizeof(RTDIRENTRYEX);
|
---|
270 | PRTDIRENTRYEX pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced);
|
---|
271 | if (!pDirEntry)
|
---|
272 | return VERR_NO_MEMORY;
|
---|
273 |
|
---|
274 | int rc;
|
---|
275 |
|
---|
276 | for (;;)
|
---|
277 | {
|
---|
278 | size_t cbDirEntry = cbDirEntryAlloced;
|
---|
279 | rc = RTVfsDirReadEx(hVfsDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX);
|
---|
280 | if (RT_FAILURE(rc))
|
---|
281 | {
|
---|
282 | if (rc == VERR_BUFFER_OVERFLOW)
|
---|
283 | {
|
---|
284 | RTMemTmpFree(pDirEntry);
|
---|
285 | cbDirEntryAlloced = RT_ALIGN_Z(RT_MIN(cbDirEntry, cbDirEntryAlloced) + 64, 64);
|
---|
286 | pDirEntry = (PRTDIRENTRYEX)RTMemTmpAlloc(cbDirEntryAlloced);
|
---|
287 | if (pDirEntry)
|
---|
288 | continue;
|
---|
289 | }
|
---|
290 | else
|
---|
291 | break;
|
---|
292 | }
|
---|
293 |
|
---|
294 | /* Skip dot directories. */
|
---|
295 | if (RTDirEntryExIsStdDotLink(pDirEntry))
|
---|
296 | continue;
|
---|
297 |
|
---|
298 | *ppszEntry = RTStrDup(pDirEntry->szName);
|
---|
299 | AssertPtrReturn(*ppszEntry, VERR_NO_MEMORY);
|
---|
300 |
|
---|
301 | *pInfo = pDirEntry->Info;
|
---|
302 |
|
---|
303 | break;
|
---|
304 |
|
---|
305 | } /* for */
|
---|
306 |
|
---|
307 | RTMemTmpFree(pDirEntry);
|
---|
308 | pDirEntry = NULL;
|
---|
309 |
|
---|
310 | return rc;
|
---|
311 | }
|
---|
312 |
|
---|
313 | #ifdef IPRT_HTTP_WITH_WEBDAV
|
---|
314 | static int dirEntryWriteDAV(char *pszBuf, size_t cbBuf,
|
---|
315 | const char *pszEntry, const PRTFSOBJINFO pObjInfo, size_t *pcbWritten)
|
---|
316 | {
|
---|
317 | char szBirthTime[32];
|
---|
318 | if (RTTimeSpecToString(&pObjInfo->BirthTime, szBirthTime, sizeof(szBirthTime)) == NULL)
|
---|
319 | return VERR_BUFFER_UNDERFLOW;
|
---|
320 |
|
---|
321 | char szModTime[32];
|
---|
322 | if (RTTimeSpecToString(&pObjInfo->ModificationTime, szModTime, sizeof(szModTime)) == NULL)
|
---|
323 | return VERR_BUFFER_UNDERFLOW;
|
---|
324 |
|
---|
325 | int rc = VINF_SUCCESS;
|
---|
326 |
|
---|
327 | /**
|
---|
328 | * !!! HACK ALERT !!!
|
---|
329 | ** @todo Build up and use a real XML DOM here. Works with Gnome / Gvfs-compatible apps though.
|
---|
330 | * !!! HACK ALERT !!!
|
---|
331 | */
|
---|
332 | ssize_t cch = RTStrPrintf(pszBuf, cbBuf,
|
---|
333 | "<d:response>"
|
---|
334 | "<d:href>%s</d:href>"
|
---|
335 | "<d:propstat>"
|
---|
336 | "<d:status>HTTP/1.1 200 OK</d:status>"
|
---|
337 | "<d:prop>"
|
---|
338 | "<d:displayname>%s</d:displayname>"
|
---|
339 | "<d:getcontentlength>%RU64</d:getcontentlength>"
|
---|
340 | "<d:getcontenttype>%s</d:getcontenttype>"
|
---|
341 | "<d:creationdate>%s</d:creationdate>"
|
---|
342 | "<d:getlastmodified>%s</d:getlastmodified>"
|
---|
343 | "<d:getetag/>"
|
---|
344 | "<d:resourcetype><d:collection/></d:resourcetype>"
|
---|
345 | "</d:prop>"
|
---|
346 | "</d:propstat>"
|
---|
347 | "</d:response>",
|
---|
348 | pszEntry, pszEntry, pObjInfo->cbObject, "application/octet-stream", szBirthTime, szModTime);
|
---|
349 |
|
---|
350 | if (cch <= 0)
|
---|
351 | rc = VERR_BUFFER_OVERFLOW;
|
---|
352 |
|
---|
353 | *pcbWritten = cch;
|
---|
354 |
|
---|
355 | return rc;
|
---|
356 | }
|
---|
357 |
|
---|
358 | static int writeHeaderDAV(PRTHTTPSERVERREQ pReq, PRTFSOBJINFO pObjInfo, char *pszBuf, size_t cbBuf, size_t *pcbWritten)
|
---|
359 | {
|
---|
360 | /**
|
---|
361 | * !!! HACK ALERT !!!
|
---|
362 | ** @todo Build up and use a real XML DOM here. Works with Gnome / Gvfs-compatible apps though.
|
---|
363 | * !!! HACK ALERT !!!
|
---|
364 | */
|
---|
365 |
|
---|
366 | size_t cbWritten = 0;
|
---|
367 |
|
---|
368 | ssize_t cch = RTStrPrintf2(pszBuf, cbBuf - cbWritten, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n");
|
---|
369 | AssertReturn(cch, VERR_BUFFER_UNDERFLOW);
|
---|
370 | pszBuf += cch;
|
---|
371 | cbWritten += cch;
|
---|
372 |
|
---|
373 | cch = RTStrPrintf2(pszBuf, cbBuf - cbWritten, "<d:multistatus xmlns:d=\"DAV:\">\r\n");
|
---|
374 | AssertReturn(cch, VERR_BUFFER_UNDERFLOW);
|
---|
375 | pszBuf += cch;
|
---|
376 | cbWritten += cch;
|
---|
377 |
|
---|
378 | int rc = dirEntryWriteDAV(pszBuf, cbBuf - cbWritten, pReq->pszUrl, pObjInfo, (size_t *)&cch);
|
---|
379 | AssertRC(rc);
|
---|
380 | pszBuf += cch;
|
---|
381 | cbWritten += cch;
|
---|
382 |
|
---|
383 | *pcbWritten += cbWritten;
|
---|
384 |
|
---|
385 | return rc;
|
---|
386 | }
|
---|
387 |
|
---|
388 | static int writeFooterDAV(PRTHTTPSERVERREQ pReq, char *pszBuf, size_t cbBuf, size_t *pcbWritten)
|
---|
389 | {
|
---|
390 | RT_NOREF(pReq, pcbWritten);
|
---|
391 |
|
---|
392 | /**
|
---|
393 | * !!! HACK ALERT !!!
|
---|
394 | ** @todo Build up and use a real XML DOM here. Works with Gnome / Gvfs-compatible apps though.
|
---|
395 | * !!! HACK ALERT !!!
|
---|
396 | */
|
---|
397 | ssize_t cch = RTStrPrintf2(pszBuf, cbBuf, "</d:multistatus>");
|
---|
398 | AssertReturn(cch, VERR_BUFFER_UNDERFLOW);
|
---|
399 | RT_NOREF(cch);
|
---|
400 |
|
---|
401 | return VINF_SUCCESS;
|
---|
402 | }
|
---|
403 | #endif /* IPRT_HTTP_WITH_WEBDAV */
|
---|
404 |
|
---|
405 | static int dirEntryWrite(RTHTTPMETHOD enmMethod, char *pszBuf, size_t cbBuf,
|
---|
406 | const char *pszEntry, const PRTFSOBJINFO pObjInfo, size_t *pcbWritten)
|
---|
407 | {
|
---|
408 | char szModTime[32];
|
---|
409 | if (RTTimeSpecToString(&pObjInfo->ModificationTime, szModTime, sizeof(szModTime)) == NULL)
|
---|
410 | return VERR_BUFFER_UNDERFLOW;
|
---|
411 |
|
---|
412 | int rc = VINF_SUCCESS;
|
---|
413 |
|
---|
414 | ssize_t cch = 0;
|
---|
415 |
|
---|
416 | if (enmMethod == RTHTTPMETHOD_GET)
|
---|
417 | {
|
---|
418 | cch = RTStrPrintf2(pszBuf, cbBuf, "201: %s %RU64 %s %s\r\n",
|
---|
419 | pszEntry, pObjInfo->cbObject, szModTime,
|
---|
420 | /** @todo Very crude; only files and directories are supported for now. */
|
---|
421 | RTFS_IS_FILE(pObjInfo->Attr.fMode) ? "FILE" : "DIRECTORY");
|
---|
422 | if (cch <= 0)
|
---|
423 | rc = VERR_BUFFER_OVERFLOW;
|
---|
424 | }
|
---|
425 | #ifdef IPRT_HTTP_WITH_WEBDAV
|
---|
426 | else if (enmMethod == RTHTTPMETHOD_PROPFIND)
|
---|
427 | {
|
---|
428 | char szBuf[RTPATH_MAX + _4K]; /** @todo Just a rough guesstimate. */
|
---|
429 | rc = dirEntryWriteDAV(szBuf, sizeof(szBuf), pszEntry, pObjInfo, (size_t *)&cch);
|
---|
430 | if (RT_SUCCESS(rc))
|
---|
431 | rc = RTStrCat(pszBuf, cbBuf, szBuf);
|
---|
432 | AssertRC(rc);
|
---|
433 | }
|
---|
434 | #endif /* IPRT_HTTP_WITH_WEBDAV */
|
---|
435 | else
|
---|
436 | rc = VERR_NOT_SUPPORTED;
|
---|
437 |
|
---|
438 | if (RT_SUCCESS(rc))
|
---|
439 | {
|
---|
440 | *pcbWritten = (size_t)cch;
|
---|
441 | }
|
---|
442 |
|
---|
443 | return rc;
|
---|
444 | }
|
---|
445 |
|
---|
446 | /**
|
---|
447 | * Resolves (and validates) a given URL to an absolute (local) path.
|
---|
448 | *
|
---|
449 | * @returns VBox status code.
|
---|
450 | * @param pThis HTTP server instance data.
|
---|
451 | * @param pszUrl URL to resolve.
|
---|
452 | * @param ppszPathAbs Where to store the resolved absolute path on success.
|
---|
453 | * Needs to be free'd with RTStrFree().
|
---|
454 | */
|
---|
455 | static int pathResolve(PHTTPSERVERDATA pThis, const char *pszUrl, char **ppszPathAbs)
|
---|
456 | {
|
---|
457 | /* Construct absolute path. */
|
---|
458 | char *pszPathAbs = NULL;
|
---|
459 | if (RTStrAPrintf(&pszPathAbs, "%s/%s", pThis->szPathRootAbs, pszUrl) <= 0)
|
---|
460 | return VERR_NO_MEMORY;
|
---|
461 |
|
---|
462 | #ifdef VBOX_STRICT
|
---|
463 | RTFSOBJINFO objInfo;
|
---|
464 | int rc2 = RTPathQueryInfo(pszPathAbs, &objInfo, RTFSOBJATTRADD_NOTHING);
|
---|
465 | AssertRCReturn(rc2, rc2); RT_NOREF(rc2);
|
---|
466 | AssertReturn(!RTFS_IS_SYMLINK(objInfo.Attr.fMode), VERR_NOT_SUPPORTED);
|
---|
467 | #endif
|
---|
468 |
|
---|
469 | *ppszPathAbs = pszPathAbs;
|
---|
470 |
|
---|
471 | return VINF_SUCCESS;
|
---|
472 | }
|
---|
473 |
|
---|
474 | DECLCALLBACK(int) onOpen(PRTHTTPCALLBACKDATA pData, PRTHTTPSERVERREQ pReq, void **ppvHandle)
|
---|
475 | {
|
---|
476 | PHTTPSERVERDATA pThis = (PHTTPSERVERDATA)pData->pvUser;
|
---|
477 | Assert(pData->cbUser == sizeof(HTTPSERVERDATA));
|
---|
478 |
|
---|
479 | char *pszPathAbs = NULL;
|
---|
480 | int rc = pathResolve(pThis, pReq->pszUrl, &pszPathAbs);
|
---|
481 | if (RT_SUCCESS(rc))
|
---|
482 | {
|
---|
483 | RTFSOBJINFO objInfo;
|
---|
484 | rc = RTPathQueryInfo(pszPathAbs, &objInfo, RTFSOBJATTRADD_NOTHING);
|
---|
485 | AssertRCReturn(rc, rc);
|
---|
486 | if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
|
---|
487 | {
|
---|
488 | /* Nothing to do here;
|
---|
489 | * The directory listing has been cached already in onQueryInfo(). */
|
---|
490 | }
|
---|
491 | else if (RTFS_IS_FILE(objInfo.Attr.fMode))
|
---|
492 | {
|
---|
493 | rc = RTFileOpen(&pThis->h.File, pszPathAbs,
|
---|
494 | RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
|
---|
495 | }
|
---|
496 |
|
---|
497 | if (RT_SUCCESS(rc))
|
---|
498 | {
|
---|
499 | pThis->fMode = objInfo.Attr.fMode;
|
---|
500 |
|
---|
501 | uint64_t *puHandle = (uint64_t *)RTMemAlloc(sizeof(uint64_t));
|
---|
502 | *puHandle = 42; /** @todo Fudge. */
|
---|
503 | *ppvHandle = puHandle;
|
---|
504 | }
|
---|
505 |
|
---|
506 | RTStrFree(pszPathAbs);
|
---|
507 | }
|
---|
508 |
|
---|
509 | LogFlowFuncLeaveRC(rc);
|
---|
510 | return rc;
|
---|
511 | }
|
---|
512 |
|
---|
513 | DECLCALLBACK(int) onRead(PRTHTTPCALLBACKDATA pData, void *pvHandle, void *pvBuf, size_t cbBuf, size_t *pcbRead)
|
---|
514 | {
|
---|
515 | PHTTPSERVERDATA pThis = (PHTTPSERVERDATA)pData->pvUser;
|
---|
516 | Assert(pData->cbUser == sizeof(HTTPSERVERDATA));
|
---|
517 |
|
---|
518 | AssertReturn(*(uint64_t *)pvHandle == 42 /** @todo Fudge. */, VERR_NOT_FOUND);
|
---|
519 |
|
---|
520 | int rc;
|
---|
521 |
|
---|
522 | if (RTFS_IS_DIRECTORY(pThis->fMode))
|
---|
523 | {
|
---|
524 | PRTHTTPSERVERRESP pResp = &pThis->Resp;
|
---|
525 |
|
---|
526 | const size_t cbToCopy = RT_MIN(cbBuf, pResp->Body.cbBodyUsed - pResp->Body.offBody);
|
---|
527 | memcpy(pvBuf, (uint8_t *)pResp->Body.pvBody + pResp->Body.offBody, cbToCopy);
|
---|
528 | Assert(pResp->Body.cbBodyUsed >= cbToCopy);
|
---|
529 | pResp->Body.offBody += cbToCopy;
|
---|
530 |
|
---|
531 | *pcbRead = cbToCopy;
|
---|
532 |
|
---|
533 | rc = VINF_SUCCESS;
|
---|
534 | }
|
---|
535 | else if (RTFS_IS_FILE(pThis->fMode))
|
---|
536 | {
|
---|
537 | rc = RTFileRead(pThis->h.File, pvBuf, cbBuf, pcbRead);
|
---|
538 | }
|
---|
539 | else
|
---|
540 | rc = VERR_NOT_SUPPORTED;
|
---|
541 |
|
---|
542 | LogFlowFuncLeaveRC(rc);
|
---|
543 | return rc;
|
---|
544 | }
|
---|
545 |
|
---|
546 | DECLCALLBACK(int) onClose(PRTHTTPCALLBACKDATA pData, void *pvHandle)
|
---|
547 | {
|
---|
548 | PHTTPSERVERDATA pThis = (PHTTPSERVERDATA)pData->pvUser;
|
---|
549 | Assert(pData->cbUser == sizeof(HTTPSERVERDATA));
|
---|
550 |
|
---|
551 | AssertReturn(*(uint64_t *)pvHandle == 42 /** @todo Fudge. */, VERR_NOT_FOUND);
|
---|
552 |
|
---|
553 | int rc;
|
---|
554 |
|
---|
555 | if (RTFS_IS_FILE(pThis->fMode))
|
---|
556 | {
|
---|
557 | rc = RTFileClose(pThis->h.File);
|
---|
558 | if (RT_SUCCESS(rc))
|
---|
559 | pThis->h.File = NIL_RTFILE;
|
---|
560 | }
|
---|
561 | else
|
---|
562 | rc = VINF_SUCCESS;
|
---|
563 |
|
---|
564 | RTMemFree(pvHandle);
|
---|
565 | pvHandle = NULL;
|
---|
566 |
|
---|
567 | LogFlowFuncLeaveRC(rc);
|
---|
568 | return rc;
|
---|
569 | }
|
---|
570 |
|
---|
571 | DECLCALLBACK(int) onQueryInfo(PRTHTTPCALLBACKDATA pData,
|
---|
572 | PRTHTTPSERVERREQ pReq, PRTFSOBJINFO pObjInfo, char **ppszMIMEHint)
|
---|
573 | {
|
---|
574 | PHTTPSERVERDATA pThis = (PHTTPSERVERDATA)pData->pvUser;
|
---|
575 | Assert(pData->cbUser == sizeof(HTTPSERVERDATA));
|
---|
576 |
|
---|
577 | /** !!!! WARNING !!!
|
---|
578 | **
|
---|
579 | ** Not production-ready code below!
|
---|
580 | ** @todo Use something like bodyAdd() instead of the RTStrPrintf2() hacks.
|
---|
581 | **
|
---|
582 | ** !!!! WARNING !!! */
|
---|
583 |
|
---|
584 | char *pszPathAbs = NULL;
|
---|
585 | int rc = pathResolve(pThis, pReq->pszUrl, &pszPathAbs);
|
---|
586 | if (RT_SUCCESS(rc))
|
---|
587 | {
|
---|
588 | RTFSOBJINFO objInfo;
|
---|
589 | rc = RTPathQueryInfo(pszPathAbs, &objInfo, RTFSOBJATTRADD_NOTHING);
|
---|
590 | if (RT_SUCCESS(rc))
|
---|
591 | {
|
---|
592 | if (RTFS_IS_DIRECTORY(objInfo.Attr.fMode))
|
---|
593 | {
|
---|
594 | PRTHTTPSERVERRESP pResp = &pThis->Resp; /* Only one request a time for now. */
|
---|
595 |
|
---|
596 | RTVFSDIR hVfsDir;
|
---|
597 | rc = dirOpen(pszPathAbs, &hVfsDir);
|
---|
598 | if (RT_SUCCESS(rc))
|
---|
599 | {
|
---|
600 | RTHttpServerResponseDestroy(pResp);
|
---|
601 | RTHttpServerResponseInitEx(pResp, _64K); /** @todo Make this more dynamic. */
|
---|
602 |
|
---|
603 | char *pszBody = (char *)pResp->Body.pvBody;
|
---|
604 | size_t cbBodyLeft = pResp->Body.cbBodyAlloc;
|
---|
605 |
|
---|
606 | /*
|
---|
607 | * Write body header.
|
---|
608 | */
|
---|
609 | if (pReq->enmMethod == RTHTTPMETHOD_GET)
|
---|
610 | {
|
---|
611 | ssize_t cch = RTStrPrintf2(pszBody, cbBodyLeft,
|
---|
612 | "300: file://%s\r\n"
|
---|
613 | "200: filename content-length last-modified file-type\r\n",
|
---|
614 | pReq->pszUrl);
|
---|
615 | Assert(cch);
|
---|
616 | pszBody += cch;
|
---|
617 | cbBodyLeft -= cch;
|
---|
618 | }
|
---|
619 | #ifdef IPRT_HTTP_WITH_WEBDAV
|
---|
620 | else if (pReq->enmMethod == RTHTTPMETHOD_PROPFIND)
|
---|
621 | {
|
---|
622 | size_t cbWritten = 0;
|
---|
623 | rc = writeHeaderDAV(pReq, &objInfo, pszBody, cbBodyLeft, &cbWritten);
|
---|
624 | if (RT_SUCCESS(rc))
|
---|
625 | {
|
---|
626 | Assert(cbBodyLeft >= cbWritten);
|
---|
627 | cbBodyLeft -= cbWritten;
|
---|
628 | }
|
---|
629 |
|
---|
630 | }
|
---|
631 | #endif /* IPRT_HTTP_WITH_WEBDAV */
|
---|
632 | /*
|
---|
633 | * Write body entries.
|
---|
634 | */
|
---|
635 | char *pszEntry = NULL;
|
---|
636 | RTFSOBJINFO fsObjInfo;
|
---|
637 | while (RT_SUCCESS(rc = dirRead(hVfsDir, &pszEntry, &fsObjInfo)))
|
---|
638 | {
|
---|
639 | LogFlowFunc(("Entry '%s'\n", pszEntry));
|
---|
640 |
|
---|
641 | size_t cbWritten = 0;
|
---|
642 | rc = dirEntryWrite(pReq->enmMethod, pszBody, cbBodyLeft, pszEntry, &fsObjInfo, &cbWritten);
|
---|
643 | if (rc == VERR_BUFFER_OVERFLOW)
|
---|
644 | {
|
---|
645 | pResp->Body.cbBodyAlloc += _4K; /** @todo Improve this. */
|
---|
646 | pResp->Body.pvBody = RTMemRealloc(pResp->Body.pvBody, pResp->Body.cbBodyAlloc);
|
---|
647 | AssertPtrBreakStmt(pResp->Body.pvBody, rc = VERR_NO_MEMORY);
|
---|
648 |
|
---|
649 | pszBody = (char *)pResp->Body.pvBody;
|
---|
650 | cbBodyLeft += _4K; /** @todo Ditto. */
|
---|
651 |
|
---|
652 | rc = dirEntryWrite(pReq->enmMethod, pszBody, cbBodyLeft, pszEntry, &fsObjInfo, &cbWritten);
|
---|
653 | }
|
---|
654 |
|
---|
655 | if ( RT_SUCCESS(rc)
|
---|
656 | && cbWritten)
|
---|
657 | {
|
---|
658 | pszBody += cbWritten;
|
---|
659 | Assert(cbBodyLeft > cbWritten);
|
---|
660 | cbBodyLeft -= cbWritten;
|
---|
661 | }
|
---|
662 |
|
---|
663 | RTStrFree(pszEntry);
|
---|
664 |
|
---|
665 | if (RT_FAILURE(rc))
|
---|
666 | break;
|
---|
667 | }
|
---|
668 |
|
---|
669 | if (rc == VERR_NO_MORE_FILES) /* All entries consumed? */
|
---|
670 | rc = VINF_SUCCESS;
|
---|
671 |
|
---|
672 | dirClose(hVfsDir);
|
---|
673 |
|
---|
674 | /*
|
---|
675 | * Write footers, if any.
|
---|
676 | */
|
---|
677 | if (RT_SUCCESS(rc))
|
---|
678 | {
|
---|
679 | if (pReq->enmMethod == RTHTTPMETHOD_GET)
|
---|
680 | {
|
---|
681 | if (ppszMIMEHint)
|
---|
682 | rc = RTStrAPrintf(ppszMIMEHint, "text/plain");
|
---|
683 | }
|
---|
684 | #ifdef IPRT_HTTP_WITH_WEBDAV
|
---|
685 | else if (pReq->enmMethod == RTHTTPMETHOD_PROPFIND)
|
---|
686 | {
|
---|
687 | rc = writeFooterDAV(pReq, pszBody, cbBodyLeft, NULL);
|
---|
688 | }
|
---|
689 | #endif /* IPRT_HTTP_WITH_WEBDAV */
|
---|
690 |
|
---|
691 | pResp->Body.cbBodyUsed = strlen((char *)pResp->Body.pvBody);
|
---|
692 |
|
---|
693 | pObjInfo->cbObject = pResp->Body.cbBodyUsed;
|
---|
694 | }
|
---|
695 | }
|
---|
696 | }
|
---|
697 | else if (RTFS_IS_FILE(objInfo.Attr.fMode))
|
---|
698 | {
|
---|
699 | RTFILE hFile;
|
---|
700 | rc = RTFileOpen(&hFile, pszPathAbs,
|
---|
701 | RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_WRITE);
|
---|
702 | if (RT_SUCCESS(rc))
|
---|
703 | {
|
---|
704 | rc = RTFileQueryInfo(hFile, pObjInfo, RTFSOBJATTRADD_NOTHING);
|
---|
705 |
|
---|
706 | RTFileClose(hFile);
|
---|
707 | }
|
---|
708 | }
|
---|
709 | else
|
---|
710 | rc = VERR_NOT_SUPPORTED;
|
---|
711 | }
|
---|
712 |
|
---|
713 | RTStrFree(pszPathAbs);
|
---|
714 | }
|
---|
715 |
|
---|
716 | LogFlowFuncLeaveRC(rc);
|
---|
717 | return rc;
|
---|
718 | }
|
---|
719 |
|
---|
720 | DECLCALLBACK(int) onDestroy(PRTHTTPCALLBACKDATA pData)
|
---|
721 | {
|
---|
722 | PHTTPSERVERDATA pThis = (PHTTPSERVERDATA)pData->pvUser;
|
---|
723 | Assert(pData->cbUser == sizeof(HTTPSERVERDATA));
|
---|
724 |
|
---|
725 | RTHttpServerResponseDestroy(&pThis->Resp);
|
---|
726 |
|
---|
727 | return VINF_SUCCESS;
|
---|
728 | }
|
---|
729 |
|
---|
730 | int main(int argc, char **argv)
|
---|
731 | {
|
---|
732 | int rc = RTR3InitExe(argc, &argv, 0);
|
---|
733 | if (RT_FAILURE(rc))
|
---|
734 | return RTMsgInitFailure(rc);
|
---|
735 |
|
---|
736 | /* Use some sane defaults. */
|
---|
737 | char szAddress[64] = "localhost";
|
---|
738 | uint16_t uPort = 8080;
|
---|
739 |
|
---|
740 | RT_ZERO(g_HttpServerData);
|
---|
741 |
|
---|
742 | /*
|
---|
743 | * Parse arguments.
|
---|
744 | */
|
---|
745 | static const RTGETOPTDEF s_aOptions[] =
|
---|
746 | {
|
---|
747 | { "--address", 'a', RTGETOPT_REQ_IPV4ADDR }, /** @todo Use a string for DNS hostnames? */
|
---|
748 | /** @todo Implement IPv6 support? */
|
---|
749 | { "--port", 'p', RTGETOPT_REQ_UINT16 },
|
---|
750 | { "--root-dir", 'r', RTGETOPT_REQ_STRING },
|
---|
751 | { "--verbose", 'v', RTGETOPT_REQ_NOTHING }
|
---|
752 | };
|
---|
753 |
|
---|
754 | RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
|
---|
755 | unsigned uVerbosityLevel = 1;
|
---|
756 |
|
---|
757 | RTGETOPTUNION ValueUnion;
|
---|
758 | RTGETOPTSTATE GetState;
|
---|
759 | RTGetOptInit(&GetState, argc, argv, s_aOptions, RT_ELEMENTS(s_aOptions), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
|
---|
760 | while ((rc = RTGetOpt(&GetState, &ValueUnion)))
|
---|
761 | {
|
---|
762 | switch (rc)
|
---|
763 | {
|
---|
764 | case 'a':
|
---|
765 | RTStrPrintf2(szAddress, sizeof(szAddress), "%RU8.%RU8.%RU8.%RU8", /** @todo Improve this. */
|
---|
766 | ValueUnion.IPv4Addr.au8[0], ValueUnion.IPv4Addr.au8[1], ValueUnion.IPv4Addr.au8[2], ValueUnion.IPv4Addr.au8[3]);
|
---|
767 | break;
|
---|
768 |
|
---|
769 | case 'p':
|
---|
770 | uPort = ValueUnion.u16;
|
---|
771 | break;
|
---|
772 |
|
---|
773 | case 'r':
|
---|
774 | RTStrCopy(g_HttpServerData.szPathRootAbs, sizeof(g_HttpServerData.szPathRootAbs), ValueUnion.psz);
|
---|
775 | break;
|
---|
776 |
|
---|
777 | case 'v':
|
---|
778 | uVerbosityLevel++;
|
---|
779 | break;
|
---|
780 |
|
---|
781 | case 'h':
|
---|
782 | RTPrintf("Usage: %s [options]\n"
|
---|
783 | "\n"
|
---|
784 | "Options:\n"
|
---|
785 | " -a, --address (default: localhost)\n"
|
---|
786 | " Specifies the address to use for listening.\n"
|
---|
787 | " -p, --port (default: 8080)\n"
|
---|
788 | " Specifies the port to use for listening.\n"
|
---|
789 | " -r, --root-dir (default: current dir)\n"
|
---|
790 | " Specifies the root directory being served.\n"
|
---|
791 | " -v, --verbose\n"
|
---|
792 | " Controls the verbosity level.\n"
|
---|
793 | " -h, -?, --help\n"
|
---|
794 | " Display this help text and exit successfully.\n"
|
---|
795 | " -V, --version\n"
|
---|
796 | " Display the revision and exit successfully.\n"
|
---|
797 | , RTPathFilename(argv[0]));
|
---|
798 | return RTEXITCODE_SUCCESS;
|
---|
799 |
|
---|
800 | case 'V':
|
---|
801 | RTPrintf("$Revision: 87042 $\n");
|
---|
802 | return RTEXITCODE_SUCCESS;
|
---|
803 |
|
---|
804 | default:
|
---|
805 | return RTGetOptPrintError(rc, &ValueUnion);
|
---|
806 | }
|
---|
807 | }
|
---|
808 |
|
---|
809 | if (!strlen(g_HttpServerData.szPathRootAbs))
|
---|
810 | {
|
---|
811 | /* By default use the current directory as serving root directory. */
|
---|
812 | rc = RTPathGetCurrent(g_HttpServerData.szPathRootAbs, sizeof(g_HttpServerData.szPathRootAbs));
|
---|
813 | if (RT_FAILURE(rc))
|
---|
814 | return RTMsgErrorExit(RTEXITCODE_FAILURE, "Retrieving current directory failed: %Rrc", rc);
|
---|
815 | }
|
---|
816 |
|
---|
817 | /* Install signal handler. */
|
---|
818 | rc = signalHandlerInstall();
|
---|
819 | if (RT_SUCCESS(rc))
|
---|
820 | {
|
---|
821 | /*
|
---|
822 | * Create the HTTP server instance.
|
---|
823 | */
|
---|
824 | RTHTTPSERVERCALLBACKS Callbacks;
|
---|
825 | RT_ZERO(Callbacks);
|
---|
826 |
|
---|
827 | Callbacks.pfnOpen = onOpen;
|
---|
828 | Callbacks.pfnRead = onRead;
|
---|
829 | Callbacks.pfnClose = onClose;
|
---|
830 | Callbacks.pfnQueryInfo = onQueryInfo;
|
---|
831 | Callbacks.pfnDestroy = onDestroy;
|
---|
832 |
|
---|
833 | g_HttpServerData.h.File = NIL_RTFILE;
|
---|
834 | g_HttpServerData.h.Dir = NIL_RTVFSDIR;
|
---|
835 |
|
---|
836 | rc = RTHttpServerResponseInit(&g_HttpServerData.Resp);
|
---|
837 | AssertRC(rc);
|
---|
838 |
|
---|
839 | RTHTTPSERVER hHTTPServer;
|
---|
840 | rc = RTHttpServerCreate(&hHTTPServer, szAddress, uPort, &Callbacks,
|
---|
841 | &g_HttpServerData, sizeof(g_HttpServerData));
|
---|
842 | if (RT_SUCCESS(rc))
|
---|
843 | {
|
---|
844 | RTPrintf("Starting HTTP server at %s:%RU16 ...\n", szAddress, uPort);
|
---|
845 | RTPrintf("Root directory is '%s'\n", g_HttpServerData.szPathRootAbs);
|
---|
846 |
|
---|
847 | RTPrintf("Running HTTP server ...\n");
|
---|
848 |
|
---|
849 | for (;;)
|
---|
850 | {
|
---|
851 | RTThreadSleep(200);
|
---|
852 |
|
---|
853 | if (g_fCanceled)
|
---|
854 | break;
|
---|
855 | }
|
---|
856 |
|
---|
857 | RTPrintf("Stopping HTTP server ...\n");
|
---|
858 |
|
---|
859 | int rc2 = RTHttpServerDestroy(hHTTPServer);
|
---|
860 | if (RT_SUCCESS(rc))
|
---|
861 | rc = rc2;
|
---|
862 |
|
---|
863 | RTPrintf("Stopped HTTP server\n");
|
---|
864 | }
|
---|
865 | else
|
---|
866 | rcExit = RTMsgErrorExit(RTEXITCODE_FAILURE, "RTHttpServerCreate failed: %Rrc", rc);
|
---|
867 |
|
---|
868 | int rc2 = signalHandlerUninstall();
|
---|
869 | if (RT_SUCCESS(rc))
|
---|
870 | rc = rc2;
|
---|
871 | }
|
---|
872 |
|
---|
873 | /* Set rcExit on failure in case we forgot to do so before. */
|
---|
874 | if (RT_FAILURE(rc))
|
---|
875 | rcExit = RTEXITCODE_FAILURE;
|
---|
876 |
|
---|
877 | return rcExit;
|
---|
878 | }
|
---|
879 |
|
---|