evhttpd implementation

- *Replace usage of boost::asio with [libevent2](http://libevent.org/)*.
boost::asio is not part of C++11, so unlike other boost there is no
forwards-compatibility reason to stick with it. Together with #4738 (convert
json_spirit to UniValue), this rids Bitcoin Core of the worst offenders with
regard to compile-time slowness.

- *Replace spit-and-duct-tape http server with evhttp*. Front-end http handling
is handled by libevent, a work queue (with configurable depth and parallelism)
is used to handle application requests.

- *Wrap HTTP request in C++ class*; this makes the application code mostly
HTTP-server-neutral

- *Refactor RPC to move all http-specific code to a separate file*.
Theoreticaly this can allow building without HTTP server but with another RPC
backend, e.g. Qt's debug console (currently not implemented) or future RPC
mechanisms people may want to use.

- *HTTP dispatch mechanism*; services (e.g., RPC, REST) register which URL
paths they want to handle.

By using a proven, high-performance asynchronous networking library (also used
by Tor) and HTTP server, problems such as #5674, #5655, #344 should be avoided.

What works? bitcoind, bitcoin-cli, bitcoin-qt. Unit tests and RPC/REST tests
pass. The aim for now is everything but SSL support.

Configuration options:

- `-rpcthreads`: repurposed as "number of  work handler threads". Still
defaults to 4.

- `-rpcworkqueue`: maximum depth of work queue. When this is reached, new
requests will return a 500 Internal Error.

- `-rpctimeout`: inactivity time, in seconds, after which to disconnect a
client.

- `-debug=http`: low-level http activity logging

src/httpserver.h

@@ -0,0 +1,138 @@
+// Copyright (c) 2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_HTTPSERVER_H
+#define BITCOIN_HTTPSERVER_H
+
+#include <string>
+#include <stdint.h>
+#include <boost/thread.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/function.hpp>
+
+struct evhttp_request;
+struct event_base;
+class CService;
+class HTTPRequest;
+
+/** Start HTTP server */
+bool StartHTTPServer(boost::thread_group& threadGroup);
+/** Interrupt HTTP server threads */
+void InterruptHTTPServer();
+/** Stop HTTP server */
+void StopHTTPServer();
+
+/** Handler for requests to a certain HTTP path */
+typedef boost::function<void(HTTPRequest* req, const std::string &)> HTTPRequestHandler;
+/** Register handler for prefix.
+ * If multiple handlers match a prefix, the first-registered one will
+ * be invoked.
+ */
+void RegisterHTTPHandler(const std::string &prefix, bool exactMatch, const HTTPRequestHandler &handler);
+/** Unregister handler for prefix */
+void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch);
+
+/** Return evhttp event base. This can be used by submodules to
+ * queue timers or custom events.
+ */
+struct event_base* EventBase();
+
+/** In-flight HTTP request.
+ * Thin C++ wrapper around evhttp_request.
+ */
+class HTTPRequest
+{
+private:
+    struct evhttp_request* req;
+    bool replySent;
+
+public:
+    HTTPRequest(struct evhttp_request* req);
+    ~HTTPRequest();
+
+    enum RequestMethod {
+        UNKNOWN,
+        GET,
+        POST,
+        HEAD,
+        PUT
+    };
+
+    /** Get requested URI.
+     */
+    std::string GetURI();
+
+    /** Get CService (address:ip) for the origin of the http request.
+     */
+    CService GetPeer();
+
+    /** Get request method.
+     */
+    RequestMethod GetRequestMethod();
+
+    /**
+     * Get the request header specified by hdr, or an empty string.
+     * Return an pair (isPresent,string).
+     */
+    std::pair<bool, std::string> GetHeader(const std::string& hdr);
+
+    /**
+     * Read request body.
+     *
+     * @note As this consumes the underlying buffer, call this only once.
+     * Repeated calls will return an empty string.
+     */
+    std::string ReadBody();
+
+    /**
+     * Write output header.
+     *
+     * @note call this before calling WriteErrorReply or Reply.
+     */
+    void WriteHeader(const std::string& hdr, const std::string& value);
+
+    /**
+     * Write HTTP reply.
+     * nStatus is the HTTP status code to send.
+     * strReply is the body of the reply. Keep it empty to send a standard message.
+     *
+     * @note Can be called only once. As this will give the request back to the
+     * main thread, do not call any other HTTPRequest methods after calling this.
+     */
+    void WriteReply(int nStatus, const std::string& strReply = "");
+};
+
+/** Event handler closure.
+ */
+class HTTPClosure
+{
+public:
+    virtual void operator()() = 0;
+    virtual ~HTTPClosure() {}
+};
+
+/** Event class. This can be used either as an cross-thread trigger or as a timer.
+ */
+class HTTPEvent
+{
+public:
+    /** Create a new event */
+    HTTPEvent(struct event_base* base, bool deleteWhenTriggered, HTTPClosure* handler);
+    ~HTTPEvent();
+
+    /** Trigger the event. If tv is 0, trigger it immediately. Otherwise trigger it after
+     * the given time has elapsed.
+     */
+    void trigger(struct timeval* tv);
+
+    /** Internal function for handling, do not call directly */
+    void _handle();
+
+private:
+    bool deleteWhenTriggered;
+    struct event* ev;
+    boost::scoped_ptr<HTTPClosure> handler;
+};
+
+#endif // BITCOIN_HTTPSERVER_H