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

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

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

#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <magic.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),
        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;
}

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

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) 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 = ContentTypeDefault) 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::OK);
                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);
        }
}

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 {
                sendStatusLine(code);
                sendHeaders(body.size(), contentType, close);
                sendBody(body);
        } 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 {
                sendStatusLine(code);
                sendHeaders(content.capacity(), contentType, close);
                sendContent(content);
        } 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 += statusCodeString(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) throw (SocketException) {
        std::string buf = buildHeaders(size, contentType, close);

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

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

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

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

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

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

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

        if (useAllow && !http.getAllow().empty()) {
                buf += "Allow: ";

                for (auto a = http.getAllow().begin(); a != http.getAllow().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());
        }

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

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

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

        buf += "\r\n";

        return buf;
}

std::string HTTPConnection::statusCodeString(int code) throw () {
        switch (code) {
                case 100:
                        return std::string("100 Continue");

                case 101:
                        return std::string("101 Switching Protocols");

                case 200:
                        return std::string("200 OK");

                case 201:
                        return std::string("201 Created");

                case 202:
                        return std::string("202 Accepted");

                case 203:
                        return std::string("203 Non-Authoritative Information");

                case 204:
                        return std::string("204 No Content");

                case 205:
                        return std::string("205 Reset Content");

                case 206:
                        return std::string("206 Partial Content");

                case 300:
                        return std::string("300 Multiple Choices");

                case 301:
                        return std::string("301 Moved Permanently");

                case 302:
                        return std::string("302 Found");

                case 303:
                        return std::string("303 See Other");

                case 304:
                        return std::string("304 Not Modified");

                case 305:
                        return std::string("305 Use Proxy");

                case 307:
                        return std::string("307 Temporary Redirect");

                case 400:
                        return std::string("400 Bad Request");

                case 401:
                        return std::string("401 Unauthorized");

                case 402:
                        return std::string("402 Payment Required");

                case 403:
                        return std::string("403 Forbidden");

                case 404:
                        return std::string("404 Not Found");

                case 405:
                        return std::string("405 Method Not Allowed");

                case 406:
                        return std::string("406 Not Acceptable");

                case 407:
                        return std::string("407 Proxy Authentication Required");

                case 408:
                        return std::string("408 Request Time-out");

                case 409:
                        return std::string("409 Conflict");

                case 410:
                        return std::string("410 Gone");

                case 411:
                        return std::string("411 Length Required");

                case 412:
                        return std::string("412 Precondition Failed");

                case 413:
                        return std::string("413 Request Entity Too Large");

                case 414:
                        return std::string("414 Request-URI Too Large");

                case 415:
                        return std::string("415 Unsupported Media Type");

                case 416:
                        return std::string("416 Requested range not satisfiable");

                case 417:
                        return std::string("417 Expectation Failed");

                case 500:
                        return std::string("500 Internal Server Error");

                case 501:
                        return std::string("501 Not Implemented");

                case 502:
                        return std::string("502 Bad Gateway");

                case 503:
                        return std::string("503 Service Unavailable");

                case 504:
                        return std::string("504 Gateway Time-out");

                case 505:
                        return std::string("505 HTTP Version not supported");
        }

        if (code >= 500 && code < 600) {
                return String::sprintf("%d Server Error", code);
        } else if (code >= 400) {
                return String::sprintf("%d Client Error", code);
        } else if (code >= 300) {
                return String::sprintf("%d Redirection", code);
        } else if (code >= 200) {
                return String::sprintf("%d Successful", code);
        } else if (code >= 100) {
                return String::sprintf("%d Informational", code);
        }

        return String::sprintf("%d Unknown", code);
}

std::string HTTPConnection::getMIMEType(const std::string &file, const std::string &fallback) const throw (ServerException) {
        std::string result;
        magic_t magic_cookie;

        if ((magic_cookie = magic_open(MAGIC_MIME)) == NULL) {
                if (fallback.empty()) {
                        THROW_CODE(ServerException, Code::InternalServerError, "magic_open: failed to initialize");
                }

                return fallback;
        }

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

                if (fallback.empty()) {
                        THROW_CODE(ServerException, Code::InternalServerError, err.c_str());
                }

                return fallback;
        }

        result = magic_file(magic_cookie, file.c_str());
        magic_close(magic_cookie);

        return result;
}

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

        if (file.empty()) {
                fullpath += request.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.", request.getPath().c_str());
}

void HTTPConnection::getFileContent(const std::string &file, std::vector<char> &content, std::string &contentType) throw (ServerException) {
        try {
                std::string buf;
                std::string fullpath = 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);
                ifile.close();

                contentType = 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) throw () {
        std::string body, buf(statusCodeString(code));

        if (!http.getBanner().empty()) {
                std::string banner = http.getBanner();

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

        return body;
}

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

---