httpclient.hpp

/* Copyright (c) 2014-2015, The Nuria Project
 * The NuriaProject Framework is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of the License,
 * or (at your option) any later version.
 * 
 * The NuriaProject Framework is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with The NuriaProject Framework.
 * If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef NURIA_HTTPCLIENT_HPP
#define NURIA_HTTPCLIENT_HPP

#include "httppostbodyreader.hpp"
#include "network_global.hpp"
#include <QNetworkCookie>
#include <QHostAddress>
#include <QIODevice>
#include <QMetaType>
#include <QMap>
#include <QUrl>

namespace Nuria {

class HttpClientPrivate;
class HttpTransport;
class HttpFilter;
class HttpServer;
class HttpNode;
class SlotInfo;

class NURIA_NETWORK_EXPORT HttpClient : public QIODevice {
        Q_OBJECT
        Q_ENUMS(HttpVerb HttpHeader)
        Q_FLAGS(HttpVerbs)
public:
        
        enum HttpVersion {
                HttpUnknown,
                Http1_0, 
                Http1_1 
        };
        
        enum HttpVerb {
                InvalidVerb = 0,
                GET = 1, 
                POST = 2, 
                HEAD = 4, 
                PUT = 8, 
                DELETE = 16, 
                
                AllVerbs = GET | POST | HEAD | PUT | DELETE
        };
        
        Q_DECLARE_FLAGS(HttpVerbs, HttpVerb)
        
        
        enum HttpHeader {
                
                /* Request and response */
                HeaderCacheControl = 0,
                HeaderContentLength,
                HeaderContentType,
                HeaderConnection,
                HeaderDate,
                
                /* Request only */
                HeaderHost = 1000, 
                HeaderUserAgent, 
                HeaderAccept,
                HeaderAcceptCharset,
                HeaderAcceptEncoding,
                HeaderAcceptLanguage,
                HeaderAuthorization,
                HeaderCookie,
                HeaderRange,
                HeaderReferer,
                HeaderDoNotTrack,
                HeaderExpect,
                
                /* Response only */
                HeaderContentEncoding = 2000,
                HeaderContentLanguage,
                HeaderContentDisposition,
                HeaderContentRange,
                HeaderLastModified,
                HeaderRefresh,
                HeaderSetCookie,
                HeaderTransferEncoding,
                HeaderLocation
                
        };
        
        enum TransferMode {
                
                Streaming = 0,
                
                Buffered,
                
                ChunkedStreaming
        };
        
        enum ConnectionMode {
                
                ConnectionClose = 0,
                
                ConnectionKeepAlive
        };
        
        enum StandardFilter {
                
                DeflateFilter = 0,
                
                GzipFilter = 1
                
        };
        
        enum class RedirectMode {
                
                Keep = 0,
                
                ForceSecure,
                
                ForceUnsecure
        };
        
        typedef QMultiMap< QByteArray, QByteArray > HeaderMap;
        
        explicit HttpClient (HttpTransport *transport, HttpServer *server);
        
        virtual ~HttpClient ();
        
        HttpTransport *transport () const;
        
        static QByteArray httpStatusCodeName (int code);
        
        static QByteArray httpHeaderName (HttpHeader header);
        
        bool isHeaderReady () const;
        
        bool responseHeaderSent () const;
        
        HttpVerb verb () const;
        
        QUrl path () const;
        
        bool hasRequestHeader (const QByteArray &key) const;
        
        bool hasRequestHeader (HttpHeader header) const;
        
        QByteArray requestHeader (const QByteArray &key) const;
        
        QByteArray requestHeader (HttpHeader header) const;
        
        QList< QByteArray > requestHeaders (const QByteArray &key) const;
        
        QList< QByteArray > requestHeaders (HttpHeader header) const;
        
        const HeaderMap &requestHeaders () const;
        
        bool hasResponseHeader (const QByteArray &key) const;
        
        bool hasResponseHeader (HttpHeader header) const;
        
        const HeaderMap &responseHeaders () const;
        
        QList< QByteArray > responseHeaders (const QByteArray &key) const;
        
        QList< QByteArray > responseHeaders (HttpHeader header) const;
        
        bool setResponseHeader (const QByteArray &key, const QByteArray &value, bool append = false);
        
        bool setResponseHeader (HttpHeader header, const QByteArray &value, bool append = false);
        
        bool setResponseHeaders (const HeaderMap &headers);
        
        bool pipeToClient (QIODevice *device, qint64 maxlen = -1);
        
        bool pipeFromPostBody (QIODevice *device, bool takeOwnership = false);
        
        qint64 rangeStart () const;
        
        qint64 rangeEnd () const;
        
        qint64 contentLength () const;
        
        bool setRangeStart (qint64 pos);
        
        bool setRangeEnd (qint64 pos);
        
        bool setContentLength (qint64 length);
        
        virtual bool isSequential () const;
        
        qint64 postBodyLength () const;
        
        qint64 postBodyTransferred ();
        
        QHostAddress localAddress () const;
        
        quint16 localPort () const;
        
        QHostAddress peerAddress () const;
                
        quint16 peerPort () const;
        
        int responseCode () const;
        
        void setResponseCode (int code);
        
        bool isConnectionSecure () const;
        
        HttpServer *httpServer () const;
        
        typedef QMap< QByteArray, QNetworkCookie > Cookies;
        
        Cookies cookies ();
        
        QNetworkCookie cookie (const QByteArray &name);
        
        bool hasCookie (const QByteArray &name);
        
        void setCookie (const QByteArray &name, const QByteArray &value,
                        const QDateTime &expires, bool secure = false);
        
        void setCookie (const QByteArray &name, const QByteArray &value,
                        qint64 maxAge = 0, bool secure = false);
        
        void setCookie (const QNetworkCookie &cookie);
        
        void removeCookie (const QByteArray &name);
        
        bool keepConnectionOpen () const;
        
        void setKeepConnectionOpen (bool keepOpen);
        
        SlotInfo slotInfo () const;
        
        void setSlotInfo (const SlotInfo &info);
        
        bool hasReadablePostBody () const;
        
        HttpPostBodyReader *postBodyReader ();
        
        TransferMode transferMode () const;
        
        bool setTransferMode (TransferMode mode);
        
        ConnectionMode connectionMode () const;
        
        bool requestCompletelyReceived () const;
        
        bool requestHasPostBody () const;
        
        void addFilter (StandardFilter filter);
        
        void addFilter (HttpFilter *filter);
        
        void removeFilter (StandardFilter filter);
        
        void removeFilter (HttpFilter *filter);
        
        bool redirectClient (const QString &localPath, RedirectMode mode = RedirectMode::Keep,
                             int statusCode = 307);
        
        bool redirectClient (const QUrl &remoteUrl, int statusCode = 307);
        
        bool atEnd () const override;
        
        bool manualInit (HttpVerb verb, HttpVersion version, const QByteArray &path, const HeaderMap &headers);
        
        // 
        qint64 bytesAvailable () const override;
        qint64 pos () const override;
        qint64 size () const override;
        bool seek (qint64 pos) override;
        bool reset () override;
        
signals:
        
        void disconnected ();
        
        void headerReady ();
        
        void postBodyComplete ();
        
public slots:
        
        bool killConnection (int error, const QString &cause = QString());
        
        bool sendResponseHeader ();
        
        void close () override;
        
        void forceClose ();
        
private slots:
        
        void clientDisconnected ();
        
        void pipeToClientReadyRead ();
        
protected:
        
        virtual qint64 readData (char *data, qint64 maxlen);
        
        virtual qint64 writeData (const char *data, qint64 len);
        
        bool resolveUrl (const QUrl &url);
        
        bool bufferPostBody (QByteArray &data);
        
private:
        friend class HttpTransport;
        friend class HttpServer;
        friend class HttpNode;
        
        bool readRangeRequestHeader ();
        
        void readRequestCookies ();
        
        bool sendRedirectResponse (const QByteArray &location, const QByteArray &display, int code);
        void updateRequestedUrl ();
        
        void bytesSent (qint64 bytes);
        void processData (QByteArray &data);
        
        bool sendChunkedData (const QByteArray &data);
        qint64 parseIntegerHeaderValue (const QByteArray &value);
        bool readPostBodyContentLength ();
        bool send100ContinueIfClientExpectsIt ();
        bool readAllAvailableHeaderLines (QByteArray &data);
        bool readFirstLine (const QByteArray &line);
        bool readHeader (const QByteArray &line);
        bool isReceivedHeaderHttp11Compliant ();
        bool verifyPostRequestCompliance ();
        bool verifyCompleteHeader ();
        bool invokeRequestedPath ();
        bool readConnectionHeader ();
        bool closeConnectionIfNoLongerNeeded ();
        bool postProcessRequestHeader ();
        bool contentTypeIsMultipart (const QByteArray &value) const;
        bool contentTypeIsUrlEncoded (const QByteArray &value) const;
        HttpPostBodyReader *createHttpMultiPartReader (const QByteArray &header);
        HttpPostBodyReader *createUrlEncodedPartReader (const QByteArray &header);
        qint64 writeDataInternal (QByteArray data);
        bool sendData (const QByteArray &data);
        void closeInternal ();
        QByteArray filterInit ();
        QByteArray filterDeinit ();
        bool filterData (QByteArray &data);
        bool filterHeaders (HeaderMap &headers);
        void addFilterNameToHeader (HeaderMap &headers, const QByteArray &name);
        void initPath (QByteArray path);
        
        bool sendPipeChunkToClient ();
        
        // 
        HttpClientPrivate *d_ptr;
        
};

}

Q_DECLARE_OPERATORS_FOR_FLAGS(Nuria::HttpClient::HttpVerbs)
Q_DECLARE_METATYPE(Nuria::HttpClient::HttpVersion)
Q_DECLARE_METATYPE(Nuria::HttpClient::HttpVerbs)
Q_DECLARE_METATYPE(Nuria::HttpClient::HttpVerb)
Q_DECLARE_METATYPE(Nuria::HttpClient*)

#endif // NURIA_HTTPCLIENT_HPP