Add a version of io::BufRead::read_until() with a read limit

[BlacklightShining]

So there's an ::std::io::BufRead::read_until(), which is great, except in cases where the input is untrusted (e.g. the context of a server process that listens for connections from the general public): while there's no possibility of an actual buffer overflow, an attacker could trivially cause undesirably high memory usage. Thus, read_until() would have to be avoided, but implementations might end up with what amounts to the same thing, with a limit on the amount of data read.

Given that this is a common usecase (it seems so to me, anyway), I propose adding this variation to BufRead as a provided method:

/// As `read_until()`, except that `buf` will be overwritten, not appended to,
/// and with the additional restriction that not more than `buf.len()` bytes
/// will be read.
fn read_until_full(&mut self, byte: u8, buf: &mut [u8]) -> Result<usize> { ... }

(I'm not particularly attached to the name read_until_full. There's probably a better one for it.)

[troplin]

You can use

bufreader.take(max_bytes).read_until(byte, &mut buf)

[BlacklightShining]

…and if you need to reuse bufreader later, you can just do bufreader.by_ref().take(...). Sounds good to me; thanks!

[i3Cheese]

But with take(max_bytes) data after the byte will be lost

[shepmaster]

That’s what #1427 (comment) is about.