Add Status page:

* Make HTTP(S) requests on websocket ports reply with Status page
* Fix isWebsocketUpgrade to compare case insensitive
* Make websocket upgrades with no websocket protocols configured report error
* Create unit test for unauthorized requests and the status page

src/ripple/rpc/impl/ServerHandlerImp.cpp

@@ -39,8 +39,10 @@
 #include <ripple/resource/Fees.h>
 #include <ripple/rpc/impl/Tuning.h>
 #include <ripple/rpc/RPCHandler.h>
+#include <ripple/server/SimpleWriter.h>
 #include <beast/core/detail/base64.hpp>
 #include <beast/http/headers.hpp>
+#include <beast/http/string_body.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/optional.hpp>
@@ -50,6 +52,72 @@
 
 namespace ripple {
 
+// Returns `true` if the HTTP request is a Websockets Upgrade
+// http://en.wikipedia.org/wiki/HTTP/1.1_Upgrade_header#Use_with_WebSockets
+static
+bool
+isWebsocketUpgrade(
+    http_request_type const& request)
+{
+    if (is_upgrade(request))
+        return beast::detail::ci_equal(
+            request.headers["Upgrade"], "websocket");
+    return false;
+}
+
+static
+bool
+isStatusRequest(
+    http_request_type const& request)
+{
+    return request.version >= 11 && request.url == "/" &&
+            request.body.size() == 0 && request.method == "GET";
+}
+
+static
+Handoff
+unauthorizedResponse(
+    http_request_type const& request)
+{
+    using namespace beast::http;
+    Handoff handoff;
+    response_v1<string_body> msg;
+    msg.version = request.version;
+    msg.status = 401;
+    msg.reason = "Unauthorized";
+    msg.headers.insert("Server", BuildInfo::getFullVersionString());
+    msg.headers.insert("Content-Type", "text/html");
+    msg.body = "Invalid protocol.";
+    prepare(msg, beast::http::connection::close);
+    handoff.response = std::make_shared<SimpleWriter>(msg);
+    return handoff;
+}
+
+// VFALCO TODO Rewrite to use beast::http::headers
+static
+bool
+authorized (
+    Port const& port,
+    std::map<std::string, std::string> const& h)
+{
+    if (port.user.empty() || port.password.empty())
+        return true;
+
+    auto const it = h.find ("authorization");
+    if ((it == h.end ()) || (it->second.substr (0, 6) != "Basic "))
+        return false;
+    std::string strUserPass64 = it->second.substr (6);
+    boost::trim (strUserPass64);
+    std::string strUserPass = beast::detail::base64_decode (strUserPass64);
+    std::string::size_type nColon = strUserPass.find (":");
+    if (nColon == std::string::npos)
+        return false;
+    std::string strUser = strUserPass.substr (0, nColon);
+    std::string strPassword = strUserPass.substr (nColon + 1);
+    return strUser == port.user && strPassword == port.password;
+}
+
+
 ServerHandlerImp::ServerHandlerImp (Application& app, Stoppable& parent,
     boost::asio::io_service& io_service, JobQueue& jobQueue,
         NetworkOPs& networkOPs, Resource::Manager& resourceManager,
@@ -119,9 +187,9 @@ ServerHandlerImp::onHandoff (Session& session,
 {
     if(isWebsocketUpgrade(request))
     {
-        Handoff handoff;
         if(session.port().protocol.count("wss2") > 0)
         {
+            Handoff handoff;
             auto const ws = session.websocketUpgrade();
             auto is = std::make_shared<WSInfoSub>(m_networkOPs, ws);
             is->getConsumer() = requestInboundEndpoint(
@@ -135,7 +203,9 @@ ServerHandlerImp::onHandoff (Session& session,
         }
 
         if(session.port().protocol.count("wss") > 0)
-            return handoff; // Pass to websocket
+            return {}; // Pass to websocket
+
+        return unauthorizedResponse(request);
     }
 
     if(session.port().protocol.count("peer") > 0)
@@ -144,6 +214,9 @@ ServerHandlerImp::onHandoff (Session& session,
             std::move(request), remote_address);
     }
 
+    if (session.port().protocol.count("wss2") > 0 && isStatusRequest(request))
+        return statusResponse(request);
+
     // Pass to legacy onRequest
     return {};
 }
@@ -155,22 +228,30 @@ ServerHandlerImp::onHandoff (Session& session,
             boost::asio::ip::tcp::endpoint remote_address) ->
     Handoff
 {
-    Handoff handoff;
-    if(session.port().protocol.count("ws2") > 0 &&
-        isWebsocketUpgrade (request))
+    if(isWebsocketUpgrade(request))
     {
-        auto const ws = session.websocketUpgrade();
-        auto is = std::make_shared<WSInfoSub>(m_networkOPs, ws);
-        is->getConsumer() = requestInboundEndpoint(
-            m_resourceManager,
-                beast::IPAddressConversion::from_asio(remote_address),
-                    session.port(), is->user());
-        ws->appDefined = std::move(is);
-        ws->run();
-        handoff.moved = true;
+        if (session.port().protocol.count("ws2") > 0)
+        {
+            Handoff handoff;
+            auto const ws = session.websocketUpgrade();
+            auto is = std::make_shared<WSInfoSub>(m_networkOPs, ws);
+            is->getConsumer() = requestInboundEndpoint(
+                m_resourceManager, beast::IPAddressConversion::from_asio(
+                    remote_address), session.port(), is->user());
+            ws->appDefined = std::move(is);
+            ws->run();
+            handoff.moved = true;
+            return handoff;
+        }
+
+        return unauthorizedResponse(request);
     }
+
+    if (session.port().protocol.count("ws2") > 0 && isStatusRequest(request))
+        return statusResponse(request);
+
     // Otherwise pass to legacy onRequest or websocket
-    return handoff;
+    return {};
 }
 
 static inline
@@ -616,36 +697,40 @@ ServerHandlerImp::processRequest (Port const& port,
 
 //------------------------------------------------------------------------------
 
-// Returns `true` if the HTTP request is a Websockets Upgrade
-// http://en.wikipedia.org/wiki/HTTP/1.1_Upgrade_header#Use_with_WebSockets
-bool
-ServerHandlerImp::isWebsocketUpgrade (http_request_type const& request)
+/*  This response is used with load balancing.
+    If the server is overloaded, status 500 is reported. Otherwise status 200
+    is reported, meaning the server can accept more connections.
+*/
+Handoff
+ServerHandlerImp::statusResponse(
+    http_request_type const& request) const
 {
-    if (is_upgrade(request))
-        return request.headers["Upgrade"] == "websocket";
-    return false;
-}
-
-// VFALCO TODO Rewrite to use beast::http::headers
-bool
-ServerHandlerImp::authorized (Port const& port,
-    std::map<std::string, std::string> const& h)
-{
-    if (port.user.empty() || port.password.empty())
-        return true;
-
-    auto const it = h.find ("authorization");
-    if ((it == h.end ()) || (it->second.substr (0, 6) != "Basic "))
-        return false;
-    std::string strUserPass64 = it->second.substr (6);
-    boost::trim (strUserPass64);
-    std::string strUserPass = beast::detail::base64_decode (strUserPass64);
-    std::string::size_type nColon = strUserPass.find (":");
-    if (nColon == std::string::npos)
-        return false;
-    std::string strUser = strUserPass.substr (0, nColon);
-    std::string strPassword = strUserPass.substr (nColon + 1);
-    return strUser == port.user && strPassword == port.password;
+    using namespace beast::http;
+    Handoff handoff;
+    response_v1<string_body> msg;
+    std::string reason;
+    if (app_.serverOkay(reason))
+    {
+        msg.status = 200;
+        msg.reason = "OK";
+        msg.body = "<!DOCTYPE html><html><head><title>" + systemName() +
+            " Test page for rippled</title></head><body><h1>" +
+                systemName() + " Test</h1><p>This page shows rippled http(s) "
+                    "connectivity is working.</p></body></html>";
+    }
+    else
+    {
+        msg.status = 500;
+        msg.reason = "Internal Server Error";
+        msg.body = "<HTML><BODY>Server cannot accept clients: " +
+            reason + "</BODY></HTML>";
+    }
+    msg.version = request.version;
+    msg.headers.insert("Server", BuildInfo::getFullVersionString());
+    msg.headers.insert("Content-Type", "text/html");
+    prepare(msg, beast::http::connection::close);
+    handoff.response = std::make_shared<SimpleWriter>(msg);
+    return handoff;
 }
 
 //------------------------------------------------------------------------------