HTTPRequest.cpp

/*
** libutil++
** $Id: HTTPRequest.cpp 1783 2016-11-27 19:17:46Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: HTTPRequest.cpp 1783 2016-11-27 19:17:46Z sella $";

#include "HTTPRequest.h"
#include "HTTP.h"

#include "../util/String.h"

#include <sys/types.h>
#include <sys/stat.h>

#include <magic.h>

using namespace sella::server;
using namespace sella::util;

const std::string HTTPRequest::ContentTypeDefault = "application/octet-stream"; /* RFC 2616 7.2.1 */

HTTPRequest::HTTPRequest(const HTTP &http) throw () :
        http(http),
        method(None),
        methodRaw(),
        methodOverride(None),
        methodOverrideRaw(),
        uri(),
        path(),
        query(),
        version(),
        headers(),
        host(),
        userAgent(),
        accept(),
        acceptCharset(),
        acceptEncoding(),
        acceptLanguage(),
        transferEncoding(),
        authorization(),
        connection(),
        cacheControl(),
        expect(),
        contentType(),
        contentLength(0),
        content()
{ }

HTTPRequest::~HTTPRequest() throw () { }

void HTTPRequest::parse(const std::string &buffer) throw (ServerException) {
        char buf[buffer.size() + 1];
        char *line, *nline, *token, *rest, *ptr = buf;

        strncpy(buf, buffer.c_str(), sizeof(buf));

        if ((line = strtok_r(ptr, "\r\n", &rest)) == NULL) {
                THROW_CODE(ServerException, Code::BadRequest, "Request was empty");
        }

        TRACE(PACKAGE, "Request-Line: %s", line);

        nline = rest;

        /* Tokenize Request-Line - RFC 2616 5.1.2 */
        if ((token = strtok_r(ptr, " ", &rest)) != NULL) {
                if (strncmp("GET", token, 3) == 0) {
                        method = Get;
                } else if (strncmp("POST", token, 4) == 0) {
                        method = Post;
                } else if (strncmp("PUT", token, 3) == 0) {
                        method = Put;
                } else if (strncmp("DELETE", token, 6) == 0) {
                        method = Delete;
                } else if (strncmp("PATCH", token, 5) == 0) {
                        method = Patch;
                } else if (strncmp("HEAD", token, 4) == 0) {
                        method = Head;
                } else if (strncmp("OPTIONS", token, 7) == 0) {
                        method = Options;
                } else if (strncmp("TRACE", token, 5) == 0) {
                        method = Trace;
                } else if (strncmp("CONNECT", token, 7) == 0) {
                        method = Connect;
                } else {
                        method = Extension;
                }

                methodRaw = token;
        } else {
                THROW_CODE(ServerException, Code::BadRequest, "Request syntax is malformed: %s", line);
        }

        if ((token = strrchr(rest, ' ')) != NULL) {
                token[0] = 0;
                uri = rest;
        } else {
                THROW_CODE(ServerException, Code::BadRequest, "Request syntax is malformed: %s", line);
        }

        if (strncmp("HTTP/", ++token, 5) == 0) {
                version = token;
        } else {
                THROW_CODE(ServerException, Code::BadRequest, "Request syntax is malformed: %s", line);
        }

        if ((token = strchr(rest, '?')) != NULL) {
                token[0] = 0;
                query = token + 1;
                path = rest;
        } else {
                path = rest;
        }

        if ((token = strrchr(rest, '.')) != NULL) {
                extension = token + 1;
        }

        ptr = nline;

        /* Tokenize Headers */
        while   ((line = strtok_r(ptr, "\r\n", &rest)) != NULL) {
                /* Standard Request Header Fields - RFC 2616 5.3 */
                if (strncasecmp("Host: ", line, 6) == 0) {
                        host = line + 6;
                } else if (strncasecmp("User-Agent: ", line, 12) == 0) {
                        userAgent = line + 12;
                } else if (strncasecmp("Accept: ", line, 8) == 0) {
                        accept = String::split(line + 8, ",", false, false); // RFC 2616 14.1 - FIXME: Must sort accept by q values for later processing.
                } else if (strncasecmp("Accept-Charset: ", line, 16) == 0) {
                        acceptCharset = String::split(line + 16, ",", false, false);
                } else if (strncasecmp("Accept-Language: ", line, 17) == 0) {
                        acceptLanguage = String::split(line + 17, ",", false, false);
                } else if (strncasecmp("Accept-Encoding: ", line, 17) == 0) {
                        acceptEncoding = String::split(line + 17, ",", false, false);
                } else if (strncasecmp("Authorization: ", line, 15) == 0) {
                        authorization = line + 15;
                } else if (strncasecmp("Transfer-Encoding: ", line, 19) == 0) {
                        transferEncoding = line + 19;
                } else if (strncasecmp("Connection: ", line, 12) == 0) {
                        connection = line + 12;
                } else if (strncasecmp("Cache-Control: ", line, 15) == 0) {
                        cacheControl = line + 15;
                } else if (strncasecmp("Expect: ", line, 8) == 0) {
                        expect = line + 8;
                } else if (strncasecmp("Content-Type: ", line, 14) == 0) {
                        contentType = line + 14;
                } else if (strncasecmp("Content-Length: ", line, 16) == 0) {
                        try {
                                contentLength = std::stoull(line + 16);
                        } catch (std::exception &e) {
                                THROW_CODE(ServerException, Code::BadRequest, "Content-Length is invalid: %s", line + 15);
                        }
                } else if (strncasecmp("X-HTTP-Method-Override: ", line, 24) == 0) { /* Common Non-standard (Google) */
                        methodOverrideRaw = line + 24;
                } else if (strncasecmp("X-HTTP-Method: ", line, 15) == 0) { /* Common Non-standard (Microsoft) */
                        methodOverrideRaw = line + 15;
                } else if (strncasecmp("X-METHOD-OVERRIDE: ", line, 19) == 0) { /* Common Non-standard (IBM) */
                        methodOverrideRaw = line + 19;
                }

                headers.push_back(line);

                ptr = rest;

                if (rest != NULL && strncmp(rest, "\n\r\n", 3) == 0) {
                        rest += 3;

                        break;
                }
        }

        if (!methodOverrideRaw.empty()) { /* Request-Line Method - RFC 2616 5.1.2 */
                if (methodOverrideRaw.compare("GET")) {
                        methodOverride = Get;
                } else if (methodOverrideRaw.compare("POST")) {
                        methodOverride = Post;
                } else if (methodOverrideRaw.compare("PUT")) {
                        methodOverride = Put;
                } else if (methodOverrideRaw.compare("DELETE")) {
                        methodOverride = Delete;
                } else if (methodOverrideRaw.compare("PATCH")) {
                        methodOverride = Patch;
                } else if (methodOverrideRaw.compare("HEAD")) {
                        methodOverride = Head;
                } else if (methodOverrideRaw.compare("OPTIONS")) {
                        methodOverride = Options;
                } else if (methodOverrideRaw.compare("TRACE")) {
                        methodOverride = Trace;
                } else if (methodOverrideRaw.compare("CONNECT")) {
                        methodOverride = Connect;
                } else {
                        methodOverride = Extension;
                }
        }

        if (host.empty()) { /* RFC 2616 14.23 */
                THROW_CODE(ServerException, Code::BadRequest, "Host header field is missing");
        }

        if (rest != NULL) {
                std::string body(rest);

                appendBody(body);

                if (contentType.empty()) { /* Guess content-type from content - RFC 2616 7.2.1 */
                        contentType = getMIMEType(body, body.size(), ContentTypeDefault);
                }
        }
}

void HTTPRequest::appendBody(const std::string &data) throw (ServerException) {
        if (content.size() + data.size() > http.getRequestBodyLimit()) {
                THROW_CODE(ServerException, Code::RequestEntityTooLarge, "The requested URI %s is larger than the configured limit of %zd bytes.", uri.c_str(), http.getRequestBodyLimit());
        }

        content.reserve(content.size() + data.size());
        content.insert(content.end(), data.begin(), data.end());
}

void HTTPRequest::appendBody(const std::vector<char> &data) throw (ServerException) {
        if (content.size() + data.size() > http.getRequestBodyLimit()) {
                THROW_CODE(ServerException, Code::RequestEntityTooLarge, "The requested URI %s is larger than the configured limit of %zd bytes.", uri.c_str(), http.getRequestBodyLimit());
        }

        content.reserve(content.size() + data.size());
        content.insert(content.end(), data.begin(), data.end());
}

HTTPRequest::Method HTTPRequest::getMethod(bool useOverride) const throw () {
        if (useOverride && methodOverride != None) {
                return methodOverride;
        }

        return method;
}

const std::string& HTTPRequest::getMethodRaw(bool useOverride) const throw () {
        if (useOverride && methodOverride != None) {
                return methodOverrideRaw;
        }

        return methodRaw;
}

HTTPRequest::Method HTTPRequest::getMethodOverride(void) const throw () {
        return methodOverride;
}

const std::string& HTTPRequest::getMethodOverrideRaw(void) const throw () {
        return methodOverrideRaw;
}

const std::string& HTTPRequest::getURI(void) const throw () {
        return uri;
}

const std::string& HTTPRequest::getPath(void) const throw () {
        return path;
}

const std::string& HTTPRequest::getExtension(void) const throw () {
        return extension;
}

const std::string& HTTPRequest::getQuery(void) const throw () {
        return query;
}

const std::string& HTTPRequest::getVersion(void) const throw () {
        return version;
}

const std::string& HTTPRequest::getHost(void) const throw () {
        return host;
}

const std::string& HTTPRequest::getUserAgent(void) const throw () {
        return userAgent;
}

const std::string& HTTPRequest::getAuthorization(void) const throw () {
        return authorization;
}

bool HTTPRequest::getAuthorizationCredentials(std::string &username, std::string &password) const throw () {
        if (isBasicAuthorization()) {
                std::string tmp = util::String::base64_decode(authorization);
                size_t delim = tmp.find_first_of(':');

                if (delim != std::string::npos) {
                        username = tmp.substr(0, delim - 1);
                        password = tmp.substr(delim + 1);

                        tmp.assign(tmp.size(), '\0'); /* Scrub sensitive data */

                        return true;
                }
        }

        return false;
}

const std::vector<std::string>& HTTPRequest::getAccept(void) const throw () {
        return accept;
}

HTTPRequest::AcceptType HTTPRequest::getAcceptType(AcceptType fallback) const throw () {
        static const boost::regex pattern_json("^application/(?:x-)?json");
        static const boost::regex pattern_jsonp("^application/(?:x-)?javascript");
        static const boost::regex pattern_icon("^image/(?:x-icon|vnd.microsoft.icon)");

        if (!extension.empty()) {
                if (extension.compare("json") == 0) {
                        return AcceptType::JSON;
                } else if (extension.compare("xml") == 0) {
                        return AcceptType::XML;
                } else if (extension.compare("jsonp") == 0) {
                        return AcceptType::JSONP;
                } else if (extension.compare("csv") == 0) {
                        return AcceptType::CSV;
                } else if (extension.compare("html") == 0) {
                        return AcceptType::HTML;
                } else if (extension.compare("plain") == 0) {
                        return AcceptType::Plain;
                }
        }

        if (accept.empty()) {
                return fallback;
        }

        for (auto a = accept.begin(); a != accept.end(); ++a) { /* Ordered by most likely to match */
                if (a->compare(0, 9, "text/html") == 0) {
                        return AcceptType::HTML;
                } else if (a->compare(0, 10, "text/plain") == 0) {
                        return AcceptType::Plain;
                } else if (String::regex_isearch(*a, pattern_json)) {
                        return AcceptType::JSON;
                } else if (a->compare(0, 15, "application/xml") == 0) {
                        return AcceptType::XML;
                } else if (String::regex_isearch(*a, pattern_jsonp)) { // JSONP
                        return AcceptType::JSONP;
                } else if (a->compare(0, 21, "application/xhtml+xml") == 0) {
                        return AcceptType::XHTML_XML;
                } else if (a->compare(0, 9, "image/png") == 0) {
                        return AcceptType::PNG;
                } else if (a->compare(0, 9, "image/gif") == 0) {
                        return AcceptType::GIF;
                } else if (a->compare(0, 10, "image/jpeg") == 0) {
                        return AcceptType::JPEG;
                } else if (a->compare(0, 8, "text/csv") == 0) {
                        return AcceptType::CSV;
                } else if (String::regex_isearch(*a, pattern_icon)) {
                        return AcceptType::Icon;
                } else if (a->compare(0, 3, "*/*") == 0) {
                        return AcceptType::Any;
                } else if (a->compare(0, 6, "text/*") == 0) {
                        return AcceptType::Text_Any;
                } else if (a->compare(0, 5, "text/") == 0) {
                        return AcceptType::Text;
                } else if (a->compare(0, 13, "application/*") == 0) {
                        return AcceptType::Application_Any;
                } else if (a->compare(0, 12, "application/") == 0) {
                        return AcceptType::Application;
                } else if (a->compare(0, 7, "image/*") == 0) {
                        return AcceptType::Image_Any;
                } else if (a->compare(0, 6, "image/") == 0) {
                        return AcceptType::Image;
                } else if (a->compare(0, 7, "audio/*") == 0) {
                        return AcceptType::Audio_Any;
                } else if (a->compare(0, 7, "audio/") == 0) {
                        return AcceptType::Audio;
                }
        }

        return fallback;
}

const std::vector<std::string>& HTTPRequest::getHeaders() const throw () {
        return headers;
}

std::string HTTPRequest::getHeader(const std::string &header) const throw (ServerException) {
        std::vector<std::string> matches;
        const boost::regex pattern(header + std::string(": *(\\S+) *"));

        for (auto h = headers.begin(); h != headers.end(); ++h) {
                try {
                        if (String::regex_imatch(*h, pattern, matches)) {
                                return matches[1];
                        }
                } catch (RegexException &e) {
                        RETHROW_CODE(ServerException, Code::InternalServerError, e);
                }
        }

        THROW_CODE(ServerException, Code::InternalServerError, "The requested header '%s' was not found.", header.c_str());
}

const std::string HTTPRequest::getBody(void) const throw () {
        std::string buf(content.begin(), content.end());

        return buf;
}

const std::vector<char>& HTTPRequest::getContent(void) const throw () {
        return content;
}

bool HTTPRequest::isContinue(void) const throw () {
        return !expect.compare("100-continue");
}

bool HTTPRequest::isChunked(void) const throw () {
        return !transferEncoding.compare("chunked");
}

bool HTTPRequest::isAcceptGzip(void) const throw () {
        auto end = acceptEncoding.end();

        return (std::find(acceptEncoding.begin(), end, "gzip") != end);
}

bool HTTPRequest::isAcceptDeflate(void) const throw () {
        auto end = acceptEncoding.end();

        return (std::find(acceptEncoding.begin(), end, "delfate") != end);
}

bool HTTPRequest::isBasicAuthorization(void) const throw () {
        return (authorization.compare(0, 5, "Basic") == 0);
}

bool HTTPRequest::empty(void) const throw () {
        return (method == None);
}

bool HTTPRequest::hasHeader(const std::string &header) const throw (ServerException) {
#if 0
        const boost::regex pattern(std::string("^") + header + std::string(":"));

        for (auto h = headers.begin(); h != headers.end(); ++h) {
                try {
                        if (String::regex_isearch(*h, pattern)) {
                                return true;
                        }
                } catch (RegexException &e) {
                        RETHROW_CODE(ServerException, Code::InternalServerError, e);
                }
        }
#else /* More efficient */
        std::string pattern = String::lower(header) + ":";
        size_t len = pattern.size();

        for (auto h = headers.begin(), end = headers.end(); h != end; ++h) {
                if (pattern.compare(0, len, String::lower(*h))) {
                        return true;
                }
        }
#endif

        return false;
}

void HTTPRequest::clear(void) throw () {
        method = None;
        methodRaw.clear();
        methodOverride = None;
        methodOverrideRaw.clear();
        uri.clear();
        path.clear();
        extension.clear();
        query.clear();
        version.clear();
        headers.clear();
        host.clear();
        userAgent.clear();
        accept.clear();
        acceptCharset.clear();
        acceptEncoding.clear();
        acceptLanguage.clear();
        transferEncoding.clear();
        authorization.clear();
        connection.clear();
        cacheControl.clear();
        expect.clear();
        contentType.clear();
        contentLength = 0;
        std::vector<char>().swap(content);
}

std::string HTTPRequest::str(void) const throw () {
        return String::sprintf("%s %s %s\n%s\n%s", methodRaw.c_str(), uri.c_str(), version.c_str(), String::join(headers, '\n').c_str(), getBody().c_str());
}

void HTTPRequest::print(void) const throw () {
        printf("[request]\n");
        printf("%s %s %s\n", methodRaw.c_str(), uri.c_str(), version.c_str());

        for (auto h = headers.begin(); h != headers.end(); ++h) {
                printf("%s\n", h->c_str());
        }

        printf("uri: %s\n", uri.c_str());
        printf("path: %s\n", path.c_str());
        printf("extension: %s\n", extension.c_str());
        printf("query: %s\n", query.c_str());

        printf("%s\n", getBody().c_str());
}

std::string HTTPRequest::getFullpath(const std::string &file) throw (ServerException) {
        std::string fullpath = http.getRoot();

        if (file.empty()) {
                fullpath += getPath();
        } else {
                fullpath += file;
        }

        if (isDirectory(fullpath)) {
                const auto &indexes = http.getDirectoryIndexes();

                for (auto i = indexes.begin(); i != indexes.end(); ++i) {
                        std::string indexpath = fullpath + *i;

                        if (isFile(indexpath)) {
                                return std::move(indexpath);
                        }
                }
        } else if (isFile(fullpath)) {
                return std::move(fullpath);
        }

        THROW_CODE(ServerException, Code::NotFound, "The requested URI %s was not found on this server.", getPath().c_str());
}

std::string HTTPRequest::getMIMEType(const std::string &file, const std::string &fallback) const throw (ServerException) {
        const char *result = NULL;

        try {
                magic_t magic;

                magic_open(magic);

                if ((result = ::magic_file(magic, file.c_str())) == NULL) {
                        THROW(ServerException, "magic_file: failed");
                }

                magic_close(magic);
        } catch (ServerException &e) {
                if (fallback.empty()) {
                        throw e;
                }

                return fallback;
        }

        return result;
}

std::string HTTPRequest::getMIMEType(const std::string &buffer, size_t size, const std::string &fallback) const throw (ServerException) {
        const char *result = NULL;

        try {
                magic_t magic;

                magic_open(magic);

                if ((result = ::magic_buffer(magic, buffer.c_str(), (size < 0) ? buffer.size() : size)) == NULL) {
                        THROW(ServerException, "magic_buffer: failed");
                }

                magic_close(magic);
        } catch (ServerException &e) {
                if (fallback.empty()) {
                        throw e;
                }

                return fallback;
        }

        return result;
}

bool HTTPRequest::isDirectory(const std::string &path) const throw () {
        struct stat s;

        return (stat(path.c_str(), &s) == 0 && S_ISDIR(s.st_mode)); 
}

bool HTTPRequest::isFile(const std::string &file) const throw () {
        struct stat s;

        return (stat(file.c_str(), &s) == 0 && S_ISREG(s.st_mode)); 
}

void HTTPRequest::magic_open(magic_t &magic) const throw (ServerException) {
        if ((magic = ::magic_open(MAGIC_MIME)) == NULL) {
                THROW_CODE(ServerException, Code::InternalServerError, "magic_open: failed to initialize");
        }

        if (::magic_load(magic, NULL) != 0) {
                std::string err = String::sprintf("magic_open: %s", magic_error(magic));
                ::magic_close(magic);

                THROW_CODE(ServerException, Code::InternalServerError, err.c_str());
        }
}

void HTTPRequest::magic_close(magic_t &magic) const throw () {
        ::magic_close(magic);
}

/*
** vim: noet ts=3 sw=3
*/