src/httpserver.h

   1 // Copyright (c) 2015 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #ifndef BITCOIN_HTTPSERVER_H
   6 #define BITCOIN_HTTPSERVER_H
   7
   8 #include <string>
   9 #include <stdint.h>
  10 #ifdef _WIN32
  11 #undef __cpuid
  12 #endif
  13 #include <boost/thread.hpp>
  14 #include <boost/scoped_ptr.hpp>
  15 #include <boost/function.hpp>
  16
  17 static const int DEFAULT_HTTP_THREADS=4;
  18 static const int DEFAULT_HTTP_WORKQUEUE=16;
  19 static const int DEFAULT_HTTP_SERVER_TIMEOUT=30;
  20
  21 struct evhttp_request;
  22 struct event_base;
  23 class CService;
  24 class HTTPRequest;
  25
  26 /** Initialize HTTP server.
  27  * Call this before RegisterHTTPHandler or EventBase().
  28  */
  29 bool InitHTTPServer();
  30 /** Start HTTP server.
  31  * This is separate from InitHTTPServer to give users race-condition-free time
  32  * to register their handlers between InitHTTPServer and StartHTTPServer.
  33  */
  34 bool StartHTTPServer();
  35 /** Interrupt HTTP server threads */
  36 void InterruptHTTPServer();
  37 /** Stop HTTP server */
  38 void StopHTTPServer();
  39
  40 /** Handler for requests to a certain HTTP path */
  41 typedef boost::function<void(HTTPRequest* req, const std::string &)> HTTPRequestHandler;
  42 /** Register handler for prefix.
  43  * If multiple handlers match a prefix, the first-registered one will
  44  * be invoked.
  45  */
  46 void RegisterHTTPHandler(const std::string &prefix, bool exactMatch, const HTTPRequestHandler &handler);
  47 /** Unregister handler for prefix */
  48 void UnregisterHTTPHandler(const std::string &prefix, bool exactMatch);
  49
  50 /** Return evhttp event base. This can be used by submodules to
  51  * queue timers or custom events.
  52  */
  53 struct event_base* EventBase();
  54
  55 /** In-flight HTTP request.
  56  * Thin C++ wrapper around evhttp_request.
  57  */
  58 class HTTPRequest
  59 {
  60 private:
  61     struct evhttp_request* req;
  62
  63     // For test access
  64 protected:
  65     bool replySent;
  66
  67 public:
  68     HTTPRequest(struct evhttp_request* req);
  69     virtual ~HTTPRequest();
  70
  71     enum RequestMethod {
  72         UNKNOWN,
  73         GET,
  74         POST,
  75         HEAD,
  76         PUT
  77     };
  78
  79     /** Get requested URI.
  80      */
  81     std::string GetURI();
  82
  83     /** Get CService (address:ip) for the origin of the http request.
  84      */
  85     virtual CService GetPeer();
  86
  87     /** Get request method.
  88      */
  89     virtual RequestMethod GetRequestMethod();
  90
  91     /**
  92      * Get the request header specified by hdr, or an empty string.
  93      * Return an pair (isPresent,string).
  94      */
  95     virtual std::pair<bool, std::string> GetHeader(const std::string& hdr);
  96
  97     /**
  98      * Read request body.
  99      *
 100      * @note As this consumes the underlying buffer, call this only once.
 101      * Repeated calls will return an empty string.
 102      */
 103     std::string ReadBody();
 104
 105     /**
 106      * Write output header.
 107      *
 108      * @note call this before calling WriteErrorReply or Reply.
 109      */
 110     virtual void WriteHeader(const std::string& hdr, const std::string& value);
 111
 112     /**
 113      * Write HTTP reply.
 114      * nStatus is the HTTP status code to send.
 115      * strReply is the body of the reply. Keep it empty to send a standard message.
 116      *
 117      * @note Can be called only once. As this will give the request back to the
 118      * main thread, do not call any other HTTPRequest methods after calling this.
 119      */
 120     virtual void WriteReply(int nStatus, const std::string& strReply = "");
 121 };
 122
 123 /** Event handler closure.
 124  */
 125 class HTTPClosure
 126 {
 127 public:
 128     virtual void operator()() = 0;
 129     virtual ~HTTPClosure() {}
 130 };
 131
 132 /** Event class. This can be used either as an cross-thread trigger or as a timer.
 133  */
 134 class HTTPEvent
 135 {
 136 public:
 137     /** Create a new event.
 138      * deleteWhenTriggered deletes this event object after the event is triggered (and the handler called)
 139      * handler is the handler to call when the event is triggered.
 140      */
 141     HTTPEvent(struct event_base* base, bool deleteWhenTriggered, const boost::function<void(void)>& handler);
 142     ~HTTPEvent();
 143
 144     /** Trigger the event. If tv is 0, trigger it immediately. Otherwise trigger it after
 145      * the given time has elapsed.
 146      */
 147     void trigger(struct timeval* tv);
 148
 149     bool deleteWhenTriggered;
 150     boost::function<void(void)> handler;
 151 private:
 152     struct event* ev;
 153 };
 154
 155 #endif // BITCOIN_HTTPSERVER_H