From aa2ee2526e05e685792f8903dc884a72edcdf8f0 Mon Sep 17 00:00:00 2001
From: Philip Rosedale <philip@highfidelity.io>
Date: Thu, 16 Jan 2014 11:51:46 -0800
Subject: [PATCH 01/18] name file correctly

---
 interface/src/VoxelSystem.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/interface/src/VoxelSystem.cpp b/interface/src/VoxelSystem.cpp
index ce4cb0bce4..a035455d5f 100644
--- a/interface/src/VoxelSystem.cpp
+++ b/interface/src/VoxelSystem.cpp
@@ -1,6 +1,5 @@
 //
-//  Cube.cpp
-//  interface
+//  VoxelSystem.cpp
 //
 //  Created by Philip on 12/31/12.
 //  Copyright (c) 2012 High Fidelity, Inc. All rights reserved.

From d236d6335de95abbcd8de9cd3e07faf50312889a Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Thu, 16 Jan 2014 17:05:02 -0800
Subject: [PATCH 02/18] add initial rev of embedded webserver based on
 QTcpSocket

---
 domain-server/CMakeLists.txt                  |   5 +
 domain-server/src/DomainServer.cpp            | 373 +++++++-------
 domain-server/src/DomainServer.h              |   8 +-
 libraries/embedded-webserver/CMakeLists.txt   |  16 +
 .../embedded-webserver/src/HttpConnection.cpp | 485 ++++++++++++++++++
 .../embedded-webserver/src/HttpConnection.h   | 261 ++++++++++
 .../embedded-webserver/src/HttpManager.cpp    |  62 +++
 .../embedded-webserver/src/HttpManager.h      |  83 +++
 8 files changed, 1099 insertions(+), 194 deletions(-)
 create mode 100644 libraries/embedded-webserver/CMakeLists.txt
 create mode 100755 libraries/embedded-webserver/src/HttpConnection.cpp
 create mode 100755 libraries/embedded-webserver/src/HttpConnection.h
 create mode 100755 libraries/embedded-webserver/src/HttpManager.cpp
 create mode 100755 libraries/embedded-webserver/src/HttpManager.h

diff --git a/domain-server/CMakeLists.txt b/domain-server/CMakeLists.txt
index e56d31bf5a..d9bd04e9b5 100644
--- a/domain-server/CMakeLists.txt
+++ b/domain-server/CMakeLists.txt
@@ -12,6 +12,8 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/../cmake
 include(${MACRO_DIR}/IncludeGLM.cmake)
 include_glm(${TARGET_NAME} ${ROOT_DIR})
 
+find_package(Qt5Network REQUIRED)
+
 include(${MACRO_DIR}/SetupHifiProject.cmake)
 
 # grab cJSON and civetweb sources to pass as OPTIONAL_SRCS
@@ -19,6 +21,8 @@ FILE(GLOB OPTIONAL_SRCS ${ROOT_DIR}/externals/civetweb/src/*)
 
 setup_hifi_project(${TARGET_NAME} TRUE ${OPTIONAL_SRCS})
 
+qt5_use_modules(${TARGET_NAME} Network)
+
 include_directories(SYSTEM ${ROOT_DIR}/externals/civetweb/include)
 
 # remove and then copy the files for the webserver
@@ -33,6 +37,7 @@ add_custom_command(TARGET ${TARGET_NAME} POST_BUILD
 # link the shared hifi library
 include(${MACRO_DIR}/LinkHifiLibrary.cmake)
 link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
+link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
 
 # link dl library on UNIX for civetweb
 if (UNIX AND NOT APPLE)
diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index 7cf3bdd056..26d0d5a33f 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -29,8 +29,11 @@ void signalhandler(int sig){
 
 DomainServer* DomainServer::domainServerInstance = NULL;
 
+const quint16 DOMAIN_SERVER_HTTP_PORT = 8080;
+
 DomainServer::DomainServer(int argc, char* argv[]) :
     QCoreApplication(argc, argv),
+    _httpManager(DOMAIN_SERVER_HTTP_PORT),
     _assignmentQueueMutex(),
     _assignmentQueue(),
     _staticAssignmentFile(QString("%1/config.ds").arg(QCoreApplication::applicationDirPath())),
@@ -58,23 +61,17 @@ DomainServer::DomainServer(int argc, char* argv[]) :
     const char METAVOXEL_CONFIG_OPTION[] = "--metavoxelServerConfig";
     _metavoxelServerConfig = getCmdOption(argc, (const char**)argv, METAVOXEL_CONFIG_OPTION);
 
-    // setup the mongoose web server
-    struct mg_callbacks callbacks = {};
-
-    QString documentRootString = QString("%1/resources/web").arg(QCoreApplication::applicationDirPath());
-
-    char* documentRoot = new char[documentRootString.size() + 1];
-    strcpy(documentRoot, documentRootString.toLocal8Bit().constData());
-
-    // list of options. Last element must be NULL.
-    const char* options[] = {"listening_ports", "8080",
-        "document_root", documentRoot, NULL};
-
-    callbacks.begin_request = civetwebRequestHandler;
-    callbacks.upload = civetwebUploadHandler;
-
-    // Start the web server.
-    mg_start(&callbacks, NULL, options);
+//    QString documentRootString = QString("%1/resources/web").arg(QCoreApplication::applicationDirPath());
+//
+//    char* documentRoot = new char[documentRootString.size() + 1];
+//    strcpy(documentRoot, documentRootString.toLocal8Bit().constData());
+//
+//    // list of options. Last element must be NULL.
+//    const char* options[] = {"listening_ports", "8080",
+//        "document_root", documentRoot, NULL};
+//
+//    callbacks.begin_request = civetwebRequestHandler;
+//    callbacks.upload = civetwebUploadHandler;
 
     connect(nodeList, SIGNAL(nodeKilled(SharedNodePointer)), this, SLOT(nodeKilled(SharedNodePointer)));
 
@@ -104,8 +101,6 @@ DomainServer::DomainServer(int argc, char* argv[]) :
     QTimer::singleShot(RESTART_HOLD_TIME_MSECS, this, SLOT(addStaticAssignmentsBackToQueueAfterRestart()));
 
     connect(this, SIGNAL(aboutToQuit()), SLOT(cleanup()));
-
-    delete[] documentRoot;
 }
 
 void DomainServer::readAvailableDatagrams() {
@@ -299,179 +294,179 @@ QJsonObject jsonObjectForNode(Node* node) {
     return nodeJson;
 }
 
-int DomainServer::civetwebRequestHandler(struct mg_connection *connection) {
-    const struct mg_request_info* ri = mg_get_request_info(connection);
-
-    const char RESPONSE_200[] = "HTTP/1.0 200 OK\r\n\r\n";
-    const char RESPONSE_400[] = "HTTP/1.0 400 Bad Request\r\n\r\n";
-
-    const char URI_ASSIGNMENT[] = "/assignment";
-    const char URI_NODE[] = "/node";
-
-    if (strcmp(ri->request_method, "GET") == 0) {
-        if (strcmp(ri->uri, "/assignments.json") == 0) {
-            // user is asking for json list of assignments
-
-            // start with a 200 response
-            mg_printf(connection, "%s", RESPONSE_200);
-
-            // setup the JSON
-            QJsonObject assignmentJSON;
-            QJsonObject assignedNodesJSON;
-
-            // enumerate the NodeList to find the assigned nodes
-            foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
-                if (node->getLinkedData()) {
-                    // add the node using the UUID as the key
-                    QString uuidString = uuidStringWithoutCurlyBraces(node->getUUID());
-                    assignedNodesJSON[uuidString] = jsonObjectForNode(node.data());
-                }
-            }
-
-            assignmentJSON["fulfilled"] = assignedNodesJSON;
-
-            QJsonObject queuedAssignmentsJSON;
-
-            // add the queued but unfilled assignments to the json
-            std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
-
-            while (assignment != domainServerInstance->_assignmentQueue.end()) {
-                QJsonObject queuedAssignmentJSON;
-
-                QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
-                queuedAssignmentJSON[JSON_KEY_TYPE] = QString((*assignment)->getTypeName());
-
-                // if the assignment has a pool, add it
-                if ((*assignment)->hasPool()) {
-                    queuedAssignmentJSON[JSON_KEY_POOL] = QString((*assignment)->getPool());
-                }
-
-                // add this queued assignment to the JSON
-                queuedAssignmentsJSON[uuidString] = queuedAssignmentJSON;
-
-                // push forward the iterator to check the next assignment
-                assignment++;
-            }
-
-            assignmentJSON["queued"] = queuedAssignmentsJSON;
-
-            // print out the created JSON
-            QJsonDocument assignmentDocument(assignmentJSON);
-            mg_printf(connection, "%s", assignmentDocument.toJson().constData());
-
-            // we've processed this request
-            return 1;
-        } else if (strcmp(ri->uri, "/nodes.json") == 0) {
-            // start with a 200 response
-            mg_printf(connection, "%s", RESPONSE_200);
-
-            // setup the JSON
-            QJsonObject rootJSON;
-            QJsonObject nodesJSON;
-
-            // enumerate the NodeList to find the assigned nodes
-            NodeList* nodeList = NodeList::getInstance();
-
-            foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
-                // add the node using the UUID as the key
-                QString uuidString = uuidStringWithoutCurlyBraces(node->getUUID());
-                nodesJSON[uuidString] = jsonObjectForNode(node.data());
-            }
-
-            rootJSON["nodes"] = nodesJSON;
-
-            // print out the created JSON
-            QJsonDocument nodesDocument(rootJSON);
-            mg_printf(connection, "%s", nodesDocument.toJson().constData());
-
-            // we've processed this request
-            return 1;
-        }
-
-        // not processed, pass to document root
-        return 0;
-    } else if (strcmp(ri->request_method, "POST") == 0) {
-        if (strcmp(ri->uri, URI_ASSIGNMENT) == 0) {
-            // return a 200
-            mg_printf(connection, "%s", RESPONSE_200);
-            // upload the file
-            mg_upload(connection, "/tmp");
-
-            return 1;
-        }
-
-        return 0;
-    } else if (strcmp(ri->request_method, "DELETE") == 0) {
-        // this is a DELETE request
-
-        // check if it is for an assignment
-        if (memcmp(ri->uri, URI_NODE, strlen(URI_NODE)) == 0) {
-            // pull the UUID from the url
-            QUuid deleteUUID = QUuid(QString(ri->uri + strlen(URI_NODE) + sizeof('/')));
-
-            if (!deleteUUID.isNull()) {
-                SharedNodePointer nodeToKill = NodeList::getInstance()->nodeWithUUID(deleteUUID);
-
-                if (nodeToKill) {
-                    // start with a 200 response
-                    mg_printf(connection, "%s", RESPONSE_200);
-
-                    // we have a valid UUID and node - kill the node that has this assignment
-                    QMetaObject::invokeMethod(NodeList::getInstance(), "killNodeWithUUID", Q_ARG(const QUuid&, deleteUUID));
-                    
-                    // successfully processed request
-                    return 1;
-                }
-            }
-        }
-
-        // request not processed - bad request
-        mg_printf(connection, "%s", RESPONSE_400);
-
-        // this was processed by civetweb
-        return 1;
-    } else {
-        // have mongoose process this request from the document_root
-        return 0;
-    }
-}
+//int DomainServer::civetwebRequestHandler(struct mg_connection *connection) {
+//    const struct mg_request_info* ri = mg_get_request_info(connection);
+//
+//    const char RESPONSE_200[] = "HTTP/1.0 200 OK\r\n\r\n";
+//    const char RESPONSE_400[] = "HTTP/1.0 400 Bad Request\r\n\r\n";
+//
+//    const char URI_ASSIGNMENT[] = "/assignment";
+//    const char URI_NODE[] = "/node";
+//
+//    if (strcmp(ri->request_method, "GET") == 0) {
+//        if (strcmp(ri->uri, "/assignments.json") == 0) {
+//            // user is asking for json list of assignments
+//
+//            // start with a 200 response
+//            mg_printf(connection, "%s", RESPONSE_200);
+//
+//            // setup the JSON
+//            QJsonObject assignmentJSON;
+//            QJsonObject assignedNodesJSON;
+//
+//            // enumerate the NodeList to find the assigned nodes
+//            foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+//                if (node->getLinkedData()) {
+//                    // add the node using the UUID as the key
+//                    QString uuidString = uuidStringWithoutCurlyBraces(node->getUUID());
+//                    assignedNodesJSON[uuidString] = jsonObjectForNode(node.data());
+//                }
+//            }
+//
+//            assignmentJSON["fulfilled"] = assignedNodesJSON;
+//
+//            QJsonObject queuedAssignmentsJSON;
+//
+//            // add the queued but unfilled assignments to the json
+//            std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
+//
+//            while (assignment != domainServerInstance->_assignmentQueue.end()) {
+//                QJsonObject queuedAssignmentJSON;
+//
+//                QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
+//                queuedAssignmentJSON[JSON_KEY_TYPE] = QString((*assignment)->getTypeName());
+//
+//                // if the assignment has a pool, add it
+//                if ((*assignment)->hasPool()) {
+//                    queuedAssignmentJSON[JSON_KEY_POOL] = QString((*assignment)->getPool());
+//                }
+//
+//                // add this queued assignment to the JSON
+//                queuedAssignmentsJSON[uuidString] = queuedAssignmentJSON;
+//
+//                // push forward the iterator to check the next assignment
+//                assignment++;
+//            }
+//
+//            assignmentJSON["queued"] = queuedAssignmentsJSON;
+//
+//            // print out the created JSON
+//            QJsonDocument assignmentDocument(assignmentJSON);
+//            mg_printf(connection, "%s", assignmentDocument.toJson().constData());
+//
+//            // we've processed this request
+//            return 1;
+//        } else if (strcmp(ri->uri, "/nodes.json") == 0) {
+//            // start with a 200 response
+//            mg_printf(connection, "%s", RESPONSE_200);
+//
+//            // setup the JSON
+//            QJsonObject rootJSON;
+//            QJsonObject nodesJSON;
+//
+//            // enumerate the NodeList to find the assigned nodes
+//            NodeList* nodeList = NodeList::getInstance();
+//
+//            foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+//                // add the node using the UUID as the key
+//                QString uuidString = uuidStringWithoutCurlyBraces(node->getUUID());
+//                nodesJSON[uuidString] = jsonObjectForNode(node.data());
+//            }
+//
+//            rootJSON["nodes"] = nodesJSON;
+//
+//            // print out the created JSON
+//            QJsonDocument nodesDocument(rootJSON);
+//            mg_printf(connection, "%s", nodesDocument.toJson().constData());
+//
+//            // we've processed this request
+//            return 1;
+//        }
+//
+//        // not processed, pass to document root
+//        return 0;
+//    } else if (strcmp(ri->request_method, "POST") == 0) {
+//        if (strcmp(ri->uri, URI_ASSIGNMENT) == 0) {
+//            // return a 200
+//            mg_printf(connection, "%s", RESPONSE_200);
+//            // upload the file
+//            mg_upload(connection, "/tmp");
+//
+//            return 1;
+//        }
+//
+//        return 0;
+//    } else if (strcmp(ri->request_method, "DELETE") == 0) {
+//        // this is a DELETE request
+//
+//        // check if it is for an assignment
+//        if (memcmp(ri->uri, URI_NODE, strlen(URI_NODE)) == 0) {
+//            // pull the UUID from the url
+//            QUuid deleteUUID = QUuid(QString(ri->uri + strlen(URI_NODE) + sizeof('/')));
+//
+//            if (!deleteUUID.isNull()) {
+//                SharedNodePointer nodeToKill = NodeList::getInstance()->nodeWithUUID(deleteUUID);
+//
+//                if (nodeToKill) {
+//                    // start with a 200 response
+//                    mg_printf(connection, "%s", RESPONSE_200);
+//
+//                    // we have a valid UUID and node - kill the node that has this assignment
+//                    QMetaObject::invokeMethod(NodeList::getInstance(), "killNodeWithUUID", Q_ARG(const QUuid&, deleteUUID));
+//                    
+//                    // successfully processed request
+//                    return 1;
+//                }
+//            }
+//        }
+//
+//        // request not processed - bad request
+//        mg_printf(connection, "%s", RESPONSE_400);
+//
+//        // this was processed by civetweb
+//        return 1;
+//    } else {
+//        // have mongoose process this request from the document_root
+//        return 0;
+//    }
+//}
 
 const char ASSIGNMENT_SCRIPT_HOST_LOCATION[] = "resources/web/assignment";
 
-void DomainServer::civetwebUploadHandler(struct mg_connection *connection, const char *path) {
-
-    // create an assignment for this saved script, for now make it local only
-    Assignment* scriptAssignment = new Assignment(Assignment::CreateCommand,
-                                                  Assignment::AgentType,
-                                                  NULL,
-                                                  Assignment::LocalLocation);
-
-    // check how many instances of this assignment the user wants by checking the ASSIGNMENT-INSTANCES header
-    const char ASSIGNMENT_INSTANCES_HTTP_HEADER[] = "ASSIGNMENT-INSTANCES";
-    const char* requestInstancesHeader = mg_get_header(connection, ASSIGNMENT_INSTANCES_HTTP_HEADER);
-
-    if (requestInstancesHeader) {
-        // the user has requested a number of instances greater than 1
-        // so set that on the created assignment
-        scriptAssignment->setNumberOfInstances(atoi(requestInstancesHeader));
-    }
-
-    QString newPath(ASSIGNMENT_SCRIPT_HOST_LOCATION);
-    newPath += "/";
-    // append the UUID for this script as the new filename, remove the curly braces
-    newPath += uuidStringWithoutCurlyBraces(scriptAssignment->getUUID());
-
-    // rename the saved script to the GUID of the assignment and move it to the script host locaiton
-    rename(path, newPath.toLocal8Bit().constData());
-
-    qDebug("Saved a script for assignment at %s", newPath.toLocal8Bit().constData());
-
-    // add the script assigment to the assignment queue
-    // lock the assignment queue mutex since we're operating on a different thread than DS main
-    domainServerInstance->_assignmentQueueMutex.lock();
-    domainServerInstance->_assignmentQueue.push_back(scriptAssignment);
-    domainServerInstance->_assignmentQueueMutex.unlock();
-}
+//void DomainServer::civetwebUploadHandler(struct mg_connection *connection, const char *path) {
+//
+//    // create an assignment for this saved script, for now make it local only
+//    Assignment* scriptAssignment = new Assignment(Assignment::CreateCommand,
+//                                                  Assignment::AgentType,
+//                                                  NULL,
+//                                                  Assignment::LocalLocation);
+//
+//    // check how many instances of this assignment the user wants by checking the ASSIGNMENT-INSTANCES header
+//    const char ASSIGNMENT_INSTANCES_HTTP_HEADER[] = "ASSIGNMENT-INSTANCES";
+//    const char* requestInstancesHeader = mg_get_header(connection, ASSIGNMENT_INSTANCES_HTTP_HEADER);
+//
+//    if (requestInstancesHeader) {
+//        // the user has requested a number of instances greater than 1
+//        // so set that on the created assignment
+//        scriptAssignment->setNumberOfInstances(atoi(requestInstancesHeader));
+//    }
+//
+//    QString newPath(ASSIGNMENT_SCRIPT_HOST_LOCATION);
+//    newPath += "/";
+//    // append the UUID for this script as the new filename, remove the curly braces
+//    newPath += uuidStringWithoutCurlyBraces(scriptAssignment->getUUID());
+//
+//    // rename the saved script to the GUID of the assignment and move it to the script host locaiton
+//    rename(path, newPath.toLocal8Bit().constData());
+//
+//    qDebug("Saved a script for assignment at %s", newPath.toLocal8Bit().constData());
+//
+//    // add the script assigment to the assignment queue
+//    // lock the assignment queue mutex since we're operating on a different thread than DS main
+//    domainServerInstance->_assignmentQueueMutex.lock();
+//    domainServerInstance->_assignmentQueue.push_back(scriptAssignment);
+//    domainServerInstance->_assignmentQueueMutex.unlock();
+//}
 
 void DomainServer::addReleasedAssignmentBackToQueue(Assignment* releasedAssignment) {
     qDebug() << "Adding assignment" << *releasedAssignment << " back to queue.";
diff --git a/domain-server/src/DomainServer.h b/domain-server/src/DomainServer.h
index 40cebdfa3f..56cb1225b8 100644
--- a/domain-server/src/DomainServer.h
+++ b/domain-server/src/DomainServer.h
@@ -16,10 +16,9 @@
 #include <QtCore/QMutex>
 
 #include <Assignment.h>
+#include <HttpManager.h>
 #include <NodeList.h>
 
-#include "civetweb.h"
-
 const int MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS = 1000;
 
 class DomainServer : public QCoreApplication {
@@ -36,9 +35,6 @@ public slots:
     void nodeKilled(SharedNodePointer node);
     
 private:    
-    static int civetwebRequestHandler(struct mg_connection *connection);
-    static void civetwebUploadHandler(struct mg_connection *connection, const char *path);
-    
     static DomainServer* domainServerInstance;
     
     void prepopulateStaticAssignmentFile();
@@ -52,6 +48,8 @@ private:
     
     unsigned char* addNodeToBroadcastPacket(unsigned char* currentPosition, Node* nodeToAdd);
     
+    HttpManager _httpManager;
+    
     QMutex _assignmentQueueMutex;
     std::deque<Assignment*> _assignmentQueue;
     
diff --git a/libraries/embedded-webserver/CMakeLists.txt b/libraries/embedded-webserver/CMakeLists.txt
new file mode 100644
index 0000000000..d826349cff
--- /dev/null
+++ b/libraries/embedded-webserver/CMakeLists.txt
@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 2.8)
+
+set(ROOT_DIR ../..)
+set(MACRO_DIR ${ROOT_DIR}/cmake/macros)
+
+# setup for find modules
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/../../cmake/modules/")
+
+set(TARGET_NAME embedded-webserver)
+
+find_package(Qt5Network REQUIRED)
+
+include(${MACRO_DIR}/SetupHifiLibrary.cmake)
+setup_hifi_library(${TARGET_NAME})
+
+qt5_use_modules(${TARGET_NAME} Network)
\ No newline at end of file
diff --git a/libraries/embedded-webserver/src/HttpConnection.cpp b/libraries/embedded-webserver/src/HttpConnection.cpp
new file mode 100755
index 0000000000..6bddf594be
--- /dev/null
+++ b/libraries/embedded-webserver/src/HttpConnection.cpp
@@ -0,0 +1,485 @@
+//
+//  HttpConnection.cpp
+//  hifi
+//
+//  Created by Stephen Birarda on 1/16/14.
+//  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+//  Heavily based on Andrzej Kapolka's original HttpConnection class
+//  found from another one of his projects.
+//  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
+//
+
+
+#include <QBuffer>
+#include <QCryptographicHash>
+#include <QTcpSocket>
+
+#include "HttpConnection.h"
+#include "HttpManager.h"
+
+HttpConnection::HttpConnection (QTcpSocket* socket, HttpManager* parentManager) :
+    QObject(parentManager),
+    _parentManager(parentManager),
+    _socket(socket),
+    _unmasker(new MaskFilter(socket, this)),
+    _stream(socket),
+    _address(socket->peerAddress()),
+    _webSocketPaused(false),
+    _closeSent(false)
+{
+    // take over ownership of the socket
+    _socket->setParent(this);
+
+    // connect initial slots
+    connect(socket, SIGNAL(readyRead()), SLOT(readRequest()));
+    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(deleteLater()));
+    connect(socket, SIGNAL(disconnected()), SLOT(deleteLater()));
+
+    // log the connection
+    qDebug() << "HTTP connection opened." << _address;
+}
+
+HttpConnection::~HttpConnection ()
+{
+    // log the destruction
+    QString error;
+    QDebug base = qDebug() << "HTTP connection closed." << _address;
+    if (_socket->error() != QAbstractSocket::UnknownSocketError) {
+        base << _socket->errorString();
+    }
+}
+
+bool HttpConnection::isWebSocketRequest ()
+{
+    return _requestHeaders.value("Upgrade") == "websocket";
+}
+
+QList<FormData> HttpConnection::parseFormData () const
+{
+    // make sure we have the correct MIME type
+    QList<QByteArray> elements = _requestHeaders.value("Content-Type").split(';');
+    if (elements.at(0).trimmed() != "multipart/form-data") {
+        return QList<FormData>();
+    }
+
+    // retrieve the boundary marker
+    QByteArray boundary;
+    for (int ii = 1, nn = elements.size(); ii < nn; ii++) {
+        QByteArray element = elements.at(ii).trimmed();
+        if (element.startsWith("boundary")) {
+            boundary = element.mid(element.indexOf('=') + 1).trimmed();
+            break;
+        }
+    }
+    QByteArray start = "--" + boundary;
+    QByteArray end = "\r\n--" + boundary + "--\r\n";
+
+    QList<FormData> data;
+    QBuffer buffer(const_cast<QByteArray*>(&_requestContent));
+    buffer.open(QIODevice::ReadOnly);
+    while (buffer.canReadLine()) {
+        QByteArray line = buffer.readLine().trimmed();
+        if (line == start) {
+            FormData datum;
+            while (buffer.canReadLine()) {
+                QByteArray line = buffer.readLine().trimmed();
+                if (line.isEmpty()) {
+                    // content starts after this line
+                    int idx = _requestContent.indexOf(end, buffer.pos());
+                    if (idx == -1) {
+                        qWarning() << "Missing end boundary." << _address;
+                        return data;
+                    }
+                    datum.second = _requestContent.mid(buffer.pos(), idx - buffer.pos());
+                    data.append(datum);
+                    buffer.seek(idx + end.length());
+
+                } else {
+                    // it's a header element
+                    int idx = line.indexOf(':');
+                    if (idx == -1) {
+                        qWarning() << "Invalid header line." << _address << line;
+                        continue;
+                    }
+                    datum.first.insert(line.left(idx).trimmed(), line.mid(idx + 1).trimmed());
+                }
+            }
+        }
+    }
+
+    return data;
+}
+
+void HttpConnection::respond (
+    const char* code, const QByteArray& content, const char* contentType, const Headers& headers)
+{
+    _socket->write("HTTP/1.1 ");
+    _socket->write(code);
+    _socket->write("\r\n");
+
+    int csize = content.size();
+
+    for (Headers::const_iterator it = headers.constBegin(), end = headers.constEnd();
+            it != end; it++) {
+        _socket->write(it.key());
+        _socket->write(": ");
+        _socket->write(it.value());
+        _socket->write("\r\n");
+    }
+    if (csize > 0) {
+        _socket->write("Content-Length: ");
+        _socket->write(QByteArray::number(csize));
+        _socket->write("\r\n");
+
+        _socket->write("Content-Type: ");
+        _socket->write(contentType);
+        _socket->write("\r\n");
+    }
+    _socket->write("Connection: close\r\n\r\n");
+
+    if (csize > 0) {
+        _socket->write(content);
+    }
+
+    // make sure we receive no further read notifications
+    _socket->disconnect(SIGNAL(readyRead()), this);
+
+    _socket->disconnectFromHost();
+}
+
+void HttpConnection::switchToWebSocket (const char* protocol)
+{
+    _socket->write("HTTP/1.1 101 Switching Protocols\r\n");
+    _socket->write("Upgrade: websocket\r\n");
+    _socket->write("Connection: Upgrade\r\n");
+    _socket->write("Sec-WebSocket-Accept: ");
+
+    QCryptographicHash hash(QCryptographicHash::Sha1);
+    hash.addData(_requestHeaders.value("Sec-WebSocket-Key"));
+    hash.addData("258EAFA5-E914-47DA-95CA-C5AB0DC85B11"); // from WebSocket draft RFC
+    _socket->write(hash.result().toBase64());
+
+    if (protocol != 0) {
+        _socket->write("\r\nSec-WebSocket-Protocol: ");
+        _socket->write(protocol);
+    }
+    _socket->write("\r\n\r\n");
+
+    // connect socket, start reading frames
+    setWebSocketPaused(false);
+}
+
+void HttpConnection::setWebSocketPaused (bool paused)
+{
+    if ((_webSocketPaused = paused)) {
+        _socket->disconnect(this, SLOT(readFrames()));
+
+    } else {
+        connect(_socket, SIGNAL(readyRead()), SLOT(readFrames()));
+        readFrames();
+    }
+}
+
+void HttpConnection::closeWebSocket (quint16 reasonCode, const char* reason)
+{
+    if (reasonCode == NoReason) {
+        writeFrameHeader(ConnectionClose);
+
+    } else {
+        int rlen = (reason == 0) ? 0 : qstrlen(reason);
+        writeFrameHeader(ConnectionClose, 2 + rlen);
+        _stream << reasonCode;
+        if (rlen > 0) {
+            _socket->write(reason);
+        }
+    }
+    _closeSent = true;
+}
+
+void HttpConnection::readRequest ()
+{
+    if (!_socket->canReadLine()) {
+        return;
+    }
+    // parse out the method and resource
+    QByteArray line = _socket->readLine().trimmed();
+    if (line.startsWith("HEAD")) {
+        _requestOperation = QNetworkAccessManager::HeadOperation;
+
+    } else if (line.startsWith("GET")) {
+        _requestOperation = QNetworkAccessManager::GetOperation;
+
+    } else if (line.startsWith("PUT")) {
+        _requestOperation = QNetworkAccessManager::PutOperation;
+
+    } else if (line.startsWith("POST")) {
+        _requestOperation = QNetworkAccessManager::PostOperation;
+
+    } else if (line.startsWith("DELETE")) {
+        _requestOperation = QNetworkAccessManager::DeleteOperation;
+
+    } else {
+        qWarning() << "Unrecognized HTTP operation." << _address << line;
+        respond("400 Bad Request", "Unrecognized operation.");
+        return;
+    }
+    int idx = line.indexOf(' ') + 1;
+    _requestUrl.setUrl(line.mid(idx, line.lastIndexOf(' ') - idx));
+
+    // switch to reading the header
+    _socket->disconnect(this, SLOT(readRequest()));
+    connect(_socket, SIGNAL(readyRead()), SLOT(readHeaders()));
+
+    // read any headers immediately available
+    readHeaders();
+}
+
+void HttpConnection::readHeaders ()
+{
+    while (_socket->canReadLine()) {
+        QByteArray line = _socket->readLine();
+        QByteArray trimmed = line.trimmed();
+        if (trimmed.isEmpty()) {
+            _socket->disconnect(this, SLOT(readHeaders()));
+
+            QByteArray clength = _requestHeaders.value("Content-Length");
+            if (clength.isEmpty()) {
+                _parentManager->handleRequest(this, "", _requestUrl.path());
+
+            } else {
+                _requestContent.resize(clength.toInt());
+                connect(_socket, SIGNAL(readyRead()), SLOT(readContent()));
+
+                // read any content immediately available
+                readContent();
+            }
+            return;
+        }
+        char first = line.at(0);
+        if (first == ' ' || first == '\t') { // continuation
+            _requestHeaders[_lastRequestHeader].append(trimmed);
+            continue;
+        }
+        int idx = trimmed.indexOf(':');
+        if (idx == -1) {
+            qWarning() << "Invalid header." << _address << trimmed;
+            respond("400 Bad Request", "The header was malformed.");
+            return;
+        }
+        _lastRequestHeader = trimmed.left(idx);
+        QByteArray& value = _requestHeaders[_lastRequestHeader];
+        if (!value.isEmpty()) {
+            value.append(", ");
+        }
+        value.append(trimmed.mid(idx + 1).trimmed());
+    }
+}
+
+void HttpConnection::readContent ()
+{
+    int size = _requestContent.size();
+    if (_socket->bytesAvailable() < size) {
+        return;
+    }
+    _socket->read(_requestContent.data(), size);
+    _socket->disconnect(this, SLOT(readContent()));
+
+    _parentManager->handleRequest(this, "", _requestUrl.path());
+}
+
+void HttpConnection::readFrames()
+{
+    // read as many messages as are available
+    while (maybeReadFrame());
+}
+
+void unget (QIODevice* device, quint32 value) {
+    device->ungetChar(value & 0xFF);
+    device->ungetChar((value >> 8) & 0xFF);
+    device->ungetChar((value >> 16) & 0xFF);
+    device->ungetChar(value >> 24);
+}
+
+bool HttpConnection::maybeReadFrame ()
+{
+    // make sure we have at least the first two bytes
+    qint64 available = _socket->bytesAvailable();
+    if (available < 2 || _webSocketPaused) {
+        return false;
+    }
+    // read the first two, which tell us whether we need more for the length
+    quint8 finalOpcode, maskLength;
+    _stream >> finalOpcode;
+    _stream >> maskLength;
+    available -= 2;
+
+    int byteLength = maskLength & 0x7F;
+    bool masked = (maskLength & 0x80) != 0;
+    int baseLength = (masked ? 4 : 0);
+    int length = -1;
+    if (byteLength == 127) {
+        if (available >= 8) {
+            quint64 longLength;
+            _stream >> longLength;
+            if (available >= baseLength + 8 + longLength) {
+                length = longLength;
+            } else {
+                unget(_socket, longLength & 0xFFFFFFFF);
+                unget(_socket, longLength >> 32);
+            }
+        }
+    } else if (byteLength == 126) {
+        if (available >= 2) {
+            quint16 shortLength;
+            _stream >> shortLength;
+            if (available >= baseLength + 2 + shortLength) {
+                length = shortLength;
+            } else {
+                _socket->ungetChar(shortLength & 0xFF);
+                _socket->ungetChar(shortLength >> 8);
+            }
+        }
+    } else if (available >= baseLength + byteLength) {
+        length = byteLength;
+    }
+    if (length == -1) {
+        _socket->ungetChar(maskLength);
+        _socket->ungetChar(finalOpcode);
+        return false;
+    }
+
+    // read the mask and set it in the filter
+    quint32 mask = 0;
+    if (masked) {
+        _stream >> mask;
+    }
+    _unmasker->setMask(mask);
+
+    // if not final, add to continuing message
+    FrameOpcode opcode = (FrameOpcode)(finalOpcode & 0x0F);
+    if ((finalOpcode & 0x80) == 0) {
+        if (opcode != ContinuationFrame) {
+            _continuingOpcode = opcode;
+        }
+        _continuingMessage += _unmasker->read(length);
+        return true;
+    }
+
+    // if continuing, add to and read from buffer
+    QIODevice* device = _unmasker;
+    FrameOpcode copcode = opcode;
+    if (opcode == ContinuationFrame) {
+        _continuingMessage += _unmasker->read(length);
+        device = new QBuffer(&_continuingMessage, this);
+        device->open(QIODevice::ReadOnly);
+        copcode = _continuingOpcode;
+    }
+
+    // act according to opcode
+    switch (copcode) {
+        case TextFrame:
+            emit webSocketMessageAvailable(device, length, true);
+            break;
+
+        case BinaryFrame:
+            emit webSocketMessageAvailable(device, length, false);
+            break;
+
+        case ConnectionClose:
+            // if this is not a response to our own close request, send a close reply
+            if (!_closeSent) {
+                closeWebSocket(GoingAway);
+            }
+            if (length >= 2) {
+                QDataStream stream(device);
+                quint16 reasonCode;
+                stream >> reasonCode;
+                emit webSocketClosed(reasonCode, device->read(length - 2));
+            } else {
+                emit webSocketClosed(0, QByteArray());
+            }
+            _socket->disconnectFromHost();
+            break;
+
+        case Ping:
+            // send the pong out immediately
+            writeFrameHeader(Pong, length, true);
+            _socket->write(device->read(length));
+            break;
+
+        case Pong:
+            qWarning() << "Got unsolicited WebSocket pong." << _address << device->read(length);
+            break;
+
+        default:
+            qWarning() << "Received unknown WebSocket opcode." << _address << opcode <<
+                device->read(length);
+            break;
+    }
+
+    // clear the continuing message buffer
+    if (opcode == ContinuationFrame) {
+        _continuingMessage.clear();
+        delete device;
+    }
+
+    return true;
+}
+
+void HttpConnection::writeFrameHeader (FrameOpcode opcode, int size, bool final)
+{
+    if (_closeSent) {
+        qWarning() << "Writing frame header after close message." << _address << opcode;
+        return;
+    }
+    _socket->putChar((final ? 0x80 : 0x0) | opcode);
+    if (size < 126) {
+        _socket->putChar(size);
+
+    } else if (size < 65536) {
+        _socket->putChar(126);
+        _stream << (quint16)size;
+
+    } else {
+        _socket->putChar(127);
+        _stream << (quint64)size;
+    }
+}
+
+MaskFilter::MaskFilter (QIODevice* device, QObject* parent) :
+    QIODevice(parent),
+    _device(device)
+{
+    open(ReadOnly);
+}
+
+void MaskFilter::setMask (quint32 mask)
+{
+    _mask[0] = (mask >> 24);
+    _mask[1] = (mask >> 16) & 0xFF;
+    _mask[2] = (mask >> 8) & 0xFF;
+    _mask[3] = mask & 0xFF;
+    _position = 0;
+    reset();
+}
+
+qint64 MaskFilter::bytesAvailable () const
+{
+    return _device->bytesAvailable() + QIODevice::bytesAvailable();
+}
+
+qint64 MaskFilter::readData (char* data, qint64 maxSize)
+{
+    qint64 bytes = _device->read(data, maxSize);
+    for (char* end = data + bytes; data < end; data++) {
+        *data ^= _mask[_position];
+        _position = (_position + 1) % 4;
+    }
+    return bytes;
+}
+
+qint64 MaskFilter::writeData (const char* data, qint64 maxSize)
+{
+    return _device->write(data, maxSize);
+}
diff --git a/libraries/embedded-webserver/src/HttpConnection.h b/libraries/embedded-webserver/src/HttpConnection.h
new file mode 100755
index 0000000000..346b436a8d
--- /dev/null
+++ b/libraries/embedded-webserver/src/HttpConnection.h
@@ -0,0 +1,261 @@
+//
+//  HttpConnection.h
+//  hifi
+//
+//  Created by Stephen Birarda on 1/16/14.
+//  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+//  Heavily based on Andrzej Kapolka's original HttpConnection class
+//  found from another one of his projects.
+//  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
+//
+
+#ifndef HTTP_CONNECTION
+#define HTTP_CONNECTION
+
+#include <QHash>
+#include <QHostAddress>
+#include <QIODevice>
+#include <QList>
+#include <QNetworkAccessManager>
+#include <QObject>
+#include <QPair>
+#include <QUrl>
+
+class QTcpSocket;
+class HttpManager;
+class MaskFilter;
+class ServerApp;
+
+/** Header hash. */
+typedef QHash<QByteArray, QByteArray> Headers;
+
+/** A form data element. */
+typedef QPair<Headers, QByteArray> FormData;
+
+/**
+ * Handles a single HTTP connection.
+ */
+class HttpConnection : public QObject
+{
+   Q_OBJECT
+
+public:
+
+    /** WebSocket close status codes. */
+    enum ReasonCode { NoReason = 0, NormalClosure = 1000, GoingAway = 1001 };
+
+    /**
+     * Initializes the connection.
+     */
+    HttpConnection (QTcpSocket* socket, HttpManager* parentManager);
+
+    /**
+     * Destroys the connection.
+     */
+    virtual ~HttpConnection ();
+
+    /**
+     * Returns a pointer to the underlying socket, to which WebSocket message bodies should be
+     * written.
+     */
+    QTcpSocket* socket () const { return _socket; }
+
+    /**
+     * Returns the request operation.
+     */
+    QNetworkAccessManager::Operation requestOperation () const { return _requestOperation; }
+
+    /**
+     * Returns a reference to the request URL.
+     */
+    const QUrl& requestUrl () const { return _requestUrl; }
+
+    /**
+     * Returns a reference to the request headers.
+     */
+    const Headers& requestHeaders () const { return _requestHeaders; }
+
+    /**
+     * Returns a reference to the request content.
+     */
+    const QByteArray& requestContent () const { return _requestContent; }
+
+    /**
+     * Checks whether the request is asking to switch to a WebSocket.
+     */
+    bool isWebSocketRequest ();
+
+    /**
+     * Parses the request content as form data, returning a list of header/content pairs.
+     */
+    QList<FormData> parseFormData () const;
+
+    /**
+     * Sends a response and closes the connection.
+     */
+    void respond (const char* code, const QByteArray& content = QByteArray(),
+        const char* contentType = "text/plain; charset=ISO-8859-1",
+        const Headers& headers = Headers());
+
+    /**
+     * Switches to a WebSocket.
+     */
+    void switchToWebSocket (const char* protocol = 0);
+
+    /**
+     * Writes a header for a WebSocket message of the specified size.  The body of the message
+     * should be written through the socket.
+     */
+    void writeWebSocketHeader (int size) { writeFrameHeader(BinaryFrame, size); }
+
+    /**
+     * Pauses or unpauses the WebSocket.  A paused WebSocket buffers messages until unpaused.
+     */
+    void setWebSocketPaused (bool paused);
+
+    /**
+     * Closes the WebSocket.
+     */
+    void closeWebSocket (quint16 reasonCode = NormalClosure, const char* reason = 0);
+
+signals:
+
+    /**
+     * Fired when a WebSocket message of the specified size is available to read.
+     */
+    void webSocketMessageAvailable (QIODevice* device, int length, bool text);
+
+    /**
+     * Fired when the WebSocket has been closed by the other side.
+     */
+    void webSocketClosed (quint16 reasonCode, QByteArray reason);
+
+protected slots:
+
+    /**
+     * Reads the request line.
+     */
+    void readRequest ();
+
+    /**
+     * Reads the headers.
+     */
+    void readHeaders ();
+
+    /**
+     * Reads the content.
+     */
+    void readContent ();
+
+    /**
+     * Reads any incoming WebSocket frames.
+     */
+    void readFrames ();
+
+protected:
+
+    /** The available WebSocket frame opcodes. */
+    enum FrameOpcode { ContinuationFrame, TextFrame, BinaryFrame,
+        ConnectionClose = 0x08, Ping, Pong };
+
+    /**
+     * Attempts to read a single WebSocket frame, returning true if successful.
+     */
+    bool maybeReadFrame ();
+
+    /**
+     * Writes a WebSocket frame header.
+     */
+    void writeFrameHeader (FrameOpcode opcode, int size = 0, bool final = true);
+
+    /** The parent HTTP manager. */
+    HttpManager* _parentManager;
+
+    /** The underlying socket. */
+    QTcpSocket* _socket;
+
+    /** The mask filter for WebSocket frames. */
+    MaskFilter* _unmasker;
+
+    /** The data stream for writing to the socket. */
+    QDataStream _stream;
+
+    /** The stored address. */
+    QHostAddress _address;
+
+    /** The requested operation. */
+    QNetworkAccessManager::Operation _requestOperation;
+
+    /** The requested URL. */
+    QUrl _requestUrl;
+
+    /** The request headers. */
+    Headers _requestHeaders;
+
+    /** The last request header processed (used for continuations). */
+    QByteArray _lastRequestHeader;
+
+    /** The content of the request. */
+    QByteArray _requestContent;
+
+    /** The opcode for the WebSocket message being continued. */
+    FrameOpcode _continuingOpcode;
+
+    /** The WebSocket message being continued. */
+    QByteArray _continuingMessage;
+
+    /** Whether or not the WebSocket is paused (buffering messages for future processing). */
+    bool _webSocketPaused;
+
+    /** Whether or not we've sent a WebSocket close message. */
+    bool _closeSent;
+};
+
+/**
+ * A filter device that applies a 32-bit mask.
+ */
+class MaskFilter : public QIODevice
+{
+    Q_OBJECT
+
+public:
+
+    /**
+     * Creates a new masker to filter the supplied device.
+     */
+    MaskFilter (QIODevice* device, QObject* parent = 0);
+
+    /**
+     * Sets the mask to apply.
+     */
+    void setMask (quint32 mask);
+
+    /**
+     * Returns the number of bytes available to read.
+     */
+    virtual qint64 bytesAvailable () const;
+
+protected:
+
+    /**
+     * Reads masked data from the underlying device.
+     */
+    virtual qint64 readData (char* data, qint64 maxSize);
+
+    /**
+     * Writes masked data to the underlying device.
+     */
+    virtual qint64 writeData (const char* data, qint64 maxSize);
+
+    /** The underlying device. */
+    QIODevice* _device;
+
+    /** The current mask. */
+    char _mask[4];
+
+    /** The current position within the mask. */
+    int _position;
+};
+
+#endif // HTTP_CONNECTION
diff --git a/libraries/embedded-webserver/src/HttpManager.cpp b/libraries/embedded-webserver/src/HttpManager.cpp
new file mode 100755
index 0000000000..140529e74a
--- /dev/null
+++ b/libraries/embedded-webserver/src/HttpManager.cpp
@@ -0,0 +1,62 @@
+//
+//  HttpManager.cpp
+//  hifi
+//
+//  Created by Stephen Birarda on 1/16/14.
+//  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+//  Heavily based on Andrzej Kapolka's original HttpManager class
+//  found from another one of his projects.
+//  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
+//
+
+#include <QTcpSocket>
+#include <QtDebug>
+
+#include "HttpConnection.h"
+#include "HttpManager.h"
+
+void HttpSubrequestHandler::registerSubhandler (const QString& name, HttpRequestHandler* handler) {
+    _subhandlers.insert(name, handler);
+}
+
+bool HttpSubrequestHandler::handleRequest (
+    HttpConnection* connection, const QString& name, const QString& path) {
+    QString subpath = path;
+    if (subpath.startsWith('/')) {
+        subpath.remove(0, 1);
+    }
+    QString subname;
+    int idx = subpath.indexOf('/');
+    if (idx == -1) {
+        subname = subpath;
+        subpath = "";
+    } else {
+        subname = subpath.left(idx);
+        subpath = subpath.mid(idx + 1);
+    }
+    HttpRequestHandler* handler = _subhandlers.value(subname);
+    if (handler == 0 || !handler->handleRequest(connection, subname, subpath)) {
+        connection->respond("404 Not Found", "Resource not found.");
+    }
+    return true;
+}
+
+HttpManager::HttpManager(quint16 port, QObject* parent) :
+    QTcpServer(parent) {
+    // start listening on the passed port
+    if (!listen(QHostAddress("0.0.0.0"), port)) {
+        qDebug() << "Failed to open HTTP server socket:" << errorString();
+        return;
+    }
+    
+    // connect the connection signal
+    connect(this, SIGNAL(newConnection()), SLOT(acceptConnections()));
+}
+
+void HttpManager::acceptConnections () {
+    QTcpSocket* socket;
+    while ((socket = nextPendingConnection()) != 0) {
+        new HttpConnection(socket, this);
+    }
+}
diff --git a/libraries/embedded-webserver/src/HttpManager.h b/libraries/embedded-webserver/src/HttpManager.h
new file mode 100755
index 0000000000..8751169271
--- /dev/null
+++ b/libraries/embedded-webserver/src/HttpManager.h
@@ -0,0 +1,83 @@
+//
+//  HttpManager.h
+//  hifi
+//
+//  Created by Stephen Birarda on 1/16/14.
+//  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+//  Heavily based on Andrzej Kapolka's original HttpManager class
+//  found from another one of his projects.
+//  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
+//
+
+#ifndef HTTP_MANAGER
+#define HTTP_MANAGER
+
+#include <QByteArray>
+#include <QHash>
+#include <QtNetwork/QTcpServer>
+
+class HttpConnection;
+class HttpRequestHandler;
+
+/**
+ * Interface for HTTP request handlers.
+ */
+class HttpRequestHandler
+{
+public:
+
+    /**
+     * Handles an HTTP request.
+     */
+    virtual bool handleRequest (
+        HttpConnection* connection, const QString& name, const QString& path) = 0;
+};
+
+/**
+ * Handles requests by forwarding them to subhandlers.
+ */
+class HttpSubrequestHandler : public HttpRequestHandler
+{
+public:
+
+    /**
+     * Registers a subhandler with the given name.
+     */
+    void registerSubhandler (const QString& name, HttpRequestHandler* handler);
+
+    /**
+     * Handles an HTTP request.
+     */
+    virtual bool handleRequest (
+        HttpConnection* connection, const QString& name, const QString& path);
+
+protected:
+
+    /** Subhandlers mapped by name. */
+    QHash<QString, HttpRequestHandler*> _subhandlers;
+};
+
+/**
+ * Handles HTTP connections.
+ */
+class HttpManager : public QTcpServer, public HttpSubrequestHandler
+{
+   Q_OBJECT
+
+public:
+
+    /**
+     * Initializes the manager.
+     */
+    HttpManager(quint16 port, QObject* parent = 0);
+
+protected slots:
+
+    /**
+     * Accepts all pending connections.
+     */
+    void acceptConnections ();
+};
+
+#endif // HTTP_MANAGER

From c5e10465c4e4768fc459be25601a21bf6cbf44ac Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Thu, 16 Jan 2014 17:08:06 -0800
Subject: [PATCH 03/18] don't include civetweb in DomainServer

---
 domain-server/CMakeLists.txt | 18 ++----------------
 1 file changed, 2 insertions(+), 16 deletions(-)

diff --git a/domain-server/CMakeLists.txt b/domain-server/CMakeLists.txt
index d9bd04e9b5..213b37ac16 100644
--- a/domain-server/CMakeLists.txt
+++ b/domain-server/CMakeLists.txt
@@ -16,15 +16,10 @@ find_package(Qt5Network REQUIRED)
 
 include(${MACRO_DIR}/SetupHifiProject.cmake)
 
-# grab cJSON and civetweb sources to pass as OPTIONAL_SRCS
-FILE(GLOB OPTIONAL_SRCS ${ROOT_DIR}/externals/civetweb/src/*)
-
-setup_hifi_project(${TARGET_NAME} TRUE ${OPTIONAL_SRCS})
+setup_hifi_project(${TARGET_NAME} TRUE)
 
 qt5_use_modules(${TARGET_NAME} Network)
 
-include_directories(SYSTEM ${ROOT_DIR}/externals/civetweb/include)
-
 # remove and then copy the files for the webserver
 add_custom_command(TARGET ${TARGET_NAME} POST_BUILD
                    COMMAND ${CMAKE_COMMAND} -E remove_directory
@@ -37,13 +32,4 @@ add_custom_command(TARGET ${TARGET_NAME} POST_BUILD
 # link the shared hifi library
 include(${MACRO_DIR}/LinkHifiLibrary.cmake)
 link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
-link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
-
-# link dl library on UNIX for civetweb
-if (UNIX AND NOT APPLE)
-  target_link_libraries(${TARGET_NAME} ${CMAKE_DL_LIBS})
-endif (UNIX AND NOT APPLE)
-
-IF (WIN32)
-	target_link_libraries(${TARGET_NAME} Winmm)
-ENDIF(WIN32)
+link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
\ No newline at end of file

From 036dba9c2f8702cfc6678d979013b6cdf727e6e3 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 08:53:55 -0800
Subject: [PATCH 04/18] setup the HTTPManager to serve files in the document
 root

---
 domain-server/src/DomainServer.cpp            |   5 +-
 .../embedded-webserver/src/HttpConnection.cpp | 267 +-----------------
 .../embedded-webserver/src/HttpConnection.h   | 109 +------
 .../embedded-webserver/src/HttpManager.cpp    |  67 +++--
 .../embedded-webserver/src/HttpManager.h      |  50 +---
 5 files changed, 62 insertions(+), 436 deletions(-)

diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index 26d0d5a33f..eb5801197a 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -33,7 +33,7 @@ const quint16 DOMAIN_SERVER_HTTP_PORT = 8080;
 
 DomainServer::DomainServer(int argc, char* argv[]) :
     QCoreApplication(argc, argv),
-    _httpManager(DOMAIN_SERVER_HTTP_PORT),
+    _httpManager(DOMAIN_SERVER_HTTP_PORT, QString("%1/resources/web/").arg(QCoreApplication::applicationDirPath())),
     _assignmentQueueMutex(),
     _assignmentQueue(),
     _staticAssignmentFile(QString("%1/config.ds").arg(QCoreApplication::applicationDirPath())),
@@ -60,8 +60,7 @@ DomainServer::DomainServer(int argc, char* argv[]) :
 
     const char METAVOXEL_CONFIG_OPTION[] = "--metavoxelServerConfig";
     _metavoxelServerConfig = getCmdOption(argc, (const char**)argv, METAVOXEL_CONFIG_OPTION);
-
-//    QString documentRootString = QString("%1/resources/web").arg(QCoreApplication::applicationDirPath());
+    
 //
 //    char* documentRoot = new char[documentRootString.size() + 1];
 //    strcpy(documentRoot, documentRootString.toLocal8Bit().constData());
diff --git a/libraries/embedded-webserver/src/HttpConnection.cpp b/libraries/embedded-webserver/src/HttpConnection.cpp
index 6bddf594be..7923e8ec40 100755
--- a/libraries/embedded-webserver/src/HttpConnection.cpp
+++ b/libraries/embedded-webserver/src/HttpConnection.cpp
@@ -22,11 +22,8 @@ HttpConnection::HttpConnection (QTcpSocket* socket, HttpManager* parentManager)
     QObject(parentManager),
     _parentManager(parentManager),
     _socket(socket),
-    _unmasker(new MaskFilter(socket, this)),
     _stream(socket),
-    _address(socket->peerAddress()),
-    _webSocketPaused(false),
-    _closeSent(false)
+    _address(socket->peerAddress())
 {
     // take over ownership of the socket
     _socket->setParent(this);
@@ -50,11 +47,6 @@ HttpConnection::~HttpConnection ()
     }
 }
 
-bool HttpConnection::isWebSocketRequest ()
-{
-    return _requestHeaders.value("Upgrade") == "websocket";
-}
-
 QList<FormData> HttpConnection::parseFormData () const
 {
     // make sure we have the correct MIME type
@@ -111,9 +103,7 @@ QList<FormData> HttpConnection::parseFormData () const
     return data;
 }
 
-void HttpConnection::respond (
-    const char* code, const QByteArray& content, const char* contentType, const Headers& headers)
-{
+void HttpConnection::respond (const char* code, const QByteArray& content, const char* contentType, const Headers& headers) {
     _socket->write("HTTP/1.1 ");
     _socket->write(code);
     _socket->write("\r\n");
@@ -139,6 +129,7 @@ void HttpConnection::respond (
     _socket->write("Connection: close\r\n\r\n");
 
     if (csize > 0) {
+        qDebug() << "Writing" << QString(content) << "\n";
         _socket->write(content);
     }
 
@@ -148,55 +139,6 @@ void HttpConnection::respond (
     _socket->disconnectFromHost();
 }
 
-void HttpConnection::switchToWebSocket (const char* protocol)
-{
-    _socket->write("HTTP/1.1 101 Switching Protocols\r\n");
-    _socket->write("Upgrade: websocket\r\n");
-    _socket->write("Connection: Upgrade\r\n");
-    _socket->write("Sec-WebSocket-Accept: ");
-
-    QCryptographicHash hash(QCryptographicHash::Sha1);
-    hash.addData(_requestHeaders.value("Sec-WebSocket-Key"));
-    hash.addData("258EAFA5-E914-47DA-95CA-C5AB0DC85B11"); // from WebSocket draft RFC
-    _socket->write(hash.result().toBase64());
-
-    if (protocol != 0) {
-        _socket->write("\r\nSec-WebSocket-Protocol: ");
-        _socket->write(protocol);
-    }
-    _socket->write("\r\n\r\n");
-
-    // connect socket, start reading frames
-    setWebSocketPaused(false);
-}
-
-void HttpConnection::setWebSocketPaused (bool paused)
-{
-    if ((_webSocketPaused = paused)) {
-        _socket->disconnect(this, SLOT(readFrames()));
-
-    } else {
-        connect(_socket, SIGNAL(readyRead()), SLOT(readFrames()));
-        readFrames();
-    }
-}
-
-void HttpConnection::closeWebSocket (quint16 reasonCode, const char* reason)
-{
-    if (reasonCode == NoReason) {
-        writeFrameHeader(ConnectionClose);
-
-    } else {
-        int rlen = (reason == 0) ? 0 : qstrlen(reason);
-        writeFrameHeader(ConnectionClose, 2 + rlen);
-        _stream << reasonCode;
-        if (rlen > 0) {
-            _socket->write(reason);
-        }
-    }
-    _closeSent = true;
-}
-
 void HttpConnection::readRequest ()
 {
     if (!_socket->canReadLine()) {
@@ -245,7 +187,7 @@ void HttpConnection::readHeaders ()
 
             QByteArray clength = _requestHeaders.value("Content-Length");
             if (clength.isEmpty()) {
-                _parentManager->handleRequest(this, "", _requestUrl.path());
+                _parentManager->handleRequest(this, _requestUrl.path());
 
             } else {
                 _requestContent.resize(clength.toInt());
@@ -276,8 +218,7 @@ void HttpConnection::readHeaders ()
     }
 }
 
-void HttpConnection::readContent ()
-{
+void HttpConnection::readContent() {
     int size = _requestContent.size();
     if (_socket->bytesAvailable() < size) {
         return;
@@ -285,201 +226,5 @@ void HttpConnection::readContent ()
     _socket->read(_requestContent.data(), size);
     _socket->disconnect(this, SLOT(readContent()));
 
-    _parentManager->handleRequest(this, "", _requestUrl.path());
-}
-
-void HttpConnection::readFrames()
-{
-    // read as many messages as are available
-    while (maybeReadFrame());
-}
-
-void unget (QIODevice* device, quint32 value) {
-    device->ungetChar(value & 0xFF);
-    device->ungetChar((value >> 8) & 0xFF);
-    device->ungetChar((value >> 16) & 0xFF);
-    device->ungetChar(value >> 24);
-}
-
-bool HttpConnection::maybeReadFrame ()
-{
-    // make sure we have at least the first two bytes
-    qint64 available = _socket->bytesAvailable();
-    if (available < 2 || _webSocketPaused) {
-        return false;
-    }
-    // read the first two, which tell us whether we need more for the length
-    quint8 finalOpcode, maskLength;
-    _stream >> finalOpcode;
-    _stream >> maskLength;
-    available -= 2;
-
-    int byteLength = maskLength & 0x7F;
-    bool masked = (maskLength & 0x80) != 0;
-    int baseLength = (masked ? 4 : 0);
-    int length = -1;
-    if (byteLength == 127) {
-        if (available >= 8) {
-            quint64 longLength;
-            _stream >> longLength;
-            if (available >= baseLength + 8 + longLength) {
-                length = longLength;
-            } else {
-                unget(_socket, longLength & 0xFFFFFFFF);
-                unget(_socket, longLength >> 32);
-            }
-        }
-    } else if (byteLength == 126) {
-        if (available >= 2) {
-            quint16 shortLength;
-            _stream >> shortLength;
-            if (available >= baseLength + 2 + shortLength) {
-                length = shortLength;
-            } else {
-                _socket->ungetChar(shortLength & 0xFF);
-                _socket->ungetChar(shortLength >> 8);
-            }
-        }
-    } else if (available >= baseLength + byteLength) {
-        length = byteLength;
-    }
-    if (length == -1) {
-        _socket->ungetChar(maskLength);
-        _socket->ungetChar(finalOpcode);
-        return false;
-    }
-
-    // read the mask and set it in the filter
-    quint32 mask = 0;
-    if (masked) {
-        _stream >> mask;
-    }
-    _unmasker->setMask(mask);
-
-    // if not final, add to continuing message
-    FrameOpcode opcode = (FrameOpcode)(finalOpcode & 0x0F);
-    if ((finalOpcode & 0x80) == 0) {
-        if (opcode != ContinuationFrame) {
-            _continuingOpcode = opcode;
-        }
-        _continuingMessage += _unmasker->read(length);
-        return true;
-    }
-
-    // if continuing, add to and read from buffer
-    QIODevice* device = _unmasker;
-    FrameOpcode copcode = opcode;
-    if (opcode == ContinuationFrame) {
-        _continuingMessage += _unmasker->read(length);
-        device = new QBuffer(&_continuingMessage, this);
-        device->open(QIODevice::ReadOnly);
-        copcode = _continuingOpcode;
-    }
-
-    // act according to opcode
-    switch (copcode) {
-        case TextFrame:
-            emit webSocketMessageAvailable(device, length, true);
-            break;
-
-        case BinaryFrame:
-            emit webSocketMessageAvailable(device, length, false);
-            break;
-
-        case ConnectionClose:
-            // if this is not a response to our own close request, send a close reply
-            if (!_closeSent) {
-                closeWebSocket(GoingAway);
-            }
-            if (length >= 2) {
-                QDataStream stream(device);
-                quint16 reasonCode;
-                stream >> reasonCode;
-                emit webSocketClosed(reasonCode, device->read(length - 2));
-            } else {
-                emit webSocketClosed(0, QByteArray());
-            }
-            _socket->disconnectFromHost();
-            break;
-
-        case Ping:
-            // send the pong out immediately
-            writeFrameHeader(Pong, length, true);
-            _socket->write(device->read(length));
-            break;
-
-        case Pong:
-            qWarning() << "Got unsolicited WebSocket pong." << _address << device->read(length);
-            break;
-
-        default:
-            qWarning() << "Received unknown WebSocket opcode." << _address << opcode <<
-                device->read(length);
-            break;
-    }
-
-    // clear the continuing message buffer
-    if (opcode == ContinuationFrame) {
-        _continuingMessage.clear();
-        delete device;
-    }
-
-    return true;
-}
-
-void HttpConnection::writeFrameHeader (FrameOpcode opcode, int size, bool final)
-{
-    if (_closeSent) {
-        qWarning() << "Writing frame header after close message." << _address << opcode;
-        return;
-    }
-    _socket->putChar((final ? 0x80 : 0x0) | opcode);
-    if (size < 126) {
-        _socket->putChar(size);
-
-    } else if (size < 65536) {
-        _socket->putChar(126);
-        _stream << (quint16)size;
-
-    } else {
-        _socket->putChar(127);
-        _stream << (quint64)size;
-    }
-}
-
-MaskFilter::MaskFilter (QIODevice* device, QObject* parent) :
-    QIODevice(parent),
-    _device(device)
-{
-    open(ReadOnly);
-}
-
-void MaskFilter::setMask (quint32 mask)
-{
-    _mask[0] = (mask >> 24);
-    _mask[1] = (mask >> 16) & 0xFF;
-    _mask[2] = (mask >> 8) & 0xFF;
-    _mask[3] = mask & 0xFF;
-    _position = 0;
-    reset();
-}
-
-qint64 MaskFilter::bytesAvailable () const
-{
-    return _device->bytesAvailable() + QIODevice::bytesAvailable();
-}
-
-qint64 MaskFilter::readData (char* data, qint64 maxSize)
-{
-    qint64 bytes = _device->read(data, maxSize);
-    for (char* end = data + bytes; data < end; data++) {
-        *data ^= _mask[_position];
-        _position = (_position + 1) % 4;
-    }
-    return bytes;
-}
-
-qint64 MaskFilter::writeData (const char* data, qint64 maxSize)
-{
-    return _device->write(data, maxSize);
+    _parentManager->handleRequest(this, _requestUrl.path());
 }
diff --git a/libraries/embedded-webserver/src/HttpConnection.h b/libraries/embedded-webserver/src/HttpConnection.h
index 346b436a8d..22ab0ddbb5 100755
--- a/libraries/embedded-webserver/src/HttpConnection.h
+++ b/libraries/embedded-webserver/src/HttpConnection.h
@@ -81,11 +81,6 @@ public:
      */
     const QByteArray& requestContent () const { return _requestContent; }
 
-    /**
-     * Checks whether the request is asking to switch to a WebSocket.
-     */
-    bool isWebSocketRequest ();
-
     /**
      * Parses the request content as form data, returning a list of header/content pairs.
      */
@@ -97,28 +92,6 @@ public:
     void respond (const char* code, const QByteArray& content = QByteArray(),
         const char* contentType = "text/plain; charset=ISO-8859-1",
         const Headers& headers = Headers());
-
-    /**
-     * Switches to a WebSocket.
-     */
-    void switchToWebSocket (const char* protocol = 0);
-
-    /**
-     * Writes a header for a WebSocket message of the specified size.  The body of the message
-     * should be written through the socket.
-     */
-    void writeWebSocketHeader (int size) { writeFrameHeader(BinaryFrame, size); }
-
-    /**
-     * Pauses or unpauses the WebSocket.  A paused WebSocket buffers messages until unpaused.
-     */
-    void setWebSocketPaused (bool paused);
-
-    /**
-     * Closes the WebSocket.
-     */
-    void closeWebSocket (quint16 reasonCode = NormalClosure, const char* reason = 0);
-
 signals:
 
     /**
@@ -148,36 +121,14 @@ protected slots:
      */
     void readContent ();
 
-    /**
-     * Reads any incoming WebSocket frames.
-     */
-    void readFrames ();
-
 protected:
 
-    /** The available WebSocket frame opcodes. */
-    enum FrameOpcode { ContinuationFrame, TextFrame, BinaryFrame,
-        ConnectionClose = 0x08, Ping, Pong };
-
-    /**
-     * Attempts to read a single WebSocket frame, returning true if successful.
-     */
-    bool maybeReadFrame ();
-
-    /**
-     * Writes a WebSocket frame header.
-     */
-    void writeFrameHeader (FrameOpcode opcode, int size = 0, bool final = true);
-
     /** The parent HTTP manager. */
     HttpManager* _parentManager;
 
     /** The underlying socket. */
     QTcpSocket* _socket;
-
-    /** The mask filter for WebSocket frames. */
-    MaskFilter* _unmasker;
-
+    
     /** The data stream for writing to the socket. */
     QDataStream _stream;
 
@@ -198,64 +149,6 @@ protected:
 
     /** The content of the request. */
     QByteArray _requestContent;
-
-    /** The opcode for the WebSocket message being continued. */
-    FrameOpcode _continuingOpcode;
-
-    /** The WebSocket message being continued. */
-    QByteArray _continuingMessage;
-
-    /** Whether or not the WebSocket is paused (buffering messages for future processing). */
-    bool _webSocketPaused;
-
-    /** Whether or not we've sent a WebSocket close message. */
-    bool _closeSent;
-};
-
-/**
- * A filter device that applies a 32-bit mask.
- */
-class MaskFilter : public QIODevice
-{
-    Q_OBJECT
-
-public:
-
-    /**
-     * Creates a new masker to filter the supplied device.
-     */
-    MaskFilter (QIODevice* device, QObject* parent = 0);
-
-    /**
-     * Sets the mask to apply.
-     */
-    void setMask (quint32 mask);
-
-    /**
-     * Returns the number of bytes available to read.
-     */
-    virtual qint64 bytesAvailable () const;
-
-protected:
-
-    /**
-     * Reads masked data from the underlying device.
-     */
-    virtual qint64 readData (char* data, qint64 maxSize);
-
-    /**
-     * Writes masked data to the underlying device.
-     */
-    virtual qint64 writeData (const char* data, qint64 maxSize);
-
-    /** The underlying device. */
-    QIODevice* _device;
-
-    /** The current mask. */
-    char _mask[4];
-
-    /** The current position within the mask. */
-    int _position;
 };
 
 #endif // HTTP_CONNECTION
diff --git a/libraries/embedded-webserver/src/HttpManager.cpp b/libraries/embedded-webserver/src/HttpManager.cpp
index 140529e74a..0d7f4b3286 100755
--- a/libraries/embedded-webserver/src/HttpManager.cpp
+++ b/libraries/embedded-webserver/src/HttpManager.cpp
@@ -10,40 +10,59 @@
 //  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
 //
 
-#include <QTcpSocket>
-#include <QtDebug>
+#include <QtCore/QDebug>
+#include <QtCore/QFile>
+#include <QtCore/QFileInfo>
+#include <QtCore/QMimeDatabase>
+#include <QtNetwork/QTcpSocket>
 
 #include "HttpConnection.h"
 #include "HttpManager.h"
 
-void HttpSubrequestHandler::registerSubhandler (const QString& name, HttpRequestHandler* handler) {
-    _subhandlers.insert(name, handler);
-}
-
-bool HttpSubrequestHandler::handleRequest (
-    HttpConnection* connection, const QString& name, const QString& path) {
-    QString subpath = path;
-    if (subpath.startsWith('/')) {
-        subpath.remove(0, 1);
+bool HttpManager::handleRequest(HttpConnection* connection, const QString& path) {
+    QString subPath = path;
+    
+    // remove any slash at the beginning of the path
+    if (subPath.startsWith('/')) {
+        subPath.remove(0, 1);
     }
-    QString subname;
-    int idx = subpath.indexOf('/');
-    if (idx == -1) {
-        subname = subpath;
-        subpath = "";
+    
+    QString filePath;
+    
+    // if the last thing is a trailing slash then we want to look for index file
+    if (subPath.endsWith('/') || subPath.size() == 0) {
+        QStringList possibleIndexFiles = QStringList() << "index.html" << "index.shtml";
+        
+        foreach (const QString& possibleIndexFilename, possibleIndexFiles) {
+            if (QFileInfo(_documentRoot + subPath + possibleIndexFilename).exists()) {
+                filePath = _documentRoot + subPath + possibleIndexFilename;
+                break;
+            }
+        }
+    } else if (QFileInfo(_documentRoot + subPath).isFile()) {
+        filePath = _documentRoot + subPath;
+    }
+    
+    if (!filePath.isEmpty()) {
+        static QMimeDatabase mimeDatabase;
+        
+        qDebug() << "Serving file at" << filePath;
+        
+        QFile localFile(filePath);
+        localFile.open(QIODevice::ReadOnly);
+        
+        connection->respond("200 OK", localFile.readAll(), qPrintable(mimeDatabase.mimeTypeForFile(filePath).name()));
     } else {
-        subname = subpath.left(idx);
-        subpath = subpath.mid(idx + 1);
-    }
-    HttpRequestHandler* handler = _subhandlers.value(subname);
-    if (handler == 0 || !handler->handleRequest(connection, subname, subpath)) {
+        // respond with a 404
         connection->respond("404 Not Found", "Resource not found.");
     }
+    
     return true;
 }
 
-HttpManager::HttpManager(quint16 port, QObject* parent) :
-    QTcpServer(parent) {
+HttpManager::HttpManager(quint16 port, const QString& documentRoot, QObject* parent) :
+    QTcpServer(parent),
+    _documentRoot(documentRoot) {
     // start listening on the passed port
     if (!listen(QHostAddress("0.0.0.0"), port)) {
         qDebug() << "Failed to open HTTP server socket:" << errorString();
@@ -54,7 +73,7 @@ HttpManager::HttpManager(quint16 port, QObject* parent) :
     connect(this, SIGNAL(newConnection()), SLOT(acceptConnections()));
 }
 
-void HttpManager::acceptConnections () {
+void HttpManager::acceptConnections() {
     QTcpSocket* socket;
     while ((socket = nextPendingConnection()) != 0) {
         new HttpConnection(socket, this);
diff --git a/libraries/embedded-webserver/src/HttpManager.h b/libraries/embedded-webserver/src/HttpManager.h
index 8751169271..5dbfefc8df 100755
--- a/libraries/embedded-webserver/src/HttpManager.h
+++ b/libraries/embedded-webserver/src/HttpManager.h
@@ -20,48 +20,10 @@
 class HttpConnection;
 class HttpRequestHandler;
 
-/**
- * Interface for HTTP request handlers.
- */
-class HttpRequestHandler
-{
-public:
-
-    /**
-     * Handles an HTTP request.
-     */
-    virtual bool handleRequest (
-        HttpConnection* connection, const QString& name, const QString& path) = 0;
-};
-
-/**
- * Handles requests by forwarding them to subhandlers.
- */
-class HttpSubrequestHandler : public HttpRequestHandler
-{
-public:
-
-    /**
-     * Registers a subhandler with the given name.
-     */
-    void registerSubhandler (const QString& name, HttpRequestHandler* handler);
-
-    /**
-     * Handles an HTTP request.
-     */
-    virtual bool handleRequest (
-        HttpConnection* connection, const QString& name, const QString& path);
-
-protected:
-
-    /** Subhandlers mapped by name. */
-    QHash<QString, HttpRequestHandler*> _subhandlers;
-};
-
 /**
  * Handles HTTP connections.
  */
-class HttpManager : public QTcpServer, public HttpSubrequestHandler
+class HttpManager : public QTcpServer
 {
    Q_OBJECT
 
@@ -70,7 +32,13 @@ public:
     /**
      * Initializes the manager.
      */
-    HttpManager(quint16 port, QObject* parent = 0);
+    HttpManager(quint16 port, const QString& documentRoot, QObject* parent = 0);
+    
+    /**
+     * Handles an HTTP request.
+     */
+    virtual bool handleRequest (HttpConnection* connection, const QString& path);
+    
 
 protected slots:
 
@@ -78,6 +46,8 @@ protected slots:
      * Accepts all pending connections.
      */
     void acceptConnections ();
+protected:
+    QString _documentRoot;
 };
 
 #endif // HTTP_MANAGER

From e68dc1b1425d779ae19372a8dbebabe368b02ac2 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 09:00:34 -0800
Subject: [PATCH 05/18] cleaup commenting and style across new HTTP classes

---
 .../embedded-webserver/src/HttpConnection.cpp | 26 ++---
 .../embedded-webserver/src/HttpConnection.h   | 97 ++++++-------------
 .../embedded-webserver/src/HttpManager.h      | 29 ++----
 3 files changed, 47 insertions(+), 105 deletions(-)

diff --git a/libraries/embedded-webserver/src/HttpConnection.cpp b/libraries/embedded-webserver/src/HttpConnection.cpp
index 7923e8ec40..ffb763cee3 100755
--- a/libraries/embedded-webserver/src/HttpConnection.cpp
+++ b/libraries/embedded-webserver/src/HttpConnection.cpp
@@ -23,8 +23,8 @@ HttpConnection::HttpConnection (QTcpSocket* socket, HttpManager* parentManager)
     _parentManager(parentManager),
     _socket(socket),
     _stream(socket),
-    _address(socket->peerAddress())
-{
+    _address(socket->peerAddress()) {
+        
     // take over ownership of the socket
     _socket->setParent(this);
 
@@ -32,23 +32,16 @@ HttpConnection::HttpConnection (QTcpSocket* socket, HttpManager* parentManager)
     connect(socket, SIGNAL(readyRead()), SLOT(readRequest()));
     connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(deleteLater()));
     connect(socket, SIGNAL(disconnected()), SLOT(deleteLater()));
-
-    // log the connection
-    qDebug() << "HTTP connection opened." << _address;
 }
 
-HttpConnection::~HttpConnection ()
-{
+HttpConnection::~HttpConnection() {
     // log the destruction
-    QString error;
-    QDebug base = qDebug() << "HTTP connection closed." << _address;
     if (_socket->error() != QAbstractSocket::UnknownSocketError) {
-        base << _socket->errorString();
+        qDebug() << _socket->errorString();
     }
 }
 
-QList<FormData> HttpConnection::parseFormData () const
-{
+QList<FormData> HttpConnection::parseFormData() const {
     // make sure we have the correct MIME type
     QList<QByteArray> elements = _requestHeaders.value("Content-Type").split(';');
     if (elements.at(0).trimmed() != "multipart/form-data") {
@@ -64,6 +57,7 @@ QList<FormData> HttpConnection::parseFormData () const
             break;
         }
     }
+    
     QByteArray start = "--" + boundary;
     QByteArray end = "\r\n--" + boundary + "--\r\n";
 
@@ -103,7 +97,7 @@ QList<FormData> HttpConnection::parseFormData () const
     return data;
 }
 
-void HttpConnection::respond (const char* code, const QByteArray& content, const char* contentType, const Headers& headers) {
+void HttpConnection::respond(const char* code, const QByteArray& content, const char* contentType, const Headers& headers) {
     _socket->write("HTTP/1.1 ");
     _socket->write(code);
     _socket->write("\r\n");
@@ -139,8 +133,7 @@ void HttpConnection::respond (const char* code, const QByteArray& content, const
     _socket->disconnectFromHost();
 }
 
-void HttpConnection::readRequest ()
-{
+void HttpConnection::readRequest() {
     if (!_socket->canReadLine()) {
         return;
     }
@@ -177,8 +170,7 @@ void HttpConnection::readRequest ()
     readHeaders();
 }
 
-void HttpConnection::readHeaders ()
-{
+void HttpConnection::readHeaders() {
     while (_socket->canReadLine()) {
         QByteArray line = _socket->readLine();
         QByteArray trimmed = line.trimmed();
diff --git a/libraries/embedded-webserver/src/HttpConnection.h b/libraries/embedded-webserver/src/HttpConnection.h
index 22ab0ddbb5..c791a93a07 100755
--- a/libraries/embedded-webserver/src/HttpConnection.h
+++ b/libraries/embedded-webserver/src/HttpConnection.h
@@ -10,8 +10,8 @@
 //  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
 //
 
-#ifndef HTTP_CONNECTION
-#define HTTP_CONNECTION
+#ifndef __hifi__HttpConnection__
+#define __hifi__HttpConnection__
 
 #include <QHash>
 #include <QHostAddress>
@@ -27,128 +27,89 @@ class HttpManager;
 class MaskFilter;
 class ServerApp;
 
-/** Header hash. */
+/// Header hash
 typedef QHash<QByteArray, QByteArray> Headers;
 
-/** A form data element. */
+/// A form data element
 typedef QPair<Headers, QByteArray> FormData;
 
-/**
- * Handles a single HTTP connection.
- */
-class HttpConnection : public QObject
-{
+/// Handles a single HTTP connection.
+class HttpConnection : public QObject {
    Q_OBJECT
 
 public:
 
-    /** WebSocket close status codes. */
+    /// WebSocket close status codes.
     enum ReasonCode { NoReason = 0, NormalClosure = 1000, GoingAway = 1001 };
 
-    /**
-     * Initializes the connection.
-     */
+    /// Initializes the connection.
     HttpConnection (QTcpSocket* socket, HttpManager* parentManager);
 
-    /**
-     * Destroys the connection.
-     */
+    /// Destroys the connection.
     virtual ~HttpConnection ();
 
-    /**
-     * Returns a pointer to the underlying socket, to which WebSocket message bodies should be
-     * written.
-     */
+    /// Returns a pointer to the underlying socket, to which WebSocket message bodies should be written.
     QTcpSocket* socket () const { return _socket; }
 
-    /**
-     * Returns the request operation.
-     */
+    /// Returns the request operation.
     QNetworkAccessManager::Operation requestOperation () const { return _requestOperation; }
 
-    /**
-     * Returns a reference to the request URL.
-     */
+    /// Returns a reference to the request URL.
     const QUrl& requestUrl () const { return _requestUrl; }
 
-    /**
-     * Returns a reference to the request headers.
-     */
+    /// Returns a reference to the request headers.
     const Headers& requestHeaders () const { return _requestHeaders; }
 
-    /**
-     * Returns a reference to the request content.
-     */
+    /// Returns a reference to the request content.
     const QByteArray& requestContent () const { return _requestContent; }
 
-    /**
-     * Parses the request content as form data, returning a list of header/content pairs.
-     */
+    /// Parses the request content as form data, returning a list of header/content pairs.
     QList<FormData> parseFormData () const;
 
-    /**
-     * Sends a response and closes the connection.
-     */
+    /// Sends a response and closes the connection.
     void respond (const char* code, const QByteArray& content = QByteArray(),
         const char* contentType = "text/plain; charset=ISO-8859-1",
         const Headers& headers = Headers());
-signals:
-
-    /**
-     * Fired when a WebSocket message of the specified size is available to read.
-     */
-    void webSocketMessageAvailable (QIODevice* device, int length, bool text);
-
-    /**
-     * Fired when the WebSocket has been closed by the other side.
-     */
-    void webSocketClosed (quint16 reasonCode, QByteArray reason);
 
 protected slots:
 
-    /**
-     * Reads the request line.
-     */
+    /// Reads the request line.
     void readRequest ();
 
-    /**
-     * Reads the headers.
-     */
+    /// Reads the headers.
     void readHeaders ();
 
-    /**
-     * Reads the content.
-     */
+    /// Reads the content.
     void readContent ();
 
 protected:
 
-    /** The parent HTTP manager. */
+    /// The parent HTTP manager
     HttpManager* _parentManager;
 
-    /** The underlying socket. */
+    /// The underlying socket.
     QTcpSocket* _socket;
     
-    /** The data stream for writing to the socket. */
+    /// The data stream for writing to the socket.
     QDataStream _stream;
 
-    /** The stored address. */
+    /// The stored address.
     QHostAddress _address;
 
-    /** The requested operation. */
+    /// The requested operation.
     QNetworkAccessManager::Operation _requestOperation;
 
-    /** The requested URL. */
+    /// The requested URL.
     QUrl _requestUrl;
 
-    /** The request headers. */
+    /// The request headers.
     Headers _requestHeaders;
 
-    /** The last request header processed (used for continuations). */
+    /// The last request header processed (used for continuations).
     QByteArray _lastRequestHeader;
 
-    /** The content of the request. */
+    /// The content of the request.
     QByteArray _requestContent;
 };
 
-#endif // HTTP_CONNECTION
+#endif /* defined(__hifi__HttpConnection__) */
diff --git a/libraries/embedded-webserver/src/HttpManager.h b/libraries/embedded-webserver/src/HttpManager.h
index 5dbfefc8df..1c5cb7ee65 100755
--- a/libraries/embedded-webserver/src/HttpManager.h
+++ b/libraries/embedded-webserver/src/HttpManager.h
@@ -10,8 +10,8 @@
 //  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
 //
 
-#ifndef HTTP_MANAGER
-#define HTTP_MANAGER
+#ifndef __hifi__HttpManager__
+#define __hifi__HttpManager__
 
 #include <QByteArray>
 #include <QHash>
@@ -20,34 +20,23 @@
 class HttpConnection;
 class HttpRequestHandler;
 
-/**
- * Handles HTTP connections.
- */
-class HttpManager : public QTcpServer
-{
+/// Handles HTTP connections
+class HttpManager : public QTcpServer {
    Q_OBJECT
 
 public:
 
-    /**
-     * Initializes the manager.
-     */
+    /// Initializes the manager.
     HttpManager(quint16 port, const QString& documentRoot, QObject* parent = 0);
     
-    /**
-     * Handles an HTTP request.
-     */
+    /// Handles an HTTP request.
     virtual bool handleRequest (HttpConnection* connection, const QString& path);
     
-
 protected slots:
-
-    /**
-     * Accepts all pending connections.
-     */
-    void acceptConnections ();
+    /// Accepts all pending connections
+    void acceptConnections();
 protected:
     QString _documentRoot;
 };
 
-#endif // HTTP_MANAGER
+#endif /* defined(__hifi__HttpManager__) */

From bce40a9963dbb0c0946fc9f509057b1d98418299 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 10:40:49 -0800
Subject: [PATCH 06/18] add basic SSI include support to HttpManager

---
 .../resources/web/assignment/index.shtml      |  2 +-
 .../web/{footer.shtml => footer.html}         |  0
 .../web/{header.shtml => header.html}         |  0
 domain-server/resources/web/index.shtml       |  6 +--
 .../web/{page-end.shtml => page-end.html}     |  0
 .../embedded-webserver/src/HttpConnection.cpp |  1 -
 .../embedded-webserver/src/HttpManager.cpp    | 48 +++++++++++++++++--
 7 files changed, 49 insertions(+), 8 deletions(-)
 rename domain-server/resources/web/{footer.shtml => footer.html} (100%)
 rename domain-server/resources/web/{header.shtml => header.html} (100%)
 rename domain-server/resources/web/{page-end.shtml => page-end.html} (100%)

diff --git a/domain-server/resources/web/assignment/index.shtml b/domain-server/resources/web/assignment/index.shtml
index ba736fd6e6..64a6d8825f 100644
--- a/domain-server/resources/web/assignment/index.shtml
+++ b/domain-server/resources/web/assignment/index.shtml
@@ -5,7 +5,7 @@
     <link href='css/style.css' rel='stylesheet'>
   </head>
   <body>
-    <pre id='editor' style='font-size: 14px;'><!--#include "placeholder.js"--></pre>
+    <pre id='editor' style='font-size: 14px;'><!--#include file="placeholder.js"--></object></pre>
     <script src='../js/jquery-2.0.3.min.js'></script>
     <script src='js/ace/ace.js' type='text/javascript'></script>
     <script src='js/assignment.js' type='text/javascript'></script>
diff --git a/domain-server/resources/web/footer.shtml b/domain-server/resources/web/footer.html
similarity index 100%
rename from domain-server/resources/web/footer.shtml
rename to domain-server/resources/web/footer.html
diff --git a/domain-server/resources/web/header.shtml b/domain-server/resources/web/header.html
similarity index 100%
rename from domain-server/resources/web/header.shtml
rename to domain-server/resources/web/header.html
diff --git a/domain-server/resources/web/index.shtml b/domain-server/resources/web/index.shtml
index 2b64dad530..29c39f6c02 100644
--- a/domain-server/resources/web/index.shtml
+++ b/domain-server/resources/web/index.shtml
@@ -1,4 +1,4 @@
-<!--#include file="header.shtml"-->
+<!--#include file="header.html"-->
   <div id="nodes-lead" class="table-lead"><h3>Nodes</h3><div class="lead-line"></div></div>
   <table id="nodes-table" class="table table-striped">
     <thead>
@@ -27,6 +27,6 @@
     <tbody>
     </tbody>
   </table>
-<!--#include file="footer.shtml"-->
+<!--#include file="footer.html"-->
 <script src='js/tables.js'></script>
-<!--#include file="page-end.shtml"-->
\ No newline at end of file
+<!--#include file="page-end.html"-->
\ No newline at end of file
diff --git a/domain-server/resources/web/page-end.shtml b/domain-server/resources/web/page-end.html
similarity index 100%
rename from domain-server/resources/web/page-end.shtml
rename to domain-server/resources/web/page-end.html
diff --git a/libraries/embedded-webserver/src/HttpConnection.cpp b/libraries/embedded-webserver/src/HttpConnection.cpp
index ffb763cee3..82660c8473 100755
--- a/libraries/embedded-webserver/src/HttpConnection.cpp
+++ b/libraries/embedded-webserver/src/HttpConnection.cpp
@@ -123,7 +123,6 @@ void HttpConnection::respond(const char* code, const QByteArray& content, const
     _socket->write("Connection: close\r\n\r\n");
 
     if (csize > 0) {
-        qDebug() << "Writing" << QString(content) << "\n";
         _socket->write(content);
     }
 
diff --git a/libraries/embedded-webserver/src/HttpManager.cpp b/libraries/embedded-webserver/src/HttpManager.cpp
index 0d7f4b3286..07dd376c8a 100755
--- a/libraries/embedded-webserver/src/HttpManager.cpp
+++ b/libraries/embedded-webserver/src/HttpManager.cpp
@@ -42,16 +42,58 @@ bool HttpManager::handleRequest(HttpConnection* connection, const QString& path)
     } else if (QFileInfo(_documentRoot + subPath).isFile()) {
         filePath = _documentRoot + subPath;
     }
+
     
     if (!filePath.isEmpty()) {
         static QMimeDatabase mimeDatabase;
         
-        qDebug() << "Serving file at" << filePath;
-        
         QFile localFile(filePath);
         localFile.open(QIODevice::ReadOnly);
+        QString localFileString(localFile.readAll());
         
-        connection->respond("200 OK", localFile.readAll(), qPrintable(mimeDatabase.mimeTypeForFile(filePath).name()));
+        QFileInfo localFileInfo(filePath);
+        
+        if (localFileInfo.completeSuffix() == "shtml") {
+            // this is a file that may have some SSI statements
+            // the only thing we support is the include directive, but check the contents for that
+            
+            // setup our static QRegExp that will catch <!--#include virtual ... --> and <!--#include file .. --> directives
+            const QString includeRegExpString = "<!--\\s*#include\\s+(virtual|file)\\s?=\\s?\"(\\S+)\"\\s*-->";
+            QRegExp includeRegExp(includeRegExpString);
+            
+            int matchPosition = 0;
+            
+            
+            while ((matchPosition = includeRegExp.indexIn(localFileString, matchPosition)) != -1) {
+                // check if this is a file or vitual include
+                bool isFileInclude = includeRegExp.cap(1) == "file";
+                
+                // setup the correct file path for the included file
+                QString includeFilePath = isFileInclude
+                    ? localFileInfo.canonicalPath() + "/" + includeRegExp.cap(2)
+                    : _documentRoot + includeRegExp.cap(2);
+                
+                QString replacementString;
+                
+                if (QFileInfo(includeFilePath).isFile()) {
+                    
+                    QFile includedFile(includeFilePath);
+                    includedFile.open(QIODevice::ReadOnly);
+                    
+                    replacementString = QString(includedFile.readAll());
+                } else {
+                    qDebug() << "SSI include directive referenced a missing file:" << includeFilePath;
+                }
+                
+                // replace the match with the contents of the file, or an empty string if the file was not found
+                localFileString.replace(matchPosition, includeRegExp.matchedLength(), replacementString);
+                
+                // push the match position forward so we can check the next match
+                matchPosition += includeRegExp.matchedLength();
+            }
+        }
+        
+        connection->respond("200 OK", localFileString.toLocal8Bit(), qPrintable(mimeDatabase.mimeTypeForFile(filePath).name()));
     } else {
         // respond with a 404
         connection->respond("404 Not Found", "Resource not found.");

From 40cdba203d9a27e5ba85b0823748cf46906d865e Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 11:29:20 -0800
Subject: [PATCH 07/18] handle programmatic DS requests except for script
 creation

---
 domain-server/src/DomainServer.cpp            | 255 ++++++++----------
 domain-server/src/DomainServer.h              |   4 +-
 .../embedded-webserver/src/HttpConnection.cpp |  12 +-
 .../embedded-webserver/src/HttpConnection.h   |   5 +-
 .../embedded-webserver/src/HttpManager.cpp    |  26 +-
 .../embedded-webserver/src/HttpManager.h      |  21 +-
 6 files changed, 159 insertions(+), 164 deletions(-)

diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index eb5801197a..4d15a98b33 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -13,6 +13,7 @@
 #include <QtCore/QStringList>
 #include <QtCore/QTimer>
 
+#include <HttpConnection.h>
 #include <PacketHeaders.h>
 #include <SharedUtil.h>
 #include <UUID.h>
@@ -33,7 +34,7 @@ const quint16 DOMAIN_SERVER_HTTP_PORT = 8080;
 
 DomainServer::DomainServer(int argc, char* argv[]) :
     QCoreApplication(argc, argv),
-    _httpManager(DOMAIN_SERVER_HTTP_PORT, QString("%1/resources/web/").arg(QCoreApplication::applicationDirPath())),
+    _httpManager(DOMAIN_SERVER_HTTP_PORT, QString("%1/resources/web/").arg(QCoreApplication::applicationDirPath()), this),
     _assignmentQueueMutex(),
     _assignmentQueue(),
     _staticAssignmentFile(QString("%1/config.ds").arg(QCoreApplication::applicationDirPath())),
@@ -293,142 +294,122 @@ QJsonObject jsonObjectForNode(Node* node) {
     return nodeJson;
 }
 
-//int DomainServer::civetwebRequestHandler(struct mg_connection *connection) {
-//    const struct mg_request_info* ri = mg_get_request_info(connection);
-//
-//    const char RESPONSE_200[] = "HTTP/1.0 200 OK\r\n\r\n";
-//    const char RESPONSE_400[] = "HTTP/1.0 400 Bad Request\r\n\r\n";
-//
-//    const char URI_ASSIGNMENT[] = "/assignment";
-//    const char URI_NODE[] = "/node";
-//
-//    if (strcmp(ri->request_method, "GET") == 0) {
-//        if (strcmp(ri->uri, "/assignments.json") == 0) {
-//            // user is asking for json list of assignments
-//
-//            // start with a 200 response
-//            mg_printf(connection, "%s", RESPONSE_200);
-//
-//            // setup the JSON
-//            QJsonObject assignmentJSON;
-//            QJsonObject assignedNodesJSON;
-//
-//            // enumerate the NodeList to find the assigned nodes
-//            foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
-//                if (node->getLinkedData()) {
-//                    // add the node using the UUID as the key
-//                    QString uuidString = uuidStringWithoutCurlyBraces(node->getUUID());
-//                    assignedNodesJSON[uuidString] = jsonObjectForNode(node.data());
-//                }
-//            }
-//
-//            assignmentJSON["fulfilled"] = assignedNodesJSON;
-//
-//            QJsonObject queuedAssignmentsJSON;
-//
-//            // add the queued but unfilled assignments to the json
-//            std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
-//
-//            while (assignment != domainServerInstance->_assignmentQueue.end()) {
-//                QJsonObject queuedAssignmentJSON;
-//
-//                QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
-//                queuedAssignmentJSON[JSON_KEY_TYPE] = QString((*assignment)->getTypeName());
-//
-//                // if the assignment has a pool, add it
-//                if ((*assignment)->hasPool()) {
-//                    queuedAssignmentJSON[JSON_KEY_POOL] = QString((*assignment)->getPool());
-//                }
-//
-//                // add this queued assignment to the JSON
-//                queuedAssignmentsJSON[uuidString] = queuedAssignmentJSON;
-//
-//                // push forward the iterator to check the next assignment
-//                assignment++;
-//            }
-//
-//            assignmentJSON["queued"] = queuedAssignmentsJSON;
-//
-//            // print out the created JSON
-//            QJsonDocument assignmentDocument(assignmentJSON);
-//            mg_printf(connection, "%s", assignmentDocument.toJson().constData());
-//
-//            // we've processed this request
-//            return 1;
-//        } else if (strcmp(ri->uri, "/nodes.json") == 0) {
-//            // start with a 200 response
-//            mg_printf(connection, "%s", RESPONSE_200);
-//
-//            // setup the JSON
-//            QJsonObject rootJSON;
-//            QJsonObject nodesJSON;
-//
-//            // enumerate the NodeList to find the assigned nodes
-//            NodeList* nodeList = NodeList::getInstance();
-//
-//            foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
-//                // add the node using the UUID as the key
-//                QString uuidString = uuidStringWithoutCurlyBraces(node->getUUID());
-//                nodesJSON[uuidString] = jsonObjectForNode(node.data());
-//            }
-//
-//            rootJSON["nodes"] = nodesJSON;
-//
-//            // print out the created JSON
-//            QJsonDocument nodesDocument(rootJSON);
-//            mg_printf(connection, "%s", nodesDocument.toJson().constData());
-//
-//            // we've processed this request
-//            return 1;
-//        }
-//
-//        // not processed, pass to document root
-//        return 0;
-//    } else if (strcmp(ri->request_method, "POST") == 0) {
-//        if (strcmp(ri->uri, URI_ASSIGNMENT) == 0) {
-//            // return a 200
-//            mg_printf(connection, "%s", RESPONSE_200);
-//            // upload the file
-//            mg_upload(connection, "/tmp");
-//
-//            return 1;
-//        }
-//
-//        return 0;
-//    } else if (strcmp(ri->request_method, "DELETE") == 0) {
-//        // this is a DELETE request
-//
-//        // check if it is for an assignment
-//        if (memcmp(ri->uri, URI_NODE, strlen(URI_NODE)) == 0) {
-//            // pull the UUID from the url
-//            QUuid deleteUUID = QUuid(QString(ri->uri + strlen(URI_NODE) + sizeof('/')));
-//
-//            if (!deleteUUID.isNull()) {
-//                SharedNodePointer nodeToKill = NodeList::getInstance()->nodeWithUUID(deleteUUID);
-//
-//                if (nodeToKill) {
-//                    // start with a 200 response
-//                    mg_printf(connection, "%s", RESPONSE_200);
-//
-//                    // we have a valid UUID and node - kill the node that has this assignment
-//                    QMetaObject::invokeMethod(NodeList::getInstance(), "killNodeWithUUID", Q_ARG(const QUuid&, deleteUUID));
-//                    
-//                    // successfully processed request
-//                    return 1;
-//                }
-//            }
-//        }
-//
-//        // request not processed - bad request
-//        mg_printf(connection, "%s", RESPONSE_400);
-//
-//        // this was processed by civetweb
-//        return 1;
-//    } else {
-//        // have mongoose process this request from the document_root
-//        return 0;
-//    }
-//}
+bool DomainServer::handleHTTPRequest(HttpConnection* connection, const QString& path) {
+    const QString JSON_MIME_TYPE = "application/json";
+    
+    const QString URI_ASSIGNMENT = "/assignment";
+    const QString URI_NODE = "/node";
+    
+    if (connection->requestOperation() == QNetworkAccessManager::GetOperation) {
+        if (path == "/assignments.json") {
+            // user is asking for json list of assignments
+            
+            // setup the JSON
+            QJsonObject assignmentJSON;
+            QJsonObject assignedNodesJSON;
+            
+            // enumerate the NodeList to find the assigned nodes
+            foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+                if (node->getLinkedData()) {
+                    // add the node using the UUID as the key
+                    QString uuidString = uuidStringWithoutCurlyBraces(node->getUUID());
+                    assignedNodesJSON[uuidString] = jsonObjectForNode(node.data());
+                }
+            }
+            
+            assignmentJSON["fulfilled"] = assignedNodesJSON;
+            
+            QJsonObject queuedAssignmentsJSON;
+            
+            // add the queued but unfilled assignments to the json
+            std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
+            
+            while (assignment != domainServerInstance->_assignmentQueue.end()) {
+                QJsonObject queuedAssignmentJSON;
+                
+                QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
+                queuedAssignmentJSON[JSON_KEY_TYPE] = QString((*assignment)->getTypeName());
+                
+                // if the assignment has a pool, add it
+                if ((*assignment)->hasPool()) {
+                    queuedAssignmentJSON[JSON_KEY_POOL] = QString((*assignment)->getPool());
+                }
+                
+                // add this queued assignment to the JSON
+                queuedAssignmentsJSON[uuidString] = queuedAssignmentJSON;
+                
+                // push forward the iterator to check the next assignment
+                assignment++;
+            }
+            
+            assignmentJSON["queued"] = queuedAssignmentsJSON;
+            
+            // print out the created JSON
+            QJsonDocument assignmentDocument(assignmentJSON);
+            connection->respond(HttpConnection::StatusCode200, assignmentDocument.toJson(), qPrintable(JSON_MIME_TYPE));
+            
+            // we've processed this request
+            return true;
+        } else if (path == "/nodes.json") {
+            // setup the JSON
+            QJsonObject rootJSON;
+            QJsonObject nodesJSON;
+            
+            // enumerate the NodeList to find the assigned nodes
+            NodeList* nodeList = NodeList::getInstance();
+            
+            foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+                // add the node using the UUID as the key
+                QString uuidString = uuidStringWithoutCurlyBraces(node->getUUID());
+                nodesJSON[uuidString] = jsonObjectForNode(node.data());
+            }
+            
+            rootJSON["nodes"] = nodesJSON;
+            
+            // print out the created JSON
+            QJsonDocument nodesDocument(rootJSON);
+            
+            // send the response
+            connection->respond(HttpConnection::StatusCode200, nodesDocument.toJson(), qPrintable(JSON_MIME_TYPE));
+        }
+    } else if (connection->requestOperation() == QNetworkAccessManager::PostOperation) {
+        if (path == URI_ASSIGNMENT) {
+            // this is a script upload - ask the HttpConnection to parse the form data
+            QList<FormData> formData = connection->parseFormData();
+            qDebug() << formData;
+        }
+    } else if (connection->requestOperation() == QNetworkAccessManager::DeleteOperation) {
+        if (path.startsWith(URI_NODE)) {
+            // this is a request to DELETE a node by UUID
+            
+            // pull the UUID from the url
+            QUuid deleteUUID = QUuid(path.mid(URI_NODE.size() + sizeof('/')));
+            
+            if (!deleteUUID.isNull()) {
+                SharedNodePointer nodeToKill = NodeList::getInstance()->nodeWithUUID(deleteUUID);
+                
+                if (nodeToKill) {
+                    // start with a 200 response
+                    connection->respond(HttpConnection::StatusCode200);
+                    
+                    // we have a valid UUID and node - kill the node that has this assignment
+                    QMetaObject::invokeMethod(NodeList::getInstance(), "killNodeWithUUID", Q_ARG(const QUuid&, deleteUUID));
+                    
+                    // successfully processed request
+                    return true;
+                }
+            }
+            
+            // bad request, couldn't pull a node ID
+            connection->respond(HttpConnection::StatusCode400);
+            
+            return true;
+        }
+    }
+    
+    // didn't process the request, let the HTTPManager try and handle
+    return false;
+}
 
 const char ASSIGNMENT_SCRIPT_HOST_LOCATION[] = "resources/web/assignment";
 
diff --git a/domain-server/src/DomainServer.h b/domain-server/src/DomainServer.h
index 56cb1225b8..96a33eb267 100644
--- a/domain-server/src/DomainServer.h
+++ b/domain-server/src/DomainServer.h
@@ -21,11 +21,13 @@
 
 const int MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS = 1000;
 
-class DomainServer : public QCoreApplication {
+class DomainServer : public QCoreApplication, public HttpRequestHandler {
     Q_OBJECT
 public:
     DomainServer(int argc, char* argv[]);
     
+    bool handleHTTPRequest(HttpConnection* connection, const QString& path);
+    
     void exit(int retCode = 0);
 
     static void setDomainServerInstance(DomainServer* domainServer);
diff --git a/libraries/embedded-webserver/src/HttpConnection.cpp b/libraries/embedded-webserver/src/HttpConnection.cpp
index 82660c8473..0ea14ea82b 100755
--- a/libraries/embedded-webserver/src/HttpConnection.cpp
+++ b/libraries/embedded-webserver/src/HttpConnection.cpp
@@ -5,10 +5,6 @@
 //  Created by Stephen Birarda on 1/16/14.
 //  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
 //
-//  Heavily based on Andrzej Kapolka's original HttpConnection class
-//  found from another one of his projects.
-//  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
-//
 
 
 #include <QBuffer>
@@ -18,6 +14,10 @@
 #include "HttpConnection.h"
 #include "HttpManager.h"
 
+const char* HttpConnection::StatusCode200 = "200 OK";
+const char* HttpConnection::StatusCode400 = "400 Bad Request";
+const char* HttpConnection::StatusCode404 = "404 Not Found";
+
 HttpConnection::HttpConnection (QTcpSocket* socket, HttpManager* parentManager) :
     QObject(parentManager),
     _parentManager(parentManager),
@@ -178,7 +178,7 @@ void HttpConnection::readHeaders() {
 
             QByteArray clength = _requestHeaders.value("Content-Length");
             if (clength.isEmpty()) {
-                _parentManager->handleRequest(this, _requestUrl.path());
+                _parentManager->handleHTTPRequest(this, _requestUrl.path());
 
             } else {
                 _requestContent.resize(clength.toInt());
@@ -217,5 +217,5 @@ void HttpConnection::readContent() {
     _socket->read(_requestContent.data(), size);
     _socket->disconnect(this, SLOT(readContent()));
 
-    _parentManager->handleRequest(this, _requestUrl.path());
+    _parentManager->handleHTTPRequest(this, _requestUrl.path());
 }
diff --git a/libraries/embedded-webserver/src/HttpConnection.h b/libraries/embedded-webserver/src/HttpConnection.h
index c791a93a07..23f210218f 100755
--- a/libraries/embedded-webserver/src/HttpConnection.h
+++ b/libraries/embedded-webserver/src/HttpConnection.h
@@ -7,7 +7,7 @@
 //
 //  Heavily based on Andrzej Kapolka's original HttpConnection class
 //  found from another one of his projects.
-//  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
+//  https://github.com/ey6es/witgap/tree/master/src/cpp/server/http
 //
 
 #ifndef __hifi__HttpConnection__
@@ -38,6 +38,9 @@ class HttpConnection : public QObject {
    Q_OBJECT
 
 public:
+    static const char* StatusCode200;
+    static const char* StatusCode400;
+    static const char* StatusCode404;
 
     /// WebSocket close status codes.
     enum ReasonCode { NoReason = 0, NormalClosure = 1000, GoingAway = 1001 };
diff --git a/libraries/embedded-webserver/src/HttpManager.cpp b/libraries/embedded-webserver/src/HttpManager.cpp
index 07dd376c8a..58c6574db9 100755
--- a/libraries/embedded-webserver/src/HttpManager.cpp
+++ b/libraries/embedded-webserver/src/HttpManager.cpp
@@ -5,10 +5,6 @@
 //  Created by Stephen Birarda on 1/16/14.
 //  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
 //
-//  Heavily based on Andrzej Kapolka's original HttpManager class
-//  found from another one of his projects.
-//  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
-//
 
 #include <QtCore/QDebug>
 #include <QtCore/QFile>
@@ -19,7 +15,15 @@
 #include "HttpConnection.h"
 #include "HttpManager.h"
 
-bool HttpManager::handleRequest(HttpConnection* connection, const QString& path) {
+bool HttpManager::handleHTTPRequest(HttpConnection* connection, const QString& path) {
+    if (_requestHandler && _requestHandler->handleHTTPRequest(connection, path)) {
+        // this request was handled by our _requestHandler object
+        // so we don't need to attempt to do so in the document root
+        return true;
+    }
+    
+    // check to see if there is a file to serve from the document root for this path
+    
     QString subPath = path;
     
     // remove any slash at the beginning of the path
@@ -45,6 +49,8 @@ bool HttpManager::handleRequest(HttpConnection* connection, const QString& path)
 
     
     if (!filePath.isEmpty()) {
+        // file exists, serve it
+
         static QMimeDatabase mimeDatabase;
         
         QFile localFile(filePath);
@@ -93,18 +99,20 @@ bool HttpManager::handleRequest(HttpConnection* connection, const QString& path)
             }
         }
         
-        connection->respond("200 OK", localFileString.toLocal8Bit(), qPrintable(mimeDatabase.mimeTypeForFile(filePath).name()));
+        connection->respond(HttpConnection::StatusCode200, localFileString.toLocal8Bit(), qPrintable(mimeDatabase.mimeTypeForFile(filePath).name()));
     } else {
         // respond with a 404
-        connection->respond("404 Not Found", "Resource not found.");
+        connection->respond(HttpConnection::StatusCode404, "Resource not found.");
     }
     
     return true;
 }
 
-HttpManager::HttpManager(quint16 port, const QString& documentRoot, QObject* parent) :
+HttpManager::HttpManager(quint16 port, const QString& documentRoot, HttpRequestHandler* requestHandler, QObject* parent) :
     QTcpServer(parent),
-    _documentRoot(documentRoot) {
+    _documentRoot(documentRoot),
+    _requestHandler(requestHandler)
+{
     // start listening on the passed port
     if (!listen(QHostAddress("0.0.0.0"), port)) {
         qDebug() << "Failed to open HTTP server socket:" << errorString();
diff --git a/libraries/embedded-webserver/src/HttpManager.h b/libraries/embedded-webserver/src/HttpManager.h
index 1c5cb7ee65..80a2c5ba2c 100755
--- a/libraries/embedded-webserver/src/HttpManager.h
+++ b/libraries/embedded-webserver/src/HttpManager.h
@@ -7,36 +7,37 @@
 //
 //  Heavily based on Andrzej Kapolka's original HttpManager class
 //  found from another one of his projects.
-//  (https://github.com/ey6es/witgap/tree/master/src/cpp/server/http)
+//  https://github.com/ey6es/witgap/tree/master/src/cpp/server/http
 //
 
 #ifndef __hifi__HttpManager__
 #define __hifi__HttpManager__
 
-#include <QByteArray>
-#include <QHash>
 #include <QtNetwork/QTcpServer>
 
 class HttpConnection;
-class HttpRequestHandler;
+
+class HttpRequestHandler {
+public:
+    /// Handles an HTTP request.
+    virtual bool handleHTTPRequest(HttpConnection* connection, const QString& path) = 0;
+};
 
 /// Handles HTTP connections
-class HttpManager : public QTcpServer {
+class HttpManager : public QTcpServer, public HttpRequestHandler {
    Q_OBJECT
-
 public:
-
     /// Initializes the manager.
-    HttpManager(quint16 port, const QString& documentRoot, QObject* parent = 0);
+    HttpManager(quint16 port, const QString& documentRoot, HttpRequestHandler* requestHandler = NULL, QObject* parent = 0);
     
-    /// Handles an HTTP request.
-    virtual bool handleRequest (HttpConnection* connection, const QString& path);
+    bool handleHTTPRequest(HttpConnection* connection, const QString& path);
     
 protected slots:
     /// Accepts all pending connections
     void acceptConnections();
 protected:
     QString _documentRoot;
+    HttpRequestHandler* _requestHandler;
 };
 
 #endif /* defined(__hifi__HttpManager__) */

From 58b426590ff45be4b4b306ad3104529450f54c09 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 11:38:24 -0800
Subject: [PATCH 08/18] make sure boundary in script upload is followed by new
 line

---
 domain-server/resources/web/assignment/js/assignment.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/domain-server/resources/web/assignment/js/assignment.js b/domain-server/resources/web/assignment/js/assignment.js
index a34f539961..a04c8192f4 100644
--- a/domain-server/resources/web/assignment/js/assignment.js
+++ b/domain-server/resources/web/assignment/js/assignment.js
@@ -19,7 +19,7 @@ $(document).ready(function(){
       + 'Content-type: application/javascript\r\n\r\n'
       // add the script
       + script + '\r\n'
-      + '--' + boundary + '--';
+      + '--' + boundary + '--\r\n';
       
     var headers = {};
     if ($('#instance-field input').val()) {

From ce393fdf27be0a6100777b47c99f90c17006adeb Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 11:53:47 -0800
Subject: [PATCH 09/18] uppercase the names of the HTTP classes

---
 domain-server/src/DomainServer.cpp            | 16 ++++++------
 domain-server/src/DomainServer.h              |  6 ++---
 ...{HttpConnection.cpp => HTTPConnection.cpp} | 26 +++++++++----------
 .../{HttpConnection.h => HTTPConnection.h}    | 20 +++++++-------
 .../src/{HttpManager.cpp => HTTPManager.cpp}  | 18 ++++++-------
 .../src/{HttpManager.h => HTTPManager.h}      | 20 +++++++-------
 6 files changed, 53 insertions(+), 53 deletions(-)
 rename libraries/embedded-webserver/src/{HttpConnection.cpp => HTTPConnection.cpp} (91%)
 rename libraries/embedded-webserver/src/{HttpConnection.h => HTTPConnection.h} (87%)
 mode change 100755 => 100644
 rename libraries/embedded-webserver/src/{HttpManager.cpp => HTTPManager.cpp} (91%)
 rename libraries/embedded-webserver/src/{HttpManager.h => HTTPManager.h} (60%)

diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index 4d15a98b33..c1be563672 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -13,7 +13,7 @@
 #include <QtCore/QStringList>
 #include <QtCore/QTimer>
 
-#include <HttpConnection.h>
+#include <HTTPConnection.h>
 #include <PacketHeaders.h>
 #include <SharedUtil.h>
 #include <UUID.h>
@@ -34,7 +34,7 @@ const quint16 DOMAIN_SERVER_HTTP_PORT = 8080;
 
 DomainServer::DomainServer(int argc, char* argv[]) :
     QCoreApplication(argc, argv),
-    _httpManager(DOMAIN_SERVER_HTTP_PORT, QString("%1/resources/web/").arg(QCoreApplication::applicationDirPath()), this),
+    _HTTPManager(DOMAIN_SERVER_HTTP_PORT, QString("%1/resources/web/").arg(QCoreApplication::applicationDirPath()), this),
     _assignmentQueueMutex(),
     _assignmentQueue(),
     _staticAssignmentFile(QString("%1/config.ds").arg(QCoreApplication::applicationDirPath())),
@@ -294,7 +294,7 @@ QJsonObject jsonObjectForNode(Node* node) {
     return nodeJson;
 }
 
-bool DomainServer::handleHTTPRequest(HttpConnection* connection, const QString& path) {
+bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString& path) {
     const QString JSON_MIME_TYPE = "application/json";
     
     const QString URI_ASSIGNMENT = "/assignment";
@@ -346,7 +346,7 @@ bool DomainServer::handleHTTPRequest(HttpConnection* connection, const QString&
             
             // print out the created JSON
             QJsonDocument assignmentDocument(assignmentJSON);
-            connection->respond(HttpConnection::StatusCode200, assignmentDocument.toJson(), qPrintable(JSON_MIME_TYPE));
+            connection->respond(HTTPConnection::StatusCode200, assignmentDocument.toJson(), qPrintable(JSON_MIME_TYPE));
             
             // we've processed this request
             return true;
@@ -370,11 +370,11 @@ bool DomainServer::handleHTTPRequest(HttpConnection* connection, const QString&
             QJsonDocument nodesDocument(rootJSON);
             
             // send the response
-            connection->respond(HttpConnection::StatusCode200, nodesDocument.toJson(), qPrintable(JSON_MIME_TYPE));
+            connection->respond(HTTPConnection::StatusCode200, nodesDocument.toJson(), qPrintable(JSON_MIME_TYPE));
         }
     } else if (connection->requestOperation() == QNetworkAccessManager::PostOperation) {
         if (path == URI_ASSIGNMENT) {
-            // this is a script upload - ask the HttpConnection to parse the form data
+            // this is a script upload - ask the HTTPConnection to parse the form data
             QList<FormData> formData = connection->parseFormData();
             qDebug() << formData;
         }
@@ -390,7 +390,7 @@ bool DomainServer::handleHTTPRequest(HttpConnection* connection, const QString&
                 
                 if (nodeToKill) {
                     // start with a 200 response
-                    connection->respond(HttpConnection::StatusCode200);
+                    connection->respond(HTTPConnection::StatusCode200);
                     
                     // we have a valid UUID and node - kill the node that has this assignment
                     QMetaObject::invokeMethod(NodeList::getInstance(), "killNodeWithUUID", Q_ARG(const QUuid&, deleteUUID));
@@ -401,7 +401,7 @@ bool DomainServer::handleHTTPRequest(HttpConnection* connection, const QString&
             }
             
             // bad request, couldn't pull a node ID
-            connection->respond(HttpConnection::StatusCode400);
+            connection->respond(HTTPConnection::StatusCode400);
             
             return true;
         }
diff --git a/domain-server/src/DomainServer.h b/domain-server/src/DomainServer.h
index 96a33eb267..17f0904e21 100644
--- a/domain-server/src/DomainServer.h
+++ b/domain-server/src/DomainServer.h
@@ -16,7 +16,7 @@
 #include <QtCore/QMutex>
 
 #include <Assignment.h>
-#include <HttpManager.h>
+#include <HTTPManager.h>
 #include <NodeList.h>
 
 const int MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS = 1000;
@@ -26,7 +26,7 @@ class DomainServer : public QCoreApplication, public HttpRequestHandler {
 public:
     DomainServer(int argc, char* argv[]);
     
-    bool handleHTTPRequest(HttpConnection* connection, const QString& path);
+    bool handleHTTPRequest(HTTPConnection* connection, const QString& path);
     
     void exit(int retCode = 0);
 
@@ -50,7 +50,7 @@ private:
     
     unsigned char* addNodeToBroadcastPacket(unsigned char* currentPosition, Node* nodeToAdd);
     
-    HttpManager _httpManager;
+    HTTPManager _HTTPManager;
     
     QMutex _assignmentQueueMutex;
     std::deque<Assignment*> _assignmentQueue;
diff --git a/libraries/embedded-webserver/src/HttpConnection.cpp b/libraries/embedded-webserver/src/HTTPConnection.cpp
similarity index 91%
rename from libraries/embedded-webserver/src/HttpConnection.cpp
rename to libraries/embedded-webserver/src/HTTPConnection.cpp
index 0ea14ea82b..3ffc96c9f4 100755
--- a/libraries/embedded-webserver/src/HttpConnection.cpp
+++ b/libraries/embedded-webserver/src/HTTPConnection.cpp
@@ -1,5 +1,5 @@
 //
-//  HttpConnection.cpp
+//  HTTPConnection.cpp
 //  hifi
 //
 //  Created by Stephen Birarda on 1/16/14.
@@ -11,14 +11,14 @@
 #include <QCryptographicHash>
 #include <QTcpSocket>
 
-#include "HttpConnection.h"
-#include "HttpManager.h"
+#include "HTTPConnection.h"
+#include "HTTPManager.h"
 
-const char* HttpConnection::StatusCode200 = "200 OK";
-const char* HttpConnection::StatusCode400 = "400 Bad Request";
-const char* HttpConnection::StatusCode404 = "404 Not Found";
+const char* HTTPConnection::StatusCode200 = "200 OK";
+const char* HTTPConnection::StatusCode400 = "400 Bad Request";
+const char* HTTPConnection::StatusCode404 = "404 Not Found";
 
-HttpConnection::HttpConnection (QTcpSocket* socket, HttpManager* parentManager) :
+HTTPConnection::HTTPConnection (QTcpSocket* socket, HTTPManager* parentManager) :
     QObject(parentManager),
     _parentManager(parentManager),
     _socket(socket),
@@ -34,14 +34,14 @@ HttpConnection::HttpConnection (QTcpSocket* socket, HttpManager* parentManager)
     connect(socket, SIGNAL(disconnected()), SLOT(deleteLater()));
 }
 
-HttpConnection::~HttpConnection() {
+HTTPConnection::~HTTPConnection() {
     // log the destruction
     if (_socket->error() != QAbstractSocket::UnknownSocketError) {
         qDebug() << _socket->errorString();
     }
 }
 
-QList<FormData> HttpConnection::parseFormData() const {
+QList<FormData> HTTPConnection::parseFormData() const {
     // make sure we have the correct MIME type
     QList<QByteArray> elements = _requestHeaders.value("Content-Type").split(';');
     if (elements.at(0).trimmed() != "multipart/form-data") {
@@ -97,7 +97,7 @@ QList<FormData> HttpConnection::parseFormData() const {
     return data;
 }
 
-void HttpConnection::respond(const char* code, const QByteArray& content, const char* contentType, const Headers& headers) {
+void HTTPConnection::respond(const char* code, const QByteArray& content, const char* contentType, const Headers& headers) {
     _socket->write("HTTP/1.1 ");
     _socket->write(code);
     _socket->write("\r\n");
@@ -132,7 +132,7 @@ void HttpConnection::respond(const char* code, const QByteArray& content, const
     _socket->disconnectFromHost();
 }
 
-void HttpConnection::readRequest() {
+void HTTPConnection::readRequest() {
     if (!_socket->canReadLine()) {
         return;
     }
@@ -169,7 +169,7 @@ void HttpConnection::readRequest() {
     readHeaders();
 }
 
-void HttpConnection::readHeaders() {
+void HTTPConnection::readHeaders() {
     while (_socket->canReadLine()) {
         QByteArray line = _socket->readLine();
         QByteArray trimmed = line.trimmed();
@@ -209,7 +209,7 @@ void HttpConnection::readHeaders() {
     }
 }
 
-void HttpConnection::readContent() {
+void HTTPConnection::readContent() {
     int size = _requestContent.size();
     if (_socket->bytesAvailable() < size) {
         return;
diff --git a/libraries/embedded-webserver/src/HttpConnection.h b/libraries/embedded-webserver/src/HTTPConnection.h
old mode 100755
new mode 100644
similarity index 87%
rename from libraries/embedded-webserver/src/HttpConnection.h
rename to libraries/embedded-webserver/src/HTTPConnection.h
index 23f210218f..80e470ece1
--- a/libraries/embedded-webserver/src/HttpConnection.h
+++ b/libraries/embedded-webserver/src/HTTPConnection.h
@@ -1,17 +1,17 @@
 //
-//  HttpConnection.h
+//  HTTPConnection.h
 //  hifi
 //
 //  Created by Stephen Birarda on 1/16/14.
 //  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
 //
-//  Heavily based on Andrzej Kapolka's original HttpConnection class
+//  Heavily based on Andrzej Kapolka's original HTTPConnection class
 //  found from another one of his projects.
 //  https://github.com/ey6es/witgap/tree/master/src/cpp/server/http
 //
 
-#ifndef __hifi__HttpConnection__
-#define __hifi__HttpConnection__
+#ifndef __hifi__HTTPConnection__
+#define __hifi__HTTPConnection__
 
 #include <QHash>
 #include <QHostAddress>
@@ -23,7 +23,7 @@
 #include <QUrl>
 
 class QTcpSocket;
-class HttpManager;
+class HTTPManager;
 class MaskFilter;
 class ServerApp;
 
@@ -34,7 +34,7 @@ typedef QHash<QByteArray, QByteArray> Headers;
 typedef QPair<Headers, QByteArray> FormData;
 
 /// Handles a single HTTP connection.
-class HttpConnection : public QObject {
+class HTTPConnection : public QObject {
    Q_OBJECT
 
 public:
@@ -46,10 +46,10 @@ public:
     enum ReasonCode { NoReason = 0, NormalClosure = 1000, GoingAway = 1001 };
 
     /// Initializes the connection.
-    HttpConnection (QTcpSocket* socket, HttpManager* parentManager);
+    HTTPConnection (QTcpSocket* socket, HTTPManager* parentManager);
 
     /// Destroys the connection.
-    virtual ~HttpConnection ();
+    virtual ~HTTPConnection ();
 
     /// Returns a pointer to the underlying socket, to which WebSocket message bodies should be written.
     QTcpSocket* socket () const { return _socket; }
@@ -88,7 +88,7 @@ protected slots:
 protected:
 
     /// The parent HTTP manager
-    HttpManager* _parentManager;
+    HTTPManager* _parentManager;
 
     /// The underlying socket.
     QTcpSocket* _socket;
@@ -115,4 +115,4 @@ protected:
     QByteArray _requestContent;
 };
 
-#endif /* defined(__hifi__HttpConnection__) */
+#endif /* defined(__hifi__HTTPConnection__) */
diff --git a/libraries/embedded-webserver/src/HttpManager.cpp b/libraries/embedded-webserver/src/HTTPManager.cpp
similarity index 91%
rename from libraries/embedded-webserver/src/HttpManager.cpp
rename to libraries/embedded-webserver/src/HTTPManager.cpp
index 58c6574db9..89712d825c 100755
--- a/libraries/embedded-webserver/src/HttpManager.cpp
+++ b/libraries/embedded-webserver/src/HTTPManager.cpp
@@ -1,5 +1,5 @@
 //
-//  HttpManager.cpp
+//  HTTPManager.cpp
 //  hifi
 //
 //  Created by Stephen Birarda on 1/16/14.
@@ -12,10 +12,10 @@
 #include <QtCore/QMimeDatabase>
 #include <QtNetwork/QTcpSocket>
 
-#include "HttpConnection.h"
-#include "HttpManager.h"
+#include "HTTPConnection.h"
+#include "HTTPManager.h"
 
-bool HttpManager::handleHTTPRequest(HttpConnection* connection, const QString& path) {
+bool HTTPManager::handleHTTPRequest(HTTPConnection* connection, const QString& path) {
     if (_requestHandler && _requestHandler->handleHTTPRequest(connection, path)) {
         // this request was handled by our _requestHandler object
         // so we don't need to attempt to do so in the document root
@@ -99,16 +99,16 @@ bool HttpManager::handleHTTPRequest(HttpConnection* connection, const QString& p
             }
         }
         
-        connection->respond(HttpConnection::StatusCode200, localFileString.toLocal8Bit(), qPrintable(mimeDatabase.mimeTypeForFile(filePath).name()));
+        connection->respond(HTTPConnection::StatusCode200, localFileString.toLocal8Bit(), qPrintable(mimeDatabase.mimeTypeForFile(filePath).name()));
     } else {
         // respond with a 404
-        connection->respond(HttpConnection::StatusCode404, "Resource not found.");
+        connection->respond(HTTPConnection::StatusCode404, "Resource not found.");
     }
     
     return true;
 }
 
-HttpManager::HttpManager(quint16 port, const QString& documentRoot, HttpRequestHandler* requestHandler, QObject* parent) :
+HTTPManager::HTTPManager(quint16 port, const QString& documentRoot, HttpRequestHandler* requestHandler, QObject* parent) :
     QTcpServer(parent),
     _documentRoot(documentRoot),
     _requestHandler(requestHandler)
@@ -123,9 +123,9 @@ HttpManager::HttpManager(quint16 port, const QString& documentRoot, HttpRequestH
     connect(this, SIGNAL(newConnection()), SLOT(acceptConnections()));
 }
 
-void HttpManager::acceptConnections() {
+void HTTPManager::acceptConnections() {
     QTcpSocket* socket;
     while ((socket = nextPendingConnection()) != 0) {
-        new HttpConnection(socket, this);
+        new HTTPConnection(socket, this);
     }
 }
diff --git a/libraries/embedded-webserver/src/HttpManager.h b/libraries/embedded-webserver/src/HTTPManager.h
similarity index 60%
rename from libraries/embedded-webserver/src/HttpManager.h
rename to libraries/embedded-webserver/src/HTTPManager.h
index 80a2c5ba2c..fdb7e1e915 100755
--- a/libraries/embedded-webserver/src/HttpManager.h
+++ b/libraries/embedded-webserver/src/HTTPManager.h
@@ -1,36 +1,36 @@
 //
-//  HttpManager.h
+//  HTTPManager.h
 //  hifi
 //
 //  Created by Stephen Birarda on 1/16/14.
 //  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
 //
-//  Heavily based on Andrzej Kapolka's original HttpManager class
+//  Heavily based on Andrzej Kapolka's original HTTPManager class
 //  found from another one of his projects.
 //  https://github.com/ey6es/witgap/tree/master/src/cpp/server/http
 //
 
-#ifndef __hifi__HttpManager__
-#define __hifi__HttpManager__
+#ifndef __hifi__HTTPManager__
+#define __hifi__HTTPManager__
 
 #include <QtNetwork/QTcpServer>
 
-class HttpConnection;
+class HTTPConnection;
 
 class HttpRequestHandler {
 public:
     /// Handles an HTTP request.
-    virtual bool handleHTTPRequest(HttpConnection* connection, const QString& path) = 0;
+    virtual bool handleHTTPRequest(HTTPConnection* connection, const QString& path) = 0;
 };
 
 /// Handles HTTP connections
-class HttpManager : public QTcpServer, public HttpRequestHandler {
+class HTTPManager : public QTcpServer, public HttpRequestHandler {
    Q_OBJECT
 public:
     /// Initializes the manager.
-    HttpManager(quint16 port, const QString& documentRoot, HttpRequestHandler* requestHandler = NULL, QObject* parent = 0);
+    HTTPManager(quint16 port, const QString& documentRoot, HttpRequestHandler* requestHandler = NULL, QObject* parent = 0);
     
-    bool handleHTTPRequest(HttpConnection* connection, const QString& path);
+    bool handleHTTPRequest(HTTPConnection* connection, const QString& path);
     
 protected slots:
     /// Accepts all pending connections
@@ -40,4 +40,4 @@ protected:
     HttpRequestHandler* _requestHandler;
 };
 
-#endif /* defined(__hifi__HttpManager__) */
+#endif /* defined(__hifi__HTTPManager__) */

From 0f8cbb9aecc90c94011e4b4f72f472de558abb5f Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 12:16:19 -0800
Subject: [PATCH 10/18] add back script upload ability hooked to HttpManager

---
 domain-server/src/DomainServer.cpp | 44 +++++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index c1be563672..73c3669b70 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -376,7 +376,49 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
         if (path == URI_ASSIGNMENT) {
             // this is a script upload - ask the HTTPConnection to parse the form data
             QList<FormData> formData = connection->parseFormData();
-            qDebug() << formData;
+            
+            // create an assignment for this saved script, for now make it local only
+            Assignment* scriptAssignment = new Assignment(Assignment::CreateCommand,
+                                                          Assignment::AgentType,
+                                                          NULL,
+                                                          Assignment::LocalLocation);
+            
+            // check how many instances of this assignment the user wants by checking the ASSIGNMENT-INSTANCES header
+            const QString ASSIGNMENT_INSTANCES_HEADER = "ASSIGNMENT-INSTANCES";
+            
+            QByteArray assignmentInstancesValue = connection->requestHeaders().value(ASSIGNMENT_INSTANCES_HEADER.toLocal8Bit());
+            if (!assignmentInstancesValue.isEmpty()) {
+                // the user has requested a specific number of instances
+                // so set that on the created assignment
+                int numInstances = assignmentInstancesValue.toInt();
+                if (numInstances > 0) {
+                    qDebug() << numInstances;
+                    scriptAssignment->setNumberOfInstances(numInstances);
+                }
+            }
+            
+            const char ASSIGNMENT_SCRIPT_HOST_LOCATION[] = "resources/web/assignment";
+            
+            QString newPath(ASSIGNMENT_SCRIPT_HOST_LOCATION);
+            newPath += "/";
+            // append the UUID for this script as the new filename, remove the curly braces
+            newPath += uuidStringWithoutCurlyBraces(scriptAssignment->getUUID());
+            
+            // create a file with the GUID of the assignment in the script host locaiton
+            QFile scriptFile(newPath);
+            scriptFile.open(QIODevice::WriteOnly);
+            scriptFile.write(formData[0].second);
+            
+            qDebug("Saved a script for assignment at %s", qPrintable(newPath));
+            
+            // respond with a 200 code for successful upload
+            connection->respond(HTTPConnection::StatusCode200);
+            
+            // add the script assigment to the assignment queue
+            // lock the assignment queue mutex since we're operating on a different thread than DS main
+            _assignmentQueueMutex.lock();
+            _assignmentQueue.push_back(scriptAssignment);
+            _assignmentQueueMutex.unlock();
         }
     } else if (connection->requestOperation() == QNetworkAccessManager::DeleteOperation) {
         if (path.startsWith(URI_NODE)) {

From 1900d3a13b7485ab24e80ea91540831c34b54e37 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 12:16:56 -0800
Subject: [PATCH 11/18] remove the old civetweb upload handler

---
 domain-server/src/DomainServer.cpp | 37 ------------------------------
 1 file changed, 37 deletions(-)

diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index 73c3669b70..ed0796af65 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -453,43 +453,6 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
     return false;
 }
 
-const char ASSIGNMENT_SCRIPT_HOST_LOCATION[] = "resources/web/assignment";
-
-//void DomainServer::civetwebUploadHandler(struct mg_connection *connection, const char *path) {
-//
-//    // create an assignment for this saved script, for now make it local only
-//    Assignment* scriptAssignment = new Assignment(Assignment::CreateCommand,
-//                                                  Assignment::AgentType,
-//                                                  NULL,
-//                                                  Assignment::LocalLocation);
-//
-//    // check how many instances of this assignment the user wants by checking the ASSIGNMENT-INSTANCES header
-//    const char ASSIGNMENT_INSTANCES_HTTP_HEADER[] = "ASSIGNMENT-INSTANCES";
-//    const char* requestInstancesHeader = mg_get_header(connection, ASSIGNMENT_INSTANCES_HTTP_HEADER);
-//
-//    if (requestInstancesHeader) {
-//        // the user has requested a number of instances greater than 1
-//        // so set that on the created assignment
-//        scriptAssignment->setNumberOfInstances(atoi(requestInstancesHeader));
-//    }
-//
-//    QString newPath(ASSIGNMENT_SCRIPT_HOST_LOCATION);
-//    newPath += "/";
-//    // append the UUID for this script as the new filename, remove the curly braces
-//    newPath += uuidStringWithoutCurlyBraces(scriptAssignment->getUUID());
-//
-//    // rename the saved script to the GUID of the assignment and move it to the script host locaiton
-//    rename(path, newPath.toLocal8Bit().constData());
-//
-//    qDebug("Saved a script for assignment at %s", newPath.toLocal8Bit().constData());
-//
-//    // add the script assigment to the assignment queue
-//    // lock the assignment queue mutex since we're operating on a different thread than DS main
-//    domainServerInstance->_assignmentQueueMutex.lock();
-//    domainServerInstance->_assignmentQueue.push_back(scriptAssignment);
-//    domainServerInstance->_assignmentQueueMutex.unlock();
-//}
-
 void DomainServer::addReleasedAssignmentBackToQueue(Assignment* releasedAssignment) {
     qDebug() << "Adding assignment" << *releasedAssignment << " back to queue.";
 

From ffb628edfb3538c6edab4bfb158bd2fbdd3429e4 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 12:18:41 -0800
Subject: [PATCH 12/18] remove the DomainServer singleton instance from DS

---
 domain-server/src/DomainServer.cpp | 12 ++----------
 domain-server/src/DomainServer.h   |  6 +-----
 2 files changed, 3 insertions(+), 15 deletions(-)

diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index ed0796af65..5db1c668fe 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -28,8 +28,6 @@ void signalhandler(int sig){
     }
 }
 
-DomainServer* DomainServer::domainServerInstance = NULL;
-
 const quint16 DOMAIN_SERVER_HTTP_PORT = 8080;
 
 DomainServer::DomainServer(int argc, char* argv[]) :
@@ -43,8 +41,6 @@ DomainServer::DomainServer(int argc, char* argv[]) :
     _metavoxelServerConfig(NULL),
     _hasCompletedRestartHold(false)
 {
-    DomainServer::setDomainServerInstance(this);
-
     signal(SIGINT, signalhandler);
 
     const char CUSTOM_PORT_OPTION[] = "-p";
@@ -253,10 +249,6 @@ void DomainServer::readAvailableDatagrams() {
     }
 }
 
-void DomainServer::setDomainServerInstance(DomainServer* domainServer) {
-    domainServerInstance = domainServer;
-}
-
 QJsonObject jsonForSocket(const HifiSockAddr& socket) {
     QJsonObject socketJSON;
 
@@ -322,9 +314,9 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
             QJsonObject queuedAssignmentsJSON;
             
             // add the queued but unfilled assignments to the json
-            std::deque<Assignment*>::iterator assignment = domainServerInstance->_assignmentQueue.begin();
+            std::deque<Assignment*>::iterator assignment = _assignmentQueue.begin();
             
-            while (assignment != domainServerInstance->_assignmentQueue.end()) {
+            while (assignment != _assignmentQueue.end()) {
                 QJsonObject queuedAssignmentJSON;
                 
                 QString uuidString = uuidStringWithoutCurlyBraces((*assignment)->getUUID());
diff --git a/domain-server/src/DomainServer.h b/domain-server/src/DomainServer.h
index 17f0904e21..e608f9ea00 100644
--- a/domain-server/src/DomainServer.h
+++ b/domain-server/src/DomainServer.h
@@ -29,16 +29,12 @@ public:
     bool handleHTTPRequest(HTTPConnection* connection, const QString& path);
     
     void exit(int retCode = 0);
-
-    static void setDomainServerInstance(DomainServer* domainServer);
     
 public slots:
     /// Called by NodeList to inform us that a node has been killed.
     void nodeKilled(SharedNodePointer node);
     
-private:    
-    static DomainServer* domainServerInstance;
-    
+private:
     void prepopulateStaticAssignmentFile();
     Assignment* matchingStaticAssignmentForCheckIn(const QUuid& checkInUUID, NODE_TYPE nodeType);
     Assignment* deployableAssignmentForRequest(Assignment& requestAssignment);

From 5fdf310a45e09430e35047ef518d0476fc213458 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 14:21:15 -0800
Subject: [PATCH 13/18] hook OctreeServer up to embedded-webserver

---
 assignment-client/CMakeLists.txt              |    2 -
 domain-server/src/DomainServer.cpp            |   11 -
 domain-server/src/DomainServer.h              |    2 +-
 externals/civetweb/LICENSE.md                 |   98 -
 externals/civetweb/include/civetweb.h         |  488 --
 externals/civetweb/include/md5.inl            |  461 --
 externals/civetweb/src/civetweb.c             | 6273 -----------------
 .../embedded-webserver/src/HTTPManager.cpp    |    2 +-
 .../embedded-webserver/src/HTTPManager.h      |    8 +-
 libraries/octree-server/CMakeLists.txt        |   11 +-
 libraries/octree-server/src/OctreeServer.cpp  |  526 +-
 libraries/octree-server/src/OctreeServer.h    |   20 +-
 12 files changed, 275 insertions(+), 7627 deletions(-)
 delete mode 100755 externals/civetweb/LICENSE.md
 delete mode 100755 externals/civetweb/include/civetweb.h
 delete mode 100755 externals/civetweb/include/md5.inl
 delete mode 100755 externals/civetweb/src/civetweb.c

diff --git a/assignment-client/CMakeLists.txt b/assignment-client/CMakeLists.txt
index ef786a58c8..5b46d43f05 100644
--- a/assignment-client/CMakeLists.txt
+++ b/assignment-client/CMakeLists.txt
@@ -36,8 +36,6 @@ link_hifi_library(voxel-server ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(script-engine ${TARGET_NAME} ${ROOT_DIR})
 #testing
 
-include_directories(${ROOT_DIR}/externals/civetweb/include)
-
 if (UNIX)
   target_link_libraries(${TARGET_NAME} ${CMAKE_DL_LIBS})
 endif (UNIX)
diff --git a/domain-server/src/DomainServer.cpp b/domain-server/src/DomainServer.cpp
index 5db1c668fe..28edf6b6a1 100644
--- a/domain-server/src/DomainServer.cpp
+++ b/domain-server/src/DomainServer.cpp
@@ -58,17 +58,6 @@ DomainServer::DomainServer(int argc, char* argv[]) :
     const char METAVOXEL_CONFIG_OPTION[] = "--metavoxelServerConfig";
     _metavoxelServerConfig = getCmdOption(argc, (const char**)argv, METAVOXEL_CONFIG_OPTION);
     
-//
-//    char* documentRoot = new char[documentRootString.size() + 1];
-//    strcpy(documentRoot, documentRootString.toLocal8Bit().constData());
-//
-//    // list of options. Last element must be NULL.
-//    const char* options[] = {"listening_ports", "8080",
-//        "document_root", documentRoot, NULL};
-//
-//    callbacks.begin_request = civetwebRequestHandler;
-//    callbacks.upload = civetwebUploadHandler;
-
     connect(nodeList, SIGNAL(nodeKilled(SharedNodePointer)), this, SLOT(nodeKilled(SharedNodePointer)));
 
     if (!_staticAssignmentFile.exists() || _voxelServerConfig) {
diff --git a/domain-server/src/DomainServer.h b/domain-server/src/DomainServer.h
index e608f9ea00..c9c4f0e2d7 100644
--- a/domain-server/src/DomainServer.h
+++ b/domain-server/src/DomainServer.h
@@ -21,7 +21,7 @@
 
 const int MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS = 1000;
 
-class DomainServer : public QCoreApplication, public HttpRequestHandler {
+class DomainServer : public QCoreApplication, public HTTPRequestHandler {
     Q_OBJECT
 public:
     DomainServer(int argc, char* argv[]);
diff --git a/externals/civetweb/LICENSE.md b/externals/civetweb/LICENSE.md
deleted file mode 100755
index 043f21222a..0000000000
--- a/externals/civetweb/LICENSE.md
+++ /dev/null
@@ -1,98 +0,0 @@
-ALL LICENSES
-=====
-
-This document includes several copyright licenses for different
-aspects of the software.  Not all licenses may apply depending
-on the features chosen.
-
-Civetweb License
------
-
-### Included with all features.
-
-> Copyright (c) 2004-2013 Sergey Lyubka
->
-> Copyright (c) 2013 No Face Press, LLC (Thomas Davis)
->
-> Copyright (c) 2013 F-Secure Corporation
->
-> Permission is hereby granted, free of charge, to any person obtaining a copy
-> of this software and associated documentation files (the "Software"), to deal
-> in the Software without restriction, including without limitation the rights
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-> copies of the Software, and to permit persons to whom the Software is
-> furnished to do so, subject to the following conditions:
-> 
-> The above copyright notice and this permission notice shall be included in
-> all copies or substantial portions of the Software.
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-> THE SOFTWARE.
-
-Lua License
-------
-
-### Included only if built with Lua support.
-
-http://www.lua.org/license.html
-
-> Copyright � 1994-2013 Lua.org, PUC-Rio.
-> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
->
-> The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-SQLite3 License
-------
-
-### Included only if built with Lua support.
-
-http://www.sqlite.org/copyright.html
-
-> 2001 September 15
->
-> The author disclaims copyright to this source code.  In place of
-> a legal notice, here is a blessing:
->
->    May you do good and not evil.
->    May you find forgiveness for yourself and forgive others.
->    May you share freely, never taking more than you give.
-
-lsqlite3 License
-------
-
-### Included only if built with Lua support.
-
-> lsqlite3                                                              
-> Copyright (C) 2002-2007 Tiago Dionizio, Doug Currie                   
-> All rights reserved.                                                  
-> Author    : Tiago Dionizio <tiago.dionizio@ist.utl.pt>                
-> Author    : Doug Currie <doug.currie@alum.mit.edu>                    
-> Library   : lsqlite3 - a SQLite 3 database binding for Lua 5          
->                                                                      
-> Permission is hereby granted, free of charge, to any person obtaining 
-> a copy of this software and associated documentation files (the       
-> "Software"), to deal in the Software without restriction, including   
-> without limitation the rights to use, copy, modify, merge, publish,   
-> distribute, sublicense, and/or sell copies of the Software, and to    
-> permit persons to whom the Software is furnished to do so, subject to 
-> the following conditions:                                             
->                                                                      
-> The above copyright notice and this permission notice shall be        
-> included in all copies or substantial portions of the Software.       
->                                                                      
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       
-> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    
-> MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-> IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  
-> CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  
-> TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     
-> SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                
-
diff --git a/externals/civetweb/include/civetweb.h b/externals/civetweb/include/civetweb.h
deleted file mode 100755
index 22caa2a030..0000000000
--- a/externals/civetweb/include/civetweb.h
+++ /dev/null
@@ -1,488 +0,0 @@
-/* Copyright (c) 2004-2013 Sergey Lyubka
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#ifndef CIVETWEB_HEADER_INCLUDED
-#define CIVETWEB_HEADER_INCLUDED
-
-#ifndef CIVETWEB_VERSION
-#define CIVETWEB_VERSION "1.6"
-#endif
-
-#include <stdio.h>
-#include <stddef.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-struct mg_context;     /* Handle for the HTTP service itself */
-struct mg_connection;  /* Handle for the individual connection */
-
-
-/* This structure contains information about the HTTP request. */
-struct mg_request_info {
-    const char *request_method; /* "GET", "POST", etc */
-    const char *uri;            /* URL-decoded URI */
-    const char *http_version;   /* E.g. "1.0", "1.1" */
-    const char *query_string;   /* URL part after '?', not including '?', or
-                                   NULL */
-    const char *remote_user;    /* Authenticated user, or NULL if no auth
-                                   used */
-    long remote_ip;             /* Client's IP address */
-    int remote_port;            /* Client's port */
-    int is_ssl;                 /* 1 if SSL-ed, 0 if not */
-    void *user_data;            /* User data pointer passed to mg_start() */
-    void *conn_data;            /* Connection-specific user data */
-
-    int num_headers;            /* Number of HTTP headers */
-    struct mg_header {
-        const char *name;       /* HTTP header name */
-        const char *value;      /* HTTP header value */
-    } http_headers[64];         /* Maximum 64 headers */
-};
-
-
-/* This structure needs to be passed to mg_start(), to let civetweb know
-   which callbacks to invoke. For detailed description, see
-   https://github.com/sunsetbrew/civetweb/blob/master/docs/UserManual.md */
-struct mg_callbacks {
-    /* Called when civetweb has received new HTTP request.
-       If callback returns non-zero,
-       callback must process the request by sending valid HTTP headers and
-       body, and civetweb will not do any further processing.
-       If callback returns 0, civetweb processes the request itself. In this
-       case, callback must not send any data to the client. */
-    int  (*begin_request)(struct mg_connection *);
-
-    /* Called when civetweb has finished processing request. */
-    void (*end_request)(const struct mg_connection *, int reply_status_code);
-
-    /* Called when civetweb is about to log a message. If callback returns
-       non-zero, civetweb does not log anything. */
-    int  (*log_message)(const struct mg_connection *, const char *message);
-
-    /* Called when civetweb initializes SSL library. */
-    int  (*init_ssl)(void *ssl_context, void *user_data);
-
-    /* Called when websocket request is received, before websocket handshake.
-       If callback returns 0, civetweb proceeds with handshake, otherwise
-       cinnection is closed immediately. */
-    int (*websocket_connect)(const struct mg_connection *);
-
-    /* Called when websocket handshake is successfully completed, and
-       connection is ready for data exchange. */
-    void (*websocket_ready)(struct mg_connection *);
-
-    /* Called when data frame has been received from the client.
-       Parameters:
-          bits: first byte of the websocket frame, see websocket RFC at
-                http://tools.ietf.org/html/rfc6455, section 5.2
-          data, data_len: payload, with mask (if any) already applied.
-       Return value:
-          non-0: keep this websocket connection opened.
-          0:     close this websocket connection. */
-    int  (*websocket_data)(struct mg_connection *, int bits,
-                           char *data, size_t data_len);
-
-    /* Called when civetweb is closing a connection.  The per-context mutex is
-       locked when this is invoked.  This is primarily useful for noting when
-       a websocket is closing and removing it from any application-maintained
-       list of clients. */
-    void (*connection_close)(struct mg_connection *);
-
-    /* Called when civetweb tries to open a file. Used to intercept file open
-       calls, and serve file data from memory instead.
-       Parameters:
-          path:     Full path to the file to open.
-          data_len: Placeholder for the file size, if file is served from
-                    memory.
-       Return value:
-          NULL: do not serve file from memory, proceed with normal file open.
-          non-NULL: pointer to the file contents in memory. data_len must be
-          initilized with the size of the memory block. */
-    const char * (*open_file)(const struct mg_connection *,
-                              const char *path, size_t *data_len);
-
-    /* Called when civetweb is about to serve Lua server page (.lp file), if
-       Lua support is enabled.
-       Parameters:
-         lua_context: "lua_State *" pointer. */
-    void (*init_lua)(struct mg_connection *, void *lua_context);
-
-    /* Called when civetweb has uploaded a file to a temporary directory as a
-       result of mg_upload() call.
-       Parameters:
-          file_file: full path name to the uploaded file. */
-    void (*upload)(struct mg_connection *, const char *file_name);
-
-    /* Called when civetweb is about to send HTTP error to the client.
-       Implementing this callback allows to create custom error pages.
-       Parameters:
-         status: HTTP error status code. */
-    int  (*http_error)(struct mg_connection *, int status);
-};
-
-/* Start web server.
-
-   Parameters:
-     callbacks: mg_callbacks structure with user-defined callbacks.
-     options: NULL terminated list of option_name, option_value pairs that
-              specify Civetweb configuration parameters.
-
-   Side-effects: on UNIX, ignores SIGCHLD and SIGPIPE signals. If custom
-      processing is required for these, signal handlers must be set up
-      after calling mg_start().
-
-
-   Example:
-     const char *options[] = {
-       "document_root", "/var/www",
-       "listening_ports", "80,443s",
-       NULL
-     };
-     struct mg_context *ctx = mg_start(&my_func, NULL, options);
-
-   Refer to https://github.com/sunsetbrew/civetweb/blob/master/docs/UserManual.md
-   for the list of valid option and their possible values.
-
-   Return:
-     web server context, or NULL on error. */
-struct mg_context *mg_start(const struct mg_callbacks *callbacks,
-                            void *user_data,
-                            const char **configuration_options);
-
-
-/* Stop the web server.
-
-   Must be called last, when an application wants to stop the web server and
-   release all associated resources. This function blocks until all Civetweb
-   threads are stopped. Context pointer becomes invalid. */
-void mg_stop(struct mg_context *);
-
-/* mg_request_handler
-
-   Called when a new request comes in.  This callback is URI based
-   and configured with mg_set_request_handler().
-
-   Parameters:
-      conn: current connection information.
-      cbdata: the callback data configured with mg_set_request_handler().
-   Returns:
-      0: the handler could not handle the request, so fall through.
-      1: the handler processed the request. */
-typedef int (* mg_request_handler)(struct mg_connection *conn, void *cbdata);
-
-/* mg_set_request_handler
-
-   Sets or removes a URI mapping for a request handler.
-
-   URI's are ordered and prefixed URI's are supported. For example,
-   consider two URIs: /a/b and /a
-           /a   matches /a
-           /a/b matches /a/b
-           /a/c matches /a
-
-   Parameters:
-      ctx: server context
-      uri: the URI to configure
-      handler: the callback handler to use when the URI is requested.
-               If NULL, the URI will be removed.
-      cbdata: the callback data to give to the handler when it s requested. */
-void mg_set_request_handler(struct mg_context *ctx, const char *uri, mg_request_handler handler, void *cbdata);
-
-
-/* Get the value of particular configuration parameter.
-   The value returned is read-only. Civetweb does not allow changing
-   configuration at run time.
-   If given parameter name is not valid, NULL is returned. For valid
-   names, return value is guaranteed to be non-NULL. If parameter is not
-   set, zero-length string is returned. */
-const char *mg_get_option(const struct mg_context *ctx, const char *name);
-
-
-/* Return array of strings that represent valid configuration options.
-   For each option, option name and default value is returned, i.e. the
-   number of entries in the array equals to number_of_options x 2.
-   Array is NULL terminated. */
-const char **mg_get_valid_option_names(void);
-
-
-/* Add, edit or delete the entry in the passwords file.
-
-   This function allows an application to manipulate .htpasswd files on the
-   fly by adding, deleting and changing user records. This is one of the
-   several ways of implementing authentication on the server side. For another,
-   cookie-based way please refer to the examples/chat in the source tree.
-
-   If password is not NULL, entry is added (or modified if already exists).
-   If password is NULL, entry is deleted.
-
-   Return:
-     1 on success, 0 on error. */
-int mg_modify_passwords_file(const char *passwords_file_name,
-                             const char *domain,
-                             const char *user,
-                             const char *password);
-
-
-/* Return information associated with the request. */
-struct mg_request_info *mg_get_request_info(struct mg_connection *);
-
-
-/* Send data to the client.
-   Return:
-    0   when the connection has been closed
-    -1  on error
-    >0  number of bytes written on success */
-int mg_write(struct mg_connection *, const void *buf, size_t len);
-
-
-/* Send data to a websocket client wrapped in a websocket frame.  Uses mg_lock
-   to ensure that the transmission is not interrupted, i.e., when the
-   application is proactively communicating and responding to a request
-   simultaneously.
-
-   Send data to a websocket client wrapped in a websocket frame.
-   This function is available when civetweb is compiled with -DUSE_WEBSOCKET
-
-   Return:
-    0   when the connection has been closed
-    -1  on error
-    >0  number of bytes written on success */
-int mg_websocket_write(struct mg_connection* conn, int opcode,
-                       const char *data, size_t data_len);
-
-/* Blocks until unique access is obtained to this connection. Intended for use
-   with websockets only.
-   Invoke this before mg_write or mg_printf when communicating with a
-   websocket if your code has server-initiated communication as well as
-   communication in direct response to a message. */
-void mg_lock(struct mg_connection* conn);
-void mg_unlock(struct mg_connection* conn);
-
-/* Opcodes, from http://tools.ietf.org/html/rfc6455 */
-enum {
-    WEBSOCKET_OPCODE_CONTINUATION = 0x0,
-    WEBSOCKET_OPCODE_TEXT = 0x1,
-    WEBSOCKET_OPCODE_BINARY = 0x2,
-    WEBSOCKET_OPCODE_CONNECTION_CLOSE = 0x8,
-    WEBSOCKET_OPCODE_PING = 0x9,
-    WEBSOCKET_OPCODE_PONG = 0xa
-};
-
-
-/* Macros for enabling compiler-specific checks for printf-like arguments. */
-#undef PRINTF_FORMAT_STRING
-#if defined(_MSC_VER) && _MSC_VER >= 1400
-#include <sal.h>
-#if defined(_MSC_VER) && _MSC_VER > 1400
-#define PRINTF_FORMAT_STRING(s) _Printf_format_string_ s
-#else
-#define PRINTF_FORMAT_STRING(s) __format_string s
-#endif
-#else
-#define PRINTF_FORMAT_STRING(s) s
-#endif
-
-#ifdef __GNUC__
-#define PRINTF_ARGS(x, y) __attribute__((format(printf, x, y)))
-#else
-#define PRINTF_ARGS(x, y)
-#endif
-
-/* Send data to the client using printf() semantics.
-
-   Works exactly like mg_write(), but allows to do message formatting. */
-int mg_printf(struct mg_connection *,
-              PRINTF_FORMAT_STRING(const char *fmt), ...) PRINTF_ARGS(2, 3);
-
-
-/* Send contents of the entire file together with HTTP headers. */
-void mg_send_file(struct mg_connection *conn, const char *path);
-
-
-/* Read data from the remote end, return number of bytes read.
-   Return:
-     0     connection has been closed by peer. No more data could be read.
-     < 0   read error. No more data could be read from the connection.
-     > 0   number of bytes read into the buffer. */
-int mg_read(struct mg_connection *, void *buf, size_t len);
-
-
-/* Get the value of particular HTTP header.
-
-   This is a helper function. It traverses request_info->http_headers array,
-   and if the header is present in the array, returns its value. If it is
-   not present, NULL is returned. */
-const char *mg_get_header(const struct mg_connection *, const char *name);
-
-
-/* Get a value of particular form variable.
-
-   Parameters:
-     data: pointer to form-uri-encoded buffer. This could be either POST data,
-           or request_info.query_string.
-     data_len: length of the encoded data.
-     var_name: variable name to decode from the buffer
-     dst: destination buffer for the decoded variable
-     dst_len: length of the destination buffer
-
-   Return:
-     On success, length of the decoded variable.
-     On error:
-        -1 (variable not found).
-        -2 (destination buffer is NULL, zero length or too small to hold the
-            decoded variable).
-
-   Destination buffer is guaranteed to be '\0' - terminated if it is not
-   NULL or zero length. */
-int mg_get_var(const char *data, size_t data_len,
-               const char *var_name, char *dst, size_t dst_len);
-
-/* Get a value of particular form variable.
-
-   Parameters:
-     data: pointer to form-uri-encoded buffer. This could be either POST data,
-           or request_info.query_string.
-     data_len: length of the encoded data.
-     var_name: variable name to decode from the buffer
-     dst: destination buffer for the decoded variable
-     dst_len: length of the destination buffer
-     occurrence: which occurrence of the variable, 0 is the first, 1 the
-                 second...
-                this makes it possible to parse a query like
-                b=x&a=y&a=z which will have occurrence values b:0, a:0 and a:1
-
-   Return:
-     On success, length of the decoded variable.
-     On error:
-        -1 (variable not found).
-        -2 (destination buffer is NULL, zero length or too small to hold the
-            decoded variable).
-
-   Destination buffer is guaranteed to be '\0' - terminated if it is not
-   NULL or zero length. */
-int mg_get_var2(const char *data, size_t data_len,
-                const char *var_name, char *dst, size_t dst_len, size_t occurrence);
-
-/* Fetch value of certain cookie variable into the destination buffer.
-
-   Destination buffer is guaranteed to be '\0' - terminated. In case of
-   failure, dst[0] == '\0'. Note that RFC allows many occurrences of the same
-   parameter. This function returns only first occurrence.
-
-   Return:
-     On success, value length.
-     On error:
-        -1 (either "Cookie:" header is not present at all or the requested
-            parameter is not found).
-        -2 (destination buffer is NULL, zero length or too small to hold the
-            value). */
-int mg_get_cookie(const char *cookie, const char *var_name,
-                  char *buf, size_t buf_len);
-
-
-/* Download data from the remote web server.
-     host: host name to connect to, e.g. "foo.com", or "10.12.40.1".
-     port: port number, e.g. 80.
-     use_ssl: wether to use SSL connection.
-     error_buffer, error_buffer_size: error message placeholder.
-     request_fmt,...: HTTP request.
-   Return:
-     On success, valid pointer to the new connection, suitable for mg_read().
-     On error, NULL. error_buffer contains error message.
-   Example:
-     char ebuf[100];
-     struct mg_connection *conn;
-     conn = mg_download("google.com", 80, 0, ebuf, sizeof(ebuf),
-                        "%s", "GET / HTTP/1.0\r\nHost: google.com\r\n\r\n");
- */
-struct mg_connection *mg_download(const char *host, int port, int use_ssl,
-                                  char *error_buffer, size_t error_buffer_size,
-                                  PRINTF_FORMAT_STRING(const char *request_fmt),
-                                  ...) PRINTF_ARGS(6, 7);
-
-
-/* Close the connection opened by mg_download(). */
-void mg_close_connection(struct mg_connection *conn);
-
-
-/* File upload functionality. Each uploaded file gets saved into a temporary
-   file and MG_UPLOAD event is sent.
-   Return number of uploaded files. */
-int mg_upload(struct mg_connection *conn, const char *destination_dir);
-
-
-/* Convenience function -- create detached thread.
-   Return: 0 on success, non-0 on error. */
-typedef void * (*mg_thread_func_t)(void *);
-int mg_start_thread(mg_thread_func_t f, void *p);
-
-
-/* Return builtin mime type for the given file name.
-   For unrecognized extensions, "text/plain" is returned. */
-const char *mg_get_builtin_mime_type(const char *file_name);
-
-
-/* Return Civetweb version. */
-const char *mg_version(void);
-
-/* URL-decode input buffer into destination buffer.
-   0-terminate the destination buffer.
-   form-url-encoded data differs from URI encoding in a way that it
-   uses '+' as character for space, see RFC 1866 section 8.2.1
-   http://ftp.ics.uci.edu/pub/ietf/html/rfc1866.txt
-   Return: length of the decoded data, or -1 if dst buffer is too small. */
-int mg_url_decode(const char *src, int src_len, char *dst,
-                  int dst_len, int is_form_url_encoded);
-
-/* URL-encode input buffer into destination buffer.
-   returns the length of the resulting buffer or -1
-   is the buffer is too small. */
-int mg_url_encode(const char *src, char *dst, size_t dst_len);
-
-/* MD5 hash given strings.
-   Buffer 'buf' must be 33 bytes long. Varargs is a NULL terminated list of
-   ASCIIz strings. When function returns, buf will contain human-readable
-   MD5 hash. Example:
-     char buf[33];
-     mg_md5(buf, "aa", "bb", NULL); */
-char *mg_md5(char buf[33], ...);
-
-
-/* Print error message to the opened error log stream.
-   This utilizes the provided logging configuration.
-     conn: connection
-     fmt: format string without the line return
-     ...: variable argument list
-   Example:
-     mg_cry(conn,"i like %s", "logging"); */
-void mg_cry(struct mg_connection *conn,
-            PRINTF_FORMAT_STRING(const char *fmt), ...) PRINTF_ARGS(2, 3);
-
-/* utility method to compare two buffers, case incensitive. */
-int mg_strncasecmp(const char *s1, const char *s2, size_t len);
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif /* CIVETWEB_HEADER_INCLUDED */
diff --git a/externals/civetweb/include/md5.inl b/externals/civetweb/include/md5.inl
deleted file mode 100755
index 4da933db40..0000000000
--- a/externals/civetweb/include/md5.inl
+++ /dev/null
@@ -1,461 +0,0 @@
-/*
- * This an amalgamation of md5.c and md5.h into a single file
- * with all static declaration to reduce linker conflicts
- * in Civetweb.
- *
- * The MD5_STATIC declaration was added to facilitate static
- * inclusion.
- * No Face Press, LLC
- */
-
-/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
-/*
-  Independent implementation of MD5 (RFC 1321).
-
-  This code implements the MD5 Algorithm defined in RFC 1321, whose
-  text is available at
-	http://www.ietf.org/rfc/rfc1321.txt
-  The code is derived from the text of the RFC, including the test suite
-  (section A.5) but excluding the rest of Appendix A.  It does not include
-  any code or documentation that is identified in the RFC as being
-  copyrighted.
-
-  The original and principal author of md5.h is L. Peter Deutsch
-  <ghost@aladdin.com>.  Other authors are noted in the change history
-  that follows (in reverse chronological order):
-
-  2002-04-13 lpd Removed support for non-ANSI compilers; removed
-	references to Ghostscript; clarified derivation from RFC 1321;
-	now handles byte order either statically or dynamically.
-  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
-  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
-	added conditionalization for C++ compilation from Martin
-	Purschke <purschke@bnl.gov>.
-  1999-05-03 lpd Original version.
- */
-
-#ifndef md5_INCLUDED
-#  define md5_INCLUDED
-
-/*
- * This package supports both compile-time and run-time determination of CPU
- * byte order.  If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
- * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
- * defined as non-zero, the code will be compiled to run only on big-endian
- * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
- * run on either big- or little-endian CPUs, but will run slightly less
- * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
- */
-
-typedef unsigned char md5_byte_t; /* 8-bit byte */
-typedef unsigned int md5_word_t; /* 32-bit word */
-
-/* Define the state of the MD5 Algorithm. */
-typedef struct md5_state_s {
-    md5_word_t count[2];	/* message length in bits, lsw first */
-    md5_word_t abcd[4];		/* digest buffer */
-    md5_byte_t buf[64];		/* accumulate block */
-} md5_state_t;
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-/* Initialize the algorithm. */
-MD5_STATIC void md5_init(md5_state_t *pms);
-
-/* Append a string to the message. */
-MD5_STATIC void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
-
-/* Finish the message and return the digest. */
-MD5_STATIC void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
-
-#ifdef __cplusplus
-}  /* end extern "C" */
-#endif
-
-#endif /* md5_INCLUDED */
-
-/*
-  Copyright (C) 1999, 2000, 2002 Aladdin Enterprises.  All rights reserved.
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  L. Peter Deutsch
-  ghost@aladdin.com
-
- */
-/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
-/*
-  Independent implementation of MD5 (RFC 1321).
-
-  This code implements the MD5 Algorithm defined in RFC 1321, whose
-  text is available at
-	http://www.ietf.org/rfc/rfc1321.txt
-  The code is derived from the text of the RFC, including the test suite
-  (section A.5) but excluding the rest of Appendix A.  It does not include
-  any code or documentation that is identified in the RFC as being
-  copyrighted.
-
-  The original and principal author of md5.c is L. Peter Deutsch
-  <ghost@aladdin.com>.  Other authors are noted in the change history
-  that follows (in reverse chronological order):
-
-  2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
-	either statically or dynamically; added missing #include <string.h>
-	in library.
-  2002-03-11 lpd Corrected argument list for main(), and added int return
-	type, in test program and T value program.
-  2002-02-21 lpd Added missing #include <stdio.h> in test program.
-  2000-07-03 lpd Patched to eliminate warnings about "constant is
-	unsigned in ANSI C, signed in traditional"; made test program
-	self-checking.
-  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
-  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
-  1999-05-03 lpd Original version.
- */
-
-#ifndef MD5_STATIC
-#include <string.h>
-#endif
-
-#undef BYTE_ORDER	/* 1 = big-endian, -1 = little-endian, 0 = unknown */
-#ifdef ARCH_IS_BIG_ENDIAN
-#  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
-#else
-#  define BYTE_ORDER 0
-#endif
-
-#define T_MASK ((md5_word_t)~0)
-#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
-#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
-#define T3    0x242070db
-#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
-#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
-#define T6    0x4787c62a
-#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
-#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
-#define T9    0x698098d8
-#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
-#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
-#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
-#define T13    0x6b901122
-#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
-#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
-#define T16    0x49b40821
-#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
-#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
-#define T19    0x265e5a51
-#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
-#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
-#define T22    0x02441453
-#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
-#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
-#define T25    0x21e1cde6
-#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
-#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
-#define T28    0x455a14ed
-#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
-#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
-#define T31    0x676f02d9
-#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
-#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
-#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
-#define T35    0x6d9d6122
-#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
-#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
-#define T38    0x4bdecfa9
-#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
-#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
-#define T41    0x289b7ec6
-#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
-#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
-#define T44    0x04881d05
-#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
-#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
-#define T47    0x1fa27cf8
-#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
-#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
-#define T50    0x432aff97
-#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
-#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
-#define T53    0x655b59c3
-#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
-#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
-#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
-#define T57    0x6fa87e4f
-#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
-#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
-#define T60    0x4e0811a1
-#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
-#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
-#define T63    0x2ad7d2bb
-#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
-
-
-static void
-md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
-{
-    md5_word_t
-    a = pms->abcd[0], b = pms->abcd[1],
-    c = pms->abcd[2], d = pms->abcd[3];
-    md5_word_t t;
-#if BYTE_ORDER > 0
-    /* Define storage only for big-endian CPUs. */
-    md5_word_t X[16];
-#else
-    /* Define storage for little-endian or both types of CPUs. */
-    md5_word_t xbuf[16];
-    const md5_word_t *X;
-#endif
-
-    {
-#if BYTE_ORDER == 0
-        /*
-         * Determine dynamically whether this is a big-endian or
-         * little-endian machine, since we can use a more efficient
-         * algorithm on the latter.
-         */
-        static const int w = 1;
-
-        if (*((const md5_byte_t *)&w)) /* dynamic little-endian */
-#endif
-#if BYTE_ORDER <= 0		/* little-endian */
-        {
-            /*
-             * On little-endian machines, we can process properly aligned
-             * data without copying it.
-             */
-            if (!((data - (const md5_byte_t *)0) & 3)) {
-                /* data are properly aligned */
-                X = (const md5_word_t *)data;
-            } else {
-                /* not aligned */
-                memcpy(xbuf, data, 64);
-                X = xbuf;
-            }
-        }
-#endif
-#if BYTE_ORDER == 0
-        else			/* dynamic big-endian */
-#endif
-#if BYTE_ORDER >= 0		/* big-endian */
-        {
-            /*
-             * On big-endian machines, we must arrange the bytes in the
-             * right order.
-             */
-            const md5_byte_t *xp = data;
-            int i;
-
-#  if BYTE_ORDER == 0
-            X = xbuf;		/* (dynamic only) */
-#  else
-#    define xbuf X		/* (static only) */
-#  endif
-            for (i = 0; i < 16; ++i, xp += 4)
-                xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
-        }
-#endif
-    }
-
-#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
-
-    /* Round 1. */
-    /* Let [abcd k s i] denote the operation
-       a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
-#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + F(b,c,d) + X[k] + Ti;\
-  a = ROTATE_LEFT(t, s) + b
-    /* Do the following 16 operations. */
-    SET(a, b, c, d,  0,  7,  T1);
-    SET(d, a, b, c,  1, 12,  T2);
-    SET(c, d, a, b,  2, 17,  T3);
-    SET(b, c, d, a,  3, 22,  T4);
-    SET(a, b, c, d,  4,  7,  T5);
-    SET(d, a, b, c,  5, 12,  T6);
-    SET(c, d, a, b,  6, 17,  T7);
-    SET(b, c, d, a,  7, 22,  T8);
-    SET(a, b, c, d,  8,  7,  T9);
-    SET(d, a, b, c,  9, 12, T10);
-    SET(c, d, a, b, 10, 17, T11);
-    SET(b, c, d, a, 11, 22, T12);
-    SET(a, b, c, d, 12,  7, T13);
-    SET(d, a, b, c, 13, 12, T14);
-    SET(c, d, a, b, 14, 17, T15);
-    SET(b, c, d, a, 15, 22, T16);
-#undef SET
-
-    /* Round 2. */
-    /* Let [abcd k s i] denote the operation
-         a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
-#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + G(b,c,d) + X[k] + Ti;\
-  a = ROTATE_LEFT(t, s) + b
-    /* Do the following 16 operations. */
-    SET(a, b, c, d,  1,  5, T17);
-    SET(d, a, b, c,  6,  9, T18);
-    SET(c, d, a, b, 11, 14, T19);
-    SET(b, c, d, a,  0, 20, T20);
-    SET(a, b, c, d,  5,  5, T21);
-    SET(d, a, b, c, 10,  9, T22);
-    SET(c, d, a, b, 15, 14, T23);
-    SET(b, c, d, a,  4, 20, T24);
-    SET(a, b, c, d,  9,  5, T25);
-    SET(d, a, b, c, 14,  9, T26);
-    SET(c, d, a, b,  3, 14, T27);
-    SET(b, c, d, a,  8, 20, T28);
-    SET(a, b, c, d, 13,  5, T29);
-    SET(d, a, b, c,  2,  9, T30);
-    SET(c, d, a, b,  7, 14, T31);
-    SET(b, c, d, a, 12, 20, T32);
-#undef SET
-
-    /* Round 3. */
-    /* Let [abcd k s t] denote the operation
-         a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
-#define H(x, y, z) ((x) ^ (y) ^ (z))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + H(b,c,d) + X[k] + Ti;\
-  a = ROTATE_LEFT(t, s) + b
-    /* Do the following 16 operations. */
-    SET(a, b, c, d,  5,  4, T33);
-    SET(d, a, b, c,  8, 11, T34);
-    SET(c, d, a, b, 11, 16, T35);
-    SET(b, c, d, a, 14, 23, T36);
-    SET(a, b, c, d,  1,  4, T37);
-    SET(d, a, b, c,  4, 11, T38);
-    SET(c, d, a, b,  7, 16, T39);
-    SET(b, c, d, a, 10, 23, T40);
-    SET(a, b, c, d, 13,  4, T41);
-    SET(d, a, b, c,  0, 11, T42);
-    SET(c, d, a, b,  3, 16, T43);
-    SET(b, c, d, a,  6, 23, T44);
-    SET(a, b, c, d,  9,  4, T45);
-    SET(d, a, b, c, 12, 11, T46);
-    SET(c, d, a, b, 15, 16, T47);
-    SET(b, c, d, a,  2, 23, T48);
-#undef SET
-
-    /* Round 4. */
-    /* Let [abcd k s t] denote the operation
-         a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
-#define I(x, y, z) ((y) ^ ((x) | ~(z)))
-#define SET(a, b, c, d, k, s, Ti)\
-  t = a + I(b,c,d) + X[k] + Ti;\
-  a = ROTATE_LEFT(t, s) + b
-    /* Do the following 16 operations. */
-    SET(a, b, c, d,  0,  6, T49);
-    SET(d, a, b, c,  7, 10, T50);
-    SET(c, d, a, b, 14, 15, T51);
-    SET(b, c, d, a,  5, 21, T52);
-    SET(a, b, c, d, 12,  6, T53);
-    SET(d, a, b, c,  3, 10, T54);
-    SET(c, d, a, b, 10, 15, T55);
-    SET(b, c, d, a,  1, 21, T56);
-    SET(a, b, c, d,  8,  6, T57);
-    SET(d, a, b, c, 15, 10, T58);
-    SET(c, d, a, b,  6, 15, T59);
-    SET(b, c, d, a, 13, 21, T60);
-    SET(a, b, c, d,  4,  6, T61);
-    SET(d, a, b, c, 11, 10, T62);
-    SET(c, d, a, b,  2, 15, T63);
-    SET(b, c, d, a,  9, 21, T64);
-#undef SET
-
-    /* Then perform the following additions. (That is increment each
-       of the four registers by the value it had before this block
-       was started.) */
-    pms->abcd[0] += a;
-    pms->abcd[1] += b;
-    pms->abcd[2] += c;
-    pms->abcd[3] += d;
-}
-
-MD5_STATIC void
-md5_init(md5_state_t *pms)
-{
-    pms->count[0] = pms->count[1] = 0;
-    pms->abcd[0] = 0x67452301;
-    pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
-    pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
-    pms->abcd[3] = 0x10325476;
-}
-
-MD5_STATIC void
-md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
-{
-    const md5_byte_t *p = data;
-    int left = nbytes;
-    int offset = (pms->count[0] >> 3) & 63;
-    md5_word_t nbits = (md5_word_t)(nbytes << 3);
-
-    if (nbytes <= 0)
-        return;
-
-    /* Update the message length. */
-    pms->count[1] += nbytes >> 29;
-    pms->count[0] += nbits;
-    if (pms->count[0] < nbits)
-        pms->count[1]++;
-
-    /* Process an initial partial block. */
-    if (offset) {
-        int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
-
-        memcpy(pms->buf + offset, p, copy);
-        if (offset + copy < 64)
-            return;
-        p += copy;
-        left -= copy;
-        md5_process(pms, pms->buf);
-    }
-
-    /* Process full blocks. */
-    for (; left >= 64; p += 64, left -= 64)
-        md5_process(pms, p);
-
-    /* Process a final partial block. */
-    if (left)
-        memcpy(pms->buf, p, left);
-}
-
-MD5_STATIC void
-md5_finish(md5_state_t *pms, md5_byte_t digest[16])
-{
-    static const md5_byte_t pad[64] = {
-        0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-    };
-    md5_byte_t data[8];
-    int i;
-
-    /* Save the length before padding. */
-    for (i = 0; i < 8; ++i)
-        data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
-    /* Pad to 56 bytes mod 64. */
-    md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
-    /* Append the length. */
-    md5_append(pms, data, 8);
-    for (i = 0; i < 16; ++i)
-        digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
-}
diff --git a/externals/civetweb/src/civetweb.c b/externals/civetweb/src/civetweb.c
deleted file mode 100755
index 6c5a08561c..0000000000
--- a/externals/civetweb/src/civetweb.c
+++ /dev/null
@@ -1,6273 +0,0 @@
-/* Copyright (c) 2004-2013 Sergey Lyubka
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#if defined(_WIN32)
-#if !defined(_CRT_SECURE_NO_WARNINGS)
-#define _CRT_SECURE_NO_WARNINGS /* Disable deprecation warning in VS2005 */
-#endif
-#else
-#ifdef __linux__
-#define _XOPEN_SOURCE 600     /* For flockfile() on Linux */
-#endif
-#define _LARGEFILE_SOURCE     /* Enable 64-bit file offsets */
-#define __STDC_FORMAT_MACROS  /* <inttypes.h> wants this for C++ */
-#define __STDC_LIMIT_MACROS   /* C++ wants that for INT64_MAX */
-#endif
-
-#if defined (_MSC_VER)
-/* 'type cast' : conversion from 'int' to 'HANDLE' of greater size */
-#pragma warning (disable : 4306 )
-/* conditional expression is constant: introduced by FD_SET(..) */
-#pragma warning (disable : 4127)
-/* non-constant aggregate initializer: issued due to missing C99 support */
-#pragma warning (disable : 4204)
-#endif
-
-/* Disable WIN32_LEAN_AND_MEAN.
-   This makes windows.h always include winsock2.h */
-#if defined(WIN32_LEAN_AND_MEAN) && (_MSC_VER <= 1400)
-#undef WIN32_LEAN_AND_MEAN
-#endif
-
-#if defined USE_IPV6 && defined(_WIN32)
-#include <ws2tcpip.h>
-#endif
-
-#if defined(__SYMBIAN32__)
-#define NO_SSL /* SSL is not supported */
-#define NO_CGI /* CGI is not supported */
-#define PATH_MAX FILENAME_MAX
-#endif /* __SYMBIAN32__ */
-
-#ifndef IGNORE_UNUSED_RESULT
-#define IGNORE_UNUSED_RESULT(a) (void)((a) && 1)
-#endif
-
-#ifndef _WIN32_WCE /* Some ANSI #includes are not available on Windows CE */
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <signal.h>
-#include <fcntl.h>
-#endif /* !_WIN32_WCE */
-
-#include <time.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <assert.h>
-#include <string.h>
-#include <ctype.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdio.h>
-
-#define MAX_WORKER_THREADS 1024
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__) /* Windows specific */
-#if defined(_MSC_VER) && _MSC_VER <= 1400
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0400 /* To make it link in VS2005 */
-#endif
-#include <windows.h>
-
-#ifndef PATH_MAX
-#define PATH_MAX MAX_PATH
-#endif
-
-#ifndef _WIN32_WCE
-#include <process.h>
-#include <direct.h>
-#include <io.h>
-#else /* _WIN32_WCE */
-#define NO_CGI /* WinCE has no pipes */
-
-typedef long off_t;
-
-#define errno   GetLastError()
-#define strerror(x)  _ultoa(x, (char *) _alloca(sizeof(x) *3 ), 10)
-#endif /* _WIN32_WCE */
-
-#define MAKEUQUAD(lo, hi) ((uint64_t)(((uint32_t)(lo)) | \
-      ((uint64_t)((uint32_t)(hi))) << 32))
-#define RATE_DIFF 10000000 /* 100 nsecs */
-#define EPOCH_DIFF MAKEUQUAD(0xd53e8000, 0x019db1de)
-#define SYS2UNIX_TIME(lo, hi) \
-  (time_t) ((MAKEUQUAD((lo), (hi)) - EPOCH_DIFF) / RATE_DIFF)
-
-/* Visual Studio 6 does not know __func__ or __FUNCTION__
-   The rest of MS compilers use __FUNCTION__, not C99 __func__
-   Also use _strtoui64 on modern M$ compilers */
-#if defined(_MSC_VER) && _MSC_VER < 1300
-#define STRX(x) #x
-#define STR(x) STRX(x)
-#define __func__ __FILE__ ":" STR(__LINE__)
-#define strtoull(x, y, z) (unsigned __int64) _atoi64(x)
-#define strtoll(x, y, z) _atoi64(x)
-#else
-#define __func__  __FUNCTION__
-#define strtoull(x, y, z) _strtoui64(x, y, z)
-#define strtoll(x, y, z) _strtoi64(x, y, z)
-#endif /* _MSC_VER */
-
-#define ERRNO   GetLastError()
-#define NO_SOCKLEN_T
-#define SSL_LIB   "ssleay32.dll"
-#define CRYPTO_LIB  "libeay32.dll"
-#define O_NONBLOCK  0
-#if !defined(EWOULDBLOCK)
-#define EWOULDBLOCK  WSAEWOULDBLOCK
-#endif /* !EWOULDBLOCK */
-#define _POSIX_
-#define INT64_FMT  "I64d"
-
-#define WINCDECL __cdecl
-#define SHUT_WR 1
-#define snprintf _snprintf
-#define vsnprintf _vsnprintf
-#define mg_sleep(x) Sleep(x)
-
-#define pipe(x) _pipe(x, MG_BUF_LEN, _O_BINARY)
-#ifndef popen
-#define popen(x, y) _popen(x, y)
-#endif
-#ifndef pclose
-#define pclose(x) _pclose(x)
-#endif
-#define close(x) _close(x)
-#define dlsym(x,y) GetProcAddress((HINSTANCE) (x), (y))
-#define RTLD_LAZY  0
-#define fseeko(x, y, z) _lseeki64(_fileno(x), (y), (z))
-#define fdopen(x, y) _fdopen((x), (y))
-#define write(x, y, z) _write((x), (y), (unsigned) z)
-#define read(x, y, z) _read((x), (y), (unsigned) z)
-#define flockfile(x) EnterCriticalSection(&global_log_file_lock)
-#define funlockfile(x) LeaveCriticalSection(&global_log_file_lock)
-#define sleep(x) Sleep((x) * 1000)
-#define rmdir(x) _rmdir(x)
-
-#if !defined(va_copy)
-#define va_copy(x, y) x = y
-#endif /* !va_copy MINGW #defines va_copy */
-
-#if !defined(fileno)
-#define fileno(x) _fileno(x)
-#endif /* !fileno MINGW #defines fileno */
-
-typedef HANDLE pthread_mutex_t;
-typedef DWORD pthread_key_t;
-typedef HANDLE pthread_t;
-typedef struct {
-    CRITICAL_SECTION threadIdSec;
-    int waitingthreadcount;        /* The number of threads queued. */
-    pthread_t *waitingthreadhdls;  /* The thread handles. */
-} pthread_cond_t;
-
-typedef DWORD clockid_t;
-#define CLOCK_MONOTONIC (1)
-#define CLOCK_REALTIME  (2)
-
-struct timespec {
-    time_t   tv_sec;        /* seconds */
-    long     tv_nsec;       /* nanoseconds */
-};
-
-#define pid_t HANDLE /* MINGW typedefs pid_t to int. Using #define here. */
-
-static int pthread_mutex_lock(pthread_mutex_t *);
-static int pthread_mutex_unlock(pthread_mutex_t *);
-static void to_unicode(const char *path, wchar_t *wbuf, size_t wbuf_len);
-struct file;
-static char *mg_fgets(char *buf, size_t size, struct file *filep, char **p);
-
-#if defined(HAVE_STDINT)
-#include <stdint.h>
-#else
-typedef unsigned int  uint32_t;
-typedef unsigned short  uint16_t;
-typedef unsigned __int64 uint64_t;
-typedef __int64   int64_t;
-#define INT64_MAX  9223372036854775807
-#endif /* HAVE_STDINT */
-
-/* POSIX dirent interface */
-struct dirent {
-    char d_name[PATH_MAX];
-};
-
-typedef struct DIR {
-    HANDLE   handle;
-    WIN32_FIND_DATAW info;
-    struct dirent  result;
-} DIR;
-
-#if !defined(USE_IPV6) && defined(_WIN32)
-#ifndef HAVE_POLL
-struct pollfd {
-    SOCKET fd;
-    short events;
-    short revents;
-};
-#define POLLIN 1
-#endif
-#endif
-
-/* Mark required libraries */
-#ifdef _MSC_VER
-#pragma comment(lib, "Ws2_32.lib")
-#endif
-
-#else    /* UNIX  specific */
-#include <sys/wait.h>
-#include <sys/socket.h>
-#include <sys/poll.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <sys/time.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <netdb.h>
-
-#include <pwd.h>
-#include <unistd.h>
-#include <dirent.h>
-#if !defined(NO_SSL_DL) && !defined(NO_SSL)
-#include <dlfcn.h>
-#endif
-#include <pthread.h>
-#if defined(__MACH__)
-#define SSL_LIB   "libssl.dylib"
-#define CRYPTO_LIB  "libcrypto.dylib"
-#else
-#if !defined(SSL_LIB)
-#define SSL_LIB   "libssl.so"
-#endif
-#if !defined(CRYPTO_LIB)
-#define CRYPTO_LIB  "libcrypto.so"
-#endif
-#endif
-#ifndef O_BINARY
-#define O_BINARY  0
-#endif /* O_BINARY */
-#define closesocket(a) close(a)
-#define mg_mkdir(x, y) mkdir(x, y)
-#define mg_remove(x) remove(x)
-#define mg_sleep(x) usleep((x) * 1000)
-#define ERRNO errno
-#define INVALID_SOCKET (-1)
-#define INT64_FMT PRId64
-typedef int SOCKET;
-#define WINCDECL
-
-#endif /* End of Windows and UNIX specific includes */
-
-#include "civetweb.h"
-
-#define PASSWORDS_FILE_NAME ".htpasswd"
-#define CGI_ENVIRONMENT_SIZE 4096
-#define MAX_CGI_ENVIR_VARS 64
-#define MG_BUF_LEN 8192
-#ifndef MAX_REQUEST_SIZE
-#define MAX_REQUEST_SIZE 16384
-#endif
-#define ARRAY_SIZE(array) (sizeof(array) / sizeof(array[0]))
-
-#ifdef _WIN32
-static CRITICAL_SECTION global_log_file_lock;
-static DWORD pthread_self(void)
-{
-    return GetCurrentThreadId();
-}
-
-int pthread_key_create(pthread_key_t *key, void (*_must_be_zero)(void*) /* destructor function not supported for windows */)
-{
-    assert(_must_be_zero == NULL);
-    if ((key!=0) && (_must_be_zero == NULL)) {
-        *key = TlsAlloc();
-        return (*key != TLS_OUT_OF_INDEXES) ? 0 : -1;
-    }
-    return -2;
-}
-
-int pthread_key_delete(pthread_key_t key)
-{
-    return TlsFree(key) ? 0 : 1;
-}
-
-int pthread_setspecific(pthread_key_t key, void * value)
-{
-    return TlsSetValue(key, value) ? 0 : 1;
-}
-
-void *pthread_getspecific(pthread_key_t key)
-{
-    return TlsGetValue(key);
-}
-#endif /* _WIN32 */
-
-#define MD5_STATIC static
-#include "md5.inl"
-
-#ifdef DEBUG_TRACE
-#undef DEBUG_TRACE
-#define DEBUG_TRACE(x)
-#else
-#if defined(DEBUG)
-#define DEBUG_TRACE(x) do { \
-  flockfile(stdout); \
-  printf("*** %lu.%p.%s.%d: ", \
-         (unsigned long) time(NULL), (void *) pthread_self(), \
-         __func__, __LINE__); \
-  printf x; \
-  putchar('\n'); \
-  fflush(stdout); \
-  funlockfile(stdout); \
-} while (0)
-#else
-#define DEBUG_TRACE(x)
-#endif /* DEBUG */
-#endif /* DEBUG_TRACE */
-
-/* Darwin prior to 7.0 and Win32 do not have socklen_t */
-#ifdef NO_SOCKLEN_T
-typedef int socklen_t;
-#endif /* NO_SOCKLEN_T */
-#define _DARWIN_UNLIMITED_SELECT
-
-#define IP_ADDR_STR_LEN 50  /* IPv6 hex string is 46 chars */
-
-#if !defined(MSG_NOSIGNAL)
-#define MSG_NOSIGNAL 0
-#endif
-
-#if !defined(SOMAXCONN)
-#define SOMAXCONN 100
-#endif
-
-#if !defined(PATH_MAX)
-#define PATH_MAX 4096
-#endif
-
-/* Size of the accepted socket queue */
-#if !defined(MGSQLEN)
-#define MGSQLEN 20
-#endif
-
-static const char *http_500_error = "Internal Server Error";
-
-#if defined(NO_SSL_DL)
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#else
-/* SSL loaded dynamically from DLL.
-   I put the prototypes here to be independent from OpenSSL source
-   installation. */
-
-typedef struct ssl_st SSL;
-typedef struct ssl_method_st SSL_METHOD;
-typedef struct ssl_ctx_st SSL_CTX;
-
-struct ssl_func {
-    const char *name;   /* SSL function name */
-    void  (*ptr)(void); /* Function pointer */
-};
-
-#define SSL_free (* (void (*)(SSL *)) ssl_sw[0].ptr)
-#define SSL_accept (* (int (*)(SSL *)) ssl_sw[1].ptr)
-#define SSL_connect (* (int (*)(SSL *)) ssl_sw[2].ptr)
-#define SSL_read (* (int (*)(SSL *, void *, int)) ssl_sw[3].ptr)
-#define SSL_write (* (int (*)(SSL *, const void *,int)) ssl_sw[4].ptr)
-#define SSL_get_error (* (int (*)(SSL *, int)) ssl_sw[5].ptr)
-#define SSL_set_fd (* (int (*)(SSL *, SOCKET)) ssl_sw[6].ptr)
-#define SSL_new (* (SSL * (*)(SSL_CTX *)) ssl_sw[7].ptr)
-#define SSL_CTX_new (* (SSL_CTX * (*)(SSL_METHOD *)) ssl_sw[8].ptr)
-#define SSLv23_server_method (* (SSL_METHOD * (*)(void)) ssl_sw[9].ptr)
-#define SSL_library_init (* (int (*)(void)) ssl_sw[10].ptr)
-#define SSL_CTX_use_PrivateKey_file (* (int (*)(SSL_CTX *, \
-        const char *, int)) ssl_sw[11].ptr)
-#define SSL_CTX_use_certificate_file (* (int (*)(SSL_CTX *, \
-        const char *, int)) ssl_sw[12].ptr)
-#define SSL_CTX_set_default_passwd_cb \
-  (* (void (*)(SSL_CTX *, mg_callback_t)) ssl_sw[13].ptr)
-#define SSL_CTX_free (* (void (*)(SSL_CTX *)) ssl_sw[14].ptr)
-#define SSL_load_error_strings (* (void (*)(void)) ssl_sw[15].ptr)
-#define SSL_CTX_use_certificate_chain_file \
-  (* (int (*)(SSL_CTX *, const char *)) ssl_sw[16].ptr)
-#define SSLv23_client_method (* (SSL_METHOD * (*)(void)) ssl_sw[17].ptr)
-#define SSL_pending (* (int (*)(SSL *)) ssl_sw[18].ptr)
-#define SSL_CTX_set_verify (* (void (*)(SSL_CTX *, int, int)) ssl_sw[19].ptr)
-#define SSL_shutdown (* (int (*)(SSL *)) ssl_sw[20].ptr)
-
-#define CRYPTO_num_locks (* (int (*)(void)) crypto_sw[0].ptr)
-#define CRYPTO_set_locking_callback \
-  (* (void (*)(void (*)(int, int, const char *, int))) crypto_sw[1].ptr)
-#define CRYPTO_set_id_callback \
-  (* (void (*)(unsigned long (*)(void))) crypto_sw[2].ptr)
-#define ERR_get_error (* (unsigned long (*)(void)) crypto_sw[3].ptr)
-#define ERR_error_string (* (char * (*)(unsigned long,char *)) crypto_sw[4].ptr)
-
-/* set_ssl_option() function updates this array.
-   It loads SSL library dynamically and changes NULLs to the actual addresses
-   of respective functions. The macros above (like SSL_connect()) are really
-   just calling these functions indirectly via the pointer. */
-static struct ssl_func ssl_sw[] = {
-    {"SSL_free",   NULL},
-    {"SSL_accept",   NULL},
-    {"SSL_connect",   NULL},
-    {"SSL_read",   NULL},
-    {"SSL_write",   NULL},
-    {"SSL_get_error",  NULL},
-    {"SSL_set_fd",   NULL},
-    {"SSL_new",   NULL},
-    {"SSL_CTX_new",   NULL},
-    {"SSLv23_server_method", NULL},
-    {"SSL_library_init",  NULL},
-    {"SSL_CTX_use_PrivateKey_file", NULL},
-    {"SSL_CTX_use_certificate_file",NULL},
-    {"SSL_CTX_set_default_passwd_cb",NULL},
-    {"SSL_CTX_free",  NULL},
-    {"SSL_load_error_strings", NULL},
-    {"SSL_CTX_use_certificate_chain_file", NULL},
-    {"SSLv23_client_method", NULL},
-    {"SSL_pending", NULL},
-    {"SSL_CTX_set_verify", NULL},
-    {"SSL_shutdown",   NULL},
-    {NULL,    NULL}
-};
-
-/* Similar array as ssl_sw. These functions could be located in different
-   lib. */
-#if !defined(NO_SSL)
-static struct ssl_func crypto_sw[] = {
-    {"CRYPTO_num_locks",  NULL},
-    {"CRYPTO_set_locking_callback", NULL},
-    {"CRYPTO_set_id_callback", NULL},
-    {"ERR_get_error",  NULL},
-    {"ERR_error_string", NULL},
-    {NULL,    NULL}
-};
-#endif /* NO_SSL */
-#endif /* NO_SSL_DL */
-
-static const char *month_names[] = {
-    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
-    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
-};
-
-/* Unified socket address. For IPv6 support, add IPv6 address structure
-   in the union u. */
-union usa {
-    struct sockaddr sa;
-    struct sockaddr_in sin;
-#if defined(USE_IPV6)
-    struct sockaddr_in6 sin6;
-#endif
-};
-
-/* Describes a string (chunk of memory). */
-struct vec {
-    const char *ptr;
-    size_t len;
-};
-
-struct file {
-    int is_directory;
-    time_t modification_time;
-    int64_t size;
-    FILE *fp;
-    const char *membuf;   /* Non-NULL if file data is in memory */
-    /* set to 1 if the content is gzipped
-       in which case we need a content-encoding: gzip header */
-    int gzipped;
-};
-#define STRUCT_FILE_INITIALIZER {0, 0, 0, NULL, NULL, 0}
-
-/* Describes listening socket, or socket which was accept()-ed by the master
-   thread and queued for future handling by the worker thread. */
-struct socket {
-    SOCKET sock;          /* Listening socket */
-    union usa lsa;        /* Local socket address */
-    union usa rsa;        /* Remote socket address */
-    unsigned is_ssl:1;    /* Is port SSL-ed */
-    unsigned ssl_redir:1; /* Is port supposed to redirect everything to SSL
-                             port */
-};
-
-/* NOTE(lsm): this enum shoulds be in sync with the config_options below. */
-enum {
-    CGI_EXTENSIONS, CGI_ENVIRONMENT, PUT_DELETE_PASSWORDS_FILE, CGI_INTERPRETER,
-    PROTECT_URI, AUTHENTICATION_DOMAIN, SSI_EXTENSIONS, THROTTLE,
-    ACCESS_LOG_FILE, ENABLE_DIRECTORY_LISTING, ERROR_LOG_FILE,
-    GLOBAL_PASSWORDS_FILE, INDEX_FILES, ENABLE_KEEP_ALIVE, ACCESS_CONTROL_LIST,
-    EXTRA_MIME_TYPES, LISTENING_PORTS, DOCUMENT_ROOT, SSL_CERTIFICATE,
-    NUM_THREADS, RUN_AS_USER, REWRITE, HIDE_FILES, REQUEST_TIMEOUT,
-    NUM_OPTIONS
-};
-
-static const char *config_options[] = {
-    "cgi_pattern", "**.cgi$|**.pl$|**.php$",
-    "cgi_environment", NULL,
-    "put_delete_auth_file", NULL,
-    "cgi_interpreter", NULL,
-    "protect_uri", NULL,
-    "authentication_domain", "mydomain.com",
-    "ssi_pattern", "**.shtml$|**.shtm$",
-    "throttle", NULL,
-    "access_log_file", NULL,
-    "enable_directory_listing", "yes",
-    "error_log_file", NULL,
-    "global_auth_file", NULL,
-    "index_files",
-    "index.html,index.htm,index.cgi,index.shtml,index.php,index.lp",
-    "enable_keep_alive", "no",
-    "access_control_list", NULL,
-    "extra_mime_types", NULL,
-    "listening_ports", "8080",
-    "document_root",  NULL,
-    "ssl_certificate", NULL,
-    "num_threads", "50",
-    "run_as_user", NULL,
-    "url_rewrite_patterns", NULL,
-    "hide_files_patterns", NULL,
-    "request_timeout_ms", "30000",
-    NULL
-};
-
-struct mg_request_handler_info {
-    char *uri;
-    size_t uri_len;
-    mg_request_handler handler;
-    void *cbdata;
-    struct mg_request_handler_info *next;
-};
-
-struct mg_context {
-    volatile int stop_flag;         /* Should we stop event loop */
-    void *ssllib_dll_handle;        /* Store the ssl library handle. */
-    void *cryptolib_dll_handle;     /* Store the crypto library handle. */
-    SSL_CTX *ssl_ctx;               /* SSL context */
-    char *config[NUM_OPTIONS];      /* Civetweb configuration parameters */
-    struct mg_callbacks callbacks;  /* User-defined callback function */
-    void *user_data;                /* User-defined data */
-
-    struct socket *listening_sockets;
-    int num_listening_sockets;
-
-    volatile int num_threads;  /* Number of threads */
-    pthread_mutex_t mutex;     /* Protects (max|num)_threads */
-    pthread_cond_t  cond;      /* Condvar for tracking workers terminations */
-
-    struct socket queue[MGSQLEN];   /* Accepted sockets */
-    volatile int sq_head;      /* Head of the socket queue */
-    volatile int sq_tail;      /* Tail of the socket queue */
-    pthread_cond_t sq_full;    /* Signaled when socket is produced */
-    pthread_cond_t sq_empty;   /* Signaled when socket is consumed */
-    pthread_t masterthreadid;  /* The master thread ID. */
-    int workerthreadcount;     /* The amount of worker threads. */
-    pthread_t *workerthreadids;/* The worker thread IDs. */
-
-    /* linked list of uri handlers */
-    struct mg_request_handler_info *request_handlers;
-};
-
-struct mg_connection {
-    struct mg_request_info request_info;
-    struct mg_context *ctx;
-    SSL *ssl;                   /* SSL descriptor */
-    SSL_CTX *client_ssl_ctx;    /* SSL context for client connections */
-    struct socket client;       /* Connected client */
-    time_t birth_time;          /* Time when request was received */
-    int64_t num_bytes_sent;     /* Total bytes sent to client */
-    int64_t content_len;        /* Content-Length header value */
-    int64_t consumed_content;   /* How many bytes of content have been read */
-    char *buf;                  /* Buffer for received data */
-    char *path_info;            /* PATH_INFO part of the URL */
-    int must_close;             /* 1 if connection must be closed */
-    int buf_size;               /* Buffer size */
-    int request_len;            /* Size of the request + headers in a buffer */
-    int data_len;               /* Total size of data in a buffer */
-    int status_code;            /* HTTP reply status code, e.g. 200 */
-    int throttle;               /* Throttling, bytes/sec. <= 0 means no
-                                   throttle */
-    time_t last_throttle_time;  /* Last time throttled data was sent */
-    int64_t last_throttle_bytes;/* Bytes sent this second */
-    pthread_mutex_t mutex;      /* Used by mg_lock/mg_unlock to ensure atomic
-                                   transmissions for websockets */
-};
-
-static pthread_key_t sTlsKey;  /* Thread local storage index */
-static int sTlsInit = 0;
-
-struct mg_workerTLS {
-    int is_master;
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-    HANDLE pthread_cond_helper_mutex;
-#endif
-};
-
-/* Directory entry */
-struct de {
-    struct mg_connection *conn;
-    char *file_name;
-    struct file file;
-};
-
-const char **mg_get_valid_option_names(void)
-{
-    return config_options;
-}
-
-static int is_file_in_memory(struct mg_connection *conn, const char *path,
-                             struct file *filep)
-{
-    size_t size = 0;
-    if ((filep->membuf = conn->ctx->callbacks.open_file == NULL ? NULL :
-                         conn->ctx->callbacks.open_file(conn, path, &size)) != NULL) {
-        /* NOTE: override filep->size only on success. Otherwise, it might
-           break constructs like if (!mg_stat() || !mg_fopen()) ... */
-        filep->size = size;
-    }
-    return filep->membuf != NULL;
-}
-
-static int is_file_opened(const struct file *filep)
-{
-    return filep->membuf != NULL || filep->fp != NULL;
-}
-
-static int mg_fopen(struct mg_connection *conn, const char *path,
-                    const char *mode, struct file *filep)
-{
-    if (!is_file_in_memory(conn, path, filep)) {
-#ifdef _WIN32
-        wchar_t wbuf[PATH_MAX], wmode[20];
-        to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
-        MultiByteToWideChar(CP_UTF8, 0, mode, -1, wmode, ARRAY_SIZE(wmode));
-        filep->fp = _wfopen(wbuf, wmode);
-#else
-        filep->fp = fopen(path, mode);
-#endif
-    }
-
-    return is_file_opened(filep);
-}
-
-static void mg_fclose(struct file *filep)
-{
-    if (filep != NULL && filep->fp != NULL) {
-        fclose(filep->fp);
-    }
-}
-
-static int get_option_index(const char *name)
-{
-    int i;
-
-    for (i = 0; config_options[i * 2] != NULL; i++) {
-        if (strcmp(config_options[i * 2], name) == 0) {
-            return i;
-        }
-    }
-    return -1;
-}
-
-const char *mg_get_option(const struct mg_context *ctx, const char *name)
-{
-    int i;
-    if ((i = get_option_index(name)) == -1) {
-        return NULL;
-    } else if (ctx->config[i] == NULL) {
-        return "";
-    } else {
-        return ctx->config[i];
-    }
-}
-
-static void sockaddr_to_string(char *buf, size_t len,
-                               const union usa *usa)
-{
-    buf[0] = '\0';
-#if defined(USE_IPV6)
-    inet_ntop(usa->sa.sa_family, usa->sa.sa_family == AF_INET ?
-              (void *) &usa->sin.sin_addr :
-              (void *) &usa->sin6.sin6_addr, buf, len);
-#elif defined(_WIN32)
-    /* Only Windoze Vista (and newer) have inet_ntop() */
-    strncpy(buf, inet_ntoa(usa->sin.sin_addr), len);
-#else
-    inet_ntop(usa->sa.sa_family, (void *) &usa->sin.sin_addr, buf, len);
-#endif
-}
-
-/* Print error message to the opened error log stream. */
-void mg_cry(struct mg_connection *conn, const char *fmt, ...)
-{
-    char buf[MG_BUF_LEN], src_addr[IP_ADDR_STR_LEN];
-    va_list ap;
-    FILE *fp;
-    time_t timestamp;
-
-    va_start(ap, fmt);
-    IGNORE_UNUSED_RESULT(vsnprintf(buf, sizeof(buf), fmt, ap));
-    va_end(ap);
-
-    /* Do not lock when getting the callback value, here and below.
-       I suppose this is fine, since function cannot disappear in the
-       same way string option can. */
-    if (conn->ctx->callbacks.log_message == NULL ||
-        conn->ctx->callbacks.log_message(conn, buf) == 0) {
-        fp = conn->ctx->config[ERROR_LOG_FILE] == NULL ? NULL :
-             fopen(conn->ctx->config[ERROR_LOG_FILE], "a+");
-
-        if (fp != NULL) {
-            flockfile(fp);
-            timestamp = time(NULL);
-
-            sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa);
-            fprintf(fp, "[%010lu] [error] [client %s] ", (unsigned long) timestamp,
-                    src_addr);
-
-            if (conn->request_info.request_method != NULL) {
-                fprintf(fp, "%s %s: ", conn->request_info.request_method,
-                        conn->request_info.uri);
-            }
-
-            fprintf(fp, "%s", buf);
-            fputc('\n', fp);
-            funlockfile(fp);
-            fclose(fp);
-        }
-    }
-}
-
-/* Return fake connection structure. Used for logging, if connection
-   is not applicable at the moment of logging. */
-static struct mg_connection *fc(struct mg_context *ctx)
-{
-    static struct mg_connection fake_connection;
-    fake_connection.ctx = ctx;
-    return &fake_connection;
-}
-
-const char *mg_version(void)
-{
-    return CIVETWEB_VERSION;
-}
-
-struct mg_request_info *mg_get_request_info(struct mg_connection *conn)
-{
-    return &conn->request_info;
-}
-
-static void mg_strlcpy(register char *dst, register const char *src, size_t n)
-{
-    for (; *src != '\0' && n > 1; n--) {
-        *dst++ = *src++;
-    }
-    *dst = '\0';
-}
-
-static int lowercase(const char *s)
-{
-    return tolower(* (const unsigned char *) s);
-}
-
-int mg_strncasecmp(const char *s1, const char *s2, size_t len)
-{
-    int diff = 0;
-
-    if (len > 0)
-        do {
-            diff = lowercase(s1++) - lowercase(s2++);
-        } while (diff == 0 && s1[-1] != '\0' && --len > 0);
-
-    return diff;
-}
-
-static int mg_strcasecmp(const char *s1, const char *s2)
-{
-    int diff;
-
-    do {
-        diff = lowercase(s1++) - lowercase(s2++);
-    } while (diff == 0 && s1[-1] != '\0');
-
-    return diff;
-}
-
-static char * mg_strndup(const char *ptr, size_t len)
-{
-    char *p;
-
-    if ((p = (char *) malloc(len + 1)) != NULL) {
-        mg_strlcpy(p, ptr, len + 1);
-    }
-
-    return p;
-}
-
-static char * mg_strdup(const char *str)
-{
-    return mg_strndup(str, strlen(str));
-}
-
-static const char *mg_strcasestr(const char *big_str, const char *small_str)
-{
-    int i, big_len = (int)strlen(big_str), small_len = (int)strlen(small_str);
-
-    for (i = 0; i <= big_len - small_len; i++) {
-        if (mg_strncasecmp(big_str + i, small_str, small_len) == 0) {
-            return big_str + i;
-        }
-    }
-
-    return NULL;
-}
-
-/* Like snprintf(), but never returns negative value, or a value
-   that is larger than a supplied buffer.
-   Thanks to Adam Zeldis to pointing snprintf()-caused vulnerability
-   in his audit report. */
-static int mg_vsnprintf(struct mg_connection *conn, char *buf, size_t buflen,
-                        const char *fmt, va_list ap)
-{
-    int n;
-
-    if (buflen == 0)
-        return 0;
-
-    n = vsnprintf(buf, buflen, fmt, ap);
-
-    if (n < 0) {
-        mg_cry(conn, "vsnprintf error");
-        n = 0;
-    } else if (n >= (int) buflen) {
-        mg_cry(conn, "truncating vsnprintf buffer: [%.*s]",
-               n > 200 ? 200 : n, buf);
-        n = (int) buflen - 1;
-    }
-    buf[n] = '\0';
-
-    return n;
-}
-
-static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
-                       PRINTF_FORMAT_STRING(const char *fmt), ...)
-PRINTF_ARGS(4, 5);
-
-static int mg_snprintf(struct mg_connection *conn, char *buf, size_t buflen,
-                       const char *fmt, ...)
-{
-    va_list ap;
-    int n;
-
-    va_start(ap, fmt);
-    n = mg_vsnprintf(conn, buf, buflen, fmt, ap);
-    va_end(ap);
-
-    return n;
-}
-
-/* Skip the characters until one of the delimiters characters found.
-   0-terminate resulting word. Skip the delimiter and following whitespaces.
-   Advance pointer to buffer to the next word. Return found 0-terminated word.
-   Delimiters can be quoted with quotechar. */
-static char *skip_quoted(char **buf, const char *delimiters,
-                         const char *whitespace, char quotechar)
-{
-    char *p, *begin_word, *end_word, *end_whitespace;
-
-    begin_word = *buf;
-    end_word = begin_word + strcspn(begin_word, delimiters);
-
-    /* Check for quotechar */
-    if (end_word > begin_word) {
-        p = end_word - 1;
-        while (*p == quotechar) {
-            /* If there is anything beyond end_word, copy it */
-            if (*end_word == '\0') {
-                *p = '\0';
-                break;
-            } else {
-                size_t end_off = strcspn(end_word + 1, delimiters);
-                memmove (p, end_word, end_off + 1);
-                p += end_off; /* p must correspond to end_word - 1 */
-                end_word += end_off + 1;
-            }
-        }
-        for (p++; p < end_word; p++) {
-            *p = '\0';
-        }
-    }
-
-    if (*end_word == '\0') {
-        *buf = end_word;
-    } else {
-        end_whitespace = end_word + 1 + strspn(end_word + 1, whitespace);
-
-        for (p = end_word; p < end_whitespace; p++) {
-            *p = '\0';
-        }
-
-        *buf = end_whitespace;
-    }
-
-    return begin_word;
-}
-
-/* Simplified version of skip_quoted without quote char
-   and whitespace == delimiters */
-static char *skip(char **buf, const char *delimiters)
-{
-    return skip_quoted(buf, delimiters, delimiters, 0);
-}
-
-
-/* Return HTTP header value, or NULL if not found. */
-static const char *get_header(const struct mg_request_info *ri,
-                              const char *name)
-{
-    int i;
-
-    for (i = 0; i < ri->num_headers; i++)
-        if (!mg_strcasecmp(name, ri->http_headers[i].name))
-            return ri->http_headers[i].value;
-
-    return NULL;
-}
-
-const char *mg_get_header(const struct mg_connection *conn, const char *name)
-{
-    return get_header(&conn->request_info, name);
-}
-
-/* A helper function for traversing a comma separated list of values.
-   It returns a list pointer shifted to the next value, or NULL if the end
-   of the list found.
-   Value is stored in val vector. If value has form "x=y", then eq_val
-   vector is initialized to point to the "y" part, and val vector length
-   is adjusted to point only to "x". */
-static const char *next_option(const char *list, struct vec *val,
-                               struct vec *eq_val)
-{
-    if (list == NULL || *list == '\0') {
-        /* End of the list */
-        list = NULL;
-    } else {
-        val->ptr = list;
-        if ((list = strchr(val->ptr, ',')) != NULL) {
-            /* Comma found. Store length and shift the list ptr */
-            val->len = list - val->ptr;
-            list++;
-        } else {
-            /* This value is the last one */
-            list = val->ptr + strlen(val->ptr);
-            val->len = list - val->ptr;
-        }
-
-        if (eq_val != NULL) {
-            /* Value has form "x=y", adjust pointers and lengths
-               so that val points to "x", and eq_val points to "y". */
-            eq_val->len = 0;
-            eq_val->ptr = (const char *) memchr(val->ptr, '=', val->len);
-            if (eq_val->ptr != NULL) {
-                eq_val->ptr++;  /* Skip over '=' character */
-                eq_val->len = val->ptr + val->len - eq_val->ptr;
-                val->len = (eq_val->ptr - val->ptr) - 1;
-            }
-        }
-    }
-
-    return list;
-}
-
-/* Perform case-insensitive match of string against pattern */
-static int match_prefix(const char *pattern, int pattern_len, const char *str)
-{
-    const char *or_str;
-    int i, j, len, res;
-
-    if ((or_str = (const char *) memchr(pattern, '|', pattern_len)) != NULL) {
-        res = match_prefix(pattern, (int)(or_str - pattern), str);
-        return res > 0 ? res :
-               match_prefix(or_str + 1, (int)((pattern + pattern_len) - (or_str + 1)), str);
-    }
-
-    i = j = 0;
-    res = -1;
-    for (; i < pattern_len; i++, j++) {
-        if (pattern[i] == '?' && str[j] != '\0') {
-            continue;
-        } else if (pattern[i] == '$') {
-            return str[j] == '\0' ? j : -1;
-        } else if (pattern[i] == '*') {
-            i++;
-            if (pattern[i] == '*') {
-                i++;
-                len = (int) strlen(str + j);
-            } else {
-                len = (int) strcspn(str + j, "/");
-            }
-            if (i == pattern_len) {
-                return j + len;
-            }
-            do {
-                res = match_prefix(pattern + i, pattern_len - i, str + j + len);
-            } while (res == -1 && len-- > 0);
-            return res == -1 ? -1 : j + res + len;
-        } else if (lowercase(&pattern[i]) != lowercase(&str[j])) {
-            return -1;
-        }
-    }
-    return j;
-}
-
-/* HTTP 1.1 assumes keep alive if "Connection:" header is not set
-   This function must tolerate situations when connection info is not
-   set up, for example if request parsing failed. */
-static int should_keep_alive(const struct mg_connection *conn)
-{
-    const char *http_version = conn->request_info.http_version;
-    const char *header = mg_get_header(conn, "Connection");
-    if (conn->must_close ||
-        conn->status_code == 401 ||
-        mg_strcasecmp(conn->ctx->config[ENABLE_KEEP_ALIVE], "yes") != 0 ||
-        (header != NULL && mg_strcasecmp(header, "keep-alive") != 0) ||
-        (header == NULL && http_version && strcmp(http_version, "1.1"))) {
-        return 0;
-    }
-    return 1;
-}
-
-static const char *suggest_connection_header(const struct mg_connection *conn)
-{
-    return should_keep_alive(conn) ? "keep-alive" : "close";
-}
-
-static void send_http_error(struct mg_connection *, int, const char *,
-                            PRINTF_FORMAT_STRING(const char *fmt), ...)
-PRINTF_ARGS(4, 5);
-
-
-static void send_http_error(struct mg_connection *conn, int status,
-                            const char *reason, const char *fmt, ...)
-{
-    char buf[MG_BUF_LEN];
-    va_list ap;
-    int len = 0;
-
-    conn->status_code = status;
-    if (conn->ctx->callbacks.http_error == NULL ||
-        conn->ctx->callbacks.http_error(conn, status)) {
-        buf[0] = '\0';
-
-        /* Errors 1xx, 204 and 304 MUST NOT send a body */
-        if (status > 199 && status != 204 && status != 304) {
-            len = mg_snprintf(conn, buf, sizeof(buf), "Error %d: %s", status, reason);
-            buf[len++] = '\n';
-
-            va_start(ap, fmt);
-            len += mg_vsnprintf(conn, buf + len, sizeof(buf) - len, fmt, ap);
-            va_end(ap);
-        }
-        DEBUG_TRACE(("[%s]", buf));
-
-        mg_printf(conn, "HTTP/1.1 %d %s\r\n"
-                  "Content-Length: %d\r\n"
-                  "Connection: %s\r\n\r\n", status, reason, len,
-                  suggest_connection_header(conn));
-        conn->num_bytes_sent += mg_printf(conn, "%s", buf);
-    }
-}
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-static int pthread_mutex_init(pthread_mutex_t *mutex, void *unused)
-{
-    (void) unused;
-    *mutex = CreateMutex(NULL, FALSE, NULL);
-    return *mutex == NULL ? -1 : 0;
-}
-
-static int pthread_mutex_destroy(pthread_mutex_t *mutex)
-{
-    return CloseHandle(*mutex) == 0 ? -1 : 0;
-}
-
-static int pthread_mutex_lock(pthread_mutex_t *mutex)
-{
-    return WaitForSingleObject(*mutex, INFINITE) == WAIT_OBJECT_0? 0 : -1;
-}
-
-static int pthread_mutex_unlock(pthread_mutex_t *mutex)
-{
-    return ReleaseMutex(*mutex) == 0 ? -1 : 0;
-}
-
-static int clock_gettime(clockid_t clk_id, struct timespec *tp)
-{
-    FILETIME ft;
-    ULARGE_INTEGER li;
-    BOOL ok = FALSE;
-    double d;
-    static double perfcnt_per_sec = 0.0;
-
-    if (tp) {
-        if (clk_id == CLOCK_REALTIME) {
-            GetSystemTimeAsFileTime(&ft);
-            li.LowPart = ft.dwLowDateTime;
-            li.HighPart = ft.dwHighDateTime;
-            li.QuadPart -= 116444736000000000; /* 1.1.1970 in filedate */
-            tp->tv_sec = (time_t)(li.QuadPart / 10000000);
-            tp->tv_nsec = (long)(li.QuadPart % 10000000) * 100;
-            ok = TRUE;
-        } else if (clk_id == CLOCK_MONOTONIC) {
-            if (perfcnt_per_sec==0) {
-                QueryPerformanceFrequency((LARGE_INTEGER *) &li);
-                perfcnt_per_sec = 1.0 / li.QuadPart;
-            }
-            if (perfcnt_per_sec!=0) {
-                QueryPerformanceCounter((LARGE_INTEGER *) &li);
-                d = li.QuadPart * perfcnt_per_sec;
-                tp->tv_sec = (time_t)d;
-                d -= tp->tv_sec;
-                tp->tv_nsec = (long)(d*1.0E9);
-                ok = TRUE;
-            }
-        }
-    }
-
-    return ok ? 0 : -1;
-}
-
-static int pthread_cond_init(pthread_cond_t *cv, const void *unused)
-{
-    (void) unused;
-    InitializeCriticalSection(&cv->threadIdSec);
-    cv->waitingthreadcount = 0;
-    cv->waitingthreadhdls = calloc(MAX_WORKER_THREADS, sizeof(pthread_t));
-    return (cv->waitingthreadhdls!=NULL) ? 0 : -1;
-}
-
-static int pthread_cond_timedwait(pthread_cond_t *cv, pthread_mutex_t *mutex, const struct timespec * abstime)
-{
-    struct mg_workerTLS * tls = (struct mg_workerTLS *)TlsGetValue(sTlsKey);
-    int ok;
-    struct timespec tsnow;
-    int64_t nsnow, nswaitabs, nswaitrel;
-    DWORD mswaitrel;
-
-    EnterCriticalSection(&cv->threadIdSec);
-    assert(cv->waitingthreadcount < MAX_WORKER_THREADS);
-    cv->waitingthreadhdls[cv->waitingthreadcount] = tls->pthread_cond_helper_mutex;
-    cv->waitingthreadcount++;
-    LeaveCriticalSection(&cv->threadIdSec);
-
-    if (abstime) {
-        clock_gettime(CLOCK_REALTIME, &tsnow);
-        nsnow = (((uint64_t)tsnow.tv_sec)<<32) + tsnow.tv_nsec;
-        nswaitabs = (((uint64_t)abstime->tv_sec)<<32) + abstime->tv_nsec;
-        nswaitrel = nswaitabs - nsnow;
-        if (nswaitrel<0) nswaitrel=0;
-        mswaitrel = (DWORD)(nswaitrel / 1000000);
-    } else {
-        mswaitrel = INFINITE;
-    }
-
-    pthread_mutex_unlock(mutex);
-    ok = (WAIT_OBJECT_0 == WaitForSingleObject(tls->pthread_cond_helper_mutex, mswaitrel));
-    pthread_mutex_lock(mutex);
-
-    return ok ? 0 : -1;
-}
-
-static int pthread_cond_wait(pthread_cond_t *cv, pthread_mutex_t *mutex)
-{
-    return pthread_cond_timedwait(cv, mutex, NULL);
-}
-
-static int pthread_cond_signal(pthread_cond_t *cv)
-{
-    int i;
-    HANDLE wkup = NULL;
-    BOOL ok = FALSE;
-
-    EnterCriticalSection(&cv->threadIdSec);
-    if (cv->waitingthreadcount) {
-        wkup = cv->waitingthreadhdls[0];
-        ok = SetEvent(wkup);
-
-        for (i=1; i<cv->waitingthreadcount; i++) {
-            cv->waitingthreadhdls[i-1] = cv->waitingthreadhdls[i];
-        }
-        cv->waitingthreadcount--;
-
-        assert(ok);
-    }
-    LeaveCriticalSection(&cv->threadIdSec);
-
-    return ok ? 0 : 1;
-}
-
-static int pthread_cond_broadcast(pthread_cond_t *cv)
-{
-    EnterCriticalSection(&cv->threadIdSec);
-    while (cv->waitingthreadcount) {
-        pthread_cond_signal(cv);
-    }
-    LeaveCriticalSection(&cv->threadIdSec);
-
-    return 0;
-}
-
-static int pthread_cond_destroy(pthread_cond_t *cv)
-{
-    EnterCriticalSection(&cv->threadIdSec);
-    assert(cv->waitingthreadcount==0);
-    cv->waitingthreadhdls = 0;
-    free(cv->waitingthreadhdls);
-    LeaveCriticalSection(&cv->threadIdSec);
-    DeleteCriticalSection(&cv->threadIdSec);
-
-    return 0;
-}
-
-/* For Windows, change all slashes to backslashes in path names. */
-static void change_slashes_to_backslashes(char *path)
-{
-    int i;
-
-    for (i = 0; path[i] != '\0'; i++) {
-        if (path[i] == '/')
-            path[i] = '\\';
-        /* i > 0 check is to preserve UNC paths, like \\server\file.txt */
-        if (path[i] == '\\' && i > 0)
-            while (path[i + 1] == '\\' || path[i + 1] == '/')
-                (void) memmove(path + i + 1,
-                               path + i + 2, strlen(path + i + 1));
-    }
-}
-
-/* Encode 'path' which is assumed UTF-8 string, into UNICODE string.
-   wbuf and wbuf_len is a target buffer and its length. */
-static void to_unicode(const char *path, wchar_t *wbuf, size_t wbuf_len)
-{
-    char buf[PATH_MAX], buf2[PATH_MAX];
-
-    mg_strlcpy(buf, path, sizeof(buf));
-    change_slashes_to_backslashes(buf);
-
-    /* Convert to Unicode and back. If doubly-converted string does not
-       match the original, something is fishy, reject. */
-    memset(wbuf, 0, wbuf_len * sizeof(wchar_t));
-    MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, (int) wbuf_len);
-    WideCharToMultiByte(CP_UTF8, 0, wbuf, (int) wbuf_len, buf2, sizeof(buf2),
-                        NULL, NULL);
-    if (strcmp(buf, buf2) != 0) {
-        wbuf[0] = L'\0';
-    }
-}
-
-#if defined(_WIN32_WCE)
-static time_t time(time_t *ptime)
-{
-    time_t t;
-    SYSTEMTIME st;
-    FILETIME ft;
-
-    GetSystemTime(&st);
-    SystemTimeToFileTime(&st, &ft);
-    t = SYS2UNIX_TIME(ft.dwLowDateTime, ft.dwHighDateTime);
-
-    if (ptime != NULL) {
-        *ptime = t;
-    }
-
-    return t;
-}
-
-static struct tm *localtime(const time_t *ptime, struct tm *ptm)
-{
-    int64_t t = ((int64_t) *ptime) * RATE_DIFF + EPOCH_DIFF;
-    FILETIME ft, lft;
-    SYSTEMTIME st;
-    TIME_ZONE_INFORMATION tzinfo;
-
-    if (ptm == NULL) {
-        return NULL;
-    }
-
-    * (int64_t *) &ft = t;
-    FileTimeToLocalFileTime(&ft, &lft);
-    FileTimeToSystemTime(&lft, &st);
-    ptm->tm_year = st.wYear - 1900;
-    ptm->tm_mon = st.wMonth - 1;
-    ptm->tm_wday = st.wDayOfWeek;
-    ptm->tm_mday = st.wDay;
-    ptm->tm_hour = st.wHour;
-    ptm->tm_min = st.wMinute;
-    ptm->tm_sec = st.wSecond;
-    ptm->tm_yday = 0; /* hope nobody uses this */
-    ptm->tm_isdst =
-        GetTimeZoneInformation(&tzinfo) == TIME_ZONE_ID_DAYLIGHT ? 1 : 0;
-
-    return ptm;
-}
-
-static struct tm *gmtime(const time_t *ptime, struct tm *ptm)
-{
-    /* FIXME(lsm): fix this. */
-    return localtime(ptime, ptm);
-}
-
-static size_t strftime(char *dst, size_t dst_size, const char *fmt,
-                       const struct tm *tm)
-{
-    (void) snprintf(dst, dst_size, "implement strftime() for WinCE");
-    return 0;
-}
-#endif
-
-/* Windows happily opens files with some garbage at the end of file name.
-   For example, fopen("a.cgi    ", "r") on Windows successfully opens
-   "a.cgi", despite one would expect an error back.
-   This function returns non-0 if path ends with some garbage. */
-static int path_cannot_disclose_cgi(const char *path)
-{
-    static const char *allowed_last_characters = "_-";
-    int last = path[strlen(path) - 1];
-    return isalnum(last) || strchr(allowed_last_characters, last) != NULL;
-}
-
-static int mg_stat(struct mg_connection *conn, const char *path,
-                   struct file *filep)
-{
-    wchar_t wbuf[PATH_MAX];
-    WIN32_FILE_ATTRIBUTE_DATA info;
-
-    if (!is_file_in_memory(conn, path, filep)) {
-        to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
-        if (GetFileAttributesExW(wbuf, GetFileExInfoStandard, &info) != 0) {
-            filep->size = MAKEUQUAD(info.nFileSizeLow, info.nFileSizeHigh);
-            filep->modification_time = SYS2UNIX_TIME(
-                                           info.ftLastWriteTime.dwLowDateTime,
-                                           info.ftLastWriteTime.dwHighDateTime);
-            filep->is_directory = info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
-            /* If file name is fishy, reset the file structure and return
-               error.
-               Note it is important to reset, not just return the error, cause
-               functions like is_file_opened() check the struct. */
-            if (!filep->is_directory && !path_cannot_disclose_cgi(path)) {
-                memset(filep, 0, sizeof(*filep));
-            }
-        }
-    }
-
-    return filep->membuf != NULL || filep->modification_time != 0;
-}
-
-static int mg_remove(const char *path)
-{
-    wchar_t wbuf[PATH_MAX];
-    to_unicode(path, wbuf, ARRAY_SIZE(wbuf));
-    return DeleteFileW(wbuf) ? 0 : -1;
-}
-
-static int mg_mkdir(const char *path, int mode)
-{
-    char buf[PATH_MAX];
-    wchar_t wbuf[PATH_MAX];
-
-    (void) mode;
-    mg_strlcpy(buf, path, sizeof(buf));
-    change_slashes_to_backslashes(buf);
-
-    (void) MultiByteToWideChar(CP_UTF8, 0, buf, -1, wbuf, ARRAY_SIZE(wbuf));
-
-    return CreateDirectoryW(wbuf, NULL) ? 0 : -1;
-}
-
-/* Implementation of POSIX opendir/closedir/readdir for Windows. */
-static DIR * opendir(const char *name)
-{
-    DIR *dir = NULL;
-    wchar_t wpath[PATH_MAX];
-    DWORD attrs;
-
-    if (name == NULL) {
-        SetLastError(ERROR_BAD_ARGUMENTS);
-    } else if ((dir = (DIR *) malloc(sizeof(*dir))) == NULL) {
-        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
-    } else {
-        to_unicode(name, wpath, ARRAY_SIZE(wpath));
-        attrs = GetFileAttributesW(wpath);
-        if (attrs != 0xFFFFFFFF &&
-            ((attrs & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)) {
-            (void) wcscat(wpath, L"\\*");
-            dir->handle = FindFirstFileW(wpath, &dir->info);
-            dir->result.d_name[0] = '\0';
-        } else {
-            free(dir);
-            dir = NULL;
-        }
-    }
-
-    return dir;
-}
-
-static int closedir(DIR *dir)
-{
-    int result = 0;
-
-    if (dir != NULL) {
-        if (dir->handle != INVALID_HANDLE_VALUE)
-            result = FindClose(dir->handle) ? 0 : -1;
-
-        free(dir);
-    } else {
-        result = -1;
-        SetLastError(ERROR_BAD_ARGUMENTS);
-    }
-
-    return result;
-}
-
-static struct dirent *readdir(DIR *dir)
-{
-    struct dirent *result = 0;
-
-    if (dir) {
-        if (dir->handle != INVALID_HANDLE_VALUE) {
-            result = &dir->result;
-            (void) WideCharToMultiByte(CP_UTF8, 0,
-                                       dir->info.cFileName, -1, result->d_name,
-                                       sizeof(result->d_name), NULL, NULL);
-
-            if (!FindNextFileW(dir->handle, &dir->info)) {
-                (void) FindClose(dir->handle);
-                dir->handle = INVALID_HANDLE_VALUE;
-            }
-
-        } else {
-            SetLastError(ERROR_FILE_NOT_FOUND);
-        }
-    } else {
-        SetLastError(ERROR_BAD_ARGUMENTS);
-    }
-
-    return result;
-}
-
-#ifndef HAVE_POLL
-static int poll(struct pollfd *pfd, int n, int milliseconds)
-{
-    struct timeval tv;
-    fd_set set;
-    int i, result;
-    SOCKET maxfd = 0;
-
-    tv.tv_sec = milliseconds / 1000;
-    tv.tv_usec = (milliseconds % 1000) * 1000;
-    FD_ZERO(&set);
-
-    for (i = 0; i < n; i++) {
-        FD_SET((SOCKET) pfd[i].fd, &set);
-        pfd[i].revents = 0;
-
-        if (pfd[i].fd > maxfd) {
-            maxfd = pfd[i].fd;
-        }
-    }
-
-    if ((result = select((int)maxfd + 1, &set, NULL, NULL, &tv)) > 0) {
-        for (i = 0; i < n; i++) {
-            if (FD_ISSET(pfd[i].fd, &set)) {
-                pfd[i].revents = POLLIN;
-            }
-        }
-    }
-
-    return result;
-}
-#endif /* HAVE_POLL */
-
-static void set_close_on_exec(SOCKET sock, struct mg_connection *conn /* may be null */)
-{
-    (void) conn; /* Unused. */
-    (void) SetHandleInformation((HANDLE) sock, HANDLE_FLAG_INHERIT, 0);
-}
-
-int mg_start_thread(mg_thread_func_t f, void *p)
-{
-#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
-    /* Compile-time option to control stack size, e.g. -DUSE_STACK_SIZE=16384 */
-    return (long)_beginthread((void (__cdecl *)(void *)) f, USE_STACK_SIZE, p) == -1L ? -1 : 0;
-#else
-    return (long)_beginthread((void (__cdecl *)(void *)) f, 0, p) == -1L ? -1 : 0;
-#endif /* defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) */
-}
-
-/* Start a thread storing the thread context. */
-
-static int mg_start_thread_with_id(unsigned (__stdcall *f)(void *), void *p,
-                                   pthread_t *threadidptr)
-{
-    uintptr_t uip;
-    HANDLE threadhandle;
-    int result;
-
-    uip = _beginthreadex(NULL, 0, (unsigned (__stdcall *)(void *)) f, p, 0,
-                         NULL);
-    threadhandle = (HANDLE) uip;
-    if (threadidptr != NULL) {
-        *threadidptr = threadhandle;
-    }
-    result = (threadhandle == NULL) ? -1 : 0;
-
-    return result;
-}
-
-/* Wait for a thread to finish. */
-
-static int mg_join_thread(pthread_t threadid)
-{
-    int result;
-    DWORD dwevent;
-
-    result = -1;
-    dwevent = WaitForSingleObject(threadid, INFINITE);
-    if (dwevent == WAIT_FAILED) {
-        int err;
-
-        err = GetLastError();
-        DEBUG_TRACE(("WaitForSingleObject() failed, error %d", err));
-    } else {
-        if (dwevent == WAIT_OBJECT_0) {
-            CloseHandle(threadid);
-            result = 0;
-        }
-    }
-
-    return result;
-}
-
-static HANDLE dlopen(const char *dll_name, int flags)
-{
-    wchar_t wbuf[PATH_MAX];
-    (void) flags;
-    to_unicode(dll_name, wbuf, ARRAY_SIZE(wbuf));
-    return LoadLibraryW(wbuf);
-}
-
-static int dlclose(void *handle)
-{
-    int result;
-
-    if (FreeLibrary(handle) != 0) {
-        result = 0;
-    } else {
-        result = -1;
-    }
-
-    return result;
-}
-
-#if !defined(NO_CGI)
-#define SIGKILL 0
-static int kill(pid_t pid, int sig_num)
-{
-    (void) TerminateProcess(pid, sig_num);
-    (void) CloseHandle(pid);
-    return 0;
-}
-
-static void trim_trailing_whitespaces(char *s)
-{
-    char *e = s + strlen(s) - 1;
-    while (e > s && isspace(* (unsigned char *) e)) {
-        *e-- = '\0';
-    }
-}
-
-static pid_t spawn_process(struct mg_connection *conn, const char *prog,
-                           char *envblk, char *envp[], int fdin,
-                           int fdout, const char *dir)
-{
-    HANDLE me;
-    char *p, *interp, full_interp[PATH_MAX], full_dir[PATH_MAX],
-         cmdline[PATH_MAX], buf[PATH_MAX];
-    struct file file = STRUCT_FILE_INITIALIZER;
-    STARTUPINFOA si;
-    PROCESS_INFORMATION pi = { 0 };
-
-    (void) envp;
-
-    memset(&si, 0, sizeof(si));
-    si.cb = sizeof(si);
-
-    /* TODO(lsm): redirect CGI errors to the error log file */
-    si.dwFlags = STARTF_USESTDHANDLES | STARTF_USESHOWWINDOW;
-    si.wShowWindow = SW_HIDE;
-
-    me = GetCurrentProcess();
-    DuplicateHandle(me, (HANDLE) _get_osfhandle(fdin), me,
-                    &si.hStdInput, 0, TRUE, DUPLICATE_SAME_ACCESS);
-    DuplicateHandle(me, (HANDLE) _get_osfhandle(fdout), me,
-                    &si.hStdOutput, 0, TRUE, DUPLICATE_SAME_ACCESS);
-
-    /* If CGI file is a script, try to read the interpreter line */
-    interp = conn->ctx->config[CGI_INTERPRETER];
-    if (interp == NULL) {
-        buf[0] = buf[1] = '\0';
-
-        /* Read the first line of the script into the buffer */
-        snprintf(cmdline, sizeof(cmdline), "%s%c%s", dir, '/', prog);
-        if (mg_fopen(conn, cmdline, "r", &file)) {
-            p = (char *) file.membuf;
-            mg_fgets(buf, sizeof(buf), &file, &p);
-            mg_fclose(&file);
-            buf[sizeof(buf) - 1] = '\0';
-        }
-
-        if (buf[0] == '#' && buf[1] == '!') {
-            trim_trailing_whitespaces(buf + 2);
-        } else {
-            buf[2] = '\0';
-        }
-        interp = buf + 2;
-    }
-
-    if (interp[0] != '\0') {
-        GetFullPathNameA(interp, sizeof(full_interp), full_interp, NULL);
-        interp = full_interp;
-    }
-    GetFullPathNameA(dir, sizeof(full_dir), full_dir, NULL);
-
-    mg_snprintf(conn, cmdline, sizeof(cmdline), "%s%s\"%s\\%s\"",
-                interp, interp[0] == '\0' ? "" : " ", full_dir, prog);
-
-    DEBUG_TRACE(("Running [%s]", cmdline));
-    if (CreateProcessA(NULL, cmdline, NULL, NULL, TRUE,
-                       CREATE_NEW_PROCESS_GROUP, envblk, NULL, &si, &pi) == 0) {
-        mg_cry(conn, "%s: CreateProcess(%s): %ld",
-               __func__, cmdline, ERRNO);
-        pi.hProcess = (pid_t) -1;
-    }
-
-    (void) CloseHandle(si.hStdOutput);
-    (void) CloseHandle(si.hStdInput);
-    if (pi.hThread != NULL)
-        (void) CloseHandle(pi.hThread);
-
-    return (pid_t) pi.hProcess;
-}
-#endif /* !NO_CGI */
-
-static int set_non_blocking_mode(SOCKET sock)
-{
-    unsigned long on = 1;
-    return ioctlsocket(sock, FIONBIO, &on);
-}
-
-#else
-static int mg_stat(struct mg_connection *conn, const char *path,
-                   struct file *filep)
-{
-    struct stat st;
-
-    if (!is_file_in_memory(conn, path, filep) && !stat(path, &st)) {
-        filep->size = st.st_size;
-        filep->modification_time = st.st_mtime;
-        filep->is_directory = S_ISDIR(st.st_mode);
-    } else {
-        filep->modification_time = (time_t) 0;
-    }
-
-    return filep->membuf != NULL || filep->modification_time != (time_t) 0;
-}
-
-static void set_close_on_exec(int fd, struct mg_connection *conn /* may be null */)
-{
-    if (fcntl(fd, F_SETFD, FD_CLOEXEC) != 0) {
-        if (conn)
-            mg_cry(conn, "%s: fcntl(F_SETFD FD_CLOEXEC) failed: %s",
-                   __func__, strerror(ERRNO));
-    }
-}
-
-int mg_start_thread(mg_thread_func_t func, void *param)
-{
-    pthread_t thread_id;
-    pthread_attr_t attr;
-    int result;
-
-    (void) pthread_attr_init(&attr);
-    (void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
-
-#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
-    /* Compile-time option to control stack size,
-       e.g. -DUSE_STACK_SIZE=16384 */
-    (void) pthread_attr_setstacksize(&attr, USE_STACK_SIZE);
-#endif /* defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1) */
-
-    result = pthread_create(&thread_id, &attr, func, param);
-    pthread_attr_destroy(&attr);
-
-    return result;
-}
-
-/* Start a thread storing the thread context. */
-
-static int mg_start_thread_with_id(mg_thread_func_t func, void *param,
-                                   pthread_t *threadidptr)
-{
-    pthread_t thread_id;
-    pthread_attr_t attr;
-    int result;
-
-    (void) pthread_attr_init(&attr);
-
-#if defined(USE_STACK_SIZE) && (USE_STACK_SIZE > 1)
-    /* Compile-time option to control stack size,
-       e.g. -DUSE_STACK_SIZE=16384 */
-    (void) pthread_attr_setstacksize(&attr, USE_STACK_SIZE);
-#endif /* defined(USE_STACK_SIZE) && USE_STACK_SIZE > 1 */
-
-    result = pthread_create(&thread_id, &attr, func, param);
-    pthread_attr_destroy(&attr);
-    if (threadidptr != NULL) {
-        *threadidptr = thread_id;
-    }
-    return result;
-}
-
-/* Wait for a thread to finish. */
-
-static int mg_join_thread(pthread_t threadid)
-{
-    int result;
-
-    result = pthread_join(threadid, NULL);
-    return result;
-}
-
-#ifndef NO_CGI
-static pid_t spawn_process(struct mg_connection *conn, const char *prog,
-                           char *envblk, char *envp[], int fdin,
-                           int fdout, const char *dir)
-{
-    pid_t pid;
-    const char *interp;
-
-    (void) envblk;
-
-    if ((pid = fork()) == -1) {
-        /* Parent */
-        send_http_error(conn, 500, http_500_error, "fork(): %s", strerror(ERRNO));
-    } else if (pid == 0) {
-        /* Child */
-        if (chdir(dir) != 0) {
-            mg_cry(conn, "%s: chdir(%s): %s", __func__, dir, strerror(ERRNO));
-        } else if (dup2(fdin, 0) == -1) {
-            mg_cry(conn, "%s: dup2(%d, 0): %s", __func__, fdin, strerror(ERRNO));
-        } else if (dup2(fdout, 1) == -1) {
-            mg_cry(conn, "%s: dup2(%d, 1): %s", __func__, fdout, strerror(ERRNO));
-        } else {
-            /* Not redirecting stderr to stdout, to avoid output being littered
-               with the error messages. */
-            (void) close(fdin);
-            (void) close(fdout);
-
-            /* After exec, all signal handlers are restored to their default
-               values, with one exception of SIGCHLD. According to
-               POSIX.1-2001 and Linux's implementation, SIGCHLD's handler will
-               leave unchanged after exec if it was set to be ignored. Restore
-               it to default action. */
-            signal(SIGCHLD, SIG_DFL);
-
-            interp = conn->ctx->config[CGI_INTERPRETER];
-            if (interp == NULL) {
-                (void) execle(prog, prog, NULL, envp);
-                mg_cry(conn, "%s: execle(%s): %s", __func__, prog, strerror(ERRNO));
-            } else {
-                (void) execle(interp, interp, prog, NULL, envp);
-                mg_cry(conn, "%s: execle(%s %s): %s", __func__, interp, prog,
-                       strerror(ERRNO));
-            }
-        }
-        exit(EXIT_FAILURE);
-    }
-
-    return pid;
-}
-#endif /* !NO_CGI */
-
-static int set_non_blocking_mode(SOCKET sock)
-{
-    int flags;
-
-    flags = fcntl(sock, F_GETFL, 0);
-    (void) fcntl(sock, F_SETFL, flags | O_NONBLOCK);
-
-    return 0;
-}
-#endif /* _WIN32 */
-
-/* Write data to the IO channel - opened file descriptor, socket or SSL
-   descriptor. Return number of bytes written. */
-static int64_t push(FILE *fp, SOCKET sock, SSL *ssl, const char *buf,
-                    int64_t len)
-{
-    int64_t sent;
-    int n, k;
-
-    (void) ssl;  /* Get rid of warning */
-    sent = 0;
-    while (sent < len) {
-
-        /* How many bytes we send in this iteration */
-        k = len - sent > INT_MAX ? INT_MAX : (int) (len - sent);
-
-#ifndef NO_SSL
-        if (ssl != NULL) {
-            n = SSL_write(ssl, buf + sent, k);
-        } else
-#endif
-            if (fp != NULL) {
-                n = (int) fwrite(buf + sent, 1, (size_t) k, fp);
-                if (ferror(fp))
-                    n = -1;
-            } else {
-                n = send(sock, buf + sent, (size_t) k, MSG_NOSIGNAL);
-            }
-
-        if (n <= 0)
-            break;
-
-        sent += n;
-    }
-
-    return sent;
-}
-
-/* Read from IO channel - opened file descriptor, socket, or SSL descriptor.
-   Return negative value on error, or number of bytes read on success. */
-static int pull(FILE *fp, struct mg_connection *conn, char *buf, int len)
-{
-    int nread;
-
-    if (fp != NULL) {
-        /* Use read() instead of fread(), because if we're reading from the
-           CGI pipe, fread() may block until IO buffer is filled up. We cannot
-           afford to block and must pass all read bytes immediately to the
-           client. */
-        nread = read(fileno(fp), buf, (size_t) len);
-#ifndef NO_SSL
-    } else if (conn->ssl != NULL) {
-        nread = SSL_read(conn->ssl, buf, len);
-#endif
-    } else {
-        nread = recv(conn->client.sock, buf, (size_t) len, 0);
-    }
-
-    return conn->ctx->stop_flag ? -1 : nread;
-}
-
-static int pull_all(FILE *fp, struct mg_connection *conn, char *buf, int len)
-{
-    int n, nread = 0;
-
-    while (len > 0 && conn->ctx->stop_flag == 0) {
-        n = pull(fp, conn, buf + nread, len);
-        if (n < 0) {
-            nread = n;  /* Propagate the error */
-            break;
-        } else if (n == 0) {
-            break;  /* No more data to read */
-        } else {
-            conn->consumed_content += n;
-            nread += n;
-            len -= n;
-        }
-    }
-
-    return nread;
-}
-
-int mg_read(struct mg_connection *conn, void *buf, size_t len)
-{
-    int n, buffered_len, nread;
-    const char *body;
-
-    /* If Content-Length is not set, read until socket is closed */
-    if (conn->consumed_content == 0 && conn->content_len == 0) {
-        conn->content_len = INT64_MAX;
-        conn->must_close = 1;
-    }
-
-    nread = 0;
-    if (conn->consumed_content < conn->content_len) {
-        /* Adjust number of bytes to read. */
-        int64_t to_read = conn->content_len - conn->consumed_content;
-        if (to_read < (int64_t) len) {
-            len = (size_t) to_read;
-        }
-
-        /* Return buffered data */
-        body = conn->buf + conn->request_len + conn->consumed_content;
-        buffered_len = (int)(&conn->buf[conn->data_len] - body);
-        if (buffered_len > 0) {
-            if (len < (size_t) buffered_len) {
-                buffered_len = (int) len;
-            }
-            memcpy(buf, body, (size_t) buffered_len);
-            len -= buffered_len;
-            conn->consumed_content += buffered_len;
-            nread += buffered_len;
-            buf = (char *) buf + buffered_len;
-        }
-
-        /* We have returned all buffered data. Read new data from the remote
-           socket. */
-        n = pull_all(NULL, conn, (char *) buf, (int) len);
-        nread = n >= 0 ? nread + n : n;
-    }
-    return nread;
-}
-
-int mg_write(struct mg_connection *conn, const void *buf, size_t len)
-{
-    time_t now;
-    int64_t n, total, allowed;
-
-    if (conn->throttle > 0) {
-        if ((now = time(NULL)) != conn->last_throttle_time) {
-            conn->last_throttle_time = now;
-            conn->last_throttle_bytes = 0;
-        }
-        allowed = conn->throttle - conn->last_throttle_bytes;
-        if (allowed > (int64_t) len) {
-            allowed = len;
-        }
-        if ((total = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
-                          (int64_t) allowed)) == allowed) {
-            buf = (char *) buf + total;
-            conn->last_throttle_bytes += total;
-            while (total < (int64_t) len && conn->ctx->stop_flag == 0) {
-                allowed = conn->throttle > (int64_t) len - total ?
-                          (int64_t) len - total : conn->throttle;
-                if ((n = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
-                              (int64_t) allowed)) != allowed) {
-                    break;
-                }
-                sleep(1);
-                conn->last_throttle_bytes = allowed;
-                conn->last_throttle_time = time(NULL);
-                buf = (char *) buf + n;
-                total += n;
-            }
-        }
-    } else {
-        total = push(NULL, conn->client.sock, conn->ssl, (const char *) buf,
-                     (int64_t) len);
-    }
-    return (int) total;
-}
-
-/* Alternative alloc_vprintf() for non-compliant C runtimes */
-static int alloc_vprintf2(char **buf, const char *fmt, va_list ap)
-{
-    va_list ap_copy;
-    int size = MG_BUF_LEN;
-    int len = -1;
-
-    *buf = NULL;
-    while (len == -1) {
-        if (*buf) free(*buf);
-        *buf = (char *)malloc(size *= 4);
-        if (!*buf) break;
-        va_copy(ap_copy, ap);
-        len = vsnprintf(*buf, size, fmt, ap_copy);
-        va_end(ap_copy);
-    }
-
-    return len;
-}
-
-/* Print message to buffer. If buffer is large enough to hold the message,
-   return buffer. If buffer is to small, allocate large enough buffer on heap,
-   and return allocated buffer. */
-static int alloc_vprintf(char **buf, size_t size, const char *fmt, va_list ap)
-{
-    va_list ap_copy;
-    int len;
-
-    /* Windows is not standard-compliant, and vsnprintf() returns -1 if
-       buffer is too small. Also, older versions of msvcrt.dll do not have
-       _vscprintf().  However, if size is 0, vsnprintf() behaves correctly.
-       Therefore, we make two passes: on first pass, get required message
-       length.
-       On second pass, actually print the message. */
-    va_copy(ap_copy, ap);
-    len = vsnprintf(NULL, 0, fmt, ap_copy);
-    va_end(ap_copy);
-
-    if (len < 0) {
-        /* C runtime is not standard compliant, vsnprintf() returned -1.
-           Switch to alternative code path that uses incremental allocations.
-        */
-        va_copy(ap_copy, ap);
-        len = alloc_vprintf2(buf, fmt, ap);
-        va_end(ap_copy);
-    } else if (len > (int) size &&
-               (size = len + 1) > 0 &&
-               (*buf = (char *) malloc(size)) == NULL) {
-        len = -1;  /* Allocation failed, mark failure */
-    } else {
-        va_copy(ap_copy, ap);
-        IGNORE_UNUSED_RESULT(vsnprintf(*buf, size, fmt, ap_copy));
-        va_end(ap_copy);
-    }
-
-    return len;
-}
-
-int mg_vprintf(struct mg_connection *conn, const char *fmt, va_list ap);
-
-int mg_vprintf(struct mg_connection *conn, const char *fmt, va_list ap)
-{
-    char mem[MG_BUF_LEN], *buf = mem;
-    int len;
-
-    if ((len = alloc_vprintf(&buf, sizeof(mem), fmt, ap)) > 0) {
-        len = mg_write(conn, buf, (size_t) len);
-    }
-    if (buf != mem && buf != NULL) {
-        free(buf);
-    }
-
-    return len;
-}
-
-int mg_printf(struct mg_connection *conn, const char *fmt, ...)
-{
-    va_list ap;
-    int result;
-
-    va_start(ap, fmt);
-    result = mg_vprintf(conn, fmt, ap);
-    va_end(ap);
-
-    return result;
-}
-
-int mg_url_decode(const char *src, int src_len, char *dst,
-                  int dst_len, int is_form_url_encoded)
-{
-    int i, j, a, b;
-#define HEXTOI(x) (isdigit(x) ? x - '0' : x - 'W')
-
-    for (i = j = 0; i < src_len && j < dst_len - 1; i++, j++) {
-        if (src[i] == '%' && i < src_len - 2 &&
-            isxdigit(* (const unsigned char *) (src + i + 1)) &&
-            isxdigit(* (const unsigned char *) (src + i + 2))) {
-            a = tolower(* (const unsigned char *) (src + i + 1));
-            b = tolower(* (const unsigned char *) (src + i + 2));
-            dst[j] = (char) ((HEXTOI(a) << 4) | HEXTOI(b));
-            i += 2;
-        } else if (is_form_url_encoded && src[i] == '+') {
-            dst[j] = ' ';
-        } else {
-            dst[j] = src[i];
-        }
-    }
-
-    dst[j] = '\0'; /* Null-terminate the destination */
-
-    return i >= src_len ? j : -1;
-}
-
-int mg_get_var(const char *data, size_t data_len, const char *name,
-               char *dst, size_t dst_len)
-{
-    return mg_get_var2(data,data_len,name,dst,dst_len,0);
-}
-
-int mg_get_var2(const char *data, size_t data_len, const char *name,
-                char *dst, size_t dst_len, size_t occurrence)
-{
-    const char *p, *e, *s;
-    size_t name_len;
-    int len;
-
-    if (dst == NULL || dst_len == 0) {
-        len = -2;
-    } else if (data == NULL || name == NULL || data_len == 0) {
-        len = -1;
-        dst[0] = '\0';
-    } else {
-        name_len = strlen(name);
-        e = data + data_len;
-        len = -1;
-        dst[0] = '\0';
-
-        /* data is "var1=val1&var2=val2...". Find variable first */
-        for (p = data; p + name_len < e; p++) {
-            if ((p == data || p[-1] == '&') && p[name_len] == '=' &&
-                !mg_strncasecmp(name, p, name_len) && 0 == occurrence--) {
-
-                /* Point p to variable value */
-                p += name_len + 1;
-
-                /* Point s to the end of the value */
-                s = (const char *) memchr(p, '&', (size_t)(e - p));
-                if (s == NULL) {
-                    s = e;
-                }
-                assert(s >= p);
-
-                /* Decode variable into destination buffer */
-                len = mg_url_decode(p, (int)(s - p), dst, (int)dst_len, 1);
-
-                /* Redirect error code from -1 to -2 (destination buffer too
-                   small). */
-                if (len == -1) {
-                    len = -2;
-                }
-                break;
-            }
-        }
-    }
-
-    return len;
-}
-
-int mg_get_cookie(const char *cookie_header, const char *var_name,
-                  char *dst, size_t dst_size)
-{
-    const char *s, *p, *end;
-    int name_len, len = -1;
-
-    if (dst == NULL || dst_size == 0) {
-        len = -2;
-    } else if (var_name == NULL || (s = cookie_header) == NULL) {
-        len = -1;
-        dst[0] = '\0';
-    } else {
-        name_len = (int) strlen(var_name);
-        end = s + strlen(s);
-        dst[0] = '\0';
-
-        for (; (s = mg_strcasestr(s, var_name)) != NULL; s += name_len) {
-            if (s[name_len] == '=') {
-                s += name_len + 1;
-                if ((p = strchr(s, ' ')) == NULL)
-                    p = end;
-                if (p[-1] == ';')
-                    p--;
-                if (*s == '"' && p[-1] == '"' && p > s + 1) {
-                    s++;
-                    p--;
-                }
-                if ((size_t) (p - s) < dst_size) {
-                    len = (int)(p - s);
-                    mg_strlcpy(dst, s, (size_t) len + 1);
-                } else {
-                    len = -3;
-                }
-                break;
-            }
-        }
-    }
-    return len;
-}
-
-static void convert_uri_to_file_name(struct mg_connection *conn, char *buf,
-                                     size_t buf_len, struct file *filep)
-{
-    struct vec a, b;
-    const char *rewrite, *uri = conn->request_info.uri,
-                          *root = conn->ctx->config[DOCUMENT_ROOT];
-    char *p;
-    int match_len;
-    char gz_path[PATH_MAX];
-    char const* accept_encoding;
-
-    /* Using buf_len - 1 because memmove() for PATH_INFO may shift part
-       of the path one byte on the right.
-       If document_root is NULL, leave the file empty. */
-    mg_snprintf(conn, buf, buf_len - 1, "%s%s",
-                root == NULL ? "" : root,
-                root == NULL ? "" : uri);
-
-    rewrite = conn->ctx->config[REWRITE];
-    while ((rewrite = next_option(rewrite, &a, &b)) != NULL) {
-        if ((match_len = match_prefix(a.ptr, (int) a.len, uri)) > 0) {
-            mg_snprintf(conn, buf, buf_len - 1, "%.*s%s", (int) b.len, b.ptr,
-                        uri + match_len);
-            break;
-        }
-    }
-
-    if (mg_stat(conn, buf, filep)) return;
-
-    /* if we can't find the actual file, look for the file
-       with the same name but a .gz extension. If we find it,
-       use that and set the gzipped flag in the file struct
-       to indicate that the response need to have the content-
-       encoding: gzip header
-       we can only do this if the browser declares support */
-    if ((accept_encoding = mg_get_header(conn, "Accept-Encoding")) != NULL) {
-        if (strstr(accept_encoding,"gzip") != NULL) {
-            snprintf(gz_path, sizeof(gz_path), "%s.gz", buf);
-            if (mg_stat(conn, gz_path, filep)) {
-                filep->gzipped = 1;
-                return;
-            }
-        }
-    }
-
-    /* Support PATH_INFO for CGI scripts. */
-    for (p = buf + strlen(buf); p > buf + 1; p--) {
-        if (*p == '/') {
-            *p = '\0';
-            if (match_prefix(conn->ctx->config[CGI_EXTENSIONS],
-                             (int)strlen(conn->ctx->config[CGI_EXTENSIONS]), buf) > 0 &&
-                mg_stat(conn, buf, filep)) {
-                /* Shift PATH_INFO block one character right, e.g.
-                    "/x.cgi/foo/bar\x00" => "/x.cgi\x00/foo/bar\x00"
-                   conn->path_info is pointing to the local variable "path"
-                   declared in handle_request(), so PATH_INFO is not valid
-                   after handle_request returns. */
-                conn->path_info = p + 1;
-                memmove(p + 2, p + 1, strlen(p + 1) + 1);  /* +1 is for
-                                                              trailing \0 */
-                p[1] = '/';
-                break;
-            } else {
-                *p = '/';
-            }
-        }
-    }
-}
-
-/* Check whether full request is buffered. Return:
-     -1  if request is malformed
-      0  if request is not yet fully buffered
-     >0  actual request length, including last \r\n\r\n */
-static int get_request_len(const char *buf, int buflen)
-{
-    const char *s, *e;
-    int len = 0;
-
-    for (s = buf, e = s + buflen - 1; len <= 0 && s < e; s++)
-        /* Control characters are not allowed but >=128 is. */
-        if (!isprint(* (const unsigned char *) s) && *s != '\r' &&
-            *s != '\n' && * (const unsigned char *) s < 128) {
-            len = -1;
-            break;  /* [i_a] abort scan as soon as one malformed character is
-                       found; */
-            /* don't let subsequent \r\n\r\n win us over anyhow */
-        } else if (s[0] == '\n' && s[1] == '\n') {
-            len = (int) (s - buf) + 2;
-        } else if (s[0] == '\n' && &s[1] < e &&
-                   s[1] == '\r' && s[2] == '\n') {
-            len = (int) (s - buf) + 3;
-        }
-
-    return len;
-}
-
-/* Convert month to the month number. Return -1 on error, or month number */
-static int get_month_index(const char *s)
-{
-    size_t i;
-
-    for (i = 0; i < ARRAY_SIZE(month_names); i++)
-        if (!strcmp(s, month_names[i]))
-            return (int) i;
-
-    return -1;
-}
-
-static int num_leap_years(int year)
-{
-    return year / 4 - year / 100 + year / 400;
-}
-
-/* Parse UTC date-time string, and return the corresponding time_t value. */
-static time_t parse_date_string(const char *datetime)
-{
-    static const unsigned short days_before_month[] = {
-        0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
-    };
-    char month_str[32];
-    int second, minute, hour, day, month, year, leap_days, days;
-    time_t result = (time_t) 0;
-
-    if (((sscanf(datetime, "%d/%3s/%d %d:%d:%d",
-                 &day, month_str, &year, &hour, &minute, &second) == 6) ||
-         (sscanf(datetime, "%d %3s %d %d:%d:%d",
-                 &day, month_str, &year, &hour, &minute, &second) == 6) ||
-         (sscanf(datetime, "%*3s, %d %3s %d %d:%d:%d",
-                 &day, month_str, &year, &hour, &minute, &second) == 6) ||
-         (sscanf(datetime, "%d-%3s-%d %d:%d:%d",
-                 &day, month_str, &year, &hour, &minute, &second) == 6)) &&
-        year > 1970 &&
-        (month = get_month_index(month_str)) != -1) {
-        leap_days = num_leap_years(year) - num_leap_years(1970);
-        year -= 1970;
-        days = year * 365 + days_before_month[month] + (day - 1) + leap_days;
-        result = (time_t) days * 24 * 3600 + (time_t) hour * 3600 +
-                 minute * 60 + second;
-    }
-
-    return result;
-}
-
-/* Protect against directory disclosure attack by removing '..',
-   excessive '/' and '\' characters */
-static void remove_double_dots_and_double_slashes(char *s)
-{
-    char *p = s;
-
-    while (*s != '\0') {
-        *p++ = *s++;
-        if (s[-1] == '/' || s[-1] == '\\') {
-            /* Skip all following slashes, backslashes and double-dots */
-            while (s[0] != '\0') {
-                if (s[0] == '/' || s[0] == '\\') {
-                    s++;
-                } else if (s[0] == '.' && s[1] == '.') {
-                    s += 2;
-                } else {
-                    break;
-                }
-            }
-        }
-    }
-    *p = '\0';
-}
-
-static const struct {
-    const char *extension;
-    size_t ext_len;
-    const char *mime_type;
-} builtin_mime_types[] = {
-    /* IANA registered MIME types (http://www.iana.org/assignments/media-types)
-       application types */
-    {".doc",     4, "application/msword"},
-    {".eps",     4, "application/postscript"},
-    {".exe",     4, "application/octet-stream"},
-    {".js",      3, "application/javascript"},
-    {".json",    5, "application/json"},
-    {".pdf",     4, "application/pdf"},
-    {".ps",      3, "application/postscript"},
-    {".rtf",     4, "application/rtf"},
-    {".xhtml",   6, "application/xhtml+xml"},
-    {".xsl",     4, "application/xml"},
-    {".xslt",    5, "application/xml"},
-
-    /* audio */
-    {".mp3",     4, "audio/mpeg"},
-    {".oga",     4, "audio/ogg"},
-    {".ogg",     4, "audio/ogg"},
-
-    /* image */
-    {".gif",     4, "image/gif"},
-    {".ief",     4, "image/ief"},
-    {".jpeg",    5, "image/jpeg"},
-    {".jpg",     4, "image/jpeg"},
-    {".jpm",     4, "image/jpm"},
-    {".jpx",     4, "image/jpx"},
-    {".png",     4, "image/png"},
-    {".svg",     4, "image/svg+xml"},
-    {".tif",     4, "image/tiff"},
-    {".tiff",    5, "image/tiff"},
-
-    /* model */
-    {".wrl",     4, "model/vrml"},
-
-    /* text */
-    {".css",     4, "text/css"},
-    {".csv",     4, "text/csv"},
-    {".htm",     4, "text/html"},
-    {".html",    5, "text/html"},
-    {".sgm",     4, "text/sgml"},
-    {".shtm",    5, "text/html"},
-    {".shtml",   6, "text/html"},
-    {".txt",     4, "text/plain"},
-    {".xml",     4, "text/xml"},
-
-    /* video */
-    {".mov",     4, "video/quicktime"},
-    {".mp4",     4, "video/mp4"},
-    {".mpeg",    5, "video/mpeg"},
-    {".mpg",     4, "video/mpeg"},
-    {".ogv",     4, "video/ogg"},
-    {".qt",      3, "video/quicktime"},
-
-    /* not registered types
-       (http://reference.sitepoint.com/html/mime-types-full,
-        http://www.hansenb.pdx.edu/DMKB/dict/tutorials/mime_typ.php, ..) */
-    {".arj",     4, "application/x-arj-compressed"},
-    {".gz",      3, "application/x-gunzip"},
-    {".rar",     4, "application/x-arj-compressed"},
-    {".swf",     4, "application/x-shockwave-flash"},
-    {".tar",     4, "application/x-tar"},
-    {".tgz",     4, "application/x-tar-gz"},
-    {".torrent", 8, "application/x-bittorrent"},
-    {".ppt",     4, "application/x-mspowerpoint"},
-    {".xls",     4, "application/x-msexcel"},
-    {".zip",     4, "application/x-zip-compressed"},
-    {".aac",     4, "audio/aac"}, /* http://en.wikipedia.org/wiki/Advanced_Audio_Coding */
-    {".aif",     4, "audio/x-aif"},
-    {".m3u",     4, "audio/x-mpegurl"},
-    {".mid",     4, "audio/x-midi"},
-    {".ra",      3, "audio/x-pn-realaudio"},
-    {".ram",     4, "audio/x-pn-realaudio"},
-    {".wav",     4, "audio/x-wav"},
-    {".bmp",     4, "image/bmp"},
-    {".ico",     4, "image/x-icon"},
-    {".pct",     4, "image/x-pct"},
-    {".pict",    5, "image/pict"},
-    {".rgb",     4, "image/x-rgb"},
-    {".webm",    5, "video/webm"}, /* http://en.wikipedia.org/wiki/WebM */
-    {".asf",     4, "video/x-ms-asf"},
-    {".avi",     4, "video/x-msvideo"},
-    {".m4v",     4, "video/x-m4v"},
-    {NULL, 0, NULL}
-};
-
-const char *mg_get_builtin_mime_type(const char *path)
-{
-    const char *ext;
-    size_t i, path_len;
-
-    path_len = strlen(path);
-
-    for (i = 0; builtin_mime_types[i].extension != NULL; i++) {
-        ext = path + (path_len - builtin_mime_types[i].ext_len);
-        if (path_len > builtin_mime_types[i].ext_len &&
-            mg_strcasecmp(ext, builtin_mime_types[i].extension) == 0) {
-            return builtin_mime_types[i].mime_type;
-        }
-    }
-
-    return "text/plain";
-}
-
-/* Look at the "path" extension and figure what mime type it has.
-   Store mime type in the vector. */
-static void get_mime_type(struct mg_context *ctx, const char *path,
-                          struct vec *vec)
-{
-    struct vec ext_vec, mime_vec;
-    const char *list, *ext;
-    size_t path_len;
-
-    path_len = strlen(path);
-
-    /* Scan user-defined mime types first, in case user wants to
-       override default mime types. */
-    list = ctx->config[EXTRA_MIME_TYPES];
-    while ((list = next_option(list, &ext_vec, &mime_vec)) != NULL) {
-        /* ext now points to the path suffix */
-        ext = path + path_len - ext_vec.len;
-        if (mg_strncasecmp(ext, ext_vec.ptr, ext_vec.len) == 0) {
-            *vec = mime_vec;
-            return;
-        }
-    }
-
-    vec->ptr = mg_get_builtin_mime_type(path);
-    vec->len = strlen(vec->ptr);
-}
-
-/* Stringify binary data. Output buffer must be twice as big as input,
-   because each byte takes 2 bytes in string representation */
-static void bin2str(char *to, const unsigned char *p, size_t len)
-{
-    static const char *hex = "0123456789abcdef";
-
-    for (; len--; p++) {
-        *to++ = hex[p[0] >> 4];
-        *to++ = hex[p[0] & 0x0f];
-    }
-    *to = '\0';
-}
-
-/* Return stringified MD5 hash for list of strings. Buffer must be 33 bytes. */
-char *mg_md5(char buf[33], ...)
-{
-    md5_byte_t hash[16];
-    const char *p;
-    va_list ap;
-    md5_state_t ctx;
-
-    md5_init(&ctx);
-
-    va_start(ap, buf);
-    while ((p = va_arg(ap, const char *)) != NULL) {
-        md5_append(&ctx, (const md5_byte_t *) p, (int) strlen(p));
-    }
-    va_end(ap);
-
-    md5_finish(&ctx, hash);
-    bin2str(buf, hash, sizeof(hash));
-    return buf;
-}
-
-/* Check the user's password, return 1 if OK */
-static int check_password(const char *method, const char *ha1, const char *uri,
-                          const char *nonce, const char *nc, const char *cnonce,
-                          const char *qop, const char *response)
-{
-    char ha2[32 + 1], expected_response[32 + 1];
-
-    /* Some of the parameters may be NULL */
-    if (method == NULL || nonce == NULL || nc == NULL || cnonce == NULL ||
-        qop == NULL || response == NULL) {
-        return 0;
-    }
-
-    /* NOTE(lsm): due to a bug in MSIE, we do not compare the URI */
-    /* TODO(lsm): check for authentication timeout */
-    if (/* strcmp(dig->uri, c->ouri) != 0 || */
-        strlen(response) != 32
-        /* || now - strtoul(dig->nonce, NULL, 10) > 3600 */
-    ) {
-        return 0;
-    }
-
-    mg_md5(ha2, method, ":", uri, NULL);
-    mg_md5(expected_response, ha1, ":", nonce, ":", nc,
-           ":", cnonce, ":", qop, ":", ha2, NULL);
-
-    return mg_strcasecmp(response, expected_response) == 0;
-}
-
-/* Use the global passwords file, if specified by auth_gpass option,
-   or search for .htpasswd in the requested directory. */
-static void open_auth_file(struct mg_connection *conn, const char *path,
-                           struct file *filep)
-{
-    char name[PATH_MAX];
-    const char *p, *e, *gpass = conn->ctx->config[GLOBAL_PASSWORDS_FILE];
-    struct file file = STRUCT_FILE_INITIALIZER;
-
-    if (gpass != NULL) {
-        /* Use global passwords file */
-        if (!mg_fopen(conn, gpass, "r", filep)) {
-#ifdef DEBUG
-            mg_cry(conn, "fopen(%s): %s", gpass, strerror(ERRNO));
-#endif
-        }
-        /* Important: using local struct file to test path for is_directory
-           flag.
-           If filep is used, mg_stat() makes it appear as if auth file was
-           opened. */
-    } else if (mg_stat(conn, path, &file) && file.is_directory) {
-        mg_snprintf(conn, name, sizeof(name), "%s%c%s",
-                    path, '/', PASSWORDS_FILE_NAME);
-        if (!mg_fopen(conn, name, "r", filep)) {
-#ifdef DEBUG
-            mg_cry(conn, "fopen(%s): %s", name, strerror(ERRNO));
-#endif
-        }
-    } else {
-        /* Try to find .htpasswd in requested directory. */
-        for (p = path, e = p + strlen(p) - 1; e > p; e--)
-            if (e[0] == '/')
-                break;
-        mg_snprintf(conn, name, sizeof(name), "%.*s%c%s",
-                    (int) (e - p), p, '/', PASSWORDS_FILE_NAME);
-        if (!mg_fopen(conn, name, "r", filep)) {
-#ifdef DEBUG
-            mg_cry(conn, "fopen(%s): %s", name, strerror(ERRNO));
-#endif
-        }
-    }
-}
-
-/* Parsed Authorization header */
-struct ah {
-    char *user, *uri, *cnonce, *response, *qop, *nc, *nonce;
-};
-
-/* Return 1 on success. Always initializes the ah structure. */
-static int parse_auth_header(struct mg_connection *conn, char *buf,
-                             size_t buf_size, struct ah *ah)
-{
-    char *name, *value, *s;
-    const char *auth_header;
-
-    (void) memset(ah, 0, sizeof(*ah));
-    if ((auth_header = mg_get_header(conn, "Authorization")) == NULL ||
-        mg_strncasecmp(auth_header, "Digest ", 7) != 0) {
-        return 0;
-    }
-
-    /* Make modifiable copy of the auth header */
-    (void) mg_strlcpy(buf, auth_header + 7, buf_size);
-    s = buf;
-
-    /* Parse authorization header */
-    for (;;) {
-        /* Gobble initial spaces */
-        while (isspace(* (unsigned char *) s)) {
-            s++;
-        }
-        name = skip_quoted(&s, "=", " ", 0);
-        /* Value is either quote-delimited, or ends at first comma or space. */
-        if (s[0] == '\"') {
-            s++;
-            value = skip_quoted(&s, "\"", " ", '\\');
-            if (s[0] == ',') {
-                s++;
-            }
-        } else {
-            value = skip_quoted(&s, ", ", " ", 0);  /* IE uses commas, FF uses
-                                                       spaces */
-        }
-        if (*name == '\0') {
-            break;
-        }
-
-        if (!strcmp(name, "username")) {
-            ah->user = value;
-        } else if (!strcmp(name, "cnonce")) {
-            ah->cnonce = value;
-        } else if (!strcmp(name, "response")) {
-            ah->response = value;
-        } else if (!strcmp(name, "uri")) {
-            ah->uri = value;
-        } else if (!strcmp(name, "qop")) {
-            ah->qop = value;
-        } else if (!strcmp(name, "nc")) {
-            ah->nc = value;
-        } else if (!strcmp(name, "nonce")) {
-            ah->nonce = value;
-        }
-    }
-
-    /* CGI needs it as REMOTE_USER */
-    if (ah->user != NULL) {
-        conn->request_info.remote_user = mg_strdup(ah->user);
-    } else {
-        return 0;
-    }
-
-    return 1;
-}
-
-static char *mg_fgets(char *buf, size_t size, struct file *filep, char **p)
-{
-    char *eof;
-    size_t len;
-    char *memend;
-
-    if (filep->membuf != NULL && *p != NULL) {
-        memend = (char *) &filep->membuf[filep->size];
-        eof = (char *) memchr(*p, '\n', memend - *p); /* Search for \n from p
-                                                         till the end of
-                                                         stream */
-        if (eof != NULL) {
-            eof += 1; /* Include \n */
-        } else {
-            eof = memend; /* Copy remaining data */
-        }
-        len = (size_t) (eof - *p) > size - 1 ? size - 1 : (size_t) (eof - *p);
-        memcpy(buf, *p, len);
-        buf[len] = '\0';
-        *p += len;
-        return len ? eof : NULL;
-    } else if (filep->fp != NULL) {
-        return fgets(buf, (int)size, filep->fp);
-    } else {
-        return NULL;
-    }
-}
-
-/* Authorize against the opened passwords file. Return 1 if authorized. */
-static int authorize(struct mg_connection *conn, struct file *filep)
-{
-    struct ah ah;
-    char line[256], f_user[256] = "", ha1[256] = "", f_domain[256] = "", buf[MG_BUF_LEN], *p;
-
-    if (!parse_auth_header(conn, buf, sizeof(buf), &ah)) {
-        return 0;
-    }
-
-    /* Loop over passwords file */
-    p = (char *) filep->membuf;
-    while (mg_fgets(line, sizeof(line), filep, &p) != NULL) {
-        if (sscanf(line, "%[^:]:%[^:]:%s", f_user, f_domain, ha1) != 3) {
-            continue;
-        }
-
-        if (!strcmp(ah.user, f_user) &&
-            !strcmp(conn->ctx->config[AUTHENTICATION_DOMAIN], f_domain))
-            return check_password(conn->request_info.request_method, ha1, ah.uri,
-                                  ah.nonce, ah.nc, ah.cnonce, ah.qop, ah.response);
-    }
-
-    return 0;
-}
-
-/* Return 1 if request is authorised, 0 otherwise. */
-static int check_authorization(struct mg_connection *conn, const char *path)
-{
-    char fname[PATH_MAX];
-    struct vec uri_vec, filename_vec;
-    const char *list;
-    struct file file = STRUCT_FILE_INITIALIZER;
-    int authorized = 1;
-
-    list = conn->ctx->config[PROTECT_URI];
-    while ((list = next_option(list, &uri_vec, &filename_vec)) != NULL) {
-        if (!memcmp(conn->request_info.uri, uri_vec.ptr, uri_vec.len)) {
-            mg_snprintf(conn, fname, sizeof(fname), "%.*s",
-                        (int) filename_vec.len, filename_vec.ptr);
-            if (!mg_fopen(conn, fname, "r", &file)) {
-                mg_cry(conn, "%s: cannot open %s: %s", __func__, fname, strerror(errno));
-            }
-            break;
-        }
-    }
-
-    if (!is_file_opened(&file)) {
-        open_auth_file(conn, path, &file);
-    }
-
-    if (is_file_opened(&file)) {
-        authorized = authorize(conn, &file);
-        mg_fclose(&file);
-    }
-
-    return authorized;
-}
-
-static void send_authorization_request(struct mg_connection *conn)
-{
-    conn->status_code = 401;
-    mg_printf(conn,
-              "HTTP/1.1 401 Unauthorized\r\n"
-              "Content-Length: 0\r\n"
-              "WWW-Authenticate: Digest qop=\"auth\", "
-              "realm=\"%s\", nonce=\"%lu\"\r\n\r\n",
-              conn->ctx->config[AUTHENTICATION_DOMAIN],
-              (unsigned long) time(NULL));
-}
-
-static int is_authorized_for_put(struct mg_connection *conn)
-{
-    struct file file = STRUCT_FILE_INITIALIZER;
-    const char *passfile = conn->ctx->config[PUT_DELETE_PASSWORDS_FILE];
-    int ret = 0;
-
-    if (passfile != NULL && mg_fopen(conn, passfile, "r", &file)) {
-        ret = authorize(conn, &file);
-        mg_fclose(&file);
-    }
-
-    return ret;
-}
-
-int mg_modify_passwords_file(const char *fname, const char *domain,
-                             const char *user, const char *pass)
-{
-    int found;
-    char line[512], u[512] = "", d[512] ="", ha1[33], tmp[PATH_MAX+1];
-    FILE *fp, *fp2;
-
-    found = 0;
-    fp = fp2 = NULL;
-
-    /* Regard empty password as no password - remove user record. */
-    if (pass != NULL && pass[0] == '\0') {
-        pass = NULL;
-    }
-
-    (void) snprintf(tmp, sizeof(tmp) - 1, "%s.tmp", fname);
-    tmp[sizeof(tmp) - 1] = 0;
-
-    /* Create the file if does not exist */
-    if ((fp = fopen(fname, "a+")) != NULL) {
-        (void) fclose(fp);
-    }
-
-    /* Open the given file and temporary file */
-    if ((fp = fopen(fname, "r")) == NULL) {
-        return 0;
-    } else if ((fp2 = fopen(tmp, "w+")) == NULL) {
-        fclose(fp);
-        return 0;
-    }
-
-    /* Copy the stuff to temporary file */
-    while (fgets(line, sizeof(line), fp) != NULL) {
-        if (sscanf(line, "%[^:]:%[^:]:%*s", u, d) != 2) {
-            continue;
-        }
-
-        if (!strcmp(u, user) && !strcmp(d, domain)) {
-            found++;
-            if (pass != NULL) {
-                mg_md5(ha1, user, ":", domain, ":", pass, NULL);
-                fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
-            }
-        } else {
-            fprintf(fp2, "%s", line);
-        }
-    }
-
-    /* If new user, just add it */
-    if (!found && pass != NULL) {
-        mg_md5(ha1, user, ":", domain, ":", pass, NULL);
-        fprintf(fp2, "%s:%s:%s\n", user, domain, ha1);
-    }
-
-    /* Close files */
-    fclose(fp);
-    fclose(fp2);
-
-    /* Put the temp file in place of real file */
-    IGNORE_UNUSED_RESULT(remove(fname));
-    IGNORE_UNUSED_RESULT(rename(tmp, fname));
-
-    return 1;
-}
-
-static SOCKET conn2(struct mg_context *ctx  /* may be null */, const char *host, int port,
-                    int use_ssl, char *ebuf, size_t ebuf_len)
-{
-    struct sockaddr_in sain;
-    struct hostent *he;
-    SOCKET sock = INVALID_SOCKET;
-
-    if (host == NULL) {
-        snprintf(ebuf, ebuf_len, "%s", "NULL host");
-    } else if (use_ssl && SSLv23_client_method == NULL) {
-        snprintf(ebuf, ebuf_len, "%s", "SSL is not initialized");
-        /* TODO(lsm): use something threadsafe instead of gethostbyname() */
-    } else if ((he = gethostbyname(host)) == NULL) {
-        snprintf(ebuf, ebuf_len, "gethostbyname(%s): %s", host, strerror(ERRNO));
-    } else if ((sock = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
-        snprintf(ebuf, ebuf_len, "socket(): %s", strerror(ERRNO));
-    } else {
-        set_close_on_exec(sock, fc(ctx));
-        memset(&sain, '\0', sizeof(sain));
-        sain.sin_family = AF_INET;
-        sain.sin_port = htons((uint16_t) port);
-        sain.sin_addr = * (struct in_addr *) he->h_addr_list[0];
-        if (connect(sock, (struct sockaddr *) &sain, sizeof(sain)) != 0) {
-            snprintf(ebuf, ebuf_len, "connect(%s:%d): %s",
-                     host, port, strerror(ERRNO));
-            closesocket(sock);
-            sock = INVALID_SOCKET;
-        }
-    }
-    return sock;
-}
-
-int mg_url_encode(const char *src, char *dst, size_t dst_len)
-{
-    static const char *dont_escape = "._-$,;~()";
-    static const char *hex = "0123456789abcdef";
-    char *pos = dst;
-    const char *end = dst + dst_len - 1;
-
-    for (; *src != '\0' && pos < end; src++, pos++) {
-        if (isalnum(*(const unsigned char *) src) ||
-            strchr(dont_escape, * (const unsigned char *) src) != NULL) {
-            *pos = *src;
-        } else if (pos + 2 < end) {
-            pos[0] = '%';
-            pos[1] = hex[(* (const unsigned char *) src) >> 4];
-            pos[2] = hex[(* (const unsigned char *) src) & 0xf];
-            pos += 2;
-        } else {
-            return -1;
-        }
-    }
-
-    *pos = '\0';
-    return (*src == '\0') ? (int)(pos - dst) : -1;
-}
-
-static void print_dir_entry(struct de *de)
-{
-    char size[64], mod[64], href[PATH_MAX];
-    struct tm *tm;
-
-    if (de->file.is_directory) {
-        mg_snprintf(de->conn, size, sizeof(size), "%s", "[DIRECTORY]");
-    } else {
-        /* We use (signed) cast below because MSVC 6 compiler cannot
-           convert unsigned __int64 to double. Sigh. */
-        if (de->file.size < 1024) {
-            mg_snprintf(de->conn, size, sizeof(size), "%d", (int) de->file.size);
-        } else if (de->file.size < 0x100000) {
-            mg_snprintf(de->conn, size, sizeof(size),
-                        "%.1fk", (double) de->file.size / 1024.0);
-        } else if (de->file.size < 0x40000000) {
-            mg_snprintf(de->conn, size, sizeof(size),
-                        "%.1fM", (double) de->file.size / 1048576);
-        } else {
-            mg_snprintf(de->conn, size, sizeof(size),
-                        "%.1fG", (double) de->file.size / 1073741824);
-        }
-    }
-    tm = localtime(&de->file.modification_time);
-    if (tm != NULL) {
-        strftime(mod, sizeof(mod), "%d-%b-%Y %H:%M", tm);
-    } else {
-        strncpy(mod, "01-Jan-1970 00:00", sizeof(mod));
-        mod[sizeof(mod) - 1] = '\0';
-    }
-    mg_url_encode(de->file_name, href, sizeof(href));
-    de->conn->num_bytes_sent += mg_printf(de->conn,
-                                          "<tr><td><a href=\"%s%s%s\">%s%s</a></td>"
-                                          "<td>&nbsp;%s</td><td>&nbsp;&nbsp;%s</td></tr>\n",
-                                          de->conn->request_info.uri, href, de->file.is_directory ? "/" : "",
-                                          de->file_name, de->file.is_directory ? "/" : "", mod, size);
-}
-
-/* This function is called from send_directory() and used for
-   sorting directory entries by size, or name, or modification time.
-   On windows, __cdecl specification is needed in case if project is built
-   with __stdcall convention. qsort always requires __cdels callback. */
-static int WINCDECL compare_dir_entries(const void *p1, const void *p2)
-{
-    const struct de *a = (const struct de *) p1, *b = (const struct de *) p2;
-    const char *query_string = a->conn->request_info.query_string;
-    int cmp_result = 0;
-
-    if (query_string == NULL) {
-        query_string = "na";
-    }
-
-    if (a->file.is_directory && !b->file.is_directory) {
-        return -1;  /* Always put directories on top */
-    } else if (!a->file.is_directory && b->file.is_directory) {
-        return 1;   /* Always put directories on top */
-    } else if (*query_string == 'n') {
-        cmp_result = strcmp(a->file_name, b->file_name);
-    } else if (*query_string == 's') {
-        cmp_result = a->file.size == b->file.size ? 0 :
-                     a->file.size > b->file.size ? 1 : -1;
-    } else if (*query_string == 'd') {
-        cmp_result = a->file.modification_time == b->file.modification_time ? 0 :
-                     a->file.modification_time > b->file.modification_time ? 1 : -1;
-    }
-
-    return query_string[1] == 'd' ? -cmp_result : cmp_result;
-}
-
-static int must_hide_file(struct mg_connection *conn, const char *path)
-{
-    const char *pw_pattern = "**" PASSWORDS_FILE_NAME "$";
-    const char *pattern = conn->ctx->config[HIDE_FILES];
-    return match_prefix(pw_pattern, (int)strlen(pw_pattern), path) > 0 ||
-           (pattern != NULL && match_prefix(pattern, (int)strlen(pattern), path) > 0);
-}
-
-static int scan_directory(struct mg_connection *conn, const char *dir,
-                          void *data, void (*cb)(struct de *, void *))
-{
-    char path[PATH_MAX];
-    struct dirent *dp;
-    DIR *dirp;
-    struct de de;
-
-    if ((dirp = opendir(dir)) == NULL) {
-        return 0;
-    } else {
-        de.conn = conn;
-
-        while ((dp = readdir(dirp)) != NULL) {
-            /* Do not show current dir and hidden files */
-            if (!strcmp(dp->d_name, ".") ||
-                !strcmp(dp->d_name, "..") ||
-                must_hide_file(conn, dp->d_name)) {
-                continue;
-            }
-
-            mg_snprintf(conn, path, sizeof(path), "%s%c%s", dir, '/', dp->d_name);
-
-            /* If we don't memset stat structure to zero, mtime will have
-               garbage and strftime() will segfault later on in
-               print_dir_entry(). memset is required only if mg_stat()
-               fails. For more details, see
-               http://code.google.com/p/mongoose/issues/detail?id=79 */
-            memset(&de.file, 0, sizeof(de.file));
-            if (!mg_stat(conn, path, &de.file)) {
-                mg_cry(conn, "%s: mg_stat(%s) failed: %s",
-                       __func__, path, strerror(ERRNO));
-            }
-
-            de.file_name = dp->d_name;
-            cb(&de, data);
-        }
-        (void) closedir(dirp);
-    }
-    return 1;
-}
-
-static int remove_directory(struct mg_connection *conn, const char *dir)
-{
-    char path[PATH_MAX];
-    struct dirent *dp;
-    DIR *dirp;
-    struct de de;
-
-    if ((dirp = opendir(dir)) == NULL) {
-        return 0;
-    } else {
-        de.conn = conn;
-
-        while ((dp = readdir(dirp)) != NULL) {
-            /* Do not show current dir (but show hidden files as they will
-               also be removed) */
-            if (!strcmp(dp->d_name, ".") ||
-                !strcmp(dp->d_name, "..")) {
-                continue;
-            }
-
-            mg_snprintf(conn, path, sizeof(path), "%s%c%s", dir, '/', dp->d_name);
-
-            /* If we don't memset stat structure to zero, mtime will have
-               garbage and strftime() will segfault later on in
-               print_dir_entry(). memset is required only if mg_stat()
-               fails. For more details, see
-               http://code.google.com/p/mongoose/issues/detail?id=79 */
-            memset(&de.file, 0, sizeof(de.file));
-            if (!mg_stat(conn, path, &de.file)) {
-                mg_cry(conn, "%s: mg_stat(%s) failed: %s",
-                       __func__, path, strerror(ERRNO));
-            }
-            if(de.file.modification_time) {
-                if(de.file.is_directory) {
-                    remove_directory(conn, path);
-                } else {
-                    mg_remove(path);
-                }
-            }
-
-        }
-        (void) closedir(dirp);
-
-        IGNORE_UNUSED_RESULT(rmdir(dir));
-    }
-
-    return 1;
-}
-
-struct dir_scan_data {
-    struct de *entries;
-    int num_entries;
-    int arr_size;
-};
-
-/* Behaves like realloc(), but frees original pointer on failure */
-static void *realloc2(void *ptr, size_t size)
-{
-    void *new_ptr = realloc(ptr, size);
-    if (new_ptr == NULL) {
-        free(ptr);
-    }
-    return new_ptr;
-}
-
-static void dir_scan_callback(struct de *de, void *data)
-{
-    struct dir_scan_data *dsd = (struct dir_scan_data *) data;
-
-    if (dsd->entries == NULL || dsd->num_entries >= dsd->arr_size) {
-        dsd->arr_size *= 2;
-        dsd->entries = (struct de *) realloc2(dsd->entries, dsd->arr_size *
-                                              sizeof(dsd->entries[0]));
-    }
-    if (dsd->entries == NULL) {
-        /* TODO(lsm): propagate an error to the caller */
-        dsd->num_entries = 0;
-    } else {
-        dsd->entries[dsd->num_entries].file_name = mg_strdup(de->file_name);
-        dsd->entries[dsd->num_entries].file = de->file;
-        dsd->entries[dsd->num_entries].conn = de->conn;
-        dsd->num_entries++;
-    }
-}
-
-static void handle_directory_request(struct mg_connection *conn,
-                                     const char *dir)
-{
-    int i, sort_direction;
-    struct dir_scan_data data = { NULL, 0, 128 };
-
-    if (!scan_directory(conn, dir, &data, dir_scan_callback)) {
-        send_http_error(conn, 500, "Cannot open directory",
-                        "Error: opendir(%s): %s", dir, strerror(ERRNO));
-        return;
-    }
-
-    sort_direction = conn->request_info.query_string != NULL &&
-                     conn->request_info.query_string[1] == 'd' ? 'a' : 'd';
-
-    conn->must_close = 1;
-    mg_printf(conn, "%s",
-              "HTTP/1.1 200 OK\r\n"
-              "Connection: close\r\n"
-              "Content-Type: text/html; charset=utf-8\r\n\r\n");
-
-    conn->num_bytes_sent += mg_printf(conn,
-                                      "<html><head><title>Index of %s</title>"
-                                      "<style>th {text-align: left;}</style></head>"
-                                      "<body><h1>Index of %s</h1><pre><table cellpadding=\"0\">"
-                                      "<tr><th><a href=\"?n%c\">Name</a></th>"
-                                      "<th><a href=\"?d%c\">Modified</a></th>"
-                                      "<th><a href=\"?s%c\">Size</a></th></tr>"
-                                      "<tr><td colspan=\"3\"><hr></td></tr>",
-                                      conn->request_info.uri, conn->request_info.uri,
-                                      sort_direction, sort_direction, sort_direction);
-
-    /* Print first entry - link to a parent directory */
-    conn->num_bytes_sent += mg_printf(conn,
-                                      "<tr><td><a href=\"%s%s\">%s</a></td>"
-                                      "<td>&nbsp;%s</td><td>&nbsp;&nbsp;%s</td></tr>\n",
-                                      conn->request_info.uri, "..", "Parent directory", "-", "-");
-
-    /* Sort and print directory entries */
-    if (data.entries != NULL) {
-        qsort(data.entries, (size_t) data.num_entries,
-              sizeof(data.entries[0]), compare_dir_entries);
-        for (i = 0; i < data.num_entries; i++) {
-            print_dir_entry(&data.entries[i]);
-            free(data.entries[i].file_name);
-        }
-        free(data.entries);
-    }
-
-    conn->num_bytes_sent += mg_printf(conn, "%s", "</table></body></html>");
-    conn->status_code = 200;
-}
-
-/* Send len bytes from the opened file to the client. */
-static void send_file_data(struct mg_connection *conn, struct file *filep,
-                           int64_t offset, int64_t len)
-{
-    char buf[MG_BUF_LEN];
-    int to_read, num_read, num_written;
-
-    /* Sanity check the offset */
-    offset = offset < 0 ? 0 : offset > filep->size ? filep->size : offset;
-
-    if (len > 0 && filep->membuf != NULL && filep->size > 0) {
-        if (len > filep->size - offset) {
-            len = filep->size - offset;
-        }
-        mg_write(conn, filep->membuf + offset, (size_t) len);
-    } else if (len > 0 && filep->fp != NULL) {
-        if (offset > 0 && fseeko(filep->fp, offset, SEEK_SET) != 0) {
-            mg_cry(conn, "%s: fseeko() failed: %s",
-                   __func__, strerror(ERRNO));
-        }
-        while (len > 0) {
-            /* Calculate how much to read from the file in the buffer */
-            to_read = sizeof(buf);
-            if ((int64_t) to_read > len) {
-                to_read = (int) len;
-            }
-
-            /* Read from file, exit the loop on error */
-            if ((num_read = (int) fread(buf, 1, (size_t) to_read, filep->fp)) <= 0) {
-                break;
-            }
-
-            /* Send read bytes to the client, exit the loop on error */
-            if ((num_written = mg_write(conn, buf, (size_t) num_read)) != num_read) {
-                break;
-            }
-
-            /* Both read and were successful, adjust counters */
-            conn->num_bytes_sent += num_written;
-            len -= num_written;
-        }
-    }
-}
-
-static int parse_range_header(const char *header, int64_t *a, int64_t *b)
-{
-    return sscanf(header, "bytes=%" INT64_FMT "-%" INT64_FMT, a, b);
-}
-
-static void gmt_time_string(char *buf, size_t buf_len, time_t *t)
-{
-    struct tm *tm;
-
-    tm = gmtime(t);
-    if (tm != NULL) {
-        strftime(buf, buf_len, "%a, %d %b %Y %H:%M:%S GMT", tm);
-    } else {
-        strncpy(buf, "Thu, 01 Jan 1970 00:00:00 GMT", buf_len);
-        buf[buf_len - 1] = '\0';
-    }
-}
-
-static void construct_etag(char *buf, size_t buf_len,
-                           const struct file *filep)
-{
-    snprintf(buf, buf_len, "\"%lx.%" INT64_FMT "\"",
-             (unsigned long) filep->modification_time, filep->size);
-}
-
-static void fclose_on_exec(struct file *filep, struct mg_connection *conn)
-{
-    if (filep != NULL && filep->fp != NULL) {
-#ifdef _WIN32
-        (void) conn; /* Unused. */
-#else
-        if (fcntl(fileno(filep->fp), F_SETFD, FD_CLOEXEC) != 0) {
-            mg_cry(conn, "%s: fcntl(F_SETFD FD_CLOEXEC) failed: %s",
-                   __func__, strerror(ERRNO));
-        }
-#endif
-    }
-}
-
-static void handle_file_request(struct mg_connection *conn, const char *path,
-                                struct file *filep)
-{
-    char date[64], lm[64], etag[64], range[64];
-    const char *msg = "OK", *hdr;
-    time_t curtime = time(NULL);
-    int64_t cl, r1, r2;
-    struct vec mime_vec;
-    int n;
-    char gz_path[PATH_MAX];
-    char const* encoding = "";
-
-    get_mime_type(conn->ctx, path, &mime_vec);
-    cl = filep->size;
-    conn->status_code = 200;
-    range[0] = '\0';
-
-    /* if this file is in fact a pre-gzipped file, rewrite its filename
-       it's important to rewrite the filename after resolving
-       the mime type from it, to preserve the actual file's type */
-    if (filep->gzipped) {
-        snprintf(gz_path, sizeof(gz_path), "%s.gz", path);
-        path = gz_path;
-        encoding = "Content-Encoding: gzip\r\n";
-    }
-
-    if (!mg_fopen(conn, path, "rb", filep)) {
-        send_http_error(conn, 500, http_500_error,
-                        "fopen(%s): %s", path, strerror(ERRNO));
-        return;
-    }
-
-    fclose_on_exec(filep, conn);
-
-    /* If Range: header specified, act accordingly */
-    r1 = r2 = 0;
-    hdr = mg_get_header(conn, "Range");
-    if (hdr != NULL && (n = parse_range_header(hdr, &r1, &r2)) > 0 &&
-        r1 >= 0 && r2 >= 0) {
-        /* actually, range requests don't play well with a pre-gzipped
-           file (since the range is specified in the uncompressed space) */
-        if (filep->gzipped) {
-            send_http_error(conn, 501, "Not Implemented", "range requests in gzipped files are not supported");
-            mg_fclose(filep);
-            return;
-        }
-        conn->status_code = 206;
-cl = n == 2 ? (r2 > cl ? cl : r2) - r1 + 1: cl - r1;
-        mg_snprintf(conn, range, sizeof(range),
-                    "Content-Range: bytes "
-                    "%" INT64_FMT "-%"
-                    INT64_FMT "/%" INT64_FMT "\r\n",
-                    r1, r1 + cl - 1, filep->size);
-        msg = "Partial Content";
-    }
-
-    /* Prepare Etag, Date, Last-Modified headers. Must be in UTC, according to
-       http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.3 */
-    gmt_time_string(date, sizeof(date), &curtime);
-    gmt_time_string(lm, sizeof(lm), &filep->modification_time);
-    construct_etag(etag, sizeof(etag), filep);
-
-    (void) mg_printf(conn,
-                     "HTTP/1.1 %d %s\r\n"
-                     "Date: %s\r\n"
-                     "Last-Modified: %s\r\n"
-                     "Etag: %s\r\n"
-                     "Content-Type: %.*s\r\n"
-                     "Content-Length: %" INT64_FMT "\r\n"
-                     "Connection: %s\r\n"
-                     "Accept-Ranges: bytes\r\n"
-                     "%s%s\r\n",
-                     conn->status_code, msg, date, lm, etag, (int) mime_vec.len,
-                     mime_vec.ptr, cl, suggest_connection_header(conn), range, encoding);
-
-    if (strcmp(conn->request_info.request_method, "HEAD") != 0) {
-        send_file_data(conn, filep, r1, cl);
-    }
-    mg_fclose(filep);
-}
-
-void mg_send_file(struct mg_connection *conn, const char *path)
-{
-    struct file file = STRUCT_FILE_INITIALIZER;
-    if (mg_stat(conn, path, &file)) {
-        handle_file_request(conn, path, &file);
-    } else {
-        send_http_error(conn, 404, "Not Found", "%s", "File not found");
-    }
-}
-
-
-/* Parse HTTP headers from the given buffer, advance buffer to the point
-   where parsing stopped. */
-static void parse_http_headers(char **buf, struct mg_request_info *ri)
-{
-    int i;
-
-    for (i = 0; i < (int) ARRAY_SIZE(ri->http_headers); i++) {
-        ri->http_headers[i].name = skip_quoted(buf, ":", " ", 0);
-        ri->http_headers[i].value = skip(buf, "\r\n");
-        if (ri->http_headers[i].name[0] == '\0')
-            break;
-        ri->num_headers = i + 1;
-    }
-}
-
-static int is_valid_http_method(const char *method)
-{
-    return !strcmp(method, "GET") || !strcmp(method, "POST") ||
-           !strcmp(method, "HEAD") || !strcmp(method, "CONNECT") ||
-           !strcmp(method, "PUT") || !strcmp(method, "DELETE") ||
-           !strcmp(method, "OPTIONS") || !strcmp(method, "PROPFIND")
-           || !strcmp(method, "MKCOL")
-           ;
-}
-
-/* Parse HTTP request, fill in mg_request_info structure.
-   This function modifies the buffer by NUL-terminating
-   HTTP request components, header names and header values. */
-static int parse_http_message(char *buf, int len, struct mg_request_info *ri)
-{
-    int is_request, request_length = get_request_len(buf, len);
-    if (request_length > 0) {
-        /* Reset attributes. DO NOT TOUCH is_ssl, remote_ip, remote_port */
-        ri->remote_user = ri->request_method = ri->uri = ri->http_version = NULL;
-        ri->num_headers = 0;
-
-        buf[request_length - 1] = '\0';
-
-        /* RFC says that all initial whitespaces should be ingored */
-        while (*buf != '\0' && isspace(* (unsigned char *) buf)) {
-            buf++;
-        }
-        ri->request_method = skip(&buf, " ");
-        ri->uri = skip(&buf, " ");
-        ri->http_version = skip(&buf, "\r\n");
-
-        /* HTTP message could be either HTTP request or HTTP response, e.g.
-           "GET / HTTP/1.0 ...." or  "HTTP/1.0 200 OK ..." */
-        is_request = is_valid_http_method(ri->request_method);
-        if ((is_request && memcmp(ri->http_version, "HTTP/", 5) != 0) ||
-            (!is_request && memcmp(ri->request_method, "HTTP/", 5) != 0)) {
-            request_length = -1;
-        } else {
-            if (is_request) {
-                ri->http_version += 5;
-            }
-            parse_http_headers(&buf, ri);
-        }
-    }
-    return request_length;
-}
-
-/* Keep reading the input (either opened file descriptor fd, or socket sock,
-   or SSL descriptor ssl) into buffer buf, until \r\n\r\n appears in the
-   buffer (which marks the end of HTTP request). Buffer buf may already
-   have some data. The length of the data is stored in nread.
-   Upon every read operation, increase nread by the number of bytes read. */
-static int read_request(FILE *fp, struct mg_connection *conn,
-                        char *buf, int bufsiz, int *nread)
-{
-    int request_len, n = 0;
-
-    request_len = get_request_len(buf, *nread);
-    while (conn->ctx->stop_flag == 0 &&
-           *nread < bufsiz && request_len == 0 &&
-           (n = pull(fp, conn, buf + *nread, bufsiz - *nread)) > 0) {
-        *nread += n;
-        assert(*nread <= bufsiz);
-        request_len = get_request_len(buf, *nread);
-    }
-
-    return request_len <= 0 && n <= 0 ? -1 : request_len;
-}
-
-/* For given directory path, substitute it to valid index file.
-   Return 0 if index file has been found, -1 if not found.
-   If the file is found, it's stats is returned in stp. */
-static int substitute_index_file(struct mg_connection *conn, char *path,
-                                 size_t path_len, struct file *filep)
-{
-    const char *list = conn->ctx->config[INDEX_FILES];
-    struct file file = STRUCT_FILE_INITIALIZER;
-    struct vec filename_vec;
-    size_t n = strlen(path);
-    int found = 0;
-
-    /* The 'path' given to us points to the directory. Remove all trailing
-       directory separator characters from the end of the path, and
-       then append single directory separator character. */
-    while (n > 0 && path[n - 1] == '/') {
-        n--;
-    }
-    path[n] = '/';
-
-    /* Traverse index files list. For each entry, append it to the given
-       path and see if the file exists. If it exists, break the loop */
-    while ((list = next_option(list, &filename_vec, NULL)) != NULL) {
-
-        /* Ignore too long entries that may overflow path buffer */
-        if (filename_vec.len > path_len - (n + 2))
-            continue;
-
-        /* Prepare full path to the index file */
-        mg_strlcpy(path + n + 1, filename_vec.ptr, filename_vec.len + 1);
-
-        /* Does it exist? */
-        if (mg_stat(conn, path, &file)) {
-            /* Yes it does, break the loop */
-            *filep = file;
-            found = 1;
-            break;
-        }
-    }
-
-    /* If no index file exists, restore directory path */
-    if (!found) {
-        path[n] = '\0';
-    }
-
-    return found;
-}
-
-/* Return True if we should reply 304 Not Modified. */
-static int is_not_modified(const struct mg_connection *conn,
-                           const struct file *filep)
-{
-    char etag[64];
-    const char *ims = mg_get_header(conn, "If-Modified-Since");
-    const char *inm = mg_get_header(conn, "If-None-Match");
-    construct_etag(etag, sizeof(etag), filep);
-    return (inm != NULL && !mg_strcasecmp(etag, inm)) ||
-           (ims != NULL && filep->modification_time <= parse_date_string(ims));
-}
-
-static int forward_body_data(struct mg_connection *conn, FILE *fp,
-                             SOCKET sock, SSL *ssl)
-{
-    const char *expect, *body;
-    char buf[MG_BUF_LEN];
-    int to_read, nread, buffered_len, success = 0;
-
-    expect = mg_get_header(conn, "Expect");
-    assert(fp != NULL);
-
-    if (conn->content_len == -1) {
-        send_http_error(conn, 411, "Length Required", "%s", "");
-    } else if (expect != NULL && mg_strcasecmp(expect, "100-continue")) {
-        send_http_error(conn, 417, "Expectation Failed", "%s", "");
-    } else {
-        if (expect != NULL) {
-            (void) mg_printf(conn, "%s", "HTTP/1.1 100 Continue\r\n\r\n");
-        }
-
-        body = conn->buf + conn->request_len + conn->consumed_content;
-        buffered_len = (int)(&conn->buf[conn->data_len] - body);
-        assert(buffered_len >= 0);
-        assert(conn->consumed_content == 0);
-
-        if (buffered_len > 0) {
-            if ((int64_t) buffered_len > conn->content_len) {
-                buffered_len = (int) conn->content_len;
-            }
-            push(fp, sock, ssl, body, (int64_t) buffered_len);
-            conn->consumed_content += buffered_len;
-        }
-
-        nread = 0;
-        while (conn->consumed_content < conn->content_len) {
-            to_read = sizeof(buf);
-            if ((int64_t) to_read > conn->content_len - conn->consumed_content) {
-                to_read = (int) (conn->content_len - conn->consumed_content);
-            }
-            nread = pull(NULL, conn, buf, to_read);
-            if (nread <= 0 || push(fp, sock, ssl, buf, nread) != nread) {
-                break;
-            }
-            conn->consumed_content += nread;
-        }
-
-        if (conn->consumed_content == conn->content_len) {
-            success = nread >= 0;
-        }
-
-        /* Each error code path in this function must send an error */
-        if (!success) {
-            send_http_error(conn, 577, http_500_error, "%s", "");
-        }
-    }
-
-    return success;
-}
-
-#if !defined(NO_CGI)
-/* This structure helps to create an environment for the spawned CGI program.
-   Environment is an array of "VARIABLE=VALUE\0" ASCIIZ strings,
-   last element must be NULL.
-   However, on Windows there is a requirement that all these VARIABLE=VALUE\0
-   strings must reside in a contiguous buffer. The end of the buffer is
-   marked by two '\0' characters.
-   We satisfy both worlds: we create an envp array (which is vars), all
-   entries are actually pointers inside buf. */
-struct cgi_env_block {
-    struct mg_connection *conn;
-    char buf[CGI_ENVIRONMENT_SIZE]; /* Environment buffer */
-    int len; /* Space taken */
-    char *vars[MAX_CGI_ENVIR_VARS]; /* char **envp */
-    int nvars; /* Number of variables */
-};
-
-static char *addenv(struct cgi_env_block *block,
-                    PRINTF_FORMAT_STRING(const char *fmt), ...)
-PRINTF_ARGS(2, 3);
-
-/* Append VARIABLE=VALUE\0 string to the buffer, and add a respective
-   pointer into the vars array. */
-static char *addenv(struct cgi_env_block *block, const char *fmt, ...)
-{
-    int n, space;
-    char *added;
-    va_list ap;
-
-    /* Calculate how much space is left in the buffer */
-    space = sizeof(block->buf) - block->len - 2;
-    assert(space >= 0);
-
-    /* Make a pointer to the free space int the buffer */
-    added = block->buf + block->len;
-
-    /* Copy VARIABLE=VALUE\0 string into the free space */
-    va_start(ap, fmt);
-    n = mg_vsnprintf(block->conn, added, (size_t) space, fmt, ap);
-    va_end(ap);
-
-    /* Make sure we do not overflow buffer and the envp array */
-    if (n > 0 && n + 1 < space &&
-        block->nvars < (int) ARRAY_SIZE(block->vars) - 2) {
-        /* Append a pointer to the added string into the envp array */
-        block->vars[block->nvars++] = added;
-        /* Bump up used length counter. Include \0 terminator */
-        block->len += n + 1;
-    } else {
-        mg_cry(block->conn, "%s: CGI env buffer truncated for [%s]", __func__, fmt);
-    }
-
-    return added;
-}
-
-static void prepare_cgi_environment(struct mg_connection *conn,
-                                    const char *prog,
-                                    struct cgi_env_block *blk)
-{
-    const char *s, *slash;
-    struct vec var_vec;
-    char *p, src_addr[IP_ADDR_STR_LEN];
-    int  i;
-
-    blk->len = blk->nvars = 0;
-    blk->conn = conn;
-    sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa);
-
-    addenv(blk, "SERVER_NAME=%s", conn->ctx->config[AUTHENTICATION_DOMAIN]);
-    addenv(blk, "SERVER_ROOT=%s", conn->ctx->config[DOCUMENT_ROOT]);
-    addenv(blk, "DOCUMENT_ROOT=%s", conn->ctx->config[DOCUMENT_ROOT]);
-    addenv(blk, "SERVER_SOFTWARE=%s/%s", "Civetweb", mg_version());
-
-    /* Prepare the environment block */
-    addenv(blk, "%s", "GATEWAY_INTERFACE=CGI/1.1");
-    addenv(blk, "%s", "SERVER_PROTOCOL=HTTP/1.1");
-    addenv(blk, "%s", "REDIRECT_STATUS=200"); /* For PHP */
-
-    /* TODO(lsm): fix this for IPv6 case */
-    addenv(blk, "SERVER_PORT=%d", ntohs(conn->client.lsa.sin.sin_port));
-
-    addenv(blk, "REQUEST_METHOD=%s", conn->request_info.request_method);
-    addenv(blk, "REMOTE_ADDR=%s", src_addr);
-    addenv(blk, "REMOTE_PORT=%d", conn->request_info.remote_port);
-    addenv(blk, "REQUEST_URI=%s", conn->request_info.uri);
-
-    /* SCRIPT_NAME */
-    assert(conn->request_info.uri[0] == '/');
-    slash = strrchr(conn->request_info.uri, '/');
-    if ((s = strrchr(prog, '/')) == NULL)
-        s = prog;
-    addenv(blk, "SCRIPT_NAME=%.*s%s", (int) (slash - conn->request_info.uri),
-           conn->request_info.uri, s);
-
-    addenv(blk, "SCRIPT_FILENAME=%s", prog);
-    addenv(blk, "PATH_TRANSLATED=%s", prog);
-    addenv(blk, "HTTPS=%s", conn->ssl == NULL ? "off" : "on");
-
-    if ((s = mg_get_header(conn, "Content-Type")) != NULL)
-        addenv(blk, "CONTENT_TYPE=%s", s);
-
-    if (conn->request_info.query_string != NULL)
-        addenv(blk, "QUERY_STRING=%s", conn->request_info.query_string);
-
-    if ((s = mg_get_header(conn, "Content-Length")) != NULL)
-        addenv(blk, "CONTENT_LENGTH=%s", s);
-
-    if ((s = getenv("PATH")) != NULL)
-        addenv(blk, "PATH=%s", s);
-
-    if (conn->path_info != NULL) {
-        addenv(blk, "PATH_INFO=%s", conn->path_info);
-    }
-
-#if defined(_WIN32)
-    if ((s = getenv("COMSPEC")) != NULL) {
-        addenv(blk, "COMSPEC=%s", s);
-    }
-    if ((s = getenv("SYSTEMROOT")) != NULL) {
-        addenv(blk, "SYSTEMROOT=%s", s);
-    }
-    if ((s = getenv("SystemDrive")) != NULL) {
-        addenv(blk, "SystemDrive=%s", s);
-    }
-    if ((s = getenv("ProgramFiles")) != NULL) {
-        addenv(blk, "ProgramFiles=%s", s);
-    }
-    if ((s = getenv("ProgramFiles(x86)")) != NULL) {
-        addenv(blk, "ProgramFiles(x86)=%s", s);
-    }
-#else
-    if ((s = getenv("LD_LIBRARY_PATH")) != NULL)
-        addenv(blk, "LD_LIBRARY_PATH=%s", s);
-#endif /* _WIN32 */
-
-    if ((s = getenv("PERLLIB")) != NULL)
-        addenv(blk, "PERLLIB=%s", s);
-
-    if (conn->request_info.remote_user != NULL) {
-        addenv(blk, "REMOTE_USER=%s", conn->request_info.remote_user);
-        addenv(blk, "%s", "AUTH_TYPE=Digest");
-    }
-
-    /* Add all headers as HTTP_* variables */
-    for (i = 0; i < conn->request_info.num_headers; i++) {
-        p = addenv(blk, "HTTP_%s=%s",
-                   conn->request_info.http_headers[i].name,
-                   conn->request_info.http_headers[i].value);
-
-        /* Convert variable name into uppercase, and change - to _ */
-        for (; *p != '=' && *p != '\0'; p++) {
-            if (*p == '-')
-                *p = '_';
-            *p = (char) toupper(* (unsigned char *) p);
-        }
-    }
-
-    /* Add user-specified variables */
-    s = conn->ctx->config[CGI_ENVIRONMENT];
-    while ((s = next_option(s, &var_vec, NULL)) != NULL) {
-        addenv(blk, "%.*s", (int) var_vec.len, var_vec.ptr);
-    }
-
-    blk->vars[blk->nvars++] = NULL;
-    blk->buf[blk->len++] = '\0';
-
-    assert(blk->nvars < (int) ARRAY_SIZE(blk->vars));
-    assert(blk->len > 0);
-    assert(blk->len < (int) sizeof(blk->buf));
-}
-
-static void handle_cgi_request(struct mg_connection *conn, const char *prog)
-{
-    char *buf;
-    size_t buflen;
-    int headers_len, data_len, i, fdin[2] = { 0, 0 }, fdout[2] = { 0, 0 };
-    const char *status, *status_text, *connection_state;
-    char *pbuf, dir[PATH_MAX], *p;
-    struct mg_request_info ri;
-    struct cgi_env_block blk;
-    FILE *in = NULL, *out = NULL;
-    struct file fout = STRUCT_FILE_INITIALIZER;
-    pid_t pid = (pid_t) -1;
-
-    buf = NULL;
-    buflen = 16384;
-    prepare_cgi_environment(conn, prog, &blk);
-
-    /* CGI must be executed in its own directory. 'dir' must point to the
-       directory containing executable program, 'p' must point to the
-       executable program name relative to 'dir'. */
-    (void) mg_snprintf(conn, dir, sizeof(dir), "%s", prog);
-    if ((p = strrchr(dir, '/')) != NULL) {
-        *p++ = '\0';
-    } else {
-        dir[0] = '.', dir[1] = '\0';
-        p = (char *) prog;
-    }
-
-    if (pipe(fdin) != 0 || pipe(fdout) != 0) {
-        send_http_error(conn, 500, http_500_error,
-                        "Cannot create CGI pipe: %s", strerror(ERRNO));
-        goto done;
-    }
-
-    pid = spawn_process(conn, p, blk.buf, blk.vars, fdin[0], fdout[1], dir);
-    if (pid == (pid_t) -1) {
-        send_http_error(conn, 500, http_500_error,
-                        "Cannot spawn CGI process [%s]: %s", prog, strerror(ERRNO));
-        goto done;
-    }
-
-    /* Make sure child closes all pipe descriptors. It must dup them to 0,1 */
-    set_close_on_exec(fdin[0], conn);
-    set_close_on_exec(fdin[1], conn);
-    set_close_on_exec(fdout[0], conn);
-    set_close_on_exec(fdout[1], conn);
-
-    /* Parent closes only one side of the pipes.
-       If we don't mark them as closed, close() attempt before
-       return from this function throws an exception on Windows.
-       Windows does not like when closed descriptor is closed again. */
-    (void) close(fdin[0]);
-    (void) close(fdout[1]);
-    fdin[0] = fdout[1] = -1;
-
-
-    if ((in = fdopen(fdin[1], "wb")) == NULL ||
-        (out = fdopen(fdout[0], "rb")) == NULL) {
-        send_http_error(conn, 500, http_500_error,
-                        "fopen: %s", strerror(ERRNO));
-        goto done;
-    }
-
-    setbuf(in, NULL);
-    setbuf(out, NULL);
-    fout.fp = out;
-
-    /* Send POST data to the CGI process if needed */
-    if (!strcmp(conn->request_info.request_method, "POST") &&
-        !forward_body_data(conn, in, INVALID_SOCKET, NULL)) {
-        goto done;
-    }
-
-    /* Close so child gets an EOF. */
-    fclose(in);
-    in = NULL;
-    fdin[1] = -1;
-
-    /* Now read CGI reply into a buffer. We need to set correct
-       status code, thus we need to see all HTTP headers first.
-       Do not send anything back to client, until we buffer in all
-       HTTP headers. */
-    data_len = 0;
-    buf = malloc(buflen);
-    if (buf == NULL) {
-        send_http_error(conn, 500, http_500_error,
-                        "Not enough memory for buffer (%u bytes)",
-                        (unsigned int) buflen);
-        goto done;
-    }
-    headers_len = read_request(out, conn, buf, (int) buflen, &data_len);
-    if (headers_len <= 0) {
-        send_http_error(conn, 500, http_500_error,
-                        "CGI program sent malformed or too big (>%u bytes) "
-                        "HTTP headers: [%.*s]",
-                        (unsigned) buflen, data_len, buf);
-        goto done;
-    }
-    pbuf = buf;
-    buf[headers_len - 1] = '\0';
-    parse_http_headers(&pbuf, &ri);
-
-    /* Make up and send the status line */
-    status_text = "OK";
-    if ((status = get_header(&ri, "Status")) != NULL) {
-        conn->status_code = atoi(status);
-        status_text = status;
-        while (isdigit(* (unsigned char *) status_text) || *status_text == ' ') {
-            status_text++;
-        }
-    } else if (get_header(&ri, "Location") != NULL) {
-        conn->status_code = 302;
-    } else {
-        conn->status_code = 200;
-    }
-    connection_state = get_header(&ri, "Connection");
-    if (connection_state == NULL ||
-        mg_strcasecmp(connection_state, "keep-alive")) {
-        conn->must_close = 1;
-    }
-    (void) mg_printf(conn, "HTTP/1.1 %d %s\r\n", conn->status_code,
-                     status_text);
-
-    /* Send headers */
-    for (i = 0; i < ri.num_headers; i++) {
-        mg_printf(conn, "%s: %s\r\n",
-                  ri.http_headers[i].name, ri.http_headers[i].value);
-    }
-    mg_write(conn, "\r\n", 2);
-
-    /* Send chunk of data that may have been read after the headers */
-    conn->num_bytes_sent += mg_write(conn, buf + headers_len,
-                                     (size_t)(data_len - headers_len));
-
-    /* Read the rest of CGI output and send to the client */
-    send_file_data(conn, &fout, 0, INT64_MAX);
-
-done:
-    if (pid != (pid_t) -1) {
-        kill(pid, SIGKILL);
-#if !defined(_WIN32)
-        {
-            int st;
-            while (waitpid(pid, &st, 0) != -1);  /* clean zombies */
-        }
-#endif
-    }
-    if (fdin[0] != -1) {
-        close(fdin[0]);
-    }
-    if (fdout[1] != -1) {
-        close(fdout[1]);
-    }
-
-    if (in != NULL) {
-        fclose(in);
-    } else if (fdin[1] != -1) {
-        close(fdin[1]);
-    }
-
-    if (out != NULL) {
-        fclose(out);
-    } else if (fdout[0] != -1) {
-        close(fdout[0]);
-    }
-    if (buf != NULL) {
-        free(buf);
-    }
-}
-#endif /* !NO_CGI */
-
-/* For a given PUT path, create all intermediate subdirectories
-   for given path. Return 0 if the path itself is a directory,
-   or -1 on error, 1 if OK. */
-static int put_dir(struct mg_connection *conn, const char *path)
-{
-    char buf[PATH_MAX];
-    const char *s, *p;
-    struct file file = STRUCT_FILE_INITIALIZER;
-    int len, res = 1;
-
-    for (s = p = path + 2; (p = strchr(s, '/')) != NULL; s = ++p) {
-        len = (int)(p - path);
-        if (len >= (int) sizeof(buf)) {
-            res = -1;
-            break;
-        }
-        memcpy(buf, path, len);
-        buf[len] = '\0';
-
-        /* Try to create intermediate directory */
-        DEBUG_TRACE(("mkdir(%s)", buf));
-        if (!mg_stat(conn, buf, &file) && mg_mkdir(buf, 0755) != 0) {
-            res = -1;
-            break;
-        }
-
-        /* Is path itself a directory? */
-        if (p[1] == '\0') {
-            res = 0;
-        }
-    }
-
-    return res;
-}
-
-static void mkcol(struct mg_connection *conn, const char *path)
-{
-    int rc, body_len;
-    struct de de;
-    memset(&de.file, 0, sizeof(de.file));
-    if (!mg_stat(conn, path, &de.file)) {
-        mg_cry(conn, "%s: mg_stat(%s) failed: %s",
-               __func__, path, strerror(ERRNO));
-    }
-
-    if(de.file.modification_time) {
-        send_http_error(conn, 405, "Method Not Allowed",
-                        "mkcol(%s): %s", path, strerror(ERRNO));
-        return;
-    }
-
-    body_len = conn->data_len - conn->request_len;
-    if(body_len > 0) {
-        send_http_error(conn, 415, "Unsupported media type",
-                        "mkcol(%s): %s", path, strerror(ERRNO));
-        return;
-    }
-
-    rc = mg_mkdir(path, 0755);
-
-    if (rc == 0) {
-        conn->status_code = 201;
-        mg_printf(conn, "HTTP/1.1 %d Created\r\n\r\n", conn->status_code);
-    } else if (rc == -1) {
-        if(errno == EEXIST)
-            send_http_error(conn, 405, "Method Not Allowed",
-                            "mkcol(%s): %s", path, strerror(ERRNO));
-        else if(errno == EACCES)
-            send_http_error(conn, 403, "Forbidden",
-                            "mkcol(%s): %s", path, strerror(ERRNO));
-        else if(errno == ENOENT)
-            send_http_error(conn, 409, "Conflict",
-                            "mkcol(%s): %s", path, strerror(ERRNO));
-        else
-            send_http_error(conn, 500, http_500_error,
-                            "fopen(%s): %s", path, strerror(ERRNO));
-    }
-}
-
-static void put_file(struct mg_connection *conn, const char *path)
-{
-    struct file file = STRUCT_FILE_INITIALIZER;
-    const char *range;
-    int64_t r1, r2;
-    int rc;
-
-    conn->status_code = mg_stat(conn, path, &file) ? 200 : 201;
-
-    if ((rc = put_dir(conn, path)) == 0) {
-        mg_printf(conn, "HTTP/1.1 %d OK\r\n\r\n", conn->status_code);
-    } else if (rc == -1) {
-        send_http_error(conn, 500, http_500_error,
-                        "put_dir(%s): %s", path, strerror(ERRNO));
-    } else if (!mg_fopen(conn, path, "wb+", &file) || file.fp == NULL) {
-        mg_fclose(&file);
-        send_http_error(conn, 500, http_500_error,
-                        "fopen(%s): %s", path, strerror(ERRNO));
-    } else {
-        fclose_on_exec(&file, conn);
-        range = mg_get_header(conn, "Content-Range");
-        r1 = r2 = 0;
-        if (range != NULL && parse_range_header(range, &r1, &r2) > 0) {
-            conn->status_code = 206;
-            fseeko(file.fp, r1, SEEK_SET);
-        }
-        if (!forward_body_data(conn, file.fp, INVALID_SOCKET, NULL)) {
-            conn->status_code = 500;
-        }
-        mg_printf(conn, "HTTP/1.1 %d OK\r\nContent-Length: 0\r\n\r\n",
-                  conn->status_code);
-        mg_fclose(&file);
-    }
-}
-
-static void send_ssi_file(struct mg_connection *, const char *,
-                          struct file *, int);
-
-static void do_ssi_include(struct mg_connection *conn, const char *ssi,
-                           char *tag, int include_level)
-{
-    char file_name[MG_BUF_LEN], path[PATH_MAX], *p;
-    struct file file = STRUCT_FILE_INITIALIZER;
-
-    /* sscanf() is safe here, since send_ssi_file() also uses buffer
-       of size MG_BUF_LEN to get the tag. So strlen(tag) is
-       always < MG_BUF_LEN. */
-    if (sscanf(tag, " virtual=\"%[^\"]\"", file_name) == 1) {
-        /* File name is relative to the webserver root */
-        (void) mg_snprintf(conn, path, sizeof(path), "%s%c%s",
-                           conn->ctx->config[DOCUMENT_ROOT], '/', file_name);
-    } else if (sscanf(tag, " abspath=\"%[^\"]\"", file_name) == 1) {
-        /* File name is relative to the webserver working directory
-           or it is absolute system path */
-        (void) mg_snprintf(conn, path, sizeof(path), "%s", file_name);
-    } else if (sscanf(tag, " file=\"%[^\"]\"", file_name) == 1 ||
-               sscanf(tag, " \"%[^\"]\"", file_name) == 1) {
-        /* File name is relative to the currect document */
-        (void) mg_snprintf(conn, path, sizeof(path), "%s", ssi);
-        if ((p = strrchr(path, '/')) != NULL) {
-            p[1] = '\0';
-        }
-        (void) mg_snprintf(conn, path + strlen(path),
-                           sizeof(path) - strlen(path), "%s", file_name);
-    } else {
-        mg_cry(conn, "Bad SSI #include: [%s]", tag);
-        return;
-    }
-
-    if (!mg_fopen(conn, path, "rb", &file)) {
-        mg_cry(conn, "Cannot open SSI #include: [%s]: fopen(%s): %s",
-               tag, path, strerror(ERRNO));
-    } else {
-        fclose_on_exec(&file, conn);
-        if (match_prefix(conn->ctx->config[SSI_EXTENSIONS],
-                         (int)strlen(conn->ctx->config[SSI_EXTENSIONS]), path) > 0) {
-            send_ssi_file(conn, path, &file, include_level + 1);
-        } else {
-            send_file_data(conn, &file, 0, INT64_MAX);
-        }
-        mg_fclose(&file);
-    }
-}
-
-#if !defined(NO_POPEN)
-static void do_ssi_exec(struct mg_connection *conn, char *tag)
-{
-    char cmd[MG_BUF_LEN] = "";
-    struct file file = STRUCT_FILE_INITIALIZER;
-
-    if (sscanf(tag, " \"%[^\"]\"", cmd) != 1) {
-        mg_cry(conn, "Bad SSI #exec: [%s]", tag);
-    } else if ((file.fp = popen(cmd, "r")) == NULL) {
-        mg_cry(conn, "Cannot SSI #exec: [%s]: %s", cmd, strerror(ERRNO));
-    } else {
-        send_file_data(conn, &file, 0, INT64_MAX);
-        pclose(file.fp);
-    }
-}
-#endif /* !NO_POPEN */
-
-static int mg_fgetc(struct file *filep, int offset)
-{
-    if (filep->membuf != NULL && offset >=0 && offset < filep->size) {
-        return ((unsigned char *) filep->membuf)[offset];
-    } else if (filep->fp != NULL) {
-        return fgetc(filep->fp);
-    } else {
-        return EOF;
-    }
-}
-
-static void send_ssi_file(struct mg_connection *conn, const char *path,
-                          struct file *filep, int include_level)
-{
-    char buf[MG_BUF_LEN];
-    int ch, offset, len, in_ssi_tag;
-
-    if (include_level > 10) {
-        mg_cry(conn, "SSI #include level is too deep (%s)", path);
-        return;
-    }
-
-    in_ssi_tag = len = offset = 0;
-    while ((ch = mg_fgetc(filep, offset)) != EOF) {
-        if (in_ssi_tag && ch == '>') {
-            in_ssi_tag = 0;
-            buf[len++] = (char) ch;
-            buf[len] = '\0';
-            assert(len <= (int) sizeof(buf));
-            if (len < 6 || memcmp(buf, "<!--#", 5) != 0) {
-                /* Not an SSI tag, pass it */
-                (void) mg_write(conn, buf, (size_t) len);
-            } else {
-                if (!memcmp(buf + 5, "include", 7)) {
-                    do_ssi_include(conn, path, buf + 12, include_level);
-#if !defined(NO_POPEN)
-                } else if (!memcmp(buf + 5, "exec", 4)) {
-                    do_ssi_exec(conn, buf + 9);
-#endif /* !NO_POPEN */
-                } else {
-                    mg_cry(conn, "%s: unknown SSI " "command: \"%s\"", path, buf);
-                }
-            }
-            len = 0;
-        } else if (in_ssi_tag) {
-            if (len == 5 && memcmp(buf, "<!--#", 5) != 0) {
-                /* Not an SSI tag */
-                in_ssi_tag = 0;
-            } else if (len == (int) sizeof(buf) - 2) {
-                mg_cry(conn, "%s: SSI tag is too large", path);
-                len = 0;
-            }
-            buf[len++] = ch & 0xff;
-        } else if (ch == '<') {
-            in_ssi_tag = 1;
-            if (len > 0) {
-                mg_write(conn, buf, (size_t) len);
-            }
-            len = 0;
-            buf[len++] = ch & 0xff;
-        } else {
-            buf[len++] = ch & 0xff;
-            if (len == (int) sizeof(buf)) {
-                mg_write(conn, buf, (size_t) len);
-                len = 0;
-            }
-        }
-    }
-
-    /* Send the rest of buffered data */
-    if (len > 0) {
-        mg_write(conn, buf, (size_t) len);
-    }
-}
-
-static void handle_ssi_file_request(struct mg_connection *conn,
-                                    const char *path)
-{
-    struct file file = STRUCT_FILE_INITIALIZER;
-
-    if (!mg_fopen(conn, path, "rb", &file)) {
-        send_http_error(conn, 500, http_500_error, "fopen(%s): %s", path,
-                        strerror(ERRNO));
-    } else {
-        conn->must_close = 1;
-        fclose_on_exec(&file, conn);
-        mg_printf(conn, "HTTP/1.1 200 OK\r\n"
-                  "Content-Type: text/html\r\nConnection: %s\r\n\r\n",
-                  suggest_connection_header(conn));
-        send_ssi_file(conn, path, &file, 0);
-        mg_fclose(&file);
-    }
-}
-
-static void send_options(struct mg_connection *conn)
-{
-    conn->status_code = 200;
-
-    mg_printf(conn, "%s", "HTTP/1.1 200 OK\r\n"
-              "Allow: GET, POST, HEAD, CONNECT, PUT, DELETE, OPTIONS, PROPFIND, MKCOL\r\n"
-              "DAV: 1\r\n\r\n");
-}
-
-/* Writes PROPFIND properties for a collection element */
-static void print_props(struct mg_connection *conn, const char* uri,
-                        struct file *filep)
-{
-    char mtime[64];
-    gmt_time_string(mtime, sizeof(mtime), &filep->modification_time);
-    conn->num_bytes_sent += mg_printf(conn,
-                                      "<d:response>"
-                                      "<d:href>%s</d:href>"
-                                      "<d:propstat>"
-                                      "<d:prop>"
-                                      "<d:resourcetype>%s</d:resourcetype>"
-                                      "<d:getcontentlength>%" INT64_FMT "</d:getcontentlength>"
-                                      "<d:getlastmodified>%s</d:getlastmodified>"
-                                      "</d:prop>"
-                                      "<d:status>HTTP/1.1 200 OK</d:status>"
-                                      "</d:propstat>"
-                                      "</d:response>\n",
-                                      uri,
-                                      filep->is_directory ? "<d:collection/>" : "",
-                                      filep->size,
-                                      mtime);
-}
-
-static void print_dav_dir_entry(struct de *de, void *data)
-{
-    char href[PATH_MAX];
-    char href_encoded[PATH_MAX];
-    struct mg_connection *conn = (struct mg_connection *) data;
-    mg_snprintf(conn, href, sizeof(href), "%s%s",
-                conn->request_info.uri, de->file_name);
-    mg_url_encode(href, href_encoded, PATH_MAX-1);
-    print_props(conn, href_encoded, &de->file);
-}
-
-static void handle_propfind(struct mg_connection *conn, const char *path,
-                            struct file *filep)
-{
-    const char *depth = mg_get_header(conn, "Depth");
-
-    conn->must_close = 1;
-    conn->status_code = 207;
-    mg_printf(conn, "HTTP/1.1 207 Multi-Status\r\n"
-              "Connection: close\r\n"
-              "Content-Type: text/xml; charset=utf-8\r\n\r\n");
-
-    conn->num_bytes_sent += mg_printf(conn,
-                                      "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
-                                      "<d:multistatus xmlns:d='DAV:'>\n");
-
-    /* Print properties for the requested resource itself */
-    print_props(conn, conn->request_info.uri, filep);
-
-    /* If it is a directory, print directory entries too if Depth is not 0 */
-    if (filep->is_directory &&
-        !mg_strcasecmp(conn->ctx->config[ENABLE_DIRECTORY_LISTING], "yes") &&
-        (depth == NULL || strcmp(depth, "0") != 0)) {
-        scan_directory(conn, path, conn, &print_dav_dir_entry);
-    }
-
-    conn->num_bytes_sent += mg_printf(conn, "%s\n", "</d:multistatus>");
-}
-
-void mg_lock(struct mg_connection* conn)
-{
-    (void) pthread_mutex_lock(&conn->mutex);
-}
-
-void mg_unlock(struct mg_connection* conn)
-{
-    (void) pthread_mutex_unlock(&conn->mutex);
-}
-
-#if defined(USE_WEBSOCKET)
-
-/* START OF SHA-1 code
-   Copyright(c) By Steve Reid <steve@edmweb.com> */
-#define SHA1HANDSOFF
-#if defined(__sun)
-#include "solarisfixes.h"
-#endif
-
-static int is_big_endian(void)
-{
-    static const int n = 1;
-    return ((char *) &n)[0] == 0;
-}
-
-union char64long16 {
-    unsigned char c[64];
-    uint32_t l[16];
-};
-
-#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
-
-static uint32_t blk0(union char64long16 *block, int i)
-{
-    /* Forrest: SHA expect BIG_ENDIAN, swap if LITTLE_ENDIAN */
-    if (!is_big_endian()) {
-        block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) |
-                      (rol(block->l[i], 8) & 0x00FF00FF);
-    }
-    return block->l[i];
-}
-
-#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
-    ^block->l[(i+2)&15]^block->l[i&15],1))
-#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(block, i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
-#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
-#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
-
-typedef struct {
-    uint32_t state[5];
-    uint32_t count[2];
-    unsigned char buffer[64];
-} SHA1_CTX;
-
-static void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
-{
-    uint32_t a, b, c, d, e;
-    union char64long16 block[1];
-
-    memcpy(block, buffer, 64);
-    a = state[0];
-    b = state[1];
-    c = state[2];
-    d = state[3];
-    e = state[4];
-    R0(a,b,c,d,e, 0);
-    R0(e,a,b,c,d, 1);
-    R0(d,e,a,b,c, 2);
-    R0(c,d,e,a,b, 3);
-    R0(b,c,d,e,a, 4);
-    R0(a,b,c,d,e, 5);
-    R0(e,a,b,c,d, 6);
-    R0(d,e,a,b,c, 7);
-    R0(c,d,e,a,b, 8);
-    R0(b,c,d,e,a, 9);
-    R0(a,b,c,d,e,10);
-    R0(e,a,b,c,d,11);
-    R0(d,e,a,b,c,12);
-    R0(c,d,e,a,b,13);
-    R0(b,c,d,e,a,14);
-    R0(a,b,c,d,e,15);
-    R1(e,a,b,c,d,16);
-    R1(d,e,a,b,c,17);
-    R1(c,d,e,a,b,18);
-    R1(b,c,d,e,a,19);
-    R2(a,b,c,d,e,20);
-    R2(e,a,b,c,d,21);
-    R2(d,e,a,b,c,22);
-    R2(c,d,e,a,b,23);
-    R2(b,c,d,e,a,24);
-    R2(a,b,c,d,e,25);
-    R2(e,a,b,c,d,26);
-    R2(d,e,a,b,c,27);
-    R2(c,d,e,a,b,28);
-    R2(b,c,d,e,a,29);
-    R2(a,b,c,d,e,30);
-    R2(e,a,b,c,d,31);
-    R2(d,e,a,b,c,32);
-    R2(c,d,e,a,b,33);
-    R2(b,c,d,e,a,34);
-    R2(a,b,c,d,e,35);
-    R2(e,a,b,c,d,36);
-    R2(d,e,a,b,c,37);
-    R2(c,d,e,a,b,38);
-    R2(b,c,d,e,a,39);
-    R3(a,b,c,d,e,40);
-    R3(e,a,b,c,d,41);
-    R3(d,e,a,b,c,42);
-    R3(c,d,e,a,b,43);
-    R3(b,c,d,e,a,44);
-    R3(a,b,c,d,e,45);
-    R3(e,a,b,c,d,46);
-    R3(d,e,a,b,c,47);
-    R3(c,d,e,a,b,48);
-    R3(b,c,d,e,a,49);
-    R3(a,b,c,d,e,50);
-    R3(e,a,b,c,d,51);
-    R3(d,e,a,b,c,52);
-    R3(c,d,e,a,b,53);
-    R3(b,c,d,e,a,54);
-    R3(a,b,c,d,e,55);
-    R3(e,a,b,c,d,56);
-    R3(d,e,a,b,c,57);
-    R3(c,d,e,a,b,58);
-    R3(b,c,d,e,a,59);
-    R4(a,b,c,d,e,60);
-    R4(e,a,b,c,d,61);
-    R4(d,e,a,b,c,62);
-    R4(c,d,e,a,b,63);
-    R4(b,c,d,e,a,64);
-    R4(a,b,c,d,e,65);
-    R4(e,a,b,c,d,66);
-    R4(d,e,a,b,c,67);
-    R4(c,d,e,a,b,68);
-    R4(b,c,d,e,a,69);
-    R4(a,b,c,d,e,70);
-    R4(e,a,b,c,d,71);
-    R4(d,e,a,b,c,72);
-    R4(c,d,e,a,b,73);
-    R4(b,c,d,e,a,74);
-    R4(a,b,c,d,e,75);
-    R4(e,a,b,c,d,76);
-    R4(d,e,a,b,c,77);
-    R4(c,d,e,a,b,78);
-    R4(b,c,d,e,a,79);
-    state[0] += a;
-    state[1] += b;
-    state[2] += c;
-    state[3] += d;
-    state[4] += e;
-    a = b = c = d = e = 0;
-    memset(block, '\0', sizeof(block));
-}
-
-static void SHA1Init(SHA1_CTX* context)
-{
-    context->state[0] = 0x67452301;
-    context->state[1] = 0xEFCDAB89;
-    context->state[2] = 0x98BADCFE;
-    context->state[3] = 0x10325476;
-    context->state[4] = 0xC3D2E1F0;
-    context->count[0] = context->count[1] = 0;
-}
-
-static void SHA1Update(SHA1_CTX* context, const unsigned char* data,
-                       uint32_t len)
-{
-    uint32_t i, j;
-
-    j = context->count[0];
-    if ((context->count[0] += len << 3) < j)
-        context->count[1]++;
-    context->count[1] += (len>>29);
-    j = (j >> 3) & 63;
-    if ((j + len) > 63) {
-        memcpy(&context->buffer[j], data, (i = 64-j));
-        SHA1Transform(context->state, context->buffer);
-        for ( ; i + 63 < len; i += 64) {
-            SHA1Transform(context->state, &data[i]);
-        }
-        j = 0;
-    } else i = 0;
-    memcpy(&context->buffer[j], &data[i], len - i);
-}
-
-static void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
-{
-    unsigned i;
-    unsigned char finalcount[8], c;
-
-    for (i = 0; i < 8; i++) {
-        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
-                                         >> ((3-(i & 3)) * 8) ) & 255);
-    }
-    c = 0200;
-    SHA1Update(context, &c, 1);
-    while ((context->count[0] & 504) != 448) {
-        c = 0000;
-        SHA1Update(context, &c, 1);
-    }
-    SHA1Update(context, finalcount, 8);
-    for (i = 0; i < 20; i++) {
-        digest[i] = (unsigned char)
-                    ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
-    }
-    memset(context, '\0', sizeof(*context));
-    memset(&finalcount, '\0', sizeof(finalcount));
-}
-/* END OF SHA1 CODE */
-
-static void base64_encode(const unsigned char *src, int src_len, char *dst)
-{
-    static const char *b64 =
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    int i, j, a, b, c;
-
-    for (i = j = 0; i < src_len; i += 3) {
-        a = src[i];
-        b = i + 1 >= src_len ? 0 : src[i + 1];
-        c = i + 2 >= src_len ? 0 : src[i + 2];
-
-        dst[j++] = b64[a >> 2];
-        dst[j++] = b64[((a & 3) << 4) | (b >> 4)];
-        if (i + 1 < src_len) {
-            dst[j++] = b64[(b & 15) << 2 | (c >> 6)];
-        }
-        if (i + 2 < src_len) {
-            dst[j++] = b64[c & 63];
-        }
-    }
-    while (j % 4 != 0) {
-        dst[j++] = '=';
-    }
-    dst[j++] = '\0';
-}
-
-static void send_websocket_handshake(struct mg_connection *conn)
-{
-    static const char *magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-    char buf[100], sha[20], b64_sha[sizeof(sha) * 2];
-    SHA1_CTX sha_ctx;
-
-    mg_snprintf(conn, buf, sizeof(buf), "%s%s",
-                mg_get_header(conn, "Sec-WebSocket-Key"), magic);
-    SHA1Init(&sha_ctx);
-    SHA1Update(&sha_ctx, (unsigned char *) buf, (uint32_t)strlen(buf));
-    SHA1Final((unsigned char *) sha, &sha_ctx);
-    base64_encode((unsigned char *) sha, sizeof(sha), b64_sha);
-    mg_printf(conn, "%s%s%s",
-              "HTTP/1.1 101 Switching Protocols\r\n"
-              "Upgrade: websocket\r\n"
-              "Connection: Upgrade\r\n"
-              "Sec-WebSocket-Accept: ", b64_sha, "\r\n\r\n");
-}
-
-static void read_websocket(struct mg_connection *conn)
-{
-    /* Pointer to the beginning of the portion of the incoming websocket
-       message queue.
-       The original websocket upgrade request is never removed, so the queue
-       begins after it. */
-    unsigned char *buf = (unsigned char *) conn->buf + conn->request_len;
-    int n;
-
-    /* body_len is the length of the entire queue in bytes
-       len is the length of the current message
-       data_len is the length of the current message's data payload
-       header_len is the length of the current message's header */
-    size_t i, len, mask_len, data_len, header_len, body_len;
-
-    /* "The masking key is a 32-bit value chosen at random by the client."
-       http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17#section-5 */
-    unsigned char mask[4];
-
-    /* data points to the place where the message is stored when passed to the
-       websocket_data callback.  This is either mem on the stack, or a
-       dynamically allocated buffer if it is too large. */
-    char mem[4096];
-    char *data = mem;
-    unsigned char mop;  /* mask flag and opcode */
-
-    /* Loop continuously, reading messages from the socket, invoking the
-       callback, and waiting repeatedly until an error occurs. */
-    assert(conn->content_len == 0);
-    for (;;) {
-        header_len = 0;
-        assert(conn->data_len >= conn->request_len);
-        if ((body_len = conn->data_len - conn->request_len) >= 2) {
-            len = buf[1] & 127;
-            mask_len = buf[1] & 128 ? 4 : 0;
-            if (len < 126 && body_len >= mask_len) {
-                data_len = len;
-                header_len = 2 + mask_len;
-            } else if (len == 126 && body_len >= 4 + mask_len) {
-                header_len = 4 + mask_len;
-                data_len = ((((int) buf[2]) << 8) + buf[3]);
-            } else if (body_len >= 10 + mask_len) {
-                header_len = 10 + mask_len;
-                data_len = (((uint64_t) ntohl(* (uint32_t *) &buf[2])) << 32) +
-                           ntohl(* (uint32_t *) &buf[6]);
-            }
-        }
-
-        if (header_len > 0) {
-            /* Allocate space to hold websocket payload */
-            data = mem;
-            if (data_len > sizeof(mem)) {
-                data = (char *)malloc(data_len);
-                if (data == NULL) {
-                    /* Allocation failed, exit the loop and then close the
-                       connection */
-                    mg_cry(conn, "websocket malloc() failed; closing connection");
-                    break;
-                }
-            }
-
-            /* Copy the mask before we shift the queue and destroy it */
-            if (mask_len > 0) {
-                *(uint32_t*)mask = *(uint32_t*)(buf + header_len - mask_len);
-            } else {
-                *(uint32_t*)mask = 0;
-            }
-
-            /* Read frame payload from the first message in the queue into
-               data and advance the queue by moving the memory in place. */
-            assert(body_len >= header_len);
-            if (data_len + header_len > body_len) {
-                mop = buf[0];   /* current mask and opcode */
-                /* Overflow case */
-                len = body_len - header_len;
-                memcpy(data, buf + header_len, len);
-                int error = 0;
-                while (len < data_len) {
-                    int n = pull(NULL, conn, data + len, (int)(data_len - len));
-                    if (n < 0) {
-                        error = 1;
-                        break;
-                    }
-                    len += n;
-                }
-                if (error) {
-                    mg_cry(conn, "Websocket pull failed; closing connection");
-                    break;
-                }
-                conn->data_len = conn->request_len;
-            } else {
-                mop = buf[0];   /* current mask and opcode, overwritten by memmove() */
-                /* Length of the message being read at the front of the
-                   queue */
-                len = data_len + header_len;
-
-                /* Copy the data payload into the data pointer for the
-                   callback */
-                memcpy(data, buf + header_len, data_len);
-
-                /* Move the queue forward len bytes */
-                memmove(buf, buf + len, body_len - len);
-
-                /* Mark the queue as advanced */
-                conn->data_len -= (int)len;
-            }
-
-            /* Apply mask if necessary */
-            if (mask_len > 0) {
-                for (i = 0; i < data_len; ++i) {
-                    data[i] ^= mask[i & 3];
-                }
-            }
-
-            /* Exit the loop if callback signalled to exit,
-               or "connection close" opcode received. */
-            if ((conn->ctx->callbacks.websocket_data != NULL &&
-                 !conn->ctx->callbacks.websocket_data(conn, mop, data, data_len)) ||
-                (buf[0] & 0xf) == WEBSOCKET_OPCODE_CONNECTION_CLOSE) {  /* Opcode == 8, connection close */
-                break;
-            }
-
-            if (data != mem) {
-                free(data);
-            }
-            /* Not breaking the loop, process next websocket frame. */
-        } else {
-            /* Read from the socket into the next available location in the
-               message queue. */
-            if ((n = pull(NULL, conn, conn->buf + conn->data_len,
-                          conn->buf_size - conn->data_len)) <= 0) {
-                /* Error, no bytes read */
-                break;
-            }
-            conn->data_len += n;
-        }
-    }
-}
-
-int mg_websocket_write(struct mg_connection* conn, int opcode, const char* data, size_t dataLen)
-{
-    unsigned char header[10];
-    size_t headerLen = 1;
-
-    int retval = -1;
-
-    header[0] = 0x80 + (opcode & 0xF);
-
-    /* Frame format: http://tools.ietf.org/html/rfc6455#section-5.2 */
-    if (dataLen < 126) {
-        /* inline 7-bit length field */
-        header[1] = (unsigned char)dataLen;
-        headerLen = 2;
-    } else if (dataLen <= 0xFFFF) {
-        /* 16-bit length field */
-        header[1] = 126;
-        *(uint16_t*)(header + 2) = htons((uint16_t)dataLen);
-        headerLen = 4;
-    } else {
-        /* 64-bit length field */
-        header[1] = 127;
-        *(uint32_t*)(header + 2) = htonl((uint64_t)dataLen >> 32);
-        *(uint32_t*)(header + 6) = htonl(dataLen & 0xFFFFFFFF);
-        headerLen = 10;
-    }
-
-    /* Note that POSIX/Winsock's send() is threadsafe
-       http://stackoverflow.com/questions/1981372/are-parallel-calls-to-send-recv-on-the-same-socket-valid
-       but mongoose's mg_printf/mg_write is not (because of the loop in
-       push(), although that is only a problem if the packet is large or
-       outgoing buffer is full). */
-    (void) mg_lock(conn);
-    retval = mg_write(conn, header, headerLen);
-    retval = mg_write(conn, data, dataLen);
-    mg_unlock(conn);
-
-    return retval;
-}
-
-static void handle_websocket_request(struct mg_connection *conn)
-{
-    const char *version = mg_get_header(conn, "Sec-WebSocket-Version");
-    if (version == NULL || strcmp(version, "13") != 0) {
-        send_http_error(conn, 426, "Upgrade Required", "%s", "Upgrade Required");
-    } else if (conn->ctx->callbacks.websocket_connect != NULL &&
-               conn->ctx->callbacks.websocket_connect(conn) != 0) {
-        /* Callback has returned non-zero, do not proceed with handshake */
-    } else {
-        send_websocket_handshake(conn);
-        if (conn->ctx->callbacks.websocket_ready != NULL) {
-            conn->ctx->callbacks.websocket_ready(conn);
-        }
-        read_websocket(conn);
-    }
-}
-
-static int is_websocket_request(const struct mg_connection *conn)
-{
-    const char *host, *upgrade, *connection, *version, *key;
-
-    host = mg_get_header(conn, "Host");
-    upgrade = mg_get_header(conn, "Upgrade");
-    connection = mg_get_header(conn, "Connection");
-    key = mg_get_header(conn, "Sec-WebSocket-Key");
-    version = mg_get_header(conn, "Sec-WebSocket-Version");
-
-    return host != NULL && upgrade != NULL && connection != NULL &&
-           key != NULL && version != NULL &&
-           mg_strcasestr(upgrade, "websocket") != NULL &&
-           mg_strcasestr(connection, "Upgrade") != NULL;
-}
-#endif /* !USE_WEBSOCKET */
-
-static int isbyte(int n)
-{
-    return n >= 0 && n <= 255;
-}
-
-static int parse_net(const char *spec, uint32_t *net, uint32_t *mask)
-{
-    int n, a, b, c, d, slash = 32, len = 0;
-
-    if ((sscanf(spec, "%d.%d.%d.%d/%d%n", &a, &b, &c, &d, &slash, &n) == 5 ||
-         sscanf(spec, "%d.%d.%d.%d%n", &a, &b, &c, &d, &n) == 4) &&
-        isbyte(a) && isbyte(b) && isbyte(c) && isbyte(d) &&
-        slash >= 0 && slash < 33) {
-        len = n;
-        *net = ((uint32_t)a << 24) | ((uint32_t)b << 16) | ((uint32_t)c << 8) | d;
-        *mask = slash ? 0xffffffffU << (32 - slash) : 0;
-    }
-
-    return len;
-}
-
-static int set_throttle(const char *spec, uint32_t remote_ip, const char *uri)
-{
-    int throttle = 0;
-    struct vec vec, val;
-    uint32_t net, mask;
-    char mult;
-    double v;
-
-    while ((spec = next_option(spec, &vec, &val)) != NULL) {
-        mult = ',';
-        if (sscanf(val.ptr, "%lf%c", &v, &mult) < 1 || v < 0 ||
-            (lowercase(&mult) != 'k' && lowercase(&mult) != 'm' && mult != ',')) {
-            continue;
-        }
-        v *= lowercase(&mult) == 'k' ? 1024 : lowercase(&mult) == 'm' ? 1048576 : 1;
-        if (vec.len == 1 && vec.ptr[0] == '*') {
-            throttle = (int) v;
-        } else if (parse_net(vec.ptr, &net, &mask) > 0) {
-            if ((remote_ip & mask) == net) {
-                throttle = (int) v;
-            }
-        } else if (match_prefix(vec.ptr, (int)vec.len, uri) > 0) {
-            throttle = (int) v;
-        }
-    }
-
-    return throttle;
-}
-
-static uint32_t get_remote_ip(const struct mg_connection *conn)
-{
-    return ntohl(* (uint32_t *) &conn->client.rsa.sin.sin_addr);
-}
-
-#ifdef USE_LUA
-#include "mod_lua.inl"
-#endif /* USE_LUA */
-
-int mg_upload(struct mg_connection *conn, const char *destination_dir)
-{
-    const char *content_type_header, *boundary_start;
-    char buf[MG_BUF_LEN], path[PATH_MAX], fname[1024], boundary[100], *s;
-    FILE *fp;
-    int bl, n, i, j, headers_len, boundary_len, eof,
-        len = 0, num_uploaded_files = 0;
-
-    /* Request looks like this:
-
-       POST /upload HTTP/1.1
-       Host: 127.0.0.1:8080
-       Content-Length: 244894
-       Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryRVr
-
-       ------WebKitFormBoundaryRVr
-       Content-Disposition: form-data; name="file"; filename="accum.png"
-       Content-Type: image/png
-
-        <89>PNG
-        <PNG DATA>
-       ------WebKitFormBoundaryRVr */
-
-    /* Extract boundary string from the Content-Type header */
-    if ((content_type_header = mg_get_header(conn, "Content-Type")) == NULL ||
-        (boundary_start = mg_strcasestr(content_type_header,
-                                        "boundary=")) == NULL ||
-        (sscanf(boundary_start, "boundary=\"%99[^\"]\"", boundary) == 0 &&
-         sscanf(boundary_start, "boundary=%99s", boundary) == 0) ||
-        boundary[0] == '\0') {
-        return num_uploaded_files;
-    }
-
-    boundary_len = (int)strlen(boundary);
-    bl = boundary_len + 4;  /* \r\n--<boundary> */
-    for (;;) {
-        /* Pull in headers */
-        assert(len >= 0 && len <= (int) sizeof(buf));
-        while ((n = mg_read(conn, buf + len, sizeof(buf) - len)) > 0) {
-            len += n;
-        }
-        if ((headers_len = get_request_len(buf, len)) <= 0) {
-            break;
-        }
-
-        /* Fetch file name. */
-        fname[0] = '\0';
-        for (i = j = 0; i < headers_len; i++) {
-            if (buf[i] == '\r' && buf[i + 1] == '\n') {
-                buf[i] = buf[i + 1] = '\0';
-                /* TODO(lsm): don't expect filename to be the 3rd field,
-                   parse the header properly instead. */
-                IGNORE_UNUSED_RESULT(sscanf(&buf[j], "Content-Disposition: %*s %*s filename=\"%1023[^\"]",
-                                            fname));
-                j = i + 2;
-            }
-        }
-
-        /* Give up if the headers are not what we expect */
-        if (fname[0] == '\0') {
-            break;
-        }
-
-        /* Move data to the beginning of the buffer */
-        assert(len >= headers_len);
-        memmove(buf, &buf[headers_len], len - headers_len);
-        len -= headers_len;
-
-        /* We open the file with exclusive lock held. This guarantee us
-           there is no other thread can save into the same file
-           simultaneously. */
-        fp = NULL;
-        /* Construct destination file name. Do not allow paths to have
-           slashes. */
-        if ((s = strrchr(fname, '/')) == NULL &&
-            (s = strrchr(fname, '\\')) == NULL) {
-            s = fname;
-        }
-
-        /* Open file in binary mode. TODO: set an exclusive lock. */
-        snprintf(path, sizeof(path), "%s/%s", destination_dir, s);
-        if ((fp = fopen(path, "wb")) == NULL) {
-            break;
-        }
-
-        /* Read POST data, write into file until boundary is found. */
-        eof = n = 0;
-        do {
-            len += n;
-            for (i = 0; i < len - bl; i++) {
-                if (!memcmp(&buf[i], "\r\n--", 4) &&
-                    !memcmp(&buf[i + 4], boundary, boundary_len)) {
-                    /* Found boundary, that's the end of file data. */
-                    fwrite(buf, 1, i, fp);
-                    eof = 1;
-                    memmove(buf, &buf[i + bl], len - (i + bl));
-                    len -= i + bl;
-                    break;
-                }
-            }
-            if (!eof && len > bl) {
-                fwrite(buf, 1, len - bl, fp);
-                memmove(buf, &buf[len - bl], bl);
-                len = bl;
-            }
-        } while (!eof && (n = mg_read(conn, buf + len, sizeof(buf) - len)) > 0);
-        fclose(fp);
-        if (eof) {
-            num_uploaded_files++;
-            if (conn->ctx->callbacks.upload != NULL) {
-                conn->ctx->callbacks.upload(conn, path);
-            }
-        }
-    }
-
-    return num_uploaded_files;
-}
-
-static int is_put_or_delete_request(const struct mg_connection *conn)
-{
-    const char *s = conn->request_info.request_method;
-    return s != NULL && (!strcmp(s, "PUT") ||
-                         !strcmp(s, "DELETE") ||
-                         !strcmp(s, "MKCOL"));
-}
-
-static int get_first_ssl_listener_index(const struct mg_context *ctx)
-{
-    int i, idx = -1;
-    for (i = 0; idx == -1 && i < ctx->num_listening_sockets; i++) {
-        idx = ctx->listening_sockets[i].is_ssl ? i : -1;
-    }
-    return idx;
-}
-
-static void redirect_to_https_port(struct mg_connection *conn, int ssl_index)
-{
-    char host[1025];
-    const char *host_header;
-    size_t hostlen;
-
-    host_header = mg_get_header(conn, "Host");
-    hostlen = sizeof(host);
-    if (host_header != NULL) {
-        char *pos;
-
-        strncpy(host, host_header, hostlen);
-        host[hostlen - 1] = '\0';
-        pos = strchr(host, ':');
-        if (pos != NULL) {
-            *pos = '\0';
-        }
-    } else {
-        /* Cannot get host from the Host: header.
-           Fallback to our IP address. */
-        sockaddr_to_string(host, hostlen, &conn->client.lsa);
-    }
-
-    mg_printf(conn, "HTTP/1.1 302 Found\r\nLocation: https://%s:%d%s\r\n\r\n",
-              host, (int) ntohs(conn->ctx->listening_sockets[ssl_index].
-                                lsa.sin.sin_port), conn->request_info.uri);
-}
-
-
-void mg_set_request_handler(struct mg_context *ctx, const char *uri, mg_request_handler handler, void *cbdata)
-{
-    struct mg_request_handler_info *tmp_rh, *lastref = 0;
-    size_t urilen = strlen(uri);
-
-    /* first see it the uri exists */
-    for (tmp_rh = ctx->request_handlers;
-         tmp_rh != NULL && strcmp(uri, tmp_rh->uri);
-         lastref = tmp_rh, tmp_rh = tmp_rh->next) {
-        /* first try for an exact match */
-        if (urilen == tmp_rh->uri_len && !strcmp(tmp_rh->uri,uri)) {
-            /* already there... */
-
-            if (handler != NULL) {
-                /* change this entry */
-                tmp_rh->handler = handler;
-                tmp_rh->cbdata = cbdata;
-            } else {
-                /* remove this entry */
-                if (lastref != NULL)
-                    lastref->next = tmp_rh->next;
-                else
-                    ctx->request_handlers = tmp_rh->next;
-                free(tmp_rh->uri);
-                free(tmp_rh);
-            }
-            return;
-        }
-
-        /* next try for a partial match, we will accept uri/something */
-        if (tmp_rh->uri_len < urilen
-            && uri[tmp_rh->uri_len] == '/'
-            && memcmp(tmp_rh->uri, uri, tmp_rh->uri_len) == 0) {
-            /* if there is a partical match this new entry MUST go BEFORE
-               the current position otherwise it will never be matched. */
-            break;
-        }
-
-    }
-
-    if (handler == NULL) {
-        /* no handler to set, this was a remove request */
-        return;
-    }
-
-    tmp_rh = (struct mg_request_handler_info *)malloc(sizeof(struct mg_request_handler_info));
-    if (tmp_rh == NULL) {
-        mg_cry(fc(ctx), "%s", "Cannot create new request handler struct, OOM");
-        return;
-    }
-    tmp_rh->uri = mg_strdup(uri);
-    tmp_rh->uri_len = strlen(uri);
-    tmp_rh->handler = handler;
-    tmp_rh->cbdata = cbdata;
-
-    if (lastref == NULL) {
-        tmp_rh->next = ctx->request_handlers;
-        ctx->request_handlers = tmp_rh;
-    } else {
-        tmp_rh->next = lastref->next;
-        lastref->next = tmp_rh;
-    }
-
-}
-
-static int use_request_handler(struct mg_connection *conn)
-{
-    struct mg_request_info *request_info = mg_get_request_info(conn);
-    const char *uri = request_info->uri;
-    size_t urilen = strlen(uri);
-    struct mg_request_handler_info *tmp_rh = conn->ctx->request_handlers;
-
-    for (; tmp_rh != NULL; tmp_rh = tmp_rh->next) {
-
-        /* first try for an exact match */
-        if (urilen == tmp_rh->uri_len && !strcmp(tmp_rh->uri,uri)) {
-            return tmp_rh->handler(conn, tmp_rh->cbdata);
-        }
-
-        /* next try for a partial match */
-        /* we will accept uri/something */
-        if (tmp_rh->uri_len < urilen
-            && uri[tmp_rh->uri_len] == '/'
-            && memcmp(tmp_rh->uri, uri, tmp_rh->uri_len) == 0) {
-
-            return tmp_rh->handler(conn, tmp_rh->cbdata);
-        }
-
-    }
-
-    return 0; /* none found */
-}
-
-/* This is the heart of the Civetweb's logic.
-   This function is called when the request is read, parsed and validated,
-   and Civetweb must decide what action to take: serve a file, or
-   a directory, or call embedded function, etcetera. */
-static void handle_request(struct mg_connection *conn)
-{
-    struct mg_request_info *ri = &conn->request_info;
-    char path[PATH_MAX];
-    int uri_len, ssl_index;
-    struct file file = STRUCT_FILE_INITIALIZER;
-
-    if ((conn->request_info.query_string = strchr(ri->uri, '?')) != NULL) {
-        * ((char *) conn->request_info.query_string++) = '\0';
-    }
-    uri_len = (int) strlen(ri->uri);
-    mg_url_decode(ri->uri, uri_len, (char *) ri->uri, uri_len + 1, 0);
-    remove_double_dots_and_double_slashes((char *) ri->uri);
-    path[0] = '\0';
-    convert_uri_to_file_name(conn, path, sizeof(path), &file);
-    conn->throttle = set_throttle(conn->ctx->config[THROTTLE],
-                                  get_remote_ip(conn), ri->uri);
-
-    DEBUG_TRACE(("%s", ri->uri));
-    /* Perform redirect and auth checks before calling begin_request() handler.
-       Otherwise, begin_request() would need to perform auth checks and
-       redirects. */
-    if (!conn->client.is_ssl && conn->client.ssl_redir &&
-        (ssl_index = get_first_ssl_listener_index(conn->ctx)) > -1) {
-        redirect_to_https_port(conn, ssl_index);
-    } else if (!is_put_or_delete_request(conn) &&
-               !check_authorization(conn, path)) {
-        send_authorization_request(conn);
-    } else if (conn->ctx->callbacks.begin_request != NULL &&
-               conn->ctx->callbacks.begin_request(conn)) {
-        /* Do nothing, callback has served the request */
-    } else if (conn->ctx->request_handlers != NULL &&
-               use_request_handler(conn)) {
-        /* Do nothing, callback has served the request */
-#if defined(USE_WEBSOCKET)
-    } else if (is_websocket_request(conn)) {
-        handle_websocket_request(conn);
-#endif
-    } else if (!strcmp(ri->request_method, "OPTIONS")) {
-        send_options(conn);
-    } else if (conn->ctx->config[DOCUMENT_ROOT] == NULL) {
-        send_http_error(conn, 404, "Not Found", "Not Found");
-    } else if (is_put_or_delete_request(conn) &&
-               (is_authorized_for_put(conn) != 1)) {
-        send_authorization_request(conn);
-    } else if (!strcmp(ri->request_method, "PUT")) {
-        put_file(conn, path);
-    } else if (!strcmp(ri->request_method, "MKCOL")) {
-        mkcol(conn, path);
-    } else if (!strcmp(ri->request_method, "DELETE")) {
-        struct de de;
-        memset(&de.file, 0, sizeof(de.file));
-        if(!mg_stat(conn, path, &de.file)) {
-            send_http_error(conn, 404, "Not Found", "%s", "File not found");
-        } else {
-            if(de.file.modification_time) {
-                if(de.file.is_directory) {
-                    remove_directory(conn, path);
-                    send_http_error(conn, 204, "No Content", "%s", "");
-                } else if (mg_remove(path) == 0) {
-                    send_http_error(conn, 204, "No Content", "%s", "");
-                } else {
-                    send_http_error(conn, 423, "Locked", "remove(%s): %s", path,
-                                    strerror(ERRNO));
-                }
-            } else {
-                send_http_error(conn, 500, http_500_error, "remove(%s): %s", path,
-                                strerror(ERRNO));
-            }
-        }
-    } else if ((file.membuf == NULL && file.modification_time == (time_t) 0) ||
-               must_hide_file(conn, path)) {
-        send_http_error(conn, 404, "Not Found", "%s", "File not found");
-    } else if (file.is_directory && ri->uri[uri_len - 1] != '/') {
-        mg_printf(conn, "HTTP/1.1 301 Moved Permanently\r\n"
-                  "Location: %s/\r\n\r\n", ri->uri);
-    } else if (!strcmp(ri->request_method, "PROPFIND")) {
-        handle_propfind(conn, path, &file);
-    } else if (file.is_directory &&
-               !substitute_index_file(conn, path, sizeof(path), &file)) {
-        if (!mg_strcasecmp(conn->ctx->config[ENABLE_DIRECTORY_LISTING], "yes")) {
-            handle_directory_request(conn, path);
-        } else {
-            send_http_error(conn, 403, "Directory Listing Denied",
-                            "Directory listing denied");
-        }
-#ifdef USE_LUA
-    } else if (match_prefix("**.lp$", 6, path) > 0) {
-        handle_lsp_request(conn, path, &file, NULL);
-#endif
-#if !defined(NO_CGI)
-    } else if (match_prefix(conn->ctx->config[CGI_EXTENSIONS],
-                            (int)strlen(conn->ctx->config[CGI_EXTENSIONS]),
-                            path) > 0) {
-        if (strcmp(ri->request_method, "POST") &&
-            strcmp(ri->request_method, "HEAD") &&
-            strcmp(ri->request_method, "GET")) {
-            send_http_error(conn, 501, "Not Implemented",
-                            "Method %s is not implemented", ri->request_method);
-        } else {
-            handle_cgi_request(conn, path);
-        }
-#endif /* !NO_CGI */
-    } else if (match_prefix(conn->ctx->config[SSI_EXTENSIONS],
-                            (int)strlen(conn->ctx->config[SSI_EXTENSIONS]),
-                            path) > 0) {
-        handle_ssi_file_request(conn, path);
-    } else if (is_not_modified(conn, &file)) {
-        send_http_error(conn, 304, "Not Modified", "%s", "");
-    } else {
-        handle_file_request(conn, path, &file);
-    }
-}
-
-static void close_all_listening_sockets(struct mg_context *ctx)
-{
-    int i;
-    for (i = 0; i < ctx->num_listening_sockets; i++) {
-        closesocket(ctx->listening_sockets[i].sock);
-    }
-    free(ctx->listening_sockets);
-}
-
-static int is_valid_port(unsigned int port)
-{
-    return port < 0xffff;
-}
-
-/* Valid listening port specification is: [ip_address:]port[s]
-   Examples: 80, 443s, 127.0.0.1:3128, 1.2.3.4:8080s
-   TODO(lsm): add parsing of the IPv6 address */
-static int parse_port_string(const struct vec *vec, struct socket *so)
-{
-    unsigned int a, b, c, d, ch, len, port;
-#if defined(USE_IPV6)
-    char buf[100];
-#endif
-
-    /* MacOS needs that. If we do not zero it, subsequent bind() will fail.
-       Also, all-zeroes in the socket address means binding to all addresses
-       for both IPv4 and IPv6 (INADDR_ANY and IN6ADDR_ANY_INIT). */
-    memset(so, 0, sizeof(*so));
-    so->lsa.sin.sin_family = AF_INET;
-
-    if (sscanf(vec->ptr, "%u.%u.%u.%u:%u%n", &a, &b, &c, &d, &port, &len) == 5) {
-        /* Bind to a specific IPv4 address, e.g. 192.168.1.5:8080 */
-        so->lsa.sin.sin_addr.s_addr = htonl((a << 24) | (b << 16) | (c << 8) | d);
-        so->lsa.sin.sin_port = htons((uint16_t) port);
-#if defined(USE_IPV6)
-
-    } else if (sscanf(vec->ptr, "[%49[^]]]:%d%n", buf, &port, &len) == 2 &&
-               inet_pton(AF_INET6, buf, &so->lsa.sin6.sin6_addr)) {
-        /* IPv6 address, e.g. [3ffe:2a00:100:7031::1]:8080 */
-        so->lsa.sin6.sin6_family = AF_INET6;
-        so->lsa.sin6.sin6_port = htons((uint16_t) port);
-#endif
-    } else if (sscanf(vec->ptr, "%u%n", &port, &len) == 1) {
-        /* If only port is specified, bind to IPv4, INADDR_ANY */
-        so->lsa.sin.sin_port = htons((uint16_t) port);
-    } else {
-        port = len = 0;   /* Parsing failure. Make port invalid. */
-    }
-
-    ch = vec->ptr[len];  /* Next character after the port number */
-    so->is_ssl = ch == 's';
-    so->ssl_redir = ch == 'r';
-
-    /* Make sure the port is valid and vector ends with 's', 'r' or ',' */
-    return is_valid_port(port) &&
-           (ch == '\0' || ch == 's' || ch == 'r' || ch == ',');
-}
-
-static int set_ports_option(struct mg_context *ctx)
-{
-    const char *list = ctx->config[LISTENING_PORTS];
-    int on = 1, success = 1;
-#if defined(USE_IPV6)
-    int off = 0;
-#endif
-    struct vec vec;
-    struct socket so, *ptr;
-
-    while (success && (list = next_option(list, &vec, NULL)) != NULL) {
-        if (!parse_port_string(&vec, &so)) {
-            mg_cry(fc(ctx), "%s: %.*s: invalid port spec. Expecting list of: %s",
-                   __func__, (int) vec.len, vec.ptr, "[IP_ADDRESS:]PORT[s|r]");
-            success = 0;
-        } else if (so.is_ssl && ctx->ssl_ctx == NULL) {
-            mg_cry(fc(ctx), "Cannot add SSL socket, is -ssl_certificate option set?");
-            success = 0;
-        } else if ((so.sock = socket(so.lsa.sa.sa_family, SOCK_STREAM, 6)) ==
-                   INVALID_SOCKET ||
-                   /* On Windows, SO_REUSEADDR is recommended only for
-                      broadcast UDP sockets */
-                   setsockopt(so.sock, SOL_SOCKET, SO_REUSEADDR,
-                              (void *) &on, sizeof(on)) != 0 ||
-#if defined(USE_IPV6)
-                   (so.lsa.sa.sa_family == AF_INET6 &&
-                    setsockopt(so.sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *) &off,
-                               sizeof(off)) != 0) ||
-#endif
-                   bind(so.sock, &so.lsa.sa, so.lsa.sa.sa_family == AF_INET ?
-                        sizeof(so.lsa.sin) : sizeof(so.lsa)) != 0 ||
-                   listen(so.sock, SOMAXCONN) != 0) {
-            mg_cry(fc(ctx), "%s: cannot bind to %.*s: %d (%s)", __func__,
-                   (int) vec.len, vec.ptr, ERRNO, strerror(errno));
-            if (so.sock != INVALID_SOCKET) {
-                closesocket(so.sock);
-            }
-            success = 0;
-        } else if ((ptr = (struct socket *) realloc(ctx->listening_sockets,
-                          (ctx->num_listening_sockets + 1) *
-                          sizeof(ctx->listening_sockets[0]))) == NULL) {
-            closesocket(so.sock);
-            success = 0;
-        } else {
-            set_close_on_exec(so.sock, fc(ctx));
-            ctx->listening_sockets = ptr;
-            ctx->listening_sockets[ctx->num_listening_sockets] = so;
-            ctx->num_listening_sockets++;
-        }
-    }
-
-    if (!success) {
-        close_all_listening_sockets(ctx);
-    }
-
-    return success;
-}
-
-static void log_header(const struct mg_connection *conn, const char *header,
-                       FILE *fp)
-{
-    const char *header_value;
-
-    if ((header_value = mg_get_header(conn, header)) == NULL) {
-        (void) fprintf(fp, "%s", " -");
-    } else {
-        (void) fprintf(fp, " \"%s\"", header_value);
-    }
-}
-
-static void log_access(const struct mg_connection *conn)
-{
-    const struct mg_request_info *ri;
-    FILE *fp;
-    char date[64], src_addr[IP_ADDR_STR_LEN];
-    struct tm *tm;
-
-    fp = conn->ctx->config[ACCESS_LOG_FILE] == NULL ?  NULL :
-         fopen(conn->ctx->config[ACCESS_LOG_FILE], "a+");
-
-    if (fp == NULL)
-        return;
-
-    tm = localtime(&conn->birth_time);
-    if (tm != NULL) {
-        strftime(date, sizeof(date), "%d/%b/%Y:%H:%M:%S %z", tm);
-    } else {
-        strncpy(date, "01/Jan/1970:00:00:00 +0000", sizeof(date));
-        date[sizeof(date) - 1] = '\0';
-    }
-
-    ri = &conn->request_info;
-    flockfile(fp);
-
-    sockaddr_to_string(src_addr, sizeof(src_addr), &conn->client.rsa);
-    fprintf(fp, "%s - %s [%s] \"%s %s HTTP/%s\" %d %" INT64_FMT,
-            src_addr, ri->remote_user == NULL ? "-" : ri->remote_user, date,
-            ri->request_method ? ri->request_method : "-",
-            ri->uri ? ri->uri : "-", ri->http_version,
-            conn->status_code, conn->num_bytes_sent);
-    log_header(conn, "Referer", fp);
-    log_header(conn, "User-Agent", fp);
-    fputc('\n', fp);
-    fflush(fp);
-
-    funlockfile(fp);
-    fclose(fp);
-}
-
-/* Verify given socket address against the ACL.
-   Return -1 if ACL is malformed, 0 if address is disallowed, 1 if allowed. */
-static int check_acl(struct mg_context *ctx, uint32_t remote_ip)
-{
-    int allowed, flag;
-    uint32_t net, mask;
-    struct vec vec;
-    const char *list = ctx->config[ACCESS_CONTROL_LIST];
-
-    /* If any ACL is set, deny by default */
-    allowed = list == NULL ? '+' : '-';
-
-    while ((list = next_option(list, &vec, NULL)) != NULL) {
-        flag = vec.ptr[0];
-        if ((flag != '+' && flag != '-') ||
-            parse_net(&vec.ptr[1], &net, &mask) == 0) {
-            mg_cry(fc(ctx), "%s: subnet must be [+|-]x.x.x.x[/x]", __func__);
-            return -1;
-        }
-
-        if (net == (remote_ip & mask)) {
-            allowed = flag;
-        }
-    }
-
-    return allowed == '+';
-}
-
-#if !defined(_WIN32)
-static int set_uid_option(struct mg_context *ctx)
-{
-    struct passwd *pw;
-    const char *uid = ctx->config[RUN_AS_USER];
-    int success = 0;
-
-    if (uid == NULL) {
-        success = 1;
-    } else {
-        if ((pw = getpwnam(uid)) == NULL) {
-            mg_cry(fc(ctx), "%s: unknown user [%s]", __func__, uid);
-        } else if (setgid(pw->pw_gid) == -1) {
-            mg_cry(fc(ctx), "%s: setgid(%s): %s", __func__, uid, strerror(errno));
-        } else if (setuid(pw->pw_uid) == -1) {
-            mg_cry(fc(ctx), "%s: setuid(%s): %s", __func__, uid, strerror(errno));
-        } else {
-            success = 1;
-        }
-    }
-
-    return success;
-}
-#endif /* !_WIN32 */
-
-#if !defined(NO_SSL)
-static pthread_mutex_t *ssl_mutexes;
-
-static int sslize(struct mg_connection *conn, SSL_CTX *s, int (*func)(SSL *))
-{
-    return (conn->ssl = SSL_new(s)) != NULL &&
-           SSL_set_fd(conn->ssl, conn->client.sock) == 1 &&
-           func(conn->ssl) == 1;
-}
-
-/* Return OpenSSL error message */
-static const char *ssl_error(void)
-{
-    unsigned long err;
-    err = ERR_get_error();
-    return err == 0 ? "" : ERR_error_string(err, NULL);
-}
-
-static void ssl_locking_callback(int mode, int mutex_num, const char *file,
-                                 int line)
-{
-    (void) line;
-    (void) file;
-
-    if (mode & 1) {  /* 1 is CRYPTO_LOCK */
-        (void) pthread_mutex_lock(&ssl_mutexes[mutex_num]);
-    } else {
-        (void) pthread_mutex_unlock(&ssl_mutexes[mutex_num]);
-    }
-}
-
-static unsigned long ssl_id_callback(void)
-{
-    return (unsigned long) pthread_self();
-}
-
-#if !defined(NO_SSL_DL)
-static void *load_dll(struct mg_context *ctx, const char *dll_name,
-                      struct ssl_func *sw)
-{
-    union {
-        void *p;
-        void (*fp)(void);
-    } u;
-    void  *dll_handle;
-    struct ssl_func *fp;
-
-    if ((dll_handle = dlopen(dll_name, RTLD_LAZY)) == NULL) {
-        mg_cry(fc(ctx), "%s: cannot load %s", __func__, dll_name);
-        return NULL;
-    }
-
-    for (fp = sw; fp->name != NULL; fp++) {
-#ifdef _WIN32
-        /* GetProcAddress() returns pointer to function */
-        u.fp = (void (*)(void)) dlsym(dll_handle, fp->name);
-#else
-        /* dlsym() on UNIX returns void *. ISO C forbids casts of data
-           pointers to function pointers. We need to use a union to make a
-           cast. */
-        u.p = dlsym(dll_handle, fp->name);
-#endif /* _WIN32 */
-        if (u.fp == NULL) {
-            mg_cry(fc(ctx), "%s: %s: cannot find %s", __func__, dll_name, fp->name);
-            dlclose(dll_handle);
-            return NULL;
-        } else {
-            fp->ptr = u.fp;
-        }
-    }
-
-    return dll_handle;
-}
-#endif /* NO_SSL_DL */
-
-/* Dynamically load SSL library. Set up ctx->ssl_ctx pointer. */
-static int set_ssl_option(struct mg_context *ctx)
-{
-    int i, size;
-    const char *pem;
-
-    /* If PEM file is not specified and the init_ssl callback
-       is not specified, skip SSL initialization. */
-    if ((pem = ctx->config[SSL_CERTIFICATE]) == NULL &&
-        ctx->callbacks.init_ssl == NULL) {
-        return 1;
-    }
-
-#if !defined(NO_SSL_DL)
-    ctx->ssllib_dll_handle = load_dll(ctx, SSL_LIB, ssl_sw);
-    ctx->cryptolib_dll_handle = load_dll(ctx, CRYPTO_LIB, crypto_sw);
-    if (!ctx->ssllib_dll_handle || !ctx->cryptolib_dll_handle) {
-        return 0;
-    }
-#endif /* NO_SSL_DL */
-
-    /* Initialize SSL library */
-    SSL_library_init();
-    SSL_load_error_strings();
-
-    if ((ctx->ssl_ctx = SSL_CTX_new(SSLv23_server_method())) == NULL) {
-        mg_cry(fc(ctx), "SSL_CTX_new (server) error: %s", ssl_error());
-        return 0;
-    }
-
-    /* If user callback returned non-NULL, that means that user callback has
-       set up certificate itself. In this case, skip sertificate setting. */
-    if ((ctx->callbacks.init_ssl == NULL ||
-         !ctx->callbacks.init_ssl(ctx->ssl_ctx, ctx->user_data)) &&
-        (SSL_CTX_use_certificate_file(ctx->ssl_ctx, pem, 1) == 0 ||
-         SSL_CTX_use_PrivateKey_file(ctx->ssl_ctx, pem, 1) == 0)) {
-        mg_cry(fc(ctx), "%s: cannot open %s: %s", __func__, pem, ssl_error());
-        return 0;
-    }
-
-    if (pem != NULL) {
-        (void) SSL_CTX_use_certificate_chain_file(ctx->ssl_ctx, pem);
-    }
-
-    /* Initialize locking callbacks, needed for thread safety.
-       http://www.openssl.org/support/faq.html#PROG1 */
-    size = sizeof(pthread_mutex_t) * CRYPTO_num_locks();
-    if ((ssl_mutexes = (pthread_mutex_t *) malloc((size_t)size)) == NULL) {
-        mg_cry(fc(ctx), "%s: cannot allocate mutexes: %s", __func__, ssl_error());
-        return 0;
-    }
-
-    for (i = 0; i < CRYPTO_num_locks(); i++) {
-        pthread_mutex_init(&ssl_mutexes[i], NULL);
-    }
-
-    CRYPTO_set_locking_callback(&ssl_locking_callback);
-    CRYPTO_set_id_callback(&ssl_id_callback);
-
-    return 1;
-}
-
-static void uninitialize_ssl(struct mg_context *ctx)
-{
-    int i;
-    if (ctx->ssl_ctx != NULL) {
-        CRYPTO_set_locking_callback(NULL);
-        for (i = 0; i < CRYPTO_num_locks(); i++) {
-            pthread_mutex_destroy(&ssl_mutexes[i]);
-        }
-        CRYPTO_set_locking_callback(NULL);
-        CRYPTO_set_id_callback(NULL);
-    }
-}
-#endif /* !NO_SSL */
-
-static int set_gpass_option(struct mg_context *ctx)
-{
-    struct file file = STRUCT_FILE_INITIALIZER;
-    const char *path = ctx->config[GLOBAL_PASSWORDS_FILE];
-    if (path != NULL && !mg_stat(fc(ctx), path, &file)) {
-        mg_cry(fc(ctx), "Cannot open %s: %s", path, strerror(ERRNO));
-        return 0;
-    }
-    return 1;
-}
-
-static int set_acl_option(struct mg_context *ctx)
-{
-    return check_acl(ctx, (uint32_t) 0x7f000001UL) != -1;
-}
-
-static void reset_per_request_attributes(struct mg_connection *conn)
-{
-    conn->path_info = NULL;
-    conn->num_bytes_sent = conn->consumed_content = 0;
-    conn->status_code = -1;
-    conn->must_close = conn->request_len = conn->throttle = 0;
-}
-
-static void close_socket_gracefully(struct mg_connection *conn)
-{
-#if defined(_WIN32)
-    char buf[MG_BUF_LEN];
-    int n;
-#endif
-    struct linger linger;
-
-    /* Set linger option to avoid socket hanging out after close. This prevent
-       ephemeral port exhaust problem under high QPS. */
-    linger.l_onoff = 1;
-    linger.l_linger = 1;
-    if (setsockopt(conn->client.sock, SOL_SOCKET, SO_LINGER,
-                   (char *) &linger, sizeof(linger)) != 0) {
-        mg_cry(conn, "%s: setsockopt(SOL_SOCKET SO_LINGER) failed: %s",
-               __func__, strerror(ERRNO));
-    }
-
-    /* Send FIN to the client */
-    shutdown(conn->client.sock, SHUT_WR);
-    set_non_blocking_mode(conn->client.sock);
-
-#if defined(_WIN32)
-    /* Read and discard pending incoming data. If we do not do that and close
-       the socket, the data in the send buffer may be discarded. This
-       behaviour is seen on Windows, when client keeps sending data
-       when server decides to close the connection; then when client
-       does recv() it gets no data back. */
-    do {
-        n = pull(NULL, conn, buf, sizeof(buf));
-    } while (n > 0);
-#endif
-
-    /* Now we know that our FIN is ACK-ed, safe to close */
-    closesocket(conn->client.sock);
-}
-
-static void close_connection(struct mg_connection *conn)
-{
-    /* call the connection_close callback if assigned */
-    if (conn->ctx->callbacks.connection_close != NULL)
-        conn->ctx->callbacks.connection_close(conn);
-
-    mg_lock(conn);
-
-    conn->must_close = 1;
-
-#ifndef NO_SSL
-    if (conn->ssl != NULL) {
-        /* Run SSL_shutdown twice to ensure completly close SSL connection */
-        SSL_shutdown(conn->ssl);
-        SSL_free(conn->ssl);
-        conn->ssl = NULL;
-    }
-#endif
-    if (conn->client.sock != INVALID_SOCKET) {
-        close_socket_gracefully(conn);
-        conn->client.sock = INVALID_SOCKET;
-    }
-
-    mg_unlock(conn);
-}
-
-void mg_close_connection(struct mg_connection *conn)
-{
-#ifndef NO_SSL
-    if (conn->client_ssl_ctx != NULL) {
-        SSL_CTX_free((SSL_CTX *) conn->client_ssl_ctx);
-    }
-#endif
-    close_connection(conn);
-    (void) pthread_mutex_destroy(&conn->mutex);
-    free(conn);
-}
-
-struct mg_connection *mg_connect(const char *host, int port, int use_ssl,
-                                 char *ebuf, size_t ebuf_len);
-
-struct mg_connection *mg_connect(const char *host, int port, int use_ssl,
-                                 char *ebuf, size_t ebuf_len)
-{
-    static struct mg_context fake_ctx;
-    struct mg_connection *conn = NULL;
-    SOCKET sock;
-
-    if ((sock = conn2(&fake_ctx, host, port, use_ssl, ebuf,
-                      ebuf_len)) == INVALID_SOCKET) {
-    } else if ((conn = (struct mg_connection *)
-                       calloc(1, sizeof(*conn) + MAX_REQUEST_SIZE)) == NULL) {
-        snprintf(ebuf, ebuf_len, "calloc(): %s", strerror(ERRNO));
-        closesocket(sock);
-#ifndef NO_SSL
-    } else if (use_ssl && (conn->client_ssl_ctx =
-                               SSL_CTX_new(SSLv23_client_method())) == NULL) {
-        snprintf(ebuf, ebuf_len, "SSL_CTX_new error");
-        closesocket(sock);
-        free(conn);
-        conn = NULL;
-#endif /* NO_SSL */
-    } else {
-        socklen_t len = sizeof(struct sockaddr);
-        conn->buf_size = MAX_REQUEST_SIZE;
-        conn->buf = (char *) (conn + 1);
-        conn->ctx = &fake_ctx;
-        conn->client.sock = sock;
-        if (getsockname(sock, &conn->client.rsa.sa, &len) != 0) {
-            mg_cry(conn, "%s: getsockname() failed: %s",
-                   __func__, strerror(ERRNO));
-        }
-        conn->client.is_ssl = use_ssl;
-        (void) pthread_mutex_init(&conn->mutex, NULL);
-#ifndef NO_SSL
-        if (use_ssl) {
-            /* SSL_CTX_set_verify call is needed to switch off server
-               certificate checking, which is off by default in OpenSSL and on
-               in yaSSL. */
-            SSL_CTX_set_verify(conn->client_ssl_ctx, 0, 0);
-            sslize(conn, conn->client_ssl_ctx, SSL_connect);
-        }
-#endif
-    }
-
-    return conn;
-}
-
-static int is_valid_uri(const char *uri)
-{
-    /* Conform to
-       http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.2
-       URI can be an asterisk (*) or should start with slash. */
-    return uri[0] == '/' || (uri[0] == '*' && uri[1] == '\0');
-}
-
-static int getreq(struct mg_connection *conn, char *ebuf, size_t ebuf_len)
-{
-    const char *cl;
-
-    ebuf[0] = '\0';
-    reset_per_request_attributes(conn);
-    conn->request_len = read_request(NULL, conn, conn->buf, conn->buf_size,
-                                     &conn->data_len);
-    assert(conn->request_len < 0 || conn->data_len >= conn->request_len);
-
-    if (conn->request_len == 0 && conn->data_len == conn->buf_size) {
-        snprintf(ebuf, ebuf_len, "%s", "Request Too Large");
-    } else if (conn->request_len <= 0) {
-        snprintf(ebuf, ebuf_len, "%s", "Client closed connection");
-    } else if (parse_http_message(conn->buf, conn->buf_size,
-                                  &conn->request_info) <= 0) {
-        snprintf(ebuf, ebuf_len, "Bad request: [%.*s]", conn->data_len, conn->buf);
-    } else {
-        /* Request is valid */
-        if ((cl = get_header(&conn->request_info, "Content-Length")) != NULL) {
-            conn->content_len = strtoll(cl, NULL, 10);
-        } else if (!mg_strcasecmp(conn->request_info.request_method, "POST") ||
-                   !mg_strcasecmp(conn->request_info.request_method, "PUT")) {
-            conn->content_len = -1;
-        } else {
-            conn->content_len = 0;
-        }
-        conn->birth_time = time(NULL);
-    }
-    return ebuf[0] == '\0';
-}
-
-struct mg_connection *mg_download(const char *host, int port, int use_ssl,
-                                  char *ebuf, size_t ebuf_len,
-                                  const char *fmt, ...)
-{
-    struct mg_connection *conn;
-    va_list ap;
-
-    va_start(ap, fmt);
-    ebuf[0] = '\0';
-    if ((conn = mg_connect(host, port, use_ssl, ebuf, ebuf_len)) == NULL) {
-    } else if (mg_vprintf(conn, fmt, ap) <= 0) {
-        snprintf(ebuf, ebuf_len, "%s", "Error sending request");
-    } else {
-        getreq(conn, ebuf, ebuf_len);
-    }
-    if (ebuf[0] != '\0' && conn != NULL) {
-        mg_close_connection(conn);
-        conn = NULL;
-    }
-    va_end(ap);
-
-    return conn;
-}
-
-static void process_new_connection(struct mg_connection *conn)
-{
-    struct mg_request_info *ri = &conn->request_info;
-    int keep_alive_enabled, keep_alive, discard_len;
-    char ebuf[100];
-
-    keep_alive_enabled = !strcmp(conn->ctx->config[ENABLE_KEEP_ALIVE], "yes");
-    keep_alive = 0;
-
-    /* Important: on new connection, reset the receiving buffer. Credit goes
-       to crule42. */
-    conn->data_len = 0;
-    do {
-        if (!getreq(conn, ebuf, sizeof(ebuf))) {
-            send_http_error(conn, 500, "Server Error", "%s", ebuf);
-            conn->must_close = 1;
-        } else if (!is_valid_uri(conn->request_info.uri)) {
-            snprintf(ebuf, sizeof(ebuf), "Invalid URI: [%s]", ri->uri);
-            send_http_error(conn, 400, "Bad Request", "%s", ebuf);
-        } else if (strcmp(ri->http_version, "1.0") &&
-                   strcmp(ri->http_version, "1.1")) {
-            snprintf(ebuf, sizeof(ebuf), "Bad HTTP version: [%s]", ri->http_version);
-            send_http_error(conn, 505, "Bad HTTP version", "%s", ebuf);
-        }
-
-        if (ebuf[0] == '\0') {
-            handle_request(conn);
-            if (conn->ctx->callbacks.end_request != NULL) {
-                conn->ctx->callbacks.end_request(conn, conn->status_code);
-            }
-            log_access(conn);
-        }
-        if (ri->remote_user != NULL) {
-            free((void *) ri->remote_user);
-            /* Important! When having connections with and without auth
-               would cause double free and then crash */
-            ri->remote_user = NULL;
-        }
-
-        /* NOTE(lsm): order is important here. should_keep_alive() call is
-           using parsed request, which will be invalid after memmove's below.
-           Therefore, memorize should_keep_alive() result now for later use
-           in loop exit condition. */
-        keep_alive = conn->ctx->stop_flag == 0 && keep_alive_enabled &&
-                     conn->content_len >= 0 && should_keep_alive(conn);
-
-        /* Discard all buffered data for this request */
-        discard_len = conn->content_len >= 0 && conn->request_len > 0 &&
-                      conn->request_len + conn->content_len < (int64_t) conn->data_len ?
-                      (int) (conn->request_len + conn->content_len) : conn->data_len;
-        assert(discard_len >= 0);
-        memmove(conn->buf, conn->buf + discard_len, conn->data_len - discard_len);
-        conn->data_len -= discard_len;
-        assert(conn->data_len >= 0);
-        assert(conn->data_len <= conn->buf_size);
-    } while (keep_alive);
-}
-
-/* Worker threads take accepted socket from the queue */
-static int consume_socket(struct mg_context *ctx, struct socket *sp)
-{
-    (void) pthread_mutex_lock(&ctx->mutex);
-    DEBUG_TRACE(("going idle"));
-
-    /* If the queue is empty, wait. We're idle at this point. */
-    while (ctx->sq_head == ctx->sq_tail && ctx->stop_flag == 0) {
-        pthread_cond_wait(&ctx->sq_full, &ctx->mutex);
-    }
-
-    /* If we're stopping, sq_head may be equal to sq_tail. */
-    if (ctx->sq_head > ctx->sq_tail) {
-        /* Copy socket from the queue and increment tail */
-        *sp = ctx->queue[ctx->sq_tail % ARRAY_SIZE(ctx->queue)];
-        ctx->sq_tail++;
-        DEBUG_TRACE(("grabbed socket %d, going busy", sp->sock));
-
-        /* Wrap pointers if needed */
-        while (ctx->sq_tail > (int) ARRAY_SIZE(ctx->queue)) {
-            ctx->sq_tail -= ARRAY_SIZE(ctx->queue);
-            ctx->sq_head -= ARRAY_SIZE(ctx->queue);
-        }
-    }
-
-    (void) pthread_cond_signal(&ctx->sq_empty);
-    (void) pthread_mutex_unlock(&ctx->mutex);
-
-    return !ctx->stop_flag;
-}
-
-static void *worker_thread_run(void *thread_func_param)
-{
-    struct mg_context *ctx = (struct mg_context *) thread_func_param;
-    struct mg_connection *conn;
-    struct mg_workerTLS tls;
-
-    tls.is_master = 0;
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-    tls.pthread_cond_helper_mutex = CreateEvent(NULL, FALSE, FALSE, NULL);
-#endif
-
-    conn = (struct mg_connection *) calloc(1, sizeof(*conn) + MAX_REQUEST_SIZE);
-    if (conn == NULL) {
-        mg_cry(fc(ctx), "%s", "Cannot create new connection struct, OOM");
-    } else {
-        pthread_setspecific(sTlsKey, &tls);
-        conn->buf_size = MAX_REQUEST_SIZE;
-        conn->buf = (char *) (conn + 1);
-        conn->ctx = ctx;
-        conn->request_info.user_data = ctx->user_data;
-        /* Allocate a mutex for this connection to allow communication both
-           within the request handler and from elsewhere in the application */
-        (void) pthread_mutex_init(&conn->mutex, NULL);
-
-        /* Call consume_socket() even when ctx->stop_flag > 0, to let it
-           signal sq_empty condvar to wake up the master waiting in
-           produce_socket() */
-        while (consume_socket(ctx, &conn->client)) {
-            conn->birth_time = time(NULL);
-
-            /* Fill in IP, port info early so even if SSL setup below fails,
-               error handler would have the corresponding info.
-               Thanks to Johannes Winkelmann for the patch.
-               TODO(lsm): Fix IPv6 case */
-            conn->request_info.remote_port = ntohs(conn->client.rsa.sin.sin_port);
-            memcpy(&conn->request_info.remote_ip,
-                   &conn->client.rsa.sin.sin_addr.s_addr, 4);
-            conn->request_info.remote_ip = ntohl(conn->request_info.remote_ip);
-            conn->request_info.is_ssl = conn->client.is_ssl;
-
-            if (!conn->client.is_ssl
-#ifndef NO_SSL
-                || sslize(conn, conn->ctx->ssl_ctx, SSL_accept)
-#endif
-               ) {
-                process_new_connection(conn);
-            }
-
-            close_connection(conn);
-        }
-    }
-
-    /* Signal master that we're done with connection and exiting */
-    (void) pthread_mutex_lock(&ctx->mutex);
-    ctx->num_threads--;
-    (void) pthread_cond_signal(&ctx->cond);
-    assert(ctx->num_threads >= 0);
-    (void) pthread_mutex_unlock(&ctx->mutex);
-
-    pthread_setspecific(sTlsKey, 0);
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-    CloseHandle(tls.pthread_cond_helper_mutex);
-#endif
-    free(conn);
-
-    DEBUG_TRACE(("exiting"));
-    return NULL;
-}
-
-/* Threads have different return types on Windows and Unix. */
-
-#ifdef _WIN32
-static unsigned __stdcall worker_thread(void *thread_func_param)
-{
-    worker_thread_run(thread_func_param);
-    return 0;
-}
-#else
-static void *worker_thread(void *thread_func_param)
-{
-    worker_thread_run(thread_func_param);
-    return NULL;
-}
-#endif /* _WIN32 */
-
-/* Master thread adds accepted socket to a queue */
-static void produce_socket(struct mg_context *ctx, const struct socket *sp)
-{
-    (void) pthread_mutex_lock(&ctx->mutex);
-
-    /* If the queue is full, wait */
-    while (ctx->stop_flag == 0 &&
-           ctx->sq_head - ctx->sq_tail >= (int) ARRAY_SIZE(ctx->queue)) {
-        (void) pthread_cond_wait(&ctx->sq_empty, &ctx->mutex);
-    }
-
-    if (ctx->sq_head - ctx->sq_tail < (int) ARRAY_SIZE(ctx->queue)) {
-        /* Copy socket to the queue and increment head */
-        ctx->queue[ctx->sq_head % ARRAY_SIZE(ctx->queue)] = *sp;
-        ctx->sq_head++;
-        DEBUG_TRACE(("queued socket %d", sp->sock));
-    }
-
-    (void) pthread_cond_signal(&ctx->sq_full);
-    (void) pthread_mutex_unlock(&ctx->mutex);
-}
-
-static int set_sock_timeout(SOCKET sock, int milliseconds)
-{
-#ifdef _WIN32
-    DWORD t = milliseconds;
-#else
-    struct timeval t;
-    t.tv_sec = milliseconds / 1000;
-    t.tv_usec = (milliseconds * 1000) % 1000000;
-#endif
-    return setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *) &t, sizeof(t)) ||
-           setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, (void *) &t, sizeof(t));
-}
-
-static void accept_new_connection(const struct socket *listener,
-                                  struct mg_context *ctx)
-{
-    struct socket so;
-    char src_addr[IP_ADDR_STR_LEN];
-    socklen_t len = sizeof(so.rsa);
-    int on = 1;
-
-    if ((so.sock = accept(listener->sock, &so.rsa.sa, &len)) == INVALID_SOCKET) {
-    } else if (!check_acl(ctx, ntohl(* (uint32_t *) &so.rsa.sin.sin_addr))) {
-        sockaddr_to_string(src_addr, sizeof(src_addr), &so.rsa);
-        mg_cry(fc(ctx), "%s: %s is not allowed to connect", __func__, src_addr);
-        closesocket(so.sock);
-    } else {
-        /* Put so socket structure into the queue */
-        DEBUG_TRACE(("Accepted socket %d", (int) so.sock));
-        set_close_on_exec(so.sock, fc(ctx));
-        so.is_ssl = listener->is_ssl;
-        so.ssl_redir = listener->ssl_redir;
-        if (getsockname(so.sock, &so.lsa.sa, &len) != 0) {
-            mg_cry(fc(ctx), "%s: getsockname() failed: %s",
-                   __func__, strerror(ERRNO));
-        }
-        /* Set TCP keep-alive. This is needed because if HTTP-level keep-alive
-           is enabled, and client resets the connection, server won't get
-           TCP FIN or RST and will keep the connection open forever. With TCP
-           keep-alive, next keep-alive handshake will figure out that the
-           client is down and will close the server end.
-           Thanks to Igor Klopov who suggested the patch. */
-        if (setsockopt(so.sock, SOL_SOCKET, SO_KEEPALIVE, (void *) &on,
-                       sizeof(on)) != 0) {
-            mg_cry(fc(ctx),
-                   "%s: setsockopt(SOL_SOCKET SO_KEEPALIVE) failed: %s",
-                   __func__, strerror(ERRNO));
-        }
-        set_sock_timeout(so.sock, atoi(ctx->config[REQUEST_TIMEOUT]));
-        produce_socket(ctx, &so);
-    }
-}
-
-static void master_thread_run(void *thread_func_param)
-{
-    struct mg_context *ctx = (struct mg_context *) thread_func_param;
-    struct mg_workerTLS tls;
-    struct pollfd *pfd;
-    int i;
-    int workerthreadcount;
-
-    /* Increase priority of the master thread */
-#if defined(_WIN32)
-    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
-#elif defined(USE_MASTER_THREAD_PRIORITY)
-    int min_prio = sched_get_priority_min(SCHED_RR);
-    int max_prio = sched_get_priority_max(SCHED_RR);
-    if ((min_prio >=0) && (max_prio >= 0) &&
-        ((USE_MASTER_THREAD_PRIORITY) <= max_prio) &&
-        ((USE_MASTER_THREAD_PRIORITY) >= min_prio)
-       ) {
-        struct sched_param sched_param = {0};
-        sched_param.sched_priority = (USE_MASTER_THREAD_PRIORITY);
-        pthread_setschedparam(pthread_self(), SCHED_RR, &sched_param);
-    }
-#endif
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-    tls.pthread_cond_helper_mutex = CreateEvent(NULL, FALSE, FALSE, NULL);
-#endif
-    tls.is_master = 1;
-    pthread_setspecific(sTlsKey, &tls);
-
-    pfd = (struct pollfd *) calloc(ctx->num_listening_sockets, sizeof(pfd[0]));
-    while (pfd != NULL && ctx->stop_flag == 0) {
-        for (i = 0; i < ctx->num_listening_sockets; i++) {
-            pfd[i].fd = ctx->listening_sockets[i].sock;
-            pfd[i].events = POLLIN;
-        }
-
-        if (poll(pfd, ctx->num_listening_sockets, 200) > 0) {
-            for (i = 0; i < ctx->num_listening_sockets; i++) {
-                /* NOTE(lsm): on QNX, poll() returns POLLRDNORM after the
-                   successful poll, and POLLIN is defined as
-                   (POLLRDNORM | POLLRDBAND)
-                   Therefore, we're checking pfd[i].revents & POLLIN, not
-                   pfd[i].revents == POLLIN. */
-                if (ctx->stop_flag == 0 && (pfd[i].revents & POLLIN)) {
-                    accept_new_connection(&ctx->listening_sockets[i], ctx);
-                }
-            }
-        }
-    }
-    free(pfd);
-    DEBUG_TRACE(("stopping workers"));
-
-    /* Stop signal received: somebody called mg_stop. Quit. */
-    close_all_listening_sockets(ctx);
-
-    /* Wakeup workers that are waiting for connections to handle. */
-    pthread_cond_broadcast(&ctx->sq_full);
-
-    /* Wait until all threads finish */
-    (void) pthread_mutex_lock(&ctx->mutex);
-    while (ctx->num_threads > 0) {
-        (void) pthread_cond_wait(&ctx->cond, &ctx->mutex);
-    }
-    (void) pthread_mutex_unlock(&ctx->mutex);
-
-    /* Join all worker threads to avoid leaking threads. */
-    workerthreadcount = ctx->workerthreadcount;
-    for (i = 0; i < workerthreadcount; i++) {
-        mg_join_thread(ctx->workerthreadids[i]);
-    }
-
-    /* All threads exited, no sync is needed. Destroy mutex and condvars */
-    (void) pthread_mutex_destroy(&ctx->mutex);
-    (void) pthread_cond_destroy(&ctx->cond);
-    (void) pthread_cond_destroy(&ctx->sq_empty);
-    (void) pthread_cond_destroy(&ctx->sq_full);
-
-#if !defined(NO_SSL)
-    uninitialize_ssl(ctx);
-#endif
-    DEBUG_TRACE(("exiting"));
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-    CloseHandle(tls.pthread_cond_helper_mutex);
-#endif
-    pthread_setspecific(sTlsKey, 0);
-
-    /* Signal mg_stop() that we're done.
-       WARNING: This must be the very last thing this
-       thread does, as ctx becomes invalid after this line. */
-    ctx->stop_flag = 2;
-}
-
-/* Threads have different return types on Windows and Unix. */
-
-#ifdef _WIN32
-static unsigned __stdcall master_thread(void *thread_func_param)
-{
-    master_thread_run(thread_func_param);
-    return 0;
-}
-#else
-static void *master_thread(void *thread_func_param)
-{
-    master_thread_run(thread_func_param);
-    return NULL;
-}
-#endif /* _WIN32 */
-
-static void free_context(struct mg_context *ctx)
-{
-    int i;
-    struct mg_request_handler_info *tmp_rh;
-
-    if (ctx == NULL)
-        return;
-
-    /* Deallocate config parameters */
-    for (i = 0; i < NUM_OPTIONS; i++) {
-        if (ctx->config[i] != NULL)
-#ifdef WIN32
-#pragma warning(suppress: 6001)
-#endif
-            free(ctx->config[i]);
-    }
-
-    /* Deallocate request handlers */
-    while (ctx->request_handlers) {
-        tmp_rh = ctx->request_handlers;
-        ctx->request_handlers = tmp_rh->next;
-        free(tmp_rh->uri);
-        free(tmp_rh);
-    }
-
-#ifndef NO_SSL
-    /* Deallocate SSL context */
-    if (ctx->ssl_ctx != NULL) {
-        SSL_CTX_free(ctx->ssl_ctx);
-    }
-    if (ssl_mutexes != NULL) {
-        free(ssl_mutexes);
-        ssl_mutexes = NULL;
-    }
-#endif /* !NO_SSL */
-
-    /* Deallocate worker thread ID array */
-    if (ctx->workerthreadids != NULL) {
-        free(ctx->workerthreadids);
-    }
-
-    /* Deallocate the tls variable */
-    sTlsInit--;
-    if (sTlsInit==0) {
-        pthread_key_delete(sTlsKey);
-    }
-
-    /* Deallocate context itself */
-    free(ctx);
-}
-
-void mg_stop(struct mg_context *ctx)
-{
-    ctx->stop_flag = 1;
-
-    /* Wait until mg_fini() stops */
-    while (ctx->stop_flag != 2) {
-        (void) mg_sleep(10);
-    }
-    mg_join_thread(ctx->masterthreadid);
-    free_context(ctx);
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-    (void) WSACleanup();
-#endif /* _WIN32 && !__SYMBIAN32__ */
-}
-
-struct mg_context *mg_start(const struct mg_callbacks *callbacks,
-                            void *user_data,
-                            const char **options)
-{
-    struct mg_context *ctx;
-    const char *name, *value, *default_value;
-    int i;
-    int workerthreadcount;
-
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-    WSADATA data;
-    WSAStartup(MAKEWORD(2,2), &data);
-#pragma warning(suppress: 28125)
-    InitializeCriticalSection(&global_log_file_lock);
-#endif /* _WIN32 && !__SYMBIAN32__ */
-
-    /* Allocate context and initialize reasonable general case defaults.
-       TODO(lsm): do proper error handling here. */
-    if ((ctx = (struct mg_context *) calloc(1, sizeof(*ctx))) == NULL) {
-        return NULL;
-    }
-
-    if (sTlsInit==0) {
-        if (0 != pthread_key_create(&sTlsKey, NULL)) {
-            mg_cry(fc(ctx), "Cannot initialize thread local storage");
-            return NULL;
-        }
-        sTlsInit++;
-    }
-
-    ctx->callbacks = *callbacks;
-    ctx->user_data = user_data;
-    ctx->request_handlers = 0;
-
-    while (options && (name = *options++) != NULL) {
-        if ((i = get_option_index(name)) == -1) {
-            mg_cry(fc(ctx), "Invalid option: %s", name);
-            free_context(ctx);
-            return NULL;
-        } else if ((value = *options++) == NULL) {
-            mg_cry(fc(ctx), "%s: option value cannot be NULL", name);
-            free_context(ctx);
-            return NULL;
-        }
-        if (ctx->config[i] != NULL) {
-            mg_cry(fc(ctx), "warning: %s: duplicate option", name);
-            free(ctx->config[i]);
-        }
-        ctx->config[i] = mg_strdup(value);
-        DEBUG_TRACE(("[%s] -> [%s]", name, value));
-    }
-
-    /* Set default value if needed */
-    for (i = 0; config_options[i * 2] != NULL; i++) {
-        default_value = config_options[i * 2 + 1];
-        if (ctx->config[i] == NULL && default_value != NULL) {
-            ctx->config[i] = mg_strdup(default_value);
-        }
-    }
-
-    /* NOTE(lsm): order is important here. SSL certificates must
-       be initialized before listening ports. UID must be set last. */
-    if (!set_gpass_option(ctx) ||
-#if !defined(NO_SSL)
-        !set_ssl_option(ctx) ||
-#endif
-        !set_ports_option(ctx) ||
-#if !defined(_WIN32)
-        !set_uid_option(ctx) ||
-#endif
-        !set_acl_option(ctx)) {
-        free_context(ctx);
-        return NULL;
-    }
-
-#if !defined(_WIN32) && !defined(__SYMBIAN32__)
-    /* Ignore SIGPIPE signal, so if browser cancels the request, it
-       won't kill the whole process. */
-    (void) signal(SIGPIPE, SIG_IGN);
-#endif /* !_WIN32 && !__SYMBIAN32__ */
-
-    (void) pthread_mutex_init(&ctx->mutex, NULL);
-    (void) pthread_cond_init(&ctx->cond, NULL);
-    (void) pthread_cond_init(&ctx->sq_empty, NULL);
-    (void) pthread_cond_init(&ctx->sq_full, NULL);
-
-    workerthreadcount = atoi(ctx->config[NUM_THREADS]);
-
-    if (workerthreadcount > MAX_WORKER_THREADS) {
-        mg_cry(fc(ctx), "Too many worker threads");
-        free_context(ctx);
-        return NULL;
-    }
-
-    if (workerthreadcount > 0) {
-        ctx->workerthreadcount = workerthreadcount;
-        ctx->workerthreadids = calloc(workerthreadcount, sizeof(pthread_t));
-        if (ctx->workerthreadids == NULL) {
-            mg_cry(fc(ctx), "Not enough memory for worker thread ID array");
-            free_context(ctx);
-            return NULL;
-        }
-    }
-
-    /* Start master (listening) thread */
-    mg_start_thread_with_id(master_thread, ctx, &ctx->masterthreadid);
-
-    /* Start worker threads */
-    for (i = 0; i < workerthreadcount; i++) {
-        (void) pthread_mutex_lock(&ctx->mutex);
-        ctx->num_threads++;
-        (void) pthread_mutex_unlock(&ctx->mutex);
-        if (mg_start_thread_with_id(worker_thread, ctx,
-                                    &ctx->workerthreadids[i]) != 0) {
-            (void) pthread_mutex_lock(&ctx->mutex);
-            ctx->num_threads--;
-            (void) pthread_mutex_unlock(&ctx->mutex);
-            mg_cry(fc(ctx), "Cannot start worker thread: %ld", (long) ERRNO);
-        }
-    }
-
-    return ctx;
-}
diff --git a/libraries/embedded-webserver/src/HTTPManager.cpp b/libraries/embedded-webserver/src/HTTPManager.cpp
index 89712d825c..735300de7c 100755
--- a/libraries/embedded-webserver/src/HTTPManager.cpp
+++ b/libraries/embedded-webserver/src/HTTPManager.cpp
@@ -108,7 +108,7 @@ bool HTTPManager::handleHTTPRequest(HTTPConnection* connection, const QString& p
     return true;
 }
 
-HTTPManager::HTTPManager(quint16 port, const QString& documentRoot, HttpRequestHandler* requestHandler, QObject* parent) :
+HTTPManager::HTTPManager(quint16 port, const QString& documentRoot, HTTPRequestHandler* requestHandler, QObject* parent) :
     QTcpServer(parent),
     _documentRoot(documentRoot),
     _requestHandler(requestHandler)
diff --git a/libraries/embedded-webserver/src/HTTPManager.h b/libraries/embedded-webserver/src/HTTPManager.h
index fdb7e1e915..e3b44e7cdc 100755
--- a/libraries/embedded-webserver/src/HTTPManager.h
+++ b/libraries/embedded-webserver/src/HTTPManager.h
@@ -17,18 +17,18 @@
 
 class HTTPConnection;
 
-class HttpRequestHandler {
+class HTTPRequestHandler {
 public:
     /// Handles an HTTP request.
     virtual bool handleHTTPRequest(HTTPConnection* connection, const QString& path) = 0;
 };
 
 /// Handles HTTP connections
-class HTTPManager : public QTcpServer, public HttpRequestHandler {
+class HTTPManager : public QTcpServer, public HTTPRequestHandler {
    Q_OBJECT
 public:
     /// Initializes the manager.
-    HTTPManager(quint16 port, const QString& documentRoot, HttpRequestHandler* requestHandler = NULL, QObject* parent = 0);
+    HTTPManager(quint16 port, const QString& documentRoot, HTTPRequestHandler* requestHandler = NULL, QObject* parent = 0);
     
     bool handleHTTPRequest(HTTPConnection* connection, const QString& path);
     
@@ -37,7 +37,7 @@ protected slots:
     void acceptConnections();
 protected:
     QString _documentRoot;
-    HttpRequestHandler* _requestHandler;
+    HTTPRequestHandler* _requestHandler;
 };
 
 #endif /* defined(__hifi__HTTPManager__) */
diff --git a/libraries/octree-server/CMakeLists.txt b/libraries/octree-server/CMakeLists.txt
index 930c91018c..169ed6f296 100644
--- a/libraries/octree-server/CMakeLists.txt
+++ b/libraries/octree-server/CMakeLists.txt
@@ -12,13 +12,8 @@ find_package(Qt5Widgets REQUIRED)
 
 include(${MACRO_DIR}/SetupHifiLibrary.cmake)
 
-# grab cJSON and civetweb sources to pass as OPTIONAL_SRCS
-FILE(GLOB OPTIONAL_SRCS ${ROOT_DIR}/externals/civetweb/src/*)
-
 setup_hifi_library(${TARGET_NAME} ${OPTIONAL_SRCS})
 
-include_directories(${ROOT_DIR}/externals/civetweb/include)
-
 qt5_use_modules(${TARGET_NAME} Widgets)
 
 include(${MACRO_DIR}/IncludeGLM.cmake)
@@ -36,7 +31,5 @@ link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
 # link in the hifi octree library
 link_hifi_library(octree ${TARGET_NAME} ${ROOT_DIR})
 
-# link dl library on UNIX for civetweb
-if (UNIX AND NOT APPLE)
-  target_link_libraries(${TARGET_NAME} ${CMAKE_DL_LIBS})
-endif (UNIX AND NOT APPLE)
\ No newline at end of file
+# link the embedded webserver
+link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
\ No newline at end of file
diff --git a/libraries/octree-server/src/OctreeServer.cpp b/libraries/octree-server/src/OctreeServer.cpp
index b97e34755f..55bc77f1bf 100644
--- a/libraries/octree-server/src/OctreeServer.cpp
+++ b/libraries/octree-server/src/OctreeServer.cpp
@@ -6,25 +6,25 @@
 //  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
 //
 
-#include "civetweb.h"
-
 #include <QtCore/QTimer>
 #include <QtCore/QUuid>
+#include <QtNetwork/QNetworkAccessManager>
 
 #include <time.h>
+#include <HTTPConnection.h>
 #include <Logging.h>
 #include <UUID.h>
 
 #include "OctreeServer.h"
 #include "OctreeServerConsts.h"
 
+OctreeServer* OctreeServer::_instance = NULL;
+
 void OctreeServer::attachQueryNodeToNode(Node* newNode) {
     if (newNode->getLinkedData() == NULL) {
-        if (GetInstance()) {
-            OctreeQueryNode* newQueryNodeData = GetInstance()->createOctreeQueryNode(newNode);
-            newQueryNodeData->resetOctreePacket(true); // don't bump sequence
-            newNode->setLinkedData(newQueryNodeData);
-        }
+        OctreeQueryNode* newQueryNodeData = _instance->createOctreeQueryNode(newNode);
+        newQueryNodeData->resetOctreePacket(true); // don't bump sequence
+        newNode->setLinkedData(newQueryNodeData);
     }
 }
 
@@ -39,30 +39,26 @@ void OctreeServer::nodeKilled(SharedNodePointer node) {
     }
 };
 
-
-OctreeServer* OctreeServer::_theInstance = NULL;
-
 OctreeServer::OctreeServer(const unsigned char* dataBuffer, int numBytes) :
-    ThreadedAssignment(dataBuffer, numBytes)
+    ThreadedAssignment(dataBuffer, numBytes),
+    _argc(0),
+    _argv(NULL),
+    _parsedArgV(NULL),
+    _httpManager(NULL),
+    _packetsPerClientPerInterval(10),
+    _tree(NULL),
+    _wantPersist(true),
+    _debugSending(false),
+    _debugReceiving(false),
+    _verboseDebug(false),
+    _jurisdiction(NULL),
+    _jurisdictionSender(NULL),
+    _octreeInboundPacketProcessor(NULL),
+    _persistThread(NULL),
+    _started(time(0)),
+    _startedUSecs(usecTimestampNow())
 {
-    _argc = 0;
-    _argv = NULL;
-    _tree = NULL;
-    _packetsPerClientPerInterval = 10;
-    _wantPersist = true;
-    _debugSending = false;
-    _debugReceiving = false;
-    _verboseDebug = false;
-    _jurisdiction = NULL;
-    _jurisdictionSender = NULL;
-    _octreeInboundPacketProcessor = NULL;
-    _persistThread = NULL;
-    _parsedArgV = NULL;
-
-    _started = time(0);
-    _startedUSecs = usecTimestampNow();
-
-    _theInstance = this;
+    _instance = this;
 }
 
 OctreeServer::~OctreeServer() {
@@ -94,235 +90,220 @@ OctreeServer::~OctreeServer() {
     qDebug() << "OctreeServer::run()... DONE";
 }
 
-void OctreeServer::initMongoose(int port) {
-    // setup the mongoose web server
-    struct mg_callbacks callbacks = {};
+void OctreeServer::initHTTPManager(int port) {
+    // setup the embedded web server
 
     QString documentRoot = QString("%1/resources/web").arg(QCoreApplication::applicationDirPath());
-    QString listenPort = QString("%1").arg(port);
 
-
-    // list of options. Last element must be NULL.
-    const char* options[] = {
-        "listening_ports", listenPort.toLocal8Bit().constData(),
-        "document_root", documentRoot.toLocal8Bit().constData(),
-        NULL };
-
-    callbacks.begin_request = civetwebRequestHandler;
-
-    // Start the web server.
-    mg_start(&callbacks, NULL, options);
+    // setup an httpManager with us as the request handler and the parent
+    _httpManager = new HTTPManager(port, documentRoot, this, this);
 }
 
-int OctreeServer::civetwebRequestHandler(struct mg_connection* connection) {
-    const struct mg_request_info* ri = mg_get_request_info(connection);
-
-    OctreeServer* theServer = GetInstance();
-
+bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QString& path) {
+    
 #ifdef FORCE_CRASH
-    if (strcmp(ri->uri, "/force_crash") == 0 && strcmp(ri->request_method, "GET") == 0) {
+    if (connection->requestOperation() == QNetworkAccessManager::GetOperation
+        && path == "/force_crash") {
+        
         qDebug() << "About to force a crash!";
+        
         int foo;
         int* forceCrash = &foo;
-        mg_printf(connection, "%s", "HTTP/1.0 200 OK\r\n\r\n");
-        mg_printf(connection, "%s", "forcing a crash....\r\n");
+        
+        QString responseString("forcing a crash...");
+        connection->respond(HTTPConnection::StatusCode200, qPrintable(responseString));
+        
         delete[] forceCrash;
-        mg_printf(connection, "%s", "did it crash....\r\n");
-        return 1;
+        
+        return true;
     }
 #endif
-
+    
     bool showStats = false;
-    if (strcmp(ri->uri, "/") == 0 && strcmp(ri->request_method, "GET") == 0) {
-        showStats = true;
+    
+    if (connection->requestOperation() == QNetworkAccessManager::GetOperation) {
+        if (path == "/") {
+            showStats = true;
+        } else if (path == "/resetStats") {
+            _octreeInboundPacketProcessor->resetStats();
+            showStats = true;
+        }
     }
-
-    if (strcmp(ri->uri, "/resetStats") == 0 && strcmp(ri->request_method, "GET") == 0) {
-        theServer->_octreeInboundPacketProcessor->resetStats();
-        showStats = true;
-    }
-
+    
     if (showStats) {
         uint64_t checkSum;
         // return a 200
-        mg_printf(connection, "%s", "HTTP/1.0 200 OK\r\n");
-        mg_printf(connection, "%s", "Content-Type: text/html\r\n\r\n");
-        mg_printf(connection, "%s", "<html><doc>\r\n");
-        mg_printf(connection, "%s", "<pre>\r\n");
-        mg_printf(connection, "<b>Your %s Server is running... <a href='/'>[RELOAD]</a></b>\r\n", theServer->getMyServerName());
-
-        tm* localtm = localtime(&theServer->_started);
+        QString statsString("<html><doc>\r\n<pre>\r\n");
+        statsString += QString("<b>Your %1 Server is running... <a href='/'>[RELOAD]</a></b>\r\n").arg(getMyServerName());
+        
+        tm* localtm = localtime(&_started);
         const int MAX_TIME_LENGTH = 128;
         char buffer[MAX_TIME_LENGTH];
         strftime(buffer, MAX_TIME_LENGTH, "%m/%d/%Y %X", localtm);
-        mg_printf(connection, "Running since: %s", buffer);
-
+        statsString += QString("Running since: %1").arg(buffer);
+        
         // Convert now to tm struct for UTC
-        tm* gmtm = gmtime(&theServer->_started);
-        if (gmtm != NULL) {
+        tm* gmtm = gmtime(&_started);
+        if (gmtm) {
             strftime(buffer, MAX_TIME_LENGTH, "%m/%d/%Y %X", gmtm);
-            mg_printf(connection, " [%s UTM] ", buffer);
+            statsString += (QString(" [%1 UTM] ").arg(buffer));
         }
-        mg_printf(connection, "%s", "\r\n");
-
+        
+        statsString += "\r\n";
+        
         uint64_t now  = usecTimestampNow();
         const int USECS_PER_MSEC = 1000;
-        uint64_t msecsElapsed = (now - theServer->_startedUSecs) / USECS_PER_MSEC;
+        uint64_t msecsElapsed = (now - _startedUSecs) / USECS_PER_MSEC;
         const int MSECS_PER_SEC = 1000;
         const int SECS_PER_MIN = 60;
         const int MIN_PER_HOUR = 60;
         const int MSECS_PER_MIN = MSECS_PER_SEC * SECS_PER_MIN;
-
+        
         float seconds = (msecsElapsed % MSECS_PER_MIN)/(float)MSECS_PER_SEC;
         int minutes = (msecsElapsed/(MSECS_PER_MIN)) % MIN_PER_HOUR;
         int hours = (msecsElapsed/(MSECS_PER_MIN * MIN_PER_HOUR));
-
-        mg_printf(connection, "%s", "Uptime: ");
+        
+        statsString += "Uptime: ";
+        
         if (hours > 0) {
-            mg_printf(connection, "%d hour%s ", hours, (hours > 1) ? "s" : "" );
+            statsString += QString("%1 hour%2").arg(hours).arg((hours > 1) ? "s" : "");
         }
         if (minutes > 0) {
-            mg_printf(connection, "%d minute%s ", minutes, (minutes > 1) ? "s" : "");
+            statsString += QString("%1 minute%s").arg(minutes).arg((minutes > 1) ? "s" : "");
         }
         if (seconds > 0) {
-            mg_printf(connection, "%.3f seconds ", seconds);
+            statsString += QString().sprintf("%.3f seconds", seconds);
         }
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "\r\n");
-
-
+        statsString += "\r\n\r\n";
+        
         // display voxel file load time
-        if (theServer->isInitialLoadComplete()) {
-            if (theServer->isPersistEnabled()) {
-                mg_printf(connection, "%s File Persist Enabled...\r\n", theServer->getMyServerName());
+        if (isInitialLoadComplete()) {
+            if (isPersistEnabled()) {
+                statsString += QString("%1 File Persist Enabled...\r\n").arg(getMyServerName());
             } else {
-                mg_printf(connection, "%s File Persist Disabled...\r\n", theServer->getMyServerName());
+                statsString += QString("%1 File Persist Disabled...\r\n").arg(getMyServerName());
             }
-            mg_printf(connection, "%s", "\r\n");
-
-            uint64_t msecsElapsed = theServer->getLoadElapsedTime() / USECS_PER_MSEC;;
+            
+            statsString += "\r\n";
+            
+            uint64_t msecsElapsed = getLoadElapsedTime() / USECS_PER_MSEC;;
             float seconds = (msecsElapsed % MSECS_PER_MIN)/(float)MSECS_PER_SEC;
             int minutes = (msecsElapsed/(MSECS_PER_MIN)) % MIN_PER_HOUR;
             int hours = (msecsElapsed/(MSECS_PER_MIN * MIN_PER_HOUR));
-
-            mg_printf(connection, "%s File Load Took: ", theServer->getMyServerName());
+            
+            statsString += QString("%1 File Load Took").arg(getMyServerName());
             if (hours > 0) {
-                mg_printf(connection, "%d hour%s ", hours, (hours > 1) ? "s" : "" );
+                statsString += QString("%1 hour%2").arg(hours).arg((hours > 1) ? "s" : "");
             }
             if (minutes > 0) {
-                mg_printf(connection, "%d minute%s ", minutes, (minutes > 1) ? "s" : "");
+                statsString += QString("%1 minute%2").arg(minutes).arg((minutes > 1) ? "s" : "");
             }
             if (seconds >= 0) {
-                mg_printf(connection, "%.3f seconds", seconds);
+                statsString += QString().sprintf("%.3f seconds", seconds);
             }
-            mg_printf(connection, "%s", "\r\n");
-
+            statsString += "\r\n";
+            
         } else {
-            mg_printf(connection, "%s", "Voxels not yet loaded...\r\n");
+            statsString += "Voxels not yet loaded...\r\n";
         }
-
-        mg_printf(connection, "%s", "\r\n");
-
-        mg_printf(connection, "%s", "\r\n");
-
-        mg_printf(connection, "%s", "<b>Configuration:</b>\r\n");
-
-        for (int i = 1; i < theServer->_argc; i++) {
-            mg_printf(connection, "%s ", theServer->_argv[i]);
+        
+        statsString += "\r\n\r\n";
+        statsString += "<b>Configuration:</b>\r\n";
+        
+        for (int i = 1; i < _argc; i++) {
+            statsString += _argv[i];
         }
-        mg_printf(connection, "%s", "\r\n"); // one to end the config line
-        mg_printf(connection, "%s", "\r\n"); // two more for spacing
-        mg_printf(connection, "%s", "\r\n");
-
+        statsString += "\r\n"; //one to end the config line
+        statsString += "\r\n\r\n"; // two more for spacing
+        
         // display scene stats
         unsigned long nodeCount = OctreeElement::getNodeCount();
         unsigned long internalNodeCount = OctreeElement::getInternalNodeCount();
         unsigned long leafNodeCount = OctreeElement::getLeafNodeCount();
-
+        
         QLocale locale(QLocale::English);
         const float AS_PERCENT = 100.0;
-        mg_printf(connection, "%s", "<b>Current Nodes in scene:</b>\r\n");
-        mg_printf(connection, "       Total Nodes: %s nodes\r\n",
-                    locale.toString((uint)nodeCount).rightJustified(16, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "    Internal Nodes: %s nodes (%5.2f%%)\r\n",
-            locale.toString((uint)internalNodeCount).rightJustified(16, ' ').toLocal8Bit().constData(),
-            ((float)internalNodeCount / (float)nodeCount) * AS_PERCENT);
-        mg_printf(connection, "        Leaf Nodes: %s nodes (%5.2f%%)\r\n",
-            locale.toString((uint)leafNodeCount).rightJustified(16, ' ').toLocal8Bit().constData(),
-            ((float)leafNodeCount / (float)nodeCount) * AS_PERCENT);
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "\r\n");
-
-
+        statsString += "<b>Current Nodes in scene:</b>\r\n";
+        statsString += QString("       Total Nodes: %1 nodes\r\n").arg(locale.toString((uint)nodeCount).rightJustified(16, ' '));
+        statsString += QString().sprintf("    Internal Nodes: %s nodes (%5.2f%%)\r\n",
+                                         locale.toString((uint)internalNodeCount).rightJustified(16,
+                                                                                                 ' ').toLocal8Bit().constData(),
+                                         ((float)internalNodeCount / (float)nodeCount) * AS_PERCENT);
+        statsString += QString().sprintf("        Leaf Nodes: %s nodes (%5.2f%%)\r\n",
+                                         locale.toString((uint)leafNodeCount).rightJustified(16, ' ').toLocal8Bit().constData(),
+                                         ((float)leafNodeCount / (float)nodeCount) * AS_PERCENT);
+        statsString += "\r\n";
+        statsString += "\r\n";
+        
         // display outbound packet stats
-        mg_printf(connection, "<b>%s Outbound Packet Statistics...</b>\r\n", theServer->getMyServerName());
+        statsString += QString("<b>%1 Outbound Packet Statistics...</b>\r\n").arg(getMyServerName());
         uint64_t totalOutboundPackets = OctreeSendThread::_totalPackets;
         uint64_t totalOutboundBytes = OctreeSendThread::_totalBytes;
         uint64_t totalWastedBytes = OctreeSendThread::_totalWastedBytes;
         uint64_t totalBytesOfOctalCodes = OctreePacketData::getTotalBytesOfOctalCodes();
         uint64_t totalBytesOfBitMasks = OctreePacketData::getTotalBytesOfBitMasks();
         uint64_t totalBytesOfColor = OctreePacketData::getTotalBytesOfColor();
-
+        
         const int COLUMN_WIDTH = 10;
-        mg_printf(connection, "           Total Outbound Packets: %s packets\r\n",
-            locale.toString((uint)totalOutboundPackets).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "             Total Outbound Bytes: %s bytes\r\n",
-            locale.toString((uint)totalOutboundBytes).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "               Total Wasted Bytes: %s bytes\r\n",
-            locale.toString((uint)totalWastedBytes).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "            Total OctalCode Bytes: %s bytes (%5.2f%%)\r\n",
+        statsString += QString("           Total Outbound Packets: %1 packets\r\n")
+            .arg(locale.toString((uint)totalOutboundPackets).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString("             Total Outbound Bytes: %1 bytes\r\n")
+            .arg(locale.toString((uint)totalOutboundBytes).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString("               Total Wasted Bytes: %1 bytes\r\n")
+            .arg(locale.toString((uint)totalWastedBytes).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString().sprintf("            Total OctalCode Bytes: %s bytes (%5.2f%%)\r\n",
             locale.toString((uint)totalBytesOfOctalCodes).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData(),
             ((float)totalBytesOfOctalCodes / (float)totalOutboundBytes) * AS_PERCENT);
-        mg_printf(connection, "             Total BitMasks Bytes: %s bytes (%5.2f%%)\r\n",
+        statsString += QString().sprintf("             Total BitMasks Bytes: %s bytes (%5.2f%%)\r\n",
             locale.toString((uint)totalBytesOfBitMasks).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData(),
             ((float)totalBytesOfBitMasks / (float)totalOutboundBytes) * AS_PERCENT);
-        mg_printf(connection, "                Total Color Bytes: %s bytes (%5.2f%%)\r\n",
+        statsString += QString().sprintf("                Total Color Bytes: %s bytes (%5.2f%%)\r\n",
             locale.toString((uint)totalBytesOfColor).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData(),
             ((float)totalBytesOfColor / (float)totalOutboundBytes) * AS_PERCENT);
-
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "\r\n");
-
+        
+        statsString += "\r\n";
+        statsString += "\r\n";
+        
         // display inbound packet stats
-        mg_printf(connection, "<b>%s Edit Statistics... <a href='/resetStats'>[RESET]</a></b>\r\n",
-                        theServer->getMyServerName());
-        uint64_t averageTransitTimePerPacket = theServer->_octreeInboundPacketProcessor->getAverageTransitTimePerPacket();
-        uint64_t averageProcessTimePerPacket = theServer->_octreeInboundPacketProcessor->getAverageProcessTimePerPacket();
-        uint64_t averageLockWaitTimePerPacket = theServer->_octreeInboundPacketProcessor->getAverageLockWaitTimePerPacket();
-        uint64_t averageProcessTimePerElement = theServer->_octreeInboundPacketProcessor->getAverageProcessTimePerElement();
-        uint64_t averageLockWaitTimePerElement = theServer->_octreeInboundPacketProcessor->getAverageLockWaitTimePerElement();
-        uint64_t totalElementsProcessed = theServer->_octreeInboundPacketProcessor->getTotalElementsProcessed();
-        uint64_t totalPacketsProcessed = theServer->_octreeInboundPacketProcessor->getTotalPacketsProcessed();
-
+        statsString += QString().sprintf("<b>%s Edit Statistics... <a href='/resetStats'>[RESET]</a></b>\r\n",
+                                         getMyServerName());
+        uint64_t averageTransitTimePerPacket = _octreeInboundPacketProcessor->getAverageTransitTimePerPacket();
+        uint64_t averageProcessTimePerPacket = _octreeInboundPacketProcessor->getAverageProcessTimePerPacket();
+        uint64_t averageLockWaitTimePerPacket = _octreeInboundPacketProcessor->getAverageLockWaitTimePerPacket();
+        uint64_t averageProcessTimePerElement = _octreeInboundPacketProcessor->getAverageProcessTimePerElement();
+        uint64_t averageLockWaitTimePerElement = _octreeInboundPacketProcessor->getAverageLockWaitTimePerElement();
+        uint64_t totalElementsProcessed = _octreeInboundPacketProcessor->getTotalElementsProcessed();
+        uint64_t totalPacketsProcessed = _octreeInboundPacketProcessor->getTotalPacketsProcessed();
+        
         float averageElementsPerPacket = totalPacketsProcessed == 0 ? 0 : totalElementsProcessed / totalPacketsProcessed;
-
-        mg_printf(connection, "           Total Inbound Packets: %s packets\r\n",
-            locale.toString((uint)totalPacketsProcessed).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "          Total Inbound Elements: %s elements\r\n",
-            locale.toString((uint)totalElementsProcessed).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, " Average Inbound Elements/Packet: %f elements/packet\r\n", averageElementsPerPacket);
-        mg_printf(connection, "     Average Transit Time/Packet: %s usecs\r\n",
-            locale.toString((uint)averageTransitTimePerPacket).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "     Average Process Time/Packet: %s usecs\r\n",
-            locale.toString((uint)averageProcessTimePerPacket).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "   Average Wait Lock Time/Packet: %s usecs\r\n",
-            locale.toString((uint)averageLockWaitTimePerPacket).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "    Average Process Time/Element: %s usecs\r\n",
-            locale.toString((uint)averageProcessTimePerElement).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-        mg_printf(connection, "  Average Wait Lock Time/Element: %s usecs\r\n",
-            locale.toString((uint)averageLockWaitTimePerElement).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-
-
+        
+        statsString += QString("           Total Inbound Packets: %1 packets\r\n")
+            .arg(locale.toString((uint)totalPacketsProcessed).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString("          Total Inbound Elements: %1 elements\r\n")
+            .arg(locale.toString((uint)totalElementsProcessed).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString().sprintf(" Average Inbound Elements/Packet: %f elements/packet\r\n", averageElementsPerPacket);
+        statsString += QString("     Average Transit Time/Packet: %1 usecs\r\n")
+            .arg(locale.toString((uint)averageTransitTimePerPacket).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString("     Average Process Time/Packet: %1 usecs\r\n")
+            .arg(locale.toString((uint)averageProcessTimePerPacket).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString("   Average Wait Lock Time/Packet: %1 usecs\r\n")
+            .arg(locale.toString((uint)averageLockWaitTimePerPacket).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString("    Average Process Time/Element: %1 usecs\r\n")
+            .arg(locale.toString((uint)averageProcessTimePerElement).rightJustified(COLUMN_WIDTH, ' '));
+        statsString += QString("  Average Wait Lock Time/Element: %1 usecs\r\n")
+            .arg(locale.toString((uint)averageLockWaitTimePerElement).rightJustified(COLUMN_WIDTH, ' '));
+        
+        
         int senderNumber = 0;
-        NodeToSenderStatsMap& allSenderStats = theServer->_octreeInboundPacketProcessor->getSingleSenderStats();
+        NodeToSenderStatsMap& allSenderStats = _octreeInboundPacketProcessor->getSingleSenderStats();
         for (NodeToSenderStatsMapIterator i = allSenderStats.begin(); i != allSenderStats.end(); i++) {
             senderNumber++;
             QUuid senderID = i->first;
             SingleSenderStats& senderStats = i->second;
-
-            mg_printf(connection, "\r\n             Stats for sender %d uuid: %s\r\n", senderNumber,
-                senderID.toString().toLocal8Bit().constData());
-
+            
+            statsString += QString("\r\n             Stats for sender %1 uuid: %2\r\n")
+                .arg(senderNumber).arg(senderID.toString());
+            
             averageTransitTimePerPacket = senderStats.getAverageTransitTimePerPacket();
             averageProcessTimePerPacket = senderStats.getAverageProcessTimePerPacket();
             averageLockWaitTimePerPacket = senderStats.getAverageLockWaitTimePerPacket();
@@ -330,36 +311,35 @@ int OctreeServer::civetwebRequestHandler(struct mg_connection* connection) {
             averageLockWaitTimePerElement = senderStats.getAverageLockWaitTimePerElement();
             totalElementsProcessed = senderStats.getTotalElementsProcessed();
             totalPacketsProcessed = senderStats.getTotalPacketsProcessed();
-
+            
             averageElementsPerPacket = totalPacketsProcessed == 0 ? 0 : totalElementsProcessed / totalPacketsProcessed;
-
-            mg_printf(connection, "               Total Inbound Packets: %s packets\r\n",
-                locale.toString((uint)totalPacketsProcessed).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-            mg_printf(connection, "              Total Inbound Elements: %s elements\r\n",
-                locale.toString((uint)totalElementsProcessed).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-            mg_printf(connection, "     Average Inbound Elements/Packet: %f elements/packet\r\n", averageElementsPerPacket);
-            mg_printf(connection, "         Average Transit Time/Packet: %s usecs\r\n",
-                locale.toString((uint)averageTransitTimePerPacket).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-            mg_printf(connection, "         Average Process Time/Packet: %s usecs\r\n",
-                locale.toString((uint)averageProcessTimePerPacket).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-            mg_printf(connection, "       Average Wait Lock Time/Packet: %s usecs\r\n",
-                locale.toString((uint)averageLockWaitTimePerPacket).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-            mg_printf(connection, "        Average Process Time/Element: %s usecs\r\n",
-                locale.toString((uint)averageProcessTimePerElement).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-            mg_printf(connection, "      Average Wait Lock Time/Element: %s usecs\r\n",
-                locale.toString((uint)averageLockWaitTimePerElement).rightJustified(COLUMN_WIDTH, ' ').toLocal8Bit().constData());
-
+            
+            statsString += QString("               Total Inbound Packets: %1 packets\r\n")
+                .arg(locale.toString((uint)totalPacketsProcessed).rightJustified(COLUMN_WIDTH, ' '));
+            statsString += QString("              Total Inbound Elements: %1 elements\r\n")
+                .arg(locale.toString((uint)totalElementsProcessed).rightJustified(COLUMN_WIDTH, ' '));
+            statsString += QString().sprintf("     Average Inbound Elements/Packet: %f elements/packet\r\n",
+                                             averageElementsPerPacket);
+            statsString += QString("         Average Transit Time/Packet: %1 usecs\r\n")
+                .arg(locale.toString((uint)averageTransitTimePerPacket).rightJustified(COLUMN_WIDTH, ' '));
+            statsString += QString("        Average Process Time/Packet: %1 usecs\r\n")
+                .arg(locale.toString((uint)averageProcessTimePerPacket).rightJustified(COLUMN_WIDTH, ' '));
+            statsString += QString("       Average Wait Lock Time/Packet: %1 usecs\r\n")
+                .arg(locale.toString((uint)averageLockWaitTimePerPacket).rightJustified(COLUMN_WIDTH, ' '));
+            statsString += QString("        Average Process Time/Element: %1 usecs\r\n")
+                .arg(locale.toString((uint)averageProcessTimePerElement).rightJustified(COLUMN_WIDTH, ' '));
+            statsString += QString("      Average Wait Lock Time/Element: %1 usecs\r\n")
+                .arg(locale.toString((uint)averageLockWaitTimePerElement).rightJustified(COLUMN_WIDTH, ' '));
+            
         }
-
-
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "\r\n");
-
+        
+        statsString += "\r\n\r\n";
+        
         // display memory usage stats
-        mg_printf(connection, "%s", "<b>Current Memory Usage Statistics</b>\r\n");
-        mg_printf(connection, "\r\nOctreeElement size... %ld bytes\r\n", sizeof(OctreeElement));
-        mg_printf(connection, "%s", "\r\n");
-
+        statsString += "<b>Current Memory Usage Statistics</b>\r\n";
+        statsString += QString().sprintf("\r\nOctreeElement size... %ld bytes\r\n", sizeof(OctreeElement));
+        statsString += "\r\n";
+        
         const char* memoryScaleLabel;
         const float MEGABYTES = 1000000.f;
         const float GIGABYTES = 1000000000.f;
@@ -371,82 +351,84 @@ int OctreeServer::civetwebRequestHandler(struct mg_connection* connection) {
             memoryScaleLabel = "GB";
             memoryScale = GIGABYTES;
         }
-
-        mg_printf(connection, "Element Node Memory Usage:       %8.2f %s\r\n",
-            OctreeElement::getVoxelMemoryUsage() / memoryScale, memoryScaleLabel);
-        mg_printf(connection, "Octcode Memory Usage:            %8.2f %s\r\n",
-            OctreeElement::getOctcodeMemoryUsage() / memoryScale, memoryScaleLabel);
-        mg_printf(connection, "External Children Memory Usage:  %8.2f %s\r\n",
-            OctreeElement::getExternalChildrenMemoryUsage() / memoryScale, memoryScaleLabel);
-        mg_printf(connection, "%s", "                                 -----------\r\n");
-        mg_printf(connection, "                         Total:  %8.2f %s\r\n",
-            OctreeElement::getTotalMemoryUsage() / memoryScale, memoryScaleLabel);
-
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "OctreeElement Children Population Statistics...\r\n");
+        
+        statsString += QString().sprintf("Element Node Memory Usage:       %8.2f %s\r\n",
+                                         OctreeElement::getVoxelMemoryUsage() / memoryScale, memoryScaleLabel);
+        statsString += QString().sprintf("Octcode Memory Usage:            %8.2f %s\r\n",
+                                         OctreeElement::getOctcodeMemoryUsage() / memoryScale, memoryScaleLabel);
+        statsString += QString().sprintf("External Children Memory Usage:  %8.2f %s\r\n",
+                                         OctreeElement::getExternalChildrenMemoryUsage() / memoryScale, memoryScaleLabel);
+        statsString += "                                 -----------\r\n";
+        statsString += QString().sprintf("                         Total:  %8.2f %s\r\n",
+                                         OctreeElement::getTotalMemoryUsage() / memoryScale, memoryScaleLabel);
+        statsString += "\r\n";
+        
+        statsString += "OctreeElement Children Population Statistics...\r\n";
         checkSum = 0;
         for (int i=0; i <= NUMBER_OF_CHILDREN; i++) {
             checkSum += OctreeElement::getChildrenCount(i);
-            mg_printf(connection, "    Nodes with %d children:      %s nodes (%5.2f%%)\r\n", i,
-                locale.toString((uint)OctreeElement::getChildrenCount(i)).rightJustified(16, ' ').toLocal8Bit().constData(),
-                ((float)OctreeElement::getChildrenCount(i) / (float)nodeCount) * AS_PERCENT);
+            statsString += QString().sprintf("    Nodes with %d children:      %s nodes (%5.2f%%)\r\n", i,
+                      locale.toString((uint)OctreeElement::getChildrenCount(i)).rightJustified(16, ' ').toLocal8Bit().constData(),
+                      ((float)OctreeElement::getChildrenCount(i) / (float)nodeCount) * AS_PERCENT);
         }
-        mg_printf(connection, "%s", "                                ----------------------\r\n");
-        mg_printf(connection, "                    Total:      %s nodes\r\n",
-            locale.toString((uint)checkSum).rightJustified(16, ' ').toLocal8Bit().constData());
-
+        statsString += "                                ----------------------\r\n";
+        statsString += QString("                    Total:      %1 nodes\r\n")
+            .arg(locale.toString((uint)checkSum).rightJustified(16, ' '));
+        
 #ifdef BLENDED_UNION_CHILDREN
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "OctreeElement Children Encoding Statistics...\r\n");
-
-        mg_printf(connection, "    Single or No Children:      %10.llu nodes (%5.2f%%)\r\n",
-            OctreeElement::getSingleChildrenCount(), ((float)OctreeElement::getSingleChildrenCount() / (float)nodeCount) * AS_PERCENT);
-        mg_printf(connection, "    Two Children as Offset:     %10.llu nodes (%5.2f%%)\r\n",
-            OctreeElement::getTwoChildrenOffsetCount(),
-            ((float)OctreeElement::getTwoChildrenOffsetCount() / (float)nodeCount) * AS_PERCENT);
-        mg_printf(connection, "    Two Children as External:   %10.llu nodes (%5.2f%%)\r\n",
-            OctreeElement::getTwoChildrenExternalCount(),
-            ((float)OctreeElement::getTwoChildrenExternalCount() / (float)nodeCount) * AS_PERCENT);
-        mg_printf(connection, "    Three Children as Offset:   %10.llu nodes (%5.2f%%)\r\n",
-            OctreeElement::getThreeChildrenOffsetCount(),
-            ((float)OctreeElement::getThreeChildrenOffsetCount() / (float)nodeCount) * AS_PERCENT);
-        mg_printf(connection, "    Three Children as External: %10.llu nodes (%5.2f%%)\r\n",
-            OctreeElement::getThreeChildrenExternalCount(),
-            ((float)OctreeElement::getThreeChildrenExternalCount() / (float)nodeCount) * AS_PERCENT);
-        mg_printf(connection, "    Children as External Array: %10.llu nodes (%5.2f%%)\r\n",
-            OctreeElement::getExternalChildrenCount(),
-            ((float)OctreeElement::getExternalChildrenCount() / (float)nodeCount) * AS_PERCENT);
-
+        statsString += "\r\n";
+        statsString += "OctreeElement Children Encoding Statistics...\r\n";
+        
+        statsString += QString().sprintf("    Single or No Children:      %10.llu nodes (%5.2f%%)\r\n",
+                                         OctreeElement::getSingleChildrenCount(),
+                                         ((float)OctreeElement::getSingleChildrenCount() / (float)nodeCount) * AS_PERCENT));
+        statsString += QString().sprintf("    Two Children as Offset:     %10.llu nodes (%5.2f%%)\r\n",
+                                         OctreeElement::getTwoChildrenOffsetCount(),
+                                         ((float)OctreeElement::getTwoChildrenOffsetCount() / (float)nodeCount) * AS_PERCENT));
+        statsString += QString().sprintf("    Two Children as External:   %10.llu nodes (%5.2f%%)\r\n",
+                                         OctreeElement::getTwoChildrenExternalCount(),
+                                         ((float)OctreeElement::getTwoChildrenExternalCount() / (float)nodeCount) * AS_PERCENT);
+        statsString += QString().sprintf("    Three Children as Offset:   %10.llu nodes (%5.2f%%)\r\n",
+                                         OctreeElement::getThreeChildrenOffsetCount(),
+                                         ((float)OctreeElement::getThreeChildrenOffsetCount() / (float)nodeCount) * AS_PERCENT);
+        statsString += QString().sprintf("    Three Children as External: %10.llu nodes (%5.2f%%)\r\n",
+                                         OctreeElement::getThreeChildrenExternalCount(),
+                                         ((float)OctreeElement::getThreeChildrenExternalCount() / (float)nodeCount) * AS_PERCENT);
+        statsString += QString().sprintf("    Children as External Array: %10.llu nodes (%5.2f%%)\r\n",
+                                         OctreeElement::getExternalChildrenCount(),
+                                         ((float)OctreeElement::getExternalChildrenCount() / (float)nodeCount) * AS_PERCENT);
+        
         checkSum = OctreeElement::getSingleChildrenCount() +
-                            OctreeElement::getTwoChildrenOffsetCount() + OctreeElement::getTwoChildrenExternalCount() +
-                            OctreeElement::getThreeChildrenOffsetCount() + OctreeElement::getThreeChildrenExternalCount() +
-                            OctreeElement::getExternalChildrenCount();
-
-        mg_printf(connection, "%s", "                                ----------------\r\n");
-        mg_printf(connection, "                         Total: %10.llu nodes\r\n", checkSum);
-        mg_printf(connection, "                      Expected: %10.lu nodes\r\n", nodeCount);
-
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "In other news....\r\n");
-        mg_printf(connection, "could store 4 children internally:     %10.llu nodes\r\n",
-            OctreeElement::getCouldStoreFourChildrenInternally());
-        mg_printf(connection, "could NOT store 4 children internally: %10.llu nodes\r\n",
-            OctreeElement::getCouldNotStoreFourChildrenInternally());
+        OctreeElement::getTwoChildrenOffsetCount() + OctreeElement::getTwoChildrenExternalCount() +
+        OctreeElement::getThreeChildrenOffsetCount() + OctreeElement::getThreeChildrenExternalCount() +
+        OctreeElement::getExternalChildrenCount();
+        
+        statsString += "                                ----------------\r\n";
+        statsString += QString().sprintf("                         Total: %10.llu nodes\r\n", checkSum);
+        statsString += QString().sprintf("                      Expected: %10.lu nodes\r\n", nodeCount);
+        
+        statsString += "\r\n";
+        statsString += "In other news....\r\n";
+        
+        statsString += QString().sprintf("could store 4 children internally:     %10.llu nodes\r\n",
+                                         OctreeElement::getCouldStoreFourChildrenInternally());
+        statsString += QString().sprintf("could NOT store 4 children internally: %10.llu nodes\r\n",
+                                         OctreeElement::getCouldNotStoreFourChildrenInternally());
 #endif
-
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "\r\n");
-        mg_printf(connection, "%s", "</pre>\r\n");
-
-        mg_printf(connection, "%s", "</doc></html>");
-
-        return 1;
+        
+        statsString += "\r\n\r\n";
+        statsString += "</pre>\r\n";
+        statsString += "</doc></html>";
+        
+        connection->respond(HTTPConnection::StatusCode200, qPrintable(statsString), "text/html");
+        
+        return true;
     } else {
-        // have mongoose process this request from the document_root
-        return 0;
+        // have HTTPManager attempt to process this request from the document_root
+        return false;
     }
-}
 
+}
 
 void OctreeServer::setArguments(int argc, char** argv) {
     _argc = argc;
@@ -553,7 +535,7 @@ void OctreeServer::run() {
     const char* statusPort = getCmdOption(_argc, _argv, STATUS_PORT);
     if (statusPort) {
         int statusPortNumber = atoi(statusPort);
-        initMongoose(statusPortNumber);
+        initHTTPManager(statusPortNumber);
     }
 
 
diff --git a/libraries/octree-server/src/OctreeServer.h b/libraries/octree-server/src/OctreeServer.h
index 708addfd1f..7e9538f38c 100644
--- a/libraries/octree-server/src/OctreeServer.h
+++ b/libraries/octree-server/src/OctreeServer.h
@@ -14,6 +14,8 @@
 #include <QDateTime>
 #include <QtCore/QCoreApplication>
 
+#include <HTTPManager.h>
+
 #include <ThreadedAssignment.h>
 #include <EnvironmentData.h>
 
@@ -23,7 +25,7 @@
 #include "OctreeInboundPacketProcessor.h"
 
 /// Handles assignments of type OctreeServer - sending octrees to various clients.
-class OctreeServer : public ThreadedAssignment {
+class OctreeServer : public ThreadedAssignment, public HTTPRequestHandler {
     Q_OBJECT
 public:                
     OctreeServer(const unsigned char* dataBuffer, int numBytes);
@@ -40,7 +42,6 @@ public:
     JurisdictionMap* getJurisdiction() { return _jurisdiction; }
 
     int getPacketsPerClientPerInterval() const { return _packetsPerClientPerInterval; }
-    static OctreeServer* GetInstance() { return _theInstance; }
 
     bool isInitialLoadComplete() const { return (_persistThread) ? _persistThread->isInitialLoadComplete() : true; }
     bool isPersistEnabled() const { return (_persistThread) ? true : false; }
@@ -61,6 +62,8 @@ public:
     virtual int sendSpecialPacket(Node* node) { return 0; }
 
     static void attachQueryNodeToNode(Node* newNode);
+    
+    bool handleHTTPRequest(HTTPConnection* connection, const QString& path);
 public slots:
     /// runs the voxel server assignment
     void run();
@@ -69,9 +72,14 @@ public slots:
     void nodeKilled(SharedNodePointer node);
 
 protected:
+    void parsePayload();
+    void initHTTPManager(int port);
+    
     int _argc;
     const char** _argv;
     char** _parsedArgV;
+    
+    HTTPManager* _httpManager;
 
     char _persistFilename[MAX_FILENAME_LENGTH];
     int _packetsPerClientPerInterval;
@@ -85,12 +93,10 @@ protected:
     OctreeInboundPacketProcessor* _octreeInboundPacketProcessor;
     OctreePersistThread* _persistThread;
 
-    void parsePayload();
-    void initMongoose(int port);
-    static int civetwebRequestHandler(struct mg_connection *connection);
-    static OctreeServer* _theInstance;
+    static OctreeServer* _instance;
+    
     time_t _started;
-    uint64_t _startedUSecs;
+    uint64_t _startedUSecs;    
 };
 
 #endif // __octree_server__OctreeServer__

From 6670ff6ee5df44a4edae2e29cabaab28fdf21973 Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Fri, 17 Jan 2014 14:27:24 -0800
Subject: [PATCH 14/18] fix linking of webserver for octree-server

---
 assignment-client/CMakeLists.txt         | 4 ++--
 libraries/particle-server/CMakeLists.txt | 2 ++
 libraries/voxel-server/CMakeLists.txt    | 5 ++++-
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/assignment-client/CMakeLists.txt b/assignment-client/CMakeLists.txt
index 5b46d43f05..d66a30957d 100644
--- a/assignment-client/CMakeLists.txt
+++ b/assignment-client/CMakeLists.txt
@@ -21,7 +21,7 @@ qt5_use_modules(${TARGET_NAME} Network Script Widgets)
 include(${MACRO_DIR}/IncludeGLM.cmake)
 include_glm(${TARGET_NAME} ${ROOT_DIR})
 
-# link in the shared library
+# link in the shared libraries
 include(${MACRO_DIR}/LinkHifiLibrary.cmake)
 link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(audio ${TARGET_NAME} ${ROOT_DIR})
@@ -34,7 +34,7 @@ link_hifi_library(octree-server ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(particle-server ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(voxel-server ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(script-engine ${TARGET_NAME} ${ROOT_DIR})
-#testing
+link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
 
 if (UNIX)
   target_link_libraries(${TARGET_NAME} ${CMAKE_DL_LIBS})
diff --git a/libraries/particle-server/CMakeLists.txt b/libraries/particle-server/CMakeLists.txt
index 5e14902f45..9c63645e8d 100644
--- a/libraries/particle-server/CMakeLists.txt
+++ b/libraries/particle-server/CMakeLists.txt
@@ -33,3 +33,5 @@ link_hifi_library(octree ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(octree-server ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(particles ${TARGET_NAME} ${ROOT_DIR})
 
+# link in the embedded webserver
+link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
\ No newline at end of file
diff --git a/libraries/voxel-server/CMakeLists.txt b/libraries/voxel-server/CMakeLists.txt
index 0db5fc5575..594d037767 100644
--- a/libraries/voxel-server/CMakeLists.txt
+++ b/libraries/voxel-server/CMakeLists.txt
@@ -28,7 +28,10 @@ target_link_libraries(${TARGET_NAME} ${ZLIB_LIBRARIES})
 include(${MACRO_DIR}/LinkHifiLibrary.cmake)
 link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
 
+# link in the embedded webserver
+link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
+
 # link in the hifi octree library
 link_hifi_library(octree ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(octree-server ${TARGET_NAME} ${ROOT_DIR})
-link_hifi_library(voxels ${TARGET_NAME} ${ROOT_DIR})
+link_hifi_library(voxels ${TARGET_NAME} ${ROOT_DIR})
\ No newline at end of file

From 5abf61299038aaaa4888b299705a18d078f1e0ab Mon Sep 17 00:00:00 2001
From: Philip Rosedale <philip@highfidelity.io>
Date: Fri, 17 Jan 2014 16:43:43 -0800
Subject: [PATCH 15/18] new sounds for voxelBird, clap scripts

---
 examples/clap.js      | 21 +++++++++++++++++----
 examples/playSound.js |  2 +-
 examples/voxelBird.js | 17 ++++++++++-------
 3 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/examples/clap.js b/examples/clap.js
index 3638d3e589..fdd2b29aa2 100644
--- a/examples/clap.js
+++ b/examples/clap.js
@@ -1,5 +1,5 @@
 //
-//  This sample script watches your hydra hands and makes clapping sound 
+//  This sample script watches your hydra hands and makes clapping sound when they come close together fast 
 //
 
 function length(v) {
@@ -17,7 +17,13 @@ function vMinus(a, b) {
 }
 
 //  First, load the clap sound from a URL 
-var clap = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/clap1.raw");
+var clap1 = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/claps/clap1.raw");
+var clap2 = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/claps/clap2.raw");
+var clap3 = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/claps/clap3.raw");
+var clap4 = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/claps/clap4.raw");
+var clap5 = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/claps/clap5.raw");
+var clap6 = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/claps/clap6.raw");
+
 var clapping = new Array();
 clapping[0] = false; 
 clapping[1] = false; 
@@ -33,16 +39,23 @@ function maybePlaySound() {
 		var speed = length(palmVelocity);
 		
 		const CLAP_SPEED = 0.2;
-		const CLAP_DISTANCE = 0.3; 
+		const CLAP_DISTANCE = 0.2; 
 
     	if (!clapping[palm] && (distanceBetween < CLAP_DISTANCE) && (speed > CLAP_SPEED)) {
     		var options = new AudioInjectionOptions();

 			options.position = palm1Position;
 			options.volume = speed / 2.0;
 			if (options.volume > 1.0) options.volume = 1.0;
+			which = Math.floor((Math.random() * 6) + 1);
+			if (which == 1) {  Audio.playSound(clap1, options);  }
+			else if (which == 2) { Audio.playSound(clap2, options); }
+			else if (which == 3) { Audio.playSound(clap3, options); }
+			else if (which == 4) { Audio.playSound(clap4, options); }
+			else if (which == 5) { Audio.playSound(clap5, options); }
+			else { Audio.playSound(clap6, options); }
 			Audio.playSound(clap, options);
 			clapping[palm] = true; 
-    	} else if (clapping[palm] && (speed < (CLAP_SPEED / 1.5))) {
+    	} else if (clapping[palm] && (speed < (CLAP_SPEED / 4.0))) {
     		clapping[palm] = false;
     	}
 	}
diff --git a/examples/playSound.js b/examples/playSound.js
index 40cd80c3cb..6631d5526a 100644
--- a/examples/playSound.js
+++ b/examples/playSound.js
@@ -3,7 +3,7 @@
 //
 
 //  First, load the clap sound from a URL 
-var clap = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/clap1.raw");
+var clap = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/bushtit_1.raw");	
 
 function maybePlaySound() {
 	if (Math.random() < 0.01) {
diff --git a/examples/voxelBird.js b/examples/voxelBird.js
index 52bd06f36b..bc4cac0247 100644
--- a/examples/voxelBird.js
+++ b/examples/voxelBird.js
@@ -41,16 +41,19 @@ function vInterpolate(a, b, fraction) {
 
 //  Decide what kind of bird we are 
 var tweet;
+
 var which = Math.random();
-if (which < 1.0) {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/bushtit_1.raw");
+if (which < 0.2) {
+	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/bushtit_1.raw");
 } else if (which < 0.4) {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/bushtit_2.raw");
+	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/rosyfacedlovebird.raw");
 } else if (which < 0.6) {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/bushtit_3.raw");
+	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/saysphoebe.raw");
+} else  if (which < 0.8) {
+	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/mexicanWhipoorwill.raw");
 } else {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/mexicanWhipoorwill.raw");
-}
+	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/westernscreechowl.raw");
+} 
 
 var position  = { x: 0, y: 0, z: 0 };
 var lastPosition  = { x: 0, y: 0, z: 0 };
@@ -58,7 +61,7 @@ var oldPosition = { x: 0, y: 0, z:0 };
 var targetPosition = { x: 0, y: 0, z: 0 };
 
 var size = 0.125;
-var range = 4.0;       //   Over what distance in meters do you want your bird to fly around 
+var range = 50.0;       //   Over what distance in meters do you want your bird to fly around 
 var color = { r: 100, g: 50, b: 150 };
 var colorEdge = { r:255, g:250, b:175 };
 var frame = 0;

From 4547f07739669c72d96adf62a2491ccae20da88e Mon Sep 17 00:00:00 2001
From: Philip Rosedale <philip@highfidelity.io>
Date: Fri, 17 Jan 2014 17:10:15 -0800
Subject: [PATCH 16/18] added fountain script

---
 examples/fountain.js                     | 62 ++++++++++++++++++++++++
 interface/src/avatar/MyAvatar.cpp        |  2 -
 interface/src/devices/SixenseManager.cpp |  2 +-
 3 files changed, 63 insertions(+), 3 deletions(-)
 create mode 100644 examples/fountain.js

diff --git a/examples/fountain.js b/examples/fountain.js
new file mode 100644
index 0000000000..b15557c8ee
--- /dev/null
+++ b/examples/fountain.js
@@ -0,0 +1,62 @@
+
+
+function vLength(v) {
+    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+
+function printVector(v) {
+	print(v.x + ", " + v.y + ", " + v.z + "\n");
+}
+
+//  Create a random vector with individual lengths between a,b
+function randVector(a, b) {
+	var rval = { x: a + Math.random() * (b - a), y: a + Math.random() * (b - a), z: a + Math.random() * (b - a) };
+	return rval;
+}
+
+function vMinus(a, b) { 
+	var rval = { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+	return rval;
+}
+
+function vPlus(a, b) { 
+	var rval = { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+	return rval;
+}
+
+function vCopy(a, b) {
+	a.x = b.x;
+	a.y = b.y;
+	a.z = b.z;
+	return;
+}
+
+//  Returns a vector which is fraction of the way between a and b
+function vInterpolate(a, b, fraction) { 
+	var rval = { x: a.x + (b.x - a.x) * fraction, y: a.y + (b.y - a.y) * fraction, z: a.z + (b.z - a.z) * fraction };
+	return rval;
+}
+ 
+var position = { x: 5.0 / TREE_SCALE, y: 5.0 / TREE_SCALE, z: 5.0 / TREE_SCALE }; 
+Voxels.queueDestructiveVoxelAdd(position.x, position.y - (1.0 / TREE_SCALE), position.z, 0.5 / TREE_SCALE, 255, 255, 1);
+	
+function makeFountain() {
+	if (Math.random() < 0.06) {
+	    //print("Made particle!\n");
+
+        var size = (0.02 + (Math.random() * 0.05)) / TREE_SCALE;
+        var velocity = { x: (Math.random() * 1.0 - 0.5) / TREE_SCALE,
+                         y: (1.0 + (Math.random() * 2.0)) / TREE_SCALE,
+                         z: (Math.random() * 1.0 - 0.5) / TREE_SCALE };
+		
+        var gravity = {  x: 0, y: -0.5 / TREE_SCALE, z: 0 }; // gravity has no effect on these bullets
+        var color = {  red: 0, green: 0, blue: 128 };
+        var damping = 0.25; // no damping
+        var inHand = false;
+        var script = "";
+
+        Particles.queueParticleAdd(position, size, color, velocity, gravity, damping, inHand, script);
+    }
+}
+// register the call back so it fires before each data send
+Agent.willSendVisualDataCallback.connect(makeFountain);
\ No newline at end of file
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 3c5fdb243f..3bbba8b749 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -175,8 +175,6 @@ void MyAvatar::simulate(float deltaTime, Transmitter* transmitter) {
 
     // Compute instantaneous acceleration
     float forwardAcceleration = glm::length(glm::dot(getBodyFrontDirection(), getVelocity() - oldVelocity)) / deltaTime;
-    const float ACCELERATION_PITCH_DECAY = 0.4f;
-    const float ACCELERATION_PULL_THRESHOLD = 0.2f;
     const float OCULUS_ACCELERATION_PULL_THRESHOLD = 1.0f;
     const int OCULUS_YAW_OFFSET_THRESHOLD = 10;
 
diff --git a/interface/src/devices/SixenseManager.cpp b/interface/src/devices/SixenseManager.cpp
index 12d045dea3..af1eafc85b 100644
--- a/interface/src/devices/SixenseManager.cpp
+++ b/interface/src/devices/SixenseManager.cpp
@@ -119,7 +119,7 @@ void SixenseManager::update(float deltaTime) {
         FingerData finger(palm, &hand);
         finger.setActive(true);
         finger.setRawRootPosition(position);
-        const float FINGER_LENGTH = 150.0f;   //  Millimeters
+        const float FINGER_LENGTH = 300.0f;   //  Millimeters
         const glm::vec3 FINGER_VECTOR(0.0f, 0.0f, FINGER_LENGTH);
         const glm::vec3 newTipPosition = position + rotation * FINGER_VECTOR;
         finger.setRawTipPosition(position + rotation * FINGER_VECTOR);

From 7381848acb8eea43731000c30d14e370b61c6b1f Mon Sep 17 00:00:00 2001
From: Stephen Birarda <commit@birarda.com>
Date: Mon, 20 Jan 2014 08:56:43 -0800
Subject: [PATCH 17/18] add back linking of Winmm for DomainServer on WIN32

---
 domain-server/CMakeLists.txt | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/domain-server/CMakeLists.txt b/domain-server/CMakeLists.txt
index 213b37ac16..19cc2b73ff 100644
--- a/domain-server/CMakeLists.txt
+++ b/domain-server/CMakeLists.txt
@@ -32,4 +32,8 @@ add_custom_command(TARGET ${TARGET_NAME} POST_BUILD
 # link the shared hifi library
 include(${MACRO_DIR}/LinkHifiLibrary.cmake)
 link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
-link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
\ No newline at end of file
+link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
+
+IF (WIN32)
+  target_link_libraries(${TARGET_NAME} Winmm)
+ENDIF(WIN32)
\ No newline at end of file

From 0c5544780974516d94afa985483f9a98ce88e59b Mon Sep 17 00:00:00 2001
From: Brad Hefta-Gaub <brad@highfidelity.io>
Date: Mon, 20 Jan 2014 09:26:49 -0800
Subject: [PATCH 18/18] fix windows build

---
 assignment-client/CMakeLists.txt | 2 +-
 domain-server/CMakeLists.txt     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/assignment-client/CMakeLists.txt b/assignment-client/CMakeLists.txt
index d66a30957d..51a91621da 100644
--- a/assignment-client/CMakeLists.txt
+++ b/assignment-client/CMakeLists.txt
@@ -41,5 +41,5 @@ if (UNIX)
 endif (UNIX)
 
 IF (WIN32)
-	target_link_libraries(${TARGET_NAME} Winmm)
+	target_link_libraries(${TARGET_NAME} Winmm Ws2_32)
 ENDIF(WIN32)
diff --git a/domain-server/CMakeLists.txt b/domain-server/CMakeLists.txt
index 19cc2b73ff..db6048c48f 100644
--- a/domain-server/CMakeLists.txt
+++ b/domain-server/CMakeLists.txt
@@ -35,5 +35,5 @@ link_hifi_library(shared ${TARGET_NAME} ${ROOT_DIR})
 link_hifi_library(embedded-webserver ${TARGET_NAME} ${ROOT_DIR})
 
 IF (WIN32)
-  target_link_libraries(${TARGET_NAME} Winmm)
+  target_link_libraries(${TARGET_NAME} Winmm Ws2_32)
 ENDIF(WIN32)
\ No newline at end of file