helpers.cpp

/*
** libutil++
** $Id: helpers.cpp 1653 2016-02-28 19:54:59Z 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: helpers.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "helpers.h"
#include "../util/CommonMacro.h"
#include "../util/Log.h"
#include "../util/String.h"
#include "../net/IPAddressPort.h"

using namespace sella::server;

sella::variant::Variant http::parseURI(const HTTPConnection::shared &connection, bool addHeader, bool addSession, bool addCRUD, bool addBody) throw () {
        sella::variant::Variant data;

        const HTTPRequest &req = connection->getRequest();

        auto &uri = data["_uri"];
        const std::string &ruri = req.getURI();
        const std::string &path = req.getPath();
        const std::string &query = req.getQuery();
        const std::string &host = req.getHost();
        const auto &headers = req.getHeaders();
        sella::net::IPAddressPort local = connection->getLocalIPAddressPort();
        sella::net::IPAddressPort remote = connection->getRemoteIPAddressPort();
        std::vector<std::string> parts;

        /* Variables first. */
        parts = sella::util::String::split(query, '&', false);
        for (auto p = parts.begin(); p != parts.end(); ++p) {
                const auto &kv = sella::util::String::split(*p, '=', true, 2);

                if (kv.size() == 1) {
                        uri[kv.at(0)];
                } else if (kv.size() == 2) {
                        uri[kv.at(0)] = sella::variant::Variant(kv.at(1), sella::variant::Variant::TypeAuto);
                }
        }

        /* URI second, since it takes priority over variable names, which may overlap. */
        parts = sella::util::String::split(path, '/', false);
        for (size_t i = 0; i < parts.size(); i++) {
                uri[sella::util::String::sprintf("%zd", i + 2)] = parts.at(i);
        }

        if (connection->isSecure()) {
                uri["0"] = std::string("https://").append(host).append(ruri);
        } else {
                uri["0"] = std::string("http://").append(host).append(ruri);
        }

        uri["1"] = host;

        if (addHeader) {
                auto &header = data["_header"];

                for (auto h = headers.begin(); h != headers.end(); ++h) {
                        std::vector<std::string> parts = sella::util::String::split(*h, ": ", true, true);
                        
                        if (parts.size() == 2) {
                                header[parts[0]] = parts[1];
                        } else if (parts.size() == 1) {
                                header[parts[0]];
                        }
                }
        }

        if (addSession) {
                auto &session = data["_session"];

                try {
                        size_t pos = host.find_last_of(':'), pos2 = host.find_last_of(']');

                        if (pos == std::string::npos || (pos2 != std::string::npos && pos2 > pos)) {
                                session["vhost"] = host;
                                session["port"] = local.getPort().str();
                        } else {
                                session["vhost"] = host.substr(0, pos);
                                session["port"] = host.substr(pos + 1);
                        }
                } catch (std::out_of_range &e) {
                        if (addSession && !session.contains("vhost")) {
                                session["vhost"] = "default";
                        }
                }

                session["secure"] = connection->isSecure();
                session["method"] = req.getMethodRaw();
                session["version"] = req.getVersion();
                session["uri"] = ruri;
                session["path"] = path;
                session["query"] = query;
                session["local"] = local.str();
                session["local-ip"] = local.getIPAddress().str();
                session["local-port"] = local.getPort().str();
                session["remote"] = remote.str();
                session["remote-ip"] = remote.getIPAddress().str();
                session["remote-port"] = remote.getPort().str();
        }

        if (addCRUD) {
                auto &session = data["_session"];

                switch (req.getMethod()) { /* http://en.wikipedia.org/wiki/Create,_read,_update_and_delete */
                        case HTTPRequest::Post:
                                session["function"] = CRUD::Create;
                                session["function-name"] = "create";
                                break;

                        case HTTPRequest::Get:
                                session["function"] = CRUD::Read;
                                session["function-name"] = "read";
                                break;

                        case HTTPRequest::Patch:
                        case HTTPRequest::Put: /* Should be interpreted as create, if new URL. */
                                session["function"] = CRUD::Update;
                                session["function-name"] = "update";
                                break;

                        case HTTPRequest::Delete:
                                session["function"] = CRUD::Delete;
                                session["function-name"] = "delete";
                                break;

                        default:
                                session["function"] = CRUD::None;
                                session["function-name"] = "none";
                                break;
                }
        }

        if (addBody) {
                data["_body"] = sella::variant::Variant(req.getBody(), sella::variant::Variant::TypeAuto);
        }

        return data;
}

std::string http::buildOutput(const HTTPConnection::shared &connection, sella::variant::Variant &data) throw (ServerException) {
        std::string output;
        const HTTPRequest &request = connection->getRequest();

        switch (request.getAcceptType()) {
                case HTTPRequest::AcceptType::JSON:
                        output = data.json();

                        break;

                case HTTPRequest::AcceptType::XML:
                        output = data.xml();

                        break;

                case HTTPRequest::AcceptType::CSV:
                        output = data.csv();

                        break;

                default:
                        output = data.str();

                        break;
        }

        return output;
}

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