Add a way to parse IP addresses without having to utf8-validate

[jyn514]

The only standard way I've found to parse an IP address is IpAddr::from_str. That function immediately converts the string to bytes:

rust/library/std/src/net/parser.rs

Line 44 in 5f4e067

Parser { state: input.as_bytes() }

It would be great to expose some way (not necessarily Parser::new, but something similar) that doesn't require doing unnecessary utf8 validation.

@rustbot label: +T-libs +C-enhancement

[kckeiks]

Hi @jyn514, where is the utf8 validation happening? As you said, the string slice gets converted to a byte slice but then it looks like the parser just works with u8s which get cast to chars at some points in the algorithm

[jyn514]

@kckeiks it happens before you ever pass the string to from_str: I have a byte sequence, and in order to parse it, I'm forced to call std::str::from_utf8.

[kckeiks]

IpAddr implements From for arrays [u8; 4] and [u8; 16]

[jyn514]

I don't have an array. I have a dynamically sized &[u8], and I'm not sure whether it's a valid IP address or not.

[kckeiks]

Gotcha. If this &[u8] is a valid ipv6 address (so it has at least 16 bytes) but the first four bytes make up a valid ipv4 address too then we'd have to make a decision. We could require that the &[u8] be of size 4 or 16 then we'd know how to interpret it?

[kckeiks]

@rustbot claim

[jyn514]

4 and 16 are misleading I think. This is a normal IP address, like "127.0.0.1", it just happens to have come from the network and not be utf8 validated. "127.0.0.1" is 9 bytes, and in general, IP addresses can be variable length.

[kckeiks]

If the address, say "127.0.0.1", comes from the network, as inside an IPv4 header, then it must be a 32 bit value, it would be of the form 01111111 00000000 00000000 000000001 but utf8 encoded IP addresses would have variable length as you said so maybe that is what you're referring to receiving on the network?

[kckeiks]

We could add something like this and add in the docs that this parses IP addresses and assumes that they're utf8 encoded?

impl<'a> TryFrom<&'a [u8]> for IpAddr {
    type Error = AddrParseError;

    fn try_from(b: &'a [u8]) -> Result<IpAddr, Self::Error> {
        Parser::from_bytes(b).parse_with(|p| p.read_ip_addr())
    }
}

[jyn514]

this parses IP addresses and assumes that they're utf8 encoded

It doesn't. No part of that code requires b to be utf8 encoded - if it contains a non-utf8 byte, then it's not a valid IP address anyway, and it returns AddrParseError like normal.

[kckeiks]

It doesn't. No part of that code requires b to be utf8 encoded - if it contains a non-utf8 byte, then it's not a valid IP address anyway, and it returns AddrParseError like normal.

I disagree. The slice of bytes must represent an IP address string in dot notation so the slice of bytes "encodes" this string; some comment should be added to the docs to explain what the slice of bytes is.

For instance, this slice of bytes is bad and would cause a parse error. It doesn't contain non-utf8 byte but it doesn't encode an IP address string in dot notation.

&[127, 0, 0 1]

instead it should be

&[49, 50, 55, 46, 48, 46, 48, 46, 49] 

This is what as_bytes() does - we get the underlying bytes encoding the string.

rust/library/std/src/net/parser.rs

Line 44 in 5f4e067

Parser { state: input.as_bytes() }

[jyn514]

Oh, I see what you mean - you're saying that it should be a byte string, and not an array of the ip numbers. Yes, I agree that's what the code is doing.