amazon-cloudfront-client-routing-lib 1.0.0

a library to encode and decode dns labels
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

enum SubnetMask {
    Ipv4 = 24,
    Ipv6 = 48,
}

/// Struct containing 3 values needed for encoding: `client_subnet`,
/// `subnet_mask`, and `is_ipv6`.
///
/// Each property is a u64 because
/// [`EncodableData`](crate::client_routing_label::EncodableData) expects a u64.
/// `client_subnet` should be formatted as a u64 by shifting each octet into an
/// unsigned integer, applying the subnet mask, then shifting until the number
/// conforms to 64 bits.
///
/// # Examples
/// ```
/// use amazon_cloudfront_client_routing_lib::ip::ClientSubnetEncodingData;
///
/// // raw values
/// let client_ip = [1, 2, 3, 4];
/// let subnet_mask = 24;
/// let is_ipv6 = 0;
///
/// // shift bytes into int
/// let mut client_subnet = u32::from_be_bytes(client_ip) as u64;
/// // apply subnet mask
/// client_subnet &= 0xffffff00;
/// // conform to 64 bits
/// client_subnet <<= 32;
///
/// let client_subnet_encoding_data = ClientSubnetEncodingData {
///     client_subnet,
///     subnet_mask,
///     is_ipv6,
/// };
/// ```
pub struct ClientSubnetEncodingData {
    pub client_subnet: u64,
    pub subnet_mask: u64,
    pub is_ipv6: u64,
}

/// Parses passed `client_ip` into various data, returns
/// [`ClientSubnetEncodingData`].
///
/// Takes in one param: `client_ip`. Attempts to parse the `client_ip` into an
/// [`IpAddr`]. If successful, determines if it's an [`Ipv4Addr`] or an
/// [`Ipv6Addr`]. Returns [`ClientSubnetEncodingData`] with the parsed
/// information. If unsuccessful, returns [`ClientSubnetEncodingData`] with all
/// properties set to 0.
///
/// # Examples:
/// ```
/// use amazon_cloudfront_client_routing_lib::ip::parse_client_ip;
///
/// // Ipv4
/// let mut client_subnet_encoding_data = parse_client_ip("1.2.3.4");
/// assert_eq!([1, 2, 3, 0, 0, 0, 0, 0], client_subnet_encoding_data.client_subnet.to_be_bytes());
/// assert_eq!(24, client_subnet_encoding_data.subnet_mask);
/// assert_eq!(0, client_subnet_encoding_data.is_ipv6);
///
/// // Ipv6
/// client_subnet_encoding_data = parse_client_ip("0102:0304:0506:0708:090a:0b0c:0d0e:0f10");
/// assert_eq!([1, 2, 3, 4, 5, 6, 0, 0], client_subnet_encoding_data.client_subnet.to_be_bytes());
/// assert_eq!(48, client_subnet_encoding_data.subnet_mask);
/// assert_eq!(1, client_subnet_encoding_data.is_ipv6);
///
/// // Invalid client ip
/// client_subnet_encoding_data = parse_client_ip("1.2.a");
/// assert_eq!([0, 0, 0, 0, 0, 0, 0, 0], client_subnet_encoding_data.client_subnet.to_be_bytes());
/// assert_eq!(0, client_subnet_encoding_data.subnet_mask);
/// assert_eq!(0, client_subnet_encoding_data.is_ipv6);
/// ```
pub fn parse_client_ip(client_ip: &str) -> ClientSubnetEncodingData {
    if let Ok(addr) = client_ip.parse::<IpAddr>() {
        if addr.is_ipv4() {
            // unwrap is ok here because we verify it is parsable before
            let ipv4_address: Ipv4Addr = client_ip.parse().unwrap();
            ClientSubnetEncodingData {
                client_subnet: (u32::from_be_bytes(ipv4_address.octets()) as u64 & 0xffffff00)
                    << 32,
                subnet_mask: SubnetMask::Ipv4 as u64,
                is_ipv6: 0,
            }
        } else {
            // unwrap is ok here because we verify it is parsable before
            let ipv6_address: Ipv6Addr = client_ip.parse().unwrap();
            ClientSubnetEncodingData {
                client_subnet: ((u128::from_be_bytes(ipv6_address.octets()) >> 64)
                    & 0xffffffffffff0000) as u64,
                subnet_mask: SubnetMask::Ipv6 as u64,
                is_ipv6: 1,
            }
        }
    } else {
        ClientSubnetEncodingData {
            client_subnet: 0,
            subnet_mask: 0,
            is_ipv6: 0,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::parse_client_ip;

    #[test]
    fn validate_parse_ipv4() {
        let client_subnet_encoding_data = parse_client_ip("85.83.215.126");

        assert_eq!(
            6148494311290830848,
            client_subnet_encoding_data.client_subnet
        );
        assert_eq!(24, client_subnet_encoding_data.subnet_mask);
        assert_eq!(0, client_subnet_encoding_data.is_ipv6);
    }

    #[test]
    fn validate_parse_ipv6() {
        let client_subnet_encoding_data =
            parse_client_ip("819e:5c2e:21e4:0094:4805:1635:f8e4:049b");

        assert_eq!(
            9340004030419828736,
            client_subnet_encoding_data.client_subnet
        );
        assert_eq!(48, client_subnet_encoding_data.subnet_mask);
        assert_eq!(1, client_subnet_encoding_data.is_ipv6);
    }

    #[test]
    fn validate_parse_abbreviated_ipv6() {
        let client_subnet_encoding_data = parse_client_ip("0319:7db1:f4d6::");

        assert_eq!(
            223347859801899008,
            client_subnet_encoding_data.client_subnet
        );
        assert_eq!(48, client_subnet_encoding_data.subnet_mask);
        assert_eq!(1, client_subnet_encoding_data.is_ipv6);
    }

    #[test]
    fn validate_parse_invalid_client_ip() {
        let client_subnet_encoding_data = parse_client_ip("1.2");

        assert_eq!(0, client_subnet_encoding_data.client_subnet);
        assert_eq!(0, client_subnet_encoding_data.subnet_mask);
        assert_eq!(0, client_subnet_encoding_data.is_ipv6);
    }
}