https_session.h

Go to the documentation of this file.

 
#ifndef CPPSERVER_HTTP_HTTPS_SESSION_H
#define CPPSERVER_HTTP_HTTPS_SESSION_H
 
#include "http_request.h"
#include "http_response.h"
 
#include "cache/filecache.h"
#include "server/asio/ssl_session.h"
 
namespace CppServer {
namespace HTTP {
 
class HTTPSServer;
 
 
class HTTPSSession : public Asio::SSLSession
{
public:
    explicit HTTPSSession(const std::shared_ptr<HTTPSServer>& server);
    HTTPSSession(const HTTPSSession&) = delete;
    HTTPSSession(HTTPSSession&&) = delete;
    virtual ~HTTPSSession() = default;
 
    HTTPSSession& operator=(const HTTPSSession&) = delete;
    HTTPSSession& operator=(HTTPSSession&&) = delete;
 
    CppCommon::FileCache& cache() noexcept { return _cache; }
    const CppCommon::FileCache& cache() const noexcept { return _cache; }
 
    HTTPResponse& response() noexcept { return _response; }
    const HTTPResponse& response() const noexcept { return _response; }
 
 
    size_t SendResponse() { return SendResponse(_response); }
 
    size_t SendResponse(const HTTPResponse& response) { return Send(response.cache()); }
 
 
    size_t SendResponseBody(std::string_view body) { return Send(body); }
 
    size_t SendResponseBody(const void* buffer, size_t size) { return Send(buffer, size); }
 
 
    size_t SendResponse(const CppCommon::Timespan& timeout) { return SendResponse(_response, timeout); }
 
    size_t SendResponse(const HTTPResponse& response, const CppCommon::Timespan& timeout) { return Send(response.cache(), timeout); }
 
 
    size_t SendResponseBody(std::string_view body, const CppCommon::Timespan& timeout) { return Send(body, timeout); }
 
    size_t SendResponseBody(const void* buffer, size_t size, const CppCommon::Timespan& timeout) { return Send(buffer, size, timeout); }
 
 
    bool SendResponseAsync() { return SendResponseAsync(_response); }
 
    bool SendResponseAsync(const HTTPResponse& response) { return SendAsync(response.cache()); }
 
 
    bool SendResponseBodyAsync(std::string_view body) { return SendAsync(body); }
 
    bool SendResponseBodyAsync(const void* buffer, size_t size) { return SendAsync(buffer, size); }
 
protected:
    void onReceived(const void* buffer, size_t size) override;
    void onDisconnected() override;
 
 
    virtual void onReceivedRequestHeader(const HTTPRequest& request) {}
 
 
    virtual void onReceivedRequest(const HTTPRequest& request) {}
 
    virtual void onReceivedCachedRequest(const HTTPRequest& request, std::string_view content) { SendAsync(content); }
 
 
    virtual void onReceivedRequestError(const HTTPRequest& request, const std::string& error) {}
 
protected:
    HTTPRequest _request;
    HTTPResponse _response;
 
private:
    // Static content cache
    CppCommon::FileCache& _cache;
 
    void onReceivedRequestInternal(const HTTPRequest& request);
};
 
} // namespace HTTP
} // namespace CppServer
 
#endif // CPPSERVER_HTTP_HTTPS_SESSION_H