httpclient.hpp

/* Copyright (c) 2014, The Nuria Project
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any damages
 * arising from the use of this software.
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *    1. The origin of this software must not be misrepresented; you must not
 *       claim that you wrote the original software. If you use this software
 *       in a product, an acknowledgment in the product documentation would be
 *       appreciated but is not required.
 *    2. Altered source versions must be plainly marked as such, and must not be
 *       misrepresented as being the original software.
 *    3. This notice may not be removed or altered from any source
 *       distribution.
 */

#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 HttpServer;
class HttpNode;
class SlotInfo;

class NURIA_NETWORK_EXPORT HttpClient : public QIODevice {
    Q_OBJECT
    Q_ENUMS(HttpVerb)
    Q_ENUMS(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
        
    };
    
    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 ();
    
    bool atEnd () 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 receivedData ();
    
    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 ();
    
private:
    friend class HttpServer;
    friend class HttpNode;
    
    bool readRangeRequestHeader ();
    
    void readRequestCookies ();
    
    qint64 parseIntegerHeaderValue (const QByteArray &value);
    bool readPostBodyContentLength ();
    bool send100ContinueIfClientExpectsIt ();
    bool readAllAvailableHeaderLines ();
    bool readFirstLine (const QByteArray &line);
    bool readHeader (const QByteArray &line);
    bool isReceivedHeaderHttp11Compliant ();
    bool verifyPostRequestCompliance ();
    bool verifyCompleteHeader ();
    bool invokeRequestedPath ();
    bool closeConnectionIfNoLongerNeeded ();
    bool verifyRequestBodyOrClose ();
    bool requestHasPostBody () const;
    bool postProcessRequestHeader ();
    bool contentTypeIsMultipart (const QByteArray &value) const;
    HttpPostBodyReader *createHttpMultiPartReader (const QByteArray &header);
    
    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