wshttpserver.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Bojan D.                                        *
 *   bojan_d@users.sourceforge.net                                         *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#include <stdlib.h>
#include <qhttp.h>
#include <qstringlist.h>
#include <qfileinfo.h>
#include <qstring.h>
#include <qhostaddress.h> 
#include <klocale.h>

#include "wshttpserver.h"

WSHttpServer::WSHttpServer( QObject* parent)
 : QServerSocket(Config().WWW.Port, 1, parent)
{
        if(ok())
        {
                emit message(i18n("Web server started on port: %1").arg(Config().WWW.Port));
        }
        else
        {
                QString error = i18n("Could not initialize webserver. Construction failed on port ");
                error += QString::number(Config().WWW.Port);
                error += ".";
                
                emit message(error);
                emit message(error, Configuration::Debug);
        }
}

WSHttpServer::~WSHttpServer()
{
}

void WSHttpServer::newConnection( int socket )
{
        QSocket* s = new QSocket( this );
        connect( s, SIGNAL(readyRead()), this, SLOT(readClient()) );
        connect( s, SIGNAL(delayedCloseFinished()), this, SLOT(discardClient()) );
        connect( s, SIGNAL(connectionClosed()), this, SLOT(closeClient()) );
        connect( s, SIGNAL(error(int)), this, SLOT(onError(int)) );
        s->setSocket( socket );
        
        emit message((s->peerAddress()).toString() + i18n(" connected."));
        
        emit newConnect();
}

void WSHttpServer::readClient()
{
        QSocket* socket = (QSocket*)sender();
        QString header_line = "";
        while( socket->canReadLine() )
        {
                header_line.append(socket->readLine()); 
        }
        
        QHttpRequestHeader this_header( header_line );
        if (this_header.method() == "GET" ) 
        {
                QString fn = this_header.path();
                
                emit message((socket->peerAddress()).toString() + i18n(" requested: ") + fn + ".");
                
                fn = fn.right(fn.length() - 1);
                QString path = getFilePath(fn);
                if(!path.isEmpty())
                {
                        QFile f(path);
                        if(f.open(IO_ReadOnly))
                        {
                                QByteArray data = f.readAll();
                                
                                QHttpResponseHeader head;
                                sendHttpResponse(socket, 200, "Ok", head, data);
                                f.close();
                        }
                        else
                        {
                                sendHttpError(socket, 400, "Bad Request", "<h1>The server could not handle your request.</h1>");
                        }
                }
                else
                {
                        sendHttpError(socket, 404, "File Not Found", "<h1>The file does not exist.</h1>");
                }
        }
        else
        {
                //MUST be GET:
                sendHttpError(socket, 405, "Method Not Allowed", "This is a minimal server.  I only accept GET");
        }
        
        socket->close();
        if(socket->state() == QSocket::Idle)
        {
                emit message((socket->peerAddress()).toString() + i18n(" disconnected."));
                socket->deleteLater();
                emit endConnect();
        }
}

QString WSHttpServer::getFilePath(const QString& filename)
{
        QStringList files = Config().WWW.Files;
        
        QString ret = "";
        
        for ( QStringList::Iterator it = files.begin(); it != files.end(); ++it ) 
        {
                QFileInfo fi(*it);
                if(filename == fi.fileName())
                {
                        ret = *it;
                        break;
                }
        }
        
        return ret;
}

void WSHttpServer::discardClient()
{
        QSocket* socket = (QSocket*)sender();
        
        emit message((socket->peerAddress()).toString() + i18n(" disconnected."));
        
        delete socket;
        emit endConnect();
}

void WSHttpServer::closeClient()
{
        QSocket* socket = (QSocket*)sender();
        socket->flush();
        socket->close();
        if(socket->state() == QSocket::Idle)
        {
                emit message((socket->peerAddress()).toString() + i18n(" disconnected."));
                delete socket;
                emit endConnect();
        }
}

void WSHttpServer::onError(int errno)
{
        QSocket* socket = (QSocket*)sender();
        if(errno == QSocket::ErrConnectionRefused)
        {
                emit message((socket->peerAddress()).toString() + i18n(": connection refused."));
        }
        else if(QSocket::ErrHostNotFound)
        {
                emit message((socket->peerAddress()).toString() + i18n(": host not found."));
        }
        else
        {
                emit message((socket->peerAddress()).toString() + i18n(": read failed."));
        }
        
        socket->flush();
        socket->close();
        if(socket->state() == QSocket::Idle)
        {
                emit message((socket->peerAddress()).toString() + i18n(" disconnected."));
                delete socket;
                emit endConnect();
        }
}

void WSHttpServer::sendHttpError(QSocket* s, int error_code, const QString& reason, const QString data)
{
        QHttpResponseHeader head;
        sendHttpResponse(s, error_code, reason, head, data);
}

void WSHttpServer::sendHttpResponse(QSocket* s, int status_code, const QString& reason, QHttpHeader& headers, QString resp)
{
        // the output
        QByteArray output;
        QTextStream ts_resp( output, IO_WriteOnly );
        ts_resp.setEncoding( QTextStream::UnicodeUTF8 );
        ts_resp << resp;
        headers.setValue("Content-Type", "text/html; charset=\"utf-8\"");
        headers.setValue("Connection","close");
        sendHttpResponse(s, status_code, reason, headers, output);
}

void WSHttpServer::sendHttpResponse(QSocket* s, int status_code, const QString& reason, QHttpHeader& headers, QByteArray output)
{
        int output_length = output.size();
        if((output_length > 256) && (headers.value("Accept-Encoding") == "deflate"))
        {
                headers.setValue("Content-Encoding","deflate");
                QByteArray compressed_output = qCompress(output);
                output_length = compressed_output.size();
                output = compressed_output;
        }
        
        headers.setContentLength(output_length);
        
        //This is the headers:
        QByteArray head_out;
        QTextStream header_resp(head_out, IO_WriteOnly);
        header_resp << "HTTP/1.1 " << status_code <<  " " << reason << "\r\n";
        QStringList::const_iterator sit;
        QStringList keys = headers.keys();
        for( sit = keys.begin(); sit != keys.end(); sit++) 
        {
                header_resp << (*sit) << ": " << headers.value( *sit ) << "\r\n";
        }
        header_resp << "\r\n";
        
        //Write the headers out:
        int header_length = head_out.size();
        int tmp = 0;
        tmp += s->writeBlock(head_out.data(), header_length);
                                
        //Write the body out:
        tmp = 0;
        tmp += s->writeBlock(output.data(), output_length);
        
        QString msg = (s->peerAddress()).toString();
        msg += ": " + QString::number(status_code) + " - " + reason + ".";
        
        emit message( msg );
        emit wroteToClient();
}

---