The Tufao::HttpServer class provides an implementation of the HTTP protocol. More...

Inheritance diagram for Tufao::HttpServer:

Collaboration diagram for Tufao::HttpServer:

Public Slots
void	close ()
	Closes the server. More...

Signals
void	requestReady (Tufao::HttpServerRequest request, Tufao::HttpServerResponse response)
	This signal is emitted each time there is request. More...

Public Member Functions
	HttpServer (QObject *parent=0)
	Constructs a Tufao::HttpServer object. More...

	~HttpServer ()
	Destroys the object.

bool	listen (const QHostAddress &address=QHostAddress::Any, quint16 port=0)
	Tells the server to listen for incoming connections on address `address` and port `port`. More...

bool	isListening () const
	Returns true if the server is listening for incoming connections.

quint16	serverPort () const
	Returns the server's port if the server is listening; otherwise returns 0. More...

void	setTimeout (int msecs=0)
	Sets the timeout of new connections to `msecs` miliseconds. More...

int	timeout () const
	Returns the current set timeout.

void	setHttpUpgradeRouter (HttpUpgradeRouter *router)
	Sets the HttpUpgradeRouter used to handle HTTP upgrades. More...

Protected Member Functions
void	handleConnection (QAbstractSocket *connection)
	Call this function will make Tufao::HttpServer handle the connection `connection`. More...

virtual void	incomingConnection (qintptr socketDescriptor)
	This virtual function is called by HttpServer when a new connection is available. More...

virtual void	checkContinue (HttpServerRequest request, HttpServerResponse response)
	This virtual function is called by HttpServer when a client do a request with the HTTP header "Expect: 100-continue". More...

virtual void	upgrade (HttpServerRequest *request, const QByteArray &head)
	This virtual function is called by HttpServer when a client requests a http upgrade. More...

Detailed Description

The Tufao::HttpServer class provides an implementation of the HTTP protocol.

The HTTP is a stateless request-response based protoccol. It let you create distributed dynamic collaborative applications.

To create a webserver, all you need to do is call Tufao::HttpServer::listen and handle the Tufao::HttpServer::requestReady signal.

#include <Tufao/HttpServer>
class WebServer: public QObject
{
    Q_OBJECT
public:
    explicit WebServer(QObject *parent = NULL) :
        QObject(parent),
        httpServer(new Tufao::HttpServer(this))
    {
        connect(httpServer,
                SIGNAL(requestReady(Tufao::HttpServerRequest*,Tufao::HttpServerResponse*),
                this,
                SLOT(handleRequest(Tufao::HttpServerRequest*,Tufao::HttpServerResponse*)));
        httpServer->listen(QHostAddress::Any, 8080);
    }
private slots:
    void handleRequest(Tufao::HttpServerRequest *request,
                       Tufao::HttpServerResponse *response)
    {
        response->writeHead(200);
        response->headers().insert("Content-Type", "text/plain");
        response->write("Hello World\n");
        response->end();
    }
private:
    Tufao::HttpServer *httpServer;
};

See Also: Tufao::HttpServerRequest; Tufao::HttpServerResponse

Constructor & Destructor Documentation

Tufao::HttpServer::HttpServer ( QObject * parent = 0 )

explicit

Constructs a Tufao::HttpServer object.

parent is passed to the QObject constructor.

Member Function Documentation

virtual void Tufao::HttpServer::checkContinue	(	HttpServerRequest *	request,
		HttpServerResponse *	response
	)

protectedvirtual

This virtual function is called by HttpServer when a client do a request with the HTTP header "Expect: 100-continue".

The base implementation call Tufao::HttpServerRequest::writeContinue and emit the Tufao::HttpServer::requestReady signal.

Reimplement this function to alter the server's behavior when a "Expect: 100-continue" request is received.

Note: Don't delete the request or the response object, they will be deleted when the connection closes. If you need delete them before, just close the connection or call the QObject::deleteLater.

void Tufao::HttpServer::close ( )

slot

Closes the server.

The server will no longer listen for incoming connections.

void Tufao::HttpServer::handleConnection ( QAbstractSocket * connection )

protected

Call this function will make Tufao::HttpServer handle the connection connection.

The Tufao::HttpServer object will take ownership of the connection object and delete it when appropriate.

virtual void Tufao::HttpServer::incomingConnection ( qintptr socketDescriptor )

protectedvirtual

This virtual function is called by HttpServer when a new connection is available.

The base implementation creates a QTcpSocket, sets the socket descriptor and call Tufao::HttpServer::handleConnection.

Reimplement this function to alter the server's behavior when a connection is available.

bool Tufao::HttpServer::listen	(	const QHostAddress &	address = `QHostAddress::Any`,
		quint16	port = `0`
	)

Tells the server to listen for incoming connections on address address and port port.

If port is 0, a port is chosen automatically. The default registered port to HTTP server is 80.

If address is QHostAddress::Any, the server will listen on all network interfaces.

Returns: true on success

See Also: Tufao::HttpServer::isListening Tufao::HttpServer::serverPort

void Tufao::HttpServer::requestReady	(	Tufao::HttpServerRequest *	request,
		Tufao::HttpServerResponse *	response
	)

signal

This signal is emitted each time there is request.

Note: There may be multiple requests per connection (in the case of keep-alive connections) and HttpServer reutilizes request objects, so you can't, as an example, create a map using request as key to identify sessions.

Warning: You MUST NOT delete request and response. request and response are deleted when the connection closes. Additionally, response will also be deleted when you are done with it (eg., calling Tufao::HttpServerResponse::end).

Note: If this is a POST request for a big file, you should increase the timeout for this individual request.

Parameters

request	An instance of Tufao::HttpServerRequest
response	An instance of Tufao::HttpServerResponse

quint16 Tufao::HttpServer::serverPort ( ) const

Returns the server's port if the server is listening; otherwise returns 0.

See Also: Tufao::HttpServer::listen Tufao::HttpServer::isListening

void Tufao::HttpServer::setHttpUpgradeRouter ( HttpUpgradeRouter * router )

Sets the HttpUpgradeRouter used to handle HTTP upgrades.

The default behaviour is use none routers to handle HTTP upgrades. If you add any router, then the default behaviour will be to use this router, but the default behaviour still can be changed if you override the upgrade method.

Note: If you pass NULL as argument, any previous configured router will be forgotten and not used anymore.

Since: 0.6

void Tufao::HttpServer::setTimeout ( int msecs = 0 )

Sets the timeout of new connections to msecs miliseconds.

If you set the timeout to 0, then timeout feature will be disabled. You should NOT disable this feature to help to protect against DoS attacks.

The default timeout is 2 minutes (120000 miliseconds).

Note: You should call this function before Tufao::HttpServer::listen.

virtual void Tufao::HttpServer::upgrade	(	HttpServerRequest *	request,
		const QByteArray &	head
	)

protectedvirtual

This virtual function is called by HttpServer when a client requests a http upgrade.

The base implementation closes the connection if no upgrade router is configured or the upgrade router isn't able to handle the request.

Reimplement this function to alter the server's behavior when a http upgrade is requested.

Note: After this function returns, the request object is deleted.; The connection object associated with request (Tufao::HttpServerRequest::socket) will be deleted when disconnected. If you need to delete it sooner, just call QIODevice::close or QObject::deleteLater.

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

httpserver.h

Public Slots

Signals

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation