VFS_httpd.cpp

Go to the documentation of this file.

 
#include "VFS_httpd.h"
 
QHash<QString, QString> VFS_httpd::MIME_TYPES;
 
VFS_httpd::VFS_httpd(quint16 port, QHostAddress addr, bool ssl, QString sslCertPath, QString sslKeyPath)
: VFS_tcp_server(port,addr,ssl,sslCertPath,sslKeyPath)
, _httpd(&_socket,port, this)
{
        initMimes();
 
        //ssl stuff here!
        //setSslConfiguration
}
 
VFS_httpd::~VFS_httpd()
{
}
 
bool VFS_httpd::isContainer()
{
        return false;
}
 
void VFS_httpd::initMimes()
{
        if (MIME_TYPES.size() > 0) return;                              //only init once
 
        MIME_TYPES.insert("html","text/html");
        MIME_TYPES.insert("rhtml","text/html");                 //our special type of processed html
        MIME_TYPES.insert("js","text/javascript");
        MIME_TYPES.insert("json","application/json");
        MIME_TYPES.insert("css","text/css");
        MIME_TYPES.insert("ico","image/ico");
        MIME_TYPES.insert("png","image/png");
        MIME_TYPES.insert("jpg","image/jpg");
        MIME_TYPES.insert("jpeg","image/jpeg");
        MIME_TYPES.insert("gif","image/gif");
        MIME_TYPES.insert("eot","application/vnd.ms-fontobject");
        MIME_TYPES.insert("svg","image/svg+xml");
        MIME_TYPES.insert("ttf","application/x-font-ttf");
        MIME_TYPES.insert("woff","text/plain");
}
 
bool VFS_httpd::listen()
{
        //if (_httpd.listen())
        if (VFS_tcp_server::listen())
        {
                connect(        &_httpd,        SIGNAL( newRequest(QHttpRequest*, QHttpResponse*)       ),
                                this,           SLOT(   handle(QHttpRequest*, QHttpResponse*)           )       );
 
                return true;
        }
        else
                VFS::WARN( QString("%1 could not listen on port %2.  Is it already in use?").arg(className()).arg(_port) );
 
        return false;
}
 
void VFS_httpd::createNewConnection()
{
        while(_socket.hasPendingConnections())
        {
                QTcpSocket *s = _socket.nextPendingConnection();
/*
                VFS_tcp_client *client = newClient( s );//, _ssl, _sslConfiguration );  //if it is ssl, it will have already been negotiated, no?
 
                connect(        client, SIGNAL( disconnected() ),
                                client, SLOT( deleteLater() )           );
 
                connect(        client, SIGNAL( error(QAbstractSocket::SocketError) ),
                                this,   SLOT(   clientError(QAbstractSocket::SocketError) )     );
*/
                QHttpConnection *connection = new QHttpConnection(s, &_httpd);
                connect(connection,     SIGNAL(newRequest(QHttpRequest *, QHttpResponse *)),
                        &_httpd,        SIGNAL(newRequest(QHttpRequest *, QHttpResponse *))     );
 
                //client->initSSL();    //seems like this should run, but theoretically we've already established encryption at this point
        }
}
 
void VFS_httpd::handle(QHttpRequest *req, QHttpResponse *resp)
{
        VFS::LOG( QString("HTTP Request: %1").arg(req->url().toString()) );
 
        VFS_httpd_responder *r = new VFS_httpd_responder(req, resp);            //as a new object so it can delete itself later
        r->respond();
}
 
/*
void VFS_httpd::addOutstandingRequest()
{
        QTcpSocket *s = dynamic_cast<QTcpSocket *>(sender());
 
        s->startTimer(3000);
}
 
void VFS_httpd::timeoutOutstandingRequest()
{
        printf("TIMEOUT!\n");
 
        QTcpSocket *s = dynamic_cast<QTcpSocket *>(sender());
 
        s->close();
}
*/
 
VFS_httpd_responder::VFS_httpd_responder(QHttpRequest *req, QHttpResponse *resp)
: QObject(nullptr)
, _m_req(req)
, _m_resp(resp)
, _size(0)
, _status(404)
{
}
 
VFS_httpd_responder::~VFS_httpd_responder()
{
        //delete _m_req;
        //delete _m_resp;
 
        //m_req->deleteLater();
        //m_resp->deleteLater();
}
 
void VFS_httpd_responder::respond()
{
        VFS::WARN("HTTPD Responder should be overridden in a subclass...  Responding with error page.");
 
        validatePath(_m_req->url());            //sets url and path
 
        switch(_status)
        {
                default:        {       _m_resp->writeHead(_status);
                                        _m_resp->end( errorPage() );
                                }
                                break;
        };
 
//      connect(_m_req, SIGNAL(data(const QByteArray&)), this, SLOT(accumulate(const QByteArray&)), Qt::UniqueConnection);
        //connect(_m_req, SIGNAL(end()), this, SLOT(reply()));
        //connect(_m_req, SIGNAL(end()), _m_resp, SLOT(end()));
//      connect(_m_resp, SIGNAL(done()), this, SLOT(deleteLater()), Qt::UniqueConnection);
}
 
void VFS_httpd_responder::validatePath(QUrl url)
{
        _url = url;
        _path = _url.path();
 
        _status = 403;          //forbidden
}
 
//this happens on a browser push?
void VFS_httpd_responder::accumulate(const QByteArray &data)
{
        Q_UNUSED(data);
 
        VFS::ERROR("Accumulate!\n");
        printf("  Accumulated: %s",qUtf8Printable(data));
 
        //m_resp->write(data);
}
 
QByteArray VFS_httpd_responder::errorPage()
{
        QString s = QString("%1: %2").arg(_status).arg(STATUS_CODES.value(_status));
        QString r = QString("Requested: %1<br><i>Serving on port %2</i>").arg(_url.toString()).arg(_url.port());
        QString e = QString("<html><head><title>%1</title></head><body><h1>%1</h1>%2</body></html>\n").arg(s).arg(r);
 
        return e.toUtf8();
}