|  | Home

# A simple HTTP Server

It is a very simple implementation of a HTTP daemon that listens on chosen port (defaultly 8080) and sends back a simple HTML page back for every GET request it gets. After sending the page, it closes the connection.

     // HttpDaemon is the the class that implements the simple HTTP server.
     class HttpDaemon : public QTcpServer
     {
         Q_OBJECT
     public:
         HttpDaemon(quint16 port, QObject* parent = 0)
             : QTcpServer(parent), disabled(false)
         {
             listen(QHostAddress::Any, port);
         }

         void incomingConnection(int socket)
         {
             if (disabled)
                 return;

             // When a new client connects, the server constructs a QTcpSocket and all
             // communication with the client is done over this QTcpSocket. QTcpSocket
             // works asynchronously, this means that all the communication is done
             // in the two slots readClient() and discardClient().
             QTcpSocket* s = new QTcpSocket(this);
             connect(s, SIGNAL(readyRead()), this, SLOT(readClient()));
             connect(s, SIGNAL(disconnected()), this, SLOT(discardClient()));
             s->setSocketDescriptor(socket);

             QtServiceBase::instance()->logMessage("New Connection");
         }

         void pause()
         {
             disabled = true;
         }

         void resume()
         {
             disabled = false;
         }

     private slots:
         void readClient()
         {
             if (disabled)
                 return;

             // This slot is called when the client sent data to the server. The
             // server looks if it was a get request and sends a very simple HTML
             // document back.
             QTcpSocket* socket = (QTcpSocket*)sender();
             if (socket->canReadLine()) {
                 QStringList tokens = QString(socket->readLine()).split(QRegExp("[ \r\n][ \r\n]*"));
                 if (tokens[0] == "GET") {
                     QTextStream os(socket);
                     os.setAutoDetectUnicode(true);
                     os << "HTTP/1.0 200 Ok\r\n"
                         "Content-Type: text/html; charset=\"utf-8\"\r\n"
                         "\r\n"
                         "<h1>Nothing to see here</h1>\n"
                         << QDateTime::currentDateTime().toString() << "\n";
                     socket->close();

                     QtServiceBase::instance()->logMessage("Wrote to client");

                     if (socket->state() == QTcpSocket::UnconnectedState) {
                         delete socket;
                         QtServiceBase::instance()->logMessage("Connection closed");
                     }
                 }
             }
         }
         void discardClient()
         {
             QTcpSocket* socket = (QTcpSocket*)sender();
             socket->deleteLater();

             QtServiceBase::instance()->logMessage("Connection closed");
         }

     private:
         bool disabled;
     };

The server implementation uses the QtService::logMessage() function to send messages and status reports to the system event log. The server also supports a paused state in which case incoming requests are ignored.

The `HttpService` class subclasses QtService to implement the service functionality.

     class HttpService : public QtService<QCoreApplication>
     {
     public:
         HttpService(int argc, char **argv)
             : QtService<QCoreApplication>(argc, argv, "Qt HTTP Daemon")
         {
             setServiceDescription("A dummy HTTP service implemented with Qt");
             setServiceFlags(QtServiceBase::CanBeSuspended);
         }

The constructor calls the QtService constructor instantiated with QCoreApplication since our service will not use GUI. The first two parameters of our constructor are passed to QtService. The last parameter, "Qt HTTP Daemon", is the name of the service.

     protected:
         void start()
         {
             QCoreApplication *app = application();

             quint16 port = (app->argc() > 1) ?
                     QString::fromLocal8Bit(app->argv()[1]).toUShort() : 8080;
             daemon = new HttpDaemon(port, app);

             if (!daemon->isListening()) {
                 logMessage(QString("Failed to bind to port %1").arg(daemon->serverPort()), QtServiceBase::Error);
                 app->quit();
             }
         }

The implementation of `start()` first checks if the user passed a port number. If yes that port is used by server to listen on. Otherwise default 8080 port is used. Then creates an instance of the HTTP server using operator new, passing the application object as the parent to ensure that the object gets destroyed.

         void pause()
         {
             daemon->pause();
         }

         void resume()
         {
             daemon->resume();
         }

     private:
         HttpDaemon *daemon;
     };

The implementations of pause() and resume() forward the request to the server object.

     #include "main.moc"

     int main(int argc, char **argv)
     {
     #if !defined(Q_WS_WIN)
         // QtService stores service settings in SystemScope, which normally require root privileges.
         // To allow testing this example as non-root, we change the directory of the SystemScope settings file.
         QSettings::setPath(QSettings::NativeFormat, QSettings::SystemScope, QDir::tempPath());
         qWarning("(Example uses dummy settings file: %s/QtSoftware.conf)", QDir::tempPath().toLatin1().constData());
     #endif
         HttpService service(argc, argv);
         return service.exec();
     }

The main entry point function creates the service object and uses the `exec()` function to execute the service.