mirror/yacreader
1
0
Fork 0
mirror of https://github.com/YACReader/yacreader synced 2025-06-04 01:28:55 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

merged

Browse Source
This commit is contained in:
Luis Ángel San Martín 2016-08-22 13:26:18 +02:00
commit 1aa8d7e784
73 changed files with 3022 additions and 1966 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
YACReaderLibrary/server/controllers/comiccontroller.cpp
View File

@ -2,6 +2,7 @@
#include "db_helper.h" #include "db_helper.h"
#include "yacreader_libraries.h" #include "yacreader_libraries.h"
#include "yacreader_http_session.h"
#include "template.h" #include "template.h"
#include "../static.h" #include "../static.h"
@ -18,6 +19,7 @@ ComicController::ComicController() {}
void ComicController::service(HttpRequest& request, HttpResponse& response) void ComicController::service(HttpRequest& request, HttpResponse& response)
{ {
HttpSession session=Static::sessionStore->getSession(request,response,false); HttpSession session=Static::sessionStore->getSession(request,response,false);
YACReaderHttpSession *ySession = Static::yacreaderSessionStore->getYACReaderSessionHttpSession(session.getId());
QString path = QUrl::fromPercentEncoding(request.getPath()).toUtf8(); QString path = QUrl::fromPercentEncoding(request.getPath()).toUtf8();
QStringList pathElements = path.split('/'); QStringList pathElements = path.split('/');
@ -44,7 +46,7 @@ void ComicController::service(HttpRequest& request, HttpResponse& response)
ComicDB comic = DBHelper::getComicInfo(libraryId, comicId); ComicDB comic = DBHelper::getComicInfo(libraryId, comicId);
if(!remoteComic) if(!remoteComic)
session.setDownloadedComic(comic.info.hash); ySession->setDownloadedComic(comic.info.hash);
Comic * comicFile = FactoryComic::newComic(libraries.getPath(libraryId)+comic.path); Comic * comicFile = FactoryComic::newComic(libraries.getPath(libraryId)+comic.path);
@ -70,19 +72,19 @@ void ComicController::service(HttpRequest& request, HttpResponse& response)
if(remoteComic) if(remoteComic)
{ {
QLOG_TRACE() << "remote comic requested"; QLOG_TRACE() << "remote comic requested";
session.setCurrentRemoteComic(comic.id, comicFile); ySession->setCurrentRemoteComic(comic.id, comicFile);
} }
else else
{ {
QLOG_TRACE() << "comic requested"; QLOG_TRACE() << "comic requested";
session.setCurrentComic(comic.id, comicFile); ySession->setCurrentComic(comic.id, comicFile);
} }
response.setHeader("Content-Type", "text/plain; charset=utf-8"); response.setHeader("Content-Type", "text/plain; charset=utf-8");
//TODO this field is not used by the client! //TODO this field is not used by the client!
response.writeText(QString("library:%1\r\n").arg(libraryName)); response.write(QString("library:%1\r\n").arg(libraryName).toUtf8());
response.writeText(QString("libraryId:%1\r\n").arg(libraryId)); response.write(QString("libraryId:%1\r\n").arg(libraryId).toUtf8());
if(remoteComic) //send previous and next comics id if(remoteComic) //send previous and next comics id
{ {
QList<LibraryItem *> siblings = DBHelper::getFolderComicsFromLibrary(libraryId, comic.parentId, true); QList<LibraryItem *> siblings = DBHelper::getFolderComicsFromLibrary(libraryId, comic.parentId, true);
@ -99,9 +101,9 @@ void ComicController::service(HttpRequest& request, HttpResponse& response)
if(found) if(found)
{ {
if(i>0) if(i>0)
response.writeText(QString("previousComic:%1\r\n").arg(siblings.at(i-1)->id)); response.write(QString("previousComic:%1\r\n").arg(siblings.at(i-1)->id).toUtf8());
if(i<siblings.length()-1) if(i<siblings.length()-1)
response.writeText(QString("nextComic:%1\r\n").arg(siblings.at(i+1)->id)); response.write(QString("nextComic:%1\r\n").arg(siblings.at(i+1)->id).toUtf8());
} }
else else
{ {
@ -109,7 +111,7 @@ void ComicController::service(HttpRequest& request, HttpResponse& response)
} }
qDeleteAll(siblings); qDeleteAll(siblings);
} }
response.writeText(comic.toTXT(),true); response.write(comic.toTXT().toUtf8(),true);
} }
else else
{ {

4
YACReaderLibrary/server/controllers/comicdownloadinfocontroller.cpp
View File

@ -21,6 +21,6 @@ void ComicDownloadInfoController::service(HttpRequest& request, HttpResponse& re
ComicDB comic = DBHelper::getComicInfo(libraryId, comicId); ComicDB comic = DBHelper::getComicInfo(libraryId, comicId);
//TODO: check if the comic wasn't found; //TODO: check if the comic wasn't found;
response.writeText(QString("fileName:%1\r\n").arg(comic.getFileName())); response.write(QString("fileName:%1\r\n").arg(comic.getFileName()).toUtf8());
response.writeText(QString("fileSize:%1\r\n").arg(comic.getFileSize()),true); response.write(QString("fileSize:%1\r\n").arg(comic.getFileSize()).toUtf8(),true);
} }

7
YACReaderLibrary/server/controllers/covercontroller.cpp
View File

@ -1,6 +1,7 @@
#include "covercontroller.h" #include "covercontroller.h"
#include "db_helper.h" //get libraries #include "db_helper.h" //get libraries
#include "yacreader_libraries.h" #include "yacreader_libraries.h"
#include "yacreader_http_session.h"
#include "template.h" #include "template.h"
#include "../static.h" #include "../static.h"
@ -9,8 +10,8 @@ CoverController::CoverController() {}
void CoverController::service(HttpRequest& request, HttpResponse& response) void CoverController::service(HttpRequest& request, HttpResponse& response)
{ {
HttpSession session=Static::sessionStore->getSession(request,response,false); HttpSession session=Static::sessionStore->getSession(request,response,false);
YACReaderHttpSession *ySession = Static::yacreaderSessionStore->getYACReaderSessionHttpSession(session.getId());
response.setHeader("Content-Type", "image/jpeg"); response.setHeader("Content-Type", "image/jpeg");
response.setHeader("Connection","close"); response.setHeader("Connection","close");
@ -47,7 +48,7 @@ void CoverController::service(HttpRequest& request, HttpResponse& response)
if (!img.isNull()) { if (!img.isNull()) {
int width = 80, height = 120; int width = 80, height = 120;
if(session.getDisplayType()=="@2x") if(ySession->getDisplayType()=="@2x")
{ {
width = 160; width = 160;
height = 240; height = 240;
@ -66,7 +67,7 @@ void CoverController::service(HttpRequest& request, HttpResponse& response)
if(folderCover) if(folderCover)
{ {
if(session.getDisplayType()=="@2x") if(ySession->getDisplayType()=="@2x")
p.drawImage(0,0,QImage(":/images/f_overlayed_retina.png")); p.drawImage(0,0,QImage(":/images/f_overlayed_retina.png"));
else else
p.drawImage(0,0,QImage(":/images/f_overlayed.png")); p.drawImage(0,0,QImage(":/images/f_overlayed.png"));

8
YACReaderLibrary/server/controllers/foldercontentcontroller.cpp
View File

@ -32,7 +32,7 @@ void FolderContentController::service(HttpRequest& request, HttpResponse& respon
serviceContent(libraryId, parentId, response); serviceContent(libraryId, parentId, response);
response.writeText("",true); response.write("",true);
} }
void FolderContentController::serviceContent(const int &library, const qulonglong &folderId, HttpResponse &response) void FolderContentController::serviceContent(const int &library, const qulonglong &folderId, HttpResponse &response)
@ -54,17 +54,17 @@ void FolderContentController::serviceContent(const int &library, const qulonglon
if((*itr)->isDir()) if((*itr)->isDir())
{ {
currentFolder = (Folder *)(*itr); currentFolder = (Folder *)(*itr);
response.writeText(QString("f\t%1\t%2\t%3\t%4\t%5\r\n").arg(library).arg(currentFolder->id).arg(currentFolder->name).arg(currentFolder->getNumChildren()).arg(currentFolder->getFirstChildHash())); response.write(QString("f\t%1\t%2\t%3\t%4\t%5\r\n").arg(library).arg(currentFolder->id).arg(currentFolder->name).arg(currentFolder->getNumChildren()).arg(currentFolder->getFirstChildHash()).toUtf8());
} }
else else
{ {
currentComic = (ComicDB *)(*itr); currentComic = (ComicDB *)(*itr);
response.writeText(QString("c\t%1\t%2\t%3\t%4\t%5\r\n").arg(library).arg(currentComic->id).arg(currentComic->getFileName()).arg(currentComic->getFileSize()).arg(currentComic->info.hash)); response.write(QString("c\t%1\t%2\t%3\t%4\t%5\r\n").arg(library).arg(currentComic->id).arg(currentComic->getFileName()).arg(currentComic->getFileSize()).arg(currentComic->info.hash).toUtf8());
} }
} }
clock_t end = clock(); clock_t end = clock();
double msecs = double(end - begin); double msecs = double(end - begin);
response.writeText(QString("%1ms").arg(msecs)); response.write(QString("%1ms").arg(msecs).toUtf8());
} }

32
YACReaderLibrary/server/controllers/foldercontroller.cpp
View File

@ -11,6 +11,8 @@
#include "qnaturalsorting.h" #include "qnaturalsorting.h"
#include "yacreader_http_session.h"
#include "QsLog.h" #include "QsLog.h"
struct LibraryItemSorter struct LibraryItemSorter
@ -26,6 +28,7 @@ FolderController::FolderController() {}
void FolderController::service(HttpRequest& request, HttpResponse& response) void FolderController::service(HttpRequest& request, HttpResponse& response)
{ {
HttpSession session=Static::sessionStore->getSession(request,response,false); HttpSession session=Static::sessionStore->getSession(request,response,false);
YACReaderHttpSession *ySession = Static::yacreaderSessionStore->getYACReaderSessionHttpSession(session.getId());
response.setHeader("Content-Type", "text/html; charset=utf-8"); response.setHeader("Content-Type", "text/html; charset=utf-8");
response.setHeader("Connection","close"); response.setHeader("Connection","close");
@ -33,7 +36,7 @@ void FolderController::service(HttpRequest& request, HttpResponse& response)
//QString y = session.get("xxx").toString(); //QString y = session.get("xxx").toString();
//response.writeText(QString("session xxx : %1 <br/>").arg(y)); //response.writeText(QString("session xxx : %1 <br/>").arg(y));
Template t=Static::templateLoader->getTemplate("folder_"+session.getDeviceType(),request.getHeader("Accept-Language")); Template t = Static::templateLoader->getTemplate("folder_"+ySession->getDeviceType(),request.getHeader("Accept-Language"));
t.enableWarnings(); t.enableWarnings();
QString path = QUrl::fromPercentEncoding(request.getPath()).toUtf8(); QString path = QUrl::fromPercentEncoding(request.getPath()).toUtf8();
QStringList pathElements = path.split('/'); QStringList pathElements = path.split('/');
@ -85,17 +88,17 @@ void FolderController::service(HttpRequest& request, HttpResponse& response)
if(folderId == 1) if(folderId == 1)
{ {
session.clearNavigationPath(); ySession->clearNavigationPath();
session.pushNavigationItem(QPair<qulonglong,quint32>(folderId,page)); ySession->pushNavigationItem(QPair<qulonglong,quint32>(folderId,page));
t.setVariable(QString("upurl"),"/"); t.setVariable(QString("upurl"),"/");
} }
else else
{ {
if(fromUp) if(fromUp)
session.popNavigationItem(); ySession->popNavigationItem();
else //drill down or direct access else //drill down or direct access
{ {
QStack<QPair<qulonglong, quint32> > path = session.getNavigationPath(); QStack<QPair<qulonglong, quint32> > path = ySession->getNavigationPath();
bool found=false; bool found=false;
for(QStack<QPair<qulonglong, quint32> >::const_iterator itr = path.begin(); itr!=path.end(); itr++) for(QStack<QPair<qulonglong, quint32> >::const_iterator itr = path.begin(); itr!=path.end(); itr++)
if(itr->first == folderId) if(itr->first == folderId)
@ -106,16 +109,16 @@ void FolderController::service(HttpRequest& request, HttpResponse& response)
if(found) if(found)
{ {
while(session.topNavigationItem().first != folderId) while(ySession->topNavigationItem().first != folderId)
session.popNavigationItem(); ySession->popNavigationItem();
session.updateTopItem(QPair<qulonglong,quint32>(folderId,page)); ySession->updateTopItem(QPair<qulonglong,quint32>(folderId,page));
} }
else else
session.pushNavigationItem(QPair<qulonglong,quint32>(folderId,page)); ySession->pushNavigationItem(QPair<qulonglong,quint32>(folderId,page));
} }
QStack<QPair<qulonglong, quint32> > path = session.getNavigationPath(); QStack<QPair<qulonglong, quint32> > path = ySession->getNavigationPath();
if(path.count()>1) if(path.count()>1)
{ {
QPair<qulonglong, quint32> parentItem = path.at(path.count()-2); QPair<qulonglong, quint32> parentItem = path.at(path.count()-2);
@ -146,7 +149,7 @@ void FolderController::service(HttpRequest& request, HttpResponse& response)
int numFoldersAtCurrentPage = qMax(0,qMin(numFolders - indexCurrentPage, elementsPerPage)); int numFoldersAtCurrentPage = qMax(0,qMin(numFolders - indexCurrentPage, elementsPerPage));
//PATH //PATH
QStack<QPair<qulonglong,quint32> > foldersPath = session.getNavigationPath(); QStack<QPair<qulonglong,quint32> > foldersPath = ySession->getNavigationPath();
t.setVariable(QString("library.name"),libraryName); t.setVariable(QString("library.name"),libraryName);
t.setVariable(QString("library.url"),QString("/library/%1/folder/1").arg(libraryId)); t.setVariable(QString("library.url"),QString("/library/%1/folder/1").arg(libraryId));
t.loop("path",foldersPath.count()-1); t.loop("path",foldersPath.count()-1);
@ -195,9 +198,9 @@ void FolderController::service(HttpRequest& request, HttpResponse& response)
const ComicDB * comic = (ComicDB *)item; const ComicDB * comic = (ComicDB *)item;
t.setVariable(QString("element%1.browse").arg(i),""); t.setVariable(QString("element%1.browse").arg(i),"");
//t.setVariable(QString("element%1.downloadurl").arg(i),"/library/"+libraryName+"/comic/"+QString("%1").arg(comic->id)); //t.setVariable(QString("element%1.downloadurl").arg(i),"/library/"+libraryName+"/comic/"+QString("%1").arg(comic->id));
if(!session.isComicOnDevice(comic->info.hash) && !session.isComicDownloaded(comic->info.hash)) if(!ySession->isComicOnDevice(comic->info.hash) && !ySession->isComicDownloaded(comic->info.hash))
t.setVariable(QString("element%1.download").arg(i),QString("<a onclick=\"this.innerHTML='IMPORTING';this.className='importedButton';\" class =\"importButton\" href=\"%1\">IMPORT</a>").arg("/library/"+QString::number(libraryId)+"/comic/"+QString("%1").arg(comic->id))); t.setVariable(QString("element%1.download").arg(i),QString("<a onclick=\"this.innerHTML='IMPORTING';this.className='importedButton';\" class =\"importButton\" href=\"%1\">IMPORT</a>").arg("/library/"+QString::number(libraryId)+"/comic/"+QString("%1").arg(comic->id)));
else if (session.isComicOnDevice(comic->info.hash)) else if (ySession->isComicOnDevice(comic->info.hash))
t.setVariable(QString("element%1.download").arg(i),QString("<div class=\"importedButton\">IMPORTED</div>")); t.setVariable(QString("element%1.download").arg(i),QString("<div class=\"importedButton\">IMPORTED</div>"));
else else
t.setVariable(QString("element%1.download").arg(i),QString("<div class=\"importedButton\">IMPORTING</div>")); t.setVariable(QString("element%1.download").arg(i),QString("<div class=\"importedButton\">IMPORTING</div>"));
@ -316,6 +319,5 @@ void FolderController::service(HttpRequest& request, HttpResponse& response)
t.setVariable("page",QString("%1").arg(page+1)); t.setVariable("page",QString("%1").arg(page+1));
t.setVariable("pages",QString("%1").arg(numPages)); t.setVariable("pages",QString("%1").arg(numPages));
response.writeText(t, true); response.write(t.toUtf8(), true);
} }

4
YACReaderLibrary/server/controllers/folderinfocontroller.cpp
View File

@ -22,7 +22,7 @@ void FolderInfoController::service(HttpRequest& request, HttpResponse& response)
serviceComics(libraryId, parentId, response); serviceComics(libraryId, parentId, response);
response.writeText("",true); response.write("",true);
} }
void FolderInfoController::serviceComics(const int &library, const qulonglong &folderId, HttpResponse &response) void FolderInfoController::serviceComics(const int &library, const qulonglong &folderId, HttpResponse &response)
@ -34,7 +34,7 @@ void FolderInfoController::serviceComics(const int &library, const qulonglong &f
for(QList<LibraryItem *>::const_iterator itr = folderComics.constBegin();itr!=folderComics.constEnd();itr++) for(QList<LibraryItem *>::const_iterator itr = folderComics.constBegin();itr!=folderComics.constEnd();itr++)
{ {
currentComic = (ComicDB *)(*itr); currentComic = (ComicDB *)(*itr);
response.writeText(QString("/library/%1/comic/%2:%3:%4\r\n").arg(library).arg(currentComic->id).arg(currentComic->getFileName()).arg(currentComic->getFileSize())); response.write(QString("/library/%1/comic/%2:%3:%4\r\n").arg(library).arg(currentComic->id).arg(currentComic->getFileName()).arg(currentComic->getFileSize()).toUtf8());
delete currentComic; delete currentComic;
} }

8
YACReaderLibrary/server/controllers/librariescontroller.cpp
View File

@ -1,6 +1,7 @@
#include "librariescontroller.h" #include "librariescontroller.h"
#include "db_helper.h" //get libraries #include "db_helper.h" //get libraries
#include "yacreader_libraries.h" #include "yacreader_libraries.h"
#include "yacreader_http_session.h"
#include "template.h" #include "template.h"
#include "../static.h" #include "../static.h"
@ -12,13 +13,14 @@ LibrariesController::LibrariesController() {}
void LibrariesController::service(HttpRequest& request, HttpResponse& response) void LibrariesController::service(HttpRequest& request, HttpResponse& response)
{ {
HttpSession session=Static::sessionStore->getSession(request,response,false); HttpSession session=Static::sessionStore->getSession(request,response,false);
YACReaderHttpSession *ySession = Static::yacreaderSessionStore->getYACReaderSessionHttpSession(session.getId());
response.setHeader("Content-Type", "text/html; charset=utf-8"); response.setHeader("Content-Type", "text/html; charset=utf-8");
response.setHeader("Connection","close"); response.setHeader("Connection","close");
session.clearNavigationPath(); ySession->clearNavigationPath();
Template t=Static::templateLoader->getTemplate("libraries_"+session.getDeviceType(),request.getHeader("Accept-Language")); Template t=Static::templateLoader->getTemplate("libraries_"+ySession->getDeviceType(),request.getHeader("Accept-Language"));
t.enableWarnings(); t.enableWarnings();
YACReaderLibraries libraries = DBHelper::getLibraries(); YACReaderLibraries libraries = DBHelper::getLibraries();
@ -36,5 +38,5 @@ void LibrariesController::service(HttpRequest& request, HttpResponse& response)
} }
response.setStatus(200,"OK"); response.setStatus(200,"OK");
response.writeText(t,true); response.write(t.toUtf8(),true);
} }

15
YACReaderLibrary/server/controllers/pagecontroller.cpp
View File

@ -4,6 +4,8 @@
#include "comic.h" #include "comic.h"
#include "comiccontroller.h" #include "comiccontroller.h"
#include "yacreader_http_session.h"
#include <QDataStream> #include <QDataStream>
#include <QPointer> #include <QPointer>
@ -16,6 +18,7 @@ PageController::PageController() {}
void PageController::service(HttpRequest& request, HttpResponse& response) void PageController::service(HttpRequest& request, HttpResponse& response)
{ {
HttpSession session=Static::sessionStore->getSession(request,response,false); HttpSession session=Static::sessionStore->getSession(request,response,false);
YACReaderHttpSession *ySession = Static::yacreaderSessionStore->getYACReaderSessionHttpSession(session.getId());
QString path = QUrl::fromPercentEncoding(request.getPath()).toUtf8(); QString path = QUrl::fromPercentEncoding(request.getPath()).toUtf8();
bool remote = path.endsWith("remote"); bool remote = path.endsWith("remote");
@ -35,14 +38,14 @@ void PageController::service(HttpRequest& request, HttpResponse& response)
if(remote) if(remote)
{ {
QLOG_TRACE() << "se recupera comic remoto para servir páginas"; QLOG_TRACE() << "se recupera comic remoto para servir páginas";
comicFile = session.getCurrentRemoteComic(); comicFile = ySession->getCurrentRemoteComic();
currentComicId = session.getCurrentRemoteComicId(); currentComicId = ySession->getCurrentRemoteComicId();
} }
else else
{ {
QLOG_TRACE() << "se recupera comic para servir páginas"; QLOG_TRACE() << "se recupera comic para servir páginas";
comicFile = session.getCurrentComic(); comicFile = ySession->getCurrentComic();
currentComicId = session.getCurrentComicId(); currentComicId = ySession->getCurrentComicId();
} }
if(currentComicId != 0 && !QPointer<Comic>(comicFile).isNull()) if(currentComicId != 0 && !QPointer<Comic>(comicFile).isNull())
@ -77,9 +80,9 @@ void PageController::service(HttpRequest& request, HttpResponse& response)
{ {
//delete comicFile; //delete comicFile;
if(remote) if(remote)
session.dismissCurrentRemoteComic(); ySession->dismissCurrentRemoteComic();
else else
session.dismissCurrentComic(); ySession->dismissCurrentComic();
} }
response.setStatus(404,"not found"); //TODO qué mensaje enviar response.setStatus(404,"not found"); //TODO qué mensaje enviar
response.write("404 not found",true); response.write("404 not found",true);

2
YACReaderLibrary/server/controllers/synccontroller.cpp
View File

@ -55,7 +55,7 @@ void SyncController::service(HttpRequest &request, HttpResponse &response)
else else
{ {
response.setStatus(412,"No comic info received"); response.setStatus(412,"No comic info received");
response.writeText("",true); response.write("",true);
return; return;
} }

4
YACReaderLibrary/server/controllers/tagscontroller.cpp
View File

@ -23,8 +23,8 @@ void TagsController::service(HttpRequest& request, HttpResponse& response)
foreach(LabelItem * tag, tags) foreach(LabelItem * tag, tags)
{ {
response.writeText(QString("%1\t%2\t%3\r\n").arg(tag->getId()).arg(tag->name()).arg(labelColorToRGBString(tag->colorid()))); response.write(QString("%1\t%2\t%3\r\n").arg(tag->getId()).arg(tag->name()).arg(labelColorToRGBString(tag->colorid())).toUtf8());
} }
response.writeText("",true); response.write("",true);
} }

2
YACReaderLibrary/server/controllers/updatecomiccontroller.cpp
View File

@ -38,7 +38,7 @@ void UpdateComicController::service(HttpRequest &request, HttpResponse &response
else else
{ {
response.setStatus(412,"No comic info received"); response.setStatus(412,"No comic info received");
response.writeText("",true); response.write("",true);
return; return;
} }

2
YACReaderLibrary/server/controllers/versioncontroller.cpp
View File

@ -6,5 +6,5 @@ void VersionController::service(HttpRequest& request, HttpResponse& response)
{ {
Q_UNUSED(request); Q_UNUSED(request);
response.writeText(SERVER_VERSION_NUMBER,true); response.write(SERVER_VERSION_NUMBER,true);
} }

12
YACReaderLibrary/server/lib/bfHttpServer/bfHttpServer.pri
View File

@ -1,12 +0,0 @@
INCLUDEPATH += $$PWD
DEPENDPATH += $$PWD
HEADERS += $$PWD/httplistener.h $$PWD/httpconnectionhandler.h $$PWD/httpconnectionhandlerpool.h $$PWD/httprequest.h $$PWD/httpresponse.h $$PWD/httpcookie.h $$PWD/httprequesthandler.h
HEADERS += $$PWD/httpsession.h $$PWD/httpsessionstore.h
HEADERS += $$PWD/staticfilecontroller.h
SOURCES += $$PWD/httplistener.cpp $$PWD/httpconnectionhandler.cpp $$PWD/httpconnectionhandlerpool.cpp $$PWD/httprequest.cpp $$PWD/httpresponse.cpp $$PWD/httpcookie.cpp $$PWD/httprequesthandler.cpp
SOURCES += $$PWD/httpsession.cpp $$PWD/httpsessionstore.cpp
SOURCES += $$PWD/staticfilecontroller.cpp
OTHER_FILES += $$PWD/../doc/readme.txt

170
YACReaderLibrary/server/lib/bfHttpServer/httpconnectionhandler.cpp
View File

@ -1,170 +0,0 @@
/**
@file
@author Stefan Frings
*/
#include "httpconnectionhandler.h"
#include "httpresponse.h"
#include <QTimer>
#include <QCoreApplication>
HttpConnectionHandler::HttpConnectionHandler(QSettings* settings, HttpRequestHandler* requestHandler)
: QThread()
{
Q_ASSERT(settings!=0);
Q_ASSERT(requestHandler!=0);
this->settings=settings;
this->requestHandler=requestHandler;
currentRequest=0;
busy = false;
// execute signals in my own thread
moveToThread(this);
socket.moveToThread(this);
readTimer.moveToThread(this);
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();
}
HttpConnectionHandler::~HttpConnectionHandler() {
socket.close();
quit();
wait();
qDebug("HttpConnectionHandler (%p): destroyed", this);
}
void HttpConnectionHandler::run() {
qDebug("HttpConnectionHandler (%p): thread started", this);
try {
exec();
}
catch (...) {
qCritical("HttpConnectionHandler (%p): an uncatched exception occured in the thread",this);
}
qDebug("HttpConnectionHandler (%p): thread stopped", this);
// Change to the main thread, otherwise deleteLater() would not work
moveToThread(QCoreApplication::instance()->thread());
}
void HttpConnectionHandler::handleConnection(tSocketDescriptor socketDescriptor) {
qDebug("HttpConnectionHandler (%p): handle new connection", this);
busy = true;
Q_ASSERT(socket.isOpen()==false); // if not, then the handler is already busy
if (!socket.setSocketDescriptor(socketDescriptor)) {
qCritical("HttpConnectionHandler (%p): cannot initialize socket: %s", this,qPrintable(socket.errorString()));
return;
}
// Start timer for read timeout
int readTimeout=settings->value("readTimeout",10000).toInt();
readTimer.start(readTimeout);
// delete previous request
delete currentRequest;
currentRequest=0;
}
bool HttpConnectionHandler::isBusy() {
return busy;
}
void HttpConnectionHandler::setBusy() {
this->busy = true;
}
void HttpConnectionHandler::readTimeout() {
qDebug("HttpConnectionHandler (%p): read timeout occured",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");
socket.disconnectFromHost();
delete currentRequest;
currentRequest=0;
}
void HttpConnectionHandler::disconnected() {
qDebug("HttpConnectionHandler (%p): disconnected", this);
socket.close();
readTimer.stop();
busy = false;
}
void HttpConnectionHandler::read() {
while (socket.bytesAvailable()) {
#ifdef SUPERVERBOSE
qDebug("HttpConnectionHandler (%p): read input",this);
#endif
// Create new HttpRequest object if necessary
if (!currentRequest) {
currentRequest=new HttpRequest(settings);
}
// 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=settings->value("readTimeout",10000).toInt();
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");
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",this);
HttpResponse response(&socket);
//response.setHeader("Connection","close"); No funciona bien con NSURLConnection
try {
requestHandler->service(*currentRequest, response);
}
catch (...) {
qCritical("HttpConnectionHandler (%p): An uncatched exception occured in the request handler",this);
}
// Finalize sending the response if not already done
if (!response.hasSentLastPart()) {
response.write(QByteArray(),true);
}
//socket.disconnectFromHost(); //CAMBIADO sólo se van a soportar conexiones NO persistentes
// Close the connection after delivering the response, if requested
if (QString::compare(currentRequest->getHeader("Connection"),"close",Qt::CaseInsensitive)==0) {
socket.disconnectFromHost();
}
else {
// Start timer for next request
int readTimeout=settings->value("readTimeout",10000).toInt();
readTimer.start(readTimeout);
}
// Prepare for next request
delete currentRequest;
currentRequest=0;
}
else
{
qDebug("HttpConnectionHandler (%p): received request",this);
}
}
}

64
YACReaderLibrary/server/lib/bfHttpServer/httpconnectionhandlerpool.cpp
View File

@ -1,64 +0,0 @@
#include "httpconnectionhandlerpool.h"
HttpConnectionHandlerPool::HttpConnectionHandlerPool(QSettings* settings, HttpRequestHandler* requestHandler)
: QObject()
{
Q_ASSERT(settings!=0);
this->settings=settings;
this->requestHandler=requestHandler;
cleanupTimer.start(settings->value("cleanupInterval",10000).toInt());
connect(&cleanupTimer, SIGNAL(timeout()), SLOT(cleanup()));
}
HttpConnectionHandlerPool::~HttpConnectionHandlerPool() {
foreach(HttpConnectionHandler* handler, pool) {
connect(handler,SIGNAL(finished()),handler,SLOT(deleteLater()));
handler->quit();
}
}
HttpConnectionHandler* HttpConnectionHandlerPool::getConnectionHandler() {
HttpConnectionHandler* freeHandler=0;
mutex.lock();
// find a free handler in pool
foreach(HttpConnectionHandler* handler, pool) {
if (!handler->isBusy()) {
freeHandler=handler;
freeHandler->setBusy();
break;
}
}
// create a new handler, if necessary
if (!freeHandler) {
int maxConnectionHandlers=settings->value("maxThreads",1000).toInt();
if (pool.count()<maxConnectionHandlers) {
freeHandler=new HttpConnectionHandler(settings,requestHandler);
freeHandler->setBusy();
pool.append(freeHandler);
}
}
mutex.unlock();
return freeHandler;
}
void HttpConnectionHandlerPool::cleanup() {
int maxIdleHandlers=settings->value("minThreads",50).toInt();
int idleCounter=0;
mutex.lock();
foreach(HttpConnectionHandler* handler, pool) {
if (!handler->isBusy()) {
if (++idleCounter > maxIdleHandlers) {
pool.removeOne(handler);
qDebug("HttpConnectionHandlerPool: Removed connection handler (%p), pool size is now %i",handler,pool.size());
connect(handler,SIGNAL(finished()),handler,SLOT(deleteLater()));
handler->quit();
break; // remove only one handler in each interval
}
}
}
mutex.unlock();
}

132
YACReaderLibrary/server/lib/bfHttpServer/httpresponse.cpp
View File

@ -1,132 +0,0 @@
/**
@file
@author Stefan Frings
*/
#include "httpresponse.h"
HttpResponse::HttpResponse(QTcpSocket* socket) {
this->socket=socket;
statusCode=200;
statusText="OK";
sentHeaders=false;
sentLastPart=false;
}
void HttpResponse::setHeader(QByteArray name, QByteArray value) {
//Q_ASSERT(sentHeaders==false);
headers.insert(name,value);
}
void HttpResponse::setHeader(QByteArray name, int value) {
//Q_ASSERT(sentHeaders==false);
headers.insert(name,QByteArray::number(value));
}
QMap<QByteArray,QByteArray>& HttpResponse::getHeaders() {
return headers;
}
void HttpResponse::setStatus(int statusCode, QByteArray description) {
this->statusCode=statusCode;
statusText=description;
}
void HttpResponse::writeHeaders() {
//Q_ASSERT(sentHeaders==false);
QByteArray buffer;
buffer.append("HTTP/1.1 ");
buffer.append(QByteArray::number(statusCode));
buffer.append(' ');
buffer.append(statusText);
buffer.append("\r\n");
foreach(QByteArray name, headers.keys()) {
buffer.append(name);
buffer.append(": ");
buffer.append(headers.value(name));
buffer.append("\r\n");
}
foreach(HttpCookie cookie,cookies.values()) {
buffer.append("Set-Cookie: ");
buffer.append(cookie.toByteArray());
buffer.append("\r\n");
}
buffer.append("\r\n");
writeToSocket(buffer);
sentHeaders=true;
}
bool HttpResponse::writeToSocket(QByteArray data) {
int remaining=data.size();
char* ptr=data.data();
while (socket->isOpen() && remaining>0) {
// Wait until the previous buffer content is written out, otherwise it could become very large
socket->waitForBytesWritten(-1);
int written=socket->write(ptr,remaining);
if (written==-1) {
return false;
}
ptr+=written;
remaining-=written;
}
return true;
}
void HttpResponse::write(QByteArray data, bool lastPart) {
//Q_ASSERT(sentLastPart==false);
if (sentHeaders==false) {
QByteArray connectionMode=headers.value("Connection");
if (!headers.contains("Content-Length") && !headers.contains("Transfer-Encoding") && connectionMode!="close" && connectionMode!="Close") {
if (!lastPart) {
headers.insert("Transfer-Encoding","chunked");
}
else {
headers.insert("Content-Length",QByteArray::number(data.size()));
}
}
writeHeaders();
}
bool chunked=headers.value("Transfer-Encoding")=="chunked" || headers.value("Transfer-Encoding")=="Chunked";
if (chunked) {
if (data.size()>0) {
QByteArray buffer=QByteArray::number(data.size(),16);
buffer.append("\r\n");
writeToSocket(buffer);
writeToSocket(data);
writeToSocket("\r\n");
}
}
else {
writeToSocket(data);
}
if (lastPart) {
if (chunked) {
writeToSocket("0\r\n\r\n");
}
else if (!headers.contains("Content-Length")) {
socket->disconnectFromHost();
}
sentLastPart=true;
}
}
void HttpResponse::writeText(QString text, bool lastPart)
{
write(QByteArray(text.toUtf8()),lastPart);
}
bool HttpResponse::hasSentLastPart() const {
return sentLastPart;
}
void HttpResponse::setCookie(const HttpCookie& cookie) {
//Q_ASSERT(sentHeaders==false);
if (!cookie.getName().isEmpty()) {
cookies.insert(cookie.getName(),cookie);
}
}
QMap<QByteArray,HttpCookie>& HttpResponse::getCookies() {
return cookies;
}

135
YACReaderLibrary/server/lib/bfHttpServer/httpresponse.h
View File

@ -1,135 +0,0 @@
/**
@file
@author Stefan Frings
*/
#ifndef HTTPRESPONSE_H
#define HTTPRESPONSE_H
#include <QMap>
#include <QString>
#include <QTcpSocket>
#include "httpcookie.h"
/**
This object represents a HTTP response, in particular the response headers.
<p>
Example code for proper response generation:
<code><pre>
response.setStatus(200,"OK"); // optional, because this is the default
response.writeBody("Hello");
response.writeBody("World!",true);
</pre></code>
<p>
Example how to return an error:
<code><pre>
response.setStatus(500,"server error");
response.write("The request cannot be processed because the servers is broken",true);
</pre></code>
<p>
For performance reason, writing a single or few large packets is better than writing
many small packets. In case of large responses (e.g. file downloads), a Content-Length
header should be set before calling write(). Web Browsers use that information to display
a progress bar.
*/
class HttpResponse {
Q_DISABLE_COPY(HttpResponse)
public:
/**
Constructor.
@param socket used to write the response
*/
HttpResponse(QTcpSocket* socket);
/**
Set a HTTP response header
@param name name of the header
@param value value of the header
*/
void setHeader(QByteArray name, QByteArray value);
/**
Set a HTTP response header
@param name name of the header
@param value value of the header
*/
void setHeader(QByteArray name, int value);
/** Get the map of HTTP response headers */
QMap<QByteArray,QByteArray>& getHeaders();
/** Get the map of cookies */
QMap<QByteArray,HttpCookie>& getCookies();
/**
Set status code and description. The default is 200,OK.
*/
void setStatus(int statusCode, QByteArray description=QByteArray());
/**
Write body data to the socket.
<p>
The HTTP status line and headers are sent automatically before the first
byte of the body gets sent.
<p>
If the response contains only a single chunk (indicated by lastPart=true),
the response is transferred in traditional mode with a Content-Length
header, which is automatically added if not already set before.
<p>
Otherwise, each part is transferred in chunked mode.
@param data Data bytes of the body
@param lastPart Indicator, if this is the last part of the response.
*/
void write(QByteArray data, bool lastPart=false);
void writeText(QString text, bool lastPart=false);
/**
Indicates wheter the body has been sent completely. Used by the connection
handler to terminate the body automatically when necessary.
*/
bool hasSentLastPart() const;
/**
Set a cookie. Cookies are sent together with the headers when the first
call to write() occurs.
*/
void setCookie(const HttpCookie& cookie);
private:
/** Request headers */
QMap<QByteArray,QByteArray> headers;
/** Socket for writing output */
QTcpSocket* socket;
/** HTTP status code*/
int statusCode;
/** HTTP status code description */
QByteArray statusText;
/** Indicator whether headers have been sent */
bool sentHeaders;
/** Indicator whether the body has been sent completely */
bool sentLastPart;
/** Cookies */
QMap<QByteArray,HttpCookie> cookies;
/** Write raw data to the socket. This method blocks until all bytes have been passed to the TCP buffer */
bool writeToSocket(QByteArray data);
/**
Write the response HTTP status and headers to the socket.
Calling this method is optional, because writeBody() calls
it automatically when required.
*/
void writeHeaders();
};
#endif // HTTPRESPONSE_H

381
YACReaderLibrary/server/lib/bfHttpServer/httpsession.cpp
View File

@ -1,381 +0,0 @@
/**
@file
@author Stefan Frings
*/
#include "httpsession.h"
#include <QDateTime>
#include <QUuid>
HttpSession::HttpSession(bool canStore) {
if (canStore) {
dataPtr=new HttpSessionData();
dataPtr->refCount=1;
dataPtr->lastAccess=QDateTime::currentMSecsSinceEpoch();
dataPtr->id=QUuid::createUuid().toString().toLatin1();
dataPtr->yacreaderSessionData.comic = 0;
dataPtr->yacreaderSessionData.comicId = 0;
dataPtr->yacreaderSessionData.remoteComic = 0;
dataPtr->yacreaderSessionData.remoteComicId = 0;
#ifdef SUPERVERBOSE
qDebug("HttpSession: created new session data with id %s",dataPtr->id.data());
#endif
}
else {
dataPtr=0;
}
}
HttpSession::HttpSession(const HttpSession& other) {
dataPtr=other.dataPtr;
if (dataPtr) {
dataPtr->lock.lockForWrite();
dataPtr->refCount++;
#ifdef SUPERVERBOSE
qDebug("HttpSession: refCount of %s is %i",dataPtr->id.data(),dataPtr->refCount);
#endif
dataPtr->lock.unlock();
}
}
HttpSession& HttpSession::operator= (const HttpSession& other) {
HttpSessionData* oldPtr=dataPtr;
dataPtr=other.dataPtr;
if (dataPtr) {
dataPtr->lock.lockForWrite();
dataPtr->refCount++;
#ifdef SUPERVERBOSE
qDebug("HttpSession: refCount of %s is %i",dataPtr->id.data(),dataPtr->refCount);
#endif
dataPtr->lastAccess=QDateTime::currentMSecsSinceEpoch();
dataPtr->lock.unlock();
}
if (oldPtr) {
int refCount;
oldPtr->lock.lockForRead();
refCount=oldPtr->refCount--;
#ifdef SUPERVERBOSE
qDebug("HttpSession: refCount of %s is %i",oldPtr->id.data(),oldPtr->refCount);
#endif
oldPtr->lock.unlock();
if (refCount==0) {
delete oldPtr;
}
}
return *this;
}
HttpSession::~HttpSession() {
if (dataPtr) {
int refCount;
dataPtr->lock.lockForRead();
refCount=--dataPtr->refCount;
#ifdef SUPERVERBOSE
qDebug("HttpSession: refCount of %s is %i",dataPtr->id.data(),dataPtr->refCount);
#endif
dataPtr->lock.unlock();
if (refCount==0) {
qDebug("HttpSession: deleting data");
delete dataPtr;
}
}
}
QByteArray HttpSession::getId() const {
if (dataPtr) {
return dataPtr->id;
}
else {
return QByteArray();
}
}
bool HttpSession::isNull() const {
return dataPtr==0;
}
void HttpSession::set(const QByteArray& key, const QVariant& value) {
if (dataPtr) {
dataPtr->lock.lockForWrite();
dataPtr->values.insert(key,value);
dataPtr->lock.unlock();
}
}
void HttpSession::remove(const QByteArray& key) {
if (dataPtr) {
dataPtr->lock.lockForWrite();
dataPtr->values.remove(key);
dataPtr->lock.unlock();
}
}
QVariant HttpSession::get(const QByteArray& key) const {
QVariant value;
if (dataPtr) {
dataPtr->lock.lockForRead();
value=dataPtr->values.value(key);
dataPtr->lock.unlock();
}
return value;
}
bool HttpSession::contains(const QByteArray& key) const {
bool found=false;
if (dataPtr) {
dataPtr->lock.lockForRead();
found=dataPtr->values.contains(key);
dataPtr->lock.unlock();
}
return found;
}
QMap<QByteArray,QVariant> HttpSession::getAll() const {
QMap<QByteArray,QVariant> values;
if (dataPtr) {
dataPtr->lock.lockForRead();
values=dataPtr->values;
dataPtr->lock.unlock();
}
return values;
}
qint64 HttpSession::getLastAccess() const {
qint64 value=0;
if (dataPtr) {
dataPtr->lock.lockForRead();
value=dataPtr->lastAccess;
dataPtr->lock.unlock();
}
return value;
}
void HttpSession::setLastAccess() {
if (dataPtr) {
dataPtr->lock.lockForRead();
dataPtr->lastAccess=QDateTime::currentMSecsSinceEpoch();
dataPtr->lock.unlock();
}
}
//AÑADIDO
//sets
bool HttpSession::isComicOnDevice(const QString & hash)
{
if(dataPtr)
return dataPtr->yacreaderSessionData.comicsOnDevice.contains(hash);
else
return false;
}
bool HttpSession::isComicDownloaded(const QString & hash)
{
if(dataPtr)
return dataPtr->yacreaderSessionData.downloadedComics.contains(hash);
else
return false;
}
void HttpSession::setComicOnDevice(const QString & hash)
{
if(dataPtr)
{
dataPtr->yacreaderSessionData.comicsOnDevice.insert(hash);
}
}
void HttpSession::setComicsOnDevice(const QSet<QString> & set)
{
if(dataPtr)
{
dataPtr->yacreaderSessionData.comicsOnDevice = set;
}
}
void HttpSession::setDownloadedComic(const QString & hash)
{
if(dataPtr)
{
dataPtr->yacreaderSessionData.downloadedComics.insert(hash);
}
}
QSet<QString> HttpSession::getComicsOnDevice()
{
if(dataPtr)
return dataPtr->yacreaderSessionData.comicsOnDevice ;
else
return QSet<QString>();
}
QSet<QString> HttpSession::getDownloadedComics()
{
if(dataPtr)
return dataPtr->yacreaderSessionData.downloadedComics ;
else
return QSet<QString>();
}
void HttpSession::clearComics()
{
if(dataPtr)
{
dataPtr->yacreaderSessionData.comicsOnDevice.clear();
dataPtr->yacreaderSessionData.downloadedComics.clear();
}
}
//current comic (import)
qulonglong HttpSession::getCurrentComicId()
{
if(dataPtr)
return dataPtr->yacreaderSessionData.comicId ;
else
return 0;
}
Comic* HttpSession::getCurrentComic()
{
if(dataPtr)
{
return dataPtr->yacreaderSessionData.comic ;
}
else
return 0;
}
void HttpSession::dismissCurrentComic()
{
if(dataPtr)
{
if(dataPtr->yacreaderSessionData.comic != 0)
{
dataPtr->yacreaderSessionData.comic->deleteLater();
dataPtr->yacreaderSessionData.comic = 0;
}
dataPtr->yacreaderSessionData.comicId = 0;
}
}
void HttpSession::setCurrentComic(qulonglong id, Comic * comic)
{
if(dataPtr)
{
dismissCurrentComic();
dataPtr->yacreaderSessionData.comicId = id;
dataPtr->yacreaderSessionData.comic = comic;
}
}
//current comic (read)
qulonglong HttpSession::getCurrentRemoteComicId()
{
if(dataPtr)
return dataPtr->yacreaderSessionData.remoteComicId ;
else
return 0;
}
Comic* HttpSession::getCurrentRemoteComic()
{
if(dataPtr)
{
return dataPtr->yacreaderSessionData.remoteComic ;
}
else
return 0;
}
void HttpSession::dismissCurrentRemoteComic()
{
if(dataPtr)
{
if(dataPtr->yacreaderSessionData.remoteComic != 0)
{
dataPtr->yacreaderSessionData.remoteComic->deleteLater();
dataPtr->yacreaderSessionData.remoteComic = 0;
}
dataPtr->yacreaderSessionData.remoteComicId = 0;
}
}
void HttpSession::setCurrentRemoteComic(qulonglong id, Comic * comic)
{
if(dataPtr)
{
dismissCurrentRemoteComic();
dataPtr->yacreaderSessionData.remoteComicId = id;
dataPtr->yacreaderSessionData.remoteComic = comic;
}
}
QString HttpSession::getDeviceType()
{
if(dataPtr)
{
return dataPtr->yacreaderSessionData.device;
}
return "";
}
QString HttpSession::getDisplayType()
{
if(dataPtr)
{
return dataPtr->yacreaderSessionData.display;
}
return "";
}
void HttpSession::setDeviceType(const QString & device)
{
if(dataPtr)
{
//dataPtr->yacreaderSessionData.comicsOnDevice.clear(); //TODO crear un método clear que limpie la sesión completamente
//dataPtr->yacreaderSessionData.downloadedComics.clear();
dataPtr->yacreaderSessionData.device = device;
}
}
void HttpSession::setDisplayType(const QString & display)
{
if(dataPtr)
{
dataPtr->yacreaderSessionData.display = display;
}
}
void HttpSession::clearNavigationPath()
{
if(dataPtr)
dataPtr->yacreaderSessionData.navigationPath.clear();
}
QPair<qulonglong, quint32> HttpSession::popNavigationItem()
{
if(dataPtr && !(dataPtr->yacreaderSessionData.navigationPath.isEmpty()))
return dataPtr->yacreaderSessionData.navigationPath.pop();
return QPair<qulonglong, quint32>();
}
QPair<qulonglong, quint32> HttpSession::topNavigationItem()
{
if(dataPtr && !(dataPtr->yacreaderSessionData.navigationPath.isEmpty()))
return dataPtr->yacreaderSessionData.navigationPath.top();
return QPair<qulonglong, quint32>();
}
void HttpSession::pushNavigationItem(const QPair<qulonglong, quint32> &item)
{
if(dataPtr)
dataPtr->yacreaderSessionData.navigationPath.push(item);
}
void HttpSession::updateTopItem(const QPair<qulonglong, quint32> &item)
{
if(dataPtr && !(dataPtr->yacreaderSessionData.navigationPath.isEmpty()))
{
dataPtr->yacreaderSessionData.navigationPath.pop();
dataPtr->yacreaderSessionData.navigationPath.push(item);
} else if(dataPtr)
{
dataPtr->yacreaderSessionData.navigationPath.push(item);
}
}
QStack<QPair<qulonglong, quint32> > HttpSession::getNavigationPath()
{
if(dataPtr)
return dataPtr->yacreaderSessionData.navigationPath;
else
return QStack<QPair<qulonglong, quint32> >();
}

193
YACReaderLibrary/server/lib/bfHttpServer/httpsession.h
View File

@ -1,193 +0,0 @@
/**
@file
@author Stefan Frings
*/
#ifndef HTTPSESSION_H
#define HTTPSESSION_H
#include <QByteArray>
#include <QVariant>
#include <QReadWriteLock>
#include <QSet>
#include <QString>
#include "comic.h"
/**
This class stores data for a single HTTP session.
A session can store any number of key/value pairs. This class uses implicit
sharing for read and write access. This class is thread safe.
@see HttpSessionStore should be used to create and get instances of this class.
*/
class HttpSession {
public:
/**
Constructor.
@param canStore The session can store data, if this parameter is true.
Otherwise all calls to set() and remove() do not have any effect.
*/
HttpSession(bool canStore=false);
/**
Copy constructor. Creates another HttpSession object that shares the
data of the other object.
*/
HttpSession(const HttpSession& other);
/**
Copy operator. Detaches from the current shared data and attaches to
the data of the other object.
*/
HttpSession& operator= (const HttpSession& other);
/**
Destructor. Detaches from the shared data.
*/
virtual ~HttpSession();
/** Get the unique ID of this session. This method is thread safe. */
QByteArray getId() const;
/**
Null sessions cannot store data. All calls to set() and remove()
do not have any effect.This method is thread safe.
*/
bool isNull() const;
/** Set a value. This method is thread safe. */
void set(const QByteArray& key, const QVariant& value);
/** Remove a value. This method is thread safe. */
void remove(const QByteArray& key);
/** Get a value. This method is thread safe. */
QVariant get(const QByteArray& key) const;
/** Check if a key exists. This method is thread safe. */
bool contains(const QByteArray& key) const;
/**
Get a copy of all data stored in this session.
Changes to the session do not affect the copy and vice versa.
This method is thread safe.
*/
QMap<QByteArray,QVariant> getAll() const;
/**
Get the timestamp of last access. That is the time when the last
HttpSessionStore::getSession() has been called.
This method is thread safe.
*/
qint64 getLastAccess() const;
/**
Set the timestamp of last access, to renew the timeout period.
Called by HttpSessionStore::getSession().
This method is thread safe.
*/
void setLastAccess();
//AÑADIDO
//sets
void setComicsOnDevice(const QSet<QString> & set);
void setComicOnDevice(const QString & hash);
void setDownloadedComic(const QString & hash);
bool isComicOnDevice(const QString & hash);
bool isComicDownloaded(const QString & hash);
QSet<QString> getComicsOnDevice();
QSet<QString> getDownloadedComics();
void clearComics();
//current comic (import)
qulonglong getCurrentComicId();
Comic * getCurrentComic();
void dismissCurrentComic();
void setCurrentComic(qulonglong id, Comic * comic);
//current comic (read)
qulonglong getCurrentRemoteComicId();
Comic * getCurrentRemoteComic();
void dismissCurrentRemoteComic();
void setCurrentRemoteComic(qulonglong id, Comic * comic);
//device identification
QString getDeviceType();
QString getDisplayType();
void setDeviceType(const QString & device);
void setDisplayType(const QString & display);
/*int popPage();
void pushPage(int page);
int topPage();
void clearFoldersPath();
int popFolder();
void pushFolder(int page);
int topFolder();
QStack<int> getFoldersPath();*/
void clearNavigationPath();
QPair<qulonglong, quint32> popNavigationItem();
QPair<qulonglong, quint32> topNavigationItem();
void pushNavigationItem(const QPair<qulonglong, quint32> & item);
void updateTopItem(const QPair<qulonglong, quint32> & item);
//TODO replace QPair by a custom class for storing folderId, page and folderName(save some DB accesses)
QStack<QPair<qulonglong, quint32> > getNavigationPath();
private:
struct YACReaderSessionData {
//cómics disponibles en dispositivo
QSet<QString> comicsOnDevice;
//cómics que han sido descargados o están siendo descargados en esta sesión
QSet<QString> downloadedComics;
//cómic actual que está siendo descargado
QString device;
QString display;
qulonglong comicId;
qulonglong remoteComicId;
//folder_id, page_number
QStack<QPair<qulonglong, quint32> > navigationPath;
Comic * comic;
Comic * remoteComic;
};
struct HttpSessionData {
/** Unique ID */
QByteArray id;
/** Timestamp of last access, set by the HttpSessionStore */
qint64 lastAccess;
/** Reference counter */
int refCount;
/** Used to synchronize threads */
QReadWriteLock lock;
/** Storage for the key/value pairs; */
QMap<QByteArray,QVariant> values;
YACReaderSessionData yacreaderSessionData;
};
/** Pointer to the shared data. */
HttpSessionData* dataPtr;
};
#endif // HTTPSESSION_H

235
YACReaderLibrary/server/lib/bfHttpServer/staticfilecontroller.cpp
View File

@ -1,235 +0,0 @@
/**
@file
@author Stefan Frings
*/
#include "staticfilecontroller.h"
#include <QFileInfo>
#include <QDir>
#include <QDateTime>
#include "httpsession.h"
#include "static.h"
#include <QCoreApplication>
StaticFileController::StaticFileController(QSettings* settings, QObject* parent)
:HttpRequestHandler(parent)
{
maxAge=settings->value("maxAge","60000").toInt();
encoding=settings->value("encoding","UTF-8").toString();
docroot=settings->value("path","./server/docroot").toString();
// Convert relative path to absolute, based on the directory of the config file.
#ifdef Q_OS_WIN32
if (QDir::isRelativePath(docroot) && settings->format()!=QSettings::NativeFormat)
#else
if (QDir::isRelativePath(docroot))
#endif
{
#if defined Q_OS_UNIX && ! defined Q_OS_MAC
QFileInfo configFile(QString(DATADIR)+"/yacreader");
docroot=QFileInfo(QString(DATADIR)+"/yacreader",docroot).absoluteFilePath();
#else
QFileInfo configFile(QCoreApplication::applicationDirPath());
docroot=QFileInfo(QCoreApplication::applicationDirPath(),docroot).absoluteFilePath();
#endif
}
qDebug("StaticFileController: docroot=%s, encoding=%s, maxAge=%i",qPrintable(docroot),qPrintable(encoding),maxAge);
maxCachedFileSize=settings->value("maxCachedFileSize","65536").toInt();
cache.setMaxCost(settings->value("cacheSize","1000000").toInt());
cacheTimeout=settings->value("cacheTime","60000").toInt();
qDebug("StaticFileController: cache timeout=%i, size=%i",cacheTimeout,cache.maxCost());
}
void StaticFileController::service(HttpRequest& request, HttpResponse& response) {
QByteArray path=request.getPath();
// Forbid access to files outside the docroot directory
if (path.startsWith("/..")) {
qWarning("StaticFileController: somebody attempted to access a file outside the docroot directory");
response.setStatus(403,"forbidden");
response.write("403 forbidden",true);
}
//TODO(DONE) carga sensible al dispositivo y a la localización
QString stringPath = path;
QStringList paths = QString(path).split('/');
QString fileName = paths.last();
stringPath.remove(fileName);
HttpSession session=Static::sessionStore->getSession(request,response,false);
QString device = session.getDeviceType();
QString display = session.getDisplayType();
if(fileName.endsWith(".png"))
fileName = getDeviceAwareFileName(fileName, device, display, request.getHeader("Accept-Language"), stringPath);
else
fileName = getDeviceAwareFileName(fileName, device, request.getHeader("Accept-Language"), stringPath);
QString newPath = stringPath.append(fileName);
path = newPath.toLocal8Bit();
//CAMBIADO
response.setHeader("Connection","close");
//END_TODO
// Check if we have the file in cache
//qint64 now=QDateTime::currentMSecsSinceEpoch();
// mutex.lock();
// CacheEntry* entry=cache.object(path);
//if (entry && (cacheTimeout==0 || entry->created>now-cacheTimeout)) {
// QByteArray document=entry->document; //copy the cached document, because other threads may destroy the cached entry immediately after mutex unlock.
// mutex.unlock();
// qDebug("StaticFileController: Cache hit for %s",path.data());
// setContentType(path,response);
// response.setHeader("Cache-Control","max-age="+QByteArray::number(maxAge/1000));
// response.write(document);
//}
//else {
// mutex.unlock();
//qDebug("StaticFileController: Cache miss for %s",path.data());
// The file is not in cache.
// If the filename is a directory, append index.html.
if (QFileInfo(docroot+path).isDir()) {
path+="/index.html";
}
QFile file(docroot+path);
if (file.exists()) {
qDebug("StaticFileController: Open file %s",qPrintable(file.fileName()));
if (file.open(QIODevice::ReadOnly)) {
setContentType(path,response);
//response.setHeader("Cache-Control","max-age="+QByteArray::number(maxAge/1000));
//if (file.size()<=maxCachedFileSize) {
// // Return the file content and store it also in the cache
// entry=new CacheEntry();
// while (!file.atEnd() && !file.error()) {
// QByteArray buffer=file.read(65536);
// response.write(buffer);
// entry->document.append(buffer);
// }
// entry->created=now;
// mutex.lock();
// cache.insert(request.getPath(),entry,entry->document.size());
// mutex.unlock();
//}
//else {
// Return the file content, do not store in cache*/
while (!file.atEnd() && !file.error()) {
response.write(file.read(131072));
//}
}
file.close();
}
else {
qWarning("StaticFileController: Cannot open existing file %s for reading",qPrintable(file.fileName()));
response.setStatus(403,"forbidden");
response.write("403 forbidden",true);
}
}
else {
response.setStatus(404,"not found");
response.write("404 not found",true);
}
//}
}
void StaticFileController::setContentType(QString fileName, HttpResponse& response) const {
if (fileName.endsWith(".png")) {
response.setHeader("Content-Type", "image/png");
}
else if (fileName.endsWith(".jpg")) {
response.setHeader("Content-Type", "image/jpeg");
}
else if (fileName.endsWith(".gif")) {
response.setHeader("Content-Type", "image/gif");
}
else if (fileName.endsWith(".pdf")) {
response.setHeader("Content-Type", "application/pdf");
}
else if (fileName.endsWith(".txt")) {
response.setHeader("Content-Type", qPrintable("text/plain; charset="+encoding));
}
else if (fileName.endsWith(".html") || fileName.endsWith(".htm")) {
response.setHeader("Content-Type", qPrintable("text/html; charset="+encoding));
}
else if (fileName.endsWith(".css")) {
response.setHeader("Content-Type", "text/css");
}
else if (fileName.endsWith(".js")) {
response.setHeader("Content-Type", "text/javascript");
}
// Todo: add all of your content types
}
bool StaticFileController::exists(QString localizedName, QString path) const
{
QString fileName=docroot+"/"+path + localizedName;
QFile file(fileName);
return file.exists();
}
//retorna fileName si no se encontró alternativa traducida ó fileName-locale.extensión si se encontró
QString StaticFileController::getLocalizedFileName(QString fileName, QString locales, QString path) const
{
QSet<QString> tried; // used to suppress duplicate attempts
QStringList locs=locales.split(',',QString::SkipEmptyParts);
QStringList fileNameParts = fileName.split('.');
QString file = fileNameParts.first();
QString extension = fileNameParts.last();
// Search for exact match
foreach (QString loc,locs) {
loc.replace(QRegExp(";.*"),"");
loc.replace('-','_');
QString localizedName=file+"-"+loc.trimmed()+"."+extension;
if (!tried.contains(localizedName)) {
if(exists(localizedName, path))
return localizedName;
tried.insert(localizedName);
}
}
// Search for correct language but any country
foreach (QString loc,locs) {
loc.replace(QRegExp("[;_-].*"),"");
QString localizedName=file+"-"+loc.trimmed()+"."+extension;
if (!tried.contains(localizedName)) {
if(exists(localizedName, path))
return localizedName;
tried.insert(localizedName);
}
}
return fileName;
}
QString StaticFileController::getDeviceAwareFileName(QString fileName, QString device, QString locales, QString path) const
{
QFileInfo fi(fileName);
QString baseName = fi.baseName();
QString extension = fi.completeSuffix();
QString completeFileName = getLocalizedFileName(baseName+"_"+device+"."+extension,locales,path);
if(QFile(docroot+"/"+path+completeFileName).exists())
return completeFileName; //existe un archivo específico para este dispositivo y locales
else
return getLocalizedFileName(fileName,locales,path); //no hay archivo específico para el dispositivo, pero puede haberlo para estas locales
}
QString StaticFileController::getDeviceAwareFileName(QString fileName, QString device, QString display, QString locales, QString path) const
{
QFileInfo fi(fileName);
QString baseName = fi.baseName();
QString extension = fi.completeSuffix();
QString completeFileName = baseName+display+"."+extension;
if(QFile(docroot+"/"+path+completeFileName).exists())
return completeFileName;
else
{
completeFileName = baseName+"_"+device+display+"."+extension;
if((QFile(docroot+"/"+path+completeFileName).exists()))
return completeFileName;
}
return fileName;
}

92
YACReaderLibrary/server/lib/bfHttpServer/staticfilecontroller.h
View File

@ -1,92 +0,0 @@
/**
@file
@author Stefan Frings
*/
#ifndef STATICFILECONTROLLER_H
#define STATICFILECONTROLLER_H
#include "httprequest.h"
#include "httpresponse.h"
#include "httprequesthandler.h"
#include <QCache>
#include <QMutex>
/**
Delivers static files. It is usually called by the applications main request handler when
the caller request a path that is mapped to static files.
<p>
The following settings are required in the config file:
<code><pre>
path=docroot
encoding=UTF-8
maxAge=60000
cacheTime=60000
cacheSize=1000000
maxCachedFileSize=65536
</pre></code>
The path is relative to the directory of the config file. In case of windows, if the
settings are in the registry, the path is relative to the current working directory.
<p>
The encoding is sent to the web browser in case of text and html files.
<p>
The cache improves performance of small files when loaded from a network
drive. Large files are not cached. Files are cached as long as possible,
when cacheTime=0. The maxAge value (in msec!) controls the remote browsers cache.
<p>
Do not instantiate this class in each request, because this would make the file cache
useless. Better create one instance during start-up and call it when the application
received a related HTTP request.
*/
class StaticFileController : public HttpRequestHandler {
Q_OBJECT
Q_DISABLE_COPY(StaticFileController);
public:
/** Constructor */
StaticFileController(QSettings* settings, QObject* parent = 0);
/** Generates the response */
void service(HttpRequest& request, HttpResponse& response);
private:
/** Encoding of text files */
QString encoding;
/** Root directory of documents */
QString docroot;
/** Maximum age of files in the browser cache */
int maxAge;
struct CacheEntry {
QByteArray document;
qint64 created;
};
/** Timeout for each cached file */
int cacheTimeout;
/** Maximum size of files in cache, larger files are not cached */
int maxCachedFileSize;
/** Cache storage */
QCache<QString,CacheEntry> cache;
/** Used to synchronize cache access for threads */
QMutex mutex;
/** Set a content-type header in the response depending on the ending of the filename */
void setContentType(QString file, HttpResponse& response) const;
QString getLocalizedFileName(QString fileName, QString locales, QString path) const;
QString getDeviceAwareFileName(QString fileName, QString device, QString locales, QString path) const;
QString getDeviceAwareFileName(QString fileName, QString device, QString display, QString locales, QString path) const;
bool exists(QString localizedName, QString path) const;
};
#endif // STATICFILECONTROLLER_H

5
YACReaderLibrary/server/lib/bfLogging/bfLogging.pri
View File

@ -1,5 +0,0 @@
INCLUDEPATH += $$PWD
DEPENDPATH += $$PWD
HEADERS += $$PWD/logmessage.h $$PWD/logger.h $$PWD/filelogger.h $$PWD/dualfilelogger.h
SOURCES += $$PWD/logmessage.cpp $$PWD/logger.cpp $$PWD/filelogger.cpp $$PWD/dualfilelogger.cpp

7
YACReaderLibrary/server/lib/bfTemplateEngine/bfTemplateEngine.pri
View File

@ -1,7 +0,0 @@
INCLUDEPATH += $$PWD
DEPENDPATH += $$PWD
HEADERS += $$PWD/template.h $$PWD/templateloader.h $$PWD/templatecache.h
SOURCES += $$PWD/template.cpp $$PWD/templateloader.cpp $$PWD/templatecache.cpp
OTHER_FILES += $$PWD/../doc/readme.txt

275
YACReaderLibrary/server/lib/httpserver/httpconnectionhandler.cpp Normal file
View File

@ -0,0 +1,275 @@
/**
@file
@author Stefan Frings
*/
#include "httpconnectionhandler.h"
#include "httpresponse.h"
HttpConnectionHandler::HttpConnectionHandler(QSettings* settings, HttpRequestHandler* requestHandler, QSslConfiguration* sslConfiguration)
: QThread()
{
Q_ASSERT(settings!=0);
Q_ASSERT(requestHandler!=0);
this->settings=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();
}
HttpConnectionHandler::~HttpConnectionHandler()
{
quit();
wait();
qDebug("HttpConnectionHandler (%p): destroyed", this);
}
void HttpConnectionHandler::createSocket()
{
// 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();
}
void HttpConnectionHandler::run()
{
qDebug("HttpConnectionHandler (%p): thread started", this);
try
{
exec();
}
catch (...)
{
qCritical("HttpConnectionHandler (%p): an uncatched exception occured in the thread",this);
}
socket->close();
delete socket;
readTimer.stop();
qDebug("HttpConnectionHandler (%p): thread stopped", this);
}
void HttpConnectionHandler::handleConnection(tSocketDescriptor socketDescriptor)
{
qDebug("HttpConnectionHandler (%p): handle new connection", this);
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=settings->value("readTimeout",10000).toInt();
readTimer.start(readTimeout);
// delete previous request
delete currentRequest;
currentRequest=0;
}
bool HttpConnectionHandler::isBusy()
{
return busy;
}
void HttpConnectionHandler::setBusy()
{
this->busy = true;
}
void HttpConnectionHandler::readTimeout()
{
qDebug("HttpConnectionHandler (%p): read timeout occured",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");
socket->flush();
socket->disconnectFromHost();
delete currentRequest;
currentRequest=0;
}
void HttpConnectionHandler::disconnected()
{
qDebug("HttpConnectionHandler (%p): disconnected", this);
socket->close();
readTimer.stop();
busy = false;
}
void HttpConnectionHandler::read()
{
// 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)
{
currentRequest=new HttpRequest(settings);
}
// 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=settings->value("readTimeout",10000).toInt();
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");
socket->flush();
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",this);
// 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 occured in the request handler",this);
}
// Finalize sending the response if not already done
if (!response.hasSentLastPart())
{
response.write(QByteArray(),true);
}
qDebug("HttpConnectionHandler (%p): finished request",this);
// 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)
{
socket->flush();
socket->disconnectFromHost();
}
else
{
// Start timer for next request
int readTimeout=settings->value("readTimeout",10000).toInt();
readTimer.start(readTimeout);
}
delete currentRequest;
currentRequest=0;
}
}
}

45
YACReaderLibrary/server/lib/bfHttpServer/httpconnectionhandler.h → YACReaderLibrary/server/lib/httpserver/httpconnectionhandler.h
View File

@ -6,13 +6,29 @@
#ifndef HTTPCONNECTIONHANDLER_H #ifndef HTTPCONNECTIONHANDLER_H
#define HTTPCONNECTIONHANDLER_H #define HTTPCONNECTIONHANDLER_H
#ifndef QT_NO_OPENSSL
#include <QSslConfiguration>
#endif
#include <QTcpSocket> #include <QTcpSocket>
#include <QSettings> #include <QSettings>
#include <QTimer> #include <QTimer>
#include <QThread> #include <QThread>
#include "httpglobal.h"
#include "httprequest.h" #include "httprequest.h"
#include "httprequesthandler.h" #include "httprequesthandler.h"
/** Alias type definition, for compatibility to different Qt versions */
#if QT_VERSION >= 0x050000
typedef qintptr tSocketDescriptor;
#else
typedef int tSocketDescriptor;
#endif
/** Alias for QSslConfiguration if OpenSSL is not supported */
#ifdef QT_NO_OPENSSL
#define QSslConfiguration QObject
#endif
/** /**
The connection handler accepts incoming connections and dispatches incoming requests to to a 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, request mapper. Since HTTP clients can send multiple requests before waiting for the response,
@ -26,26 +42,21 @@
</pre></code> </pre></code>
<p> <p>
The readTimeout value defines the maximum time to wait for a complete HTTP request. The readTimeout value defines the maximum time to wait for a complete HTTP request.
@see HttpRequest for description of config settings maxRequestSize and maxMultiPartSize @see HttpRequest for description of config settings maxRequestSize and maxMultiPartSize.
*/ */
class DECLSPEC HttpConnectionHandler : public QThread {
#if QT_VERSION >= 0x050000
typedef qintptr tSocketDescriptor;
#else
typedef int tSocketDescriptor;
#endif
class HttpConnectionHandler : public QThread {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(HttpConnectionHandler) Q_DISABLE_COPY(HttpConnectionHandler)
public: public:
/** /**
Constructor. Constructor.
@param settings Configuration settings of the HTTP webserver @param settings Configuration settings of the HTTP webserver
@param requestHandler handler that will process each incomin HTTP request @param requestHandler Handler that will process each incoming HTTP request
@param sslConfiguration SSL (HTTPS) will be used if not NULL
*/ */
HttpConnectionHandler(QSettings* settings, HttpRequestHandler* requestHandler); HttpConnectionHandler(QSettings* settings, HttpRequestHandler* requestHandler, QSslConfiguration* sslConfiguration=NULL);
/** Destructor */ /** Destructor */
virtual ~HttpConnectionHandler(); virtual ~HttpConnectionHandler();
@ -61,8 +72,8 @@ private:
/** Configuration settings */ /** Configuration settings */
QSettings* settings; QSettings* settings;
/** TCP socket of the current connection */ /** TCP socket of the current connection */
QTcpSocket socket; QTcpSocket* socket;
/** Time for read timeout detection */ /** Time for read timeout detection */
QTimer readTimer; QTimer readTimer;
@ -76,9 +87,15 @@ private:
/** This shows the busy-state from a very early time */ /** This shows the busy-state from a very early time */
bool busy; bool busy;
/** Executes the htreads own event loop */ /** Configuration for SSL */
QSslConfiguration* sslConfiguration;
/** Executes the threads own event loop */
void run(); void run();
/** Create SSL or TCP socket */
void createSocket();
public slots: public slots:
/** /**

146
YACReaderLibrary/server/lib/httpserver/httpconnectionhandlerpool.cpp Normal file
View File

@ -0,0 +1,146 @@
#ifndef QT_NO_OPENSSL
#include <QSslSocket>
#include <QSslKey>
#include <QSslCertificate>
#include <QSslConfiguration>
#endif
#include <QDir>
#include "httpconnectionhandlerpool.h"
HttpConnectionHandlerPool::HttpConnectionHandlerPool(QSettings* settings, HttpRequestHandler* requestHandler)
: QObject()
{
Q_ASSERT(settings!=0);
this->settings=settings;
this->requestHandler=requestHandler;
this->sslConfiguration=NULL;
loadSslConfig();
cleanupTimer.start(settings->value("cleanupInterval",1000).toInt());
connect(&cleanupTimer, SIGNAL(timeout()), SLOT(cleanup()));
}
HttpConnectionHandlerPool::~HttpConnectionHandlerPool()
{
// delete all connection handlers and wait until their threads are closed
foreach(HttpConnectionHandler* handler, pool)
{
delete handler;
}
delete sslConfiguration;
qDebug("HttpConnectionHandlerPool (%p): destroyed", this);
}
HttpConnectionHandler* HttpConnectionHandlerPool::getConnectionHandler()
{
HttpConnectionHandler* freeHandler=0;
mutex.lock();
// find a free handler in pool
foreach(HttpConnectionHandler* handler, pool)
{
if (!handler->isBusy())
{
freeHandler=handler;
freeHandler->setBusy();
break;
}
}
// create a new handler, if necessary
if (!freeHandler)
{
int maxConnectionHandlers=settings->value("maxThreads",100).toInt();
if (pool.count()<maxConnectionHandlers)
{
freeHandler=new HttpConnectionHandler(settings,requestHandler,sslConfiguration);
freeHandler->setBusy();
pool.append(freeHandler);
}
}
mutex.unlock();
return freeHandler;
}
void HttpConnectionHandlerPool::cleanup()
{
int maxIdleHandlers=settings->value("minThreads",1).toInt();
int idleCounter=0;
mutex.lock();
foreach(HttpConnectionHandler* handler, pool)
{
if (!handler->isBusy())
{
if (++idleCounter > maxIdleHandlers)
{
delete handler;
pool.removeOne(handler);
qDebug("HttpConnectionHandlerPool: Removed connection handler (%p), pool size is now %i",handler,pool.size());
break; // remove only one handler in each interval
}
}
}
mutex.unlock();
}
void HttpConnectionHandlerPool::loadSslConfig()
{
// If certificate and key files are configured, then load them
QString sslKeyFileName=settings->value("sslKeyFile","").toString();
QString sslCertFileName=settings->value("sslCertFile","").toString();
if (!sslKeyFileName.isEmpty() && !sslCertFileName.isEmpty())
{
#ifdef QT_NO_OPENSSL
qWarning("HttpConnectionHandlerPool: SSL is not supported");
#else
// Convert relative fileNames to absolute, based on the directory of the config file.
QFileInfo configFile(settings->fileName());
#ifdef Q_OS_WIN32
if (QDir::isRelativePath(sslKeyFileName) && settings->format()!=QSettings::NativeFormat)
#else
if (QDir::isRelativePath(sslKeyFileName))
#endif
{
sslKeyFileName=QFileInfo(configFile.absolutePath(),sslKeyFileName).absoluteFilePath();
}
#ifdef Q_OS_WIN32
if (QDir::isRelativePath(sslCertFileName) && settings->format()!=QSettings::NativeFormat)
#else
if (QDir::isRelativePath(sslCertFileName))
#endif
{
sslCertFileName=QFileInfo(configFile.absolutePath(),sslCertFileName).absoluteFilePath();
}
// Load the SSL certificate
QFile certFile(sslCertFileName);
if (!certFile.open(QIODevice::ReadOnly))
{
qCritical("HttpConnectionHandlerPool: cannot open sslCertFile %s", qPrintable(sslCertFileName));
return;
}
QSslCertificate certificate(&certFile, QSsl::Pem);
certFile.close();
// Load the key file
QFile keyFile(sslKeyFileName);
if (!keyFile.open(QIODevice::ReadOnly))
{
qCritical("HttpConnectionHandlerPool: cannot open sslKeyFile %s", qPrintable(sslKeyFileName));
return;
}
QSslKey sslKey(&keyFile, QSsl::Rsa, QSsl::Pem);
keyFile.close();
// Create the SSL configuration
sslConfiguration=new QSslConfiguration();
sslConfiguration->setLocalCertificate(certificate);
sslConfiguration->setPrivateKey(sslKey);
sslConfiguration->setPeerVerifyMode(QSslSocket::VerifyNone);
sslConfiguration->setProtocol(QSsl::TlsV1SslV3);
qDebug("HttpConnectionHandlerPool: SSL settings loaded");
#endif
}
}

42
YACReaderLibrary/server/lib/bfHttpServer/httpconnectionhandlerpool.h → YACReaderLibrary/server/lib/httpserver/httpconnectionhandlerpool.h
View File

@ -5,29 +5,45 @@
#include <QTimer> #include <QTimer>
#include <QObject> #include <QObject>
#include <QMutex> #include <QMutex>
#include "httpglobal.h"
#include "httpconnectionhandler.h" #include "httpconnectionhandler.h"
/** /**
Pool of http connection handlers. Connection handlers are created on demand and idle handlers are Pool of http connection handlers. The size of the pool grows and
cleaned up in regular time intervals. shrinks on demand.
<p> <p>
Example for the required configuration settings: Example for the required configuration settings:
<code><pre> <code><pre>
minThreads=1 minThreads=4
maxThreads=100 maxThreads=100
cleanupInterval=1000 cleanupInterval=60000
readTimeout=60000
;sslKeyFile=ssl/my.key
;sslCertFile=ssl/my.cert
maxRequestSize=16000 maxRequestSize=16000
maxMultiPartSize=1000000 maxMultiPartSize=1000000
</pre></code> </pre></code>
The pool is empty initially and grows with the number of concurrent After server start, the size of the thread pool is always 0. Threads
connections. A timer removes one idle connection handler at each are started on demand when requests come in. The cleanup timer reduces
interval, but it leaves some spare handlers in memory to improve the number of idle threads slowly by closing one thread in each interval.
performance. But the configured minimum number of threads are kept running.
@see HttpConnectionHandler for description of config settings readTimeout <p>
For SSL support, you need an OpenSSL certificate file and a key file.
Both can be created with the command
<code><pre>
openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout my.key -out my.cert
</pre></code>
<p>
Visit http://slproweb.com/products/Win32OpenSSL.html to download the Light version of OpenSSL for Windows.
<p>
Please note that a listener with SSL settings can only handle HTTPS protocol. To
support both HTTP and HTTPS simultaneously, you need to start two listeners on different ports -
one with SLL and one without SSL.
@see HttpConnectionHandler for description of the readTimeout
@see HttpRequest for description of config settings maxRequestSize and maxMultiPartSize @see HttpRequest for description of config settings maxRequestSize and maxMultiPartSize
*/ */
class HttpConnectionHandlerPool : public QObject { class DECLSPEC HttpConnectionHandlerPool : public QObject {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(HttpConnectionHandlerPool) Q_DISABLE_COPY(HttpConnectionHandlerPool)
public: public:
@ -63,6 +79,12 @@ private:
/** Used to synchronize threads */ /** Used to synchronize threads */
QMutex mutex; QMutex mutex;
/** The SSL configuration (certificate, key and other settings) */
QSslConfiguration* sslConfiguration;
/** Load SSL configuration */
void loadSslConfig();
private slots: private slots:
/** Received from the clean-up timer. */ /** Received from the clean-up timer. */

150
YACReaderLibrary/server/lib/bfHttpServer/httpcookie.cpp → YACReaderLibrary/server/lib/httpserver/httpcookie.cpp
View File

@ -5,13 +5,15 @@
#include "httpcookie.h" #include "httpcookie.h"
HttpCookie::HttpCookie() { HttpCookie::HttpCookie()
{
version=1; version=1;
maxAge=0; maxAge=0;
secure=false; secure=false;
} }
HttpCookie::HttpCookie(const QByteArray name, const QByteArray value, const int maxAge, const QByteArray path, const QByteArray comment, const QByteArray domain, const bool secure) { HttpCookie::HttpCookie(const QByteArray name, const QByteArray value, const int maxAge, const QByteArray path, const QByteArray comment, const QByteArray domain, const bool secure, const bool httpOnly)
{
this->name=name; this->name=name;
this->value=value; this->value=value;
this->maxAge=maxAge; this->maxAge=maxAge;
@ -19,171 +21,230 @@ HttpCookie::HttpCookie(const QByteArray name, const QByteArray value, const int
this->comment=comment; this->comment=comment;
this->domain=domain; this->domain=domain;
this->secure=secure; this->secure=secure;
this->httpOnly=httpOnly;
this->version=1; this->version=1;
} }
HttpCookie::HttpCookie(const QByteArray source) { HttpCookie::HttpCookie(const QByteArray source)
{
version=1; version=1;
maxAge=0; maxAge=0;
secure=false; secure=false;
QList<QByteArray> list=splitCSV(source); QList<QByteArray> list=splitCSV(source);
foreach(QByteArray part, list) { foreach(QByteArray part, list)
{
// Split the part into name and value // Split the part into name and value
QByteArray name; QByteArray name;
QByteArray value; QByteArray value;
int posi=part.indexOf('='); int posi=part.indexOf('=');
if (posi) { if (posi)
{
name=part.left(posi).trimmed(); name=part.left(posi).trimmed();
value=part.mid(posi+1).trimmed(); value=part.mid(posi+1).trimmed();
} }
else { else
{
name=part.trimmed(); name=part.trimmed();
value=""; value="";
} }
// Set fields // Set fields
if (name=="Comment") { if (name=="Comment")
{
comment=value; comment=value;
} }
else if (name=="Domain") { else if (name=="Domain")
{
domain=value; domain=value;
} }
else if (name=="Max-Age") { else if (name=="Max-Age")
{
maxAge=value.toInt(); maxAge=value.toInt();
} }
else if (name=="Path") { else if (name=="Path")
{
path=value; path=value;
} }
else if (name=="Secure") { else if (name=="Secure")
{
secure=true; secure=true;
} }
else if (name=="Version") { else if (name=="HttpOnly")
{
httpOnly=true;
}
else if (name=="Version")
{
version=value.toInt(); version=value.toInt();
} }
else { else {
if (this->name.isEmpty()) { if (this->name.isEmpty())
{
this->name=name; this->name=name;
this->value=value; this->value=value;
} }
else { else
{
qWarning("HttpCookie: Ignoring unknown %s=%s",name.data(),value.data()); qWarning("HttpCookie: Ignoring unknown %s=%s",name.data(),value.data());
} }
} }
} }
} }
QByteArray HttpCookie::toByteArray() const { QByteArray HttpCookie::toByteArray() const
{
QByteArray buffer(name); QByteArray buffer(name);
buffer.append('='); buffer.append('=');
buffer.append(value); buffer.append(value);
if (!comment.isEmpty()) { if (!comment.isEmpty())
{
buffer.append("; Comment="); buffer.append("; Comment=");
buffer.append(comment); buffer.append(comment);
} }
if (!domain.isEmpty()) { if (!domain.isEmpty())
{
buffer.append("; Domain="); buffer.append("; Domain=");
buffer.append(domain); buffer.append(domain);
} }
if (maxAge!=0) { if (maxAge!=0)
{
buffer.append("; Max-Age="); buffer.append("; Max-Age=");
buffer.append(QByteArray::number(maxAge)); buffer.append(QByteArray::number(maxAge));
} }
if (!path.isEmpty()) { if (!path.isEmpty())
{
buffer.append("; Path="); buffer.append("; Path=");
buffer.append(path); buffer.append(path);
} }
if (secure) { if (secure) {
buffer.append("; Secure"); buffer.append("; Secure");
} }
if (httpOnly) {
buffer.append("; HttpOnly");
}
buffer.append("; Version="); buffer.append("; Version=");
buffer.append(QByteArray::number(version)); buffer.append(QByteArray::number(version));
return buffer; return buffer;
} }
void HttpCookie::setName(const QByteArray name){ void HttpCookie::setName(const QByteArray name)
{
this->name=name; this->name=name;
} }
void HttpCookie::setValue(const QByteArray value){ void HttpCookie::setValue(const QByteArray value)
{
this->value=value; this->value=value;
} }
void HttpCookie::setComment(const QByteArray comment){ void HttpCookie::setComment(const QByteArray comment)
{
this->comment=comment; this->comment=comment;
} }
void HttpCookie::setDomain(const QByteArray domain){ void HttpCookie::setDomain(const QByteArray domain)
{
this->domain=domain; this->domain=domain;
} }
void HttpCookie::setMaxAge(const int maxAge){ void HttpCookie::setMaxAge(const int maxAge)
{
this->maxAge=maxAge; this->maxAge=maxAge;
} }
void HttpCookie::setPath(const QByteArray path){ void HttpCookie::setPath(const QByteArray path)
{
this->path=path; this->path=path;
} }
void HttpCookie::setSecure(const bool secure){ void HttpCookie::setSecure(const bool secure)
{
this->secure=secure; this->secure=secure;
} }
QByteArray HttpCookie::getName() const { void HttpCookie::setHttpOnly(const bool httpOnly)
{
this->httpOnly=httpOnly;
}
QByteArray HttpCookie::getName() const
{
return name; return name;
} }
QByteArray HttpCookie::getValue() const { QByteArray HttpCookie::getValue() const
{
return value; return value;
} }
QByteArray HttpCookie::getComment() const { QByteArray HttpCookie::getComment() const
{
return comment; return comment;
} }
QByteArray HttpCookie::getDomain() const { QByteArray HttpCookie::getDomain() const
{
return domain; return domain;
} }
int HttpCookie::getMaxAge() const { int HttpCookie::getMaxAge() const
{
return maxAge; return maxAge;
} }
QByteArray HttpCookie::getPath() const { QByteArray HttpCookie::getPath() const
{
return path; return path;
} }
bool HttpCookie::getSecure() const { bool HttpCookie::getSecure() const
{
return secure; return secure;
} }
int HttpCookie::getVersion() const { bool HttpCookie::getHttpOnly() const
{
return httpOnly;
}
int HttpCookie::getVersion() const
{
return version; return version;
} }
QList<QByteArray> HttpCookie::splitCSV(const QByteArray source) { QList<QByteArray> HttpCookie::splitCSV(const QByteArray source)
{
bool inString=false; bool inString=false;
QList<QByteArray> list; QList<QByteArray> list;
QByteArray buffer; QByteArray buffer;
for (int i=0; i<source.size(); ++i) { for (int i=0; i<source.size(); ++i)
{
char c=source.at(i); char c=source.at(i);
if (inString==false) { if (inString==false)
if (c=='\"') { {
if (c=='\"')
{
inString=true; inString=true;
} }
else if (c==';') { else if (c==';')
{
QByteArray trimmed=buffer.trimmed(); QByteArray trimmed=buffer.trimmed();
if (!trimmed.isEmpty()) { if (!trimmed.isEmpty())
{
list.append(trimmed); list.append(trimmed);
} }
buffer.clear(); buffer.clear();
} }
else { else
{
buffer.append(c); buffer.append(c);
} }
} }
else { else
if (c=='\"') { {
if (c=='\"')
{
inString=false; inString=false;
} }
else { else {
@ -192,7 +253,8 @@ QList<QByteArray> HttpCookie::splitCSV(const QByteArray source) {
} }
} }
QByteArray trimmed=buffer.trimmed(); QByteArray trimmed=buffer.trimmed();
if (!trimmed.isEmpty()) { if (!trimmed.isEmpty())
{
list.append(trimmed); list.append(trimmed);
} }
return list; return list;

19
YACReaderLibrary/server/lib/bfHttpServer/httpcookie.h → YACReaderLibrary/server/lib/httpserver/httpcookie.h
View File

@ -8,6 +8,7 @@
#include <QList> #include <QList>
#include <QByteArray> #include <QByteArray>
#include "httpglobal.h"
/** /**
HTTP cookie as defined in RFC 2109. This class can also parse HTTP cookie as defined in RFC 2109. This class can also parse
@ -15,7 +16,7 @@
2109. 2109.
*/ */
class HttpCookie class DECLSPEC HttpCookie
{ {
public: public:
@ -30,9 +31,10 @@ public:
@param path Path for that the cookie will be sent, default="/" which means the whole domain @param path Path for that the cookie will be sent, default="/" which means the whole domain
@param comment Optional comment, may be displayed by the web browser somewhere @param comment Optional comment, may be displayed by the web browser somewhere
@param domain Optional domain for that the cookie will be sent. Defaults to the current domain @param domain Optional domain for that the cookie will be sent. Defaults to the current domain
@param secure If true, the cookie will only be sent on secure connections @param secure If true, the cookie will be sent by the browser to the server only on secure connections
@param httpOnly If true, the browser does not allow client-side scripts to access the cookie
*/ */
HttpCookie(const QByteArray name, const QByteArray value, const int maxAge, const QByteArray path="/", const QByteArray comment=QByteArray(), const QByteArray domain=QByteArray(), const bool secure=false); HttpCookie(const QByteArray name, const QByteArray value, const int maxAge, const QByteArray path="/", const QByteArray comment=QByteArray(), const QByteArray domain=QByteArray(), const bool secure=false, const bool httpOnly=false);
/** /**
Create a cookie from a string. Create a cookie from a string.
@ -40,7 +42,7 @@ public:
*/ */
HttpCookie(const QByteArray source); HttpCookie(const QByteArray source);
/** Convert this cookie to a string that may be used in a Set-Cookie2 header. */ /** Convert this cookie to a string that may be used in a Set-Cookie header. */
QByteArray toByteArray() const ; QByteArray toByteArray() const ;
/** /**
@ -67,9 +69,12 @@ public:
/** Set the path for that the cookie will be sent, default="/" which means the whole domain */ /** Set the path for that the cookie will be sent, default="/" which means the whole domain */
void setPath(const QByteArray path); void setPath(const QByteArray path);
/** Set secure mode, so that the cokkie will only be sent on secure connections */ /** Set secure mode, so that the cookie will be sent by the browser to the server only on secure connections */
void setSecure(const bool secure); void setSecure(const bool secure);
/** Set secure mode, so that he browser does not allow client-side scripts to access the cookie */
void setHttpOnly(const bool httpOnly);
/** Get the name of this cookie */ /** Get the name of this cookie */
QByteArray getName() const; QByteArray getName() const;
@ -91,6 +96,9 @@ public:
/** Get the secure flag of this cookie */ /** Get the secure flag of this cookie */
bool getSecure() const; bool getSecure() const;
/** Get the httpOnly of this cookie */
bool getHttpOnly() const;
/** Returns always 1 */ /** Returns always 1 */
int getVersion() const; int getVersion() const;
@ -103,6 +111,7 @@ private:
int maxAge; int maxAge;
QByteArray path; QByteArray path;
bool secure; bool secure;
bool httpOnly;
int version; int version;
}; };

7
YACReaderLibrary/server/lib/httpserver/httpglobal.cpp Normal file
View File

@ -0,0 +1,7 @@
#include "httpglobal.h"
const char* getQtWebAppLibVersion()
{
return "1.6.5";
}

27
YACReaderLibrary/server/lib/httpserver/httpglobal.h Normal file
View File

@ -0,0 +1,27 @@
/**
@file
@author Stefan Frings
*/
#ifndef HTTPGLOBAL_H
#define HTTPGLOBAL_H
#include <QtGlobal>
// This is specific to Windows dll's
#if defined(Q_OS_WIN)
#if defined(QTWEBAPPLIB_EXPORT)
#define DECLSPEC Q_DECL_EXPORT
#elif defined(QTWEBAPPLIB_IMPORT)
#define DECLSPEC Q_DECL_IMPORT
#endif
#endif
#if !defined(DECLSPEC)
#define DECLSPEC
#endif
/** Get the library version number */
DECLSPEC const char* getQtWebAppLibVersion();
#endif // HTTPGLOBAL_H

79
YACReaderLibrary/server/lib/bfHttpServer/httplistener.cpp → YACReaderLibrary/server/lib/httpserver/httplistener.cpp
View File

@ -12,53 +12,86 @@ HttpListener::HttpListener(QSettings* settings, HttpRequestHandler* requestHandl
: QTcpServer(parent) : QTcpServer(parent)
{ {
Q_ASSERT(settings!=0); Q_ASSERT(settings!=0);
Q_ASSERT(requestHandler!=0);
pool=NULL;
this->settings=settings;
this->requestHandler=requestHandler;
// Reqister type of socketDescriptor for signal/slot handling // Reqister type of socketDescriptor for signal/slot handling
qRegisterMetaType<tSocketDescriptor>("tSocketDescriptor"); qRegisterMetaType<tSocketDescriptor>("tSocketDescriptor");
// Create connection handler pool
this->settings=settings;
pool=new HttpConnectionHandlerPool(settings,requestHandler);
// Start listening // Start listening
int port=settings->value("port",8080).toInt(); listen();
listen(QHostAddress::Any, port); }
//Cambiado
int i = 0;
while (!isListening() && i < 1000) { HttpListener::~HttpListener()
listen(QHostAddress::Any, (rand() % 45535)+20000); {
i++; close();
qDebug("HttpListener: destroyed");
}
void HttpListener::listen()
{
if (!pool)
{
pool=new HttpConnectionHandlerPool(settings,requestHandler);
}
QString host = settings->value("host").toString();
int port=settings->value("port").toInt();
QTcpServer::listen(host.isEmpty() ? QHostAddress::Any : QHostAddress(host), port);
//YACReader---------------------------------------------
//try to listen even if the default port is no available
int i = 0;
while (!isListening() && i < 1000) {
QTcpServer::listen(QHostAddress::Any, (rand() % 45535)+20000);
i++;
}
//------------------------------------------------------
if (!isListening())
{
qDebug("HttpListener: Cannot bind on port %i: %s",port,qPrintable(errorString()));
} }
if(!isListening())
{
qCritical("HttpListener: Cannot bind on port %i: %s",port,qPrintable(errorString()));
}
else { else {
qDebug("HttpListener: Listening on port %i",port); qDebug("HttpListener: Listening on port %i",port);
} }
} }
HttpListener::~HttpListener() {
close(); void HttpListener::close() {
QTcpServer::close();
qDebug("HttpListener: closed"); qDebug("HttpListener: closed");
delete pool; if (pool) {
qDebug("HttpListener: destroyed"); delete pool;
pool=NULL;
}
} }
void HttpListener::incomingConnection(tSocketDescriptor socketDescriptor) { void HttpListener::incomingConnection(tSocketDescriptor socketDescriptor) {
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpListener: New connection"); qDebug("HttpListener: New connection");
#endif #endif
HttpConnectionHandler* freeHandler=pool->getConnectionHandler();
HttpConnectionHandler* freeHandler=NULL;
if (pool)
{
freeHandler=pool->getConnectionHandler();
}
// Let the handler process the new connection. // Let the handler process the new connection.
if (freeHandler) { if (freeHandler)
{
// The descriptor is passed via signal/slot because the handler lives in another // The descriptor is passed via signal/slot because the handler lives in another
// thread and cannot open the socket when called by another thread. // thread and cannot open the socket when directly called by another thread.
connect(this,SIGNAL(handleConnection(tSocketDescriptor)),freeHandler,SLOT(handleConnection(tSocketDescriptor))); connect(this,SIGNAL(handleConnection(tSocketDescriptor)),freeHandler,SLOT(handleConnection(tSocketDescriptor)));
emit handleConnection(socketDescriptor); emit handleConnection(socketDescriptor);
disconnect(this,SIGNAL(handleConnection(tSocketDescriptor)),freeHandler,SLOT(handleConnection(tSocketDescriptor))); disconnect(this,SIGNAL(handleConnection(tSocketDescriptor)),freeHandler,SLOT(handleConnection(tSocketDescriptor)));
} }
else { else
{
// Reject the connection // Reject the connection
qDebug("HttpListener: Too many connections"); qDebug("HttpListener: Too many incoming connections");
QTcpSocket* socket=new QTcpSocket(this); QTcpSocket* socket=new QTcpSocket(this);
socket->setSocketDescriptor(socketDescriptor); socket->setSocketDescriptor(socketDescriptor);
connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater())); connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater()));

40
YACReaderLibrary/server/lib/bfHttpServer/httplistener.h → YACReaderLibrary/server/lib/httpserver/httplistener.h
View File

@ -3,12 +3,13 @@
@author Stefan Frings @author Stefan Frings
*/ */
#ifndef LISTENER_H #ifndef HTTPLISTENER_H
#define LISTENER_H #define HTTPLISTENER_H
#include <QTcpServer> #include <QTcpServer>
#include <QSettings> #include <QSettings>
#include <QBasicTimer> #include <QBasicTimer>
#include "httpglobal.h"
#include "httpconnectionhandler.h" #include "httpconnectionhandler.h"
#include "httpconnectionhandlerpool.h" #include "httpconnectionhandlerpool.h"
#include "httprequesthandler.h" #include "httprequesthandler.h"
@ -19,36 +20,54 @@
<p> <p>
Example for the required settings in the config file: Example for the required settings in the config file:
<code><pre> <code><pre>
;host=192.168.0.100
port=8080 port=8080
minThreads=1 minThreads=1
maxThreads=10 maxThreads=10
cleanupInterval=1000 cleanupInterval=1000
readTimeout=60000 readTimeout=60000
;sslKeyFile=ssl/my.key
;sslCertFile=ssl/my.cert
maxRequestSize=16000 maxRequestSize=16000
maxMultiPartSize=1000000 maxMultiPartSize=1000000
</pre></code> </pre></code>
The port number is the incoming TCP port that this listener listens to. The optional host parameter binds the listener to one network interface.
@see HttpConnectionHandlerPool for description of config settings minThreads, maxThreads and cleanupInterval The listener handles all network interfaces if no host is configured.
@see HttpConnectionHandler for description of config settings readTimeout The port number specifies the incoming TCP port that this listener listens to.
@see HttpConnectionHandlerPool for description of config settings minThreads, maxThreads, cleanupInterval and ssl settings
@see HttpConnectionHandler for description of the readTimeout
@see HttpRequest for description of config settings maxRequestSize and maxMultiPartSize @see HttpRequest for description of config settings maxRequestSize and maxMultiPartSize
*/ */
class HttpListener : public QTcpServer { class DECLSPEC HttpListener : public QTcpServer {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(HttpListener) Q_DISABLE_COPY(HttpListener)
public: public:
/** /**
Constructor. Constructor.
Creates a connection pool and starts listening on the configured host and port.
@param settings Configuration settings for the HTTP server. Must not be 0. @param settings Configuration settings for the HTTP server. Must not be 0.
@param requestHandler Processes each received HTTP request, usually by dispatching to controller classes. @param requestHandler Processes each received HTTP request, usually by dispatching to controller classes.
@param parent Parent object. @param parent Parent object.
@warning Ensure to close or delete the listener before deleting the request handler.
*/ */
HttpListener(QSettings* settings, HttpRequestHandler* requestHandler, QObject* parent = 0); HttpListener(QSettings* settings, HttpRequestHandler* requestHandler, QObject* parent = NULL);
/** Destructor */ /** Destructor */
virtual ~HttpListener(); virtual ~HttpListener();
/**
Restart listeing after close().
*/
void listen();
/**
Closes the listener, waits until all pending requests are processed,
then closes the connection pool.
*/
void close();
protected: protected:
/** Serves new incoming connection requests */ /** Serves new incoming connection requests */
@ -59,13 +78,16 @@ private:
/** Configuration settings for the HTTP server */ /** Configuration settings for the HTTP server */
QSettings* settings; QSettings* settings;
/** Point to the reuqest handler which processes all HTTP requests */
HttpRequestHandler* requestHandler;
/** Pool of connection handlers */ /** Pool of connection handlers */
HttpConnectionHandlerPool* pool; HttpConnectionHandlerPool* pool;
signals: signals:
/** /**
Emitted when the connection handler shall process a new incoming onnection. Sent to the connection handler to process a new incoming connection.
@param socketDescriptor references the accepted connection. @param socketDescriptor references the accepted connection.
*/ */
@ -73,4 +95,4 @@ signals:
}; };
#endif // LISTENER_H #endif // HTTPLISTENER_H

418
YACReaderLibrary/server/lib/bfHttpServer/httprequest.cpp → YACReaderLibrary/server/lib/httpserver/httprequest.cpp
View File

@ -8,144 +8,189 @@
#include <QDir> #include <QDir>
#include "httpcookie.h" #include "httpcookie.h"
HttpRequest::HttpRequest(QSettings* settings) { HttpRequest::HttpRequest(QSettings* settings)
{
status=waitForRequest; status=waitForRequest;
currentSize=0; currentSize=0;
expectedBodySize=0; expectedBodySize=0;
maxSize=settings->value("maxRequestSize","32000000").toInt(); maxSize=settings->value("maxRequestSize","16000").toInt();
maxMultiPartSize=settings->value("maxMultiPartSize","32000000").toInt(); maxMultiPartSize=settings->value("maxMultiPartSize","1000000").toInt();
} }
void HttpRequest::readRequest(QTcpSocket& socket) { void HttpRequest::readRequest(QTcpSocket* socket)
#ifdef SUPERVERBOSE {
qDebug("HttpRequest: read request"); #ifdef SUPERVERBOSE
#endif qDebug("HttpRequest: read request");
#endif
int toRead=maxSize-currentSize+1; // allow one byte more to be able to detect overflow int toRead=maxSize-currentSize+1; // allow one byte more to be able to detect overflow
QByteArray newData=socket.readLine(toRead).trimmed(); lineBuffer.append(socket->readLine(toRead));
currentSize+=newData.size(); currentSize+=lineBuffer.size();
if (!newData.isEmpty()) { if (!lineBuffer.contains('\r') && !lineBuffer.contains('\n'))
{
#ifdef SUPERVERBOSE
qDebug("HttpRequest: collecting more parts until line break");
#endif
return;
}
QByteArray newData=lineBuffer.trimmed();
lineBuffer.clear();
if (!newData.isEmpty())
{
QList<QByteArray> list=newData.split(' '); QList<QByteArray> list=newData.split(' ');
if (list.count()!=3 || !list.at(2).contains("HTTP")) { if (list.count()!=3 || !list.at(2).contains("HTTP"))
{
qWarning("HttpRequest: received broken HTTP request, invalid first line"); qWarning("HttpRequest: received broken HTTP request, invalid first line");
status=abort; status=abort;
} }
else { else {
method=list.at(0); method=list.at(0).trimmed();
path=list.at(1); path=list.at(1);
version=list.at(2); version=list.at(2);
peerAddress = socket->peerAddress();
status=waitForHeader; status=waitForHeader;
} }
} }
} }
void HttpRequest::readHeader(QTcpSocket& socket) { void HttpRequest::readHeader(QTcpSocket* socket)
#ifdef SUPERVERBOSE {
qDebug("HttpRequest: read header"); #ifdef SUPERVERBOSE
#endif qDebug("HttpRequest: read header");
#endif
int toRead=maxSize-currentSize+1; // allow one byte more to be able to detect overflow int toRead=maxSize-currentSize+1; // allow one byte more to be able to detect overflow
QByteArray newData=socket.readLine(toRead).trimmed(); lineBuffer.append(socket->readLine(toRead));
currentSize+=newData.size(); currentSize+=lineBuffer.size();
if (!lineBuffer.contains('\r') && !lineBuffer.contains('\n'))
{
#ifdef SUPERVERBOSE
qDebug("HttpRequest: collecting more parts until line break");
#endif
return;
}
QByteArray newData=lineBuffer.trimmed();
lineBuffer.clear();
int colon=newData.indexOf(':'); int colon=newData.indexOf(':');
if (colon>0) { if (colon>0)
{
// Received a line with a colon - a header // Received a line with a colon - a header
currentHeader=newData.left(colon); currentHeader=newData.left(colon).toLower();
QByteArray value=newData.mid(colon+1).trimmed(); QByteArray value=newData.mid(colon+1).trimmed();
headers.insert(currentHeader,value); headers.insert(currentHeader,value);
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: received header %s: %s",currentHeader.data(),value.data()); qDebug("HttpRequest: received header %s: %s",currentHeader.data(),value.data());
#endif #endif
} }
else if (!newData.isEmpty()) { else if (!newData.isEmpty())
{
// received another line - belongs to the previous header // received another line - belongs to the previous header
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: read additional line of header"); qDebug("HttpRequest: read additional line of header");
#endif #endif
// Received additional line of previous header // Received additional line of previous header
if (headers.contains(currentHeader)) { if (headers.contains(currentHeader)) {
headers.insert(currentHeader,headers.value(currentHeader)+" "+newData); headers.insert(currentHeader,headers.value(currentHeader)+" "+newData);
} }
} }
else { else
{
// received an empty line - end of headers reached // received an empty line - end of headers reached
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: headers completed"); qDebug("HttpRequest: headers completed");
#endif #endif
// Empty line received, that means all headers have been received // Empty line received, that means all headers have been received
// Check for multipart/form-data // Check for multipart/form-data
QByteArray contentType=headers.value("Content-Type"); QByteArray contentType=headers.value("content-type");
if (contentType.startsWith("multipart/form-data")) { if (contentType.startsWith("multipart/form-data"))
{
int posi=contentType.indexOf("boundary="); int posi=contentType.indexOf("boundary=");
if (posi>=0) { if (posi>=0) {
boundary=contentType.mid(posi+9); boundary=contentType.mid(posi+9);
if (boundary.startsWith('"') && boundary.endsWith('"'))
{
boundary = boundary.mid(1,boundary.length()-2);
}
} }
} }
QByteArray contentLength=getHeader("Content-Length"); QByteArray contentLength=headers.value("content-length");
if (!contentLength.isEmpty()) { if (!contentLength.isEmpty())
{
expectedBodySize=contentLength.toInt(); expectedBodySize=contentLength.toInt();
} }
if (expectedBodySize==0) { if (expectedBodySize==0)
#ifdef SUPERVERBOSE {
qDebug("HttpRequest: expect no body"); #ifdef SUPERVERBOSE
#endif qDebug("HttpRequest: expect no body");
#endif
status=complete; status=complete;
} }
else if (boundary.isEmpty() && expectedBodySize+currentSize>maxSize) { else if (boundary.isEmpty() && expectedBodySize+currentSize>maxSize)
{
qWarning("HttpRequest: expected body is too large"); qWarning("HttpRequest: expected body is too large");
status=abort; status=abort;
} }
else if (!boundary.isEmpty() && expectedBodySize>maxMultiPartSize) { else if (!boundary.isEmpty() && expectedBodySize>maxMultiPartSize)
{
qWarning("HttpRequest: expected multipart body is too large"); qWarning("HttpRequest: expected multipart body is too large");
status=abort; status=abort;
} }
else { else {
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: expect %i bytes body",expectedBodySize); qDebug("HttpRequest: expect %i bytes body",expectedBodySize);
#endif #endif
status=waitForBody; status=waitForBody;
} }
} }
} }
void HttpRequest::readBody(QTcpSocket& socket) { void HttpRequest::readBody(QTcpSocket* socket)
{
Q_ASSERT(expectedBodySize!=0); Q_ASSERT(expectedBodySize!=0);
if (boundary.isEmpty()) { if (boundary.isEmpty())
{
// normal body, no multipart // normal body, no multipart
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: receive body"); qDebug("HttpRequest: receive body");
#endif #endif
int toRead=expectedBodySize-bodyData.size(); int toRead=expectedBodySize-bodyData.size();
QByteArray newData=socket.read(toRead); QByteArray newData=socket->read(toRead);
currentSize+=newData.size(); currentSize+=newData.size();
bodyData.append(newData); bodyData.append(newData);
if (bodyData.size()>=expectedBodySize) { if (bodyData.size()>=expectedBodySize)
{
status=complete; status=complete;
} }
} }
else { else
{
// multipart body, store into temp file // multipart body, store into temp file
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: receiving multipart body"); qDebug("HttpRequest: receiving multipart body");
#endif #endif
if (!tempFile.isOpen()) { if (!tempFile.isOpen())
{
tempFile.open(); tempFile.open();
} }
// Transfer data in 64kb blocks // Transfer data in 64kb blocks
int fileSize=tempFile.size(); int fileSize=tempFile.size();
int toRead=expectedBodySize-fileSize; int toRead=expectedBodySize-fileSize;
if (toRead>65536) { if (toRead>65536)
{
toRead=65536; toRead=65536;
} }
fileSize+=tempFile.write(socket.read(toRead)); fileSize+=tempFile.write(socket->read(toRead));
if (fileSize>=maxMultiPartSize) { if (fileSize>=maxMultiPartSize)
{
qWarning("HttpRequest: received too many multipart bytes"); qWarning("HttpRequest: received too many multipart bytes");
status=abort; status=abort;
} }
else if (fileSize>=expectedBodySize) { else if (fileSize>=expectedBodySize)
#ifdef SUPERVERBOSE {
#ifdef SUPERVERBOSE
qDebug("HttpRequest: received whole multipart body"); qDebug("HttpRequest: received whole multipart body");
#endif #endif
tempFile.flush(); tempFile.flush();
if (tempFile.error()) { if (tempFile.error())
{
qCritical("HttpRequest: Error writing temp file for multipart body"); qCritical("HttpRequest: Error writing temp file for multipart body");
} }
parseMultiPartFile(); parseMultiPartFile();
@ -155,87 +200,106 @@ void HttpRequest::readBody(QTcpSocket& socket) {
} }
} }
void HttpRequest::decodeRequestParams() { void HttpRequest::decodeRequestParams()
#ifdef SUPERVERBOSE {
qDebug("HttpRequest: extract and decode request parameters"); #ifdef SUPERVERBOSE
#endif qDebug("HttpRequest: extract and decode request parameters");
#endif
// Get URL parameters // Get URL parameters
QByteArray rawParameters; QByteArray rawParameters;
int questionMark=path.indexOf('?'); int questionMark=path.indexOf('?');
if (questionMark>=0) { if (questionMark>=0)
{
rawParameters=path.mid(questionMark+1); rawParameters=path.mid(questionMark+1);
path=path.left(questionMark); path=path.left(questionMark);
} }
// Get request body parameters // Get request body parameters
QByteArray contentType=headers.value("Content-Type"); QByteArray contentType=headers.value("content-type");
if (!bodyData.isEmpty() && (contentType.isEmpty() || contentType.startsWith("application/x-www-form-urlencoded"))) { if (!bodyData.isEmpty() && (contentType.isEmpty() || contentType.startsWith("application/x-www-form-urlencoded")))
if (rawParameters.isEmpty()) { {
if (!rawParameters.isEmpty())
{
rawParameters.append('&'); rawParameters.append('&');
rawParameters.append(bodyData); rawParameters.append(bodyData);
} }
else { else
{
rawParameters=bodyData; rawParameters=bodyData;
} }
} }
// Split the parameters into pairs of value and name // Split the parameters into pairs of value and name
QList<QByteArray> list=rawParameters.split('&'); QList<QByteArray> list=rawParameters.split('&');
foreach (QByteArray part, list) { foreach (QByteArray part, list)
{
int equalsChar=part.indexOf('='); int equalsChar=part.indexOf('=');
if (equalsChar>=0) { if (equalsChar>=0)
{
QByteArray name=part.left(equalsChar).trimmed(); QByteArray name=part.left(equalsChar).trimmed();
QByteArray value=part.mid(equalsChar+1).trimmed(); QByteArray value=part.mid(equalsChar+1).trimmed();
parameters.insert(urlDecode(name),urlDecode(value)); parameters.insert(urlDecode(name),urlDecode(value));
} }
else if (!part.isEmpty()){ else if (!part.isEmpty())
{
// Name without value // Name without value
parameters.insert(urlDecode(part),""); parameters.insert(urlDecode(part),"");
} }
} }
} }
void HttpRequest::extractCookies() { void HttpRequest::extractCookies()
#ifdef SUPERVERBOSE {
qDebug("HttpRequest: extract cookies"); #ifdef SUPERVERBOSE
#endif qDebug("HttpRequest: extract cookies");
foreach(QByteArray cookieStr, headers.values("Cookie")) { #endif
foreach(QByteArray cookieStr, headers.values("cookie"))
{
QList<QByteArray> list=HttpCookie::splitCSV(cookieStr); QList<QByteArray> list=HttpCookie::splitCSV(cookieStr);
foreach(QByteArray part, list) { foreach(QByteArray part, list)
#ifdef SUPERVERBOSE {
qDebug("HttpRequest: found cookie %s",part.data()); #ifdef SUPERVERBOSE
#endif // Split the part into name and value qDebug("HttpRequest: found cookie %s",part.data());
#endif // Split the part into name and value
QByteArray name; QByteArray name;
QByteArray value; QByteArray value;
int posi=part.indexOf('='); int posi=part.indexOf('=');
if (posi) { if (posi)
{
name=part.left(posi).trimmed(); name=part.left(posi).trimmed();
value=part.mid(posi+1).trimmed(); value=part.mid(posi+1).trimmed();
} }
else { else
{
name=part.trimmed(); name=part.trimmed();
value=""; value="";
} }
cookies.insert(name,value); cookies.insert(name,value);
} }
} }
headers.remove("Cookie"); headers.remove("cookie");
} }
void HttpRequest::readFromSocket(QTcpSocket& socket) { void HttpRequest::readFromSocket(QTcpSocket* socket)
{
Q_ASSERT(status!=complete); Q_ASSERT(status!=complete);
if (status==waitForRequest) { if (status==waitForRequest)
{
readRequest(socket); readRequest(socket);
} }
else if (status==waitForHeader) { else if (status==waitForHeader)
{
readHeader(socket); readHeader(socket);
} }
else if (status==waitForBody) { else if (status==waitForBody)
{
readBody(socket); readBody(socket);
} }
if (currentSize>maxSize) { if ((boundary.isEmpty() && currentSize>maxSize) || (!boundary.isEmpty() && currentSize>maxMultiPartSize))
{
qWarning("HttpRequest: received too many bytes"); qWarning("HttpRequest: received too many bytes");
status=abort; status=abort;
} }
if (status==complete) { if (status==complete)
{
// Extract and decode request parameters from url and body // Extract and decode request parameters from url and body
decodeRequestParams(); decodeRequestParams();
// Extract cookies from headers // Extract cookies from headers
@ -244,62 +308,82 @@ void HttpRequest::readFromSocket(QTcpSocket& socket) {
} }
HttpRequest::RequestStatus HttpRequest::getStatus() const { HttpRequest::RequestStatus HttpRequest::getStatus() const
{
return status; return status;
} }
QByteArray HttpRequest::getMethod() const { QByteArray HttpRequest::getMethod() const
{
return method; return method;
} }
QByteArray HttpRequest::getPath() const { QByteArray HttpRequest::getPath() const
{
return urlDecode(path); return urlDecode(path);
} }
QByteArray HttpRequest::getVersion() const { const QByteArray& HttpRequest::getRawPath() const
{
return path;
}
QByteArray HttpRequest::getVersion() const
{
return version; return version;
} }
QByteArray HttpRequest::getHeader(const QByteArray& name) const { QByteArray HttpRequest::getHeader(const QByteArray& name) const
return headers.value(name); {
return headers.value(name.toLower());
} }
QList<QByteArray> HttpRequest::getHeaders(const QByteArray& name) const { QList<QByteArray> HttpRequest::getHeaders(const QByteArray& name) const
return headers.values(name); {
return headers.values(name.toLower());
} }
QMultiMap<QByteArray,QByteArray> HttpRequest::getHeaderMap() const { QMultiMap<QByteArray,QByteArray> HttpRequest::getHeaderMap() const
{
return headers; return headers;
} }
QByteArray HttpRequest::getParameter(const QByteArray& name) const { QByteArray HttpRequest::getParameter(const QByteArray& name) const
{
return parameters.value(name); return parameters.value(name);
} }
QList<QByteArray> HttpRequest::getParameters(const QByteArray& name) const { QList<QByteArray> HttpRequest::getParameters(const QByteArray& name) const
{
return parameters.values(name); return parameters.values(name);
} }
QMultiMap<QByteArray,QByteArray> HttpRequest::getParameterMap() const { QMultiMap<QByteArray,QByteArray> HttpRequest::getParameterMap() const
{
return parameters; return parameters;
} }
QByteArray HttpRequest::getBody() const { QByteArray HttpRequest::getBody() const
{
return bodyData; return bodyData;
} }
QByteArray HttpRequest::urlDecode(const QByteArray source) { QByteArray HttpRequest::urlDecode(const QByteArray source)
{
QByteArray buffer(source); QByteArray buffer(source);
buffer.replace('+',' '); buffer.replace('+',' ');
int percentChar=buffer.indexOf('%'); int percentChar=buffer.indexOf('%');
while (percentChar>=0) { while (percentChar>=0)
{
bool ok; bool ok;
char byte=buffer.mid(percentChar+1,2).toInt(&ok,16); char byte=buffer.mid(percentChar+1,2).toInt(&ok,16);
if (ok) { if (ok)
{
buffer.replace(percentChar,3,(char*)&byte,1); buffer.replace(percentChar,3,(char*)&byte,1);
} }
percentChar=buffer.indexOf('%',percentChar+1); percentChar=buffer.indexOf('%',percentChar+1);
@ -308,65 +392,77 @@ QByteArray HttpRequest::urlDecode(const QByteArray source) {
} }
void HttpRequest::parseMultiPartFile() { void HttpRequest::parseMultiPartFile()
{
qDebug("HttpRequest: parsing multipart temp file"); qDebug("HttpRequest: parsing multipart temp file");
tempFile.seek(0); tempFile.seek(0);
bool finished=false; bool finished=false;
while (!tempFile.atEnd() && !finished && !tempFile.error()) { while (!tempFile.atEnd() && !finished && !tempFile.error())
{
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: reading multpart headers"); qDebug("HttpRequest: reading multpart headers");
#endif #endif
QByteArray fieldName; QByteArray fieldName;
QByteArray fileName; QByteArray fileName;
while (!tempFile.atEnd() && !finished && !tempFile.error()) { while (!tempFile.atEnd() && !finished && !tempFile.error())
{
QByteArray line=tempFile.readLine(65536).trimmed(); QByteArray line=tempFile.readLine(65536).trimmed();
if (line.startsWith("Content-Disposition:")) { if (line.startsWith("Content-Disposition:"))
if (line.contains("form-data")) { {
if (line.contains("form-data"))
{
int start=line.indexOf(" name=\""); int start=line.indexOf(" name=\"");
int end=line.indexOf("\"",start+7); int end=line.indexOf("\"",start+7);
if (start>=0 && end>=start) { if (start>=0 && end>=start)
{
fieldName=line.mid(start+7,end-start-7); fieldName=line.mid(start+7,end-start-7);
} }
start=line.indexOf(" filename=\""); start=line.indexOf(" filename=\"");
end=line.indexOf("\"",start+11); end=line.indexOf("\"",start+11);
if (start>=0 && end>=start) { if (start>=0 && end>=start)
{
fileName=line.mid(start+11,end-start-11); fileName=line.mid(start+11,end-start-11);
} }
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: multipart field=%s, filename=%s",fieldName.data(),fileName.data()); qDebug("HttpRequest: multipart field=%s, filename=%s",fieldName.data(),fileName.data());
#endif #endif
} }
else { else
{
qDebug("HttpRequest: ignoring unsupported content part %s",line.data()); qDebug("HttpRequest: ignoring unsupported content part %s",line.data());
} }
} }
else if (line.isEmpty()) { else if (line.isEmpty())
{
break; break;
} }
} }
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: reading multpart data"); qDebug("HttpRequest: reading multpart data");
#endif #endif
QTemporaryFile* uploadedFile=0; QTemporaryFile* uploadedFile=0;
QByteArray fieldValue; QByteArray fieldValue;
while (!tempFile.atEnd() && !finished && !tempFile.error()) { while (!tempFile.atEnd() && !finished && !tempFile.error())
{
QByteArray line=tempFile.readLine(65536); QByteArray line=tempFile.readLine(65536);
if (line.startsWith("--"+boundary)) { if (line.startsWith("--"+boundary))
{
// Boundary found. Until now we have collected 2 bytes too much, // Boundary found. Until now we have collected 2 bytes too much,
// so remove them from the last result // so remove them from the last result
if (fileName.isEmpty() && !fieldName.isEmpty()) { if (fileName.isEmpty() && !fieldName.isEmpty())
{
// last field was a form field // last field was a form field
fieldValue.remove(fieldValue.size()-2,2); fieldValue.remove(fieldValue.size()-2,2);
parameters.insert(fieldName,fieldValue); parameters.insert(fieldName,fieldValue);
qDebug("HttpRequest: set parameter %s=%s",fieldName.data(),fieldValue.data()); qDebug("HttpRequest: set parameter %s=%s",fieldName.data(),fieldValue.data());
} }
else if (!fileName.isEmpty() && !fieldName.isEmpty()) { else if (!fileName.isEmpty() && !fieldName.isEmpty())
{
// last field was a file // last field was a file
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: finishing writing to uploaded file"); qDebug("HttpRequest: finishing writing to uploaded file");
#endif #endif
uploadedFile->resize(uploadedFile->size()-2); uploadedFile->resize(uploadedFile->size()-2);
uploadedFile->flush(); uploadedFile->flush();
uploadedFile->seek(0); uploadedFile->seek(0);
@ -375,57 +471,79 @@ void HttpRequest::parseMultiPartFile() {
uploadedFiles.insert(fieldName,uploadedFile); uploadedFiles.insert(fieldName,uploadedFile);
qDebug("HttpRequest: uploaded file size is %i",(int) uploadedFile->size()); qDebug("HttpRequest: uploaded file size is %i",(int) uploadedFile->size());
} }
if (line.contains(boundary+"--")) { if (line.contains(boundary+"--"))
{
finished=true; finished=true;
} }
break; break;
} }
else { else
if (fileName.isEmpty() && !fieldName.isEmpty()) { {
if (fileName.isEmpty() && !fieldName.isEmpty())
{
// this is a form field. // this is a form field.
currentSize+=line.size(); currentSize+=line.size();
fieldValue.append(line); fieldValue.append(line);
} }
else if (!fileName.isEmpty() && !fieldName.isEmpty()) { else if (!fileName.isEmpty() && !fieldName.isEmpty())
{
// this is a file // this is a file
if (!uploadedFile) { if (!uploadedFile)
{
uploadedFile=new QTemporaryFile(); uploadedFile=new QTemporaryFile();
uploadedFile->open(); uploadedFile->open();
} }
uploadedFile->write(line); uploadedFile->write(line);
if (uploadedFile->error()) { if (uploadedFile->error())
{
qCritical("HttpRequest: error writing temp file, %s",qPrintable(uploadedFile->errorString())); qCritical("HttpRequest: error writing temp file, %s",qPrintable(uploadedFile->errorString()));
} }
} }
} }
} }
} }
if (tempFile.error()) { if (tempFile.error())
{
qCritical("HttpRequest: cannot read temp file, %s",qPrintable(tempFile.errorString())); qCritical("HttpRequest: cannot read temp file, %s",qPrintable(tempFile.errorString()));
} }
#ifdef SUPERVERBOSE #ifdef SUPERVERBOSE
qDebug("HttpRequest: finished parsing multipart temp file"); qDebug("HttpRequest: finished parsing multipart temp file");
#endif #endif
} }
HttpRequest::~HttpRequest() { HttpRequest::~HttpRequest()
foreach(QByteArray key, uploadedFiles.keys()) { {
foreach(QByteArray key, uploadedFiles.keys())
{
QTemporaryFile* file=uploadedFiles.value(key); QTemporaryFile* file=uploadedFiles.value(key);
file->close(); file->close();
delete file; delete file;
} }
} }
QTemporaryFile* HttpRequest::getUploadedFile(const QByteArray fieldName) { QTemporaryFile* HttpRequest::getUploadedFile(const QByteArray fieldName) const
{
return uploadedFiles.value(fieldName); return uploadedFiles.value(fieldName);
} }
QByteArray HttpRequest::getCookie(const QByteArray& name) const { QByteArray HttpRequest::getCookie(const QByteArray& name) const
{
return cookies.value(name); return cookies.value(name);
} }
/** Get the map of cookies */ /** Get the map of cookies */
QMap<QByteArray,QByteArray>& HttpRequest::getCookieMap() { QMap<QByteArray,QByteArray>& HttpRequest::getCookieMap()
{
return cookies; return cookies;
} }
/**
Get the address of the connected client.
Note that multiple clients may have the same IP address, if they
share an internet connection (which is very common).
*/
QHostAddress HttpRequest::getPeerAddress() const
{
return peerAddress;
}

57
YACReaderLibrary/server/lib/bfHttpServer/httprequest.h → YACReaderLibrary/server/lib/httpserver/httprequest.h
View File

@ -7,12 +7,14 @@
#define HTTPREQUEST_H #define HTTPREQUEST_H
#include <QByteArray> #include <QByteArray>
#include <QHostAddress>
#include <QTcpSocket> #include <QTcpSocket>
#include <QMap> #include <QMap>
#include <QMultiMap> #include <QMultiMap>
#include <QSettings> #include <QSettings>
#include <QTemporaryFile> #include <QTemporaryFile>
#include <QUuid> #include <QUuid>
#include "httpglobal.h"
/** /**
This object represents a single HTTP request. It reads the request This object represents a single HTTP request. It reads the request
@ -31,9 +33,10 @@
The body is always a little larger than the file itself. The body is always a little larger than the file itself.
*/ */
class HttpRequest { class DECLSPEC HttpRequest {
Q_DISABLE_COPY(HttpRequest) Q_DISABLE_COPY(HttpRequest)
friend class HttpSessionStore; friend class HttpSessionStore;
public: public:
/** Values for getStatus() */ /** Values for getStatus() */
@ -51,11 +54,12 @@ public:
virtual ~HttpRequest(); virtual ~HttpRequest();
/** /**
Read the request from a socket. This method must be called repeatedly Read the HTTP request from a socket.
This method is called by the connection handler repeatedly
until the status is RequestStatus::complete or RequestStatus::abort. until the status is RequestStatus::complete or RequestStatus::abort.
@param socket Source of the data @param socket Source of the data
*/ */
void readFromSocket(QTcpSocket& socket); void readFromSocket(QTcpSocket* socket);
/** /**
Get the status of this reqeust. Get the status of this reqeust.
@ -69,12 +73,15 @@ public:
/** Get the decoded path of the HTPP request (e.g. "/index.html") */ /** Get the decoded path of the HTPP request (e.g. "/index.html") */
QByteArray getPath() const; QByteArray getPath() const;
/** Get the raw path of the HTTP request (e.g. "/file%20with%20spaces.html") */
const QByteArray& getRawPath() const;
/** Get the version of the HTPP request (e.g. "HTTP/1.1") */ /** Get the version of the HTPP request (e.g. "HTTP/1.1") */
QByteArray getVersion() const; QByteArray getVersion() const;
/** /**
Get the value of a HTTP request header. Get the value of a HTTP request header.
@param name Name of the header @param name Name of the header, not case-senitive.
@return If the header occurs multiple times, only the last @return If the header occurs multiple times, only the last
one is returned. one is returned.
*/ */
@ -82,16 +89,19 @@ public:
/** /**
Get the values of a HTTP request header. Get the values of a HTTP request header.
@param name Name of the header @param name Name of the header, not case-senitive.
*/ */
QList<QByteArray> getHeaders(const QByteArray& name) const; QList<QByteArray> getHeaders(const QByteArray& name) const;
/** Get all HTTP request headers */ /**
* Get all HTTP request headers. Note that the header names
* are returned in lower-case.
*/
QMultiMap<QByteArray,QByteArray> getHeaderMap() const; QMultiMap<QByteArray,QByteArray> getHeaderMap() const;
/** /**
Get the value of a HTTP request parameter. Get the value of a HTTP request parameter.
@param name Name of the parameter @param name Name of the parameter, case-sensitive.
@return If the parameter occurs multiple times, only the last @return If the parameter occurs multiple times, only the last
one is returned. one is returned.
*/ */
@ -99,14 +109,14 @@ public:
/** /**
Get the values of a HTTP request parameter. Get the values of a HTTP request parameter.
@param name Name of the parameter @param name Name of the parameter, case-sensitive.
*/ */
QList<QByteArray> getParameters(const QByteArray& name) const; QList<QByteArray> getParameters(const QByteArray& name) const;
/** Get all HTTP request parameters */ /** Get all HTTP request parameters. */
QMultiMap<QByteArray,QByteArray> getParameterMap() const; QMultiMap<QByteArray,QByteArray> getParameterMap() const;
/** Get the HTTP request body */ /** Get the HTTP request body. */
QByteArray getBody() const; QByteArray getBody() const;
/** /**
@ -125,17 +135,24 @@ public:
For uploaded files, the method getParameters() returns For uploaded files, the method getParameters() returns
the original fileName as provided by the calling web browser. the original fileName as provided by the calling web browser.
*/ */
QTemporaryFile* getUploadedFile(const QByteArray fieldName); QTemporaryFile* getUploadedFile(const QByteArray fieldName) const;
/** /**
Get the value of a cookie Get the value of a cookie.
@param name Name of the cookie @param name Name of the cookie
*/ */
QByteArray getCookie(const QByteArray& name) const; QByteArray getCookie(const QByteArray& name) const;
/** Get the map of cookies */ /** Get all cookies. */
QMap<QByteArray,QByteArray>& getCookieMap(); QMap<QByteArray,QByteArray>& getCookieMap();
/**
Get the address of the connected client.
Note that multiple clients may have the same IP address, if they
share an internet connection (which is very common).
*/
QHostAddress getPeerAddress() const;
private: private:
/** Request headers */ /** Request headers */
@ -163,11 +180,14 @@ private:
QByteArray version; QByteArray version;
/** /**
Status of this request. Status of this request. For the state engine.
@see RequestStatus @see RequestStatus
*/ */
RequestStatus status; RequestStatus status;
/** Address of the connected peer. */
QHostAddress peerAddress;
/** Maximum size of requests in bytes. */ /** Maximum size of requests in bytes. */
int maxSize; int maxSize;
@ -193,13 +213,13 @@ private:
void parseMultiPartFile(); void parseMultiPartFile();
/** Sub-procedure of readFromSocket(), read the first line of a request. */ /** Sub-procedure of readFromSocket(), read the first line of a request. */
void readRequest(QTcpSocket& socket); void readRequest(QTcpSocket* socket);
/** Sub-procedure of readFromSocket(), read header lines. */ /** Sub-procedure of readFromSocket(), read header lines. */
void readHeader(QTcpSocket& socket); void readHeader(QTcpSocket* socket);
/** Sub-procedure of readFromSocket(), read the request body. */ /** Sub-procedure of readFromSocket(), read the request body. */
void readBody(QTcpSocket& socket); void readBody(QTcpSocket* socket);
/** Sub-procedure of readFromSocket(), extract and decode request parameters. */ /** Sub-procedure of readFromSocket(), extract and decode request parameters. */
void decodeRequestParams(); void decodeRequestParams();
@ -207,6 +227,9 @@ private:
/** Sub-procedure of readFromSocket(), extract cookies from headers */ /** Sub-procedure of readFromSocket(), extract cookies from headers */
void extractCookies(); void extractCookies();
/** Buffer for collecting characters of request and header lines */
QByteArray lineBuffer;
}; };
#endif // HTTPREQUEST_H #endif // HTTPREQUEST_H

8
YACReaderLibrary/server/lib/bfHttpServer/httprequesthandler.cpp → YACReaderLibrary/server/lib/httpserver/httprequesthandler.cpp
View File

@ -9,10 +9,12 @@ HttpRequestHandler::HttpRequestHandler(QObject* parent)
: QObject(parent) : QObject(parent)
{} {}
HttpRequestHandler::~HttpRequestHandler() {} HttpRequestHandler::~HttpRequestHandler()
{}
void HttpRequestHandler::service(HttpRequest& request, HttpResponse& response) { void HttpRequestHandler::service(HttpRequest& request, HttpResponse& response)
qCritical("HttpRequestHandler: you need to override the dispatch() function"); {
qCritical("HttpRequestHandler: you need to override the service() function");
qDebug("HttpRequestHandler: request=%s %s %s",request.getMethod().data(),request.getPath().data(),request.getVersion().data()); qDebug("HttpRequestHandler: request=%s %s %s",request.getMethod().data(),request.getPath().data(),request.getVersion().data());
response.setStatus(501,"not implemented"); response.setStatus(501,"not implemented");
response.write("501 not implemented",true); response.write("501 not implemented",true);

10
YACReaderLibrary/server/lib/bfHttpServer/httprequesthandler.h → YACReaderLibrary/server/lib/httpserver/httprequesthandler.h
View File

@ -6,6 +6,7 @@
#ifndef HTTPREQUESTHANDLER_H #ifndef HTTPREQUESTHANDLER_H
#define HTTPREQUESTHANDLER_H #define HTTPREQUESTHANDLER_H
#include "httpglobal.h"
#include "httprequest.h" #include "httprequest.h"
#include "httpresponse.h" #include "httpresponse.h"
@ -21,13 +22,16 @@
@see StaticFileController which delivers static local files. @see StaticFileController which delivers static local files.
*/ */
class HttpRequestHandler : public QObject { class DECLSPEC HttpRequestHandler : public QObject {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(HttpRequestHandler) Q_DISABLE_COPY(HttpRequestHandler)
public: public:
/** Constructor */ /**
HttpRequestHandler(QObject* parent=0); * Constructor.
* @param parent Parent object.
*/
HttpRequestHandler(QObject* parent=NULL);
/** Destructor */ /** Destructor */
virtual ~HttpRequestHandler(); virtual ~HttpRequestHandler();

198
YACReaderLibrary/server/lib/httpserver/httpresponse.cpp Normal file
View File

@ -0,0 +1,198 @@
/**
@file
@author Stefan Frings
*/
#include "httpresponse.h"
HttpResponse::HttpResponse(QTcpSocket* socket)
{
this->socket=socket;
statusCode=200;
statusText="OK";
sentHeaders=false;
sentLastPart=false;
chunkedMode=false;
}
void HttpResponse::setHeader(QByteArray name, QByteArray value)
{
Q_ASSERT(sentHeaders==false);
headers.insert(name,value);
}
void HttpResponse::setHeader(QByteArray name, int value)
{
Q_ASSERT(sentHeaders==false);
headers.insert(name,QByteArray::number(value));
}
QMap<QByteArray,QByteArray>& HttpResponse::getHeaders()
{
return headers;
}
void HttpResponse::setStatus(int statusCode, QByteArray description)
{
this->statusCode=statusCode;
statusText=description;
}
int HttpResponse::getStatusCode() const
{
return this->statusCode;
}
void HttpResponse::writeHeaders()
{
Q_ASSERT(sentHeaders==false);
QByteArray buffer;
buffer.append("HTTP/1.1 ");
buffer.append(QByteArray::number(statusCode));
buffer.append(' ');
buffer.append(statusText);
buffer.append("\r\n");
foreach(QByteArray name, headers.keys())
{
buffer.append(name);
buffer.append(": ");
buffer.append(headers.value(name));
buffer.append("\r\n");
}
foreach(HttpCookie cookie,cookies.values())
{
buffer.append("Set-Cookie: ");
buffer.append(cookie.toByteArray());
buffer.append("\r\n");
}
buffer.append("\r\n");
writeToSocket(buffer);
sentHeaders=true;
}
bool HttpResponse::writeToSocket(QByteArray data)
{
int remaining=data.size();
char* ptr=data.data();
while (socket->isOpen() && remaining>0)
{
// If the output buffer has become large, then wait until it has been sent.
if (socket->bytesToWrite()>16384)
{
socket->waitForBytesWritten(-1);
}
int written=socket->write(ptr,remaining);
if (written==-1)
{
return false;
}
ptr+=written;
remaining-=written;
}
return true;
}
void HttpResponse::write(QByteArray data, bool lastPart)
{
Q_ASSERT(sentLastPart==false);
// Send HTTP headers, if not already done (that happens only on the first call to write())
if (sentHeaders==false)
{
// If the whole response is generated with a single call to write(), then we know the total
// size of the response and therefore can set the Content-Length header automatically.
if (lastPart)
{
// Automatically set the Content-Length header
headers.insert("Content-Length",QByteArray::number(data.size()));
}
// else if we will not close the connection at the end, them we must use the chunked mode.
else
{
QByteArray connectionValue=headers.value("Connection",headers.value("connection"));
bool connectionClose=QString::compare(connectionValue,"close",Qt::CaseInsensitive)==0;
if (!connectionClose)
{
headers.insert("Transfer-Encoding","chunked");
chunkedMode=true;
}
}
writeHeaders();
}
// Send data
if (data.size()>0)
{
if (chunkedMode)
{
if (data.size()>0)
{
QByteArray size=QByteArray::number(data.size(),16);
writeToSocket(size);
writeToSocket("\r\n");
writeToSocket(data);
writeToSocket("\r\n");
}
}
else
{
writeToSocket(data);
}
}
// Only for the last chunk, send the terminating marker and flush the buffer.
if (lastPart)
{
if (chunkedMode)
{
writeToSocket("0\r\n\r\n");
}
socket->flush();
sentLastPart=true;
}
}
bool HttpResponse::hasSentLastPart() const
{
return sentLastPart;
}
void HttpResponse::setCookie(const HttpCookie& cookie)
{
Q_ASSERT(sentHeaders==false);
if (!cookie.getName().isEmpty())
{
cookies.insert(cookie.getName(),cookie);
}
}
QMap<QByteArray,HttpCookie>& HttpResponse::getCookies()
{
return cookies;
}
void HttpResponse::redirect(const QByteArray& url)
{
setStatus(303,"See Other");
setHeader("Location",url);
write("Redirect",true);
}
void HttpResponse::flush()
{
socket->flush();
}
bool HttpResponse::isConnected() const
{
return socket->isOpen();
}

159
YACReaderLibrary/server/lib/httpserver/httpresponse.h Normal file
View File

@ -0,0 +1,159 @@
/**
@file
@author Stefan Frings
*/
#ifndef HTTPRESPONSE_H
#define HTTPRESPONSE_H
#include <QMap>
#include <QString>
#include <QTcpSocket>
#include "httpglobal.h"
#include "httpcookie.h"
/**
This object represents a HTTP response, used to return something to the web client.
<p>
<code><pre>
response.setStatus(200,"OK"); // optional, because this is the default
response.writeBody("Hello");
response.writeBody("World!",true);
</pre></code>
<p>
Example how to return an error:
<code><pre>
response.setStatus(500,"server error");
response.write("The request cannot be processed because the servers is broken",true);
</pre></code>
<p>
In case of large responses (e.g. file downloads), a Content-Length header should be set
before calling write(). Web Browsers use that information to display a progress bar.
*/
class DECLSPEC HttpResponse {
Q_DISABLE_COPY(HttpResponse)
public:
/**
Constructor.
@param socket used to write the response
*/
HttpResponse(QTcpSocket* socket);
/**
Set a HTTP response header.
You must call this method before the first write().
@param name name of the header
@param value value of the header
*/
void setHeader(QByteArray name, QByteArray value);
/**
Set a HTTP response header.
You must call this method before the first write().
@param name name of the header
@param value value of the header
*/
void setHeader(QByteArray name, int value);
/** Get the map of HTTP response headers */
QMap<QByteArray,QByteArray>& getHeaders();
/** Get the map of cookies */
QMap<QByteArray,HttpCookie>& getCookies();
/**
Set status code and description. The default is 200,OK.
You must call this method before the first write().
*/
void setStatus(int statusCode, QByteArray description=QByteArray());
/** Return the status code. */
int getStatusCode() const;
/**
Write body data to the socket.
<p>
The HTTP status line, headers and cookies are sent automatically before the body.
<p>
If the response contains only a single chunk (indicated by lastPart=true),
then a Content-Length header is automatically set.
<p>
Chunked mode is automatically selected if there is no Content-Length header
and also no Connection:close header.
@param data Data bytes of the body
@param lastPart Indicates that this is the last chunk of data and flushes the output buffer.
*/
void write(QByteArray data, bool lastPart=false);
/**
Indicates whether the body has been sent completely (write() has been called with lastPart=true).
*/
bool hasSentLastPart() const;
/**
Set a cookie.
You must call this method before the first write().
*/
void setCookie(const HttpCookie& cookie);
/**
Send a redirect response to the browser.
Cannot be combined with write().
@param url Destination URL
*/
void redirect(const QByteArray& url);
/**
* Flush the output buffer (of the underlying socket).
* You normally don't need to call this method because flush is
* automatically called after HttpRequestHandler::service() returns.
*/
void flush();
/**
* May be used to check whether the connection to the web client has been lost.
* This might be useful to cancel the generation of large or slow responses.
*/
bool isConnected() const;
private:
/** Request headers */
QMap<QByteArray,QByteArray> headers;
/** Socket for writing output */
QTcpSocket* socket;
/** HTTP status code*/
int statusCode;
/** HTTP status code description */
QByteArray statusText;
/** Indicator whether headers have been sent */
bool sentHeaders;
/** Indicator whether the body has been sent completely */
bool sentLastPart;
/** Whether the response is sent in chunked mode */
bool chunkedMode;
/** Cookies */
QMap<QByteArray,HttpCookie> cookies;
/** Write raw data to the socket. This method blocks until all bytes have been passed to the TCP buffer */
bool writeToSocket(QByteArray data);
/**
Write the response HTTP status and headers to the socket.
Calling this method is optional, because writeBody() calls
it automatically when required.
*/
void writeHeaders();
};
#endif // HTTPRESPONSE_H

33
YACReaderLibrary/server/lib/httpserver/httpserver.pri Normal file
View File

@ -0,0 +1,33 @@
INCLUDEPATH += $$PWD
DEPENDPATH += $$PWD
QT += network
# Enable very detailed debug messages when compiling the debug version
CONFIG(debug, debug|release) {
DEFINES += SUPERVERBOSE
}
HEADERS += $$PWD/httpglobal.h \
$$PWD/httplistener.h \
$$PWD/httpconnectionhandler.h \
$$PWD/httpconnectionhandlerpool.h \
$$PWD/httprequest.h \
$$PWD/httpresponse.h \
$$PWD/httpcookie.h \
$$PWD/httprequesthandler.h \
$$PWD/httpsession.h \
$$PWD/httpsessionstore.h \
$$PWD/staticfilecontroller.h
SOURCES += $$PWD/httpglobal.cpp \
$$PWD/httplistener.cpp \
$$PWD/httpconnectionhandler.cpp \
$$PWD/httpconnectionhandlerpool.cpp \
$$PWD/httprequest.cpp \
$$PWD/httpresponse.cpp \
$$PWD/httpcookie.cpp \
$$PWD/httprequesthandler.cpp \
$$PWD/httpsession.cpp \
$$PWD/httpsessionstore.cpp \
$$PWD/staticfilecontroller.cpp

186
YACReaderLibrary/server/lib/httpserver/httpsession.cpp Normal file
View File

@ -0,0 +1,186 @@
/**
@file
@author Stefan Frings
*/
#include "httpsession.h"
#include <QDateTime>
#include <QUuid>
HttpSession::HttpSession(bool canStore)
{
if (canStore)
{
dataPtr=new HttpSessionData();
dataPtr->refCount=1;
dataPtr->lastAccess=QDateTime::currentMSecsSinceEpoch();
dataPtr->id=QUuid::createUuid().toString().toLocal8Bit();
#ifdef SUPERVERBOSE
qDebug("HttpSession: created new session data with id %s",dataPtr->id.data());
#endif
}
else
{
dataPtr=0;
}
}
HttpSession::HttpSession(const HttpSession& other)
{
dataPtr=other.dataPtr;
if (dataPtr)
{
dataPtr->lock.lockForWrite();
dataPtr->refCount++;
#ifdef SUPERVERBOSE
qDebug("HttpSession: refCount of %s is %i",dataPtr->id.data(),dataPtr->refCount);
#endif
dataPtr->lock.unlock();
}
}
HttpSession& HttpSession::operator= (const HttpSession& other)
{
HttpSessionData* oldPtr=dataPtr;
dataPtr=other.dataPtr;
if (dataPtr)
{
dataPtr->lock.lockForWrite();
dataPtr->refCount++;
#ifdef SUPERVERBOSE
qDebug("HttpSession: refCount of %s is %i",dataPtr->id.data(),dataPtr->refCount);
#endif
dataPtr->lastAccess=QDateTime::currentMSecsSinceEpoch();
dataPtr->lock.unlock();
}
if (oldPtr)
{
int refCount;
oldPtr->lock.lockForRead();
refCount=oldPtr->refCount--;
#ifdef SUPERVERBOSE
qDebug("HttpSession: refCount of %s is %i",oldPtr->id.data(),oldPtr->refCount);
#endif
oldPtr->lock.unlock();
if (refCount==0)
{
delete oldPtr;
}
}
return *this;
}
HttpSession::~HttpSession()
{
if (dataPtr) {
int refCount;
dataPtr->lock.lockForRead();
refCount=--dataPtr->refCount;
#ifdef SUPERVERBOSE
qDebug("HttpSession: refCount of %s is %i",dataPtr->id.data(),dataPtr->refCount);
#endif
dataPtr->lock.unlock();
if (refCount==0)
{
qDebug("HttpSession: deleting data");
delete dataPtr;
}
}
}
QByteArray HttpSession::getId() const
{
if (dataPtr)
{
return dataPtr->id;
}
else
{
return QByteArray();
}
}
bool HttpSession::isNull() const {
return dataPtr==0;
}
void HttpSession::set(const QByteArray& key, const QVariant& value)
{
if (dataPtr)
{
dataPtr->lock.lockForWrite();
dataPtr->values.insert(key,value);
dataPtr->lock.unlock();
}
}
void HttpSession::remove(const QByteArray& key)
{
if (dataPtr)
{
dataPtr->lock.lockForWrite();
dataPtr->values.remove(key);
dataPtr->lock.unlock();
}
}
QVariant HttpSession::get(const QByteArray& key) const
{
QVariant value;
if (dataPtr)
{
dataPtr->lock.lockForRead();
value=dataPtr->values.value(key);
dataPtr->lock.unlock();
}
return value;
}
bool HttpSession::contains(const QByteArray& key) const
{
bool found=false;
if (dataPtr)
{
dataPtr->lock.lockForRead();
found=dataPtr->values.contains(key);
dataPtr->lock.unlock();
}
return found;
}
QMap<QByteArray,QVariant> HttpSession::getAll() const
{
QMap<QByteArray,QVariant> values;
if (dataPtr)
{
dataPtr->lock.lockForRead();
values=dataPtr->values;
dataPtr->lock.unlock();
}
return values;
}
qint64 HttpSession::getLastAccess() const
{
qint64 value=0;
if (dataPtr)
{
dataPtr->lock.lockForRead();
value=dataPtr->lastAccess;
dataPtr->lock.unlock();
}
return value;
}
void HttpSession::setLastAccess()
{
if (dataPtr)
{
dataPtr->lock.lockForRead();
dataPtr->lastAccess=QDateTime::currentMSecsSinceEpoch();
dataPtr->lock.unlock();
}
}

118
YACReaderLibrary/server/lib/httpserver/httpsession.h Normal file
View File

@ -0,0 +1,118 @@
/**
@file
@author Stefan Frings
*/
#ifndef HTTPSESSION_H
#define HTTPSESSION_H
#include <QByteArray>
#include <QVariant>
#include <QReadWriteLock>
#include "httpglobal.h"
/**
This class stores data for a single HTTP session.
A session can store any number of key/value pairs. This class uses implicit
sharing for read and write access. This class is thread safe.
@see HttpSessionStore should be used to create and get instances of this class.
*/
class DECLSPEC HttpSession {
public:
/**
Constructor.
@param canStore The session can store data, if this parameter is true.
Otherwise all calls to set() and remove() do not have any effect.
*/
HttpSession(bool canStore=false);
/**
Copy constructor. Creates another HttpSession object that shares the
data of the other object.
*/
HttpSession(const HttpSession& other);
/**
Copy operator. Detaches from the current shared data and attaches to
the data of the other object.
*/
HttpSession& operator= (const HttpSession& other);
/**
Destructor. Detaches from the shared data.
*/
virtual ~HttpSession();
/** Get the unique ID of this session. This method is thread safe. */
QByteArray getId() const;
/**
Null sessions cannot store data. All calls to set() and remove()
do not have any effect.This method is thread safe.
*/
bool isNull() const;
/** Set a value. This method is thread safe. */
void set(const QByteArray& key, const QVariant& value);
/** Remove a value. This method is thread safe. */
void remove(const QByteArray& key);
/** Get a value. This method is thread safe. */
QVariant get(const QByteArray& key) const;
/** Check if a key exists. This method is thread safe. */
bool contains(const QByteArray& key) const;
/**
Get a copy of all data stored in this session.
Changes to the session do not affect the copy and vice versa.
This method is thread safe.
*/
QMap<QByteArray,QVariant> getAll() const;
/**
Get the timestamp of last access. That is the time when the last
HttpSessionStore::getSession() has been called.
This method is thread safe.
*/
qint64 getLastAccess() const;
/**
Set the timestamp of last access, to renew the timeout period.
Called by HttpSessionStore::getSession().
This method is thread safe.
*/
void setLastAccess();
private:
struct HttpSessionData {
/** Unique ID */
QByteArray id;
/** Timestamp of last access, set by the HttpSessionStore */
qint64 lastAccess;
/** Reference counter */
int refCount;
/** Used to synchronize threads */
QReadWriteLock lock;
/** Storage for the key/value pairs; */
QMap<QByteArray,QVariant> values;
};
/** Pointer to the shared data. */
HttpSessionData* dataPtr;
};
#endif // HTTPSESSION_H

54
YACReaderLibrary/server/lib/bfHttpServer/httpsessionstore.cpp → YACReaderLibrary/server/lib/httpserver/httpsessionstore.cpp
View File

@ -11,10 +11,10 @@ HttpSessionStore::HttpSessionStore(QSettings* settings, QObject* parent)
:QObject(parent) :QObject(parent)
{ {
this->settings=settings; this->settings=settings;
connect(&cleanupTimer,SIGNAL(timeout()),this,SLOT(timerEvent())); connect(&cleanupTimer,SIGNAL(timeout()),this,SLOT(sessionTimerEvent()));
cleanupTimer.start(60000); cleanupTimer.start(60000);
cookieName=settings->value("cookieName","sessionid").toByteArray(); cookieName=settings->value("cookieName","sessionid").toByteArray();
expirationTime=settings->value("expirationTime",864000000).toInt(); expirationTime=settings->value("expirationTime",3600000).toInt();
qDebug("HttpSessionStore: Sessions expire after %i milliseconds",expirationTime); qDebug("HttpSessionStore: Sessions expire after %i milliseconds",expirationTime);
} }
@ -23,18 +23,22 @@ HttpSessionStore::~HttpSessionStore()
cleanupTimer.stop(); cleanupTimer.stop();
} }
QByteArray HttpSessionStore::getSessionId(HttpRequest& request, HttpResponse& response) { QByteArray HttpSessionStore::getSessionId(HttpRequest& request, HttpResponse& response)
{
// The session ID in the response has priority because this one will be used in the next request. // The session ID in the response has priority because this one will be used in the next request.
mutex.lock(); mutex.lock();
// Get the session ID from the response cookie // Get the session ID from the response cookie
QByteArray sessionId=response.getCookies().value(cookieName).getValue(); QByteArray sessionId=response.getCookies().value(cookieName).getValue();
if (sessionId.isEmpty()) { if (sessionId.isEmpty())
{
// Get the session ID from the request cookie // Get the session ID from the request cookie
sessionId=request.getCookie(cookieName); sessionId=request.getCookie(cookieName);
} }
// Clear the session ID if there is no such session in the storage. // Clear the session ID if there is no such session in the storage.
if (!sessionId.isEmpty()) { if (!sessionId.isEmpty())
if (!sessions.contains(sessionId)) { {
if (!sessions.contains(sessionId))
{
qDebug("HttpSessionStore: received invalid session cookie with ID %s",sessionId.data()); qDebug("HttpSessionStore: received invalid session cookie with ID %s",sessionId.data());
sessionId.clear(); sessionId.clear();
} }
@ -43,21 +47,31 @@ QByteArray HttpSessionStore::getSessionId(HttpRequest& request, HttpResponse& re
return sessionId; return sessionId;
} }
HttpSession HttpSessionStore::getSession(HttpRequest& request, HttpResponse& response, bool allowCreate) { HttpSession HttpSessionStore::getSession(HttpRequest& request, HttpResponse& response, bool allowCreate)
{
QByteArray sessionId=getSessionId(request,response); QByteArray sessionId=getSessionId(request,response);
mutex.lock(); mutex.lock();
if (!sessionId.isEmpty()) { if (!sessionId.isEmpty())
{
HttpSession session=sessions.value(sessionId); HttpSession session=sessions.value(sessionId);
if (!session.isNull()) { if (!session.isNull())
{
mutex.unlock(); mutex.unlock();
// Refresh the session cookie
QByteArray cookieName=settings->value("cookieName","sessionid").toByteArray();
QByteArray cookiePath=settings->value("cookiePath").toByteArray();
QByteArray cookieComment=settings->value("cookieComment").toByteArray();
QByteArray cookieDomain=settings->value("cookieDomain").toByteArray();
response.setCookie(HttpCookie(cookieName,session.getId(),expirationTime/1000,cookiePath,cookieComment,cookieDomain));
session.setLastAccess(); session.setLastAccess();
return session; return session;
} }
} }
// Need to create a new session // Need to create a new session
if (allowCreate) { if (allowCreate)
{
QByteArray cookieName=settings->value("cookieName","sessionid").toByteArray(); QByteArray cookieName=settings->value("cookieName","sessionid").toByteArray();
QByteArray cookiePath=settings->value("cookiePath","/").toByteArray(); QByteArray cookiePath=settings->value("cookiePath").toByteArray();
QByteArray cookieComment=settings->value("cookieComment").toByteArray(); QByteArray cookieComment=settings->value("cookieComment").toByteArray();
QByteArray cookieDomain=settings->value("cookieDomain").toByteArray(); QByteArray cookieDomain=settings->value("cookieDomain").toByteArray();
HttpSession session(true); HttpSession session(true);
@ -72,7 +86,8 @@ HttpSession HttpSessionStore::getSession(HttpRequest& request, HttpResponse& res
return HttpSession(); return HttpSession();
} }
HttpSession HttpSessionStore::getSession(const QByteArray id) { HttpSession HttpSessionStore::getSession(const QByteArray id)
{
mutex.lock(); mutex.lock();
HttpSession session=sessions.value(id); HttpSession session=sessions.value(id);
mutex.unlock(); mutex.unlock();
@ -80,19 +95,19 @@ HttpSession HttpSessionStore::getSession(const QByteArray id) {
return session; return session;
} }
void HttpSessionStore::timerEvent() { void HttpSessionStore::sessionTimerEvent()
// Todo: find a way to delete sessions only if no controller is accessing them {
mutex.lock(); mutex.lock();
qint64 now=QDateTime::currentMSecsSinceEpoch(); qint64 now=QDateTime::currentMSecsSinceEpoch();
QMap<QByteArray,HttpSession>::iterator i = sessions.begin(); QMap<QByteArray,HttpSession>::iterator i = sessions.begin();
while (i != sessions.end()) { while (i != sessions.end())
{
QMap<QByteArray,HttpSession>::iterator prev = i; QMap<QByteArray,HttpSession>::iterator prev = i;
++i; ++i;
HttpSession session=prev.value(); HttpSession session=prev.value();
qint64 lastAccess=session.getLastAccess(); qint64 lastAccess=session.getLastAccess();
if (now-lastAccess>expirationTime) { //TODO cleaning up will cause current opened comic to be deleted, so clients won't be able to download it if (now-lastAccess>expirationTime)
//If the cleaning occurs in the midle of a download it going to cause issues {
//Temporal fix: use a big expirationTime = 10 days
qDebug("HttpSessionStore: session %s expired",session.getId().data()); qDebug("HttpSessionStore: session %s expired",session.getId().data());
sessions.erase(prev); sessions.erase(prev);
} }
@ -102,7 +117,8 @@ void HttpSessionStore::timerEvent() {
/** Delete a session */ /** Delete a session */
void HttpSessionStore::removeSession(HttpSession session) { void HttpSessionStore::removeSession(HttpSession session)
{
mutex.lock(); mutex.lock();
sessions.remove(session.getId()); sessions.remove(session.getId());
mutex.unlock(); mutex.unlock();

16
YACReaderLibrary/server/lib/bfHttpServer/httpsessionstore.h → YACReaderLibrary/server/lib/httpserver/httpsessionstore.h
View File

@ -10,6 +10,7 @@
#include <QMap> #include <QMap>
#include <QTimer> #include <QTimer>
#include <QMutex> #include <QMutex>
#include "httpglobal.h"
#include "httpsession.h" #include "httpsession.h"
#include "httpresponse.h" #include "httpresponse.h"
#include "httprequest.h" #include "httprequest.h"
@ -25,17 +26,17 @@
<code><pre> <code><pre>
cookiePath=/ cookiePath=/
cookieComment=Session ID cookieComment=Session ID
cookieDomain=stefanfrings.de ;cookieDomain=stefanfrings.de
</pre></code> </pre></code>
*/ */
class HttpSessionStore : public QObject { class DECLSPEC HttpSessionStore : public QObject {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(HttpSessionStore) Q_DISABLE_COPY(HttpSessionStore)
public: public:
/** Constructor. */ /** Constructor. */
HttpSessionStore(QSettings* settings, QObject* parent); HttpSessionStore(QSettings* settings, QObject* parent=NULL);
/** Destructor */ /** Destructor */
virtual ~HttpSessionStore(); virtual ~HttpSessionStore();
@ -75,14 +76,15 @@ public:
/** Delete a session */ /** Delete a session */
void removeSession(HttpSession session); void removeSession(HttpSession session);
protected:
/** Storage for the sessions */
QMap<QByteArray,HttpSession> sessions;
private: private:
/** Configuration settings */ /** Configuration settings */
QSettings* settings; QSettings* settings;
/** Storage for the sessions */
QMap<QByteArray,HttpSession> sessions;
/** Timer to remove expired sessions */ /** Timer to remove expired sessions */
QTimer cleanupTimer; QTimer cleanupTimer;
@ -98,7 +100,7 @@ private:
private slots: private slots:
/** Called every minute to cleanup expired sessions. */ /** Called every minute to cleanup expired sessions. */
void timerEvent(); void sessionTimerEvent();
}; };
#endif // HTTPSESSIONSTORE_H #endif // HTTPSESSIONSTORE_H

288
YACReaderLibrary/server/lib/httpserver/staticfilecontroller.cpp Normal file
View File

@ -0,0 +1,288 @@
/**
@file
@author Stefan Frings
*/
#include "staticfilecontroller.h"
#include <QFileInfo>
#include <QDir>
#include <QDateTime>
//YACReader-----
#include "httpsession.h"
#include "yacreader_http_session.h"
#include "static.h"
//--
StaticFileController::StaticFileController(QSettings* settings, QObject* parent)
:HttpRequestHandler(parent)
{
maxAge=settings->value("maxAge","60000").toInt();
encoding=settings->value("encoding","UTF-8").toString();
docroot=settings->value("path",".").toString();
if(!(docroot.startsWith(":/") || docroot.startsWith("qrc://")))
{
// Convert relative path to absolute, based on the directory of the config file.
#ifdef Q_OS_WIN32
if (QDir::isRelativePath(docroot) && settings->format()!=QSettings::NativeFormat)
#else
if (QDir::isRelativePath(docroot))
#endif
{
QFileInfo configFile(settings->fileName());
docroot=QFileInfo(configFile.absolutePath(),docroot).absoluteFilePath();
}
}
qDebug("StaticFileController: docroot=%s, encoding=%s, maxAge=%i",qPrintable(docroot),qPrintable(encoding),maxAge);
maxCachedFileSize=settings->value("maxCachedFileSize","65536").toInt();
cache.setMaxCost(settings->value("cacheSize","1000000").toInt());
cacheTimeout=settings->value("cacheTime","60000").toInt();
qDebug("StaticFileController: cache timeout=%i, size=%i",cacheTimeout,cache.maxCost());
}
void StaticFileController::service(HttpRequest& request, HttpResponse& response)
{
QByteArray path=request.getPath();
// Check if we have the file in cache
qint64 now=QDateTime::currentMSecsSinceEpoch();
mutex.lock();
CacheEntry* entry=cache.object(path);
if (entry && (cacheTimeout==0 || entry->created>now-cacheTimeout))
{
QByteArray document=entry->document; //copy the cached document, because other threads may destroy the cached entry immediately after mutex unlock.
QByteArray filename=entry->filename;
mutex.unlock();
qDebug("StaticFileController: Cache hit for %s",path.data());
setContentType(filename,response);
response.setHeader("Cache-Control","max-age="+QByteArray::number(maxAge/1000));
response.write(document);
}
else
{
mutex.unlock();
//TODO(DONE) carga sensible al dispositivo y a la localización
QString stringPath = path;
QStringList paths = QString(path).split('/');
QString fileName = paths.last();
stringPath.remove(fileName);
HttpSession session=Static::sessionStore->getSession(request,response,false);
YACReaderHttpSession *ySession = Static::yacreaderSessionStore->getYACReaderSessionHttpSession(session.getId());
QString device = ySession->getDeviceType();
QString display = ySession->getDisplayType();
if(fileName.endsWith(".png"))
fileName = getDeviceAwareFileName(fileName, device, display, request.getHeader("Accept-Language"), stringPath);
else
fileName = getDeviceAwareFileName(fileName, device, request.getHeader("Accept-Language"), stringPath);
QString newPath = stringPath.append(fileName);
path = newPath.toLocal8Bit();
//CAMBIADO
//response.setHeader("Connection","close");
//END_TODO
// The file is not in cache.
qDebug("StaticFileController: Cache miss for %s",path.data());
// Forbid access to files outside the docroot directory
if (path.contains("/.."))
{
qWarning("StaticFileController: detected forbidden characters in path %s",path.data());
response.setStatus(403,"forbidden");
response.write("403 forbidden",true);
return;
}
// If the filename is a directory, append index.html.
if (QFileInfo(docroot+path).isDir())
{
path+="/index.html";
}
// Try to open the file
QFile file(docroot+path);
qDebug("StaticFileController: Open file %s",qPrintable(file.fileName()));
if (file.open(QIODevice::ReadOnly))
{
setContentType(path,response);
response.setHeader("Cache-Control","max-age="+QByteArray::number(maxAge/1000));
if (file.size()<=maxCachedFileSize)
{
// Return the file content and store it also in the cache
entry=new CacheEntry();
while (!file.atEnd() && !file.error())
{
QByteArray buffer=file.read(65536);
response.write(buffer);
entry->document.append(buffer);
}
entry->created=now;
entry->filename=path;
mutex.lock();
cache.insert(request.getPath(),entry,entry->document.size());
mutex.unlock();
}
else
{
// Return the file content, do not store in cache
while (!file.atEnd() && !file.error())
{
response.write(file.read(65536));
}
}
file.close();
}
else {
if (file.exists())
{
qWarning("StaticFileController: Cannot open existing file %s for reading",qPrintable(file.fileName()));
response.setStatus(403,"forbidden");
response.write("403 forbidden",true);
}
else
{
response.setStatus(404,"not found");
response.write("404 not found",true);
}
}
}
}
void StaticFileController::setContentType(QString fileName, HttpResponse& response) const
{
if (fileName.endsWith(".png"))
{
response.setHeader("Content-Type", "image/png");
}
else if (fileName.endsWith(".jpg"))
{
response.setHeader("Content-Type", "image/jpeg");
}
else if (fileName.endsWith(".gif"))
{
response.setHeader("Content-Type", "image/gif");
}
else if (fileName.endsWith(".pdf"))
{
response.setHeader("Content-Type", "application/pdf");
}
else if (fileName.endsWith(".txt"))
{
response.setHeader("Content-Type", qPrintable("text/plain; charset="+encoding));
}
else if (fileName.endsWith(".html") || fileName.endsWith(".htm"))
{
response.setHeader("Content-Type", qPrintable("text/html; charset="+encoding));
}
else if (fileName.endsWith(".css"))
{
response.setHeader("Content-Type", "text/css");
}
else if (fileName.endsWith(".js"))
{
response.setHeader("Content-Type", "text/javascript");
}
else if (fileName.endsWith(".svg"))
{
response.setHeader("Content-Type", "image/svg+xml");
}
else if (fileName.endsWith(".woff"))
{
response.setHeader("Content-Type", "font/woff");
}
else if (fileName.endsWith(".woff2"))
{
response.setHeader("Content-Type", "font/woff2");
}
else if (fileName.endsWith(".ttf"))
{
response.setHeader("Content-Type", "application/x-font-ttf");
}
else if (fileName.endsWith(".eot"))
{
response.setHeader("Content-Type", "application/vnd.ms-fontobject");
}
else if (fileName.endsWith(".otf"))
{
response.setHeader("Content-Type", "application/font-otf");
}
// Todo: add all of your content types
else
{
qDebug("StaticFileController: unknown MIME type for filename '%s'", qPrintable(fileName));
}
}
//YACReader------------------------------------------------------------------------
bool StaticFileController::exists(QString localizedName, QString path) const
{
QString fileName=docroot+"/"+path + localizedName;
QFile file(fileName);
return file.exists();
}
//retorna fileName si no se encontró alternativa traducida ó fileName-locale.extensión si se encontró
QString StaticFileController::getLocalizedFileName(QString fileName, QString locales, QString path) const
{
QSet<QString> tried; // used to suppress duplicate attempts
QStringList locs=locales.split(',',QString::SkipEmptyParts);
QStringList fileNameParts = fileName.split('.');
QString file = fileNameParts.first();
QString extension = fileNameParts.last();
// Search for exact match
foreach (QString loc,locs) {
loc.replace(QRegExp(";.*"),"");
loc.replace('-','_');
QString localizedName=file+"-"+loc.trimmed()+"."+extension;
if (!tried.contains(localizedName)) {
if(exists(localizedName, path))
return localizedName;
tried.insert(localizedName);
}
}
// Search for correct language but any country
foreach (QString loc,locs) {
loc.replace(QRegExp("[;_-].*"),"");
QString localizedName=file+"-"+loc.trimmed()+"."+extension;
if (!tried.contains(localizedName)) {
if(exists(localizedName, path))
return localizedName;
tried.insert(localizedName);
}
}
return fileName;
}
QString StaticFileController::getDeviceAwareFileName(QString fileName, QString device, QString locales, QString path) const
{
QFileInfo fi(fileName);
QString baseName = fi.baseName();
QString extension = fi.completeSuffix();
QString completeFileName = getLocalizedFileName(baseName+"_"+device+"."+extension,locales,path);
if(QFile(docroot+"/"+path+completeFileName).exists())
return completeFileName; //existe un archivo específico para este dispositivo y locales
else
return getLocalizedFileName(fileName,locales,path); //no hay archivo específico para el dispositivo, pero puede haberlo para estas locales
}
QString StaticFileController::getDeviceAwareFileName(QString fileName, QString device, QString display, QString locales, QString path) const
{
QFileInfo fi(fileName);
QString baseName = fi.baseName();
QString extension = fi.completeSuffix();
QString completeFileName = baseName+display+"."+extension;
if(QFile(docroot+"/"+path+completeFileName).exists())
return completeFileName;
else
{
completeFileName = baseName+"_"+device+display+"."+extension;
if((QFile(docroot+"/"+path+completeFileName).exists()))
return completeFileName;
}
return fileName;
}

94
YACReaderLibrary/server/lib/httpserver/staticfilecontroller.h Normal file
View File

@ -0,0 +1,94 @@
/**
@file
@author Stefan Frings
*/
#ifndef STATICFILECONTROLLER_H
#define STATICFILECONTROLLER_H
#include <QCache>
#include <QMutex>
#include "httpglobal.h"
#include "httprequest.h"
#include "httpresponse.h"
#include "httprequesthandler.h"
/**
Delivers static files. It is usually called by the applications main request handler when
the caller requests a path that is mapped to static files.
<p>
The following settings are required in the config file:
<code><pre>
path=../docroot
encoding=UTF-8
maxAge=60000
cacheTime=60000
cacheSize=1000000
maxCachedFileSize=65536
</pre></code>
The path is relative to the directory of the config file. In case of windows, if the
settings are in the registry, the path is relative to the current working directory.
<p>
The encoding is sent to the web browser in case of text and html files.
<p>
The cache improves performance of small files when loaded from a network
drive. Large files are not cached. Files are cached as long as possible,
when cacheTime=0. The maxAge value (in msec!) controls the remote browsers cache.
<p>
Do not instantiate this class in each request, because this would make the file cache
useless. Better create one instance during start-up and call it when the application
received a related HTTP request.
*/
class DECLSPEC StaticFileController : public HttpRequestHandler {
Q_OBJECT
Q_DISABLE_COPY(StaticFileController)
public:
/** Constructor */
StaticFileController(QSettings* settings, QObject* parent = NULL);
/** Generates the response */
void service(HttpRequest& request, HttpResponse& response);
private:
/** Encoding of text files */
QString encoding;
/** Root directory of documents */
QString docroot;
/** Maximum age of files in the browser cache */
int maxAge;
struct CacheEntry {
QByteArray document;
qint64 created;
QByteArray filename;
};
/** Timeout for each cached file */
int cacheTimeout;
/** Maximum size of files in cache, larger files are not cached */
int maxCachedFileSize;
/** Cache storage */
QCache<QString,CacheEntry> cache;
/** Used to synchronize cache access for threads */
QMutex mutex;
/** Set a content-type header in the response depending on the ending of the filename */
void setContentType(QString file, HttpResponse& response) const;
//YACReader------------------------------------------------------------------------
QString getLocalizedFileName(QString fileName, QString locales, QString path) const;
QString getDeviceAwareFileName(QString fileName, QString device, QString locales, QString path) const;
QString getDeviceAwareFileName(QString fileName, QString device, QString display, QString locales, QString path) const;
bool exists(QString localizedName, QString path) const;
};
#endif // STATICFILECONTROLLER_H

14
YACReaderLibrary/server/lib/bfLogging/dualfilelogger.cpp → YACReaderLibrary/server/lib/logging/dualfilelogger.cpp
View File

@ -13,8 +13,14 @@ DualFileLogger::DualFileLogger(QSettings* firstSettings, QSettings* secondSettin
secondLogger=new FileLogger(secondSettings, refreshInterval, this); secondLogger=new FileLogger(secondSettings, refreshInterval, this);
} }
void DualFileLogger::log(const QtMsgType type, const QString& message, const QString &file, const QString &function, const int line)
void DualFileLogger::log(const QtMsgType type, const QString& message) { {
firstLogger->log(type, message); firstLogger->log(type,message,file,function,line);
secondLogger->log(type, message); secondLogger->log(type,message,file,function,line);
}
void DualFileLogger::clear(const bool buffer, const bool variables)
{
firstLogger->clear(buffer,variables);
secondLogger->clear(buffer,variables);
} }

22
YACReaderLibrary/server/lib/bfLogging/dualfilelogger.h → YACReaderLibrary/server/lib/logging/dualfilelogger.h
View File

@ -6,11 +6,12 @@
#ifndef DUALFILELOGGER_H #ifndef DUALFILELOGGER_H
#define DUALFILELOGGER_H #define DUALFILELOGGER_H
#include "logger.h"
#include "filelogger.h"
#include <QString> #include <QString>
#include <QSettings> #include <QSettings>
#include <QtGlobal> #include <QtGlobal>
#include "logglobal.h"
#include "logger.h"
#include "filelogger.h"
/** /**
Logs messages into two log files simultaneously. Logs messages into two log files simultaneously.
@ -18,7 +19,7 @@
@see FileLogger for a description of the two underlying loggers. @see FileLogger for a description of the two underlying loggers.
*/ */
class DualFileLogger : public Logger { class DECLSPEC DualFileLogger : public Logger {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(DualFileLogger) Q_DISABLE_COPY(DualFileLogger)
public: public:
@ -37,13 +38,24 @@ public:
DualFileLogger(QSettings* firstSettings, QSettings* secondSettings, const int refreshInterval=10000, QObject *parent = 0); DualFileLogger(QSettings* firstSettings, QSettings* secondSettings, const int refreshInterval=10000, QObject *parent = 0);
/** /**
Decorate and log a message. Decorate and log the message, if type>=minLevel.
This method is thread safe. This method is thread safe.
@param type Message type (level) @param type Message type (level)
@param message Message text @param message Message text
@param file Name of the source file where the message was generated (usually filled with the macro __FILE__)
@param function Name of the function where the message was generated (usually filled with the macro __LINE__)
@param line Line Number of the source file, where the message was generated (usually filles with the macro __func__ or __FUNCTION__)
@see LogMessage for a description of the message decoration. @see LogMessage for a description of the message decoration.
*/ */
virtual void log(const QtMsgType type, const QString& message); virtual void log(const QtMsgType type, const QString& message, const QString &file="", const QString &function="", const int line=0);
/**
Clear the thread-local data of the current thread.
This method is thread safe.
@param buffer Whether to clear the backtrace buffer
@param variables Whether to clear the log variables
*/
virtual void clear(const bool buffer=true, const bool variables=true);
private: private:

82
YACReaderLibrary/server/lib/bfLogging/filelogger.cpp → YACReaderLibrary/server/lib/logging/filelogger.cpp
View File

@ -13,16 +13,16 @@
#include <QDir> #include <QDir>
#include <QFileInfo> #include <QFileInfo>
#include <stdio.h> #include <stdio.h>
#include "yacreader_global.h"
void FileLogger::refreshSettings() { void FileLogger::refreshSettings()
{
mutex.lock(); mutex.lock();
// Save old file name for later comparision with new settings // Save old file name for later comparision with new settings
QString oldFileName=fileName; QString oldFileName=fileName;
// Load new config settings // Load new config settings
settings->sync(); settings->sync();
fileName=settings->value("fileName","server_log.log").toString(); fileName=settings->value("fileName").toString();
// Convert relative fileName to absolute, based on the directory of the config file. // Convert relative fileName to absolute, based on the directory of the config file.
#ifdef Q_OS_WIN32 #ifdef Q_OS_WIN32
if (QDir::isRelativePath(fileName) && settings->format()!=QSettings::NativeFormat) if (QDir::isRelativePath(fileName) && settings->format()!=QSettings::NativeFormat)
@ -30,18 +30,19 @@ void FileLogger::refreshSettings() {
if (QDir::isRelativePath(fileName)) if (QDir::isRelativePath(fileName))
#endif #endif
{ {
QFileInfo configFile(YACReader::getSettingsPath()); QFileInfo configFile(settings->fileName());
fileName=QFileInfo(YACReader::getSettingsPath(),fileName).absoluteFilePath(); fileName=QFileInfo(configFile.absolutePath(),fileName).absoluteFilePath();
} }
maxSize=settings->value("maxSize",1048576).toLongLong(); maxSize=settings->value("maxSize",0).toLongLong();
maxBackups=settings->value("maxBackups",1).toInt(); maxBackups=settings->value("maxBackups",0).toInt();
msgFormat=settings->value("msgFormat","{timestamp} {type} {msg}").toString(); msgFormat=settings->value("msgFormat","{timestamp} {type} {msg}").toString();
timestampFormat=settings->value("timestampFormat","yyyy-MM-dd hh:mm:ss.zzz").toString(); timestampFormat=settings->value("timestampFormat","yyyy-MM-dd hh:mm:ss.zzz").toString();
minLevel=static_cast<QtMsgType>(settings->value("minLevel",QtCriticalMsg).toInt()); minLevel=static_cast<QtMsgType>(settings->value("minLevel",0).toInt());
bufferSize=settings->value("bufferSize",0).toInt(); bufferSize=settings->value("bufferSize",0).toInt();
// Create new file if the filename has been changed // Create new file if the filename has been changed
if (oldFileName!=fileName) { if (oldFileName!=fileName)
{
fprintf(stderr,"Logging to %s\n",qPrintable(fileName)); fprintf(stderr,"Logging to %s\n",qPrintable(fileName));
close(); close();
open(); open();
@ -57,7 +58,8 @@ FileLogger::FileLogger(QSettings* settings, const int refreshInterval, QObject*
Q_ASSERT(refreshInterval>=0); Q_ASSERT(refreshInterval>=0);
this->settings=settings; this->settings=settings;
file=0; file=0;
if (refreshInterval>0) { if (refreshInterval>0)
{
refreshTimer.start(refreshInterval,this); refreshTimer.start(refreshInterval,this);
} }
flushTimer.start(1000,this); flushTimer.start(1000,this);
@ -65,26 +67,31 @@ FileLogger::FileLogger(QSettings* settings, const int refreshInterval, QObject*
} }
FileLogger::~FileLogger() { FileLogger::~FileLogger()
{
close(); close();
} }
void FileLogger::write(const LogMessage* logMessage) { void FileLogger::write(const LogMessage* logMessage)
{
// Try to write to the file // Try to write to the file
if (file) { if (file)
{
// Write the message // Write the message
file->write(qPrintable(logMessage->toString(msgFormat,timestampFormat))); file->write(qPrintable(logMessage->toString(msgFormat,timestampFormat)));
// Flush error messages immediately, to ensure that no important message // Flush error messages immediately, to ensure that no important message
// gets lost when the program terinates abnormally. // gets lost when the program terinates abnormally.
if (logMessage->getType()>=QtCriticalMsg) { if (logMessage->getType()>=QtCriticalMsg)
{
file->flush(); file->flush();
} }
// Check for success // Check for success
if (file->error()) { if (file->error())
{
close(); close();
qWarning("Cannot write to log file %s: %s",qPrintable(fileName),qPrintable(file->errorString())); qWarning("Cannot write to log file %s: %s",qPrintable(fileName),qPrintable(file->errorString()));
} }
@ -92,19 +99,23 @@ void FileLogger::write(const LogMessage* logMessage) {
} }
// Fall-back to the super class method, if writing failed // Fall-back to the super class method, if writing failed
if (!file) { if (!file)
{
Logger::write(logMessage); Logger::write(logMessage);
} }
} }
void FileLogger::open() { void FileLogger::open()
if (fileName.isEmpty()) { {
if (fileName.isEmpty())
{
qWarning("Name of logFile is empty"); qWarning("Name of logFile is empty");
} }
else { else {
file=new QFile(fileName); file=new QFile(fileName);
if (!file->open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text)) { if (!file->open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text))
{
qWarning("Cannot open log file %s: %s",qPrintable(fileName),qPrintable(file->errorString())); qWarning("Cannot open log file %s: %s",qPrintable(fileName),qPrintable(file->errorString()));
file=0; file=0;
} }
@ -112,8 +123,10 @@ void FileLogger::open() {
} }
void FileLogger::close() { void FileLogger::close()
if (file) { {
if (file)
{
file->close(); file->close();
delete file; delete file;
file=0; file=0;
@ -123,18 +136,22 @@ void FileLogger::close() {
void FileLogger::rotate() { void FileLogger::rotate() {
// count current number of existing backup files // count current number of existing backup files
int count=0; int count=0;
forever { forever
{
QFile bakFile(QString("%1.%2").arg(fileName).arg(count+1)); QFile bakFile(QString("%1.%2").arg(fileName).arg(count+1));
if (bakFile.exists()) { if (bakFile.exists())
{
++count; ++count;
} }
else { else
{
break; break;
} }
} }
// Remove all old backup files that exceed the maximum number // Remove all old backup files that exceed the maximum number
while (maxBackups>0 && count>=maxBackups) { while (maxBackups>0 && count>=maxBackups)
{
QFile::remove(QString("%1.%2").arg(fileName).arg(count)); QFile::remove(QString("%1.%2").arg(fileName).arg(count));
--count; --count;
} }
@ -149,21 +166,26 @@ void FileLogger::rotate() {
} }
void FileLogger::timerEvent(QTimerEvent* event) { void FileLogger::timerEvent(QTimerEvent* event)
if (!event) { {
if (!event)
{
return; return;
} }
else if (event->timerId()==refreshTimer.timerId()) { else if (event->timerId()==refreshTimer.timerId())
{
refreshSettings(); refreshSettings();
} }
else if (event->timerId()==flushTimer.timerId() && file) { else if (event->timerId()==flushTimer.timerId() && file)
{
mutex.lock(); mutex.lock();
// Flush the I/O buffer // Flush the I/O buffer
file->flush(); file->flush();
// Rotate the file if it is too large // Rotate the file if it is too large
if (maxSize>0 && file->size()>=maxSize) { if (maxSize>0 && file->size()>=maxSize)
{
close(); close();
rotate(); rotate();
open(); open();

3
YACReaderLibrary/server/lib/bfLogging/filelogger.h → YACReaderLibrary/server/lib/logging/filelogger.h
View File

@ -11,6 +11,7 @@
#include <QFile> #include <QFile>
#include <QMutex> #include <QMutex>
#include <QBasicTimer> #include <QBasicTimer>
#include "logglobal.h"
#include "logger.h" #include "logger.h"
/** /**
@ -45,7 +46,7 @@
@see Logger for a descrition of the buffer. @see Logger for a descrition of the buffer.
*/ */
class FileLogger : public Logger { class DECLSPEC FileLogger : public Logger {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(FileLogger) Q_DISABLE_COPY(FileLogger)
public: public:

66
YACReaderLibrary/server/lib/bfLogging/logger.cpp → YACReaderLibrary/server/lib/logging/logger.cpp
View File

@ -9,6 +9,7 @@
#include <QMutex> #include <QMutex>
#include <QDateTime> #include <QDateTime>
#include <QThread> #include <QThread>
#include <QObject>
Logger* Logger::defaultLogger=0; Logger* Logger::defaultLogger=0;
@ -16,9 +17,6 @@ Logger* Logger::defaultLogger=0;
QThreadStorage<QHash<QString,QString>*> Logger::logVars; QThreadStorage<QHash<QString,QString>*> Logger::logVars;
QThreadStorage<QList<LogMessage*>*> Logger::buffers;
QMutex Logger::mutex; QMutex Logger::mutex;
@ -32,7 +30,8 @@ Logger::Logger(QObject* parent)
Logger::Logger(const QString msgFormat, const QString timestampFormat, const QtMsgType minLevel, const int bufferSize, QObject* parent) Logger::Logger(const QString msgFormat, const QString timestampFormat, const QtMsgType minLevel, const int bufferSize, QObject* parent)
:QObject(parent) { :QObject(parent)
{
this->msgFormat=msgFormat; this->msgFormat=msgFormat;
this->timestampFormat=timestampFormat; this->timestampFormat=timestampFormat;
this->minLevel=minLevel; this->minLevel=minLevel;
@ -40,7 +39,8 @@ Logger::Logger(const QString msgFormat, const QString timestampFormat, const QtM
} }
void Logger::msgHandler(const QtMsgType type, const QString &message, const QString &file, const QString &function, const int line) { void Logger::msgHandler(const QtMsgType type, const QString &message, const QString &file, const QString &function, const int line)
{
static QMutex recursiveMutex(QMutex::Recursive); static QMutex recursiveMutex(QMutex::Recursive);
static QMutex nonRecursiveMutex(QMutex::NonRecursive); static QMutex nonRecursiveMutex(QMutex::NonRecursive);
@ -50,18 +50,21 @@ void Logger::msgHandler(const QtMsgType type, const QString &message, const QStr
recursiveMutex.lock(); recursiveMutex.lock();
// Fall back to stderr when this method has been called recursively. // Fall back to stderr when this method has been called recursively.
if (defaultLogger && nonRecursiveMutex.tryLock()) { if (defaultLogger && nonRecursiveMutex.tryLock())
{
defaultLogger->log(type, message, file, function, line); defaultLogger->log(type, message, file, function, line);
nonRecursiveMutex.unlock(); nonRecursiveMutex.unlock();
} }
else { else
{
fputs(qPrintable(message),stderr); fputs(qPrintable(message),stderr);
fflush(stderr); fflush(stderr);
} }
// Abort the program after logging a fatal message // Abort the program after logging a fatal message
if (type>=QtFatalMsg) { if (type>=QtFatalMsg)
//abort(); {
abort();
} }
recursiveMutex.unlock(); recursiveMutex.unlock();
@ -69,19 +72,23 @@ void Logger::msgHandler(const QtMsgType type, const QString &message, const QStr
#if QT_VERSION >= 0x050000 #if QT_VERSION >= 0x050000
void Logger::msgHandler5(const QtMsgType type, const QMessageLogContext &context, const QString &message) { void Logger::msgHandler5(const QtMsgType type, const QMessageLogContext &context, const QString &message)
{
(void)(context); // suppress "unused parameter" warning (void)(context); // suppress "unused parameter" warning
msgHandler(type,message,context.file,context.function,context.line); msgHandler(type,message,context.file,context.function,context.line);
} }
#else #else
void Logger::msgHandler4(const QtMsgType type, const char* message) { void Logger::msgHandler4(const QtMsgType type, const char* message)
{
msgHandler(type,message); msgHandler(type,message);
} }
#endif #endif
Logger::~Logger() { Logger::~Logger()
if (defaultLogger==this) { {
if (defaultLogger==this)
{
#if QT_VERSION >= 0x050000 #if QT_VERSION >= 0x050000
qInstallMessageHandler(0); qInstallMessageHandler(0);
#else #else
@ -92,13 +99,15 @@ Logger::~Logger() {
} }
void Logger::write(const LogMessage* logMessage) { void Logger::write(const LogMessage* logMessage)
{
fputs(qPrintable(logMessage->toString(msgFormat,timestampFormat)),stderr); fputs(qPrintable(logMessage->toString(msgFormat,timestampFormat)),stderr);
fflush(stderr); fflush(stderr);
} }
void Logger::installMsgHandler() { void Logger::installMsgHandler()
{
defaultLogger=this; defaultLogger=this;
#if QT_VERSION >= 0x050000 #if QT_VERSION >= 0x050000
qInstallMessageHandler(msgHandler5); qInstallMessageHandler(msgHandler5);
@ -108,9 +117,11 @@ void Logger::installMsgHandler() {
} }
void Logger::set(const QString& name, const QString& value) { void Logger::set(const QString& name, const QString& value)
{
mutex.lock(); mutex.lock();
if (!logVars.hasLocalData()) { if (!logVars.hasLocalData())
{
logVars.setLocalData(new QHash<QString,QString>); logVars.setLocalData(new QHash<QString,QString>);
} }
logVars.localData()->insert(name,value); logVars.localData()->insert(name,value);
@ -118,23 +129,27 @@ void Logger::set(const QString& name, const QString& value) {
} }
void Logger::clear(const bool buffer, const bool variables) { void Logger::clear(const bool buffer, const bool variables)
{
mutex.lock(); mutex.lock();
if (buffer && buffers.hasLocalData()) { if (buffer && buffers.hasLocalData())
{
QList<LogMessage*>* buffer=buffers.localData(); QList<LogMessage*>* buffer=buffers.localData();
while (buffer && !buffer->isEmpty()) { while (buffer && !buffer->isEmpty()) {
LogMessage* logMessage=buffer->takeLast(); LogMessage* logMessage=buffer->takeLast();
delete logMessage; delete logMessage;
} }
} }
if (variables && logVars.hasLocalData()) { if (variables && logVars.hasLocalData())
{
logVars.localData()->clear(); logVars.localData()->clear();
} }
mutex.unlock(); mutex.unlock();
} }
void Logger::log(const QtMsgType type, const QString& message, const QString &file, const QString &function, const int line) { void Logger::log(const QtMsgType type, const QString& message, const QString &file, const QString &function, const int line)
{
mutex.lock(); mutex.lock();
// If the buffer is enabled, write the message into it // If the buffer is enabled, write the message into it
@ -148,12 +163,14 @@ void Logger::log(const QtMsgType type, const QString& message, const QString &fi
LogMessage* logMessage=new LogMessage(type,message,logVars.localData(),file,function,line); LogMessage* logMessage=new LogMessage(type,message,logVars.localData(),file,function,line);
buffer->append(logMessage); buffer->append(logMessage);
// Delete oldest message if the buffer became too large // Delete oldest message if the buffer became too large
if (buffer->size()>bufferSize) { if (buffer->size()>bufferSize)
{
delete buffer->takeFirst(); delete buffer->takeFirst();
} }
// If the type of the message is high enough, print the whole buffer // If the type of the message is high enough, print the whole buffer
if (type>=minLevel) { if (type>=minLevel) {
while (!buffer->isEmpty()) { while (!buffer->isEmpty())
{
LogMessage* logMessage=buffer->takeFirst(); LogMessage* logMessage=buffer->takeFirst();
write(logMessage); write(logMessage);
delete logMessage; delete logMessage;
@ -163,7 +180,8 @@ void Logger::log(const QtMsgType type, const QString& message, const QString &fi
// Buffer is disabled, print the message if the type is high enough // Buffer is disabled, print the message if the type is high enough
else { else {
if (type>=minLevel) { if (type>=minLevel)
{
LogMessage logMessage(type,message,logVars.localData(),file,function,line); LogMessage logMessage(type,message,logVars.localData(),file,function,line);
write(&logMessage); write(&logMessage);
} }

13
YACReaderLibrary/server/lib/bfLogging/logger.h → YACReaderLibrary/server/lib/logging/logger.h
View File

@ -6,13 +6,13 @@
#ifndef LOGGER_H #ifndef LOGGER_H
#define LOGGER_H #define LOGGER_H
#include <QObject>
#include <QtGlobal> #include <QtGlobal>
#include <QThreadStorage> #include <QThreadStorage>
#include <QHash> #include <QHash>
#include <QStringList> #include <QStringList>
#include <QMutex> #include <QMutex>
#include <QObject>
#include "logglobal.h"
#include "logmessage.h" #include "logmessage.h"
/** /**
@ -45,7 +45,7 @@
because logging to the console is less useful. because logging to the console is less useful.
*/ */
class Logger : public QObject { class DECLSPEC Logger : public QObject {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(Logger) Q_DISABLE_COPY(Logger)
public: public:
@ -100,10 +100,11 @@ public:
/** /**
Clear the thread-local data of the current thread. Clear the thread-local data of the current thread.
This method is thread safe.
@param buffer Whether to clear the backtrace buffer @param buffer Whether to clear the backtrace buffer
@param variables Whether to clear the log variables @param variables Whether to clear the log variables
*/ */
static void clear(const bool buffer=true, const bool variables=true); virtual void clear(const bool buffer=true, const bool variables=true);
protected: protected:
@ -119,7 +120,7 @@ protected:
/** Size of backtrace buffer, number of messages per thread. 0=disabled */ /** Size of backtrace buffer, number of messages per thread. 0=disabled */
int bufferSize; int bufferSize;
/** Used to synchronize access to the static members */ /** Used to synchronize access of concurrent threads */
static QMutex mutex; static QMutex mutex;
/** /**
@ -176,7 +177,7 @@ private:
static QThreadStorage<QHash<QString,QString>*> logVars; static QThreadStorage<QHash<QString,QString>*> logVars;
/** Thread local backtrace buffers */ /** Thread local backtrace buffers */
static QThreadStorage<QList<LogMessage*>*> buffers; QThreadStorage<QList<LogMessage*>*> buffers;
}; };

6
YACReaderLibrary/server/lib/logging/logging.pri Normal file
View File

@ -0,0 +1,6 @@
INCLUDEPATH += $$PWD
DEPENDPATH += $$PWD
HEADERS += $$PWD/logglobal.h $$PWD/logmessage.h $$PWD/logger.h $$PWD/filelogger.h $$PWD/dualfilelogger.h
SOURCES += $$PWD/logmessage.cpp $$PWD/logger.cpp $$PWD/filelogger.cpp $$PWD/dualfilelogger.cpp

24
YACReaderLibrary/server/lib/logging/logglobal.h Normal file
View File

@ -0,0 +1,24 @@
/**
@file
@author Stefan Frings
*/
#ifndef LOGGLOBAL_H
#define LOGGLOBAL_H
#include <QtGlobal>
// This is specific to Windows dll's
#if defined(Q_OS_WIN)
#if defined(QTWEBAPPLIB_EXPORT)
#define DECLSPEC Q_DECL_EXPORT
#elif defined(QTWEBAPPLIB_IMPORT)
#define DECLSPEC Q_DECL_IMPORT
#endif
#endif
#if !defined(DECLSPEC)
#define DECLSPEC
#endif
#endif // LOGGLOBAL_H

52
YACReaderLibrary/server/lib/bfLogging/logmessage.cpp → YACReaderLibrary/server/lib/logging/logmessage.cpp
View File

@ -6,7 +6,8 @@
#include "logmessage.h" #include "logmessage.h"
#include <QThread> #include <QThread>
LogMessage::LogMessage(const QtMsgType type, const QString& message, QHash<QString, QString>* logVars, const QString &file, const QString &function, const int line) { LogMessage::LogMessage(const QtMsgType type, const QString& message, QHash<QString, QString>* logVars, const QString &file, const QString &function, const int line)
{
this->type=type; this->type=type;
this->message=message; this->message=message;
this->file=file; this->file=file;
@ -17,16 +18,19 @@ LogMessage::LogMessage(const QtMsgType type, const QString& message, QHash<QStri
// Copy the logVars if not null, // Copy the logVars if not null,
// so that later changes in the original do not affect the copy // so that later changes in the original do not affect the copy
if (logVars) { if (logVars)
{
this->logVars=*logVars; this->logVars=*logVars;
} }
} }
QString LogMessage::toString(const QString& msgFormat, const QString& timestampFormat) const { QString LogMessage::toString(const QString& msgFormat, const QString& timestampFormat) const
{
QString decorated=msgFormat+"\n"; QString decorated=msgFormat+"\n";
decorated.replace("{msg}",message); decorated.replace("{msg}",message);
if (decorated.contains("{timestamp}")) { if (decorated.contains("{timestamp}"))
{
decorated.replace("{timestamp}",timestamp.toString(timestampFormat)); decorated.replace("{timestamp}",timestamp.toString(timestampFormat));
} }
@ -34,21 +38,22 @@ QString LogMessage::toString(const QString& msgFormat, const QString& timestampF
typeNr.setNum(type); typeNr.setNum(type);
decorated.replace("{typeNr}",typeNr); decorated.replace("{typeNr}",typeNr);
switch (type) { switch (type)
case QtDebugMsg: {
decorated.replace("{type}","DEBUG"); case QtDebugMsg:
break; decorated.replace("{type}","DEBUG");
case QtWarningMsg: break;
decorated.replace("{type}","WARNING"); case QtWarningMsg:
break; decorated.replace("{type}","WARNING");
case QtCriticalMsg: break;
decorated.replace("{type}","CRITICAL"); case QtCriticalMsg:
break; decorated.replace("{type}","CRITICAL");
case QtFatalMsg: break;
decorated.replace("{type}","FATAL"); case QtFatalMsg:
break; decorated.replace("{type}","FATAL");
default: break;
decorated.replace("{type}",typeNr); default:
decorated.replace("{type}",typeNr);
} }
decorated.replace("{file}",file); decorated.replace("{file}",file);
@ -60,9 +65,11 @@ QString LogMessage::toString(const QString& msgFormat, const QString& timestampF
decorated.replace("{thread}",threadId); decorated.replace("{thread}",threadId);
// Fill in variables // Fill in variables
if (decorated.contains("{") && !logVars.isEmpty()) { if (decorated.contains("{") && !logVars.isEmpty())
{
QList<QString> keys=logVars.keys(); QList<QString> keys=logVars.keys();
foreach (QString key, keys) { foreach (QString key, keys)
{
decorated.replace("{"+key+"}",logVars.value(key)); decorated.replace("{"+key+"}",logVars.value(key));
} }
} }
@ -70,6 +77,7 @@ QString LogMessage::toString(const QString& msgFormat, const QString& timestampF
return decorated; return decorated;
} }
QtMsgType LogMessage::getType() const { QtMsgType LogMessage::getType() const
{
return type; return type;
} }

14
YACReaderLibrary/server/lib/bfLogging/logmessage.h → YACReaderLibrary/server/lib/logging/logmessage.h
View File

@ -9,6 +9,7 @@
#include <QtGlobal> #include <QtGlobal>
#include <QDateTime> #include <QDateTime>
#include <QHash> #include <QHash>
#include "logglobal.h"
/** /**
Represents a single log message together with some data Represents a single log message together with some data
@ -20,16 +21,17 @@
- {typeNr} Type of the message in numeric format (0-3) - {typeNr} Type of the message in numeric format (0-3)
- {type} Type of the message in string format (DEBUG, WARNING, CRITICAL, FATAL) - {type} Type of the message in string format (DEBUG, WARNING, CRITICAL, FATAL)
- {thread} ID number of the thread - {thread} ID number of the thread
- {msg} Message text (only useable in msgFormat) - {msg} Message text
- {file} Filename where the message was generated #
- {function} Function where the message was generated #
- {line} Line number where the message was generated #
- {xxx} For any user-defined logger variable - {xxx} For any user-defined logger variable
# The macros qDebug()...qFatal() dont fill these variable in case of QT versions before 5.0. Plus some new variables since QT 5.0, only filled when compiled in debug mode:
- {file} Filename where the message was generated
- {function} Function where the message was generated
- {line} Line number where the message was generated
*/ */
class LogMessage class DECLSPEC LogMessage
{ {
Q_DISABLE_COPY(LogMessage) Q_DISABLE_COPY(LogMessage)
public: public:

131
YACReaderLibrary/server/lib/bfTemplateEngine/template.cpp → YACReaderLibrary/server/lib/templateengine/template.cpp
View File

@ -7,131 +7,174 @@
#include <QFileInfo> #include <QFileInfo>
Template::Template(QString source, QString sourceName) Template::Template(QString source, QString sourceName)
: QString(source) { : QString(source)
{
this->sourceName=sourceName; this->sourceName=sourceName;
this->warnings=false; this->warnings=false;
} }
Template::Template(QFile& file, QTextCodec* textCodec) { Template::Template(QFile& file, QTextCodec* textCodec)
{
this->warnings=false; this->warnings=false;
sourceName=QFileInfo(file.fileName()).baseName(); sourceName=QFileInfo(file.fileName()).baseName();
if (!file.isOpen()) { if (!file.isOpen())
{
file.open(QFile::ReadOnly | QFile::Text); file.open(QFile::ReadOnly | QFile::Text);
} }
QByteArray data=file.readAll(); QByteArray data=file.readAll();
file.close(); file.close();
if (data.size()==0 || file.error()) { if (data.size()==0 || file.error())
{
qCritical("Template: cannot read from %s, %s",qPrintable(sourceName),qPrintable(file.errorString())); qCritical("Template: cannot read from %s, %s",qPrintable(sourceName),qPrintable(file.errorString()));
}
else
{
append(textCodec->toUnicode(data)); append(textCodec->toUnicode(data));
} }
} }
int Template::setVariable(QString name, QString value) { int Template::setVariable(QString name, QString value)
{
int count=0; int count=0;
QString variable="{"+name+"}"; QString variable="{"+name+"}";
int start=indexOf(variable); int start=indexOf(variable);
while (start>=0) { while (start>=0)
{
replace(start, variable.length(), value); replace(start, variable.length(), value);
count++; count++;
start=indexOf(variable,start+value.length()); start=indexOf(variable,start+value.length());
} }
if (count==0 && warnings) { if (count==0 && warnings)
{
qWarning("Template: missing variable %s in %s",qPrintable(variable),qPrintable(sourceName)); qWarning("Template: missing variable %s in %s",qPrintable(variable),qPrintable(sourceName));
} }
return count; return count;
} }
int Template::setCondition(QString name, bool value) { int Template::setCondition(QString name, bool value)
{
int count=0; int count=0;
QString startTag=QString("{if %1}").arg(name); QString startTag=QString("{if %1}").arg(name);
QString elseTag=QString("{else %1}").arg(name); QString elseTag=QString("{else %1}").arg(name);
QString endTag=QString("{end %1}").arg(name); QString endTag=QString("{end %1}").arg(name);
// search for if-else-end // search for if-else-end
int start=indexOf(startTag); int start=indexOf(startTag);
while (start>=0) { while (start>=0)
{
int end=indexOf(endTag,start+startTag.length()); int end=indexOf(endTag,start+startTag.length());
if (end>=0) { if (end>=0)
{
count++; count++;
int ellse=indexOf(elseTag,start+startTag.length()); int ellse=indexOf(elseTag,start+startTag.length());
if (ellse>start && ellse<end) { // there is an else part if (ellse>start && ellse<end)
if (value==true) { {
// there is an else part
if (value==true)
{
QString truePart=mid(start+startTag.length(), ellse-start-startTag.length()); QString truePart=mid(start+startTag.length(), ellse-start-startTag.length());
replace(start, end-start+endTag.length(), truePart); replace(start, end-start+endTag.length(), truePart);
} }
else { // value==false else
{
// value==false
QString falsePart=mid(ellse+elseTag.length(), end-ellse-elseTag.length()); QString falsePart=mid(ellse+elseTag.length(), end-ellse-elseTag.length());
replace(start, end-start+endTag.length(), falsePart); replace(start, end-start+endTag.length(), falsePart);
} }
} }
else if (value==true) { // and no else part else if (value==true)
{
// and no else part
QString truePart=mid(start+startTag.length(), end-start-startTag.length()); QString truePart=mid(start+startTag.length(), end-start-startTag.length());
replace(start, end-start+endTag.length(), truePart); replace(start, end-start+endTag.length(), truePart);
} }
else { // value==false and no else part else
{
// value==false and no else part
replace(start, end-start+endTag.length(), ""); replace(start, end-start+endTag.length(), "");
} }
start=indexOf(startTag,start); start=indexOf(startTag,start);
} }
else { else
{
qWarning("Template: missing condition end %s in %s",qPrintable(endTag),qPrintable(sourceName)); qWarning("Template: missing condition end %s in %s",qPrintable(endTag),qPrintable(sourceName));
} }
} }
// search for ifnot-else-end // search for ifnot-else-end
QString startTag2="{ifnot "+name+"}"; QString startTag2="{ifnot "+name+"}";
start=indexOf(startTag2); start=indexOf(startTag2);
while (start>=0) { while (start>=0)
{
int end=indexOf(endTag,start+startTag2.length()); int end=indexOf(endTag,start+startTag2.length());
if (end>=0) { if (end>=0)
{
count++; count++;
int ellse=indexOf(elseTag,start+startTag2.length()); int ellse=indexOf(elseTag,start+startTag2.length());
if (ellse>start && ellse<end) { // there is an else part if (ellse>start && ellse<end)
if (value==false) { {
// there is an else part
if (value==false)
{
QString falsePart=mid(start+startTag2.length(), ellse-start-startTag2.length()); QString falsePart=mid(start+startTag2.length(), ellse-start-startTag2.length());
replace(start, end-start+endTag.length(), falsePart); replace(start, end-start+endTag.length(), falsePart);
} }
else { // value==true else
{
// value==true
QString truePart=mid(ellse+elseTag.length(), end-ellse-elseTag.length()); QString truePart=mid(ellse+elseTag.length(), end-ellse-elseTag.length());
replace(start, end-start+endTag.length(), truePart); replace(start, end-start+endTag.length(), truePart);
} }
} }
else if (value==false) { // and no else part else if (value==false)
{
// and no else part
QString falsePart=mid(start+startTag2.length(), end-start-startTag2.length()); QString falsePart=mid(start+startTag2.length(), end-start-startTag2.length());
replace(start, end-start+endTag.length(), falsePart); replace(start, end-start+endTag.length(), falsePart);
} }
else { // value==true and no else part else
{
// value==true and no else part
replace(start, end-start+endTag.length(), ""); replace(start, end-start+endTag.length(), "");
} }
start=indexOf(startTag2,start); start=indexOf(startTag2,start);
} }
else { else
{
qWarning("Template: missing condition end %s in %s",qPrintable(endTag),qPrintable(sourceName)); qWarning("Template: missing condition end %s in %s",qPrintable(endTag),qPrintable(sourceName));
} }
} }
if (count==0 && warnings) { if (count==0 && warnings)
{
qWarning("Template: missing condition %s or %s in %s",qPrintable(startTag),qPrintable(startTag2),qPrintable(sourceName)); qWarning("Template: missing condition %s or %s in %s",qPrintable(startTag),qPrintable(startTag2),qPrintable(sourceName));
} }
return count; return count;
} }
int Template::loop(QString name, int repetitions) { int Template::loop(QString name, int repetitions)
//Q_ASSERT(repetitions>=0); {
Q_ASSERT(repetitions>=0);
int count=0; int count=0;
QString startTag="{loop "+name+"}"; QString startTag="{loop "+name+"}";
QString elseTag="{else "+name+"}"; QString elseTag="{else "+name+"}";
QString endTag="{end "+name+"}"; QString endTag="{end "+name+"}";
// search for loop-else-end // search for loop-else-end
int start=indexOf(startTag); int start=indexOf(startTag);
while (start>=0) { while (start>=0)
{
int end=indexOf(endTag,start+startTag.length()); int end=indexOf(endTag,start+startTag.length());
if (end>=0) { if (end>=0)
{
count++; count++;
int ellse=indexOf(elseTag,start+startTag.length()); int ellse=indexOf(elseTag,start+startTag.length());
if (ellse>start && ellse<end) { // there is an else part if (ellse>start && ellse<end)
if (repetitions>0) { {
// there is an else part
if (repetitions>0)
{
QString loopPart=mid(start+startTag.length(), ellse-start-startTag.length()); QString loopPart=mid(start+startTag.length(), ellse-start-startTag.length());
QString insertMe; QString insertMe;
for (int i=0; i<repetitions; ++i) { for (int i=0; i<repetitions; ++i)
{
// number variables, conditions and sub-loop within the loop // number variables, conditions and sub-loop within the loop
QString nameNum=name+QString::number(i); QString nameNum=name+QString::number(i);
QString s=loopPart; QString s=loopPart;
@ -145,15 +188,20 @@ int Template::loop(QString name, int repetitions) {
} }
replace(start, end-start+endTag.length(), insertMe); replace(start, end-start+endTag.length(), insertMe);
} }
else { // repetitions==0 else
{
// repetitions==0
QString elsePart=mid(ellse+elseTag.length(), end-ellse-elseTag.length()); QString elsePart=mid(ellse+elseTag.length(), end-ellse-elseTag.length());
replace(start, end-start+endTag.length(), elsePart); replace(start, end-start+endTag.length(), elsePart);
} }
} }
else if (repetitions>0) { // and no else part else if (repetitions>0)
{
// and no else part
QString loopPart=mid(start+startTag.length(), end-start-startTag.length()); QString loopPart=mid(start+startTag.length(), end-start-startTag.length());
QString insertMe; QString insertMe;
for (int i=0; i<repetitions; ++i) { for (int i=0; i<repetitions; ++i)
{
// number variables, conditions and sub-loop within the loop // number variables, conditions and sub-loop within the loop
QString nameNum=name+QString::number(i); QString nameNum=name+QString::number(i);
QString s=loopPart; QString s=loopPart;
@ -167,22 +215,27 @@ int Template::loop(QString name, int repetitions) {
} }
replace(start, end-start+endTag.length(), insertMe); replace(start, end-start+endTag.length(), insertMe);
} }
else { // repetitions==0 and no else part else
{
// repetitions==0 and no else part
replace(start, end-start+endTag.length(), ""); replace(start, end-start+endTag.length(), "");
} }
start=indexOf(startTag,start); start=indexOf(startTag,start);
} }
else { else
{
qWarning("Template: missing loop end %s in %s",qPrintable(endTag),qPrintable(sourceName)); qWarning("Template: missing loop end %s in %s",qPrintable(endTag),qPrintable(sourceName));
} }
} }
if (count==0 && warnings) { if (count==0 && warnings)
{
qWarning("Template: missing loop %s in %s",qPrintable(startTag),qPrintable(sourceName)); qWarning("Template: missing loop %s in %s",qPrintable(startTag),qPrintable(sourceName));
} }
return count; return count;
} }
void Template::enableWarnings(bool enable) { void Template::enableWarnings(bool enable)
{
warnings=enable; warnings=enable;
} }

5
YACReaderLibrary/server/lib/bfTemplateEngine/template.h → YACReaderLibrary/server/lib/templateengine/template.h
View File

@ -12,6 +12,7 @@
#include <QTextCodec> #include <QTextCodec>
#include <QFile> #include <QFile>
#include <QString> #include <QString>
#include "templateglobal.h"
/** /**
Enhanced version of QString for template processing. Templates Enhanced version of QString for template processing. Templates
@ -37,7 +38,7 @@
Example code to fill this template: Example code to fill this template:
<p><code><pre> <p><code><pre>
Template t(QFile("test.tpl"),QTextCode::codecForName("UTF-8")); Template t(QFile("test.tpl"),QTextCode::codecForName("UTF-8"));
t.setVariable("user", "Stefan"); t.setVariable("username", "Stefan");
t.setCondition("locked",false); t.setCondition("locked",false);
t.loop("user",2); t.loop("user",2);
t.setVariable("user0.name,"Markus"); t.setVariable("user0.name,"Markus");
@ -86,7 +87,7 @@
@see TemplateCache @see TemplateCache
*/ */
class Template : public QString { class DECLSPEC Template : public QString {
public: public:
/** /**

8
YACReaderLibrary/server/lib/bfTemplateEngine/templatecache.cpp → YACReaderLibrary/server/lib/templateengine/templatecache.cpp
View File

@ -6,17 +6,19 @@
TemplateCache::TemplateCache(QSettings* settings, QObject* parent) TemplateCache::TemplateCache(QSettings* settings, QObject* parent)
:TemplateLoader(settings,parent) :TemplateLoader(settings,parent)
{ {
cache.setMaxCost(settings->value("cacheSize","160000").toInt());//este tamaño antes era 1000000 cache.setMaxCost(settings->value("cacheSize","1000000").toInt());
cacheTimeout=settings->value("cacheTime","60000").toInt(); cacheTimeout=settings->value("cacheTime","60000").toInt();
qDebug("TemplateCache: timeout=%i, size=%i",cacheTimeout,cache.maxCost()); qDebug("TemplateCache: timeout=%i, size=%i",cacheTimeout,cache.maxCost());
} }
QString TemplateCache::tryFile(QString localizedName) { QString TemplateCache::tryFile(QString localizedName)
{
qint64 now=QDateTime::currentMSecsSinceEpoch(); qint64 now=QDateTime::currentMSecsSinceEpoch();
// search in cache // search in cache
qDebug("TemplateCache: trying cached %s",qPrintable(localizedName)); qDebug("TemplateCache: trying cached %s",qPrintable(localizedName));
CacheEntry* entry=cache.object(localizedName); CacheEntry* entry=cache.object(localizedName);
if (entry && (cacheTimeout==0 || entry->created>now-cacheTimeout)) { if (entry && (cacheTimeout==0 || entry->created>now-cacheTimeout))
{
return entry->document; return entry->document;
} }
// search on filesystem // search on filesystem

9
YACReaderLibrary/server/lib/bfTemplateEngine/templatecache.h → YACReaderLibrary/server/lib/templateengine/templatecache.h
View File

@ -1,8 +1,9 @@
#ifndef TEMPLATECACHE_H #ifndef TEMPLATECACHE_H
#define TEMPLATECACHE_H #define TEMPLATECACHE_H
#include "templateloader.h"
#include <QCache> #include <QCache>
#include "templateglobal.h"
#include "templateloader.h"
/** /**
Caching template loader, reduces the amount of I/O and improves performance Caching template loader, reduces the amount of I/O and improves performance
@ -25,7 +26,7 @@
<p> <p>
The following settings are required: The following settings are required:
<code><pre> <code><pre>
path=. path=../templates
suffix=.tpl suffix=.tpl
encoding=UTF-8 encoding=UTF-8
cacheSize=1000000 cacheSize=1000000
@ -38,9 +39,9 @@
@see TemplateLoader @see TemplateLoader
*/ */
class TemplateCache : public TemplateLoader { class DECLSPEC TemplateCache : public TemplateLoader {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(TemplateCache); Q_DISABLE_COPY(TemplateCache)
public: public:
/** /**

11
YACReaderLibrary/server/lib/templateengine/templateengine.pri Normal file
View File

@ -0,0 +1,11 @@
INCLUDEPATH += $$PWD
DEPENDPATH += $$PWD
HEADERS += $$PWD/templateglobal.h
HEADERS += $$PWD/template.h
HEADERS += $$PWD/templateloader.h
HEADERS += $$PWD/templatecache.h
SOURCES += $$PWD/template.cpp
SOURCES += $$PWD/templateloader.cpp
SOURCES += $$PWD/templatecache.cpp

24
YACReaderLibrary/server/lib/templateengine/templateglobal.h Normal file
View File

@ -0,0 +1,24 @@
/**
@file
@author Stefan Frings
*/
#ifndef TEMPLATEGLOBAL_H
#define TEMPLATEGLOBAL_H
#include <QtGlobal>
// This is specific to Windows dll's
#if defined(Q_OS_WIN)
#if defined(QTWEBAPPLIB_EXPORT)
#define DECLSPEC Q_DECL_EXPORT
#elif defined(QTWEBAPPLIB_IMPORT)
#define DECLSPEC Q_DECL_IMPORT
#endif
#endif
#if !defined(DECLSPEC)
#define DECLSPEC
#endif
#endif // TEMPLATEGLOBAL_H

51
YACReaderLibrary/server/lib/bfTemplateEngine/templateloader.cpp → YACReaderLibrary/server/lib/templateengine/templateloader.cpp
View File

@ -9,12 +9,11 @@
#include <QStringList> #include <QStringList>
#include <QDir> #include <QDir>
#include <QSet> #include <QSet>
#include <QCoreApplication>
TemplateLoader::TemplateLoader(QSettings* settings, QObject* parent) TemplateLoader::TemplateLoader(QSettings* settings, QObject* parent)
: QObject(parent) : QObject(parent)
{ {
templatePath=settings->value("path","./server/templates").toString(); templatePath=settings->value("path",".").toString();
// Convert relative path to absolute, based on the directory of the config file. // Convert relative path to absolute, based on the directory of the config file.
#ifdef Q_OS_WIN32 #ifdef Q_OS_WIN32
if (QDir::isRelativePath(templatePath) && settings->format()!=QSettings::NativeFormat) if (QDir::isRelativePath(templatePath) && settings->format()!=QSettings::NativeFormat)
@ -22,28 +21,27 @@ TemplateLoader::TemplateLoader(QSettings* settings, QObject* parent)
if (QDir::isRelativePath(templatePath)) if (QDir::isRelativePath(templatePath))
#endif #endif
{ {
#if defined Q_OS_UNIX && !defined Q_OS_MAC QFileInfo configFile(settings->fileName());
QFileInfo configFile(QString(DATADIR)+"/yacreader"); templatePath=QFileInfo(configFile.absolutePath(),templatePath).absoluteFilePath();
templatePath=QFileInfo(QString(DATADIR)+"/yacreader",templatePath).absoluteFilePath();
#else
QFileInfo configFile(QCoreApplication::applicationDirPath());
templatePath=QFileInfo(QCoreApplication::applicationDirPath(),templatePath).absoluteFilePath();
#endif
} }
fileNameSuffix=settings->value("suffix",".tpl").toString(); fileNameSuffix=settings->value("suffix",".tpl").toString();
QString encoding=settings->value("encoding").toString(); QString encoding=settings->value("encoding").toString();
if (encoding.isEmpty()) { if (encoding.isEmpty())
{
textCodec=QTextCodec::codecForLocale(); textCodec=QTextCodec::codecForLocale();
} }
else { else
{
textCodec=QTextCodec::codecForName(encoding.toLocal8Bit()); textCodec=QTextCodec::codecForName(encoding.toLocal8Bit());
} }
qDebug("TemplateLoader: path=%s, codec=%s",qPrintable(templatePath),textCodec->name().data()); qDebug("TemplateLoader: path=%s, codec=%s",qPrintable(templatePath),textCodec->name().data());
} }
TemplateLoader::~TemplateLoader() {} TemplateLoader::~TemplateLoader()
{}
QString TemplateLoader::tryFile(QString localizedName) { QString TemplateLoader::tryFile(QString localizedName)
{
QString fileName=templatePath+"/"+localizedName+fileNameSuffix; QString fileName=templatePath+"/"+localizedName+fileNameSuffix;
qDebug("TemplateCache: trying file %s",qPrintable(fileName)); qDebug("TemplateCache: trying file %s",qPrintable(fileName));
QFile file(fileName); QFile file(fileName);
@ -51,28 +49,33 @@ QString TemplateLoader::tryFile(QString localizedName) {
file.open(QIODevice::ReadOnly); file.open(QIODevice::ReadOnly);
QString document=textCodec->toUnicode(file.readAll()); QString document=textCodec->toUnicode(file.readAll());
file.close(); file.close();
if (file.error()) { if (file.error())
{
qCritical("TemplateLoader: cannot load file %s, %s",qPrintable(fileName),qPrintable(file.errorString())); qCritical("TemplateLoader: cannot load file %s, %s",qPrintable(fileName),qPrintable(file.errorString()));
return ""; return "";
} }
else { else
{
return document; return document;
} }
} }
return ""; return "";
} }
Template TemplateLoader::getTemplate(QString templateName, QString locales) { Template TemplateLoader::getTemplate(QString templateName, QString locales)
{
mutex.lock(); mutex.lock();
QSet<QString> tried; // used to suppress duplicate attempts QSet<QString> tried; // used to suppress duplicate attempts
QStringList locs=locales.split(',',QString::SkipEmptyParts); QStringList locs=locales.split(',',QString::SkipEmptyParts);
// Search for exact match // Search for exact match
foreach (QString loc,locs) { foreach (QString loc,locs)
{
loc.replace(QRegExp(";.*"),""); loc.replace(QRegExp(";.*"),"");
loc.replace('-','_'); loc.replace('-','_');
QString localizedName=templateName+"-"+loc.trimmed(); QString localizedName=templateName+"-"+loc.trimmed();
if (!tried.contains(localizedName)) { if (!tried.contains(localizedName))
{
QString document=tryFile(localizedName); QString document=tryFile(localizedName);
if (!document.isEmpty()) { if (!document.isEmpty()) {
mutex.unlock(); mutex.unlock();
@ -83,12 +86,15 @@ Template TemplateLoader::getTemplate(QString templateName, QString locales) {
} }
// Search for correct language but any country // Search for correct language but any country
foreach (QString loc,locs) { foreach (QString loc,locs)
{
loc.replace(QRegExp("[;_-].*"),""); loc.replace(QRegExp("[;_-].*"),"");
QString localizedName=templateName+"-"+loc.trimmed(); QString localizedName=templateName+"-"+loc.trimmed();
if (!tried.contains(localizedName)) { if (!tried.contains(localizedName))
{
QString document=tryFile(localizedName); QString document=tryFile(localizedName);
if (!document.isEmpty()) { if (!document.isEmpty())
{
mutex.unlock(); mutex.unlock();
return Template(document,localizedName); return Template(document,localizedName);
} }
@ -98,7 +104,8 @@ Template TemplateLoader::getTemplate(QString templateName, QString locales) {
// Search for default file // Search for default file
QString document=tryFile(templateName); QString document=tryFile(templateName);
if (!document.isEmpty()) { if (!document.isEmpty())
{
mutex.unlock(); mutex.unlock();
return Template(document,templateName); return Template(document,templateName);
} }

9
YACReaderLibrary/server/lib/bfTemplateEngine/templateloader.h → YACReaderLibrary/server/lib/templateengine/templateloader.h
View File

@ -9,8 +9,9 @@
#include <QString> #include <QString>
#include <QSettings> #include <QSettings>
#include <QTextCodec> #include <QTextCodec>
#include "template.h"
#include <QMutex> #include <QMutex>
#include "templateglobal.h"
#include "template.h"
/** /**
Loads localized versions of template files. If the caller requests a file with the Loads localized versions of template files. If the caller requests a file with the
@ -25,7 +26,7 @@
The following settings are required: The following settings are required:
<code><pre> <code><pre>
path=. path=../templates
suffix=.tpl suffix=.tpl
encoding=UTF-8 encoding=UTF-8
</pre></code> </pre></code>
@ -34,9 +35,9 @@
@see TemplateCache @see TemplateCache
*/ */
class TemplateLoader : public QObject { class DECLSPEC TemplateLoader : public QObject {
Q_OBJECT Q_OBJECT
Q_DISABLE_COPY(TemplateLoader); Q_DISABLE_COPY(TemplateLoader)
public: public:
/** /**

30
YACReaderLibrary/server/requestmapper.cpp
View File

@ -29,6 +29,8 @@
#include "db_helper.h" #include "db_helper.h"
#include "yacreader_libraries.h" #include "yacreader_libraries.h"
#include "yacreader_http_session.h"
#include "QsLog.h" #include "QsLog.h"
RequestMapper::RequestMapper(QObject* parent) RequestMapper::RequestMapper(QObject* parent)
@ -39,6 +41,8 @@ void RequestMapper::loadSession(HttpRequest & request, HttpResponse& response)
HttpSession session=Static::sessionStore->getSession(request,response); HttpSession session=Static::sessionStore->getSession(request,response);
if(session.contains("ySession")) //session is already alive check if it is needed to update comics if(session.contains("ySession")) //session is already alive check if it is needed to update comics
{ {
YACReaderHttpSession *ySession = Static::yacreaderSessionStore->getYACReaderSessionHttpSession(session.getId());
QString postData = QString::fromUtf8(request.getBody()); QString postData = QString::fromUtf8(request.getBody());
if(postData.contains("currentPage")) if(postData.contains("currentPage"))
@ -48,26 +52,30 @@ void RequestMapper::loadSession(HttpRequest & request, HttpResponse& response)
QList<QString> data = postData.split("\n"); QList<QString> data = postData.split("\n");
if(data.length() > 2) { if(data.length() > 2) {
session.setDeviceType(data.at(0).split(":").at(1)); ySession->setDeviceType(data.at(0).split(":").at(1));
session.setDisplayType(data.at(1).split(":").at(1)); ySession->setDisplayType(data.at(1).split(":").at(1));
QList<QString> comics = data.at(2).split(":").at(1).split("\t"); QList<QString> comics = data.at(2).split(":").at(1).split("\t");
session.clearComics(); ySession->clearComics();
foreach(QString hash,comics) { foreach(QString hash,comics) {
session.setComicOnDevice(hash); ySession->setComicOnDevice(hash);
} }
} }
else else
{ {
if(data.length()>1) if(data.length()>1)
{ {
session.setDeviceType(data.at(0).split(":").at(1)); ySession->setDeviceType(data.at(0).split(":").at(1));
session.setDisplayType(data.at(1).split(":").at(1)); ySession->setDisplayType(data.at(1).split(":").at(1));
} }
} }
} }
} }
else else
{ {
YACReaderHttpSession *ySession = new YACReaderHttpSession(this);
Static::yacreaderSessionStore->addYACReaderHttpSession(session.getId(), ySession);
session.set("ySession","ok"); session.set("ySession","ok");
QString postData = QString::fromUtf8(request.getBody()); QString postData = QString::fromUtf8(request.getBody());
@ -77,18 +85,18 @@ void RequestMapper::loadSession(HttpRequest & request, HttpResponse& response)
if(data.length() > 2) if(data.length() > 2)
{ {
session.setDeviceType(data.at(0).split(":").at(1)); ySession->setDeviceType(data.at(0).split(":").at(1));
session.setDisplayType(data.at(1).split(":").at(1)); ySession->setDisplayType(data.at(1).split(":").at(1));
QList<QString> comics = data.at(2).split(":").at(1).split("\t"); QList<QString> comics = data.at(2).split(":").at(1).split("\t");
foreach(QString hash,comics) foreach(QString hash,comics)
{ {
session.setComicOnDevice(hash); ySession->setComicOnDevice(hash);
} }
} }
else //values by default, only for debug purposes. else //values by default, only for debug purposes.
{ {
session.setDeviceType("ipad"); ySession->setDeviceType("ipad");
session.setDisplayType("@2x"); ySession->setDisplayType("@2x");
} }
} }

14
YACReaderLibrary/server/server.pri
View File

@ -19,7 +19,9 @@ HEADERS += \
#v2 #v2
$$PWD/controllers/versioncontroller.h \ $$PWD/controllers/versioncontroller.h \
$$PWD/controllers/foldercontentcontroller.h \ $$PWD/controllers/foldercontentcontroller.h \
$$PWD/controllers/tagscontroller.h $$PWD/controllers/tagscontroller.h \
$$PWD/yacreader_http_session.h \
$$PWD/yacreader_http_session_store.h
SOURCES += \ SOURCES += \
$$PWD/static.cpp \ $$PWD/static.cpp \
@ -39,10 +41,12 @@ SOURCES += \
#v2 #v2
$$PWD/controllers/versioncontroller.cpp \ $$PWD/controllers/versioncontroller.cpp \
$$PWD/controllers/foldercontentcontroller.cpp \ $$PWD/controllers/foldercontentcontroller.cpp \
$$PWD/controllers/tagscontroller.cpp $$PWD/controllers/tagscontroller.cpp \
$$PWD/yacreader_http_session.cpp \
$$PWD/yacreader_http_session_store.cpp
include(lib/bfLogging/bfLogging.pri) include(lib/logging/logging.pri)
include(lib/bfHttpServer/bfHttpServer.pri) include(lib/httpserver/httpserver.pri)
include(lib/bfTemplateEngine/bfTemplateEngine.pri) include(lib/templateengine/templateengine.pri)
DEFINES += SERVER_VERSION_NUMBER=\\\"2.0\\\" DEFINES += SERVER_VERSION_NUMBER=\\\"2.0\\\"

66
YACReaderLibrary/server/startup.cpp
View File

@ -35,28 +35,94 @@ void Startup::start() {
mainLogSettings->beginGroup("mainLogFile"); mainLogSettings->beginGroup("mainLogFile");
//QSettings* debugLogSettings=new QSettings(configFileName,QSettings::IniFormat,app); //QSettings* debugLogSettings=new QSettings(configFileName,QSettings::IniFormat,app);
//debugLogSettings->beginGroup("debugLogFile"); //debugLogSettings->beginGroup("debugLogFile");
if(mainLogSettings->value("fileName").isNull())
mainLogSettings->setValue("fileName", QFileInfo(YACReader::getSettingsPath(), "server_log.log").absoluteFilePath());
if(mainLogSettings->value("maxSize").isNull())
mainLogSettings->setValue("maxSize",1048576);
if(mainLogSettings->value("maxBackups").isNull())
mainLogSettings->setValue("maxBackups",1);
if(mainLogSettings->value("minLevel").isNull())
mainLogSettings->setValue("minLevel",QtCriticalMsg);
Logger* logger=new FileLogger(mainLogSettings,10000,app); Logger* logger=new FileLogger(mainLogSettings,10000,app);
logger->installMsgHandler(); logger->installMsgHandler();
// Configure template loader and cache // Configure template loader and cache
QSettings* templateSettings=new QSettings(configFileName,QSettings::IniFormat,app); QSettings* templateSettings=new QSettings(configFileName,QSettings::IniFormat,app);
templateSettings->beginGroup("templates"); templateSettings->beginGroup("templates");
if(templateSettings->value("cacheSize").isNull())
templateSettings->setValue("cacheSize","160000");
QString baseTemplatePath = QString("./server/templates");
QString templatePath;
#if defined Q_OS_UNIX && !defined Q_OS_MAC
templatePath=QFileInfo(QString(DATADIR)+"/yacreader",baseTemplatePath).absoluteFilePath();
#else
templatePath=QFileInfo(QCoreApplication::applicationDirPath(),baseTemplatePath).absoluteFilePath();
#endif
if(templateSettings->value("path").isNull())
templateSettings->setValue("path",templatePath);
Static::templateLoader=new TemplateCache(templateSettings,app); Static::templateLoader=new TemplateCache(templateSettings,app);
// Configure session store // Configure session store
QSettings* sessionSettings=new QSettings(configFileName,QSettings::IniFormat,app); QSettings* sessionSettings=new QSettings(configFileName,QSettings::IniFormat,app);
sessionSettings->beginGroup("sessions"); sessionSettings->beginGroup("sessions");
if(sessionSettings->value("expirationTime").isNull())
sessionSettings->setValue("expirationTime",864000000);
Static::sessionStore=new HttpSessionStore(sessionSettings,app); Static::sessionStore=new HttpSessionStore(sessionSettings,app);
Static::yacreaderSessionStore = new YACReaderHttpSessionStore(Static::sessionStore, app);
// Configure static file controller // Configure static file controller
QSettings* fileSettings=new QSettings(configFileName,QSettings::IniFormat,app); QSettings* fileSettings=new QSettings(configFileName,QSettings::IniFormat,app);
fileSettings->beginGroup("docroot"); fileSettings->beginGroup("docroot");
QString basedocroot = "./server/docroot";
QString docroot;
#if defined Q_OS_UNIX && ! defined Q_OS_MAC
QFileInfo configFile(QString(DATADIR)+"/yacreader");
docroot=QFileInfo(QString(DATADIR)+"/yacreader",basedocroot).absoluteFilePath();
#else
QFileInfo configFile(QCoreApplication::applicationDirPath());
docroot=QFileInfo(QCoreApplication::applicationDirPath(),basedocroot).absoluteFilePath();
#endif
if(fileSettings->value("path").isNull())
fileSettings->setValue("path",docroot);
Static::staticFileController=new StaticFileController(fileSettings,app); Static::staticFileController=new StaticFileController(fileSettings,app);
// Configure and start the TCP listener // Configure and start the TCP listener
qDebug("ServiceHelper: Starting service"); qDebug("ServiceHelper: Starting service");
QSettings* listenerSettings=new QSettings(configFileName,QSettings::IniFormat,app); QSettings* listenerSettings=new QSettings(configFileName,QSettings::IniFormat,app);
listenerSettings->beginGroup("listener"); listenerSettings->beginGroup("listener");
if(listenerSettings->value("maxRequestSize").isNull())
listenerSettings->setValue("maxRequestSize","32000000");
if(listenerSettings->value("maxMultiPartSize").isNull())
listenerSettings->setValue("maxMultiPartSize","32000000");
if(listenerSettings->value("cleanupInterval").isNull())
listenerSettings->setValue("cleanupInterval",10000);
if(listenerSettings->value("minThreads").isNull())
listenerSettings->setValue("maxThreads",1000);
if(listenerSettings->value("minThreads").isNull())
listenerSettings->setValue("minThreads",50);
listener = new HttpListener(listenerSettings,new RequestMapper(app),app); listener = new HttpListener(listenerSettings,new RequestMapper(app),app);
qDebug("ServiceHelper: Service has started"); qDebug("ServiceHelper: Service has started");

2
YACReaderLibrary/server/static.cpp
View File

@ -17,6 +17,8 @@ HttpSessionStore* Static::sessionStore=0;
StaticFileController* Static::staticFileController=0; StaticFileController* Static::staticFileController=0;
YACReaderHttpSessionStore* Static::yacreaderSessionStore=0;
QString Static::getConfigFileName() { QString Static::getConfigFileName() {
return QString("%1/%2.ini").arg(getConfigDir()).arg(QCoreApplication::applicationName()); return QString("%1/%2.ini").arg(getConfigDir()).arg(QCoreApplication::applicationName());
} }

4
YACReaderLibrary/server/static.h
View File

@ -11,6 +11,8 @@
#include "httpsessionstore.h" #include "httpsessionstore.h"
#include "staticfilecontroller.h" #include "staticfilecontroller.h"
#include "yacreader_http_session_store.h"
/** /**
This class contains some static resources that are used by the application. This class contains some static resources that are used by the application.
*/ */
@ -51,6 +53,8 @@ public:
/** Storage for session cookies */ /** Storage for session cookies */
static HttpSessionStore* sessionStore; static HttpSessionStore* sessionStore;
static YACReaderHttpSessionStore* yacreaderSessionStore;
/** Controller for static files */ /** Controller for static files */
static StaticFileController* staticFileController; static StaticFileController* staticFileController;

174
YACReaderLibrary/server/yacreader_http_session.cpp Normal file
View File

@ -0,0 +1,174 @@
#include "yacreader_http_session.h"
YACReaderHttpSession::YACReaderHttpSession(QObject *parent)
: QObject(parent), comic(nullptr), remoteComic(nullptr), comicId(0), remoteComicId(0)
{
}
YACReaderHttpSession::~YACReaderHttpSession()
{
if(comic != nullptr)
delete comic;
if(remoteComic != nullptr)
delete remoteComic;
}
bool YACReaderHttpSession::isComicOnDevice(const QString & hash)
{
return comicsOnDevice.contains(hash);
}
bool YACReaderHttpSession::isComicDownloaded(const QString & hash)
{
return downloadedComics.contains(hash);
}
void YACReaderHttpSession::setComicOnDevice(const QString & hash)
{
comicsOnDevice.insert(hash);
}
void YACReaderHttpSession::setComicsOnDevice(const QSet<QString> & set)
{
comicsOnDevice = set;
}
void YACReaderHttpSession::setDownloadedComic(const QString & hash)
{
downloadedComics.insert(hash);
}
QSet<QString> YACReaderHttpSession::getComicsOnDevice()
{
return comicsOnDevice ;
}
QSet<QString> YACReaderHttpSession::getDownloadedComics()
{
return downloadedComics ;
}
void YACReaderHttpSession::clearComics()
{
comicsOnDevice.clear();
downloadedComics.clear();
}
//current comic (import)
qulonglong YACReaderHttpSession::getCurrentComicId()
{
return comicId;
}
Comic* YACReaderHttpSession::getCurrentComic()
{
return comic;
}
void YACReaderHttpSession::dismissCurrentComic()
{
if(comic != nullptr)
{
comic->deleteLater();
comic = nullptr;
}
}
void YACReaderHttpSession::setCurrentComic(qulonglong id, Comic * comic)
{
dismissCurrentComic();
comicId = id;
this->comic = comic;
}
//current comic (read)
qulonglong YACReaderHttpSession::getCurrentRemoteComicId()
{
return remoteComicId ;
}
Comic* YACReaderHttpSession::getCurrentRemoteComic()
{
return remoteComic ;
}
void YACReaderHttpSession::dismissCurrentRemoteComic()
{
if(remoteComic != nullptr)
{
remoteComic->deleteLater();
remoteComic = nullptr;
}
}
void YACReaderHttpSession::setCurrentRemoteComic(qulonglong id, Comic * comic)
{
dismissCurrentRemoteComic();
remoteComicId = id;
remoteComic = comic;
}
QString YACReaderHttpSession::getDeviceType()
{
return device;
}
QString YACReaderHttpSession::getDisplayType()
{
return display;
}
void YACReaderHttpSession::setDeviceType(const QString & device)
{
//comicsOnDevice.clear(); //TODO crear un m<>todo clear que limpie la sesi<73>n completamente
//downloadedComics.clear();
this->device = device;
}
void YACReaderHttpSession::setDisplayType(const QString & display)
{
this->display = display;
}
void YACReaderHttpSession::clearNavigationPath()
{
navigationPath.clear();
}
QPair<qulonglong, quint32> YACReaderHttpSession::popNavigationItem()
{
if(navigationPath.isEmpty() == false)
return navigationPath.pop();
return QPair<qulonglong, quint32>();
}
QPair<qulonglong, quint32> YACReaderHttpSession::topNavigationItem()
{
if(navigationPath.isEmpty() == false)
return navigationPath.top();
return QPair<qulonglong, quint32>();
}
void YACReaderHttpSession::pushNavigationItem(const QPair<qulonglong, quint32> &item)
{
navigationPath.push(item);
}
void YACReaderHttpSession::updateTopItem(const QPair<qulonglong, quint32> &item)
{
if(navigationPath.isEmpty() == false)
{
navigationPath.pop();
navigationPath.push(item);
}
else
{
navigationPath.push(item);
}
}
QStack<QPair<qulonglong, quint32> > YACReaderHttpSession::getNavigationPath()
{
return navigationPath;
}

72
YACReaderLibrary/server/yacreader_http_session.h Normal file
View File

@ -0,0 +1,72 @@
#ifndef YACREADERHTTPSESSION_H
#define YACREADERHTTPSESSION_H
#include <QObject>
#include "comic.h"
class YACReaderHttpSession : public QObject
{
Q_OBJECT
public:
explicit YACReaderHttpSession(QObject *parent = 0);
~YACReaderHttpSession();
void setComicsOnDevice(const QSet<QString> & set);
void setComicOnDevice(const QString & hash);
void setDownloadedComic(const QString & hash);
bool isComicOnDevice(const QString & hash);
bool isComicDownloaded(const QString & hash);
QSet<QString> getComicsOnDevice();
QSet<QString> getDownloadedComics();
void clearComics();
//current comic (import)
qulonglong getCurrentComicId();
Comic * getCurrentComic();
void dismissCurrentComic();
void setCurrentComic(qulonglong id, Comic * comic);
//current comic (read)
qulonglong getCurrentRemoteComicId();
Comic * getCurrentRemoteComic();
void dismissCurrentRemoteComic();
void setCurrentRemoteComic(qulonglong id, Comic * comic);
//device identification
QString getDeviceType();
QString getDisplayType();
void setDeviceType(const QString & device);
void setDisplayType(const QString & display);
void clearNavigationPath();
QPair<qulonglong, quint32> popNavigationItem();
QPair<qulonglong, quint32> topNavigationItem();
void pushNavigationItem(const QPair<qulonglong, quint32> & item);
void updateTopItem(const QPair<qulonglong, quint32> & item);
//TODO replace QPair by a custom class for storing folderId, page and folderName(save some DB accesses)
QStack<QPair<qulonglong, quint32> > getNavigationPath();
signals:
public slots:
private:
QSet<QString> comicsOnDevice;
QSet<QString> downloadedComics;
QString device;
QString display;
qulonglong comicId;
qulonglong remoteComicId;
Comic * comic;
Comic * remoteComic;
QStack<QPair<qulonglong, quint32> > navigationPath; /* folder_id, page_number */
};
#endif // YACREADERHTTPSESSION_H

42
YACReaderLibrary/server/yacreader_http_session_store.cpp Normal file
View File

@ -0,0 +1,42 @@
#include "yacreader_http_session_store.h"
#include "httpsessionstore.h"
YACReaderHttpSessionStore::YACReaderHttpSessionStore(HttpSessionStore *sessionStore, QObject *parent)
: QObject(parent), sessionStore(sessionStore)
{
connect(&cleanupTimer,SIGNAL(timeout()),this,SLOT(sessionTimerEvent()));
cleanupTimer.start(60000);
}
void YACReaderHttpSessionStore::addYACReaderHttpSession(const QByteArray &httpSessionId, YACReaderHttpSession *yacreaderHttpSession)
{
QMutexLocker locker(&mutex);
sessions.insert(httpSessionId, yacreaderHttpSession);
}
YACReaderHttpSession *YACReaderHttpSessionStore::getYACReaderSessionHttpSession(const QByteArray &httpSessionId)
{
QMutexLocker locker(&mutex);
return sessions.value(httpSessionId, nullptr);
}
void YACReaderHttpSessionStore::sessionTimerEvent()
{
QMutexLocker locker(&mutex);
for(const QByteArray &id : sessions.keys())
{
if(sessionStore->getSession(id).isNull())
{
YACReaderHttpSession *session = sessions.value(id, nullptr);
if(session != nullptr)
delete session;
sessions.remove(id);
}
}
}

39
YACReaderLibrary/server/yacreader_http_session_store.h Normal file
View File

@ -0,0 +1,39 @@
#ifndef YACREADERHTTPSESSIONSTORE_H
#define YACREADERHTTPSESSIONSTORE_H
#include <QObject>
#include <QtCore>
class HttpSessionStore;
class YACReaderHttpSession;
class YACReaderHttpSessionStore : public QObject
{
Q_OBJECT
public:
explicit YACReaderHttpSessionStore(HttpSessionStore *sessionStore, QObject *parent = 0);
void addYACReaderHttpSession(const QByteArray & httpSessionId, YACReaderHttpSession *yacreaderHttpSession);
YACReaderHttpSession *getYACReaderSessionHttpSession(const QByteArray & httpSessionId);
signals:
public slots:
private:
QMap<QByteArray, YACReaderHttpSession*> sessions;
HttpSessionStore *sessionStore;
QTimer cleanupTimer;
QMutex mutex;
private slots:
void sessionTimerEvent();
};
#endif // YACREADERHTTPSESSIONSTORE_H