Http::RequestParser Class Reference

#include <requestparser.h>

Collaboration diagram for Http::RequestParser:

Classes
struct	ParseResult

Public Types
enum class	ParseStatus { OK , Incomplete , BadRequest }

Static Public Member Functions
static ParseResult	parse (const QByteArray &data)

Static Public Attributes
static const long	MAX_CONTENT_SIZE = 64 * 1024 * 1024

Private Member Functions
	RequestParser ()
ParseResult	doParse (const QByteArray &data)
bool	parseStartLines (QStringView data)
bool	parseRequestLine (const QString &line)
bool	parsePostMessage (const QByteArray &data)
bool	parseFormData (const QByteArray &data)

Private Attributes
Request	m_request

Detailed Description

Definition at line 37 of file requestparser.h.

Member Enumeration Documentation

ParseStatus

enum Http::RequestParser::ParseStatus

strong

Enumerator
OK
Incomplete
BadRequest

Definition at line 40 of file requestparser.h.

        {
            OK,
            Incomplete,
            BadRequest
        };

Constructor & Destructor Documentation

RequestParser()

RequestParser::RequestParser ( )

private

Definition at line 78 of file requestparser.cpp.

{
}

Member Function Documentation

doParse()

RequestParser::ParseResult RequestParser::doParse ( const QByteArray &  data )

private

Definition at line 88 of file requestparser.cpp.

{
    // we don't handle malformed requests which use double `LF` as delimiter
    const int headerEnd = data.indexOf(EOH);
    if (headerEnd < 0)
    {
        qDebug() << Q_FUNC_INFO << "incomplete request";
        return {ParseStatus::Incomplete, Request(), 0};
    }
 
    const QString httpHeaders = QString::fromLatin1(data.constData(), headerEnd);
    if (!parseStartLines(httpHeaders))
    {
        qWarning() << Q_FUNC_INFO << "header parsing error";
        return {ParseStatus::BadRequest, Request(), 0};
    }
 
    const int headerLength = headerEnd + EOH.length();
 
    // handle supported methods
    if ((m_request.method == HEADER_REQUEST_METHOD_GET) || (m_request.method == HEADER_REQUEST_METHOD_HEAD))
        return {ParseStatus::OK, m_request, headerLength};
    if (m_request.method == HEADER_REQUEST_METHOD_POST)
    {
        const auto parseContentLength = [this]() -> int
        {
            // [rfc7230] 3.3.2. Content-Length
 
            const QString rawValue = m_request.headers.value(HEADER_CONTENT_LENGTH);
            if (rawValue.isNull())  // `HEADER_CONTENT_LENGTH` does not exist
                return 0;
            return Utils::String::parseInt(rawValue).value_or(-1);
        };
 
        const int contentLength = parseContentLength();
        if (contentLength < 0)
        {
            qWarning() << Q_FUNC_INFO << "bad request: content-length invalid";
            return {ParseStatus::BadRequest, Request(), 0};
        }
        if (contentLength > MAX_CONTENT_SIZE)
        {
            qWarning() << Q_FUNC_INFO << "bad request: message too long";
            return {ParseStatus::BadRequest, Request(), 0};
        }
 
        if (contentLength > 0)
        {
            const QByteArray httpBodyView = midView(data, headerLength, contentLength);
            if (httpBodyView.length() < contentLength)
            {
                qDebug() << Q_FUNC_INFO << "incomplete request";
                return {ParseStatus::Incomplete, Request(), 0};
            }
 
            if (!parsePostMessage(httpBodyView))
            {
                qWarning() << Q_FUNC_INFO << "message body parsing error";
                return {ParseStatus::BadRequest, Request(), 0};
            }
        }
 
        return {ParseStatus::OK, m_request, (headerLength + contentLength)};
    }
 
    qWarning() << Q_FUNC_INFO << "unsupported request method: " << m_request.method;
    return {ParseStatus::BadRequest, Request(), 0};  // TODO: SHOULD respond "501 Not Implemented"
}

References anonymous_namespace{requestparser.cpp}::EOH, Http::HEADER_CONTENT_LENGTH, Http::HEADER_REQUEST_METHOD_GET, Http::HEADER_REQUEST_METHOD_HEAD, Http::HEADER_REQUEST_METHOD_POST, Http::Request::method, Utils::ByteArray::midView(), and Utils::String::parseInt().

Referenced by parse().

Here is the call graph for this function:

Here is the caller graph for this function:

parse()

RequestParser::ParseResult RequestParser::parse ( const QByteArray &  data )

static

Definition at line 82 of file requestparser.cpp.

{
    // Warning! Header names are converted to lowercase
    return RequestParser().doParse(data);
}

References doParse().

Referenced by Http::Connection::read().

Here is the call graph for this function:

Here is the caller graph for this function:

parseFormData()

bool RequestParser::parseFormData ( const QByteArray &  data )

private

Definition at line 309 of file requestparser.cpp.

{
    const QVector<QByteArray> list = splitToViews(data, EOH, Qt::KeepEmptyParts);
 
    if (list.size() != 2)
    {
        qWarning() << Q_FUNC_INFO << "multipart/form-data format error";
        return false;
    }
 
    const QString headers = QString::fromLatin1(list[0]);
    const QByteArray payload = viewWithoutEndingWith(list[1], CRLF);
 
    HeaderMap headersMap;
    const QList<QStringView> headerLines = QStringView(headers).split(QString::fromLatin1(CRLF), Qt::SkipEmptyParts);
    for (const auto &line : headerLines)
    {
        if (line.trimmed().startsWith(QString::fromLatin1(HEADER_CONTENT_DISPOSITION), Qt::CaseInsensitive))
        {
            // extract out filename & name
            const QList<QStringView> directives = line.split(u';', Qt::SkipEmptyParts);
 
            for (const auto &directive : directives)
            {
                const int idx = directive.indexOf('=');
                if (idx < 0)
                    continue;
 
                const QString name = directive.left(idx).trimmed().toString().toLower();
                const QString value = Utils::String::unquote(directive.mid(idx + 1).trimmed()).toString();
                headersMap[name] = value;
            }
        }
        else
        {
            if (!parseHeaderLine(line.toString(), headersMap))
                return false;
        }
    }
 
    // pick data
    const QLatin1String filename("filename");
    const QLatin1String name("name");
 
    if (headersMap.contains(filename))
    {
        m_request.files.append({headersMap[filename], headersMap[HEADER_CONTENT_TYPE], payload});
    }
    else if (headersMap.contains(name))
    {
        m_request.posts[headersMap[name]] = payload;
    }
    else
    {
        // malformed
        qWarning() << Q_FUNC_INFO << "multipart/form-data header error";
        return false;
    }
 
    return true;
}

References Http::CRLF, anonymous_namespace{requestparser.cpp}::EOH, Http::HEADER_CONTENT_DISPOSITION, Http::HEADER_CONTENT_TYPE, nova3.helpers::headers, anonymous_namespace{requestparser.cpp}::parseHeaderLine(), Utils::ByteArray::splitToViews(), Utils::String::unquote(), anonymous_namespace{preferences.cpp}::value(), and anonymous_namespace{requestparser.cpp}::viewWithoutEndingWith().

Here is the call graph for this function:

parsePostMessage()

bool RequestParser::parsePostMessage ( const QByteArray &  data )

private

Definition at line 243 of file requestparser.cpp.

{
    // parse POST message-body
    const QString contentType = m_request.headers[HEADER_CONTENT_TYPE];
    const QString contentTypeLower = contentType.toLower();
 
    // application/x-www-form-urlencoded
    if (contentTypeLower.startsWith(CONTENT_TYPE_FORM_ENCODED))
    {
        // [URL Standard] 5.1 application/x-www-form-urlencoded parsing
        const QByteArray processedData = QByteArray(data).replace('+', ' ');
 
        QListIterator<QStringPair> i(QUrlQuery(processedData).queryItems(QUrl::FullyDecoded));
        while (i.hasNext())
        {
            const QStringPair pair = i.next();
            m_request.posts[pair.first] = pair.second;
        }
 
        return true;
    }
 
    // multipart/form-data
    if (contentTypeLower.startsWith(CONTENT_TYPE_FORM_DATA))
    {
        // [rfc2046] 5.1.1. Common Syntax
 
        // find boundary delimiter
        const QLatin1String boundaryFieldName("boundary=");
        const int idx = contentType.indexOf(boundaryFieldName);
        if (idx < 0)
        {
            qWarning() << Q_FUNC_INFO << "Could not find boundary in multipart/form-data header!";
            return false;
        }
 
        const QByteArray delimiter = Utils::String::unquote(QStringView(contentType).mid(idx + boundaryFieldName.size())).toLatin1();
        if (delimiter.isEmpty())
        {
            qWarning() << Q_FUNC_INFO << "boundary delimiter field empty!";
            return false;
        }
 
        // split data by "dash-boundary"
        const QByteArray dashDelimiter = QByteArray("--") + delimiter + CRLF;
        QVector<QByteArray> multipart = splitToViews(data, dashDelimiter, Qt::SkipEmptyParts);
        if (multipart.isEmpty())
        {
            qWarning() << Q_FUNC_INFO << "multipart empty";
            return false;
        }
 
        // remove the ending delimiter
        const QByteArray endDelimiter = QByteArray("--") + delimiter + QByteArray("--") + CRLF;
        multipart.push_back(viewWithoutEndingWith(multipart.takeLast(), endDelimiter));
 
        return std::all_of(multipart.cbegin(), multipart.cend(), [this](const QByteArray &part)
        {
            return this->parseFormData(part);
        });
    }
 
    qWarning() << Q_FUNC_INFO << "unknown content type:" << contentType;
    return false;
}

References Http::CONTENT_TYPE_FORM_DATA, Http::CONTENT_TYPE_FORM_ENCODED, Http::CRLF, Http::HEADER_CONTENT_TYPE, Utils::ByteArray::splitToViews(), Utils::String::unquote(), and anonymous_namespace{requestparser.cpp}::viewWithoutEndingWith().

Here is the call graph for this function:

parseRequestLine()

bool RequestParser::parseRequestLine ( const QString &  line )

private

Definition at line 192 of file requestparser.cpp.

{
    // [rfc7230] 3.1.1. Request Line
 
    const QRegularExpression re(QLatin1String("^([A-Z]+)\\s+(\\S+)\\s+HTTP\\/(\\d\\.\\d)$"));
    const QRegularExpressionMatch match = re.match(line);
 
    if (!match.hasMatch())
    {
        qWarning() << Q_FUNC_INFO << "invalid http header:" << line;
        return false;
    }
 
    // Request Methods
    m_request.method = match.captured(1);
 
    // Request Target
    const QByteArray url {match.captured(2).toLatin1()};
    const int sepPos = url.indexOf('?');
    const QByteArray pathComponent = ((sepPos == -1) ? url : midView(url, 0, sepPos));
 
    m_request.path = QString::fromUtf8(QByteArray::fromPercentEncoding(pathComponent));
 
    if (sepPos >= 0)
    {
        const QByteArray query = midView(url, (sepPos + 1));
 
        // [rfc3986] 2.4 When to Encode or Decode
        // URL components should be separated before percent-decoding
        for (const QByteArray &param : asConst(splitToViews(query, "&")))
        {
            const int eqCharPos = param.indexOf('=');
            if (eqCharPos <= 0) continue;  // ignores params without name
 
            const QByteArray nameComponent = midView(param, 0, eqCharPos);
            const QByteArray valueComponent = midView(param, (eqCharPos + 1));
            const QString paramName = QString::fromUtf8(QByteArray::fromPercentEncoding(nameComponent).replace('+', ' '));
            const QByteArray paramValue = valueComponent.isNull()
                ? QByteArray("")
                : QByteArray::fromPercentEncoding(valueComponent).replace('+', ' ');
 
            m_request.query[paramName] = paramValue;
        }
    }
 
    // HTTP-version
    m_request.version = match.captured(3);
 
    return true;
}

References asConst(), Utils::ByteArray::midView(), and Utils::ByteArray::splitToViews().

Here is the call graph for this function:

parseStartLines()

bool RequestParser::parseStartLines ( QStringView  data )

private

Definition at line 157 of file requestparser.cpp.

{
    // we don't handle malformed request which uses `LF` for newline
    const QList<QStringView> lines = data.split(QString::fromLatin1(CRLF), Qt::SkipEmptyParts);
 
    // [rfc7230] 3.2.2. Field Order
    QStringList requestLines;
    for (const auto &line : lines)
    {
        if (line.at(0).isSpace() && !requestLines.isEmpty())
        {
            // continuation of previous line
            requestLines.last() += line.toString();
        }
        else
        {
            requestLines += line.toString();
        }
    }
 
    if (requestLines.isEmpty())
        return false;
 
    if (!parseRequestLine(requestLines[0]))
        return false;
 
    for (auto i = ++(requestLines.begin()); i != requestLines.end(); ++i)
    {
        if (!parseHeaderLine(*i, m_request.headers))
            return false;
    }
 
    return true;
}

References Http::CRLF, and anonymous_namespace{requestparser.cpp}::parseHeaderLine().

Here is the call graph for this function:

Member Data Documentation

m_request

Request Http::RequestParser::m_request

private

Definition at line 69 of file requestparser.h.

MAX_CONTENT_SIZE

const long Http::RequestParser::MAX_CONTENT_SIZE = 64 * 1024 * 1024

static

Definition at line 57 of file requestparser.h.

Referenced by Http::Connection::read().

---

The documentation for this class was generated from the following files:

• src/base/http/requestparser.h
• src/base/http/requestparser.cpp