diff --git a/python_multipart/multipart.py b/python_multipart/multipart.py index d387e9a..b430bda 100644 --- a/python_multipart/multipart.py +++ b/python_multipart/multipart.py @@ -1275,6 +1275,15 @@ def data_callback(name: CallbackName, end_i: int, remaining: bool = False) -> No index += 1 elif state == HEADER_FIELD_START: + if data.startswith(b"\r\n", i, length): + # Consume the blank line without visiting the intermediate states. + self.callback("headers_finished") + self.marks["part_data"] = i + 2 + index = 0 + state = PART_DATA + i += 2 + continue + # Mark the start of a header field here, reset the index, and # continue parsing our header field. index = 0 @@ -1369,7 +1378,12 @@ def data_callback(name: CallbackName, end_i: int, remaining: bool = False) -> No data_callback("header_value", i) self.callback("header_end") current_header_size = 0 - state = HEADER_VALUE_ALMOST_DONE + if data.startswith(b"\r\n", cr, length): + # Consume the buffered LF without another parser iteration. + i += 1 + state = HEADER_FIELD_START + else: + state = HEADER_VALUE_ALMOST_DONE else: i = length @@ -1395,15 +1409,9 @@ def data_callback(name: CallbackName, end_i: int, remaining: bool = False) -> No raise MultipartParseError(msg, offset=i) self.callback("headers_finished") - state = PART_DATA_START - elif state == PART_DATA_START: - # Mark the start of our part data. - self.marks["part_data"] = i - - # Start processing part data, including this character. + self.marks["part_data"] = i + 1 state = PART_DATA - i -= 1 elif state == PART_DATA: # We're processing our part data right now. During this, we @@ -1422,6 +1430,18 @@ def data_callback(name: CallbackName, end_i: int, remaining: bool = False) -> No # Calling `find` is much faster than iterating here. i0 = data.find(boundary, i, length) if i0 >= 0: + # Finish a buffered delimiter without stepping through its CRLF. + after = i0 + boundary_length + if data.startswith(b"\r\n", after, length): + data_callback("part_data", i0) + self.callback("part_end") + self.callback("part_begin") + current_header_count = 0 + current_header_size = 0 + state = HEADER_FIELD_START + i = after + 2 + continue + # We matched the whole boundary string. index = boundary_length - 1 i = i0 + boundary_length - 1 diff --git a/tests/test_multipart.py b/tests/test_multipart.py index 36a0ca3..d6614e2 100644 --- a/tests/test_multipart.py +++ b/tests/test_multipart.py @@ -40,10 +40,10 @@ from .compat import parametrize, parametrize_class if TYPE_CHECKING: - from collections.abc import Iterator + from collections.abc import Callable, Iterator from typing import Any, TypedDict - from python_multipart.multipart import FileConfig + from python_multipart.multipart import FileConfig, MultipartCallbacks class TestParams(TypedDict): name: str @@ -931,6 +931,77 @@ def test_multipart_opening_boundary_max_size() -> None: assert events == ["begin", "end"] +def test_multipart_events_do_not_depend_on_chunk_boundaries() -> None: + data = ( + b"--boundary\r\n" + b'Content-Disposition: form-data; name="a"\r\n' + b"X-Empty:\r\n" + b"\r\n" + b"first\r\n" + b"--boundary\r\n" + b"\r\n" + b"second\r\n" + b"--boundary--\r\n" + ) + + def parse(chunks: list[bytes]) -> list[tuple[str, bytes]]: + events: list[tuple[str, bytes]] = [] + + def on_data(name: str) -> Callable[[bytes, int, int], None]: + return lambda data, start, end: events.append((name, data[start:end])) + + def on_event(name: str) -> Callable[[], None]: + return lambda: events.append((name, b"")) + + callbacks: MultipartCallbacks = { + "on_part_begin": on_event("part_begin"), + "on_part_data": on_data("part_data"), + "on_part_end": on_event("part_end"), + "on_header_begin": on_event("header_begin"), + "on_header_field": on_data("header_field"), + "on_header_value": on_data("header_value"), + "on_header_end": on_event("header_end"), + "on_headers_finished": on_event("headers_finished"), + "on_end": on_event("end"), + } + parser = MultipartParser(b"boundary", callbacks) + for chunk in chunks: + parser.write(chunk) + parser.finalize() + + # Merge adjacent data events, since a split can break one value into several callbacks. + merged: list[tuple[str, bytes]] = [] + for name, value in events: + if merged and value and merged[-1][0] == name: + merged[-1] = (name, merged[-1][1] + value) + else: + merged.append((name, value)) + return merged + + expected = parse([data]) + assert expected == [ + ("part_begin", b""), + ("header_begin", b""), + ("header_field", b"Content-Disposition"), + ("header_value", b'form-data; name="a"'), + ("header_end", b""), + ("header_begin", b""), + ("header_field", b"X-Empty"), + ("header_end", b""), + ("headers_finished", b""), + ("part_data", b"first"), + ("part_end", b""), + ("part_begin", b""), + ("headers_finished", b""), + ("part_data", b"second"), + ("part_end", b""), + ("end", b""), + ] + for i in range(1, len(data)): + assert parse([data[:i], data[i:]]) == expected + assert parse([data[i : i + 1] for i in range(len(data))]) == expected + + @pytest.mark.parametrize( "config,first,second,message", [