libhv/http/HttpMessage.cpp

#include "HttpMessage.h"

#include <string.h>

#include "htime.h"
#include "hlog.h"
#include "hurl.h"
#include "base64.h"

using namespace hv;

http_headers DefaultHeaders;
http_body    NoBody;
HttpCookie   NoCookie;
char HttpMessage::s_date[32] = {0};

HttpCookie::HttpCookie() {
    init();
}

void HttpCookie::init()  {
    max_age = 0;
    secure = false;
    httponly = false;
    samesite = Default;
    priority = NotSet;
}

void HttpCookie::reset() {
    init();
    name.clear();
    value.clear();
    domain.clear();
    path.clear();
    expires.clear();
    kv.clear();
}

bool HttpCookie::parse(const std::string& str) {
    std::stringstream ss;
    ss << str;
    std::string line;
    std::string::size_type pos;
    std::string key;
    std::string val;

    reset();
    while (std::getline(ss, line, ';')) {
        pos = line.find_first_of('=');
        if (pos != std::string::npos) {
            key = trim(line.substr(0, pos));
            val = trim(line.substr(pos+1));
            const char* pkey = key.c_str();
            if (stricmp(pkey, "Domain") == 0) {
                domain = val;
            }
            else if (stricmp(pkey, "Path") == 0) {
                path = val;
            }
            else if (stricmp(pkey, "Expires") == 0) {
                expires = val;
            }
            else if (stricmp(pkey, "Max-Age") == 0) {
                max_age = atoi(val.c_str());
            }
            else if (stricmp(pkey, "SameSite") == 0) {
                samesite =  stricmp(val.c_str(), "Strict") == 0 ? HttpCookie::SameSite::Strict :
                            stricmp(val.c_str(), "Lax")    == 0 ? HttpCookie::SameSite::Lax    :
                            stricmp(val.c_str(), "None")   == 0 ? HttpCookie::SameSite::None   :
                                                                  HttpCookie::SameSite::Default;
            }
            else if (stricmp(pkey, "Priority") == 0) {
                priority =  stricmp(val.c_str(), "Low")    == 0 ? HttpCookie::Priority::Low    :
                            stricmp(val.c_str(), "Medium") == 0 ? HttpCookie::Priority::Medium :
                            stricmp(val.c_str(), "High")   == 0 ? HttpCookie::Priority::High   :
                                                                  HttpCookie::Priority::NotSet ;
            }
            else {
                if (name.empty()) {
                    name = key;
                    value = val;
                }
                kv[key] = val;
            }
        } else {
            key = trim(line);
            const char* pkey = key.c_str();
            if (stricmp(pkey, "Secure") == 0) {
                secure = true;
            }
            else if (stricmp(pkey, "HttpOnly") == 0) {
                httponly = true;
            }
            else {
                hlogi("Cookie Unrecognized key '%s'", key.c_str());
            }
        }

    }
    return !name.empty();
}

std::string HttpCookie::dump() const {
    assert(!name.empty() || !kv.empty());
    std::string res;

    if (!name.empty()) {
        res = name;
        res += "=";
        res += value;
    }

    for (auto& pair : kv) {
        if (pair.first == name) continue;
        if (!res.empty()) res += "; ";
        res += pair.first;
        res += "=";
        res += pair.second;
    }

    if (!domain.empty()) {
        res += "; Domain=";
        res += domain;
    }

    if (!path.empty()) {
        res += "; Path=";
        res += path;
    }

    if (max_age > 0) {
        res += "; Max-Age=";
        res += hv::to_string(max_age);
    } else if (!expires.empty()) {
        res += "; Expires=";
        res += expires;
    }

    if (samesite != HttpCookie::SameSite::Default) {
        res += "; SameSite=";
        res += samesite == HttpCookie::SameSite::Strict ? "Strict" :
               samesite == HttpCookie::SameSite::Lax    ? "Lax"    :
                                                          "None"   ;
    }

    if (priority != HttpCookie::Priority::NotSet) {
        res += "; Priority=";
        res += priority == HttpCookie::Priority::Low    ? "Low"    :
               priority == HttpCookie::Priority::Medium ? "Medium" :
                                                          "High"   ;
    }

    if (secure) {
        res += "; Secure";
    }

    if (httponly) {
        res += "; HttpOnly";
    }

    return res;
}

HttpMessage::HttpMessage() {
    type = HTTP_BOTH;
    Init();
}

HttpMessage::~HttpMessage() {

}

void HttpMessage::Init() {
    http_major = 1;
    http_minor = 1;
    content = NULL;
    content_length = 0;
    content_type = CONTENT_TYPE_NONE;
}

void HttpMessage::Reset() {
    Init();
    headers.clear();
    cookies.clear();
    body.clear();
#ifndef WITHOUT_HTTP_CONTENT
    json.clear();
    form.clear();
    kv.clear();
#endif
}

#ifndef WITHOUT_HTTP_CONTENT
// NOTE: json ignore number/string, 123/"123"

std::string HttpMessage::GetString(const char* key, const std::string& defvalue) {
    switch (ContentType()) {
    case APPLICATION_JSON:
    {
        if (json.empty()) {
            ParseBody();
        }
        if (!json.is_object()) {
            return defvalue;
        }
        const auto& value = json[key];
        if (value.is_string()) {
            return value;
        }
        else if (value.is_number()) {
            return hv::to_string(value);
        }
        else if (value.is_boolean()) {
            bool b = value;
            return b ? "true" : "false";
        }
        else {
            return defvalue;
        }
    }
        break;
    case MULTIPART_FORM_DATA:
    {
        if (form.empty()) {
            ParseBody();
        }
        auto iter = form.find(key);
        if (iter != form.end()) {
            return iter->second.content;
        }
    }
        break;
    case APPLICATION_URLENCODED:
    {
        if (kv.empty()) {
            ParseBody();
        }
        auto iter = kv.find(key);
        if (iter != kv.end()) {
            return iter->second;
        }
    }
        break;
    default:
        break;
    }
    return defvalue;
}

template<>
HV_EXPORT int64_t HttpMessage::Get(const char* key, int64_t defvalue) {
    if (ContentType() == APPLICATION_JSON) {
        if (json.empty()) {
            ParseBody();
        }
        if (!json.is_object()) {
            return defvalue;
        }
        const auto& value = json[key];
        if (value.is_number()) {
            return value;
        }
        else if (value.is_string()) {
            std::string str = value;
            return atoll(str.c_str());
        }
        else if (value.is_boolean()) {
            bool b = value;
            return b ? 1 : 0;
        }
        else {
            return defvalue;
        }
    }
    else {
        std::string str = GetString(key);
        return str.empty() ? defvalue : atoll(str.c_str());
    }
}

template<>
HV_EXPORT int HttpMessage::Get(const char* key, int defvalue) {
    return (int)Get<int64_t>(key, defvalue);
}

template<>
HV_EXPORT double HttpMessage::Get(const char* key, double defvalue) {
    if (ContentType() == APPLICATION_JSON) {
        if (json.empty()) {
            ParseBody();
        }
        if (!json.is_object()) {
            return defvalue;
        }
        const auto& value = json[key];
        if (value.is_number()) {
            return value;
        }
        else if (value.is_string()) {
            std::string str = value;
            return atof(str.c_str());
        }
        else {
            return defvalue;
        }
    }
    else {
        std::string str = GetString(key);
        return str.empty() ? defvalue : atof(str.c_str());
    }
}

template<>
HV_EXPORT float HttpMessage::Get(const char* key, float defvalue) {
    return (float)Get<double>(key, defvalue);
}

template<>
HV_EXPORT bool HttpMessage::Get(const char* key, bool defvalue) {
    if (ContentType() == APPLICATION_JSON) {
        if (json.empty()) {
            ParseBody();
        }
        if (!json.is_object()) {
            return defvalue;
        }
        const auto& value = json[key];
        if (value.is_boolean()) {
            return value;
        }
        else if (value.is_string()) {
            std::string str = value;
            return hv_getboolean(str.c_str());
        }
        else if (value.is_number()) {
            return value != 0;
        }
        else {
            return defvalue;
        }
    }
    else {
        std::string str = GetString(key);
        return str.empty() ? defvalue : hv_getboolean(str.c_str());
    }
}

bool HttpMessage::GetBool(const char* key, bool defvalue) {
    return Get<bool>(key, defvalue);
}
int64_t HttpMessage::GetInt(const char* key, int64_t defvalue) {
    return Get<int64_t>(key, defvalue);
}
double HttpMessage::GetFloat(const char* key, double defvalue) {
    return Get<double>(key, defvalue);
}
#endif

void HttpMessage::FillContentType() {
    auto iter = headers.find("Content-Type");
    if (iter != headers.end()) {
        content_type = http_content_type_enum(iter->second.c_str());
        goto append;
    }

#ifndef WITHOUT_HTTP_CONTENT
    if (content_type == CONTENT_TYPE_NONE) {
        if (json.size() != 0) {
            content_type = APPLICATION_JSON;
        }
        else if (form.size() != 0) {
            content_type = MULTIPART_FORM_DATA;
        }
        else if (kv.size() != 0) {
            content_type = X_WWW_FORM_URLENCODED;
        }
        else if (body.size() != 0) {
            content_type = TEXT_PLAIN;
        }
    }
#endif

    if (content_type != CONTENT_TYPE_NONE) {
        headers["Content-Type"] = http_content_type_str(content_type);
    }

append:
#ifndef WITHOUT_HTTP_CONTENT
    if (content_type == MULTIPART_FORM_DATA) {
        auto iter = headers.find("Content-Type");
        if (iter != headers.end()) {
            const char* boundary = strstr(iter->second.c_str(), "boundary=");
            if (boundary == NULL) {
                boundary = DEFAULT_MULTIPART_BOUNDARY;
                iter->second += "; boundary=";
                iter->second += boundary;
            }
        }
    }
#endif
    return;
}

bool HttpMessage::NeedContentLength() {
    if (type == HTTP_RESPONSE) {
        HttpResponse* res = (HttpResponse*)(this);
        if (res->status_code / 100 == 1 ||
            res->status_code == HTTP_STATUS_NO_CONTENT ||
            res->status_code == HTTP_STATUS_NOT_MODIFIED) {
            return false;
        }
        return true;
    }
    return false;
}

void HttpMessage::FillContentLength() {
    auto iter = headers.find("Content-Length");
    if (iter != headers.end()) {
        content_length = atoll(iter->second.c_str());
    }
    if (content_length == 0) {
        DumpBody();
        content_length = body.size();
    }
    if (iter == headers.end() && !IsChunked() && content_type != TEXT_EVENT_STREAM) {
        if (content_length != 0 || NeedContentLength()) {
            headers["Content-Length"] = hv::to_string(content_length);
        }
    }
}

bool HttpMessage::IsChunked() {
    auto iter = headers.find("Transfer-Encoding");
    return iter != headers.end() && stricmp(iter->second.c_str(), "chunked") == 0;
}

bool HttpMessage::IsKeepAlive() {
    bool keepalive = true;
    auto iter = headers.find("connection");
    if (iter != headers.end()) {
        const char* keepalive_value = iter->second.c_str();
        if (stricmp(keepalive_value, "keep-alive") == 0) {
            keepalive = true;
        }
        else if (stricmp(keepalive_value, "close") == 0) {
            keepalive = false;
        }
        else if (stricmp(keepalive_value, "upgrade") == 0) {
            keepalive = true;
        }
    }
    else if (http_major == 1 && http_minor == 0) {
        keepalive = false;
    }
    return keepalive;
}

bool HttpMessage::IsUpgrade() {
    auto iter = headers.find("upgrade");
    return iter != headers.end();
}

// headers
void HttpMessage::SetHeader(const char* key, const std::string& value) {
    headers[key] = value;
}
std::string HttpMessage::GetHeader(const char* key, const std::string& defvalue) {
    auto iter = headers.find(key);
    return iter == headers.end() ? defvalue : iter->second;
}

// cookies
void HttpMessage::AddCookie(const HttpCookie& cookie) {
    cookies.push_back(cookie);
}
const HttpCookie& HttpMessage::GetCookie(const std::string& name) {
    for (auto iter = cookies.begin(); iter != cookies.end(); ++iter) {
        if (iter->name == name) {
            return *iter;
        }
        auto kv_iter = iter->kv.find(name);
        if (kv_iter != iter->kv.end()) {
            iter->name = name;
            iter->value = kv_iter->second;
            return *iter;
        }
    }
    return NoCookie;
}

// body
void HttpMessage::SetBody(const std::string& body) {
    this->body = body;
}
const std::string& HttpMessage::Body() {
    return this->body;
}

void HttpMessage::DumpHeaders(std::string& str) {
    FillContentType();
    FillContentLength();

    // headers
    for (auto& header: headers) {
        // http2 :method :path :scheme :authority :status
        if (*str.c_str() != ':') {
            // %s: %s\r\n
            str += header.first;
            str += ": ";
            // fix CVE-2023-26148
            // if the value has \r\n, translate to \\r\\n
            if (header.second.find("\r") != std::string::npos ||
                header.second.find("\n") != std::string::npos) {
                std::string newStr = "";
                for (size_t i = 0; i < header.second.size(); ++i) {
                    if (header.second[i] == '\r') {
                        newStr += "\\r";
                    } else if (header.second[i] == '\n') {
                        newStr += "\\n";
                    } else {
                        newStr += header.second[i];
                    }
                }
                str += newStr;
            } else {
                str += header.second;
            }
            str += "\r\n";
        }
    }

    // cookies
    const char* cookie_field = "Cookie";
    if (type == HTTP_RESPONSE) {
        cookie_field = "Set-Cookie";
    }
    for (auto& cookie : cookies) {
        str += cookie_field;
        str += ": ";
        str += cookie.dump();
        str += "\r\n";
    }
}

void HttpMessage::DumpBody() {
    if (body.size() != 0) {
        return;
    }
    FillContentType();
#ifndef WITHOUT_HTTP_CONTENT
    switch(content_type) {
    case APPLICATION_JSON:
        body = dump_json(json, 2);
        break;
    case MULTIPART_FORM_DATA:
    {
        auto iter = headers.find("Content-Type");
        if (iter == headers.end()) {
            return;
        }
        const char* boundary = strstr(iter->second.c_str(), "boundary=");
        if (boundary == NULL) {
            return;
        }
        boundary += strlen("boundary=");
        body = dump_multipart(form, boundary);
    }
        break;
    case X_WWW_FORM_URLENCODED:
        body = dump_query_params(kv);
        break;
    default:
        // nothing to do
        break;
    }
#endif
}

void HttpMessage::DumpBody(std::string& str) {
    DumpBody();
    const char* content = (const char*)Content();
    size_t content_length = ContentLength();
    if (content && content_length) {
        str.append(content, content_length);
    }
}

int HttpMessage::ParseBody() {
    if (body.size() == 0) {
        return -1;
    }
    FillContentType();
#ifndef WITHOUT_HTTP_CONTENT
    switch(content_type) {
    case APPLICATION_JSON:
    {
        std::string errmsg;
        int ret = parse_json(body.c_str(), json, errmsg);
        if (ret != 0 && errmsg.size() != 0) {
            hloge("%s", errmsg.c_str());
        }
        return ret;
    }
    case MULTIPART_FORM_DATA:
    {
        auto iter = headers.find("Content-Type");
        if (iter == headers.end()) {
            return -1;
        }
        const char* boundary = strstr(iter->second.c_str(), "boundary=");
        if (boundary == NULL) {
            return -1;
        }
        boundary += strlen("boundary=");
        std::string strBoundary(boundary);
        strBoundary = trim_pairs(strBoundary, "\"\"\'\'");
        return parse_multipart(body, form, strBoundary.c_str());
    }
    case X_WWW_FORM_URLENCODED:
        return parse_query_params(body.c_str(), kv);
    default:
        // nothing to do
        return 0;
    }
#endif
    return 0;
}

std::string HttpMessage::Dump(bool is_dump_headers, bool is_dump_body) {
    std::string str;
    if (is_dump_headers) {
        DumpHeaders(str);
    }
    str += "\r\n";
    if (is_dump_body) {
        DumpBody(str);
    }
    return str;
}


HttpRequest::HttpRequest() : HttpMessage() {
    type = HTTP_REQUEST;
    Init();
}

void HttpRequest::Init() {
    headers["User-Agent"] = DEFAULT_HTTP_USER_AGENT;
    headers["Accept"] = "*/*";
    method = HTTP_GET;
    scheme = "http";
    host = "127.0.0.1";
    port = DEFAULT_HTTP_PORT;
    path = "/";
    timeout = DEFAULT_HTTP_TIMEOUT;
    connect_timeout = DEFAULT_HTTP_CONNECT_TIMEOUT;
    retry_count = DEFAULT_HTTP_FAIL_RETRY_COUNT;
    retry_delay = DEFAULT_HTTP_FAIL_RETRY_DELAY;
    redirect = 1;
    proxy = 0;
    cancel = 0;
}

void HttpRequest::Reset() {
    HttpMessage::Reset();
    Init();
    url.clear();
    query_params.clear();
}

void HttpRequest::DumpUrl() {
    std::string str;
    if (url.size() != 0 &&
        *url.c_str() != '/' &&
        strstr(url.c_str(), "://") != NULL) {
        // have been complete url
        goto query;
    }
    // scheme://
    str = scheme;
    str += "://";
    // host:port
    if (url.size() != 0 && *url.c_str() != '/') {
        // url begin with host
        str += url;
    }
    else {
        if (port == 0 ||
            port == DEFAULT_HTTP_PORT ||
            port == DEFAULT_HTTPS_PORT) {
            str += Host();
        }
        else {
            str += hv::asprintf("%s:%d", host.c_str(), port);
        }
    }
    // /path
    if (url.size() != 0 && *url.c_str() == '/') {
        // url begin with path
        str += url;
    }
    else if (path.size() > 1 && *path.c_str() == '/') {
        str += path;
    }
    else if (url.size() == 0) {
        str += '/';
    }
    url = str;
query:
    // ?query
    if (strchr(url.c_str(), '?') == NULL &&
        query_params.size() != 0) {
        url += '?';
        url += dump_query_params(query_params);
    }
}

void HttpRequest::ParseUrl() {
    DumpUrl();
    hurl_t parser;
    hv_parse_url(&parser, url.c_str());
    // scheme
    std::string scheme_ = url.substr(parser.fields[HV_URL_SCHEME].off, parser.fields[HV_URL_SCHEME].len);
    // host
    std::string host_(host);
    if (parser.fields[HV_URL_HOST].len > 0) {
        host_ = url.substr(parser.fields[HV_URL_HOST].off, parser.fields[HV_URL_HOST].len);
    }
    // port
    int port_ = parser.port ? parser.port : strcmp(scheme_.c_str(), "https") ? DEFAULT_HTTP_PORT : DEFAULT_HTTPS_PORT;
    if (!proxy) {
        scheme = scheme_;
        host = host_;
        port = port_;
    }
    FillHost(host_.c_str(), port_);
    // path
    if (parser.fields[HV_URL_PATH].len > 0) {
        path = url.substr(parser.fields[HV_URL_PATH].off);
    }
    // query
    if (parser.fields[HV_URL_QUERY].len > 0) {
        parse_query_params(url.c_str()+parser.fields[HV_URL_QUERY].off, query_params);
    }
}

std::string HttpRequest::Path() {
    const char* s = path.c_str();
    const char* e = s;
    while (*e && *e != '?' && *e != '#') ++e;
    return HUrl::unescape(std::string(s, e));
}

void HttpRequest::FillHost(const char* host, int port) {
    if (headers.find("Host") == headers.end()) {
        if (port == 0 ||
            port == DEFAULT_HTTP_PORT ||
            port == DEFAULT_HTTPS_PORT) {
            headers["Host"] = host;
        } else {
            headers["Host"] = hv::NetAddr::to_string(host, port);
        }
    }
}

void HttpRequest::SetHost(const char* host, int port) {
    this->host = host;
    this->port = port;
    FillHost(host, port);
}

void HttpRequest::SetProxy(const char* host, int port) {
    this->scheme = "http";
    this->host = host;
    this->port = port;
    proxy = 1;
}

void HttpRequest::SetAuth(const std::string& auth) {
    SetHeader("Authorization", auth);
}

void HttpRequest::SetBasicAuth(const std::string& username, const std::string& password) {
    std::string strAuth = hv::asprintf("%s:%s", username.c_str(), password.c_str());
    std::string base64Auth = hv::Base64Encode((const unsigned char*)strAuth.c_str(), strAuth.size());
    SetAuth(std::string("Basic ") + base64Auth);
}

void HttpRequest::SetBearerTokenAuth(const std::string& token) {
    SetAuth(std::string("Bearer ") + token);
}

std::string HttpRequest::Dump(bool is_dump_headers, bool is_dump_body) {
    ParseUrl();

    std::string str;
    str.reserve(MAX(512, path.size() + 128));
    // GET / HTTP/1.1\r\n
    str = asprintf("%s %s HTTP/%d.%d\r\n",
            http_method_str(method),
            proxy ? url.c_str() : path.c_str(),
            (int)http_major, (int)http_minor);
    if (is_dump_headers) {
        DumpHeaders(str);
    }
    str += "\r\n";
    if (is_dump_body) {
        DumpBody(str);
    }
    return str;
}

void HttpRequest::SetRange(long from, long to) {
    SetHeader("Range", hv::asprintf("bytes=%ld-%ld", from, to));
}

bool HttpRequest::GetRange(long& from, long& to) {
    auto iter = headers.find("Range");
    if (iter != headers.end()) {
        sscanf(iter->second.c_str(), "bytes=%ld-%ld", &from, &to);
        return true;
    }
    from = to = 0;
    return false;
}

HttpResponse::HttpResponse() : HttpMessage() {
    type = HTTP_RESPONSE;
    Init();
}

void HttpResponse::Init() {
    status_code = HTTP_STATUS_OK;
}

void HttpResponse::Reset() {
    HttpMessage::Reset();
    Init();
}

std::string HttpResponse::Dump(bool is_dump_headers, bool is_dump_body) {
    char c_str[256] = {0};
    std::string str;
    str.reserve(512);
    // HTTP/1.1 200 OK\r\n
    snprintf(c_str, sizeof(c_str), "HTTP/%d.%d %d %s\r\n",
            (int)http_major, (int)http_minor,
            (int)status_code, http_status_str(status_code));
    str = c_str;
    if (is_dump_headers) {
        if (*s_date) {
            headers["Date"] = s_date;
        } else {
            headers["Date"] = gmtime_fmt(time(NULL), c_str);
        }
        DumpHeaders(str);
    }
    str += "\r\n";
    if (is_dump_body) {
        DumpBody(str);
    }
    return str;
}

void HttpResponse::SetRange(long from, long to, long total) {
    SetHeader("Content-Range", hv::asprintf("bytes %ld-%ld/%ld", from, to, total));
}

bool HttpResponse::GetRange(long& from, long& to, long& total) {
    auto iter = headers.find("Content-Range");
    if (iter != headers.end()) {
        sscanf(iter->second.c_str(), "bytes %ld-%ld/%ld", &from, &to, &total);
        return true;
    }
    from = to = total = 0;
    return false;
}