httpserverconnection.h

// Copyright (c) 2018 IIS (The Internet Foundation in Sweden)
// Written by Göran Andersson <initgoran@gmail.com>
 
#pragma once
 
#include <map>
 
#include "httpconnection.h"
 
class WebServerTask;
 
enum class HttpState {
    CLOSE,
    WAITING_FOR_REQUEST, SENDING_RESPONSE,
    READING_POST_DATA, WEBSOCKET
};
 
class HttpServerConnection : public HttpConnection {
public:
    HttpServerConnection(const std::string &label, WebServerTask *task, int fd,
                         const char *ip, uint16_t port);
    virtual ~HttpServerConnection() override;
    PollState connected() final {
        return PollState::READ;
    }
    PollState readData(char *buf, size_t len) final;
    //PollState unexpectedData(char *, size_t ) override;
    PollState writeData() override;
 
    bool hasQueryPar(const std::string &name) const;
 
    void eraseQueryPar(const std::string &name) {
        current_query_pars.erase(name);
    }
 
    std::string getQueryVal(const std::string &name) const;
 
    const std::multimap<std::string, std::string> &currentQueryPars() const {
        return current_query_pars;
    }
 
    std::map<std::string, std::string> currentRequestCookies() const;
 
    std::string cookieVal(const std::string &name) const;
 
    std::string getHeaderVal(const std::string &name) const;
 
    typedef std::multimap<std::string, std::string>::const_iterator Hit;
    std::pair<Hit, Hit> getHeaderVals(const std::string &name) const {
            return http_request_headers.equal_range(name);
    }
 
    size_t sendHttpResponse(const std::string &headers,
                            const std::string &mime,
                            const std::string &contents);
 
    size_t sendHttpResponseHeader(const std::string &headers,
                                  const std::string &mime,
                                  size_t content_length);
 
    size_t sendChunkedResponseHeader(const std::string &headers,
                                     const std::string &mime);
 
    size_t sendChunk(const std::string &content);
 
    size_t chunkedResponseComplete();
 
    bool sendingChunkedResponse() const {
        return sending_chunked_response;
    }
 
#ifdef USE_WEBROOT
    bool prepareFileResponse(const std::string &url);
 
    HttpState sendHttpFileResponse(const std::string &headers,
                                   const std::string &mime);
 
#endif
 
    const std::string &currentUri() const {
        return current_uri;
    }
 
    const std::string currentFullUrl() const {
        if (current_query_string.empty())
            return current_uri;
        return current_uri + '?' + current_query_string;
    }
 
    const std::string &currentQueryString() const {
        return current_query_string;
    }
 
    size_t remainingPostData() const {
        return remaining_post_data;
    }
 
    void bufferPostData() {
        buffer_post_data = true;
    }
 
    void notifyWsHandshake() {
        notify_after_ws_handshake = true;
    }
 
    void setOwner(Task *new_owner) override;
 
    std::string currentRequest() const {
        return current_request;
    }
private:
    // A weak pointer to the owner task. Dangerous. However, the EventLoop will
    // kill all connections (i.e. us) before killing the owner task.
    WebServerTask *owner_task;
    HttpState state = HttpState::WAITING_FOR_REQUEST;
    std::string current_request;
    std::multimap<std::string, std::string> http_request_headers;
    std::string current_method, current_uri;
    std::string current_query_string;
    std::multimap<std::string, std::string> current_query_pars;
    static void get_all_parameters(const char *qpos,
        std::multimap<std::string, std::string> &pars);
 
    // Will be set when sending a response with known Content-Length:
    size_t remaining_bytes;
 
#ifdef USE_WEBROOT
    // Will be set if sending_static_file is true:
    int static_file_fd;
 
    // Will be true when sending a static file:
    bool sending_static_file = false;
#endif
 
    // Will be true when sending chunked response:
    bool sending_chunked_response = false;
 
    // If set to true, the owner will be notified after handshake:
    bool notify_after_ws_handshake = false;
 
    // Will be set in state READING_POST_DATA:
    bool buffer_post_data;
    size_t remaining_post_data;
 
    bool parse_request();
    PollState got_post_data(const char *buf, size_t len);
    PollState check_buffer();
};