Skip to content

Fix infinite loop when parsing MagicMock objects #32

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
sgd2z wants to merge 6 commits into
base: main
Choose a base branch
from
Open

Fix infinite loop when parsing MagicMock objects #32

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
f2e9a89
Fix infinite loop when parsing MagicMock objects
sgd2z Dec 9, 2025
ab6288c
make fix python 2.7 compatible
sgd2z Dec 9, 2025
133864b
more python 2.7 related fixes
sgd2z Dec 9, 2025
722f4a4
skip new tests for 2.7
sgd2z Dec 9, 2025
801f8e7
updated for test coverage
sgd2z Dec 9, 2025
74daf22
Address PR comments: improve error message and Python 2 test compatib…
sgd2z Dec 19, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 17 additions & 7 deletions llsd/base.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -410,14 +410,24 @@ def _reset(self, something):
# string is so large that the overhead of copying it into a
# BytesIO is significant, advise caller to pass a stream instead.
self._stream = io.BytesIO(something)
elif something.seekable():
# 'something' is already a seekable stream, use directly
self._stream = something
elif isinstance(something, io.IOBase):
# 'something' is a proper IO stream - must be seekable for parsing
if something.seekable():
self._stream = something
else:
raise LLSDParseError(
"Cannot parse LLSD from non-seekable stream."
)
else:
# 'something' isn't seekable, wrap in BufferedReader
# (let BufferedReader handle the problem of passing an
# inappropriate object)
self._stream = io.BufferedReader(something)
Comment on lines -417 to -420
Copy link
Contributor

@nattylinden nattylinden Dec 17, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We're replacing this codepath for unseekable streams with a new LLSDParseError, but that should be OK.

Looks like we stopped supporting unseekable streams in f5aab9f (#6, released in v1.2.0), where we replaced uses of peek() with uses of tell() & seek() to rewind when necessary instead. All the parsing functions use LLSDBaseParser.matchseq() to consume sequences from the stream, which starts by calling tell() on the stream, which should only be supported if the stream is seekable.

The use of io.BufferedReader() comes from earlier, in 2ffd753 (#4), where we used io.BufferedReader to add peek() support to streams. Per f5aab9f:

Refine LLSDBaseParser._reset() wrapper logic to wrap an existing stream in io.BufferedReader only if it's not already seekable(). That includes an incoming bytes object: wrap it only in BytesIO, which is seekable().

This seems to imply wrapping an unseekable stream in an io.BufferedReader should add the ability to seek, but it doesn't: if the stream it contains is unseekable, the io.BufferedReader is unseekable too. (That makes sense, since io.BufferedReader would need to keep an unbounded buffer for the whole stream in order to seek arbitrarily.)

Python 3.11.2 (main, Apr 28 2025, 14:11:48) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import io, sys
>>> sys.stdin.buffer.seekable()
False
>>> reader = io.BufferedReader(sys.stdin.buffer)
>>> reader.seekable()
False
>>> reader.tell()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
OSError: [Errno 29] Illegal seek
>>>

Python 2.7.18 (default, Dec 18 2025, 00:08:35)
[GCC 12.2.0] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import io, sys
>>> reader = io.open(sys.stdin.fileno(), 'rb')
>>> type(reader)
<type '_io.BufferedReader'>
>>> reader.seekable()
False
>>> reader.tell()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: [Errno 29] Illegal seek
>>>

The test_parse_non_seekable_stream_raises_error test confirms this when run without the llsd/base.py fix: once parsing proceeds to matchseq(), we attempt to tell() or seek() on the stream (depending how parsing is invoked), which raises an io.UnsupportedOperation: File or stream is not seekable.

$ git log --graph --oneline -1
* f00d36b (HEAD -> main, secondlife/main) Allow dependabot in CLA check (#33)

$ python3
Python 3.11.2 (main, Apr 28 2025, 14:11:48) [GCC 12.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import io, llsd
>>> stream = io.BytesIO()
>>> stream.seekable = lambda: False
>>> llsd.parse(stream)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/local/natty/python-llsd/llsd/__init__.py", line 53, in parse
    if baseparser.matchseq(pattern):
       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/local/natty/python-llsd/llsd/base.py", line 455, in matchseq
    self._stream.seek(oldpos)
io.UnsupportedOperation: File or stream is not seekable.
>>>

$

Seems acceptable to throw an exception here when the stream is unseekable.

# Invalid input type - raise a clear error
# This catches MagicMock and other non-stream objects that might
# have read/seek attributes but aren't actual IO streams
raise LLSDParseError(
"Cannot parse LLSD from {0}. "
"Expected bytes or a seekable io.IOBase object.".format(
type(something).__name__
)
)

def starts_with(self, pattern):
"""
Expand Down
56 changes: 56 additions & 0 deletions tests/llsd_test.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1977,3 +1977,59 @@ def test_uuid_map_key(self):
self.assertEqual(llsd.format_notation(llsdmap), b"{'00000000-0000-0000-0000-000000000000':'uuid'}")


class InvalidInputTypes(unittest.TestCase):
'''
Tests for handling invalid input types that should raise LLSDParseError
instead of hanging or consuming infinite memory.
'''

@unittest.skipIf(PY2, "MagicMock requires Python 3")
def test_parse_magicmock_raises_error(self):
'''
Parsing a MagicMock object should raise LLSDParseError, not hang.
This is a regression test for a bug where llsd.parse() would go into
an infinite loop when passed a MagicMock (e.g., from an improperly
mocked requests.Response.content).
'''
from unittest.mock import MagicMock
mock = MagicMock()
with self.assertRaises(llsd.LLSDParseError) as context:
llsd.parse(mock)
self.assertIn('MagicMock', str(context.exception))

def test_parse_string_raises_error(self):
'''
Parsing a string (not bytes) should raise LLSDParseError.
Only applies to Python 3 where str and bytes are distinct.
'''
with self.assertRaises(llsd.LLSDParseError) as context:
llsd.parse(b'not bytes'.decode('ascii'))
self.assertIn('unicode' if PY2 else 'str', str(context.exception))

def test_parse_none_raises_error(self):
'''
Parsing None should raise LLSDParseError.
'''
with self.assertRaises(llsd.LLSDParseError) as context:
llsd.parse(None)
self.assertIn('NoneType', str(context.exception))

def test_parse_int_raises_error(self):
'''
Parsing an integer should raise LLSDParseError.
'''
with self.assertRaises(llsd.LLSDParseError) as context:
llsd.parse(42)
self.assertIn('int', str(context.exception))

def test_parse_non_seekable_stream_raises_error(self):
'''
Parsing a non-seekable stream should raise LLSDParseError.
'''
stream = io.BytesIO()
stream.seekable = lambda: False
with self.assertRaises(llsd.LLSDParseError) as context:
llsd.parse(stream)
self.assertIn('non-seekable', str(context.exception))