| | #cython: language_level=3 |
| | # |
| | # Based on https://github.com/MagicStack/httptools |
| | # |
| |
|
| | from cpython cimport ( |
| | Py_buffer, |
| | PyBUF_SIMPLE, |
| | PyBuffer_Release, |
| | PyBytes_AsString, |
| | PyBytes_AsStringAndSize, |
| | PyObject_GetBuffer, |
| | ) |
| | from cpython.mem cimport PyMem_Free, PyMem_Malloc |
| | from libc.limits cimport ULLONG_MAX |
| | from libc.string cimport memcpy |
| |
|
| | from multidict import CIMultiDict as _CIMultiDict, CIMultiDictProxy as _CIMultiDictProxy |
| | from yarl import URL as _URL |
| |
|
| | from aiohttp import hdrs |
| | from aiohttp.helpers import DEBUG, set_exception |
| |
|
| | from .http_exceptions import ( |
| | BadHttpMessage, |
| | BadHttpMethod, |
| | BadStatusLine, |
| | ContentLengthError, |
| | InvalidHeader, |
| | InvalidURLError, |
| | LineTooLong, |
| | PayloadEncodingError, |
| | TransferEncodingError, |
| | ) |
| | from .http_parser import DeflateBuffer as _DeflateBuffer |
| | from .http_writer import ( |
| | HttpVersion as _HttpVersion, |
| | HttpVersion10 as _HttpVersion10, |
| | HttpVersion11 as _HttpVersion11, |
| | ) |
| | from .streams import EMPTY_PAYLOAD as _EMPTY_PAYLOAD, StreamReader as _StreamReader |
| |
|
| | cimport cython |
| |
|
| | from aiohttp cimport _cparser as cparser |
| |
|
| | include "_headers.pxi" |
| |
|
| | from aiohttp cimport _find_header |
| |
|
| | ALLOWED_UPGRADES = frozenset({"websocket"}) |
| | DEF DEFAULT_FREELIST_SIZE = 250 |
| |
|
| | cdef extern from "Python.h": |
| | int PyByteArray_Resize(object, Py_ssize_t) except -1 |
| | Py_ssize_t PyByteArray_Size(object) except -1 |
| | char* PyByteArray_AsString(object) |
| |
|
| | __all__ = ('HttpRequestParser', 'HttpResponseParser', |
| | 'RawRequestMessage', 'RawResponseMessage') |
| |
|
| | cdef object URL = _URL |
| | cdef object URL_build = URL.build |
| | cdef object CIMultiDict = _CIMultiDict |
| | cdef object CIMultiDictProxy = _CIMultiDictProxy |
| | cdef object HttpVersion = _HttpVersion |
| | cdef object HttpVersion10 = _HttpVersion10 |
| | cdef object HttpVersion11 = _HttpVersion11 |
| | cdef object SEC_WEBSOCKET_KEY1 = hdrs.SEC_WEBSOCKET_KEY1 |
| | cdef object CONTENT_ENCODING = hdrs.CONTENT_ENCODING |
| | cdef object EMPTY_PAYLOAD = _EMPTY_PAYLOAD |
| | cdef object StreamReader = _StreamReader |
| | cdef object DeflateBuffer = _DeflateBuffer |
| | cdef bytes EMPTY_BYTES = b"" |
| |
|
| | cdef inline object extend(object buf, const char* at, size_t length): |
| | cdef Py_ssize_t s |
| | cdef char* ptr |
| | s = PyByteArray_Size(buf) |
| | PyByteArray_Resize(buf, s + length) |
| | ptr = PyByteArray_AsString(buf) |
| | memcpy(ptr + s, at, length) |
| |
|
| |
|
| | DEF METHODS_COUNT = 46; |
| |
|
| | cdef list _http_method = [] |
| |
|
| | for i in range(METHODS_COUNT): |
| | _http_method.append( |
| | cparser.llhttp_method_name(<cparser.llhttp_method_t> i).decode('ascii')) |
| |
|
| |
|
| | cdef inline str http_method_str(int i): |
| | if i < METHODS_COUNT: |
| | return <str>_http_method[i] |
| | else: |
| | return "<unknown>" |
| |
|
| | cdef inline object find_header(bytes raw_header): |
| | cdef Py_ssize_t size |
| | cdef char *buf |
| | cdef int idx |
| | PyBytes_AsStringAndSize(raw_header, &buf, &size) |
| | idx = _find_header.find_header(buf, size) |
| | if idx == -1: |
| | return raw_header.decode('utf-8', 'surrogateescape') |
| | return headers[idx] |
| |
|
| |
|
| | @cython.freelist(DEFAULT_FREELIST_SIZE) |
| | cdef class RawRequestMessage: |
| | cdef readonly str method |
| | cdef readonly str path |
| | cdef readonly object version # HttpVersion |
| | cdef readonly object headers # CIMultiDict |
| | cdef readonly object raw_headers # tuple |
| | cdef readonly object should_close |
| | cdef readonly object compression |
| | cdef readonly object upgrade |
| | cdef readonly object chunked |
| | cdef readonly object url # yarl.URL |
| |
|
| | def __init__(self, method, path, version, headers, raw_headers, |
| | should_close, compression, upgrade, chunked, url): |
| | self.method = method |
| | self.path = path |
| | self.version = version |
| | self.headers = headers |
| | self.raw_headers = raw_headers |
| | self.should_close = should_close |
| | self.compression = compression |
| | self.upgrade = upgrade |
| | self.chunked = chunked |
| | self.url = url |
| |
|
| | def __repr__(self): |
| | info = [] |
| | info.append(("method", self.method)) |
| | info.append(("path", self.path)) |
| | info.append(("version", self.version)) |
| | info.append(("headers", self.headers)) |
| | info.append(("raw_headers", self.raw_headers)) |
| | info.append(("should_close", self.should_close)) |
| | info.append(("compression", self.compression)) |
| | info.append(("upgrade", self.upgrade)) |
| | info.append(("chunked", self.chunked)) |
| | info.append(("url", self.url)) |
| | sinfo = ', '.join(name + '=' + repr(val) for name, val in info) |
| | return '<RawRequestMessage(' + sinfo + ')>' |
| |
|
| | def _replace(self, **dct): |
| | cdef RawRequestMessage ret |
| | ret = _new_request_message(self.method, |
| | self.path, |
| | self.version, |
| | self.headers, |
| | self.raw_headers, |
| | self.should_close, |
| | self.compression, |
| | self.upgrade, |
| | self.chunked, |
| | self.url) |
| | if "method" in dct: |
| | ret.method = dct["method"] |
| | if "path" in dct: |
| | ret.path = dct["path"] |
| | if "version" in dct: |
| | ret.version = dct["version"] |
| | if "headers" in dct: |
| | ret.headers = dct["headers"] |
| | if "raw_headers" in dct: |
| | ret.raw_headers = dct["raw_headers"] |
| | if "should_close" in dct: |
| | ret.should_close = dct["should_close"] |
| | if "compression" in dct: |
| | ret.compression = dct["compression"] |
| | if "upgrade" in dct: |
| | ret.upgrade = dct["upgrade"] |
| | if "chunked" in dct: |
| | ret.chunked = dct["chunked"] |
| | if "url" in dct: |
| | ret.url = dct["url"] |
| | return ret |
| |
|
| | cdef _new_request_message(str method, |
| | str path, |
| | object version, |
| | object headers, |
| | object raw_headers, |
| | bint should_close, |
| | object compression, |
| | bint upgrade, |
| | bint chunked, |
| | object url): |
| | cdef RawRequestMessage ret |
| | ret = RawRequestMessage.__new__(RawRequestMessage) |
| | ret.method = method |
| | ret.path = path |
| | ret.version = version |
| | ret.headers = headers |
| | ret.raw_headers = raw_headers |
| | ret.should_close = should_close |
| | ret.compression = compression |
| | ret.upgrade = upgrade |
| | ret.chunked = chunked |
| | ret.url = url |
| | return ret |
| |
|
| |
|
| | @cython.freelist(DEFAULT_FREELIST_SIZE) |
| | cdef class RawResponseMessage: |
| | cdef readonly object version # HttpVersion |
| | cdef readonly int code |
| | cdef readonly str reason |
| | cdef readonly object headers # CIMultiDict |
| | cdef readonly object raw_headers # tuple |
| | cdef readonly object should_close |
| | cdef readonly object compression |
| | cdef readonly object upgrade |
| | cdef readonly object chunked |
| |
|
| | def __init__(self, version, code, reason, headers, raw_headers, |
| | should_close, compression, upgrade, chunked): |
| | self.version = version |
| | self.code = code |
| | self.reason = reason |
| | self.headers = headers |
| | self.raw_headers = raw_headers |
| | self.should_close = should_close |
| | self.compression = compression |
| | self.upgrade = upgrade |
| | self.chunked = chunked |
| |
|
| | def __repr__(self): |
| | info = [] |
| | info.append(("version", self.version)) |
| | info.append(("code", self.code)) |
| | info.append(("reason", self.reason)) |
| | info.append(("headers", self.headers)) |
| | info.append(("raw_headers", self.raw_headers)) |
| | info.append(("should_close", self.should_close)) |
| | info.append(("compression", self.compression)) |
| | info.append(("upgrade", self.upgrade)) |
| | info.append(("chunked", self.chunked)) |
| | sinfo = ', '.join(name + '=' + repr(val) for name, val in info) |
| | return '<RawResponseMessage(' + sinfo + ')>' |
| |
|
| |
|
| | cdef _new_response_message(object version, |
| | int code, |
| | str reason, |
| | object headers, |
| | object raw_headers, |
| | bint should_close, |
| | object compression, |
| | bint upgrade, |
| | bint chunked): |
| | cdef RawResponseMessage ret |
| | ret = RawResponseMessage.__new__(RawResponseMessage) |
| | ret.version = version |
| | ret.code = code |
| | ret.reason = reason |
| | ret.headers = headers |
| | ret.raw_headers = raw_headers |
| | ret.should_close = should_close |
| | ret.compression = compression |
| | ret.upgrade = upgrade |
| | ret.chunked = chunked |
| | return ret |
| |
|
| |
|
| | @cython.internal |
| | cdef class HttpParser: |
| |
|
| | cdef: |
| | cparser.llhttp_t* _cparser |
| | cparser.llhttp_settings_t* _csettings |
| |
|
| | bytes _raw_name |
| | object _name |
| | bytes _raw_value |
| | bint _has_value |
| |
|
| | object _protocol |
| | object _loop |
| | object _timer |
| |
|
| | size_t _max_line_size |
| | size_t _max_field_size |
| | size_t _max_headers |
| | bint _response_with_body |
| | bint _read_until_eof |
| |
|
| | bint _started |
| | object _url |
| | bytearray _buf |
| | str _path |
| | str _reason |
| | list _headers |
| | list _raw_headers |
| | bint _upgraded |
| | list _messages |
| | object _payload |
| | bint _payload_error |
| | object _payload_exception |
| | object _last_error |
| | bint _auto_decompress |
| | int _limit |
| |
|
| | str _content_encoding |
| |
|
| | Py_buffer py_buf |
| |
|
| | def __cinit__(self): |
| | self._cparser = <cparser.llhttp_t*> \ |
| | PyMem_Malloc(sizeof(cparser.llhttp_t)) |
| | if self._cparser is NULL: |
| | raise MemoryError() |
| |
|
| | self._csettings = <cparser.llhttp_settings_t*> \ |
| | PyMem_Malloc(sizeof(cparser.llhttp_settings_t)) |
| | if self._csettings is NULL: |
| | raise MemoryError() |
| |
|
| | def __dealloc__(self): |
| | PyMem_Free(self._cparser) |
| | PyMem_Free(self._csettings) |
| |
|
| | cdef _init( |
| | self, cparser.llhttp_type mode, |
| | object protocol, object loop, int limit, |
| | object timer=None, |
| | size_t max_line_size=8190, size_t max_headers=32768, |
| | size_t max_field_size=8190, payload_exception=None, |
| | bint response_with_body=True, bint read_until_eof=False, |
| | bint auto_decompress=True, |
| | ): |
| | cparser.llhttp_settings_init(self._csettings) |
| | cparser.llhttp_init(self._cparser, mode, self._csettings) |
| | self._cparser.data = <void*>self |
| | self._cparser.content_length = 0 |
| |
|
| | self._protocol = protocol |
| | self._loop = loop |
| | self._timer = timer |
| |
|
| | self._buf = bytearray() |
| | self._payload = None |
| | self._payload_error = 0 |
| | self._payload_exception = payload_exception |
| | self._messages = [] |
| |
|
| | self._raw_name = EMPTY_BYTES |
| | self._raw_value = EMPTY_BYTES |
| | self._has_value = False |
| |
|
| | self._max_line_size = max_line_size |
| | self._max_headers = max_headers |
| | self._max_field_size = max_field_size |
| | self._response_with_body = response_with_body |
| | self._read_until_eof = read_until_eof |
| | self._upgraded = False |
| | self._auto_decompress = auto_decompress |
| | self._content_encoding = None |
| |
|
| | self._csettings.on_url = cb_on_url |
| | self._csettings.on_status = cb_on_status |
| | self._csettings.on_header_field = cb_on_header_field |
| | self._csettings.on_header_value = cb_on_header_value |
| | self._csettings.on_headers_complete = cb_on_headers_complete |
| | self._csettings.on_body = cb_on_body |
| | self._csettings.on_message_begin = cb_on_message_begin |
| | self._csettings.on_message_complete = cb_on_message_complete |
| | self._csettings.on_chunk_header = cb_on_chunk_header |
| | self._csettings.on_chunk_complete = cb_on_chunk_complete |
| |
|
| | self._last_error = None |
| | self._limit = limit |
| |
|
| | cdef _process_header(self): |
| | cdef str value |
| | if self._raw_name is not EMPTY_BYTES: |
| | name = find_header(self._raw_name) |
| | value = self._raw_value.decode('utf-8', 'surrogateescape') |
| |
|
| | self._headers.append((name, value)) |
| |
|
| | if name is CONTENT_ENCODING: |
| | self._content_encoding = value |
| |
|
| | self._has_value = False |
| | self._raw_headers.append((self._raw_name, self._raw_value)) |
| | self._raw_name = EMPTY_BYTES |
| | self._raw_value = EMPTY_BYTES |
| |
|
| | cdef _on_header_field(self, char* at, size_t length): |
| | if self._has_value: |
| | self._process_header() |
| |
|
| | if self._raw_name is EMPTY_BYTES: |
| | self._raw_name = at[:length] |
| | else: |
| | self._raw_name += at[:length] |
| |
|
| | cdef _on_header_value(self, char* at, size_t length): |
| | if self._raw_value is EMPTY_BYTES: |
| | self._raw_value = at[:length] |
| | else: |
| | self._raw_value += at[:length] |
| | self._has_value = True |
| |
|
| | cdef _on_headers_complete(self): |
| | self._process_header() |
| |
|
| | should_close = not cparser.llhttp_should_keep_alive(self._cparser) |
| | upgrade = self._cparser.upgrade |
| | chunked = self._cparser.flags & cparser.F_CHUNKED |
| |
|
| | raw_headers = tuple(self._raw_headers) |
| | headers = CIMultiDictProxy(CIMultiDict(self._headers)) |
| |
|
| | if self._cparser.type == cparser.HTTP_REQUEST: |
| | allowed = upgrade and headers.get("upgrade", "").lower() in ALLOWED_UPGRADES |
| | if allowed or self._cparser.method == cparser.HTTP_CONNECT: |
| | self._upgraded = True |
| | else: |
| | if upgrade and self._cparser.status_code == 101: |
| | self._upgraded = True |
| |
|
| | # do not support old websocket spec |
| | if SEC_WEBSOCKET_KEY1 in headers: |
| | raise InvalidHeader(SEC_WEBSOCKET_KEY1) |
| |
|
| | encoding = None |
| | enc = self._content_encoding |
| | if enc is not None: |
| | self._content_encoding = None |
| | enc = enc.lower() |
| | if enc in ('gzip', 'deflate', 'br'): |
| | encoding = enc |
| |
|
| | if self._cparser.type == cparser.HTTP_REQUEST: |
| | method = http_method_str(self._cparser.method) |
| | msg = _new_request_message( |
| | method, self._path, |
| | self.http_version(), headers, raw_headers, |
| | should_close, encoding, upgrade, chunked, self._url) |
| | else: |
| | msg = _new_response_message( |
| | self.http_version(), self._cparser.status_code, self._reason, |
| | headers, raw_headers, should_close, encoding, |
| | upgrade, chunked) |
| |
|
| | if ( |
| | ULLONG_MAX > self._cparser.content_length > 0 or chunked or |
| | self._cparser.method == cparser.HTTP_CONNECT or |
| | (self._cparser.status_code >= 199 and |
| | self._cparser.content_length == 0 and |
| | self._read_until_eof) |
| | ): |
| | payload = StreamReader( |
| | self._protocol, timer=self._timer, loop=self._loop, |
| | limit=self._limit) |
| | else: |
| | payload = EMPTY_PAYLOAD |
| |
|
| | self._payload = payload |
| | if encoding is not None and self._auto_decompress: |
| | self._payload = DeflateBuffer(payload, encoding) |
| |
|
| | if not self._response_with_body: |
| | payload = EMPTY_PAYLOAD |
| |
|
| | self._messages.append((msg, payload)) |
| |
|
| | cdef _on_message_complete(self): |
| | self._payload.feed_eof() |
| | self._payload = None |
| |
|
| | cdef _on_chunk_header(self): |
| | self._payload.begin_http_chunk_receiving() |
| |
|
| | cdef _on_chunk_complete(self): |
| | self._payload.end_http_chunk_receiving() |
| |
|
| | cdef object _on_status_complete(self): |
| | pass |
| |
|
| | cdef inline http_version(self): |
| | cdef cparser.llhttp_t* parser = self._cparser |
| |
|
| | if parser.http_major == 1: |
| | if parser.http_minor == 0: |
| | return HttpVersion10 |
| | elif parser.http_minor == 1: |
| | return HttpVersion11 |
| |
|
| | return HttpVersion(parser.http_major, parser.http_minor) |
| |
|
| | ### Public API ### |
| |
|
| | def feed_eof(self): |
| | cdef bytes desc |
| |
|
| | if self._payload is not None: |
| | if self._cparser.flags & cparser.F_CHUNKED: |
| | raise TransferEncodingError( |
| | "Not enough data for satisfy transfer length header.") |
| | elif self._cparser.flags & cparser.F_CONTENT_LENGTH: |
| | raise ContentLengthError( |
| | "Not enough data for satisfy content length header.") |
| | elif cparser.llhttp_get_errno(self._cparser) != cparser.HPE_OK: |
| | desc = cparser.llhttp_get_error_reason(self._cparser) |
| | raise PayloadEncodingError(desc.decode('latin-1')) |
| | else: |
| | self._payload.feed_eof() |
| | elif self._started: |
| | self._on_headers_complete() |
| | if self._messages: |
| | return self._messages[-1][0] |
| |
|
| | def feed_data(self, data): |
| | cdef: |
| | size_t data_len |
| | size_t nb |
| | cdef cparser.llhttp_errno_t errno |
| |
|
| | PyObject_GetBuffer(data, &self.py_buf, PyBUF_SIMPLE) |
| | data_len = <size_t>self.py_buf.len |
| |
|
| | errno = cparser.llhttp_execute( |
| | self._cparser, |
| | <char*>self.py_buf.buf, |
| | data_len) |
| |
|
| | if errno is cparser.HPE_PAUSED_UPGRADE: |
| | cparser.llhttp_resume_after_upgrade(self._cparser) |
| |
|
| | nb = cparser.llhttp_get_error_pos(self._cparser) - <char*>self.py_buf.buf |
| |
|
| | PyBuffer_Release(&self.py_buf) |
| |
|
| | if errno not in (cparser.HPE_OK, cparser.HPE_PAUSED_UPGRADE): |
| | if self._payload_error == 0: |
| | if self._last_error is not None: |
| | ex = self._last_error |
| | self._last_error = None |
| | else: |
| | after = cparser.llhttp_get_error_pos(self._cparser) |
| | before = data[:after - <char*>self.py_buf.buf] |
| | after_b = after.split(b"\r\n", 1)[0] |
| | before = before.rsplit(b"\r\n", 1)[-1] |
| | data = before + after_b |
| | pointer = " " * (len(repr(before))-1) + "^" |
| | ex = parser_error_from_errno(self._cparser, data, pointer) |
| | self._payload = None |
| | raise ex |
| |
|
| | if self._messages: |
| | messages = self._messages |
| | self._messages = [] |
| | else: |
| | messages = () |
| |
|
| | if self._upgraded: |
| | return messages, True, data[nb:] |
| | else: |
| | return messages, False, b"" |
| |
|
| | def set_upgraded(self, val): |
| | self._upgraded = val |
| |
|
| |
|
| | cdef class HttpRequestParser(HttpParser): |
| |
|
| | def __init__( |
| | self, protocol, loop, int limit, timer=None, |
| | size_t max_line_size=8190, size_t max_headers=32768, |
| | size_t max_field_size=8190, payload_exception=None, |
| | bint response_with_body=True, bint read_until_eof=False, |
| | bint auto_decompress=True, |
| | ): |
| | self._init(cparser.HTTP_REQUEST, protocol, loop, limit, timer, |
| | max_line_size, max_headers, max_field_size, |
| | payload_exception, response_with_body, read_until_eof, |
| | auto_decompress) |
| |
|
| | cdef object _on_status_complete(self): |
| | cdef int idx1, idx2 |
| | if not self._buf: |
| | return |
| | self._path = self._buf.decode('utf-8', 'surrogateescape') |
| | try: |
| | idx3 = len(self._path) |
| | if self._cparser.method == cparser.HTTP_CONNECT: |
| | # authority-form, |
| | # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.3 |
| | self._url = URL.build(authority=self._path, encoded=True) |
| | elif idx3 > 1 and self._path[0] == '/': |
| | # origin-form, |
| | # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.1 |
| | idx1 = self._path.find("?") |
| | if idx1 == -1: |
| | query = "" |
| | idx2 = self._path.find("#") |
| | if idx2 == -1: |
| | path = self._path |
| | fragment = "" |
| | else: |
| | path = self._path[0: idx2] |
| | fragment = self._path[idx2+1:] |
| |
|
| | else: |
| | path = self._path[0:idx1] |
| | idx1 += 1 |
| | idx2 = self._path.find("#", idx1+1) |
| | if idx2 == -1: |
| | query = self._path[idx1:] |
| | fragment = "" |
| | else: |
| | query = self._path[idx1: idx2] |
| | fragment = self._path[idx2+1:] |
| |
|
| | self._url = URL.build( |
| | path=path, |
| | query_string=query, |
| | fragment=fragment, |
| | encoded=True, |
| | ) |
| | else: |
| | # absolute-form for proxy maybe, |
| | # https://datatracker.ietf.org/doc/html/rfc7230#section-5.3.2 |
| | self._url = URL(self._path, encoded=True) |
| | finally: |
| | PyByteArray_Resize(self._buf, 0) |
| |
|
| |
|
| | cdef class HttpResponseParser(HttpParser): |
| |
|
| | def __init__( |
| | self, protocol, loop, int limit, timer=None, |
| | size_t max_line_size=8190, size_t max_headers=32768, |
| | size_t max_field_size=8190, payload_exception=None, |
| | bint response_with_body=True, bint read_until_eof=False, |
| | bint auto_decompress=True |
| | ): |
| | self._init(cparser.HTTP_RESPONSE, protocol, loop, limit, timer, |
| | max_line_size, max_headers, max_field_size, |
| | payload_exception, response_with_body, read_until_eof, |
| | auto_decompress) |
| | # Use strict parsing on dev mode, so users are warned about broken servers. |
| | if not DEBUG: |
| | cparser.llhttp_set_lenient_headers(self._cparser, 1) |
| | cparser.llhttp_set_lenient_optional_cr_before_lf(self._cparser, 1) |
| | cparser.llhttp_set_lenient_spaces_after_chunk_size(self._cparser, 1) |
| |
|
| | cdef object _on_status_complete(self): |
| | if self._buf: |
| | self._reason = self._buf.decode('utf-8', 'surrogateescape') |
| | PyByteArray_Resize(self._buf, 0) |
| | else: |
| | self._reason = self._reason or '' |
| |
|
| | cdef int cb_on_message_begin(cparser.llhttp_t* parser) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| |
|
| | pyparser._started = True |
| | pyparser._headers = [] |
| | pyparser._raw_headers = [] |
| | PyByteArray_Resize(pyparser._buf, 0) |
| | pyparser._path = None |
| | pyparser._reason = None |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_url(cparser.llhttp_t* parser, |
| | const char *at, size_t length) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | try: |
| | if length > pyparser._max_line_size: |
| | raise LineTooLong( |
| | 'Status line is too long', pyparser._max_line_size, length) |
| | extend(pyparser._buf, at, length) |
| | except BaseException as ex: |
| | pyparser._last_error = ex |
| | return -1 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_status(cparser.llhttp_t* parser, |
| | const char *at, size_t length) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | cdef str reason |
| | try: |
| | if length > pyparser._max_line_size: |
| | raise LineTooLong( |
| | 'Status line is too long', pyparser._max_line_size, length) |
| | extend(pyparser._buf, at, length) |
| | except BaseException as ex: |
| | pyparser._last_error = ex |
| | return -1 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_header_field(cparser.llhttp_t* parser, |
| | const char *at, size_t length) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | cdef Py_ssize_t size |
| | try: |
| | pyparser._on_status_complete() |
| | size = len(pyparser._raw_name) + length |
| | if size > pyparser._max_field_size: |
| | raise LineTooLong( |
| | 'Header name is too long', pyparser._max_field_size, size) |
| | pyparser._on_header_field(at, length) |
| | except BaseException as ex: |
| | pyparser._last_error = ex |
| | return -1 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_header_value(cparser.llhttp_t* parser, |
| | const char *at, size_t length) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | cdef Py_ssize_t size |
| | try: |
| | size = len(pyparser._raw_value) + length |
| | if size > pyparser._max_field_size: |
| | raise LineTooLong( |
| | 'Header value is too long', pyparser._max_field_size, size) |
| | pyparser._on_header_value(at, length) |
| | except BaseException as ex: |
| | pyparser._last_error = ex |
| | return -1 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_headers_complete(cparser.llhttp_t* parser) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | try: |
| | pyparser._on_status_complete() |
| | pyparser._on_headers_complete() |
| | except BaseException as exc: |
| | pyparser._last_error = exc |
| | return -1 |
| | else: |
| | if pyparser._upgraded or pyparser._cparser.method == cparser.HTTP_CONNECT: |
| | return 2 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_body(cparser.llhttp_t* parser, |
| | const char *at, size_t length) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | cdef bytes body = at[:length] |
| | try: |
| | pyparser._payload.feed_data(body, length) |
| | except BaseException as underlying_exc: |
| | reraised_exc = underlying_exc |
| | if pyparser._payload_exception is not None: |
| | reraised_exc = pyparser._payload_exception(str(underlying_exc)) |
| |
|
| | set_exception(pyparser._payload, reraised_exc, underlying_exc) |
| |
|
| | pyparser._payload_error = 1 |
| | return -1 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_message_complete(cparser.llhttp_t* parser) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | try: |
| | pyparser._started = False |
| | pyparser._on_message_complete() |
| | except BaseException as exc: |
| | pyparser._last_error = exc |
| | return -1 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_chunk_header(cparser.llhttp_t* parser) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | try: |
| | pyparser._on_chunk_header() |
| | except BaseException as exc: |
| | pyparser._last_error = exc |
| | return -1 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef int cb_on_chunk_complete(cparser.llhttp_t* parser) except -1: |
| | cdef HttpParser pyparser = <HttpParser>parser.data |
| | try: |
| | pyparser._on_chunk_complete() |
| | except BaseException as exc: |
| | pyparser._last_error = exc |
| | return -1 |
| | else: |
| | return 0 |
| |
|
| |
|
| | cdef parser_error_from_errno(cparser.llhttp_t* parser, data, pointer): |
| | cdef cparser.llhttp_errno_t errno = cparser.llhttp_get_errno(parser) |
| | cdef bytes desc = cparser.llhttp_get_error_reason(parser) |
| |
|
| | err_msg = "{}:\n\n {!r}\n {}".format(desc.decode("latin-1"), data, pointer) |
| |
|
| | if errno in {cparser.HPE_CB_MESSAGE_BEGIN, |
| | cparser.HPE_CB_HEADERS_COMPLETE, |
| | cparser.HPE_CB_MESSAGE_COMPLETE, |
| | cparser.HPE_CB_CHUNK_HEADER, |
| | cparser.HPE_CB_CHUNK_COMPLETE, |
| | cparser.HPE_INVALID_CONSTANT, |
| | cparser.HPE_INVALID_HEADER_TOKEN, |
| | cparser.HPE_INVALID_CONTENT_LENGTH, |
| | cparser.HPE_INVALID_CHUNK_SIZE, |
| | cparser.HPE_INVALID_EOF_STATE, |
| | cparser.HPE_INVALID_TRANSFER_ENCODING}: |
| | return BadHttpMessage(err_msg) |
| | elif errno == cparser.HPE_INVALID_METHOD: |
| | return BadHttpMethod(error=err_msg) |
| | elif errno in {cparser.HPE_INVALID_STATUS, |
| | cparser.HPE_INVALID_VERSION}: |
| | return BadStatusLine(error=err_msg) |
| | elif errno == cparser.HPE_INVALID_URL: |
| | return InvalidURLError(err_msg) |
| |
|
| | return BadHttpMessage(err_msg) |
| |
|
