144 lines
4.4 KiB
C++
144 lines
4.4 KiB
C++
/**
|
|
* @file
|
|
*
|
|
* @author Stefan Frings
|
|
* @author Petr Bravenec petr.bravenec@hobrasoft.cz
|
|
* @author Craig Drummond
|
|
*/
|
|
|
|
#include "staticfilecontroller.h"
|
|
#include "httpconnection.h"
|
|
#include "httpresponse.h"
|
|
#include "httprequest.h"
|
|
#include "basichttpserver.h"
|
|
#include <QFileInfo>
|
|
#include <QDir>
|
|
#include <QDateTime>
|
|
#include <QFile>
|
|
#include <QFileInfo>
|
|
#include <QDir>
|
|
#include <QDateTime>
|
|
#include <QDebug>
|
|
#include <QRegExp>
|
|
#include <QSettings>
|
|
#include <QDebug>
|
|
|
|
#define DBUG if (BasicHttpServer::debugEnabled()) qWarning() << "StaticFileController" << (void *)this << __FUNCTION__
|
|
|
|
static QString docroot;
|
|
static QString indexFile;
|
|
static bool cacheOn=false;
|
|
static int cacheTimeout=-1;
|
|
static int maxAge=0;
|
|
static int maxCachedFileSize=0;
|
|
static QHash<QByteArray, QByteArray> mimetypes;
|
|
|
|
static void initMimeTypes()
|
|
{
|
|
if (mimetypes.isEmpty()) {
|
|
mimetypes.insert("png", "image/png");
|
|
mimetypes.insert("jpeg", "image/jpeg");
|
|
mimetypes.insert("jpg", "image/jpeg");
|
|
mimetypes.insert("gif", "image/gif");
|
|
mimetypes.insert("txt", "text/plain");
|
|
mimetypes.insert("html", "text/html");
|
|
mimetypes.insert("xhtml", "text/html");
|
|
mimetypes.insert("htm", "text/html");
|
|
mimetypes.insert("css", "text/css");
|
|
mimetypes.insert("json", "application/json");
|
|
mimetypes.insert("js", "application/javascript");
|
|
}
|
|
}
|
|
|
|
StaticFileController::StaticFileController(const QSettings *settings)
|
|
{
|
|
if (-1==cacheTimeout) {
|
|
docroot=settings->value("http/root", "/var/www").toString();
|
|
indexFile=settings->value("http/index", "index.html").toString();
|
|
// cacheOn=settings->value("http/cacheOn", false).toBool();
|
|
// cacheTimeout=settings->value("http/cacheTimeout", 600000).toInt();
|
|
// maxAge=settings->value("http/maxAge", 3600).toInt();
|
|
// maxCachedFileSize=settings->value("http/maxCachedFileSize", 1000000).toInt();
|
|
}
|
|
initMimeTypes();
|
|
}
|
|
|
|
void StaticFileController::addMimeType(const QByteArray &extension, const QByteArray &mimetype)
|
|
{
|
|
initMimeTypes();
|
|
mimetypes.insert(extension, mimetype);
|
|
}
|
|
|
|
QByteArray StaticFileController::mimeType(const QByteArray &extension)
|
|
{
|
|
return mimetypes.contains(extension) ? mimetypes[extension] : QByteArray();
|
|
}
|
|
|
|
HttpRequestHandler::HandleStatus StaticFileController::handle(HttpRequest *request, HttpResponse *response)
|
|
{
|
|
QString path = request->path();
|
|
|
|
if (path.startsWith("/..")) {
|
|
response->setStatus(403,"Forbidden");
|
|
response->write("403 Forbidden");
|
|
response->flush();
|
|
return Status_Handled;
|
|
}
|
|
|
|
if (QFileInfo(docroot+path).isDir()) {
|
|
path += "/" + indexFile;
|
|
}
|
|
|
|
// qint64 now = QDateTime::currentDateTime().toTime_t() * 1000;
|
|
// CacheEntry *entry = cache.object(path);
|
|
// // Found in cache
|
|
// if (cacheOn && entry && (cacheTimeout == 0 || entry->created > now-cacheTimeout)) {
|
|
// setContentType(path, response);
|
|
// response->setHeader("Cache-Control", "max-age=" + QByteArray::number((int)(maxAge/1000)));
|
|
// response->write(entry->document);
|
|
// return Status_Handled;
|
|
// }
|
|
|
|
QFile file(docroot+path);
|
|
if (!file.exists()) {
|
|
DBUG << "404 Not found: " << docroot+path;
|
|
response->setStatus(404, "Not found");
|
|
response->write("404 Not found");
|
|
response->flush();
|
|
return Status_Handled;
|
|
}
|
|
|
|
if (!file.open(QIODevice::ReadOnly)) {
|
|
DBUG << "403 Forbidden: " << docroot+path;
|
|
response->setStatus(403, "Forbidden");
|
|
response->write("403 Forbidden");
|
|
response->flush();
|
|
return Status_Handled;
|
|
}
|
|
|
|
setContentType(QString(path).replace(QRegExp("^.*\\."), "").toLower(), response);
|
|
// if (file.size() <= maxCachedFileSize && cacheOn) {
|
|
// response->setHeader("Cache-Control", "max-age=" + QByteArray::number((int)(maxAge/1000)));
|
|
// entry = new CacheEntry();
|
|
// entry->created = now;
|
|
// entry->document = file.readAll();
|
|
// response->write(entry->document);
|
|
// cache.insert(path, entry, entry->document.size());
|
|
// }
|
|
|
|
// if (file.size() > maxCachedFileSize || !cacheOn) {
|
|
response->write(file.readAll());
|
|
// }
|
|
|
|
file.close();
|
|
return Status_Handled;
|
|
}
|
|
|
|
void StaticFileController::setContentType(const QString &ext, HttpResponse *response)
|
|
{
|
|
QByteArray mime=mimeType(ext.toLatin1());
|
|
if (!mime.isEmpty()) {
|
|
response->setHeader("Content-Type", mime);
|
|
}
|
|
}
|