Implement NetworkManager

For now there are two methods:

- `NETWORK:IsUrlAllowed()`: Check whether access to a certain URL is allowed.
- `NETWORK:HttpRequest()`: Perform an HTTP request.

By default access to the network is disabled for all target hosts. It
can be enabled by setting `HttpEnable=1` in the preferences. Individual
hosts have to be added to `HttpAllowHosts` as a comma separated list to
allow access.

See included docs for more details on usage.

extern/IXWebSocket-11.3.2/ixwebsocket/IXWebSocketServer.cpp

@@ -0,0 +1,229 @@
+/*
+ *  IXWebSocketServer.cpp
+ *  Author: Benjamin Sergeant
+ *  Copyright (c) 2018 Machine Zone, Inc. All rights reserved.
+ */
+
+#include "IXWebSocketServer.h"
+
+#include "IXNetSystem.h"
+#include "IXSetThreadName.h"
+#include "IXSocketConnect.h"
+#include "IXWebSocket.h"
+#include "IXWebSocketTransport.h"
+#include <future>
+#include <sstream>
+#include <string.h>
+
+namespace ix
+{
+    const int WebSocketServer::kDefaultHandShakeTimeoutSecs(3); // 3 seconds
+    const bool WebSocketServer::kDefaultEnablePong(true);
+
+    WebSocketServer::WebSocketServer(int port,
+                                     const std::string& host,
+                                     int backlog,
+                                     size_t maxConnections,
+                                     int handshakeTimeoutSecs,
+                                     int addressFamily)
+        : SocketServer(port, host, backlog, maxConnections, addressFamily)
+        , _handshakeTimeoutSecs(handshakeTimeoutSecs)
+        , _enablePong(kDefaultEnablePong)
+        , _enablePerMessageDeflate(true)
+    {
+    }
+
+    WebSocketServer::~WebSocketServer()
+    {
+        stop();
+    }
+
+    void WebSocketServer::stop()
+    {
+        stopAcceptingConnections();
+
+        auto clients = getClients();
+        for (auto client : clients)
+        {
+            client->close();
+        }
+
+        SocketServer::stop();
+    }
+
+    void WebSocketServer::enablePong()
+    {
+        _enablePong = true;
+    }
+
+    void WebSocketServer::disablePong()
+    {
+        _enablePong = false;
+    }
+
+    void WebSocketServer::disablePerMessageDeflate()
+    {
+        _enablePerMessageDeflate = false;
+    }
+
+    void WebSocketServer::setOnConnectionCallback(const OnConnectionCallback& callback)
+    {
+        _onConnectionCallback = callback;
+    }
+
+    void WebSocketServer::setOnClientMessageCallback(const OnClientMessageCallback& callback)
+    {
+        _onClientMessageCallback = callback;
+    }
+
+    void WebSocketServer::handleConnection(std::unique_ptr<Socket> socket,
+                                           std::shared_ptr<ConnectionState> connectionState)
+    {
+        setThreadName("WebSocketServer::" + connectionState->getId());
+
+        auto webSocket = std::make_shared<WebSocket>();
+        if (_onConnectionCallback)
+        {
+            _onConnectionCallback(webSocket, connectionState);
+
+            if (!webSocket->isOnMessageCallbackRegistered())
+            {
+                logError("WebSocketServer Application developer error: Server callback improperly "
+                         "registerered.");
+                logError("Missing call to setOnMessageCallback inside setOnConnectionCallback.");
+                connectionState->setTerminated();
+                return;
+            }
+        }
+        else if (_onClientMessageCallback)
+        {
+            WebSocket* webSocketRawPtr = webSocket.get();
+            webSocket->setOnMessageCallback(
+                [this, webSocketRawPtr, connectionState](const WebSocketMessagePtr& msg) {
+                    _onClientMessageCallback(connectionState, *webSocketRawPtr, msg);
+                });
+        }
+        else
+        {
+            logError(
+                "WebSocketServer Application developer error: No server callback is registerered.");
+            logError("Missing call to setOnConnectionCallback or setOnClientMessageCallback.");
+            connectionState->setTerminated();
+            return;
+        }
+
+        webSocket->disableAutomaticReconnection();
+
+        if (_enablePong)
+        {
+            webSocket->enablePong();
+        }
+        else
+        {
+            webSocket->disablePong();
+        }
+
+        // Add this client to our client set
+        {
+            std::lock_guard<std::mutex> lock(_clientsMutex);
+            _clients.insert(webSocket);
+        }
+
+        auto status = webSocket->connectToSocket(
+            std::move(socket), _handshakeTimeoutSecs, _enablePerMessageDeflate);
+        if (status.success)
+        {
+            // Process incoming messages and execute callbacks
+            // until the connection is closed
+            webSocket->run();
+        }
+        else
+        {
+            std::stringstream ss;
+            ss << "WebSocketServer::handleConnection() HTTP status: " << status.http_status
+               << " error: " << status.errorStr;
+            logError(ss.str());
+        }
+
+        webSocket->setOnMessageCallback(nullptr);
+
+        // Remove this client from our client set
+        {
+            std::lock_guard<std::mutex> lock(_clientsMutex);
+            if (_clients.erase(webSocket) != 1)
+            {
+                logError("Cannot delete client");
+            }
+        }
+
+        connectionState->setTerminated();
+    }
+
+    std::set<std::shared_ptr<WebSocket>> WebSocketServer::getClients()
+    {
+        std::lock_guard<std::mutex> lock(_clientsMutex);
+        return _clients;
+    }
+
+    size_t WebSocketServer::getConnectedClientsCount()
+    {
+        std::lock_guard<std::mutex> lock(_clientsMutex);
+        return _clients.size();
+    }
+
+    //
+    // Classic servers
+    //
+    void WebSocketServer::makeBroadcastServer()
+    {
+        setOnClientMessageCallback([this](std::shared_ptr<ConnectionState> connectionState,
+                                          WebSocket& webSocket,
+                                          const WebSocketMessagePtr& msg) {
+            auto remoteIp = connectionState->getRemoteIp();
+            if (msg->type == ix::WebSocketMessageType::Message)
+            {
+                for (auto&& client : getClients())
+                {
+                    if (client.get() != &webSocket)
+                    {
+                        client->send(msg->str, msg->binary);
+
+                        // Make sure the OS send buffer is flushed before moving on
+                        do
+                        {
+                            std::chrono::duration<double, std::milli> duration(500);
+                            std::this_thread::sleep_for(duration);
+                        } while (client->bufferedAmount() != 0);
+                    }
+                }
+            }
+        });
+    }
+
+    bool WebSocketServer::listenAndStart()
+    {
+        auto res = listen();
+        if (!res.first)
+        {
+            return false;
+        }
+
+        start();
+        return true;
+    }
+
+    int WebSocketServer::getHandshakeTimeoutSecs()
+    {
+        return _handshakeTimeoutSecs;
+    }
+
+    bool WebSocketServer::isPongEnabled()
+    {
+        return _enablePong;
+    }
+
+    bool WebSocketServer::isPerMessageDeflateEnabled()
+    {
+        return _enablePerMessageDeflate;
+    }
+} // namespace ix