e4bb7c4e75
Now Client reads the first headers block, then LocalWebserver decides which Handler to use. In case of "/upload", UploadFileHandler is used. But now it only knows the "path" parameter. If that's valid, actual UploadFileClientHandler is created, which reads the contents of the request and, when finds there an "upload_file" field, starts saving it in the directory specified by "path". With that we don't need temp files approach from Reader class.
618 lines
16 KiB
C++
618 lines
16 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
*/
|
|
|
|
#define FORBIDDEN_SYMBOL_ALLOW_ALL
|
|
|
|
#include "backends/networking/sdl_net/reader.h"
|
|
#include "backends/networking/sdl_net/localwebserver.h"
|
|
#include "common/debug.h"
|
|
#include "common/stream.h"
|
|
#include "common/memstream.h"
|
|
#include "backends/fs/fs-factory.h"
|
|
|
|
// This define lets us use the system function remove() on Symbian, which
|
|
// is disabled by default due to a macro conflict.
|
|
// See backends/platform/symbian/src/portdefs.h .
|
|
#define SYMBIAN_USE_SYSTEM_REMOVE
|
|
|
|
#ifndef _WIN32_WCE
|
|
#include <errno.h> // for removeFile()
|
|
#endif
|
|
|
|
namespace Networking {
|
|
|
|
Reader::Reader(): _randomSource("Networking::Reader") {
|
|
_state = RS_NONE;
|
|
_content = nullptr;
|
|
_bytesLeft = 0;
|
|
|
|
_window = nullptr;
|
|
_windowUsed = 0;
|
|
_windowSize = 0;
|
|
|
|
_headers = "";
|
|
_stream = nullptr;
|
|
_firstBlock = true;
|
|
|
|
_contentLength = 0;
|
|
_availableBytes = 0;
|
|
_isFileField = false;
|
|
_isBadRequest = false;
|
|
}
|
|
|
|
namespace {
|
|
bool removeFile(const char *filename) {
|
|
// FIXME: remove does not exist on all systems. If your port fails to
|
|
// compile because of this, please let us know (scummvm-devel).
|
|
// There is a nicely portable workaround, too: Make this method overloadable.
|
|
if (remove(filename) != 0) {
|
|
#ifndef _WIN32_WCE
|
|
if (errno == EACCES)
|
|
error("Reader: removeFile(): Search or write permission denied: %s", filename);
|
|
|
|
if (errno == ENOENT)
|
|
error("Reader: removeFile(): '%s' does not exist or path is invalid", filename);
|
|
#endif
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
Reader::~Reader() {
|
|
cleanup();
|
|
}
|
|
|
|
Reader &Reader::operator=(Reader &r) {
|
|
if (this == &r) return *this;
|
|
cleanup();
|
|
|
|
_state = r._state;
|
|
_content = r._content;
|
|
_bytesLeft = r._bytesLeft;
|
|
r._state = RS_NONE;
|
|
|
|
_window = r._window;
|
|
_windowUsed = r._windowUsed;
|
|
_windowSize = r._windowSize;
|
|
r._window = nullptr;
|
|
|
|
_headers = r._headers;
|
|
_stream = r._stream;
|
|
_firstBlock = r._firstBlock;
|
|
r._stream = nullptr;
|
|
|
|
_headers = r._headers;
|
|
_method = r._method;
|
|
_path = r._path;
|
|
_query = r._query;
|
|
_anchor = r._anchor;
|
|
_queryParameters = r._queryParameters;
|
|
_attachedFiles = r._attachedFiles;
|
|
r._attachedFiles.clear();
|
|
_contentLength = r._contentLength;
|
|
_boundary = r._boundary;
|
|
_availableBytes = r._availableBytes;
|
|
_currentFieldName = r._currentFieldName;
|
|
_currentFileName = r._currentFileName;
|
|
_currentTempFileName = r._currentTempFileName;
|
|
_isFileField = r._isFileField;
|
|
_isBadRequest = r._isBadRequest;
|
|
|
|
return *this;
|
|
}
|
|
|
|
void Reader::cleanup() {
|
|
//_content is not to be freed, it's not owned by Reader
|
|
|
|
if (_window != nullptr) freeWindow();
|
|
delete _stream;
|
|
|
|
//delete temp files (by the time Reader is destucted those must be renamed or read)
|
|
for (Common::HashMap<Common::String, Common::String>::iterator i = _attachedFiles.begin(); i != _attachedFiles.end(); ++i) {
|
|
AbstractFSNode *node = g_system->getFilesystemFactory()->makeFileNodePath(i->_value);
|
|
if (node->exists()) removeFile(node->getPath().c_str());
|
|
}
|
|
}
|
|
|
|
bool Reader::readWholeRequest() {
|
|
if (_state == RS_NONE) _state = RS_READING_HEADERS;
|
|
|
|
while (true) {
|
|
if (!bytesLeft()) return false;
|
|
|
|
if (_state == RS_READING_HEADERS)
|
|
if (!readWholeHeaders())
|
|
return false;
|
|
|
|
if (_boundary.empty()) return true; //not POST multipart
|
|
|
|
if (!bytesLeft()) return false;
|
|
|
|
if (_state == RS_READING_CONTENT)
|
|
if (!readWholeContent())
|
|
return false;
|
|
|
|
if (_availableBytes >= 2) {
|
|
Common::String bts;
|
|
bts += readOne();
|
|
bts += readOne();
|
|
if (bts == "--") break;
|
|
if (bts == "\r\n") continue;
|
|
warning("strange bytes: \"%s\"", bts.c_str());
|
|
} else {
|
|
warning("strange ending");
|
|
break;
|
|
}
|
|
}
|
|
if (_availableBytes > 0) debug("STRANGE END: %llu bytes left", _availableBytes);
|
|
else debug("END");
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Reader::readFirstHeaders() {
|
|
if (_state == RS_NONE) _state = RS_READING_HEADERS;
|
|
|
|
if (!bytesLeft()) return false;
|
|
|
|
if (_state == RS_READING_HEADERS)
|
|
return readWholeHeaders();
|
|
|
|
warning("Reader::readFirstHeaders(): bad state");
|
|
return false;
|
|
}
|
|
|
|
bool Reader::readFirstContent(Common::WriteStream *stream) {
|
|
if (_state != RS_READING_CONTENT) {
|
|
warning("Reader::readFirstContent(): bad state");
|
|
return false;
|
|
}
|
|
|
|
if (!bytesLeft()) return false;
|
|
|
|
return readWholeContentIntoStream(stream);
|
|
}
|
|
|
|
bool Reader::readBlockHeaders(Common::WriteStream *stream) {
|
|
if (_state != RS_READING_HEADERS) {
|
|
warning("Reader::readBlockHeaders(): bad state");
|
|
return false;
|
|
}
|
|
|
|
if (!bytesLeft()) return false;
|
|
|
|
return readWholeHeadersIntoStream(stream);
|
|
}
|
|
|
|
bool Reader::readBlockContent(Common::WriteStream *stream) {
|
|
if (_state != RS_READING_CONTENT) {
|
|
warning("Reader::readBlockContent(): bad state");
|
|
return false;
|
|
}
|
|
|
|
if (!bytesLeft()) return false;
|
|
|
|
if (!readWholeContentIntoStream(stream))
|
|
return false;
|
|
|
|
/*
|
|
if (_availableBytes >= 2) {
|
|
Common::String bts;
|
|
bts += readOne();
|
|
bts += readOne();
|
|
if (bts == "--") _isOver = true;
|
|
else if (bts != "\r\n")
|
|
warning("strange bytes: \"%s\"", bts.c_str());
|
|
} else {
|
|
warning("strange ending");
|
|
_isOver = true;
|
|
}
|
|
*/
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Reader::readWholeHeaders() {
|
|
Common::String boundary = "\r\n\r\n";
|
|
if (_window == nullptr) {
|
|
makeWindow(boundary.size());
|
|
_headers = "";
|
|
}
|
|
|
|
while (readOneByteInString(_headers, boundary)) {
|
|
if (!bytesLeft()) return false;
|
|
}
|
|
handleHeaders(_headers);
|
|
|
|
freeWindow();
|
|
_state = RS_READING_CONTENT;
|
|
return true;
|
|
}
|
|
|
|
bool Reader::readWholeHeadersIntoStream(Common::WriteStream *stream) {
|
|
Common::String boundary = "\r\n\r\n";
|
|
if (_window == nullptr) makeWindow(boundary.size());
|
|
|
|
while (readOneByteInStream(stream, boundary)) {
|
|
if (!bytesLeft()) return false;
|
|
}
|
|
if (stream) stream->flush();
|
|
|
|
freeWindow();
|
|
_state = RS_READING_CONTENT;
|
|
return true;
|
|
}
|
|
|
|
namespace {
|
|
void readFromThatUntilLineEnd(const char *cstr, Common::String needle, Common::String &result) {
|
|
const char *position = strstr(cstr, needle.c_str());
|
|
|
|
if (position) {
|
|
char c;
|
|
for (const char *i = position + needle.size(); c = *i, c != 0; ++i) {
|
|
if (c == '\n' || c == '\r') break;
|
|
result += c;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Reader::handleHeaders(Common::String headers) {
|
|
debug("\nHANDLE HEADERS:\n>>%s<<", headers.c_str());
|
|
if (_boundary.empty()) {
|
|
//parse method, path, query, fragment
|
|
parseFirstLine(headers);
|
|
|
|
//find boundary
|
|
_boundary = "";
|
|
readFromThatUntilLineEnd(headers.c_str(), "boundary=", _boundary);
|
|
|
|
//find content length
|
|
Common::String contentLength = "";
|
|
readFromThatUntilLineEnd(headers.c_str(), "Content-Length: ", contentLength);
|
|
_contentLength = contentLength.asUint64();
|
|
_availableBytes = _contentLength;
|
|
debug("BOUNDARY: %s", _boundary.c_str());
|
|
debug("LENGTH: %llu", _contentLength);
|
|
} else {
|
|
//find field name
|
|
_currentFieldName = "";
|
|
readFromThatUntilLineEnd(headers.c_str(), "name=\"", _currentFieldName);
|
|
for (uint32 i = 0; i < _currentFieldName.size(); ++i)
|
|
if (_currentFieldName[i] == '\"') {
|
|
_currentFieldName.erase(i);
|
|
break;
|
|
}
|
|
debug("FIELD NAME: >>%s<<", _currentFieldName.c_str());
|
|
|
|
//find out field type
|
|
_currentFileName = "";
|
|
readFromThatUntilLineEnd(headers.c_str(), "filename=\"", _currentFileName);
|
|
for (uint32 i = 0; i < _currentFileName.size(); ++i)
|
|
if (_currentFileName[i] == '\"') {
|
|
_currentFileName.erase(i);
|
|
break;
|
|
}
|
|
|
|
if (!_currentFileName.empty()) {
|
|
_isFileField = true;
|
|
_queryParameters[_currentFieldName] = _currentFileName;
|
|
debug("FILE NAME: >>%s<<", _currentFileName.c_str());
|
|
} else {
|
|
_isFileField = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Reader::parseFirstLine(const Common::String &headers) {
|
|
uint32 headersSize = headers.size();
|
|
bool bad = false;
|
|
|
|
const uint32 SUSPICIOUS_HEADERS_SIZE = 128 * 1024;
|
|
if (headersSize > SUSPICIOUS_HEADERS_SIZE) bad = true;
|
|
|
|
if (!bad) {
|
|
if (headersSize > 0) {
|
|
const char *cstr = headers.c_str();
|
|
const char *position = strstr(cstr, "\r\n");
|
|
if (position) { //we have at least one line - and we want the first one
|
|
//"<METHOD> <path> HTTP/<VERSION>\r\n"
|
|
Common::String method, path, http, buf;
|
|
uint32 length = position - cstr;
|
|
if (headersSize > length) headersSize = length;
|
|
for (uint32 i = 0; i < headersSize; ++i) {
|
|
if (headers[i] != ' ') buf += headers[i];
|
|
if (headers[i] == ' ' || i == headersSize - 1) {
|
|
if (method == "") method = buf;
|
|
else if (path == "") path = buf;
|
|
else if (http == "") http = buf;
|
|
else {
|
|
bad = true;
|
|
break;
|
|
}
|
|
buf = "";
|
|
}
|
|
}
|
|
|
|
//check that method is supported
|
|
if (method != "GET" && method != "PUT" && method != "POST") bad = true;
|
|
|
|
//check that HTTP/<VERSION> is OK
|
|
if (!http.hasPrefix("HTTP/")) bad = true;
|
|
|
|
_method = method;
|
|
parsePathQueryAndAnchor(path);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bad) _isBadRequest = true;
|
|
}
|
|
|
|
void Reader::parsePathQueryAndAnchor(Common::String path) {
|
|
//<path>[?query][#anchor]
|
|
bool readingPath = true;
|
|
bool readingQuery = false;
|
|
_path = "";
|
|
_query = "";
|
|
_anchor = "";
|
|
for (uint32 i = 0; i < path.size(); ++i) {
|
|
if (readingPath) {
|
|
if (path[i] == '?') {
|
|
readingPath = false;
|
|
readingQuery = true;
|
|
} else _path += path[i];
|
|
} else if (readingQuery) {
|
|
if (path[i] == '#') {
|
|
readingQuery = false;
|
|
} else _query += path[i];
|
|
} else _anchor += path[i];
|
|
}
|
|
|
|
parseQueryParameters();
|
|
}
|
|
|
|
void Reader::parseQueryParameters() {
|
|
Common::String key = "";
|
|
Common::String value = "";
|
|
bool readingKey = true;
|
|
for (uint32 i = 0; i < _query.size(); ++i) {
|
|
if (readingKey) {
|
|
if (_query[i] == '=') {
|
|
readingKey = false;
|
|
value = "";
|
|
} else key += _query[i];
|
|
} else {
|
|
if (_query[i] == '&') {
|
|
if (_queryParameters.contains(key)) warning("Query parameter \"%s\" is already set!", key.c_str());
|
|
else _queryParameters[key] = LocalWebserver::urlDecode(value);
|
|
readingKey = true;
|
|
key = "";
|
|
} else value += _query[i];
|
|
}
|
|
}
|
|
|
|
if (!key.empty()) {
|
|
if (_queryParameters.contains(key)) warning("Query parameter \"%s\" is already set!", key.c_str());
|
|
else _queryParameters[key] = LocalWebserver::urlDecode(value);
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
char generateRandomChar(Common::RandomSource &random) {
|
|
int r = random.getRandomNumber(36);
|
|
char c = '0' + r;
|
|
if (r > 9) c = 'a' + r - 10;
|
|
return c;
|
|
}
|
|
|
|
Common::String generateTempFileName(Common::String originalFilename, Common::RandomSource &random) {
|
|
//generates "./<originalFilename>-<uniqueSequence>.scummtmp"
|
|
//normalize <originalFilename>
|
|
Common::String prefix = "./";
|
|
for (uint32 i = 0; i < originalFilename.size(); ++i) {
|
|
char c = originalFilename[i];
|
|
if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '.' || c == '_' || c == '-') {
|
|
prefix += c;
|
|
} else {
|
|
prefix += '_';
|
|
}
|
|
}
|
|
prefix += '-';
|
|
|
|
//generate initial sequence
|
|
Common::String uniqueSequence;
|
|
for (uint32 i = 0; i < 5; ++i)
|
|
uniqueSequence += generateRandomChar(random);
|
|
|
|
//update sequence while generate path exists
|
|
AbstractFSNode *node;
|
|
Common::String path;
|
|
do {
|
|
uniqueSequence += generateRandomChar(random);
|
|
path = prefix + uniqueSequence + ".scummtmp";
|
|
node = g_system->getFilesystemFactory()->makeFileNodePath(path);
|
|
} while (node->exists());
|
|
|
|
return path;
|
|
}
|
|
}
|
|
|
|
bool Reader::readWholeContent() {
|
|
Common::String boundary = "--" + _boundary;
|
|
if (!_firstBlock) boundary = "\r\n" + boundary;
|
|
if (_window == nullptr) {
|
|
makeWindow(boundary.size());
|
|
|
|
if (_stream) delete _stream;
|
|
if (_isFileField) {
|
|
//create temporary file
|
|
_currentTempFileName = generateTempFileName(_currentFileName, _randomSource);
|
|
AbstractFSNode *node = g_system->getFilesystemFactory()->makeFileNodePath(_currentTempFileName);
|
|
_stream = node->createWriteStream();
|
|
if (_stream == nullptr)
|
|
error("Unable to open temp file to write into!");
|
|
} else {
|
|
_stream = new Common::MemoryReadWriteStream(DisposeAfterUse::YES);
|
|
}
|
|
}
|
|
|
|
while (readOneByteInStream(_stream, boundary)) {
|
|
if (!bytesLeft()) return false;
|
|
}
|
|
|
|
_firstBlock = false;
|
|
if (_isFileField) {
|
|
if (_stream != nullptr) {
|
|
_stream->flush();
|
|
delete _stream;
|
|
_stream = nullptr;
|
|
} else {
|
|
warning("No stream was created!");
|
|
}
|
|
handleFileContent(_currentTempFileName);
|
|
} else {
|
|
Common::MemoryReadWriteStream *dynamicStream = dynamic_cast<Common::MemoryReadWriteStream *>(_stream);
|
|
if (dynamicStream != nullptr)
|
|
if (dynamicStream->size() == 0)
|
|
handleValueContent("");
|
|
else
|
|
handleValueContent(Common::String((char *)dynamicStream->getData(), dynamicStream->size()));
|
|
else
|
|
if (_stream != nullptr)
|
|
warning("Stream somehow changed its type from MemoryReadWriteStream!");
|
|
else
|
|
warning("No stream was created!");
|
|
}
|
|
|
|
freeWindow();
|
|
_state = RS_READING_HEADERS;
|
|
return true;
|
|
}
|
|
|
|
bool Reader::readWholeContentIntoStream(Common::WriteStream *stream) {
|
|
Common::String boundary = "--" + _boundary;
|
|
if (!_firstBlock) boundary = "\r\n" + boundary;
|
|
if (_window == nullptr) makeWindow(boundary.size());
|
|
|
|
while (readOneByteInStream(stream, boundary)) {
|
|
if (!bytesLeft()) return false;
|
|
}
|
|
|
|
_firstBlock = false;
|
|
if (stream) stream->flush();
|
|
|
|
freeWindow();
|
|
_state = RS_READING_HEADERS;
|
|
return true;
|
|
}
|
|
|
|
void Reader::handleFileContent(Common::String filename) {
|
|
debug("\nHANDLE FILE CONTENT:\nFILE >>%s<< SAVED INTO >>%s<<", _currentFileName.c_str(), filename.c_str());
|
|
_attachedFiles[_currentFileName] = filename;
|
|
}
|
|
|
|
void Reader::handleValueContent(Common::String value) {
|
|
debug("\nHANDLE CONTENT:\n>>%s<<", value.c_str());
|
|
_queryParameters[_currentFieldName] = value;
|
|
}
|
|
|
|
void Reader::makeWindow(uint32 size) {
|
|
freeWindow();
|
|
|
|
_window = new byte[size];
|
|
_windowUsed = 0;
|
|
_windowSize = size;
|
|
}
|
|
|
|
void Reader::freeWindow() {
|
|
delete[] _window;
|
|
_window = nullptr;
|
|
_windowUsed = _windowSize = 0;
|
|
}
|
|
|
|
bool Reader::readOneByteInStream(Common::WriteStream *stream, const Common::String &boundary) {
|
|
byte b = readOne();
|
|
_window[_windowUsed++] = b;
|
|
if (_windowUsed < _windowSize) return true;
|
|
|
|
//when window is filled, check whether that's the boundary
|
|
if (Common::String((char *)_window, _windowSize) == boundary)
|
|
return false;
|
|
|
|
//if not, add the first byte of the window to the string
|
|
if (stream) stream->writeByte(_window[0]);
|
|
for (uint32 i = 1; i < _windowSize; ++i)
|
|
_window[i - 1] = _window[i];
|
|
--_windowUsed;
|
|
return true;
|
|
}
|
|
|
|
bool Reader::readOneByteInString(Common::String &buffer, const Common::String &boundary) {
|
|
byte b = readOne();
|
|
_window[_windowUsed++] = b;
|
|
if (_windowUsed < _windowSize) return true;
|
|
|
|
//when window is filled, check whether that's the boundary
|
|
if (Common::String((char *)_window, _windowSize) == boundary)
|
|
return false;
|
|
|
|
//if not, add the first byte of the window to the string
|
|
buffer += _window[0];
|
|
for (uint32 i = 1; i < _windowSize; ++i)
|
|
_window[i - 1] = _window[i];
|
|
--_windowUsed;
|
|
return true;
|
|
}
|
|
|
|
byte Reader::readOne() {
|
|
byte b;
|
|
_content->read(&b, 1);
|
|
--_availableBytes;
|
|
--_bytesLeft;
|
|
return b;
|
|
}
|
|
|
|
uint32 Reader::bytesLeft() { return _bytesLeft; }
|
|
|
|
void Reader::setContent(Common::MemoryReadWriteStream *stream) {
|
|
_content = stream;
|
|
_bytesLeft = stream->size() - stream->pos();
|
|
}
|
|
|
|
bool Reader::badRequest() { return _isBadRequest; }
|
|
|
|
Common::String Reader::method() const { return _method; }
|
|
|
|
Common::String Reader::path() const { return _path; }
|
|
|
|
Common::String Reader::query() const { return _query; }
|
|
|
|
Common::String Reader::queryParameter(Common::String name) const { return _queryParameters[name]; }
|
|
|
|
Common::String Reader::attachedFile(Common::String name) const { return _attachedFiles[name]; }
|
|
|
|
Common::String Reader::anchor() const { return _anchor; }
|
|
|
|
} // End of namespace Networking
|