pylons__waitress-249

The problem is that `ReadOnlyFileBasedBuffer` in `waitress/buffers.py` fails when given an `io.IOBase` subclass that is not seekable. It attempts to call `seek` and `tell` to determine the file length, but these methods raise `io.UnsupportedOperation` if the object is not seekable, even if the methods exist.

I need to check `waitress/buffers.py` around line 140, identify where `seek` and `tell` are called, and ensure that it checks if the object is seekable or catches `UnsupportedOperation`.

Plan:
1.  Analyze `waitress/buffers.py` around line 140.
2.  Create a reproduction script that uses a non-seekable `io.IOBase` subclass (e.g., `io.StringIO` is seekable, but maybe something like `io.BytesIO`? No, those are seekable. I can create a custom class inheriting from `io.RawIOBase` that overrides `seek` and `tell` to raise `UnsupportedOperation`).
3.  Verify the fix by ensuring the code handles non-seekable buffers gracefully.
4.  Run existing tests to ensure no regressions.

{
  "end_line": 200,
  "filepath": "waitress/buffers.py",
  "start_line": 100
}

{
  "status": "ok",
  "filepath": "waitress/buffers.py",
  "content": "            nf.write(data)\n        self.file = nf\n\n    def getfile(self):\n        return self.file\n\n    def close(self):\n        if hasattr(self.file, 'close'):\n            self.file.close()\n        self.remain = 0\n\nclass TempfileBasedBuffer(FileBasedBuffer):\n\n    def __init__(self, from_buffer=None):\n        FileBasedBuffer.__init__(self, self.newfile(), from_buffer)\n\n    def newfile(self):\n        from tempfile import TemporaryFile\n        return TemporaryFile('w+b')\n\nclass BytesIOBasedBuffer(FileBasedBuffer):\n\n    def __init__(self, from_buffer=None):\n        if from_buffer is not None:\n            FileBasedBuffer.__init__(self, BytesIO(), from_buffer)\n        else:\n            # Shortcut. :-)\n            self.file = BytesIO()\n\n    def newfile(self):\n        return BytesIO()\n\nclass ReadOnlyFileBasedBuffer(FileBasedBuffer):\n    # used as wsgi.file_wrapper\n\n    def __init__(self, file, block_size=32768):\n        self.file = file\n        self.block_size = block_size # for __iter__\n\n    def prepare(self, size=None):\n        if hasattr(self.file, 'seek') and hasattr(self.file, 'tell'):\n            start_pos = self.file.tell()\n            self.file.seek(0, 2)\n            end_pos = self.file.tell()\n            self.file.seek(start_pos)\n            fsize = end_pos - start_pos\n            if size is None:\n                self.remain = fsize\n            else:\n                self.remain = min(fsize, size)\n        return self.remain\n\n    def get(self, numbytes=-1, skip=False):\n        # never read more than self.remain (it can be user-specified)\n        if numbytes == -1 or numbytes > self.remain:\n            numbytes = self.remain\n        file = self.file\n        if not skip:\n            read_pos = file.tell()\n        res = file.read(numbytes)\n        if skip:\n            self.remain -= len(res)\n        else:\n            file.seek(read_pos)\n        return res\n\n    def __iter__(self): # called by task if self.filelike has no seek/tell\n        return self\n\n    def next(self):\n        val = self.file.read(self.block_size)\n        if not val:\n            raise StopIteration\n        return val\n\n    __next__ = next # py3\n\n    def append(self, s):\n        raise NotImplementedError\n\nclass OverflowableBuffer(object):\n    \"\"\"\n    This buffer implementation has four stages:\n    - No data\n    - Bytes-based buffer\n    - BytesIO-based buffer\n    - Temporary file storage\n    The first two stages are fastest for simple transfers.\n    \"\"\"\n\n    overflowed = False\n    buf = None\n    strbuf = b'' # Bytes-based buffer.\n\n    def __init__(self, overflow):\n        # overflow is the maximum to be stored in a StringIO buffer.\n        self.overflow = overflow\n\n    def __len__(self):\n        buf = self.buf\n        if buf is not None:",
  "start_line": 100,
  "end_line": 200,
  "total_lines": 298,
  "is_truncated": false
}

The problematic code is in `ReadOnlyFileBasedBuffer.prepare`:

```python
    def prepare(self, size=None):
        if hasattr(self.file, 'seek') and hasattr(self.file, 'tell'):
            start_pos = self.file.tell()
            self.file.seek(0, 2)
            end_pos = self.file.tell()
            self.file.seek(start_pos)
            fsize = end_pos - start_pos
            if size is None:
                self.remain = fsize
            else:
                self.remain = min(fsize, size)
        return self.remain
```

As described in the issue, if `self.file` is an `io.IOBase` subclass that is not seekable, `hasattr(self.file, 'seek')` and `hasattr(self.file, 'tell')` will be True, but calling them will raise `io.UnsupportedOperation`.

Also, `get` method uses `tell` and `seek`:

```python
    def get(self, numbytes=-1, skip=False):
        # never read more than self.remain (user-specified)
        if numbytes == -1 or numbytes > self.remain:
            numbytes = self.remain
        file = self.file
        if not skip:
            read_pos = file.tell()
        res = file.read(numbytes)
        if skip:
            self.remain -= len(res)
        else:
            file.seek(read_pos)
        return res
```

Wait, if `prepare` fails or is skipped, `self.remain` is not initialized (it will raise `AttributeError` because it's not in `__init__` and `prepare` is usually called before `get`). Let's check `ReadOnlyFileBasedBuffer.__init__`.

```python
    def __init__(self, file, block_size=32768):
        self.file = file
        self.block_size = block_size # for __iter__
```

Indeed, `self.remain` is only set in `prepare`.

If `prepare` can't determine the size, it should probably set `self.remain` to something that indicates it's unknown or just not set it and handle it in `get`. But `get` uses `self.remain`.

Wait, if `hasattr(self.file, 'seek')` is false, `prepare` just returns `self.remain`... but `self.remain` isn't initialized yet! This looks like another bug or I'm missing something.

Actually, if `hasattr(self.file, 'seek')` is false, it returns `self.remain`, which will raise `AttributeError`.

Let's check how `ReadOnlyFileBasedBuffer` is used. It's used as `wsgi.file_wrapper`.

Looking at `ReadOnlyFileBasedBuffer.prepare`:
```python
    def prepare(self, size=None):
        if hasattr(self.file, 'seek') and hasattr(self.file, 'tell'):
            # ... (seek/tell logic)
        return self.remain
```
If the condition is false, it returns `self.remain`. But `self.remain` is not defined in `__init__`.

Let's see if `FileBasedBuffer` (the base class) defines `self.remain`.

```python
class FileBasedBuffer(object): # I need to read this.
```

Let's read the beginning of `waitress/buffers.py`.

{
  "end_line": 100,
  "filepath": "waitress/buffers.py",
  "start_line": 1
}

{
  "status": "ok",
  "filepath": "waitress/buffers.py",
  "content": "##############################################################################\n#\n# Copyright (c) 2001-2004 Zope Foundation and Contributors.\n# All Rights Reserved.\n#\n# This software is subject to the provisions of the Zope Public License,\n# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.\n# THIS SOFTWARE IS PROVIDED \"AS IS\" AND ANY AND ALL EXPRESS OR IMPLIED\n# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS\n# FOR A PARTICULAR PURPOSE.\n#\n##############################################################################\n\"\"\"Buffers\n\"\"\"\nfrom io import BytesIO\n\n# copy_bytes controls the size of temp. strings for shuffling data around.\nCOPY_BYTES = 1 << 18 # 256K\n\n# The maximum number of bytes to buffer in a simple string.\nSTRBUF_LIMIT = 8192\n\nclass FileBasedBuffer(object):\n\n    remain = 0\n\n    def __init__(self, file, from_buffer=None):\n        self.file = file\n        if from_buffer is not None:\n            from_file = from_buffer.getfile()\n            read_pos = from_file.tell()\n            from_file.seek(0)\n            while True:\n                data = from_file.read(COPY_BYTES)\n                if not data:\n                    break\n                file.write(data)\n            self.remain = int(file.tell() - read_pos)\n            from_file.seek(read_pos)\n            file.seek(read_pos)\n\n    def __len__(self):\n        return self.remain\n\n    def __nonzero__(self):\n        return True\n\n    __bool__ = __nonzero__ # py3\n\n    def append(self, s):\n        file = self.file\n        read_pos = file.tell()\n        file.seek(0, 2)\n        file.write(s)\n        file.seek(read_pos)\n        self.remain = self.remain + len(s)\n\n    def get(self, numbytes=-1, skip=False):\n        file = self.file\n        if not skip:\n            read_pos = file.tell()\n        if numbytes < 0:\n            # Read all\n            res = file.read()\n        else:\n            res = file.read(numbytes)\n        if skip:\n            self.remain -= len(res)\n        else:\n            file.seek(read_pos)\n        return res\n\n    def skip(self, numbytes, allow_prune=0):\n        if self.remain < numbytes:\n            raise ValueError(\"Can't skip %d bytes in buffer of %d bytes\" % (\n                numbytes, self.remain)\n            )\n        self.file.seek(numbytes, 1)\n        self.remain = self.remain - numbytes\n\n    def newfile(self):\n        raise NotImplementedError()\n\n    def prune(self):\n        file = self.file\n        if self.remain == 0:\n            read_pos = file.tell()\n            file.seek(0, 2)\n            sz = file.tell()\n            file.seek(read_pos)\n            if sz == 0:\n                # Nothing to prune.\n                return\n        nf = self.newfile()\n        while True:\n            data = file.read(COPY_BYTES)\n            if not data:\n                break\n            nf.write(data)",
  "start_line": 1,
  "end_line": 100,
  "total_lines": 298,
  "is_truncated": false
}

`FileBasedBuffer` defines `remain = 0` as a class attribute. So `ReadOnlyFileBasedBuffer` inherits it.

Now let's create a reproduction script. I need a non-seekable `io.IOBase` subclass. `io.BufferedReader` is usually seekable if the underlying file is. `io.TextIOWrapper` is too. A good example would be `io.BytesIO` but with `seek` and `tell` modified to raise `UnsupportedOperation`, or just a custom `io.IOBase` subclass.

According to the issue: "In `io.IOBase` subclasses that are not seekable, those two methods exist but raise an `UnsupportedOperation`".

Wait, `io.RawIOBase` has `seek` and `tell` which raise `UnsupportedOperation` by default.

Let's test this.

{
  "command": "python3 - <<'PY'\nimport io\nfrom waitress.buffers import ReadOnlyFileBasedBuffer\n\nclass NonSeekableBuffer(io.RawIOBase):\n    def read(self, size=-1):\n        return b\"hello world\"\n\nbuf = NonSeekableBuffer()\nrop = ReadOnlyFileBasedBuffer(buf)\ntry:\n    rop.prepare()\n    print(\"Success\")\nexcept Exception as e:\n    print(f\"Caught exception: {type(e).__name__}: {e}\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "Caught exception: UnsupportedOperation: seek\n",
  "stderr": "",
  "exit_code": 0
}

The reproduction script confirms the issue. `rop.prepare()` fails with `UnsupportedOperation: seek`.

Now let's see how to fix it.
The problem statement suggests: "in case of io.IOBase instance `.seekable` should probably be checked for `True` or the `UnsupportedOperation` should be trapped."

Let's check if `io.IOBase` has a `.seekable()` method. Yes, it does.

Wait, but `ReadOnlyFileBasedBuffer.prepare` currently does:
```python
    def prepare(self, size=None):
        if hasattr(self.file, 'seek') and hasattr(self.file, 'tell'):
            start_pos = self.file.tell()
            self.file.seek(0, 2)
            end_pos = self.file.tell()
            self.file.seek(start_pos)
            fsize = end_pos - start_pos
            if size is None:
                self.remain = fsize
            else:
                self.remain = min(fsize, size)
        return self.remain
```

If we check `self.file.seekable()`, it should be more robust.

However, not all file-like objects might have a `.seekable()` method. So we should check if it has `.seekable()` and if it returns True, OR just wrap the seek/tell block in a try-except `UnsupportedOperation`.

Wait, if `self.file` is not seekable, `prepare` cannot determine the size. What should it do in that case?

If it fails to determine the size, `self.remain` remains 0 (from `FileBasedBuffer.remain = 0`).

Let's see what happens if `self.remain` is 0.
In `get`:
```python
    def get(self, numbytes=-1, skip=False):
        # never read more than self.remain (it can be user-specified)
        if numbytes == -1 or numbytes > self.remain:
            numbytes = self.remain
        file = self.file
        if not skip:
            read_pos = file.tell()
        res = file.read(numbytes)
        if skip:
            self.remain -= len(res)
        else:
            file.seek(read_pos)
        return res
```
If `self.remain` is 0, `numbytes` becomes 0, and `res` will be `file.read(0)`, which is `b''`. This might not be what we want if the file is not seekable but still has data.

But `ReadOnlyFileBasedBuffer` is used as `wsgi.file_wrapper`. The WSGI server (waitress) uses `get` to read data from the buffer. If `self.remain` is 0, it might think the buffer is empty.

However, there's also an `__iter__` method:
```python
    def __iter__(self): # called by task if self.filelike has no seek/tell
        return self

    def next(self):
        val = self.file.read(self.block_size)
        if not val:
            raise StopIteration
        return val

    __next__ = next # py3
```
Wait, the comment says `__iter__` is called by task if `self.filelike` has no seek/tell.

Let's see where `ReadOnlyFileBasedBuffer` is used in the codebase.

{
  "command": "grep -rn \"ReadOnlyFileBasedBuffer\" waitress/"
}

{
  "status": "ok",
  "stdout": "waitress/buffers.py:132:class ReadOnlyFileBasedBuffer(FileBasedBuffer):\nwaitress/channel.py:21:    ReadOnlyFileBasedBuffer,\nwaitress/channel.py:309:                if data.__class__ is ReadOnlyFileBasedBuffer:\nwaitress/task.py:21:from .buffers import ReadOnlyFileBasedBuffer\nwaitress/task.py:451:            if app_iter.__class__ is ReadOnlyFileBasedBuffer:\nwaitress/task.py:788:            'wsgi.file_wrapper': ReadOnlyFileBasedBuffer,\nwaitress/tests/test_task.py:614:        from waitress.buffers import ReadOnlyFileBasedBuffer\nwaitress/tests/test_task.py:616:        app_iter = ReadOnlyFileBasedBuffer(f, 8192)\nwaitress/tests/test_task.py:627:        from waitress.buffers import ReadOnlyFileBasedBuffer\nwaitress/tests/test_task.py:629:        app_iter = ReadOnlyFileBasedBuffer(f, 8192)\nwaitress/tests/test_task.py:641:        from waitress.buffers import ReadOnlyFileBasedBuffer\nwaitress/tests/test_task.py:643:        app_iter = ReadOnlyFileBasedBuffer(f, 8192)\nwaitress/tests/test_buffers.py:146:class TestReadOnlyFileBasedBuffer(unittest.TestCase):\nwaitress/tests/test_buffers.py:149:        from waitress.buffers import ReadOnlyFileBasedBuffer\nwaitress/tests/test_buffers.py:150:        return ReadOnlyFileBasedBuffer(file, block_size)\nwaitress/tests/test_channel.py:211:        from waitress.buffers import ReadOnlyFileBasedBuffer\nwaitress/tests/test_channel.py:213:        wrapper = ReadOnlyFileBasedBuffer(f, 8192)\n",
  "stderr": "grep: waitress/__pycache__/task.cpython-37.pyc: binary file matches\ngrep: waitress/__pycache__/buffers.cpython-37.pyc: binary file matches\ngrep: waitress/__pycache__/channel.cpython-37.pyc: binary file matches\n",
  "exit_code": 0
}

Let's look at `waitress/task.py` around line 451.

{
  "end_line": 470,
  "filepath": "waitress/task.py",
  "start_line": 440
}

{
  "status": "ok",
  "filepath": "waitress/task.py",
  "content": "\n            self.response_headers.extend(headers)\n\n            # Return a method used to write the response data.\n            return self.write\n\n        # Call the application to handle the request and write a response\n        app_iter = self.channel.server.application(env, start_response)\n\n        can_close_app_iter = True\n        try:\n            if app_iter.__class__ is ReadOnlyFileBasedBuffer:\n                cl = self.content_length\n                size = app_iter.prepare(cl)\n                if size:\n                    if cl != size:\n                        if cl is not None:\n                            self.remove_content_length_header()\n                        self.content_length = size\n                    self.write(b'') # generate headers\n                    # if the write_soon below succeeds then the channel will\n                    # take over closing the underlying file via the channel's\n                    # _flush_some or handle_close so we intentionally avoid\n                    # calling close in the finally block\n                    self.channel.write_soon(app_iter)\n                    can_close_app_iter = False\n                    return\n\n            first_chunk_len = None\n            for chunk in app_iter:\n                if first_chunk_len is None:",
  "start_line": 440,
  "end_line": 470,
  "total_lines": 833,
  "is_truncated": false
}

In `task.py`, if `app_iter` is a `ReadOnlyFileBasedBuffer`, it calls `app_iter.prepare(cl)`.

```python
                if app_iter.__class__ is ReadOnlyFileBasedBuffer:
                    cl = self.content_length
                    size = app_iter.prepare(cl)
                    if size:
                        # ... optimization paths ...
                        self.channel.write_soon(app_iter)
                        can_close_app_iter = False
                        return
```

If `size` is 0 or `None` (or if `prepare` fails and we catch it), it falls back to:
```python
            first_chunk_len = None
            for chunk in app_iter:
                if first_chunk_len is None:
```
And `ReadOnlyFileBasedBuffer.__iter__` returns `self`, and `__next__` calls `self.file.read(self.block_size)`.

So if we can't determine the size in `prepare`, we should return 0 (or some falsy value) so it falls back to the iterator.

Wait, `ReadOnlyFileBasedBuffer.prepare` currently returns `self.remain`. And `self.remain` is initialized to 0 via `FileBasedBuffer`.

So the only problem is that it crashes when calling `tell()` and `seek()` if they exist but are not supported.

Let's check `get` again. Does it crash?

```python
    def get(self, numbytes=-1, skip=False):
        # never read more than self.remain (it can be user-specified)
        if numbytes == -1 or numbytes > self.remain:
            numbytes = self.remain
        file = self.file
        if not skip:
            read_pos = file.tell()
        res = file.read(numbytes)
        if skip:
            self.remain -= len(res)
        else:
            file.seek(read_pos)
        return res
```

If `self.remain` is 0, `numbytes` becomes 0, and it calls `file.tell()` and `file.seek(read_pos)`. Both will raise `UnsupportedOperation` if the file is not seekable.

However, `get` is only called if `size` was returned by `prepare` (or rather, if `self.remain > 0`).

In `task.py`:
```python
                if app_iter.__class__ is ReadOnlyFileBasedBuffer:
                    cl = self.content_length
                    size = app_iter.prepare(cl)
                    if size:
                        # ...
                        self.channel.write_soon(app_iter)
                        can_close_app_iter = False
                        return
```
`self.channel.write_soon(app_iter)` probably calls `app_iter.get()`.

Let's check `waitress/channel.py` to see how `write_soon` uses the buffer.

{
  "end_line": 320,
  "filepath": "waitress/channel.py",
  "start_line": 300
}

{
  "status": "ok",
  "filepath": "waitress/channel.py",
  "content": "            # can cleanup possibly before the app_iter is exhausted\n            raise ClientDisconnected\n        if data:\n            # the async mainloop might be popping data off outbuf; we can\n            # block here waiting for it because we're in a task thread\n            with self.outbuf_lock:\n                self._flush_outbufs_below_high_watermark()\n                if not self.connected:\n                    raise ClientDisconnected\n                if data.__class__ is ReadOnlyFileBasedBuffer:\n                    # they used wsgi.file_wrapper\n                    self.outbufs.append(data)\n                    nextbuf = OverflowableBuffer(self.adj.outbuf_overflow)\n                    self.outbufs.append(nextbuf)\n                    self.current_outbuf_count = 0\n                else:\n                    if self.current_outbuf_count > self.adj.outbuf_high_watermark:\n                        # rotate to a new buffer if the current buffer has hit\n                        # the watermark to avoid it growing unbounded\n                        nextbuf = OverflowableBuffer(self.adj.outbuf_overflow)\n                        self.outbufs.append(nextbuf)",
  "start_line": 300,
  "end_line": 320,
  "total_lines": 415,
  "is_truncated": false
}

Wait, I'm looking at `channel.py` around 309. Let's see where `write_soon` is defined and used.

{
  "command": "grep -rn \"def write_soon\" waitress/"
}

{
  "status": "ok",
  "stdout": "waitress/channel.py:297:    def write_soon(self, data):\nwaitress/tests/test_task.py:1493:    def write_soon(self, data):\n",
  "stderr": "",
  "exit_code": 0
}

Let's read `write_soon` in `waitress/channel.py`.

{
  "end_line": 315,
  "filepath": "waitress/channel.py",
  "start_line": 290
}

{
  "status": "ok",
  "filepath": "waitress/channel.py",
  "content": "        if fd in ac:\n            del ac[fd]\n\n    #\n    # SYNCHRONOUS METHODS\n    #\n\n    def write_soon(self, data):\n        if not self.connected:\n            # if the socket is closed then interrupt the task so that it\n            # can cleanup possibly before the app_iter is exhausted\n            raise ClientDisconnected\n        if data:\n            # the async mainloop might be popping data off outbuf; we can\n            # block here waiting for it because we're in a task thread\n            with self.outbuf_lock:\n                self._flush_outbufs_below_high_watermark()\n                if not self.connected:\n                    raise ClientDisconnected\n                if data.__class__ is ReadOnlyFileBasedBuffer:\n                    # they used wsgi.file_wrapper\n                    self.outbufs.append(data)\n                    nextbuf = OverflowableBuffer(self.adj.outbuf_overflow)\n                    self.outbufs.append(nextbuf)\n                    self.current_outbuf_count = 0\n                else:",
  "start_line": 290,
  "end_line": 315,
  "total_lines": 415,
  "is_truncated": false
}

It seems `write_soon` just appends the buffer to `self.outbufs`. The actual reading from the buffer happens in the async main loop.

Let's search for where `outbufs` are processed.

{
  "command": "grep -rn \"outbufs\" waitress/channel.py"
}

{
  "status": "ok",
  "stdout": "56:    total_outbufs_len = 0        # total bytes ready to send\n73:        self.outbufs = [OverflowableBuffer(adj.outbuf_overflow)]\n91:        return self.total_outbufs_len or self.will_close\n108:        elif self.total_outbufs_len >= self.adj.send_bytes:\n130:        if self.close_when_flushed and not self.total_outbufs_len:\n143:        return not (self.will_close or self.requests or self.total_outbufs_len)\n180:                    self.outbufs[-1].append(outbuf_payload)\n182:                    self.total_outbufs_len += len(outbuf_payload)\n211:                if self.total_outbufs_len < self.adj.outbuf_high_watermark:\n223:            outbuf = self.outbufs[0]\n234:                    self.total_outbufs_len -= num_sent\n240:                # self.outbufs[-1] must always be a writable outbuf\n241:                if len(self.outbufs) > 1:\n242:                    toclose = self.outbufs.pop(0)\n263:            for outbuf in self.outbufs:\n269:            self.total_outbufs_len = 0\n306:                self._flush_outbufs_below_high_watermark()\n311:                    self.outbufs.append(data)\n313:                    self.outbufs.append(nextbuf)\n320:                        self.outbufs.append(nextbuf)\n322:                    self.outbufs[-1].append(data)\n325:                self.total_outbufs_len += num_bytes\n333:    def _flush_outbufs_below_high_watermark(self):\n335:        if self.total_outbufs_len > self.adj.outbuf_high_watermark:\n339:                    self.total_outbufs_len > self.adj.outbuf_high_watermark\n395:                    # much data in the outbufs waiting to be flushed\n402:                        self._flush_outbufs_below_high_watermark()\n",
  "stderr": "",
  "exit_code": 0
}

Let's find where the buffers are read from. `OverflowableBuffer` probably has a `get` method.
Wait, `ReadOnlyFileBasedBuffer` also has a `get` method.

In `waitress/channel.py` around line 223, `outbuf = self.outbufs[0]` is used. Let's see what happens with `outbuf`.

{
  "end_line": 250,
  "filepath": "waitress/channel.py",
  "start_line": 210
}

{
  "status": "ok",
  "filepath": "waitress/channel.py",
  "content": "\n                if self.total_outbufs_len < self.adj.outbuf_high_watermark:\n                    self.outbuf_lock.notify()\n            finally:\n                self.outbuf_lock.release()\n\n    def _flush_some(self):\n        # Send as much data as possible to our client\n\n        sent = 0\n        dobreak = False\n\n        while True:\n            outbuf = self.outbufs[0]\n            # use outbuf.__len__ rather than len(outbuf) FBO of not getting\n            # OverflowError on 32-bit Python\n            outbuflen = outbuf.__len__()\n            while outbuflen > 0:\n                chunk = outbuf.get(self.sendbuf_len)\n                num_sent = self.send(chunk)\n                if num_sent:\n                    outbuf.skip(num_sent, True)\n                    outbuflen -= num_sent\n                    sent += num_sent\n                    self.total_outbufs_len -= num_sent\n                else:\n                    # failed to write anything, break out entirely\n                    dobreak = True\n                    break\n            else:\n                # self.outbufs[-1] must always be a writable outbuf\n                if len(self.outbufs) > 1:\n                    toclose = self.outbufs.pop(0)\n                    try:\n                        toclose.close()\n                    except Exception:\n                        self.logger.exception(\n                            'Unexpected error when closing an outbuf')\n                else:\n                    # caught up, done flushing for now\n                    dobreak = True",
  "start_line": 210,
  "end_line": 250,
  "total_lines": 415,
  "is_truncated": false
}

Yes, `chunk = outbuf.get(self.sendbuf_len)` is called. And `outbuf.skip(num_sent, True)` is called.

`ReadOnlyFileBasedBuffer.get` and `ReadOnlyFileBasedBuffer.skip` (from `FileBasedBuffer`) both use `tell()` and `seek()`.

So if a `ReadOnlyFileBasedBuffer` is created with a non-seekable file, it will crash in `prepare`, and if it survives that, it will crash in `get` and `skip`.

However, if `prepare` returns 0 (which it will if we catch the exception), it will NOT be used in `write_soon` optimization path, and instead it'll be iterated over in `task.py`:

```python
            first_chunk_len = None
            for chunk in app_iter:
                if first_chunk_len is None:
```

And `ReadOnlyFileBasedBuffer.__next__` uses `self.file.read(self.block_size)`, which does NOT require seek/tell.

So the correct fix is to ensure that `prepare` returns 0 (or fails gracefully) if the file is not seekable, so that the system falls back to the iterator.

Wait, but if `self.file` has `seek` and `tell` but they raise `UnsupportedOperation`, `prepare` currently crashes. If we catch this and return 0, it will be fine.

But we should also consider `get` and `skip` just in case `ReadOnlyFileBasedBuffer` is used elsewhere.

Actually, `ReadOnlyFileBasedBuffer` is designed for files. If a file is not seekable, it's basically just a stream.

Let's look at `ReadOnlyFileBasedBuffer.prepare` again.

```python
    def prepare(self, size=None):
        if hasattr(self.file, 'seek') and hasattr(self.file, 'tell'):
            start_pos = self.file.tell()
            self.file.seek(0, 2)
            end_pos = self.file.tell()
            self.file.seek(start_pos)
            fsize = end_pos - start_pos
            if size is None:
                self.remain = fsize
            else:
                self.remain = min(fsize, size)
        return self.remain
```

I should wrap the `seek`/`tell` block in a try-except `UnsupportedOperation`.

What about `io.UnsupportedOperation`? I should import it. It's in the `io` module.

Wait, does `ReadOnlyFileBasedBuffer` need to support `get` and `skip` for non-seekable files?
If `prepare` returns 0, the `task.py` loop uses `__iter__`, which is fine.

But what if someone uses `ReadOnlyFileBasedBuffer` and calls `get` directly?
`get` uses `tell()` and `seek()`.

```python
    def get(self, numbytes=-1, skip=False):
        # never read more than self.remain (it can be user-specified)
        if numbytes == -1 or numbytes > self.remain:
            numbytes = self.remain
        file = self.file
        if not skip:
            read_pos = file.tell()
        res = file.read(numbytes)
        if skip:
            self.remain -= len(res)
        else:
            file.seek(read_pos)
        return res
```

If the file is not seekable, `get`'s `file.tell()` and `file.seek(read_pos)` will fail.

However, `get` is called with `skip=False` by default. If it's not seekable, we can't really "peek" and then "put back" the read data. `ReadOnlyFileBasedBuffer.get` seems to be implementing a peeking read.

If the file is not seekable, this behavior is impossible.

But wait, `ReadOnlyFileBasedBuffer` is specifically for `wsgi.file_wrapper`. The WSGI spec for `file_wrapper` says it should return an object that implements the iteration protocol. Seek/tell are optional.

In `task.py`, the optimization uses `ReadOnlyFileBasedBuffer.get`, but if `prepare` returns 0, it uses the iterator.

So if we make `prepare` return 0 on `UnsupportedOperation`, we are safe for the `task.py` usage.

What about `get`?
If `prepare` returned 0, then `get` is called with `numbytes` that becomes `self.remain` which is 0.
Then `file.tell()` is called. Crash.

Actually, if `self.remain` is 0, `get` should probably just return `b''` or something, but it still calls `file.tell()`.

Let's see if we should also protect `get`.

```python
    def get(self, numbytes=-1, skip=False):
        # never read more than self.remain (it can be user-specified)
        if numbytes == -1 or numbytes > self.remain:
            numbytes = self.remain
        if numbytes <= 0:
            return b''
        # ...
```

If `numbytes` is 0, we can just return `b''` and avoid `tell()`.

Wait, if `numbytes` was specified as 100, but `self.remain` is 0, it returns `b''`. That's correct.

But if `self.remain` is 100 and the file is not seekable (somehow `remain` was set), `get` will still crash.

Let's look at `ReadOnlyFileBasedBuffer.prepare` again. If it can't determine the size, `self.remain` stays 0.

If `self.remain` is 0, `get` will:
1. `numbytes = self.remain` (which is 0)
2. `file.tell()` -> CRASH.

So `get` should also be protected.

Wait, if `self.remain` is 0, `get` is basically useless.

Let's see if we can just make `get` and `skip` check for seekability/capture `UnsupportedOperation` as well.

Actually, if the file is not seekable, `ReadOnlyFileBasedBuffer` cannot support `get` (peeking) or `skip`. It can only support `__iter__` (sequential read).

So maybe we should just ensure that if the file is not seekable, `prepare` returns 0 and `get` returns `b''`.

Let's refine the plan:
1.  Import `UnsupportedOperation` from `io`.
2.  Modify `ReadOnlyFileBasedBuffer.prepare` to catch `UnsupportedOperation` and return `self.remain` (which will be 0).
3.  Modify `ReadOnlyFileBasedBuffer.get` to check if `numbytes <= 0` first, and return `b''`.
4.  Also, if `numbytes > 0`, we should still be careful if `self.file` is not seekable.

Wait, if `self.remain` is 0, `get` should return `b''`.
If `self.remain > 0`, `get` will try to seek/tell. If it fails, what should it do?
It can't really "peek".

But if `prepare` correctly returns 0 for non-seekable files, then `self.remain` will be 0 and `get` will be called with `numbytes=0`.

Let's see:
```python
    def get(self, numbytes=-1, skip=False):
        # never read more than self.remain (it can be user-specified)
        if numbytes == -1 or numbytes > self.remain:
            numbytes = self.remain
        if numbytes <= 0:
            return b''
        # ...
```

If `self.remain` is 0, `numbytes` becomes 0, and it returns `b''`. No crash!

What about `skip`?
`FileBasedBuffer.skip` uses `self.file.seek(numbytes, 1)`.

```python
    def skip(self, numbytes, allow_prune=0):
        if self.remain < numbytes:
            raise ValueError("Can't skip %d bytes in buffer of %d bytes" % (
                numbytes, self.remain
            ))
        self.file.seek(numbytes, 1)
        self.remain = self.remain - numbytes
```

If `self.remain` is 0 and `numbytes` is 0, it calls `seek(0, 1)`. This might still crash on non-seekable files.

But `skip` is probably called after `get` by the channel.
In `_flush_some`:
```python
                chunk = outbuf.get(self.sendbuf_len)
                num_sent = self.send(chunk)
                if num_sent:
                    outbuf.skip(num_sent, True)
```

Wait, `outbuf.skip(num_sent, True)`.
Looking at `FileBasedBuffer.skip`:
```python
    def skip(self, numbytes, allow_prune=0):
        # ...
        self.file.seek(numbytes, 1)
        self.remain = self.remain - numbytes
```
It doesn't use the `allow_prune` argument for anything other than the name? Wait, I don't see it being used.

Oh, `ReadOnlyFileBasedBuffer` DOES NOT override `skip`. It uses `FileBasedBuffer.skip`.

But wait, `ReadOnlyFileBasedBuffer.get` has a `skip` parameter!

```python
    def get(self, numbytes=-1, skip=False):
        # ...
        if skip:
            self.remain -= len(res)
        else:
            file.seek(read_pos)
        return res
```

If `skip=True` is passed to `get`, it doesn't call `seek()`.

In `_flush_some`, `outbuf.get(self.sendbuf_len)` is called. `skip` is `False` by default.
Then `outbuf.skip(num_sent, True)` is called.

Wait, `ReadOnlyFileBasedBuffer` DOES NOT have a `skip` method! It inherits from `FileBasedBuffer`.
`FileBasedBuffer.skip` is:

```python
    def skip(self, numbytes, allow_prune=0):
        if self.remain < numbytes:
            raise ValueError("Can't skip %d bytes in buffer of %d bytes" % (
                numbytes, self.remain
            ))
        self.file.seek(numbytes, 1)
        self.remain = self.remain - numbytes
```

Wait, if `ReadOnlyFileBasedBuffer` is used, then `get` is called with `skip=False`.
Then `skip(num_sent, True)` is called.
The `True` here is passed as `allow_prune`.
Then `self.file.seek(num_sent, 1)` is called. This will crash on non-seekable files.

But again, if `prepare` returns 0, then `ReadOnlyFileBasedBuffer` is NOT used as an `outbuf` in `channel.py`. It's used in the `for chunk in app_iter` loop in `task.py`.

So we only need to make sure `prepare` returns 0 if the file is not seekable.

But wait, `ReadOnlyFileBasedBuffer` is a public class. What if someone uses it and calls `get` or `skip`?
Well, the problem statement says: "Currently waitress is just crashing if it receives an `io.IOBase` subclasses which is not seekable as the file to serve."

The "file to serve" usually means it's passed to `wsgi.file_wrapper`, which in waitress's case means it's wrapped in `ReadOnlyFileBasedBuffer`.

So the main crash is in `prepare` during `task.py` execution.

Let's verify this. In my reproduction script:
```python
buf = NonSeekableBuffer()
rop = ReadOnlyFileBasedBuffer(buf)
rop.prepare() # crashes here
```

If I fix `prepare` and it returns 0, then in `task.py`:
```python
                if app_iter.__class__ is ReadOnlyFileBasedBuffer:
                    cl = self.content_length
                    size = app_iter.prepare(cl)
                    if size:
                        # ... optimization path ...
                        return
            # fallback to iterator
            for chunk in app_iter:
                # ...
```
It will use the iterator. And `__next__` just calls `read()`, which works.

So the primary fix is in `prepare`.

Should I also fix `get` and `skip`?
If `prepare` returned 0, `self.remain` is 0.
If the user calls `rop.get(10)`, `numbytes` becomes 0, it returns `b''`. (If I add the `numbytes <= 0` check).
If the user calls `rop.skip(10)`, it raises `ValueError("Can't skip 10 bytes in buffer of 0 bytes")`.

So it seems we just need to fix `prepare` and maybe `get` for completeness.

Wait, if `prepare` is called with a `size` > 0, and the file is not seekable, should we set `self.remain` to `size`?
The current code:
```python
            if size is None:
                self.remain = fsize
            else:
                self.remain = min(fsize, size)
```
If we can't find `fsize`, we can't do `min(fsize, size)`.
If the user provided `size`, maybe we can use it?
But `ReadOnlyFileBasedBuffer.get` uses `self.remain` to limit reading, AND it uses `seek`/`tell` to peek. If it's not seekable, it can't peek, so `get` is broken anyway.

The safest thing is to return a falsy value from `prepare` (like 0 or `None` - although `FileBasedBuffer.remain` is 0) if we can't determine the size and it's not seekable.

Actually, the problem description says: "In `io.IOBase` subclasses that are not seekable, those two methods exist but raise an `UnsupportedOperation`, in case of io.IOBase instance `.seekable` should probably be checked for `True` or the `UnsupportedOperation` should be trapped."

Let's do both: check `seekable()` if it exists, and trap `UnsupportedOperation`.

Wait, if I only trap `UnsupportedOperation` in `prepare`, is that enough?
Yes, for the case where it's used as `wsgi.file_wrapper` in `task.py`.

Let's check if `io.UnsupportedOperation` is available in `waitress/buffers.py`.
No, it's only importing `BytesIO` from `io`.

I should add `from io import BytesIO, UnsupportedOperation`.

One detail: `UnsupportedOperation` was added in Python 3. We should check if we need compatibility.
But `waitress` seems to be targeting Python 3 (based on `__next__ = next # py3`).

Wait, let's check `waitress/compat.py` if there are any compatibility wrappers.

{
  "filepath": "waitress/compat.py"
}

{
  "status": "ok",
  "filepath": "waitress/compat.py",
  "content": "import os\nimport sys\nimport types\nimport platform\nimport warnings\n\ntry:\n    import urlparse\nexcept ImportError: # pragma: no cover\n    from urllib import parse as urlparse\n\ntry:\n    import fcntl\nexcept ImportError: # pragma: no cover\n    fcntl = None # windows\n\n# True if we are running on Python 3.\nPY2 = sys.version_info[0] == 2\nPY3 = sys.version_info[0] == 3\n\n# True if we are running on Windows\nWIN = platform.system() == 'Windows'\n\nif PY3: # pragma: no cover\n    string_types = str,\n    integer_types = int,\n    class_types = type,\n    text_type = str\n    binary_type = bytes\n    long = int\nelse:\n    string_types = basestring,\n    integer_types = (int, long)\n    class_types = (type, types.ClassType)\n    text_type = unicode\n    binary_type = str\n    long = long\n\nif PY3: # pragma: no cover\n    from urllib.parse import unquote_to_bytes\n    def unquote_bytes_to_wsgi(bytestring):\n        return unquote_to_bytes(bytestring).decode('latin-1')\nelse:\n    from urlparse import unquote as unquote_to_bytes\n    def unquote_bytes_to_wsgi(bytestring):\n        return unquote_to_bytes(bytestring)\n\ndef text_(s, encoding='latin-1', errors='strict'):\n    \"\"\" If ``s`` is an instance of ``binary_type``, return\n    ``s.decode(encoding, errors)``, otherwise return ``s``\"\"\"\n    if isinstance(s, binary_type):\n        return s.decode(encoding, errors)\n    return s # pragma: no cover\n\nif PY3: # pragma: no cover\n    def tostr(s):\n        if isinstance(s, text_type):\n            s = s.encode('latin-1')\n        return str(s, 'latin-1', 'strict')\n\n    def tobytes(s):\n        return bytes(s, 'latin-1')\nelse:\n    tostr = str\n\n    def tobytes(s):\n        return s\n\nif PY3: # pragma: no cover\n    import builtins\n    exec_ = getattr(builtins, \"exec\")\n\n    def reraise(tp, value, tb=None):\n        if value is None:\n            value = tp\n        if value.__traceback__ is not tb:\n            raise value.with_traceback(tb)\n        raise value\n\n    del builtins\n\nelse: # pragma: no cover\n    def exec_(code, globs=None, locs=None):\n        \"\"\"Execute code in a namespace.\"\"\"\n        if globs is None:\n            frame = sys._getframe(1)\n            globs = frame.f_globals\n            if locs is None:\n                locs = frame.f_locals\n            del frame\n        elif locs is None:\n            locs = globs\n        exec(\"\"\"exec code in globs, locs\"\"\")\n\n    exec_(\"\"\"def reraise(tp, value, tb=None):\n    raise tp, value, tb\n\"\"\")\n\ntry:\n    from StringIO import StringIO as NativeIO\nexcept ImportError: # pragma: no cover\n    from io import StringIO as NativeIO\n\ntry:\n    import httplib\nexcept ImportError: # pragma: no cover\n    from http import client as httplib\n\ntry:\n    MAXINT = sys.maxint\nexcept AttributeError: # pragma: no cover\n    MAXINT = sys.maxsize\n\n\n# Fix for issue reported in https://github.com/Pylons/waitress/issues/138,\n# Python on Windows may not define IPPROTO_IPV6 in socket.\nimport socket\n\nHAS_IPV6 = socket.has_ipv6\n\nif hasattr(socket, 'IPPROTO_IPV6') and hasattr(socket, 'IPV6_V6ONLY'):\n    IPPROTO_IPV6 = socket.IPPROTO_IPV6\n    IPV6_V6ONLY = socket.IPV6_V6ONLY\nelse: # pragma: no cover\n    if WIN:\n        IPPROTO_IPV6 = 41\n        IPV6_V6ONLY = 27\n    else:\n        warnings.warn(\n            'OS does not support required IPv6 socket flags. This is requirement '\n            'for Waitress. Please open an issue at https://github.com/Pylons/waitress. '\n            'IPv6 support has been disabled.',\n            RuntimeWarning\n        )\n        HAS_IPV6 = False\n\ndef set_nonblocking(fd): # pragma: no cover\n    if PY3 and sys.version_info[1] >= 5:\n        os.set_blocking(fd, False)\n    elif fcntl is None:\n        raise RuntimeError('no fcntl module present')\n    else:\n        flags = fcntl.fcntl(fd, fcntl.F_GETFL, 0)\n        flags = flags | os.O_NONBLOCK\n        fcntl.fcntl(fd, fcntl.F_SETFL, flags)\n\nif PY3:\n    ResourceWarning = ResourceWarning\nelse:\n    ResourceWarning = UserWarning",
  "start_line": 1,
  "end_line": 150,
  "total_lines": 162,
  "is_truncated": true
}

The code has substantial Python 2 support. `UnsupportedOperation` was added in Python 3.
For Python 2, we might need to handle different exceptions or just check for `seekable()`.
But `io.UnsupportedOperation` is the one raised by `io.IOBase` in Python 3.

In Python 2, the `io` module also exists, but `UnsupportedOperation` might be different (actually it's `io.UnsupportedOperation` in both).

Let's check if `io.UnsupportedOperation` is available in the environment.
The reproduction script already used it (wait, no, my reproduction script didn't use it, it just printed the exception).

{
  "command": "python3 - <<'PY'\nimport io\ntry:\n    print(io.UnsupportedOperation)\n    print(\"Available\")\nexcept AttributeError:\n    print(\"Not available\")\nPY\n"
}

{
  "status": "ok",
  "stdout": "<class 'io.UnsupportedOperation'>\nAvailable\n",
  "stderr": "",
  "exit_code": 0
}