qhttp.h

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtNetwork module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#ifndef QHTTP_H
#define QHTTP_H

#include <qobject.h>
#include <qstringlist.h>
#include <qmap.h>
#include <qpair.h>
#include <qscopedpointer.h>
#include <qtcpsocket.h>

QT_BEGIN_HEADER

class QTcpSocket;
class QTimerEvent;
class QIODevice;
class QAuthenticator;
class QNetworkProxy;
class QSslError;

class QHttpPrivate;

class QHttpHeaderPrivate;
class QHttpHeader
{
public:
        QHttpHeader();
        QHttpHeader(const QHttpHeader & header);
        QHttpHeader(const QString & str);
        virtual ~QHttpHeader();

        QHttpHeader & operator=(const QHttpHeader & h);

        void setValue(const QString & key, const QString & value);
        void setValues(const QList<QPair<QString, QString>> & values);
        void addValue(const QString & key, const QString & value);
        QList<QPair<QString, QString>> values() const;
        bool hasKey(const QString & key) const;
        QStringList keys() const;
        QString value(const QString & key) const;
        QStringList allValues(const QString & key) const;
        void removeValue(const QString & key);
        void removeAllValues(const QString & key);

        // ### Qt 5: change to qint64
        bool hasContentLength() const;
        uint contentLength() const;
        void setContentLength(int len);

        bool hasContentType() const;
        QString contentType() const;
        void setContentType(const QString & type);

        virtual QString toString() const;
        bool isValid() const;

        virtual int majorVersion() const = 0;
        virtual int minorVersion() const = 0;

protected:
        virtual bool parseLine(const QString & line, int number);
        bool parse(const QString & str);
        void setValid(bool);

        QHttpHeader(QHttpHeaderPrivate & dd, const QString & str = QString());
        QHttpHeader(QHttpHeaderPrivate & dd, const QHttpHeader & header);
        QScopedPointer<QHttpHeaderPrivate> d_ptr;

private:
        Q_DECLARE_PRIVATE(QHttpHeader)
};

class QHttpResponseHeaderPrivate;
class QHttpResponseHeader : public QHttpHeader
{
public:
        QHttpResponseHeader();
        QHttpResponseHeader(const QHttpResponseHeader & header);
        QHttpResponseHeader(const QString & str);
        QHttpResponseHeader(int code, const QString & text = QString(), int majorVer = 1, int minorVer = 1);
        QHttpResponseHeader & operator=(const QHttpResponseHeader & header);

        void setStatusLine(int code, const QString & text = QString(), int majorVer = 1, int minorVer = 1);

        int statusCode() const;
        QString reasonPhrase() const;

        int majorVersion() const;
        int minorVersion() const;

        QString toString() const;

protected:
        bool parseLine(const QString & line, int number);

private:
        Q_DECLARE_PRIVATE(QHttpResponseHeader)
        friend class QHttpPrivate;
};

class QHttpRequestHeaderPrivate;
class QHttpRequestHeader : public QHttpHeader
{
public:
        QHttpRequestHeader();
        QHttpRequestHeader(const QString & method, const QString & path, int majorVer = 1, int minorVer = 1);
        QHttpRequestHeader(const QHttpRequestHeader & header);
        QHttpRequestHeader(const QString & str);
        QHttpRequestHeader & operator=(const QHttpRequestHeader & header);

        void setRequest(const QString & method, const QString & path, int majorVer = 1, int minorVer = 1);

        QString method() const;
        QString path() const;

        int majorVersion() const;
        int minorVersion() const;

        QString toString() const;

protected:
        bool parseLine(const QString & line, int number);

private:
        Q_DECLARE_PRIVATE(QHttpRequestHeader)
};

class QHttp : public QObject
{
        Q_OBJECT

public:
        enum ConnectionMode
        {
                ConnectionModeHttp,
                ConnectionModeHttps
        };

        explicit QHttp(QObject * parent = 0);
        QHttp(const QString & hostname, quint16 port = 80, QObject * parent = 0);
        QHttp(const QString & hostname, ConnectionMode mode, quint16 port = 0, QObject * parent = 0);
        virtual ~QHttp();

        enum State
        {
                Unconnected,
                HostLookup,
                Connecting,
                Sending,
                Reading,
                Connected,
                Closing
        };
        enum Error
        {
                NoError,
                UnknownError,
                HostNotFound,
                ConnectionRefused,
                UnexpectedClose,
                InvalidResponseHeader,
                WrongContentLength,
                Aborted,
                AuthenticationRequiredError,
                ProxyAuthenticationRequiredError
        };

        int setHost(const QString & hostname, quint16 port = 80);
        int setHost(const QString & hostname, ConnectionMode mode, quint16 port = 0);

        int setSocket(QTcpSocket * socket);
        int setUser(const QString & username, const QString & password = QString());

#ifndef QT_NO_NETWORKPROXY
        int setProxy(const QString & host, int port,
            const QString & username = QString(),
            const QString & password = QString());
        int setProxy(const QNetworkProxy & proxy);
#endif

        int get(const QString & path, QIODevice * to = 0);
        int post(const QString & path, QIODevice * data, QIODevice * to = 0);
        int post(const QString & path, const QByteArray & data, QIODevice * to = 0);
        int head(const QString & path);
        int request(const QHttpRequestHeader & header, QIODevice * device = 0, QIODevice * to = 0);
        int request(const QHttpRequestHeader & header, const QByteArray & data, QIODevice * to = 0);

        int closeConnection();
        int close();

        qint64 bytesAvailable() const;
        qint64 read(char * data, qint64 maxlen);
        QByteArray readAll();

        int currentId() const;
        QIODevice * currentSourceDevice() const;
        QIODevice * currentDestinationDevice() const;
        QHttpRequestHeader currentRequest() const;
        QHttpResponseHeader lastResponse() const;
        bool hasPendingRequests() const;
        void clearPendingRequests();

        State state() const;

        Error error() const;
        QString errorString() const;

public Q_SLOTS:
        void abort();

#ifndef QT_NO_OPENSSL
        void ignoreSslErrors();
#endif

Q_SIGNALS:
        void stateChanged(int);
        void responseHeaderReceived(const QHttpResponseHeader & resp);
        void readyRead(const QHttpResponseHeader & resp);

        // ### Qt 5: change to qint64
        void dataSendProgress(int, int);
        void dataReadProgress(int, int);

        void requestStarted(int);
        void requestFinished(int, bool);
        void done(bool);

#ifndef QT_NO_NETWORKPROXY
        void proxyAuthenticationRequired(const QNetworkProxy & proxy, QAuthenticator *);
#endif
        void authenticationRequired(const QString & hostname, quint16 port, QAuthenticator *);

#ifndef QT_NO_OPENSSL
        void sslErrors(const QList<QSslError> & errors);
#endif

private:
        Q_DISABLE_COPY(QHttp)
        QScopedPointer<QHttpPrivate> d;

        void _q_startNextRequest();
        void _q_slotReadyRead();
        void _q_slotConnected();
        void _q_slotError(QAbstractSocket::SocketError e);
        void _q_slotClosed();
        void _q_slotBytesWritten(qint64 numBytes);
#ifndef QT_NO_OPENSSL
        void _q_slotEncryptedBytesWritten(qint64 numBytes);
#endif
        void _q_slotDoFinished();
        void _q_slotSendRequest();
        void _q_continuePost();

        friend class QHttpNormalRequest;
        friend class QHttpSetHostRequest;
        friend class QHttpSetSocketRequest;
        friend class QHttpSetUserRequest;
        friend class QHttpSetProxyRequest;
        friend class QHttpCloseRequest;
        friend class QHttpPGHRequest;
};

QT_END_HEADER

#endif // QHTTP_H