diff options
Diffstat (limited to '')
| -rw-r--r-- | src/VBox/Runtime/r3/http-server.cpp | 1455 |
1 files changed, 1455 insertions, 0 deletions
diff --git a/src/VBox/Runtime/r3/http-server.cpp b/src/VBox/Runtime/r3/http-server.cpp new file mode 100644 index 00000000..93c3f3fa --- /dev/null +++ b/src/VBox/Runtime/r3/http-server.cpp @@ -0,0 +1,1455 @@ +/* $Id: http-server.cpp $ */ +/** @file + * Simple HTTP server (RFC 7231) implementation. + * + * Known limitations so far: + * - Only HTTP 1.1. + * - Only supports GET + HEAD methods so far. + * - Only supports UTF-8 charset. + * - Only supports plain text and octet stream MIME types. + * - No content compression ("gzip", "x-gzip", ++). + * - No caching. + * - No redirections (via 302). + * - No encryption (TLS). + * - No IPv6 support. + * - No multi-threading. + * + * For WebDAV (optional via IPRT_HTTP_WITH_WEBDAV): + * - Only OPTIONS + PROPLIST methods are implemented (e.g. simple read-only support). + * - No pagination support for directory listings. + */ + +/* + * Copyright (C) 2020-2023 Oracle and/or its affiliates. + * + * This file is part of VirtualBox base platform packages, as + * available from https://www.virtualbox.org. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, in version 3 of the + * License. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <https://www.gnu.org/licenses>. + * + * The contents of this file may alternatively be used under the terms + * of the Common Development and Distribution License Version 1.0 + * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included + * in the VirtualBox distribution, in which case the provisions of the + * CDDL are applicable instead of those of the GPL. + * + * You may elect to license modified versions of this file under the + * terms and conditions of either the GPL or the CDDL or both. + * + * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0 + */ + + +/********************************************************************************************************************************* +* Header Files * +*********************************************************************************************************************************/ +#define LOG_GROUP RTLOGGROUP_HTTP +#include <iprt/http.h> +#include <iprt/http-server.h> +#include "internal/iprt.h" +#include "internal/magics.h" + +#include <iprt/asm.h> +#include <iprt/assert.h> +#include <iprt/circbuf.h> +#include <iprt/ctype.h> +#include <iprt/err.h> +#include <iprt/file.h> /* For file mode flags. */ +#include <iprt/getopt.h> +#include <iprt/mem.h> +#include <iprt/log.h> +#include <iprt/path.h> +#include <iprt/poll.h> +#include <iprt/socket.h> +#include <iprt/sort.h> +#include <iprt/string.h> +#include <iprt/system.h> +#include <iprt/tcp.h> + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ +/** + * Internal HTTP server instance. + */ +typedef struct RTHTTPSERVERINTERNAL +{ + /** Magic value. */ + uint32_t u32Magic; + /** Callback table. */ + RTHTTPSERVERCALLBACKS Callbacks; + /** Pointer to TCP server instance. */ + PRTTCPSERVER pTCPServer; + /** Pointer to user-specific data. Optional. */ + void *pvUser; + /** Size of user-specific data. Optional. */ + size_t cbUser; +} RTHTTPSERVERINTERNAL; +/** Pointer to an internal HTTP server instance. */ +typedef RTHTTPSERVERINTERNAL *PRTHTTPSERVERINTERNAL; + + +/********************************************************************************************************************************* +* Defined Constants And Macros * +*********************************************************************************************************************************/ +/** Validates a handle and returns VERR_INVALID_HANDLE if not valid. */ +#define RTHTTPSERVER_VALID_RETURN_RC(hHttpServer, a_rc) \ + do { \ + AssertPtrReturn((hHttpServer), (a_rc)); \ + AssertReturn((hHttpServer)->u32Magic == RTHTTPSERVER_MAGIC, (a_rc)); \ + } while (0) + +/** Validates a handle and returns VERR_INVALID_HANDLE if not valid. */ +#define RTHTTPSERVER_VALID_RETURN(hHttpServer) RTHTTPSERVER_VALID_RETURN_RC((hHttpServer), VERR_INVALID_HANDLE) + +/** Validates a handle and returns (void) if not valid. */ +#define RTHTTPSERVER_VALID_RETURN_VOID(hHttpServer) \ + do { \ + AssertPtrReturnVoid(hHttpServer); \ + AssertReturnVoid((hHttpServer)->u32Magic == RTHTTPSERVER_MAGIC); \ + } while (0) + + +/** Handles a HTTP server callback with no arguments and returns. */ +#define RTHTTPSERVER_HANDLE_CALLBACK_RET(a_Name) \ + do \ + { \ + PRTHTTPSERVERCALLBACKS pCallbacks = &pClient->pServer->Callbacks; \ + if (pCallbacks->a_Name) \ + { \ + RTHTTPCALLBACKDATA Data = { &pClient->State }; \ + return pCallbacks->a_Name(&Data); \ + } \ + return VERR_NOT_IMPLEMENTED; \ + } while (0) + +/** Handles a HTTP server callback with no arguments and sets rc accordingly. */ +#define RTHTTPSERVER_HANDLE_CALLBACK(a_Name) \ + do \ + { \ + PRTHTTPSERVERCALLBACKS pCallbacks = &pClient->pServer->Callbacks; \ + if (pCallbacks->a_Name) \ + { \ + RTHTTPCALLBACKDATA Data = { &pClient->State, pClient->pServer->pvUser, pClient->pServer->cbUser }; \ + rc = pCallbacks->a_Name(&Data); \ + } \ + } while (0) + +/** Handles a HTTP server callback with arguments and sets rc accordingly. */ +#define RTHTTPSERVER_HANDLE_CALLBACK_VA(a_Name, ...) \ + do \ + { \ + PRTHTTPSERVERCALLBACKS pCallbacks = &pClient->pServer->Callbacks; \ + if (pCallbacks->a_Name) \ + { \ + RTHTTPCALLBACKDATA Data = { &pClient->State, pClient->pServer->pvUser, pClient->pServer->cbUser }; \ + rc = pCallbacks->a_Name(&Data, __VA_ARGS__); \ + } \ + } while (0) + +/** Handles a HTTP server callback with arguments and returns. */ +#define RTHTTPSERVER_HANDLE_CALLBACK_VA_RET(a_Name, ...) \ + do \ + { \ + PRTHTTPSERVERCALLBACKS pCallbacks = &pClient->pServer->Callbacks; \ + if (pCallbacks->a_Name) \ + { \ + RTHTTPCALLBACKDATA Data = { &pClient->State, pClient->pServer->pvUser, pClient->pServer->cbUser }; \ + return pCallbacks->a_Name(&Data, __VA_ARGS__); \ + } \ + } while (0) + + +/********************************************************************************************************************************* +* Structures and Typedefs * +*********************************************************************************************************************************/ + +/** + * Structure for maintaining an internal HTTP server client. + */ +typedef struct RTHTTPSERVERCLIENT +{ + /** Pointer to internal server state. */ + PRTHTTPSERVERINTERNAL pServer; + /** Socket handle the client is bound to. */ + RTSOCKET hSocket; + /** Actual client state. */ + RTHTTPSERVERCLIENTSTATE State; +} RTHTTPSERVERCLIENT; +/** Pointer to an internal HTTP server client state. */ +typedef RTHTTPSERVERCLIENT *PRTHTTPSERVERCLIENT; + +/** Function pointer declaration for a specific HTTP server method handler. */ +typedef DECLCALLBACKTYPE(int, FNRTHTTPSERVERMETHOD,(PRTHTTPSERVERCLIENT pClient, PRTHTTPSERVERREQ pReq)); +/** Pointer to a FNRTHTTPSERVERMETHOD(). */ +typedef FNRTHTTPSERVERMETHOD *PFNRTHTTPSERVERMETHOD; + +/** + * Static lookup table for some file extensions <-> MIME type. Add more as needed. + * Keep this alphabetical (file extension). + */ +static const struct +{ + /** File extension. */ + const char *pszExt; + /** MIME type. */ + const char *pszMIMEType; +} s_aFileExtMIMEType[] = { + { ".arj", "application/x-arj-compressed" }, + { ".asf", "video/x-ms-asf" }, + { ".avi", "video/x-msvideo" }, + { ".bmp", "image/bmp" }, + { ".css", "text/css" }, + { ".doc", "application/msword" }, + { ".exe", "application/octet-stream" }, + { ".gif", "image/gif" }, + { ".gz", "application/x-gunzip" }, + { ".htm", "text/html" }, + { ".html", "text/html" }, + { ".ico", "image/x-icon" }, + { ".js", "application/x-javascript" }, + { ".json", "text/json" }, + { ".jpg", "image/jpeg" }, + { ".jpeg", "image/jpeg" }, + { ".ogg", "application/ogg" }, + { ".m3u", "audio/x-mpegurl" }, + { ".m4v", "video/x-m4v" }, + { ".mid", "audio/mid" }, + { ".mov", "video/quicktime" }, + { ".mp3", "audio/x-mp3" }, + { ".mp4", "video/mp4" }, + { ".mpg", "video/mpeg" }, + { ".mpeg", "video/mpeg" }, + { ".pdf", "application/pdf" }, + { ".png", "image/png" }, + { ".ra", "audio/x-pn-realaudio" }, + { ".ram", "audio/x-pn-realaudio" }, + { ".rar", "application/x-arj-compressed" }, + { ".rtf", "application/rtf" }, + { ".shtm", "text/html" }, + { ".shtml", "text/html" }, + { ".svg", "image/svg+xml" }, + { ".swf", "application/x-shockwave-flash" }, + { ".torrent", "application/x-bittorrent" }, + { ".tar", "application/x-tar" }, + { ".tgz", "application/x-tar-gz" }, + { ".ttf", "application/x-font-ttf" }, + { ".txt", "text/plain" }, + { ".wav", "audio/x-wav" }, + { ".webm", "video/webm" }, + { ".xml", "text/xml" }, + { ".xls", "application/excel" }, + { ".xsl", "application/xml" }, + { ".xslt", "application/xml" }, + { ".zip", "application/x-zip-compressed" }, + { NULL, NULL } +}; + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ + +/** @name Method handlers. + * @{ + */ +static FNRTHTTPSERVERMETHOD rtHttpServerHandleGET; +static FNRTHTTPSERVERMETHOD rtHttpServerHandleHEAD; +#ifdef IPRT_HTTP_WITH_WEBDAV + static FNRTHTTPSERVERMETHOD rtHttpServerHandleOPTIONS; + static FNRTHTTPSERVERMETHOD rtHttpServerHandlePROPFIND; +#endif +/** @} */ + +/** + * Structure for maintaining a single method entry for the methods table. + */ +typedef struct RTHTTPSERVERMETHOD_ENTRY +{ + /** Method ID. */ + RTHTTPMETHOD enmMethod; + /** Function pointer invoked to handle the command. */ + PFNRTHTTPSERVERMETHOD pfnMethod; +} RTHTTPSERVERMETHOD_ENTRY; +/** Pointer to a command entry. */ +typedef RTHTTPSERVERMETHOD_ENTRY *PRTHTTPMETHOD_ENTRY; + + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +/** + * Table of handled methods. + */ +static const RTHTTPSERVERMETHOD_ENTRY g_aMethodMap[] = +{ + { RTHTTPMETHOD_GET, rtHttpServerHandleGET }, + { RTHTTPMETHOD_HEAD, rtHttpServerHandleHEAD }, +#ifdef IPRT_HTTP_WITH_WEBDAV + { RTHTTPMETHOD_OPTIONS, rtHttpServerHandleOPTIONS }, + { RTHTTPMETHOD_PROPFIND, rtHttpServerHandlePROPFIND }, +#endif + { RTHTTPMETHOD_END, NULL } +}; + +/** Maximum length in characters a HTTP server path can have (excluding termination). */ +#define RTHTTPSERVER_MAX_PATH RTPATH_MAX + + +/********************************************************************************************************************************* +* Internal functions * +*********************************************************************************************************************************/ + +/** + * Guesses the HTTP MIME type based on a given file extension. + * + * Note: Has to include the beginning dot, e.g. ".mp3" (see IPRT). + * + * @returns Guessed MIME type, or "application/octet-stream" if not found. + * @param pszFileExt File extension to guess MIME type for. + */ +static const char *rtHttpServerGuessMIMEType(const char *pszFileExt) +{ + if (pszFileExt) + { + size_t i = 0; + while (s_aFileExtMIMEType[i++].pszExt) /* Slow, but does the job for now. */ + { + if (!RTStrICmp(pszFileExt, s_aFileExtMIMEType[i].pszExt)) + return s_aFileExtMIMEType[i].pszMIMEType; + } + } + + return "application/octet-stream"; +} + +/** + * Initializes a HTTP body. + * + * @param pBody Body to initialize. + * @param cbSize Size of body (in bytes) to allocate. Optional and can be 0. + */ +static int rtHttpServerBodyInit(PRTHTTPBODY pBody, size_t cbSize) +{ + if (cbSize) + { + pBody->pvBody = RTMemAlloc(cbSize); + AssertPtrReturn(pBody->pvBody, VERR_NO_MEMORY); + pBody->cbBodyAlloc = cbSize; + } + else + { + pBody->pvBody = NULL; + pBody->cbBodyAlloc = 0; + } + + pBody->cbBodyUsed = 0; + pBody->offBody = 0; + + return VINF_SUCCESS; +} + +/** + * Destroys a HTTP body. + * + * @param pBody Body to destroy. + */ +static void rtHttpServerBodyDestroy(PRTHTTPBODY pBody) +{ + if (!pBody) + return; + + if (pBody->pvBody) + { + Assert(pBody->cbBodyAlloc); + + RTMemFree(pBody->pvBody); + pBody->pvBody = NULL; + } + + pBody->cbBodyAlloc = 0; + pBody->cbBodyUsed = 0; + pBody->offBody = 0; +} + +/** + * Allocates and initializes a new client request. + * + * @returns Pointer to the new client request, or NULL on OOM. + * Needs to be free'd with rtHttpServerReqFree(). + */ +static PRTHTTPSERVERREQ rtHttpServerReqAlloc(void) +{ + PRTHTTPSERVERREQ pReq = (PRTHTTPSERVERREQ)RTMemAllocZ(sizeof(RTHTTPSERVERREQ)); + AssertPtrReturn(pReq, NULL); + + int rc2 = RTHttpHeaderListInit(&pReq->hHdrLst); + AssertRC(rc2); + + rc2 = rtHttpServerBodyInit(&pReq->Body, 0 /* cbSize */); + AssertRC(rc2); + + return pReq; +} + +/** + * Frees a formerly allocated client request. + * + * @param pReq Pointer to client request to free. + * The pointer will be invalid on return. + */ +static void rtHttpServerReqFree(PRTHTTPSERVERREQ pReq) +{ + if (!pReq) + return; + + RTStrFree(pReq->pszUrl); + + RTHttpHeaderListDestroy(pReq->hHdrLst); + + rtHttpServerBodyDestroy(&pReq->Body); + + RTMemFree(pReq); + pReq = NULL; +} + +/** + * Initializes a HTTP server response with an allocated body size. + * + * @returns VBox status code. + * @param pResp HTTP server response to initialize. + * @param cbBody Body size (in bytes) to allocate. + */ +RTR3DECL(int) RTHttpServerResponseInitEx(PRTHTTPSERVERRESP pResp, size_t cbBody) +{ + pResp->enmSts = RTHTTPSTATUS_INTERNAL_NOT_SET; + + int rc = RTHttpHeaderListInit(&pResp->hHdrLst); + AssertRCReturn(rc, rc); + + rc = rtHttpServerBodyInit(&pResp->Body, cbBody); + + return rc; +} + +/** + * Initializes a HTTP server response. + * + * @returns VBox status code. + * @param pResp HTTP server response to initialize. + */ +RTR3DECL(int) RTHttpServerResponseInit(PRTHTTPSERVERRESP pResp) +{ + return RTHttpServerResponseInitEx(pResp, 0 /* cbBody */); +} + +/** + * Destroys a formerly initialized HTTP server response. + * + * @param pResp Pointer to HTTP server response to destroy. + */ +RTR3DECL(void) RTHttpServerResponseDestroy(PRTHTTPSERVERRESP pResp) +{ + if (!pResp) + return; + + pResp->enmSts = RTHTTPSTATUS_INTERNAL_NOT_SET; + + RTHttpHeaderListDestroy(pResp->hHdrLst); + + rtHttpServerBodyDestroy(&pResp->Body); +} + + +/********************************************************************************************************************************* +* Protocol Functions * +*********************************************************************************************************************************/ + +/** + * Logs the HTTP protocol communication to the debug logger (2). + * + * @param pClient Client to log communication for. + * @param fWrite Whether the server is writing (to client) or reading (from client). + * @param pszData Actual protocol communication data to log. + */ +static void rtHttpServerLogProto(PRTHTTPSERVERCLIENT pClient, bool fWrite, const char *pszData) +{ + RT_NOREF(pClient); + +#ifdef LOG_ENABLED + if (!pszData) /* Nothing to log? Bail out. */ + return; + + char **ppapszStrings; + size_t cStrings; + int rc2 = RTStrSplit(pszData, strlen(pszData), RTHTTPSERVER_HTTP11_EOL_STR, &ppapszStrings, &cStrings); + if (RT_SUCCESS(rc2)) + { + for (size_t i = 0; i < cStrings; i++) + { + Log2(("%s %s\n", fWrite ? ">" : "<", ppapszStrings[i])); + RTStrFree(ppapszStrings[i]); + } + + RTMemFree(ppapszStrings); + } +#else + RT_NOREF(fWrite, pszData); +#endif +} + +/** + * Writes HTTP protocol communication data to a connected client. + * + * @returns VBox status code. + * @param pClient Client to write data to. + * @param pszData Data to write. Must be zero-terminated. + */ +static int rtHttpServerWriteProto(PRTHTTPSERVERCLIENT pClient, const char *pszData) +{ + rtHttpServerLogProto(pClient, true /* fWrite */, pszData); + return RTTcpWrite(pClient->hSocket, pszData, strlen(pszData)); +} + +/** + * Main function for sending a response back to the client. + * + * @returns VBox status code. + * @param pClient Client to reply to. + * @param enmSts Status code to send. + */ +static int rtHttpServerSendResponse(PRTHTTPSERVERCLIENT pClient, RTHTTPSTATUS enmSts) +{ + char *pszResp; + int rc = RTStrAPrintf(&pszResp, + "%s %RU32 %s\r\n", RTHTTPVER_1_1_STR, enmSts, RTHttpStatusToStr(enmSts)); + AssertRCReturn(rc, rc); + rc = rtHttpServerWriteProto(pClient, pszResp); + RTStrFree(pszResp); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Main function for sending response headers back to the client. + * + * @returns VBox status code. + * @param pClient Client to reply to. + * @param pHdrLst Header list to send. Optional and can be NULL. + */ +static int rtHttpServerSendResponseHdrEx(PRTHTTPSERVERCLIENT pClient, PRTHTTPHEADERLIST pHdrLst) +{ + RTHTTPHEADERLIST HdrLst; + int rc = RTHttpHeaderListInit(&HdrLst); + AssertRCReturn(rc, rc); + +#ifdef DEBUG + /* Include a timestamp when running a debug build. */ + RTTIMESPEC tsNow; + char szTS[64]; + RTTimeSpecToString(RTTimeNow(&tsNow), szTS, sizeof(szTS)); + rc = RTHttpHeaderListAdd(HdrLst, "Date", szTS, strlen(szTS), RTHTTPHEADERLISTADD_F_BACK); + AssertRCReturn(rc, rc); +#endif + + /* Note: Deliberately don't include the VBox version due to security reasons. */ + rc = RTHttpHeaderListAdd(HdrLst, "Server", "Oracle VirtualBox", strlen("Oracle VirtualBox"), RTHTTPHEADERLISTADD_F_BACK); + AssertRCReturn(rc, rc); + +#ifdef IPRT_HTTP_WITH_WEBDAV + rc = RTHttpHeaderListAdd(HdrLst, "Allow", "GET, HEAD, PROPFIND", strlen("GET, HEAD, PROPFIND"), RTHTTPHEADERLISTADD_F_BACK); + AssertRCReturn(rc, rc); + rc = RTHttpHeaderListAdd(HdrLst, "DAV", "1", strlen("1"), RTHTTPHEADERLISTADD_F_BACK); /* Note: v1 is sufficient for read-only access. */ + AssertRCReturn(rc, rc); +#endif + + char *pszHdr = NULL; + + size_t i = 0; + const char *pszEntry; + while ((pszEntry = RTHttpHeaderListGetByOrdinal(HdrLst, i++)) != NULL) + { + rc = RTStrAAppend(&pszHdr, pszEntry); + AssertRCBreak(rc); + rc = RTStrAAppend(&pszHdr, RTHTTPSERVER_HTTP11_EOL_STR); + AssertRCBreak(rc); + } + + /* Append optional headers, if any. */ + if (pHdrLst) + { + i = 0; + while ((pszEntry = RTHttpHeaderListGetByOrdinal(*pHdrLst, i++)) != NULL) + { + rc = RTStrAAppend(&pszHdr, pszEntry); + AssertRCBreak(rc); + rc = RTStrAAppend(&pszHdr, RTHTTPSERVER_HTTP11_EOL_STR); + AssertRCBreak(rc); + } + } + + if (RT_SUCCESS(rc)) + { + /* Append trailing EOL. */ + rc = RTStrAAppend(&pszHdr, RTHTTPSERVER_HTTP11_EOL_STR); + if (RT_SUCCESS(rc)) + rc = rtHttpServerWriteProto(pClient, pszHdr); + } + + RTStrFree(pszHdr); + + RTHttpHeaderListDestroy(HdrLst); + + LogFlowFunc(("rc=%Rrc\n", rc)); + return rc; +} + +/** + * Replies with (three digit) response status back to the client, extended version. + * + * @returns VBox status code. + * @param pClient Client to reply to. + * @param enmSts Status code to send. + * @param pHdrLst Header list to send. Optional and can be NULL. + */ +static int rtHttpServerSendResponseEx(PRTHTTPSERVERCLIENT pClient, RTHTTPSTATUS enmSts, PRTHTTPHEADERLIST pHdrLst) +{ + int rc = rtHttpServerSendResponse(pClient, enmSts); + if (RT_SUCCESS(rc)) + rc = rtHttpServerSendResponseHdrEx(pClient, pHdrLst); + + return rc; +} + +/** + * Replies with (three digit) response status back to the client. + * + * @returns VBox status code. + * @param pClient Client to reply to. + * @param enmSts Status code to send. + */ +static int rtHttpServerSendResponseSimple(PRTHTTPSERVERCLIENT pClient, RTHTTPSTATUS enmSts) +{ + return rtHttpServerSendResponseEx(pClient, enmSts, NULL /* pHdrLst */); +} + +/** + * Sends a chunk of the response body to the client. + * + * @returns VBox status code. + * @param pClient Client to send body to. + * @param pvBuf Data buffer to send. + * @param cbBuf Size (in bytes) of data buffer to send. + * @param pcbSent Where to store the sent bytes. Optional and can be NULL. + */ +static int rtHttpServerSendResponseBody(PRTHTTPSERVERCLIENT pClient, void *pvBuf, size_t cbBuf, size_t *pcbSent) +{ + int rc = RTTcpWrite(pClient->hSocket, pvBuf, cbBuf); + if ( RT_SUCCESS(rc) + && pcbSent) + *pcbSent = cbBuf; + + return rc; +} + +/** + * Resolves a VBox status code to a HTTP status code. + * + * @returns Resolved HTTP status code, or RTHTTPSTATUS_INTERNALSERVERERROR if not able to resolve. + * @param rc VBox status code to resolve. + */ +static RTHTTPSTATUS rtHttpServerRcToStatus(int rc) +{ + switch (rc) + { + case VINF_SUCCESS: return RTHTTPSTATUS_OK; + case VERR_INVALID_PARAMETER: return RTHTTPSTATUS_BADREQUEST; + case VERR_INVALID_POINTER: return RTHTTPSTATUS_BADREQUEST; + case VERR_NOT_IMPLEMENTED: return RTHTTPSTATUS_NOTIMPLEMENTED; + case VERR_NOT_SUPPORTED: return RTHTTPSTATUS_NOTIMPLEMENTED; + case VERR_PATH_NOT_FOUND: return RTHTTPSTATUS_NOTFOUND; + case VERR_FILE_NOT_FOUND: return RTHTTPSTATUS_NOTFOUND; + case VERR_IS_A_DIRECTORY: return RTHTTPSTATUS_FORBIDDEN; + case VERR_NOT_FOUND: return RTHTTPSTATUS_NOTFOUND; + default: + break; + } + + AssertMsgFailed(("rc=%Rrc not handled for HTTP status\n", rc)); + return RTHTTPSTATUS_INTERNALSERVERERROR; +} + + +/********************************************************************************************************************************* +* Command Protocol Handlers * +*********************************************************************************************************************************/ + +/** + * Handler for the GET method. + * + * @returns VBox status code. + * @param pClient Client to handle GET method for. + * @param pReq Client request to handle. + */ +static DECLCALLBACK(int) rtHttpServerHandleGET(PRTHTTPSERVERCLIENT pClient, PRTHTTPSERVERREQ pReq) +{ + LogFlowFuncEnter(); + + int rc = VINF_SUCCESS; + + /* If a low-level GET request handler is defined, call it and return. */ + RTHTTPSERVER_HANDLE_CALLBACK_VA_RET(pfnOnGetRequest, pReq); + + RTFSOBJINFO fsObj; + RT_ZERO(fsObj); /* Shut up MSVC. */ + + char *pszMIMEHint = NULL; + + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnQueryInfo, pReq, &fsObj, &pszMIMEHint); + if (RT_FAILURE(rc)) + return rc; + + void *pvHandle = NULL; + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnOpen, pReq, &pvHandle); + + if (RT_SUCCESS(rc)) + { + size_t cbBuf = _64K; + void *pvBuf = RTMemAlloc(cbBuf); + AssertPtrReturn(pvBuf, VERR_NO_MEMORY); + + for (;;) + { + RTHTTPHEADERLIST HdrLst; + rc = RTHttpHeaderListInit(&HdrLst); + AssertRCReturn(rc, rc); + + char szVal[16]; + + /* Note: For directories fsObj.cbObject contains the actual size (in bytes) + * of the body data for the directory listing. */ + + ssize_t cch = RTStrPrintf2(szVal, sizeof(szVal), "%RU64", fsObj.cbObject); + AssertBreakStmt(cch, VERR_BUFFER_OVERFLOW); + rc = RTHttpHeaderListAdd(HdrLst, "Content-Length", szVal, strlen(szVal), RTHTTPHEADERLISTADD_F_BACK); + AssertRCBreak(rc); + + cch = RTStrPrintf2(szVal, sizeof(szVal), "identity"); + AssertBreakStmt(cch, VERR_BUFFER_OVERFLOW); + rc = RTHttpHeaderListAdd(HdrLst, "Content-Encoding", szVal, strlen(szVal), RTHTTPHEADERLISTADD_F_BACK); + AssertRCBreak(rc); + + if (pszMIMEHint == NULL) + { + const char *pszMIME = rtHttpServerGuessMIMEType(RTPathSuffix(pReq->pszUrl)); + rc = RTHttpHeaderListAdd(HdrLst, "Content-Type", pszMIME, strlen(pszMIME), RTHTTPHEADERLISTADD_F_BACK); + } + else + { + rc = RTHttpHeaderListAdd(HdrLst, "Content-Type", pszMIMEHint, strlen(pszMIMEHint), RTHTTPHEADERLISTADD_F_BACK); + RTStrFree(pszMIMEHint); + pszMIMEHint = NULL; + } + AssertRCBreak(rc); + + if (pClient->State.msKeepAlive) + { + /* If the client requested to keep alive the connection, + * always override this with 30s and report this back to the client. */ + pClient->State.msKeepAlive = RT_MS_30SEC; /** @todo Make this configurable. */ +#ifdef DEBUG_andy + pClient->State.msKeepAlive = 5000; +#endif + cch = RTStrPrintf2(szVal, sizeof(szVal), "timeout=%RU64", pClient->State.msKeepAlive / RT_MS_1SEC); /** @todo No pipelining support here yet. */ + AssertBreakStmt(cch, VERR_BUFFER_OVERFLOW); + rc = RTHttpHeaderListAdd(HdrLst, "Keep-Alive", szVal, strlen(szVal), RTHTTPHEADERLISTADD_F_BACK); + AssertRCReturn(rc, rc); + } + + rc = rtHttpServerSendResponseEx(pClient, RTHTTPSTATUS_OK, &HdrLst); + + RTHttpHeaderListDestroy(HdrLst); + + if (rc == VERR_BROKEN_PIPE) /* Could happen on fast reloads. */ + break; + AssertRCReturn(rc, rc); + + size_t cbToRead = fsObj.cbObject; + size_t cbRead = 0; /* Shut up GCC. */ + size_t cbWritten = 0; /* Ditto. */ + while (cbToRead) + { + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnRead, pvHandle, pvBuf, RT_MIN(cbBuf, cbToRead), &cbRead); + if (RT_FAILURE(rc)) + break; + rc = rtHttpServerSendResponseBody(pClient, pvBuf, cbRead, &cbWritten); + AssertBreak(cbToRead >= cbWritten); + cbToRead -= cbWritten; + if (rc == VERR_NET_CONNECTION_RESET_BY_PEER) /* Clients often apruptly abort the connection when done. */ + { + rc = VINF_SUCCESS; + break; + } + AssertRCBreak(rc); + } + + break; + } /* for (;;) */ + + RTMemFree(pvBuf); + + int rc2 = rc; /* Save rc. */ + + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnClose, pvHandle); + + if (RT_FAILURE(rc2)) /* Restore original rc on failure. */ + rc = rc2; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Handler for the HEAD method. + * + * @returns VBox status code. + * @param pClient Client to handle HEAD method for. + * @param pReq Client request to handle. + */ +static DECLCALLBACK(int) rtHttpServerHandleHEAD(PRTHTTPSERVERCLIENT pClient, PRTHTTPSERVERREQ pReq) +{ + LogFlowFuncEnter(); + + /* If a low-level HEAD request handler is defined, call it and return. */ + RTHTTPSERVER_HANDLE_CALLBACK_VA_RET(pfnOnHeadRequest, pReq); + + int rc = VINF_SUCCESS; + + RTFSOBJINFO fsObj; + RT_ZERO(fsObj); /* Shut up MSVC. */ + + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnQueryInfo, pReq, &fsObj, NULL /* pszMIMEHint */); + if (RT_SUCCESS(rc)) + { + RTHTTPHEADERLIST HdrLst; + rc = RTHttpHeaderListInit(&HdrLst); + AssertRCReturn(rc, rc); + + /* + * Note: A response to a HEAD request does not have a body. + * All entity headers below are assumed to describe the the response a similar GET + * request would return (but then with a body). + */ + char szVal[16]; + + ssize_t cch = RTStrPrintf2(szVal, sizeof(szVal), "%RU64", fsObj.cbObject); + AssertReturn(cch, VERR_BUFFER_OVERFLOW); + rc = RTHttpHeaderListAdd(HdrLst, "Content-Length", szVal, strlen(szVal), RTHTTPHEADERLISTADD_F_BACK); + AssertRCReturn(rc, rc); + + cch = RTStrPrintf2(szVal, sizeof(szVal), "identity"); + AssertReturn(cch, VERR_BUFFER_OVERFLOW); + rc = RTHttpHeaderListAdd(HdrLst, "Content-Encoding", szVal, strlen(szVal), RTHTTPHEADERLISTADD_F_BACK); + AssertRCReturn(rc, rc); + + const char *pszMIME = rtHttpServerGuessMIMEType(RTPathSuffix(pReq->pszUrl)); + rc = RTHttpHeaderListAdd(HdrLst, "Content-Type", pszMIME, strlen(pszMIME), RTHTTPHEADERLISTADD_F_BACK); + AssertRCReturn(rc, rc); + + rc = rtHttpServerSendResponseEx(pClient, RTHTTPSTATUS_OK, &HdrLst); + AssertRCReturn(rc, rc); + + RTHttpHeaderListDestroy(HdrLst); + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +#ifdef IPRT_HTTP_WITH_WEBDAV +/** + * Handler for the OPTIONS method. + * + * @returns VBox status code. + * @param pClient Client to handle OPTIONS method for. + * @param pReq Client request to handle. + */ +static DECLCALLBACK(int) rtHttpServerHandleOPTIONS(PRTHTTPSERVERCLIENT pClient, PRTHTTPSERVERREQ pReq) +{ + LogFlowFuncEnter(); + + RT_NOREF(pReq); + + int rc = rtHttpServerSendResponseEx(pClient, RTHTTPSTATUS_OK, NULL /* pHdrLst */); + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Handler for the PROPFIND (WebDAV) method. + * + * @returns VBox status code. + * @param pClient Client to handle PROPFIND method for. + * @param pReq Client request to handle. + */ +static DECLCALLBACK(int) rtHttpServerHandlePROPFIND(PRTHTTPSERVERCLIENT pClient, PRTHTTPSERVERREQ pReq) +{ + LogFlowFuncEnter(); + + int rc = VINF_SUCCESS; + + /* If a low-level GET request handler is defined, call it and return. */ + RTHTTPSERVER_HANDLE_CALLBACK_VA_RET(pfnOnGetRequest, pReq); + + RTFSOBJINFO fsObj; + RT_ZERO(fsObj); /* Shut up MSVC. */ + + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnQueryInfo, pReq, &fsObj, NULL /* pszMIMEHint */); + if (RT_FAILURE(rc)) + return rc; + + void *pvHandle = NULL; + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnOpen, pReq, &pvHandle); + + if (RT_SUCCESS(rc)) + { + size_t cbBuf = _64K; + void *pvBuf = RTMemAlloc(cbBuf); + AssertPtrReturn(pvBuf, VERR_NO_MEMORY); + + for (;;) + { + RTHTTPHEADERLIST HdrLst; + rc = RTHttpHeaderListInit(&HdrLst); + AssertRCReturn(rc, rc); + + char szVal[16]; + + rc = RTHttpHeaderListAdd(HdrLst, "Content-Type", "text/xml; charset=utf-8", strlen("text/xml; charset=utf-8"), RTHTTPHEADERLISTADD_F_BACK); + AssertRCBreak(rc); + + /* Note: For directories fsObj.cbObject contains the actual size (in bytes) + * of the body data for the directory listing. */ + + ssize_t cch = RTStrPrintf2(szVal, sizeof(szVal), "%RU64", fsObj.cbObject); + AssertBreakStmt(cch, VERR_BUFFER_OVERFLOW); + rc = RTHttpHeaderListAdd(HdrLst, "Content-Length", szVal, strlen(szVal), RTHTTPHEADERLISTADD_F_BACK); + AssertRCBreak(rc); + + rc = rtHttpServerSendResponseEx(pClient, RTHTTPSTATUS_MULTISTATUS, &HdrLst); + AssertRCReturn(rc, rc); + + RTHttpHeaderListDestroy(HdrLst); + + size_t cbToRead = fsObj.cbObject; + size_t cbRead = 0; /* Shut up GCC. */ + size_t cbWritten = 0; /* Ditto. */ + while (cbToRead) + { + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnRead, pvHandle, pvBuf, RT_MIN(cbBuf, cbToRead), &cbRead); + if (RT_FAILURE(rc)) + break; + //rtHttpServerLogProto(pClient, true /* fWrite */, (const char *)pvBuf); + rc = rtHttpServerSendResponseBody(pClient, pvBuf, cbRead, &cbWritten); + AssertBreak(cbToRead >= cbWritten); + cbToRead -= cbWritten; + if (rc == VERR_NET_CONNECTION_RESET_BY_PEER) /* Clients often apruptly abort the connection when done. */ + { + rc = VINF_SUCCESS; + break; + } + AssertRCBreak(rc); + } + + break; + } /* for (;;) */ + + RTMemFree(pvBuf); + + int rc2 = rc; /* Save rc. */ + + RTHTTPSERVER_HANDLE_CALLBACK_VA(pfnClose, pvHandle); + + if (RT_FAILURE(rc2)) /* Restore original rc on failure. */ + rc = rc2; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} +#endif /* IPRT_HTTP_WITH_WEBDAV */ + +/** + * Validates if a given path is valid or not. + * + * @returns \c true if path is valid, or \c false if not. + * @param pszPath Path to check. + * @param fIsAbsolute Whether the path to check is an absolute path or not. + */ +static bool rtHttpServerPathIsValid(const char *pszPath, bool fIsAbsolute) +{ + if (!pszPath) + return false; + + bool fIsValid = strlen(pszPath) + && RTStrIsValidEncoding(pszPath) + && RTStrStr(pszPath, "..") == NULL; /** @todo Very crude for now -- improve this. */ + if ( fIsValid + && fIsAbsolute) + { + RTFSOBJINFO objInfo; + int rc2 = RTPathQueryInfo(pszPath, &objInfo, RTFSOBJATTRADD_NOTHING); + if (RT_SUCCESS(rc2)) + { + fIsValid = RTFS_IS_DIRECTORY(objInfo.Attr.fMode) + || RTFS_IS_FILE(objInfo.Attr.fMode); + + /* No symlinks and other stuff not allowed. */ + } + else + fIsValid = false; + } + + LogFlowFunc(("pszPath=%s -> %RTbool\n", pszPath, fIsValid)); + return fIsValid; + +} + +/** + * Parses headers and sets (replaces) a given header list. + * + * @returns VBox status code. + * @param hList Header list to fill parsed headers in. + * @param cStrings Number of strings to parse for \a papszStrings. + * @param papszStrings Array of strings to parse. + */ +static int rtHttpServerParseHeaders(RTHTTPHEADERLIST hList, size_t cStrings, char **papszStrings) +{ + /* Nothing to parse left? Bail out early. */ + if ( !cStrings + || !papszStrings) + return VINF_SUCCESS; + +#ifdef LOG_ENABLED + for (size_t i = 0; i < cStrings; i++) + LogFlowFunc(("Header: %s\n", papszStrings[i])); +#endif + + int rc = RTHttpHeaderListSet(hList, cStrings, papszStrings); + + LogFlowFunc(("rc=%Rrc, cHeaders=%zu\n", rc, cStrings)); + return rc; +} + +/** + * Main function for parsing and allocating a client request. + * + * See: https://tools.ietf.org/html/rfc2616#section-2.2 + * + * @returns VBox status code. + * @param pClient Client to parse request from. + * @param pszReq Request string with headers to parse. + * @param cbReq Size (in bytes) of request string to parse. + * @param ppReq Where to store the allocated client request on success. + * Needs to be free'd via rtHttpServerReqFree(). + */ +static int rtHttpServerParseRequest(PRTHTTPSERVERCLIENT pClient, const char *pszReq, size_t cbReq, + PRTHTTPSERVERREQ *ppReq) +{ + RT_NOREF(pClient); + + AssertPtrReturn(pszReq, VERR_INVALID_POINTER); + AssertReturn(cbReq, VERR_INVALID_PARAMETER); + + /* We only support UTF-8 charset for now. */ + AssertReturn(RTStrIsValidEncoding(pszReq), VERR_INVALID_PARAMETER); + + char **ppapszReq = NULL; + size_t cReq = 0; + int rc = RTStrSplit(pszReq, cbReq, RTHTTPSERVER_HTTP11_EOL_STR, &ppapszReq, &cReq); + if (RT_FAILURE(rc)) + return rc; + + if (!cReq) + return VERR_INVALID_PARAMETER; + +#ifdef LOG_ENABLED + for (size_t i = 0; i < cReq; i++) + LogFlowFunc(("%s\n", ppapszReq[i])); +#endif + + PRTHTTPSERVERREQ pReq = NULL; + + char **ppapszFirstLine = NULL; + size_t cFirstLine = 0; + rc = RTStrSplit(ppapszReq[0], strlen(ppapszReq[0]), " ", &ppapszFirstLine, &cFirstLine); + if (RT_SUCCESS(rc)) + { + if (cFirstLine < 3) /* At leat the method, path and version has to be present. */ + rc = VERR_INVALID_PARAMETER; + } + + while (RT_SUCCESS(rc)) /* To use break. */ + { + pReq = rtHttpServerReqAlloc(); + AssertPtrBreakStmt(pReq, rc = VERR_NO_MEMORY); + + /* + * Parse method to use. Method names are case sensitive. + */ + const char *pszMethod = ppapszFirstLine[0]; + if (!RTStrCmp(pszMethod, "GET")) pReq->enmMethod = RTHTTPMETHOD_GET; + else if (!RTStrCmp(pszMethod, "HEAD")) pReq->enmMethod = RTHTTPMETHOD_HEAD; +#ifdef IPRT_HTTP_WITH_WEBDAV + else if (!RTStrCmp(pszMethod, "OPTIONS")) pReq->enmMethod = RTHTTPMETHOD_OPTIONS; + else if (!RTStrCmp(pszMethod, "PROPFIND")) pReq->enmMethod = RTHTTPMETHOD_PROPFIND; +#endif + else + { + rc = VERR_NOT_SUPPORTED; + break; + } + + /* + * Parse requested path. + */ + /** @todo Do URL unescaping here. */ + const char *pszPath = ppapszFirstLine[1]; + if (!rtHttpServerPathIsValid(pszPath, false /* fIsAbsolute */)) + { + rc = VERR_PATH_NOT_FOUND; + break; + } + + pReq->pszUrl = RTStrDup(pszPath); + + /* + * Parse HTTP version to use. + * We're picky heree: Only HTTP 1.1 is supported by now. + */ + const char *pszVer = ppapszFirstLine[2]; + if (RTStrCmp(pszVer, RTHTTPVER_1_1_STR)) /** @todo Use RTStrVersionCompare. Later. */ + { + rc = VERR_NOT_SUPPORTED; + break; + } + + /** @todo Anything else needed for the first line here? */ + + /* + * Process headers, if any. + */ + if (cReq > 1) + { + rc = rtHttpServerParseHeaders(pReq->hHdrLst, cReq - 1, &ppapszReq[1]); + if (RT_SUCCESS(rc)) + { + if (RTHttpHeaderListGet(pReq->hHdrLst, "Connection", RTSTR_MAX)) + pClient->State.msKeepAlive = RT_MS_30SEC; /** @todo Insert the real value here. */ + } + } + break; + } /* for (;;) */ + + /* + * Cleanup. + */ + + for (size_t i = 0; i < cFirstLine; i++) + RTStrFree(ppapszFirstLine[i]); + RTMemFree(ppapszFirstLine); + + for (size_t i = 0; i < cReq; i++) + RTStrFree(ppapszReq[i]); + RTMemFree(ppapszReq); + + if (RT_FAILURE(rc)) + { + rtHttpServerReqFree(pReq); + pReq = NULL; + } + else + *ppReq = pReq; + + return rc; +} + +/** + * Main function for processing client requests. + * + * @returns VBox status code. + * @param pClient Client to process request for. + * @param pszReq Request string to parse and handle. + * @param cbReq Size (in bytes) of request string. + */ +static int rtHttpServerProcessRequest(PRTHTTPSERVERCLIENT pClient, char *pszReq, size_t cbReq) +{ + RTHTTPSTATUS enmSts = RTHTTPSTATUS_INTERNAL_NOT_SET; + + PRTHTTPSERVERREQ pReq = NULL; /* Shut up GCC. */ + int rc = rtHttpServerParseRequest(pClient, pszReq, cbReq, &pReq); + if (RT_SUCCESS(rc)) + { + LogFlowFunc(("Request %s %s\n", RTHttpMethodToStr(pReq->enmMethod), pReq->pszUrl)); + + unsigned i = 0; + for (; i < RT_ELEMENTS(g_aMethodMap); i++) + { + const RTHTTPSERVERMETHOD_ENTRY *pMethodEntry = &g_aMethodMap[i]; + if (pReq->enmMethod == pMethodEntry->enmMethod) + { + /* Hand in request to method handler. */ + int rcMethod = pMethodEntry->pfnMethod(pClient, pReq); + if (RT_FAILURE(rcMethod)) + LogFunc(("Request %s %s failed with %Rrc\n", RTHttpMethodToStr(pReq->enmMethod), pReq->pszUrl, rcMethod)); + + enmSts = rtHttpServerRcToStatus(rcMethod); + break; + } + } + + if (i == RT_ELEMENTS(g_aMethodMap)) + enmSts = RTHTTPSTATUS_NOTIMPLEMENTED; + + rtHttpServerReqFree(pReq); + } + else + enmSts = RTHTTPSTATUS_BADREQUEST; + + if (enmSts != RTHTTPSTATUS_INTERNAL_NOT_SET) + { + int rc2 = rtHttpServerSendResponseSimple(pClient, enmSts); + if (RT_SUCCESS(rc)) + rc = rc2; + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Main loop for processing client requests. + * + * @returns VBox status code. + * @param pClient Client to process requests for. + */ +static int rtHttpServerClientMain(PRTHTTPSERVERCLIENT pClient) +{ + int rc; + + char szReq[RTHTTPSERVER_MAX_REQ_LEN + 1]; + + LogFlowFunc(("Client connected\n")); + + /* Initialize client state. */ + pClient->State.msKeepAlive = 0; + + RTMSINTERVAL cWaitMs = RT_INDEFINITE_WAIT; /* The first wait always waits indefinitely. */ + uint64_t tsLastReadMs = 0; + + for (;;) + { + rc = RTTcpSelectOne(pClient->hSocket, cWaitMs); + if (RT_FAILURE(rc)) + { + LogFlowFunc(("RTTcpSelectOne=%Rrc (cWaitMs=%RU64)\n", rc, cWaitMs)); + if (rc == VERR_TIMEOUT) + { + if (pClient->State.msKeepAlive) /* Keep alive handling needed? */ + { + if (!tsLastReadMs) + tsLastReadMs = RTTimeMilliTS(); + const uint64_t tsDeltaMs = pClient->State.msKeepAlive - (RTTimeMilliTS() - tsLastReadMs); + LogFlowFunc(("tsLastReadMs=%RU64, tsDeltaMs=%RU64\n", tsLastReadMs, tsDeltaMs)); + Log3Func(("Keep alive active (%RU32ms): %RU64ms remaining\n", pClient->State.msKeepAlive, tsDeltaMs)); + if ( tsDeltaMs > cWaitMs + && tsDeltaMs < pClient->State.msKeepAlive) + continue; + + LogFunc(("Keep alive active: Client did not respond within %RU32ms, closing\n", pClient->State.msKeepAlive)); + rc = VINF_SUCCESS; + break; + } + } + + break; + } + + LogFlowFunc(("Reading client request ...\n")); + + tsLastReadMs = RTTimeMilliTS(); + cWaitMs = 200; /* All consequtive waits do busy waiting for now. */ + + char *pszReq = szReq; + size_t cbRead; + size_t cbToRead = sizeof(szReq); + size_t cbReadTotal = 0; + + do + { + rc = RTTcpReadNB(pClient->hSocket, pszReq, cbToRead, &cbRead); + if (RT_FAILURE(rc)) + break; + + if (!cbRead) + break; + + /* Make sure to terminate string read so far. */ + pszReq[cbRead] = '\0'; + + /* End of request reached? */ + /** @todo BUGBUG Improve this. */ + char *pszEOR = RTStrStr(&pszReq[cbReadTotal], "\r\n\r\n"); + if (pszEOR) + { + cbReadTotal = pszEOR - pszReq; + *pszEOR = '\0'; + break; + } + + AssertBreak(cbToRead >= cbRead); + cbToRead -= cbRead; + cbReadTotal += cbRead; + AssertBreak(cbReadTotal <= sizeof(szReq)); + pszReq += cbRead; + + } while (cbToRead); + + if ( RT_SUCCESS(rc) + && cbReadTotal) + { + LogFlowFunc(("Received client request (%zu bytes)\n", cbReadTotal)); + + rtHttpServerLogProto(pClient, false /* fWrite */, szReq); + + rc = rtHttpServerProcessRequest(pClient, szReq, cbReadTotal); + } + else + break; + + } /* for */ + + if (RT_FAILURE(rc)) + { + switch (rc) + { + case VERR_NET_CONNECTION_RESET_BY_PEER: + { + LogFunc(("Client closed the connection\n")); + rc = VINF_SUCCESS; + break; + } + + default: + LogFunc(("Client processing failed with %Rrc\n", rc)); + break; + } + } + + LogFlowFuncLeaveRC(rc); + return rc; +} + +/** + * Per-client thread for serving the server's control connection. + * + * @returns VBox status code. + * @param hSocket Socket handle to use for the control connection. + * @param pvUser User-provided arguments. Of type PRTHTTPSERVERINTERNAL. + */ +static DECLCALLBACK(int) rtHttpServerClientThread(RTSOCKET hSocket, void *pvUser) +{ + PRTHTTPSERVERINTERNAL pThis = (PRTHTTPSERVERINTERNAL)pvUser; + RTHTTPSERVER_VALID_RETURN(pThis); + + LogFlowFuncEnter(); + + RTHTTPSERVERCLIENT Client; + RT_ZERO(Client); + + Client.pServer = pThis; + Client.hSocket = hSocket; + + return rtHttpServerClientMain(&Client); +} + +RTR3DECL(int) RTHttpServerCreate(PRTHTTPSERVER hHttpServer, const char *pszAddress, uint16_t uPort, + PRTHTTPSERVERCALLBACKS pCallbacks, void *pvUser, size_t cbUser) +{ + AssertPtrReturn(hHttpServer, VERR_INVALID_POINTER); + AssertPtrReturn(pszAddress, VERR_INVALID_POINTER); + AssertReturn (uPort, VERR_INVALID_PARAMETER); + AssertPtrReturn(pCallbacks, VERR_INVALID_POINTER); + /* pvUser is optional. */ + + int rc; + + PRTHTTPSERVERINTERNAL pThis = (PRTHTTPSERVERINTERNAL)RTMemAllocZ(sizeof(RTHTTPSERVERINTERNAL)); + if (pThis) + { + pThis->u32Magic = RTHTTPSERVER_MAGIC; + pThis->Callbacks = *pCallbacks; + pThis->pvUser = pvUser; + pThis->cbUser = cbUser; + + rc = RTTcpServerCreate(pszAddress, uPort, RTTHREADTYPE_DEFAULT, "httpsrv", + rtHttpServerClientThread, pThis /* pvUser */, &pThis->pTCPServer); + if (RT_SUCCESS(rc)) + { + *hHttpServer = (RTHTTPSERVER)pThis; + } + } + else + rc = VERR_NO_MEMORY; + + return rc; +} + +RTR3DECL(int) RTHttpServerDestroy(RTHTTPSERVER hHttpServer) +{ + if (hHttpServer == NIL_RTHTTPSERVER) + return VINF_SUCCESS; + + PRTHTTPSERVERINTERNAL pThis = hHttpServer; + RTHTTPSERVER_VALID_RETURN(pThis); + + AssertPtr(pThis->pTCPServer); + + int rc = VINF_SUCCESS; + + PRTHTTPSERVERCALLBACKS pCallbacks = &pThis->Callbacks; + if (pCallbacks->pfnDestroy) + { + RTHTTPCALLBACKDATA Data = { NULL /* pClient */, pThis->pvUser, pThis->cbUser }; + rc = pCallbacks->pfnDestroy(&Data); + } + + if (RT_SUCCESS(rc)) + { + rc = RTTcpServerDestroy(pThis->pTCPServer); + if (RT_SUCCESS(rc)) + { + pThis->u32Magic = RTHTTPSERVER_MAGIC_DEAD; + + RTMemFree(pThis); + } + } + + return rc; +} |