| #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,
|
| 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 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
|
|
|
| bytearray _raw_name
|
| bytearray _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
|
| object _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 = bytearray()
|
| self._raw_value = bytearray()
|
| 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):
|
| if self._raw_name:
|
| raw_name = bytes(self._raw_name)
|
| raw_value = bytes(self._raw_value)
|
|
|
| name = find_header(raw_name)
|
| value = raw_value.decode('utf-8', 'surrogateescape')
|
|
|
| self._headers.add(name, value)
|
|
|
| if name is CONTENT_ENCODING:
|
| self._content_encoding = value
|
|
|
| PyByteArray_Resize(self._raw_name, 0)
|
| PyByteArray_Resize(self._raw_value, 0)
|
| self._has_value = False
|
| self._raw_headers.append((raw_name, raw_value))
|
|
|
| cdef _on_header_field(self, char* at, size_t length):
|
| cdef Py_ssize_t size
|
| cdef char *buf
|
| if self._has_value:
|
| self._process_header()
|
|
|
| size = PyByteArray_Size(self._raw_name)
|
| PyByteArray_Resize(self._raw_name, size + length)
|
| buf = PyByteArray_AsString(self._raw_name)
|
| memcpy(buf + size, at, length)
|
|
|
| cdef _on_header_value(self, char* at, size_t length):
|
| cdef Py_ssize_t size
|
| cdef char *buf
|
|
|
| size = PyByteArray_Size(self._raw_value)
|
| PyByteArray_Resize(self._raw_value, size + length)
|
| buf = PyByteArray_AsString(self._raw_value)
|
| memcpy(buf + size, 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(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 = CIMultiDict()
|
| 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 in {cparser.HPE_INVALID_STATUS,
|
| cparser.HPE_INVALID_METHOD,
|
| cparser.HPE_INVALID_VERSION}:
|
| return BadStatusLine(error=err_msg)
|
| elif errno == cparser.HPE_INVALID_URL:
|
| return InvalidURLError(err_msg)
|
|
|
| return BadHttpMessage(err_msg)
|
|
|
