qtwebapp::HttpConnectionHandler Class Reference

#include <httpconnectionhandler.h>

Inherits QThread.

Collaboration diagram for qtwebapp::HttpConnectionHandler:

Public Slots
void	handleConnection (tSocketDescriptor socketDescriptor)

Public Member Functions
	HttpConnectionHandler (QSettings *settings, HttpRequestHandler *requestHandler, QSslConfiguration *sslConfiguration=NULL)
	HttpConnectionHandler (const HttpListenerSettings *settings, HttpRequestHandler *requestHandler, QSslConfiguration *sslConfiguration=NULL)
virtual	~HttpConnectionHandler ()
bool	isBusy ()
void	setBusy ()
const HttpListenerSettings *	getListenerSettings () const

Private Slots
void	readTimeout ()
void	read ()
void	disconnected ()

Private Member Functions
void	run ()
void	createSocket ()

Private Attributes
QSettings *	settings
const HttpListenerSettings *	listenerSettings
QTcpSocket *	socket
QTimer	readTimer
HttpRequest *	currentRequest
HttpRequestHandler *	requestHandler
bool	busy
QSslConfiguration *	sslConfiguration
bool	useQtSettings

Detailed Description

Alias for QSslConfiguration if OpenSSL is not supported The connection handler accepts incoming connections and dispatches incoming requests to to a request mapper. Since HTTP clients can send multiple requests before waiting for the response, the incoming requests are queued and processed one after the other.

Example for the required configuration settings:

readTimeout=60000
maxRequestSize=16000
maxMultiPartSize=1000000

The readTimeout value defines the maximum time to wait for a complete HTTP request.

See also

HttpRequest for description of config settings maxRequestSize and maxMultiPartSize.

Definition at line 52 of file httpconnectionhandler.h.

Constructor & Destructor Documentation

HttpConnectionHandler() [1/2]

HttpConnectionHandler::HttpConnectionHandler	(	QSettings *	settings,
		HttpRequestHandler *	requestHandler,
		QSslConfiguration *	sslConfiguration = NULL
	)

Constructor.

Parameters

settings	Configuration settings of the HTTP webserver as Qt settings
requestHandler	Handler that will process each incoming HTTP request
sslConfiguration	SSL (HTTPS) will be used if not NULL

Definition at line 11 of file httpconnectionhandler.cpp.

References busy, createSocket(), currentRequest, disconnected(), listenerSettings, read(), readTimeout(), readTimer, requestHandler, settings, socket, and sslConfiguration.

    : QThread(), useQtSettings(true)
{
    Q_ASSERT(settings != 0);
    Q_ASSERT(requestHandler != 0);
    this->settings = settings;
    this->listenerSettings = 0;
    this->requestHandler = requestHandler;
    this->sslConfiguration = sslConfiguration;
    currentRequest = 0;
    busy=false;

    // Create TCP or SSL socket
    createSocket();

    // execute signals in my own thread
    moveToThread(this);
    socket->moveToThread(this);
    readTimer.moveToThread(this);

    // Connect signals
    connect(socket, SIGNAL(readyRead()), SLOT(read()));
    connect(socket, SIGNAL(disconnected()), SLOT(disconnected()));
    connect(&readTimer, SIGNAL(timeout()), SLOT(readTimeout()));
    readTimer.setSingleShot(true);

    qDebug("HttpConnectionHandler (%p): constructed", this);
    this->start();
}

Here is the call graph for this function:

HttpConnectionHandler() [2/2]

HttpConnectionHandler::HttpConnectionHandler	(	const HttpListenerSettings *	settings,
		HttpRequestHandler *	requestHandler,
		QSslConfiguration *	sslConfiguration = NULL
	)

Constructor.

Parameters

settings	Configuration settings of the HTTP webserver as a structure
requestHandler	Handler that will process each incoming HTTP request
sslConfiguration	SSL (HTTPS) will be used if not NULL

Definition at line 41 of file httpconnectionhandler.cpp.

References busy, createSocket(), currentRequest, disconnected(), listenerSettings, read(), readTimeout(), readTimer, requestHandler, settings, socket, and sslConfiguration.

    : QThread(), useQtSettings(false)
{
    Q_ASSERT(settings != 0);
    Q_ASSERT(requestHandler != 0);
    this->settings = 0;
    this->listenerSettings = settings;
    this->requestHandler = requestHandler;
    this->sslConfiguration = sslConfiguration;
    currentRequest = 0;
    busy = false;

    // Create TCP or SSL socket
    createSocket();

    // execute signals in my own thread
    moveToThread(this);
    socket->moveToThread(this);
    readTimer.moveToThread(this);

    // Connect signals
    connect(socket, SIGNAL(readyRead()), SLOT(read()));
    connect(socket, SIGNAL(disconnected()), SLOT(disconnected()));
    connect(&readTimer, SIGNAL(timeout()), SLOT(readTimeout()));
    readTimer.setSingleShot(true);

    qDebug("HttpConnectionHandler (%p): constructed", this);
    this->start();
}

Here is the call graph for this function:

~HttpConnectionHandler()

HttpConnectionHandler::~HttpConnectionHandler ( )

virtual

Destructor

Definition at line 72 of file httpconnectionhandler.cpp.

{
    quit();
    wait();
    qDebug("HttpConnectionHandler (%p): destroyed", this);
}

Member Function Documentation

createSocket()

void HttpConnectionHandler::createSocket ( )

private

Create SSL or TCP socket

Definition at line 80 of file httpconnectionhandler.cpp.

References socket, and sslConfiguration.

Referenced by HttpConnectionHandler().

{
    // If SSL is supported and configured, then create an instance of QSslSocket
    #ifndef QT_NO_OPENSSL
        if (sslConfiguration)
        {
            QSslSocket* sslSocket=new QSslSocket();
            sslSocket->setSslConfiguration(*sslConfiguration);
            socket=sslSocket;
            qDebug("HttpConnectionHandler (%p): SSL is enabled", this);
            return;
        }
    #endif
    // else create an instance of QTcpSocket
    socket=new QTcpSocket();
}

Here is the caller graph for this function:

disconnected

void HttpConnectionHandler::disconnected ( )

privateslot

Received from the socket when a connection has been closed

Definition at line 182 of file httpconnectionhandler.cpp.

References busy, readTimer, and socket.

Referenced by HttpConnectionHandler().

{
    qDebug("HttpConnectionHandler (%p): disconnected", this);
    socket->close();
    readTimer.stop();
    busy = false;
}

Here is the caller graph for this function:

getListenerSettings()

const HttpListenerSettings* qtwebapp::HttpConnectionHandler::getListenerSettings ( ) const

inline

Get a listener settings constant reference. Can be changed on the HttpListener only.

Returns

The current listener settings

Definition at line 87 of file httpconnectionhandler.h.

{ return listenerSettings; }

handleConnection

void HttpConnectionHandler::handleConnection ( tSocketDescriptor  socketDescriptor )

slot

Received from from the listener, when the handler shall start processing a new connection.

Parameters

socketDescriptor

references the accepted connection.

Definition at line 120 of file httpconnectionhandler.cpp.

References busy, currentRequest, listenerSettings, qtwebapp::HttpListenerSettings::readTimeout, readTimeout(), readTimer, settings, socket, sslConfiguration, and useQtSettings.

{
#ifdef SUPERVERBOSE
    qDebug("HttpConnectionHandler (%p): handle new connection", this);
#endif
    busy = true;
    Q_ASSERT(socket->isOpen()==false); // if not, then the handler is already busy

    //UGLY workaround - we need to clear writebuffer before reusing this socket
    //https://bugreports.qt-project.org/browse/QTBUG-28914
    socket->connectToHost("",0);
    socket->abort();

    if (!socket->setSocketDescriptor(socketDescriptor))
    {
        qCritical("HttpConnectionHandler (%p): cannot initialize socket: %s", this,qPrintable(socket->errorString()));
        return;
    }

    #ifndef QT_NO_OPENSSL
        // Switch on encryption, if SSL is configured
        if (sslConfiguration)
        {
            qDebug("HttpConnectionHandler (%p): Starting encryption", this);
            ((QSslSocket*)socket)->startServerEncryption();
        }
    #endif

    // Start timer for read timeout
    int readTimeout = useQtSettings ? settings->value("readTimeout",10000).toInt() : listenerSettings->readTimeout;
    readTimer.start(readTimeout);
    // delete previous request
    delete currentRequest;
    currentRequest=0;
}

Here is the call graph for this function:

isBusy()

bool HttpConnectionHandler::isBusy

(

)

Returns true, if this handler is in use.

Definition at line 157 of file httpconnectionhandler.cpp.

References busy.

Referenced by qtwebapp::HttpConnectionHandlerPool::cleanup(), and qtwebapp::HttpConnectionHandlerPool::getConnectionHandler().

{
    return busy;
}

Here is the caller graph for this function:

read

void HttpConnectionHandler::read ( )

privateslot

Received from the socket when incoming data can be read

Definition at line 190 of file httpconnectionhandler.cpp.

References qtwebapp::HttpRequest::abort, qtwebapp::HttpRequest::complete, currentRequest, qtwebapp::HttpRequest::getHeader(), qtwebapp::HttpRequest::getMethod(), qtwebapp::HttpRequest::getPath(), qtwebapp::HttpRequest::getPeerAddress(), qtwebapp::HttpRequest::getStatus(), qtwebapp::HttpRequest::getVersion(), listenerSettings, qtwebapp::HttpRequest::readFromSocket(), qtwebapp::HttpListenerSettings::readTimeout, readTimeout(), readTimer, requestHandler, qtwebapp::HttpRequestHandler::service(), settings, socket, useQtSettings, and qtwebapp::HttpRequest::waitForBody.

Referenced by HttpConnectionHandler().

{
    // The loop adds support for HTTP pipelinig
    while (socket->bytesAvailable())
    {
        #ifdef SUPERVERBOSE
            qDebug("HttpConnectionHandler (%p): read input",this);
        #endif

        // Create new HttpRequest object if necessary
        if (!currentRequest)
        {
            if (useQtSettings) {
                currentRequest = new HttpRequest(settings);
            } else {
                currentRequest = new HttpRequest(listenerSettings);
            }
        }

        // Collect data for the request object
        while (socket->bytesAvailable() && currentRequest->getStatus()!=HttpRequest::complete && currentRequest->getStatus()!=HttpRequest::abort)
        {
            currentRequest->readFromSocket(socket);
            if (currentRequest->getStatus()==HttpRequest::waitForBody)
            {
                // Restart timer for read timeout, otherwise it would
                // expire during large file uploads.
                int readTimeout = useQtSettings ? settings->value("readTimeout",10000).toInt() : listenerSettings->readTimeout;
                readTimer.start(readTimeout);
            }
        }

        // If the request is aborted, return error message and close the connection
        if (currentRequest->getStatus()==HttpRequest::abort)
        {
            socket->write("HTTP/1.1 413 entity too large\r\nConnection: close\r\n\r\n413 Entity too large\r\n");
            while(socket->bytesToWrite()) socket->waitForBytesWritten();
            socket->disconnectFromHost();
            delete currentRequest;
            currentRequest=0;
            return;
        }

        // If the request is complete, let the request mapper dispatch it
        if (currentRequest->getStatus()==HttpRequest::complete)
        {
            readTimer.stop();
            qDebug("HttpConnectionHandler (%p): received request from %s (%s) %s",
                    this,
                    qPrintable(currentRequest->getPeerAddress().toString()),
                    currentRequest->getMethod().toStdString().c_str(),
                    currentRequest->getPath().toStdString().c_str());

            // Copy the Connection:close header to the response
            HttpResponse response(socket);
            bool closeConnection=QString::compare(currentRequest->getHeader("Connection"),"close",Qt::CaseInsensitive)==0;
            if (closeConnection)
            {
                response.setHeader("Connection","close");
            }

            // In case of HTTP 1.0 protocol add the Connection:close header.
            // This ensures that the HttpResponse does not activate chunked mode, which is not spported by HTTP 1.0.
            else
            {
                bool http1_0=QString::compare(currentRequest->getVersion(),"HTTP/1.0",Qt::CaseInsensitive)==0;
                if (http1_0)
                {
                    closeConnection=true;
                    response.setHeader("Connection","close");
                }
            }

            // Call the request mapper
            try
            {
                requestHandler->service(*currentRequest, response);
            }
            catch (...)
            {
                qCritical("HttpConnectionHandler (%p): An uncatched exception occurred in the request handler",this);
            }

            // Finalize sending the response if not already done
            if (!response.hasSentLastPart())
            {
                response.write(QByteArray(),true);
            }

#ifdef SUPERVERBOSE
            qDebug("HttpConnectionHandler (%p): finished request",this);
#endif

            // Find out whether the connection must be closed
            if (!closeConnection)
            {
                // Maybe the request handler or mapper added a Connection:close header in the meantime
                bool closeResponse=QString::compare(response.getHeaders().value("Connection"),"close",Qt::CaseInsensitive)==0;
                if (closeResponse==true)
                {
                    closeConnection=true;
                }
                else
                {
                    // If we have no Content-Length header and did not use chunked mode, then we have to close the
                    // connection to tell the HTTP client that the end of the response has been reached.
                    bool hasContentLength=response.getHeaders().contains("Content-Length");
                    if (!hasContentLength)
                    {
                        bool hasChunkedMode=QString::compare(response.getHeaders().value("Transfer-Encoding"),"chunked",Qt::CaseInsensitive)==0;
                        if (!hasChunkedMode)
                        {
                            closeConnection=true;
                        }
                    }
                }
            }

            // Close the connection or prepare for the next request on the same connection.
            if (closeConnection)
            {
                while(socket->bytesToWrite()) socket->waitForBytesWritten();
                socket->disconnectFromHost();
            }
            else
            {
                // Start timer for next request
                int readTimeout = useQtSettings ? settings->value("readTimeout",10000).toInt() : listenerSettings->readTimeout;
                readTimer.start(readTimeout);
            }
            delete currentRequest;
            currentRequest=0;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

readTimeout

void HttpConnectionHandler::readTimeout ( )

privateslot

Received from the socket when a read-timeout occurred

Definition at line 168 of file httpconnectionhandler.cpp.

References currentRequest, and socket.

Referenced by handleConnection(), HttpConnectionHandler(), and read().

{
    qDebug("HttpConnectionHandler (%p): read timeout occurred",this);

    //Commented out because QWebView cannot handle this.
    //socket->write("HTTP/1.1 408 request timeout\r\nConnection: close\r\n\r\n408 request timeout\r\n");

    while(socket->bytesToWrite()) socket->waitForBytesWritten();
    socket->disconnectFromHost();
    delete currentRequest;
    currentRequest=0;
}

Here is the caller graph for this function:

run()

void HttpConnectionHandler::run ( )

private

Executes the threads own event loop

Definition at line 98 of file httpconnectionhandler.cpp.

References readTimer, and socket.

{
#ifdef SUPERVERBOSE
    qDebug("HttpConnectionHandler (%p): thread started", this);
#endif
    try
    {
        exec();
    }
    catch (...)
    {
        qCritical("HttpConnectionHandler (%p): an uncatched exception occurred in the thread",this);
    }
    socket->close();
    delete socket;
    readTimer.stop();
#ifdef SUPERVERBOSE
    qDebug("HttpConnectionHandler (%p): thread stopped", this);
#endif
}

setBusy()

void HttpConnectionHandler::setBusy

(

)

Mark this handler as busy

Definition at line 162 of file httpconnectionhandler.cpp.

References busy.

Referenced by qtwebapp::HttpConnectionHandlerPool::getConnectionHandler().

{
    this->busy = true;
}

Here is the caller graph for this function:

Member Data Documentation

busy

bool qtwebapp::HttpConnectionHandler::busy

private

This shows the busy-state from a very early time

Definition at line 111 of file httpconnectionhandler.h.

Referenced by disconnected(), handleConnection(), HttpConnectionHandler(), isBusy(), and setBusy().

currentRequest

HttpRequest* qtwebapp::HttpConnectionHandler::currentRequest

private

Storage for the current incoming HTTP request

Definition at line 105 of file httpconnectionhandler.h.

Referenced by handleConnection(), HttpConnectionHandler(), read(), and readTimeout().

listenerSettings

const HttpListenerSettings* qtwebapp::HttpConnectionHandler::listenerSettings

private

Configuration settings

Definition at line 96 of file httpconnectionhandler.h.

Referenced by handleConnection(), HttpConnectionHandler(), and read().

readTimer

QTimer qtwebapp::HttpConnectionHandler::readTimer

private

Time for read timeout detection

Definition at line 102 of file httpconnectionhandler.h.

Referenced by disconnected(), handleConnection(), HttpConnectionHandler(), read(), and run().

requestHandler

HttpRequestHandler* qtwebapp::HttpConnectionHandler::requestHandler

private

Dispatches received requests to services

Definition at line 108 of file httpconnectionhandler.h.

Referenced by HttpConnectionHandler(), and read().

settings

QSettings* qtwebapp::HttpConnectionHandler::settings

private

Configuration settings

Definition at line 93 of file httpconnectionhandler.h.

Referenced by handleConnection(), HttpConnectionHandler(), and read().

socket

QTcpSocket* qtwebapp::HttpConnectionHandler::socket

private

TCP socket of the current connection

Definition at line 99 of file httpconnectionhandler.h.

Referenced by createSocket(), disconnected(), handleConnection(), HttpConnectionHandler(), read(), readTimeout(), and run().

sslConfiguration

QSslConfiguration* qtwebapp::HttpConnectionHandler::sslConfiguration

private

Configuration for SSL

Definition at line 114 of file httpconnectionhandler.h.

Referenced by createSocket(), handleConnection(), and HttpConnectionHandler().

useQtSettings

bool qtwebapp::HttpConnectionHandler::useQtSettings

private

Settings flag

Definition at line 123 of file httpconnectionhandler.h.

Referenced by handleConnection(), and read().

---

The documentation for this class was generated from the following files:

• httpserver/httpconnectionhandler.h
• httpserver/httpconnectionhandler.cpp