/builddir/build/BUILD/libutil++-1.4.0/src/sella/server/HTTPRequest.cpp

/*
** libutil++
** $Id: HTTPRequest.cpp 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 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 1197 2014-10-14 22:26:11Z sella $";

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

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

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

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;
        }

        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);
                } 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()) {
                THROW_CODE(ServerException, Code::BadRequest, "Missing Host header");
        }

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

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::getQuery(void) const throw () {
        return query;
}

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

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

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::empty(void) const throw () {
        return (method == None);
}

void HTTPRequest::clear(void) throw () {
        method = None;
        methodRaw.clear();
        methodOverride = None;
        methodOverrideRaw.clear();
        uri.clear();
        path.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());
        }

#if 1
        printf("uri: %s\n", uri.c_str());
        printf("path: %s\n", path.c_str());
        printf("query: %s\n", query.c_str());
#endif

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

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

---