You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
588 lines
17 KiB
588 lines
17 KiB
/** |
|
@file |
|
@author Stefan Frings |
|
*/ |
|
|
|
#include "httprequest.h" |
|
#include "httplistenersettings.h" |
|
|
|
#include <QList> |
|
#include <QDir> |
|
#include "httpcookie.h" |
|
|
|
using namespace qtwebapp; |
|
|
|
HttpRequest::HttpRequest(QSettings* settings) : |
|
useQtSettings(true) |
|
{ |
|
Q_ASSERT(settings != 0); |
|
status=waitForRequest; |
|
currentSize=0; |
|
expectedBodySize=0; |
|
maxSize=settings->value("maxRequestSize","16000").toInt(); |
|
maxMultiPartSize=settings->value("maxMultiPartSize","1000000").toInt(); |
|
tempFile=0; |
|
} |
|
|
|
HttpRequest::HttpRequest(const HttpListenerSettings* settings) : |
|
useQtSettings(false) |
|
{ |
|
Q_ASSERT(settings != 0); |
|
status=waitForRequest; |
|
currentSize=0; |
|
expectedBodySize=0; |
|
maxSize=settings->maxRequestSize; |
|
maxMultiPartSize=settings->maxMultiPartSize; |
|
tempFile=0; |
|
} |
|
|
|
|
|
void HttpRequest::readRequest(QTcpSocket* socket) |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readRequest: read request"); |
|
#endif |
|
int toRead=maxSize-currentSize+1; // allow one byte more to be able to detect overflow |
|
lineBuffer.append(socket->readLine(toRead)); |
|
currentSize+=lineBuffer.size(); |
|
if (!lineBuffer.contains('\r') && !lineBuffer.contains('\n')) |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readRequest: collecting more parts until line break"); |
|
#endif |
|
return; |
|
} |
|
QByteArray newData=lineBuffer.trimmed(); |
|
lineBuffer.clear(); |
|
if (!newData.isEmpty()) |
|
{ |
|
QList<QByteArray> list=newData.split(' '); |
|
if (list.count()!=3 || !list.at(2).contains("HTTP")) |
|
{ |
|
qWarning("HttpRequest::readRequest: received broken HTTP request, invalid first line"); |
|
status=abort; |
|
} |
|
else { |
|
method=list.at(0).trimmed(); |
|
path=list.at(1); |
|
version=list.at(2); |
|
peerAddress = socket->peerAddress(); |
|
status=waitForHeader; |
|
} |
|
} |
|
} |
|
|
|
void HttpRequest::readHeader(QTcpSocket* socket) |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readHeader"); |
|
#endif |
|
int toRead=maxSize-currentSize+1; // allow one byte more to be able to detect overflow |
|
lineBuffer.append(socket->readLine(toRead)); |
|
currentSize+=lineBuffer.size(); |
|
if (!lineBuffer.contains('\r') && !lineBuffer.contains('\n')) |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readHeader: collecting more parts until line break"); |
|
#endif |
|
return; |
|
} |
|
QByteArray newData=lineBuffer.trimmed(); |
|
lineBuffer.clear(); |
|
int colon=newData.indexOf(':'); |
|
if (colon>0) |
|
{ |
|
// Received a line with a colon - a header |
|
currentHeader=newData.left(colon).toLower(); |
|
QByteArray value=newData.mid(colon+1).trimmed(); |
|
headers.insert(currentHeader,value); |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readHeader: received header %s: %s",currentHeader.data(),value.data()); |
|
#endif |
|
} |
|
else if (!newData.isEmpty()) |
|
{ |
|
// received another line - belongs to the previous header |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readHeader: read additional line of header"); |
|
#endif |
|
// Received additional line of previous header |
|
if (headers.contains(currentHeader)) { |
|
headers.insert(currentHeader,headers.value(currentHeader)+" "+newData); |
|
} |
|
} |
|
else |
|
{ |
|
// received an empty line - end of headers reached |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readHeader: headers completed"); |
|
#endif |
|
// Empty line received, that means all headers have been received |
|
// Check for multipart/form-data |
|
QByteArray contentType=headers.value("content-type"); |
|
if (contentType.startsWith("multipart/form-data")) |
|
{ |
|
int posi=contentType.indexOf("boundary="); |
|
if (posi>=0) { |
|
boundary=contentType.mid(posi+9); |
|
if (boundary.startsWith('"') && boundary.endsWith('"')) |
|
{ |
|
boundary = boundary.mid(1,boundary.length()-2); |
|
} |
|
} |
|
} |
|
QByteArray contentLength=headers.value("content-length"); |
|
if (!contentLength.isEmpty()) |
|
{ |
|
expectedBodySize=contentLength.toInt(); |
|
} |
|
if (expectedBodySize==0) |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readHeader: expect no body"); |
|
#endif |
|
status=complete; |
|
} |
|
else if (boundary.isEmpty() && expectedBodySize+currentSize>maxSize) |
|
{ |
|
qWarning("HttpRequest::readHeader: expected body is too large"); |
|
status=abort; |
|
} |
|
else if (!boundary.isEmpty() && expectedBodySize>maxMultiPartSize) |
|
{ |
|
qWarning("HttpRequest::readHeader: expected multipart body is too large"); |
|
status=abort; |
|
} |
|
else { |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readHeader: expect %i bytes body",expectedBodySize); |
|
#endif |
|
status=waitForBody; |
|
} |
|
} |
|
} |
|
|
|
void HttpRequest::readBody(QTcpSocket* socket) |
|
{ |
|
Q_ASSERT(expectedBodySize!=0); |
|
if (boundary.isEmpty()) |
|
{ |
|
// normal body, no multipart |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readBody: receive body"); |
|
#endif |
|
int toRead=expectedBodySize-bodyData.size(); |
|
QByteArray newData=socket->read(toRead); |
|
currentSize+=newData.size(); |
|
bodyData.append(newData); |
|
if (bodyData.size()>=expectedBodySize) |
|
{ |
|
status=complete; |
|
} |
|
} |
|
else |
|
{ |
|
// multipart body, store into temp file |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readBody: receiving multipart body"); |
|
#endif |
|
// Create an object for the temporary file, if not already present |
|
if (tempFile == NULL) |
|
{ |
|
tempFile = new QTemporaryFile; |
|
} |
|
if (!tempFile->isOpen()) |
|
{ |
|
tempFile->open(); |
|
} |
|
// Transfer data in 64kb blocks |
|
int fileSize=tempFile->size(); |
|
int toRead=expectedBodySize-fileSize; |
|
if (toRead>65536) |
|
{ |
|
toRead=65536; |
|
} |
|
fileSize+=tempFile->write(socket->read(toRead)); |
|
if (fileSize>=maxMultiPartSize) |
|
{ |
|
qWarning("HttpRequest::readBody: received too many multipart bytes"); |
|
status=abort; |
|
} |
|
else if (fileSize>=expectedBodySize) |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::readBody: received whole multipart body"); |
|
#endif |
|
tempFile->flush(); |
|
if (tempFile->error()) |
|
{ |
|
qCritical("HttpRequest::readBody: Error writing temp file for multipart body"); |
|
} |
|
parseMultiPartFile(); |
|
tempFile->close(); |
|
status=complete; |
|
} |
|
} |
|
} |
|
|
|
void HttpRequest::decodeRequestParams() |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::decodeRequestParams: extract and decode request parameters"); |
|
#endif |
|
// Get URL parameters |
|
QByteArray rawParameters; |
|
int questionMark=path.indexOf('?'); |
|
if (questionMark>=0) |
|
{ |
|
rawParameters=path.mid(questionMark+1); |
|
path=path.left(questionMark); |
|
} |
|
// Get request body parameters |
|
QByteArray contentType=headers.value("content-type"); |
|
if (!bodyData.isEmpty() && (contentType.isEmpty() || contentType.startsWith("application/x-www-form-urlencoded"))) |
|
{ |
|
if (!rawParameters.isEmpty()) |
|
{ |
|
rawParameters.append('&'); |
|
rawParameters.append(bodyData); |
|
} |
|
else |
|
{ |
|
rawParameters=bodyData; |
|
} |
|
} |
|
// Split the parameters into pairs of value and name |
|
QList<QByteArray> list=rawParameters.split('&'); |
|
foreach (QByteArray part, list) |
|
{ |
|
int equalsChar=part.indexOf('='); |
|
if (equalsChar>=0) |
|
{ |
|
QByteArray name=part.left(equalsChar).trimmed(); |
|
QByteArray value=part.mid(equalsChar+1).trimmed(); |
|
parameters.insert(urlDecode(name),urlDecode(value)); |
|
} |
|
else if (!part.isEmpty()) |
|
{ |
|
// Name without value |
|
parameters.insert(urlDecode(part),""); |
|
} |
|
} |
|
} |
|
|
|
void HttpRequest::extractCookies() |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::extractCookies"); |
|
#endif |
|
foreach(QByteArray cookieStr, headers.values("cookie")) |
|
{ |
|
QList<QByteArray> list=HttpCookie::splitCSV(cookieStr); |
|
foreach(QByteArray part, list) |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::extractCookies: found cookie %s",part.data()); |
|
#endif // Split the part into name and value |
|
QByteArray name; |
|
QByteArray value; |
|
int posi=part.indexOf('='); |
|
if (posi) |
|
{ |
|
name=part.left(posi).trimmed(); |
|
value=part.mid(posi+1).trimmed(); |
|
} |
|
else |
|
{ |
|
name=part.trimmed(); |
|
value=""; |
|
} |
|
cookies.insert(name,value); |
|
} |
|
} |
|
headers.remove("cookie"); |
|
} |
|
|
|
void HttpRequest::readFromSocket(QTcpSocket* socket) |
|
{ |
|
Q_ASSERT(status!=complete); |
|
if (status==waitForRequest) |
|
{ |
|
readRequest(socket); |
|
} |
|
else if (status==waitForHeader) |
|
{ |
|
readHeader(socket); |
|
} |
|
else if (status==waitForBody) |
|
{ |
|
readBody(socket); |
|
} |
|
if ((boundary.isEmpty() && currentSize>maxSize) || (!boundary.isEmpty() && currentSize>maxMultiPartSize)) |
|
{ |
|
qWarning("HttpRequest::readFromSocket: received too many bytes"); |
|
status=abort; |
|
} |
|
if (status==complete) |
|
{ |
|
// Extract and decode request parameters from url and body |
|
decodeRequestParams(); |
|
// Extract cookies from headers |
|
extractCookies(); |
|
} |
|
} |
|
|
|
|
|
HttpRequest::RequestStatus HttpRequest::getStatus() const |
|
{ |
|
return status; |
|
} |
|
|
|
|
|
QByteArray HttpRequest::getMethod() const |
|
{ |
|
return method; |
|
} |
|
|
|
|
|
QByteArray HttpRequest::getPath() const |
|
{ |
|
return urlDecode(path); |
|
} |
|
|
|
|
|
const QByteArray& HttpRequest::getRawPath() const |
|
{ |
|
return path; |
|
} |
|
|
|
|
|
QByteArray HttpRequest::getVersion() const |
|
{ |
|
return version; |
|
} |
|
|
|
|
|
QByteArray HttpRequest::getHeader(const QByteArray& name) const |
|
{ |
|
return headers.value(name.toLower()); |
|
} |
|
|
|
QList<QByteArray> HttpRequest::getHeaders(const QByteArray& name) const |
|
{ |
|
return headers.values(name.toLower()); |
|
} |
|
|
|
QMultiMap<QByteArray,QByteArray> HttpRequest::getHeaderMap() const |
|
{ |
|
return headers; |
|
} |
|
|
|
QByteArray HttpRequest::getParameter(const QByteArray& name) const |
|
{ |
|
return parameters.value(name); |
|
} |
|
|
|
QList<QByteArray> HttpRequest::getParameters(const QByteArray& name) const |
|
{ |
|
return parameters.values(name); |
|
} |
|
|
|
QMultiMap<QByteArray,QByteArray> HttpRequest::getParameterMap() const |
|
{ |
|
return parameters; |
|
} |
|
|
|
QByteArray HttpRequest::getBody() const |
|
{ |
|
return bodyData; |
|
} |
|
|
|
QByteArray HttpRequest::urlDecode(const QByteArray source) |
|
{ |
|
QByteArray buffer(source); |
|
buffer.replace('+',' '); |
|
int percentChar=buffer.indexOf('%'); |
|
while (percentChar>=0) |
|
{ |
|
bool ok; |
|
char byte=buffer.mid(percentChar+1,2).toInt(&ok,16); |
|
if (ok) |
|
{ |
|
buffer.replace(percentChar,3,(char*)&byte,1); |
|
} |
|
percentChar=buffer.indexOf('%',percentChar+1); |
|
} |
|
return buffer; |
|
} |
|
|
|
|
|
void HttpRequest::parseMultiPartFile() |
|
{ |
|
qDebug("HttpRequest::parseMultiPartFile: parsing multipart temp file"); |
|
tempFile->seek(0); |
|
bool finished=false; |
|
while (!tempFile->atEnd() && !finished && !tempFile->error()) |
|
{ |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::parseMultiPartFile: reading multipart headers"); |
|
#endif |
|
QByteArray fieldName; |
|
QByteArray fileName; |
|
while (!tempFile->atEnd() && !finished && !tempFile->error()) |
|
{ |
|
QByteArray line=tempFile->readLine(65536).trimmed(); |
|
if (line.startsWith("Content-Disposition:")) |
|
{ |
|
if (line.contains("form-data")) |
|
{ |
|
int start=line.indexOf(" name=\""); |
|
int end=line.indexOf("\"",start+7); |
|
if (start>=0 && end>=start) |
|
{ |
|
fieldName=line.mid(start+7,end-start-7); |
|
} |
|
start=line.indexOf(" filename=\""); |
|
end=line.indexOf("\"",start+11); |
|
if (start>=0 && end>=start) |
|
{ |
|
fileName=line.mid(start+11,end-start-11); |
|
} |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::parseMultiPartFile: multipart field=%s, filename=%s",fieldName.data(),fileName.data()); |
|
#endif |
|
} |
|
else |
|
{ |
|
qDebug("HttpRequest::parseMultiPartFile: ignoring unsupported content part %s",line.data()); |
|
} |
|
} |
|
else if (line.isEmpty()) |
|
{ |
|
break; |
|
} |
|
} |
|
|
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::parseMultiPartFile: reading multipart data"); |
|
#endif |
|
QTemporaryFile* uploadedFile=0; |
|
QByteArray fieldValue; |
|
while (!tempFile->atEnd() && !finished && !tempFile->error()) |
|
{ |
|
QByteArray line=tempFile->readLine(65536); |
|
if (line.startsWith("--"+boundary)) |
|
{ |
|
// Boundary found. Until now we have collected 2 bytes too much, |
|
// so remove them from the last result |
|
if (fileName.isEmpty() && !fieldName.isEmpty()) |
|
{ |
|
// last field was a form field |
|
fieldValue.remove(fieldValue.size()-2,2); |
|
parameters.insert(fieldName,fieldValue); |
|
qDebug("HttpRequest: set parameter %s=%s",fieldName.data(),fieldValue.data()); |
|
} |
|
else if (!fileName.isEmpty() && !fieldName.isEmpty()) |
|
{ |
|
// last field was a file |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::parseMultiPartFile: finishing writing to uploaded file"); |
|
#endif |
|
parameters.insert(fieldName,fileName); |
|
if (uploadedFile) |
|
{ |
|
uploadedFile->resize(uploadedFile->size()-2); |
|
uploadedFile->flush(); |
|
uploadedFile->seek(0); |
|
qDebug("HttpRequest::parseMultiPartFile: set parameter %s=%s",fieldName.data(),fileName.data()); |
|
uploadedFiles.insert(fieldName,uploadedFile); |
|
qDebug("HttpRequest::parseMultiPartFile: uploaded file size is %i",(int) uploadedFile->size()); |
|
} |
|
} |
|
if (line.contains(boundary+"--")) |
|
{ |
|
finished=true; |
|
} |
|
break; |
|
} |
|
else |
|
{ |
|
if (fileName.isEmpty() && !fieldName.isEmpty()) |
|
{ |
|
// this is a form field. |
|
currentSize+=line.size(); |
|
fieldValue.append(line); |
|
} |
|
else if (!fileName.isEmpty() && !fieldName.isEmpty()) |
|
{ |
|
// this is a file |
|
if (!uploadedFile) |
|
{ |
|
uploadedFile=new QTemporaryFile(); |
|
uploadedFile->open(); |
|
} |
|
uploadedFile->write(line); |
|
if (uploadedFile->error()) |
|
{ |
|
qCritical("HttpRequest::parseMultiPartFile: error writing temp file, %s",qPrintable(uploadedFile->errorString())); |
|
} |
|
} |
|
} |
|
} |
|
} |
|
if (tempFile->error()) |
|
{ |
|
qCritical("HttpRequest::parseMultiPartFile: cannot read temp file, %s",qPrintable(tempFile->errorString())); |
|
} |
|
#ifdef SUPERVERBOSE |
|
qDebug("HttpRequest::parseMultiPartFile: finished parsing multipart temp file"); |
|
#endif |
|
} |
|
|
|
HttpRequest::~HttpRequest() |
|
{ |
|
foreach(QByteArray key, uploadedFiles.keys()) |
|
{ |
|
QTemporaryFile* file=uploadedFiles.value(key); |
|
if (file->isOpen()) |
|
{ |
|
file->close(); |
|
} |
|
delete file; |
|
} |
|
if (tempFile != NULL) |
|
{ |
|
if (tempFile->isOpen()) |
|
{ |
|
tempFile->close(); |
|
} |
|
delete tempFile; |
|
} |
|
} |
|
|
|
QTemporaryFile* HttpRequest::getUploadedFile(const QByteArray fieldName) const |
|
{ |
|
return uploadedFiles.value(fieldName); |
|
} |
|
|
|
QByteArray HttpRequest::getCookie(const QByteArray& name) const |
|
{ |
|
return cookies.value(name); |
|
} |
|
|
|
/** Get the map of cookies */ |
|
QMap<QByteArray,QByteArray>& HttpRequest::getCookieMap() |
|
{ |
|
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; |
|
} |
|
|
|
|