httpclientconnection.h

// Copyright (c) 2018 IIS (The Internet Foundation in Sweden)
// Written by Göran Andersson <initgoran@gmail.com>
 
#pragma once
 
#include <map>
#include <sstream>
 
#include "httpconnection.h"
 
class HttpClientTask;
 
class HttpClientConnection : public HttpConnection {
public:
    // TODO: take a HttpHost as a parameter!
    HttpClientConnection(const std::string &label, HttpClientTask *task,
                         const std::string &hostname, uint16_t port,
                         const std::string &http_hostname = std::string(),
                         uint16_t iptype = 0,
                         struct addrinfo *local_addr = nullptr);
 
    PollState connected() final;
    PollState readData(char *buf, size_t len) final;
 
    PollState writeData() final;
 
    void doStreamResponse() {
        buffer_response = false;
    }
 
    unsigned int httpStatus() const {
        return response_http_status;
    }
 
    std::string contentType() const {
        auto p = http_response_headers.find("content-type");
        if (p == http_response_headers.end())
            return std::string();
        else
            return p->second;
    }
 
    const std::string &rawHttpHeader() const {
        return response_header;
    }
 
    const std::multimap<std::string, std::string> &responseHeaders() const {
        return http_response_headers;
    }
 
    size_t remainingContentLength() const {
        return bytes_left_to_read;
    }
 
    std::string contents() const {
        return buffer;
    }
 
    void get(const std::string &url);
 
    void post(const std::string &url, size_t len);
 
    // As above, but with first chunk of data available. Using this method
    // may save one call to doPost(), i.e. one less send system call.
    /*
    void post(const std::string &url, size_t len,
              const char *buf, size_t buffer_len, size_t lspace = 0);
    */
 
    void post(const std::string &url, const std::string &data);
 
    void ws_get(const std::string &url);
 
    void pass() {
        current_request = "pass";
    }
    bool idle() const {
        return current_request.empty() ||
            current_request == "pass";
    }
 
    static std::string urlencode(const std::string &val);
    static void addUrlPars(std::string &url,
                           const std::map<std::string, std::string> &pars);
    std::string cacheLabel() override;
 
    void setOwner(Task *new_owner) override;
private:
    std::string real_hostname;
    // A weak pointer to the owner task. Dangerous. However, the EventLoop will
    // kill all connections (i.e. us) before killing the owner task.
    HttpClientTask *owner_task;
    std::string proto_hostname;
    std::string current_request, current_uri;
 
    // Set if this is a websocket connection:
    std::string websocket_rkey;
 
    // Used when reading response headers:
    std::string response_header;
 
    const std::string::size_type max_header_length = 20000;
 
    bool response_header_complete = false;
    // Set when response headers are parsed:
    bool response_is_chunked;
    bool final_chunk;
    bool buffer_response = true;
    size_t bytes_left_to_read = 0;
    size_t bytes_left_to_post = 0;
    unsigned int response_http_status = 0;
    std::string chunked_info;
 
    bool parseResponseHeaders();
    std::multimap<std::string, std::string> http_response_headers;
    bool parseChunkedEncodingLength(char *&buf, size_t &len);
};