HTTPConnection.h

/*
** libutil++
** $Id: HTTPConnection.h 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
*/

#ifndef __libutilxx__sella__server__HTTPConnection_H__
#define __libutilxx__sella__server__HTTPConnection_H__

#include "../../common.h"
#include "../net/SocketException.h"
#include "../net/TCPSocket.h"
#include "../net/SecureTCPSocket.h"
#include "../util/Time.h"
#include "Code.h"
#include "HTTPRequest.h"
#include "ServerException.h"

#include <set>
#include <memory>

namespace sella {
        namespace server {
                class HTTPConnection;
                class HTTP;
        }
}

class sella::server::HTTPConnection {
        public:
                typedef std::shared_ptr<HTTPConnection> shared;

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

                enum Compression : uint8_t { None, Gzip, Deflate };

        public:
                HTTPConnection(const HTTP &http, sella::net::TCPSocket::shared &socket, timeval tv = ReceiveTimeoutDefault) throw ();
                virtual ~HTTPConnection() throw ();

                static const HTTPConnection::shared shared_ptr(const HTTP &http, sella::net::TCPSocket::shared &socket, timeval tv = ReceiveTimeoutDefault) throw ();

                const HTTPRequest& getRequest(void) throw (ServerException);
                struct timespec getRuntime(void) const throw ();
                bool isUsable(void) const throw ();
                bool isSecure(void) const throw ();

                void response(const std::string &body, const std::string &contentType = ContentTypeDefault, bool close = true) throw (ServerException);
                void response(const std::vector<char> &content, const std::string &contentType, bool close = true) throw (ServerException);
                void error(int code, const std::string &detail = std::string(), const std::string &contentType = ContentTypeDefault) throw (ServerException);
                void error(int code, const std::vector<char> &content, const std::string &contentType = ContentTypeDefault) throw (ServerException);

                void methodOptions(void) throw (ServerException);
                void methodGet(void) throw (ServerException);
                void methodHead(void) throw (ServerException);
                void methodPost(void) throw (ServerException);
                void methodPut(void) throw (ServerException);
                void methodDelete(void) throw (ServerException);
                void methodTrace(void) throw (ServerException);
                void methodConnect(void) throw (ServerException);
                void methodPatch(void) throw (ServerException);

                sella::net::IPAddressPort getLocalIPAddressPort(void) const throw (ServerException);
                sella::net::IPAddressPort getRemoteIPAddressPort(void) const throw (ServerException);

                const char* getSSLLibraryVersion(void) const throw ();
                const char* getActiveProtocol(void) const throw ();
                const char* getActiveCipher(void) const throw ();

                std::string getContentType(HTTPRequest::AcceptType type, const std::string &fallback = std::string()) const throw ();

                void clear(void) throw ();

        protected:
                const HTTP &http;
                sella::net::TCPSocket::shared socket;
                struct timespec start;
                HTTPRequest request;

                void response(int code, const std::string &body, const std::string &contentType = ContentTypeDefault, bool close = true) throw (ServerException);
                void response(int code, const std::vector<char> &content, const std::string &contentType, bool close = true) throw (ServerException);

                void sendStatusLine(int code, const std::string &detail = std::string()) throw (sella::net::SocketException);
                void sendHeaders(size_t size, const std::string &contentType = ContentTypeDefault, bool close = true, Compression compression = None) throw (sella::net::SocketException);
                void sendBody(const std::string &body) throw (sella::net::SocketException);
                void sendContent(const std::vector<char> &content) throw (sella::net::SocketException);

                void read(std::string &buffer) throw (ServerException);
                void chunker(void) throw (ServerException);

                Compression getCompressionType(const std::string &body, const std::string &contentType) const throw ();
                Compression getCompressionType(const std::vector<char> &content, const std::string &contentType) const throw ();

                const std::string buildHeaders(size_t contentSize, const std::string &contentType = ContentTypeDefault, bool close = true, bool useAllow = false, Compression compression = None, const std::string &transferEncoding = std::string()) throw ();

                void getFileContent(const std::string &file, std::vector<char> &content, std::string &contentType) throw (ServerException);
                size_t getFileSize(std::ifstream &ifile) throw (ServerException);
                std::string getErrorBody(int code, const std::string &detail = std::string(), const std::string &callback = std::string()) throw ();
};

#endif

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