HTTPConnection.h

//
//  HTTPConnection.h
//  libraries/embedded-webserver/src
//
//  Created by Stephen Birarda on 1/16/14.
//  Copyright 2014 High Fidelity, Inc.
//
//  Heavily based on Andrzej Kapolka's original HTTPConnection class
//  found from another one of his projects.
//  https://github.com/ey6es/witgap/tree/master/src/cpp/server/http
//
//  Distributed under the Apache License, Version 2.0.
//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
 
#ifndef hifi_HTTPConnection_h
#define hifi_HTTPConnection_h
 
#include <QHash>
#include <QIODevice>
#include <QList>
#include <QtNetwork/QHostAddress>
#include <QtNetwork/QNetworkAccessManager>
#include <QObject>
#include <QPair>
#include <QTemporaryFile>
#include <QUrl>
 
#include <memory>
 
class QTcpSocket;
class HTTPManager;
class MaskFilter;
class ServerApp;
 
typedef QHash<QByteArray, QByteArray> Headers;
 
typedef QPair<Headers, QByteArray> FormData;
 
class HTTPConnection : public QObject {
   Q_OBJECT
 
public:
    static const char* StatusCode200;
    static const char* StatusCode204;
    static const char* StatusCode301;
    static const char* StatusCode302;
    static const char* StatusCode400;
    static const char* StatusCode401;
    static const char* StatusCode403;
    static const char* StatusCode404;
    static const char* StatusCode500;
    static const char* DefaultContentType;
 
    enum ReasonCode { NoReason = 0, NormalClosure = 1000, GoingAway = 1001 };
 
    class Storage {
    public:
        Storage() = default;
        virtual ~Storage() = default;
 
        virtual const QByteArray& content() const = 0;
 
        virtual qint64 bytesLeftToWrite() const = 0;
        virtual void write(const QByteArray& data) = 0;
    };
 
    HTTPConnection(QTcpSocket* socket, HTTPManager* parentManager);
 
    virtual ~HTTPConnection();
 
    QTcpSocket* socket() const { return _socket; }
 
    const QHostAddress &peerAddress() const { return _address; }
 
    QNetworkAccessManager::Operation requestOperation() const { return _requestOperation; }
 
    const QUrl& requestUrl() const { return _requestUrl; }
 
    QByteArray requestHeader(const QString& key) const { return _requestHeaders.value(key.toLower().toLocal8Bit()); }
 
    const QByteArray& requestContent() const { return _requestContent->content(); }
 
    QList<FormData> parseFormData() const;
 
    QHash<QString, QString> parseUrlEncodedForm();
 
    void respond(const char* code, const QByteArray& content = QByteArray(),
        const char* contentType = DefaultContentType,
        const Headers& headers = Headers());
    void respond(const char* code, std::unique_ptr<QIODevice> device,
        const char* contentType = DefaultContentType,
        const Headers& headers = Headers());
 
protected slots:
 
    void readRequest();
 
    void readHeaders();
 
    void readContent();
 
protected:
    void respondWithStatusAndHeaders(const char* code, const char* contentType, const Headers& headers, qint64 size);
 
    HTTPManager* _parentManager;
 
    QTcpSocket* _socket;
 
    QHostAddress _address;
 
    QNetworkAccessManager::Operation _requestOperation;
 
    QUrl _requestUrl;
 
    Headers _requestHeaders;
 
    QByteArray _lastRequestHeader;
 
    std::unique_ptr<Storage> _requestContent;
 
    std::unique_ptr<QIODevice> _responseDevice;
};
 
#endif // hifi_HTTPConnection_h