HTTPConnection.cpp

/*
** libutil++
** $Id: HTTPConnection.cpp 1785 2016-11-28 01:09:40Z 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: HTTPConnection.cpp 1785 2016-11-28 01:09:40Z sella $";

#include "HTTPConnection.h"
#include "HTTP.h"
#include "../util/Time.h"
#include "../util/String.h"
#include "../util/CommonMacro.h"

#include <string.h>
#include <unistd.h>
#include <zlib.h>

#include <iostream>
#include <fstream>
#include <string>

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

const timeval HTTPConnection::ReceiveTimeoutDefault = { 30, 0 };
const std::string HTTPConnection::MIMEFallback = "text/plain; charset=us-ascii";
const std::string HTTPConnection::ContentTypeDefault = "text/html; charset=iso-8859-1";

HTTPConnection::HTTPConnection(const HTTP &http, TCPSocket::shared &socket, timeval tv) throw () :
        http(http),
        socket(socket),
        start(Time::clock_monotonic_coarse()),
        request(http)
{
        socket->setSoSndTimeo(tv);
        socket->setSoRcvTimeo(tv);
}

HTTPConnection::~HTTPConnection() throw () { }

const HTTPConnection::shared HTTPConnection::shared_ptr(const HTTP &http, sella::net::TCPSocket::shared &socket, timeval tv) throw () {
        return std::make_shared<HTTPConnection>(http, socket, tv);
}

const HTTPRequest& HTTPConnection::getRequest(void) throw (ServerException) {
        if (request.empty()) {
                std::string buffer;

                read(buffer);
                request.parse(buffer);

                if (request.contentLength > http.getRequestBodyLimit()) {
                        THROW_CODE(ServerException, Code::RequestEntityTooLarge, "Content-Length is larger than %zd", http.getRequestBodyLimit());
                }

                if (request.isContinue()) {
                        if (request.isChunked()) {
                                chunker();
                        } else {
                                THROW_CODE(ServerException, Code::NotImplemented, "Unsupported transfer-encoding"); /* Not implemented */
                        }
                }
        }

        return request;
}

struct timespec HTTPConnection::getRuntime(void) const throw () {
        struct timespec delta = Time::clock_monotonic_coarse();

        return Time::subtractts(delta, start);
}

bool HTTPConnection::isUsable(void) const throw () {
        return socket->isUsable();
}

bool HTTPConnection::isSecure(void) const throw () {
        return socket->isSecure();
}

void HTTPConnection::response(const std::string &body, const std::string &contentType, bool close) throw (ServerException) {
        response(Code::OK, body, contentType, close);
}

void HTTPConnection::response(const std::vector<char> &content, const std::string &contentType, bool close) throw (ServerException) {
        response(Code::OK, content, contentType, close);
}

void HTTPConnection::error(int code, const std::string &detail, const std::string &contentType) throw (ServerException) {
        std::string body = getErrorBody(code, detail);

        response(code, body);
}

void HTTPConnection::error(int code, const std::vector<char> &content, const std::string &contentType) throw (ServerException) {
        response(code, content, contentType, true);
}

void HTTPConnection::methodOptions(void) throw (ServerException) {
        std::string buf;

        if (request.getURI().compare("*") == 0) {
                /* Server specific */
        } else {
                /* Resource specific */
        }

        try {
                response(Code::OK, buf, ContentTypeDefault);
        } catch (SocketException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        }
}

void HTTPConnection::methodGet(void) throw (ServerException) {
        std::vector<char> content;
        std::string contentType;

        getFileContent(request.getPath(), content, contentType);

        response(content, contentType);
}

void HTTPConnection::methodHead(void) throw (ServerException) {
        int code = Code::OK;
        std::vector<char> content;
        std::string contentType;

        try {
                getFileContent(request.getPath(), content, contentType);
        } catch (ServerException &e) {
                code = e.getCode();
        }

        try {
                sendStatusLine(code);
                sendHeaders(content.capacity(), contentType);
        } catch (SocketException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        }
}

void HTTPConnection::methodPost(void) throw (ServerException) {
        THROW_CODE(ServerException, Code::MethodNotAllowed, "The method %s is not allowed for the URL %s.", request.getMethodRaw().c_str(), request.getPath().c_str());
}

void HTTPConnection::methodPut(void) throw (ServerException) {
        THROW_CODE(ServerException, Code::MethodNotAllowed, "The method %s is not allowed for the URL %s.", request.getMethodRaw().c_str(), request.getPath().c_str());
}

void HTTPConnection::methodDelete(void) throw (ServerException) {
        THROW_CODE(ServerException, Code::MethodNotAllowed, "The method %s is not allowed for the URL %s.", request.getMethodRaw().c_str(), request.getPath().c_str());
}

void HTTPConnection::methodTrace(void) throw (ServerException) {
        const std::vector<char> &content = request.getContent();
        std::string trace = String::sprintf("%s %s %s\r\n", request.getMethodRaw().c_str(), request.getURI().c_str(), request.getVersion().c_str());

        for (auto h = request.getHeaders().begin(); h != request.getHeaders().end(); ++h) {
                trace += *h + "\r\n";
        }
        trace += "\r\n";

        try {
                sendStatusLine(Code::OK);
                sendHeaders(trace.size() + content.capacity(), "message/http");
                sendBody(trace);
                sendContent(content);
        } catch (SocketException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        }
}

void HTTPConnection::methodConnect(void) throw (ServerException) {
        THROW_CODE(ServerException, Code::MethodNotAllowed, "The method %s is not allowed for the URL %s.", request.getMethodRaw().c_str(), request.getPath().c_str());
}

void HTTPConnection::methodPatch(void) throw (ServerException) {
        THROW_CODE(ServerException, Code::MethodNotAllowed, "The method %s is not allowed for the URL %s.", request.getMethodRaw().c_str(), request.getPath().c_str());
}

IPAddressPort HTTPConnection::getLocalIPAddressPort(void) const throw (ServerException) {
        try {
                return socket->getLocalIPAddressPort();
        } catch (SocketException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        }
}

IPAddressPort HTTPConnection::getRemoteIPAddressPort(void) const throw (ServerException) {
        try {
                return socket->getRemoteIPAddressPort();
        } catch (SocketException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        }
}

const char* HTTPConnection::getSSLLibraryVersion(void) const throw () {
        if (socket->isSecure()) {
                return std::static_pointer_cast<sella::net::SecureTCPSocket>(socket)->getSSLLibraryVersion();
        }

        return "none";
}

const char* HTTPConnection::getActiveProtocol(void) const throw () {
        if (socket->isSecure()) {
                try {
                        return std::static_pointer_cast<sella::net::SecureTCPSocket>(socket)->getActiveProtocol();
                } catch (...) { }
        }

        return "none";
}

const char* HTTPConnection::getActiveCipher(void) const throw () {
        if (socket->isSecure()) {
                try {
                        return std::static_pointer_cast<sella::net::SecureTCPSocket>(socket)->getActiveCipher();
                } catch (...) { }
        }

        return "none";
}

std::string HTTPConnection::getContentType(HTTPRequest::AcceptType type, const std::string &fallback) const throw () {
        switch (type) {
                case HTTPRequest::AcceptType::HTML:
                        return "text/html";

                case HTTPRequest::AcceptType::Plain:
                        return "text/plain";

                case HTTPRequest::AcceptType::JSON:
                        return "application/json";

                case HTTPRequest::AcceptType::JSONP:
                        return "application/javascript";

                case HTTPRequest::AcceptType::XML:
                        return "application/xml";

                case HTTPRequest::AcceptType::XHTML_XML:
                        return "application/xhtml+xml";

                case HTTPRequest::AcceptType::CSV:
                        return "text/csv";

                case HTTPRequest::AcceptType::PNG:
                        return "image/png";

                case HTTPRequest::AcceptType::GIF:
                        return "image/gif";

                case HTTPRequest::AcceptType::JPEG:
                        return "image/jpeg";

                case HTTPRequest::AcceptType::Icon:
                        return "image/x-icon";

                default:
                        break;
        }

        return fallback;
}

void HTTPConnection::clear(void) throw () {
        socket.reset();
        request.clear();
}

void HTTPConnection::response(int code, const std::string &body, const std::string &contentType, bool close) throw (ServerException) {
        try {
                Compression compression = getCompressionType(body, contentType);

                sendStatusLine(code);

                if (compression == Gzip || compression == Deflate) {
                        std::string buf = String::deflate(body, (compression == Gzip) ? String::Gzip : String::Zlib, http.getCompressionLevel());

                        sendHeaders(buf.size(), contentType, close, compression);
                        sendBody(buf);
                } else {
                        sendHeaders(body.size(), contentType, close);
                        sendBody(body);
                }
        } catch (CompressionException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        } catch (SocketException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        }
}

void HTTPConnection::response(int code, const std::vector<char> &content, const std::string &contentType, bool close) throw (ServerException) {
        try {
                Compression compression = getCompressionType(content, contentType);

                sendStatusLine(code);

                if (compression == Gzip || compression == Deflate) {    
                        std::vector<char> buf = String::deflate(content, (compression == Gzip) ? String::Gzip : String::Zlib, http.getCompressionLevel(), content.capacity());

                        sendHeaders(buf.capacity(), contentType, close, compression);
                        sendContent(buf);
                } else {
                        sendHeaders(content.capacity(), contentType, close);
                        sendContent(content);
                }
        } catch (CompressionException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        } catch (SocketException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        }
}

void HTTPConnection::sendStatusLine(int code, const std::string &detail) throw (SocketException) {
        std::string buf("HTTP/1.1 ");

        buf += Code::statusCodeDisplayString(code);

        if (!detail.empty()) {
                buf += " - ";
                buf += detail;
        }

        buf += "\r\n";

        socket->send(buf.c_str(), buf.size());
}

void HTTPConnection::sendHeaders(size_t size, const std::string &contentType, bool close, Compression compression) throw (SocketException) {
        std::string buf = buildHeaders(size, contentType, close, false, compression);

        socket->send(buf.c_str(), buf.size());
}

void HTTPConnection::sendBody(const std::string &body) throw (SocketException) {
        socket->send(body.c_str(), body.size());
}

void HTTPConnection::sendContent(const std::vector<char> &content) throw (SocketException) {
        socket->send(&content.front(), content.capacity());
}

void HTTPConnection::read(std::string &buffer) throw (ServerException) {
        char buf[262144]; /* 256K */
        ssize_t pktlen;

        try {
                do {
                        if ((pktlen = socket->recv(buf, sizeof(buf))) <= 0) {
                                THROW_CODE(ServerException, Code::InternalServerError, "socket disconnected");
                        }

                        buffer.append(buf, pktlen);
                } while (socket->hasData());
        } catch (SocketException &e) {
                RETHROW_CODE(ServerException, Code::InternalServerError, e);
        }
}

void HTTPConnection::chunker(void) throw (ServerException) {
        std::string buffer;
        size_t size;

        sendStatusLine(Code::Continue); /* Request next chunk */

        do {
                /* Read until chunk size is available */
                while ((size = buffer.find("\r\n")) == std::string::npos) {
//                      printf("READING FOR CHUNK SIZE\n");
                        read(buffer);
                }

                { /* Chunk Size */
                        std::string buf = buffer.substr(0, size);
//                      printf("Chunk Size Buffer: %s (oct)\n", buf.c_str());

                        try {
                                size = std::stoull(buf, NULL, 16);
                        } catch (std::exception &e) {
                                THROW_CODE(ServerException, Code::InternalServerError, "Invalid chunk size");
                        }

//                      printf("Chunk Size: %zd\n", size);

                        if (size == 0) {
//                              printf("GOT LAST CHUNK\n");

                                return;
                        }

                        buffer.erase(0, buf.size() + 2);
                }

                /* Read additional data, until next chunk is full. */
                while (buffer.size() < size + 2) {
//                      printf("READING FOR CHUNK DATA: buffer.size(): %zd, size + 2: %zd\n", buffer.size(), size + 2);
                        read(buffer);
                }

                { /* Chunk Data */
                        request.appendBody(buffer.substr(0, size));
                        buffer.erase(0, size + 2);
                }

                FIXME("Need to imlement support for trailers");
                /* Read any trailers, until chunk size is reached */
//              while ((size = buffer.find("\r\n")) == std::string::npos) {
//                      read(buffer);
//              }
        } while (true);
}

HTTPConnection::Compression HTTPConnection::getCompressionType(const std::string &body, const std::string &contentType) const throw () {
        Compression compression = None;

        if (http.getCompressionLevel() > 0 && body.size() > http.getCompressionThreshold()) {
                static const boost::regex pattern("^(?:text|application)");

                if (String::regex_isearch(contentType, pattern)) {
                        if (request.isAcceptGzip()) { /* Prefer gzip over deflate - deflate support is poor on some browsers */
                                compression = Gzip;
                        } else if (request.isAcceptDeflate()) {
                                compression = Deflate;
                        } else {
                                compression = None;
                        }
                }
        }

        return compression;
}

HTTPConnection::Compression HTTPConnection::getCompressionType(const std::vector<char> &content, const std::string &contentType) const throw () {
        Compression compression = None;

        if (http.getCompressionLevel() > 0 && content.capacity() > http.getCompressionThreshold()) {
                static const boost::regex pattern("^(?:text|application)");

                if (String::regex_isearch(contentType, pattern)) {
                        if (request.isAcceptGzip()) { /* Prefer gzip over deflate - deflate support is poor on some browsers */
                                compression = Gzip;
                        } else if (request.isAcceptDeflate()) {
                                compression = Deflate;
                        } else {
                                compression = None;
                        }
                }
        }

        return compression;
}

const std::string HTTPConnection::buildHeaders(size_t contentSize, const std::string &contentType, bool close, bool useAllow, Compression compression, const std::string &transferEncoding) throw () {
        std::string buf;

        buf = "Date: " + Time::getRFC1123Date() + "\r\n";
        buf += "Server: " + http.getBanner() + "\r\n";

        if (useAllow) {
                auto &&allow = http.getAllow();

                if (!allow.empty()) {
                        buf += "Allow: ";

                        for (auto a = allow.begin(), end = allow.end(); a != end; ++a) {
                                switch (*a) {
                                        case HTTPRequest::Options:
                                                buf += "OPTIONS,";
                                                break;

                                        case HTTPRequest::Get:
                                                buf += "GET,";
                                                break;

                                        case HTTPRequest::Head:
                                                buf += "HEAD,";
                                                break;

                                        case HTTPRequest::Post:
                                                buf += "POST,";
                                                break;

                                        case HTTPRequest::Put:
                                                buf += "PUT,";
                                                break;

                                        case HTTPRequest::Delete:
                                                buf += "DELETE,";
                                                break;

                                        case HTTPRequest::Trace:
                                                buf += "TRACE,";
                                                break;

                                        case HTTPRequest::Connect:
                                                buf += "CONNECT,";
                                                break;

                                        case HTTPRequest::Patch:
                                                buf += "PATCH,";
                                                break;

                                        default:
                                                break;
                                }
                        }

                        buf.erase(buf.size() - 1); /* buf.pop_back() not implemented yet. */
                        buf += "\r\n";
                }
        }

        if (transferEncoding.empty()) {
                if (request.getMethod() != HTTPRequest::Head) {
                        buf += String::sprintf("Content-Length: %zd\r\n", contentSize);
                }
        } else {
                buf += String::sprintf("Transfer-Encoding: %s\r\n", transferEncoding.c_str());
        }

        if (compression == Gzip) {
                if (request.getMethod() != HTTPRequest::Head) {
                        buf += "Content-Encoding: gzip\r\n";
                }
        } else if (compression == Deflate) {
                if (request.getMethod() != HTTPRequest::Head) {
                        buf += "Content-Encoding: deflate\r\n";
                }
        }

        const auto &headers = http.getCustomHeaders();
        for (auto h = headers.begin(), end = headers.end(); h != end; ++h) {
                buf += *h + "\r\n";
        }

        if (close) {
                buf += "Connection: close\r\n";
        }

        buf += "Content-Type: " + contentType + "\r\n";

        buf += "\r\n";

        return buf;
}

void HTTPConnection::getFileContent(const std::string &file, std::vector<char> &content, std::string &contentType) throw (ServerException) {
        try {
                std::string buf;
                std::string fullpath = request.getFullpath(file);
                std::ifstream ifile(fullpath, std::ifstream::in);
                size_t size = getFileSize(ifile);

                content.reserve(size); /* Changes capacity, but not size. */
                ifile.read(&content.front(), size);

                if (!ifile) {
                        THROW_CODE(ServerException, Code::InternalServerError, "Read only %zd/%zd bytes from file", ifile.gcount(), size);
                }

                contentType = request.getMIMEType(fullpath, MIMEFallback);
        } catch (std::ifstream::failure &e) {
                RETHROW_CODE(ServerException, Code::NotFound, e);
        }
}

size_t HTTPConnection::getFileSize(std::ifstream &ifile) throw (ServerException) {
        if (!ifile.is_open()) {
                THROW_CODE(ServerException, Code::Forbidden, "You don't have permission to access %s on this server.", request.getPath().c_str());
        }

        ifile.seekg(0, std::ios::end);
        size_t size = ifile.tellg();
        ifile.seekg(0, std::ios::beg);

        if (size > http.getRequestBodyLimit()) {
                THROW_CODE(ServerException, Code::RequestEntityTooLarge, "The requested URI %s is larger than the configured limit of %zd bytes.", request.getPath().c_str(), http.getRequestBodyLimit()).c_str();
        }

        return size;
}

std::string HTTPConnection::getErrorBody(int code, const std::string &detail, const std::string &callback) throw () {
        std::string body, status(Code::statusCodeString(code));
        std::string displayStatus(Code::statusCodeDisplayString(code));
        HTTPRequest::AcceptType type = request.getAcceptType(http.getFallbackAcceptType());

        switch (type) {
                case HTTPRequest::AcceptType::Any:
                case HTTPRequest::AcceptType::Text_Any:
                case HTTPRequest::AcceptType::HTML:
                        if (!http.getBanner().empty()) {
                                std::string banner = http.getBanner();

                                body = "<html><head><title>" + displayStatus + "</title></head><body><h1>" + displayStatus + "</h1>" + detail + "<p><hr><address>" + banner + "</address></body></html>\r\n";
                        } else {
                                body = "<html><head><title>" + displayStatus + "</title></head><body><h1>" + displayStatus + "</h1>" + detail + "</body></html>\r\n";
                        }

                        break;

                case HTTPRequest::AcceptType::JSON:
                        body = String::sprintf("{ \"error\": { \"code\": %d, \"status\": \"%s\", \"message\": \"%s\" }}", code, status.c_str(), String::escape(detail).c_str());

                        break;

                case HTTPRequest::AcceptType::JSONP:
                        body = String::sprintf("%s({ \"error\": { \"code\": %d, \"status\": \"%s\", \"message\": \"%s\" } })", callback.c_str(), code, status.c_str(), String::escape(detail).c_str());

                        break;

                case HTTPRequest::AcceptType::XHTML_XML:
                case HTTPRequest::AcceptType::XML:
                        body = "<error><code>" + String::sprintf("%d", code) + "</code><status>" + status + "</status><message>" + detail + "</message></error>\r\n";

                        break;

                case HTTPRequest::AcceptType::Text:
                case HTTPRequest::AcceptType::Plain:
                        body = String::sprintf("code: %d, status: %s, message: %s", code, status.c_str(), detail.c_str());

                        break;

                default:
                        break;
        }

        return body;
}

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