Modified return type for ipaddr

[carlosb1]

What does this PR do

Fixes #2003

Checklist:

• I have read CONTRIBUTING.md
• I have written necessary tests and rustdoc comments
• A change log has been added if this PR modifies nix's API

[SteveLauC]

It seems that we can also retain the const here if we choose the following impl:

    pub const fn ip(&self) -> Ipv4Addr {
        let bytes = self.0.sin_addr.s_addr.to_ne_bytes();
        let (a, b, c, d) = (bytes[0], bytes[1], bytes[2], bytes[3]);
        Ipv4Addr::new(a, b, c, d)
    }

[SteveLauC]

And for SockaddrIn6::ip(), we can also make it const with a similar impl:

    pub const fn ip(&self) -> Ipv6Addr {
        let bytes = self.0.sin6_addr.s6_addr;
        let [a, b, c, d, e, f, g, h] =
            unsafe { transmute::<_, [u16; 8]>(bytes) };
        
        // Ipv6Addr::new() takes segments in native endian, convert them here
        let [a, b, c, d, e, f, g, h] = [
            u16::from_be(a),
            u16::from_be(b),
            u16::from_be(c),
            u16::from_be(d),
            u16::from_be(e),
            u16::from_be(f),
            u16::from_be(g),
            u16::from_be(h),
        ];

        Ipv6Addr::new(a, b, c, d, e, f, g, h)
    }

[SteveLauC]

cc @asomers, these two types were added in #1684

[asomers]

And for SockaddrIn6::ip(), we can also make it const with a similar impl:

    pub const fn ip(&self) -> Ipv6Addr {
        let bytes = self.0.sin6_addr.s6_addr;
        let [a, b, c, d, e, f, g, h] =
            unsafe { transmute::<_, [u16; 8]>(bytes) };
        
        // Ipv6Addr::new() takes segments in native endian, convert them here
        let [a, b, c, d, e, f, g, h] = [
            u16::from_be(a),
            u16::from_be(b),
            u16::from_be(c),
            u16::from_be(d),
            u16::from_be(e),
            u16::from_be(f),
            u16::from_be(g),
            u16::from_be(h),
        ];

        Ipv6Addr::new(a, b, c, d, e, f, g, h)
    }

mem::transmute should be a last resort. I don't think we need it here. We could do the conversion more verbosely just by addressing the individual octets directly.

[carlosb1]

And for SockaddrIn6::ip(), we can also make it const with a similar impl:

    pub const fn ip(&self) -> Ipv6Addr {
        let bytes = self.0.sin6_addr.s6_addr;
        let [a, b, c, d, e, f, g, h] =
            unsafe { transmute::<_, [u16; 8]>(bytes) };
        
        // Ipv6Addr::new() takes segments in native endian, convert them here
        let [a, b, c, d, e, f, g, h] = [
            u16::from_be(a),
            u16::from_be(b),
            u16::from_be(c),
            u16::from_be(d),
            u16::from_be(e),
            u16::from_be(f),
            u16::from_be(g),
            u16::from_be(h),
        ];

        Ipv6Addr::new(a, b, c, d, e, f, g, h)
    }

mem::transmute should be a last resort. I don't think we need it here. We could do the conversion more verbosely just by addressing the individual octets directly.

I reimplemented it

[SteveLauC]

LGTM! Sorry for the late review, thanks for doing this!

[SteveLauC]

I forgot to mention that we have changed the CHANGELOG mode in #2149, let me fix this later