tomFlowee
b4a3da2642
These are technically static libs, but not in any way shared libs. They are used solely only by this repo and really only by the hub. Most important, no header files are installed and basically none of the normal rules for reusable libraries are applied to these files.
160 lines
4.4 KiB
C++
160 lines
4.4 KiB
C++
/*
|
|
* This file is part of the Flowee project
|
|
* Copyright (C) 2015 The Bitcoin Core developers
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef FLOWEE_HTTPSERVER_H
|
|
#define FLOWEE_HTTPSERVER_H
|
|
|
|
#include <string>
|
|
#include <cstdint>
|
|
#include <boost/thread.hpp>
|
|
#include <boost/scoped_ptr.hpp>
|
|
#include <boost/function.hpp>
|
|
|
|
struct evhttp_request;
|
|
struct event_base;
|
|
class CService;
|
|
class HTTPRequest;
|
|
|
|
/** Initialize HTTP server.
|
|
* Call this before RegisterHTTPHandler or EventBase().
|
|
*/
|
|
bool InitHTTPServer();
|
|
/** Start HTTP server.
|
|
* This is separate from InitHTTPServer to give users race-condition-free time
|
|
* to register their handlers between InitHTTPServer and StartHTTPServer.
|
|
*/
|
|
void StartHTTPServer();
|
|
/** 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.
|
|
* deleteWhenTriggered deletes this event object after the event is triggered (and the handler called)
|
|
* handler is the handler to call when the event is triggered.
|
|
*/
|
|
HTTPEvent(struct event_base* base, bool deleteWhenTriggered, const boost::function<void(void)>& 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);
|
|
|
|
bool deleteWhenTriggered;
|
|
boost::function<void(void)> handler;
|
|
private:
|
|
struct event* ev;
|
|
};
|
|
|
|
#endif
|