ppsspp/Common/Net/HTTPServer.h

#pragma once

#include <functional>
#include <map>
#include <memory>
#include <vector>

#include <retro_atomic.h>

#include "Common/Net/HTTPHeaders.h"
#include "Common/Net/Resolve.h"
#include "Common/Thread/Thread.h"

// One thread per request. Run() and the destructor belong to one thread (the accept loop's);
// the destructor joins every worker, so handlers must finish on their own or be woken first.
class NewThreadExecutor {
public:
	~NewThreadExecutor();
	void Run(std::function<void()> func);

private:
	// Joins the workers that have finished.
	void Prune();

	struct Worker {
		Thread thread;
		// The worker's last act.
		retro_atomic_int_t done{ 0 };
	};
	std::vector<std::unique_ptr<Worker>> workers_;
};

namespace net {

class CancelToken;
class InputSink;
class OutputSink;

}  // namespace net

namespace http {

class ServerRequest {
public:
	ServerRequest(int fd);
	~ServerRequest();

	std::string_view resource() const {
		return header_.resource;
	}

	RequestHeader::Method Method() const {
		return header_.method;
	}

	const RequestHeader &Header() const {
		return header_;
	}

	bool GetParamValue(const char *param_name, std::string *value) const {
		return header_.GetParamValue(param_name, value);
	}
	// Use lowercase.
	bool GetHeader(const char *name, std::string *value) const {
		return header_.GetOther(name, value);
	}

	net::InputSink *In() const { return in_; }
	net::OutputSink *Out() const { return out_; }

	// TODO: Remove, in favor of PartialWrite and friends.
	int fd() const { return fd_; }

	void WritePartial() const;
	void Write();
	void Close();

	bool IsOK() const { return fd_ > 0; }

	// If size is negative, no Content-Length: line is written.
	void WriteHttpResponseHeader(const char *ver, int status, int64_t size = -1, const char *mimeType = nullptr, const char *otherHeaders = nullptr) const;

private:
	net::InputSink *in_;
	net::OutputSink *out_;
	RequestHeader header_;
	int fd_;
};

// Register handlers on this class to serve stuff.
class Server {
public:
	// Takes ownership.
	Server(NewThreadExecutor *executor);
	virtual ~Server();

	typedef std::function<void(const ServerRequest &)> UrlHandlerFunc;
	typedef std::map<std::string, UrlHandlerFunc, std::less<>> UrlHandlerMap;

	// Runs forever, serving request. If you want to do something else than serve pages,
	// better put this on a thread. Returns false if failed to start serving, never
	// returns if successful.
	bool Run(int port);
	// Blocks until a connection arrives and hands it to the executor, or until cancel is set.
	// Returns false when cancelled or on error.
	bool RunSlice(const net::CancelToken *cancel);
	bool Listen(int port, const char *reason, net::DNSType type = net::DNSType::ANY);
	void Stop();

	void RegisterHandler(const char *url_path, UrlHandlerFunc handler);
	void SetFallbackHandler(UrlHandlerFunc handler);

	// If you want to customize things at a lower level than just a simple path handler,
	// then inherit and override this. Implementations should forward to HandleRequestDefault
	// if they don't recognize the url.
	virtual void HandleRequest(const ServerRequest &request);

	int ListenerSocket() const {
		return listenerSock_;
	}
	int Port() const {
		return port_;
	}
	const std::string &LocalAddress() const {
		return localAddress_;
	}

private:
	bool Listen6(int port, bool ipv6_only, const char *reason);
	bool Listen4(int port, const char *reason);

	void HandleConnection(int conn_fd);

	// Things like default 404, etc.
	void HandleRequestDefault(const ServerRequest &request);

	// Neat built-in handlers that are tied to the server.
	void HandleListing(const ServerRequest &request);
	void Handle404(const ServerRequest &request);

	int listenerSock_;
	int port_ = 0;
	std::string localAddress_;

	UrlHandlerMap handlers_;
	UrlHandlerFunc fallback_;

	NewThreadExecutor *executor_;
};

}  // namespace http