1 // FIXME: These tests are all excellent candidates for AFL fuzz testing
2 use core::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
3 use core::str::FromStr;
4
5 const PORT: u16 = 8080;
6 const SCOPE_ID: u32 = 1337;
7
8 const IPV4: Ipv4Addr = Ipv4Addr::new(192, 168, 0, 1);
9 const IPV4_STR: &str = "192.168.0.1";
10 const IPV4_STR_PORT: &str = "192.168.0.1:8080";
11 const IPV4_STR_WITH_OCTAL: &str = "0127.0.0.1";
12 const IPV4_STR_WITH_HEX: &str = "0x10.0.0.1";
13
14 const IPV6: Ipv6Addr = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0xc0a8, 0x1);
15 const IPV6_STR_FULL: &str = "2001:db8:0:0:0:0:c0a8:1";
16 const IPV6_STR_COMPRESS: &str = "2001:db8::c0a8:1";
17 const IPV6_STR_V4: &str = "2001:db8::192.168.0.1";
18 const IPV6_STR_V4_WITH_OCTAL: &str = "2001:db8::0127.0.0.1";
19 const IPV6_STR_V4_WITH_HEX: &str = "2001:db8::0x10.0.0.1";
20 const IPV6_STR_PORT: &str = "[2001:db8::c0a8:1]:8080";
21 const IPV6_STR_PORT_SCOPE_ID: &str = "[2001:db8::c0a8:1%1337]:8080";
22
23 #[test]
parse_ipv4()24 fn parse_ipv4() {
25 let result: Ipv4Addr = IPV4_STR.parse().unwrap();
26 assert_eq!(result, IPV4);
27
28 assert!(Ipv4Addr::from_str(IPV4_STR_PORT).is_err());
29 assert!(Ipv4Addr::from_str(IPV4_STR_WITH_OCTAL).is_err());
30 assert!(Ipv4Addr::from_str(IPV4_STR_WITH_HEX).is_err());
31 assert!(Ipv4Addr::from_str(IPV6_STR_FULL).is_err());
32 assert!(Ipv4Addr::from_str(IPV6_STR_COMPRESS).is_err());
33 assert!(Ipv4Addr::from_str(IPV6_STR_V4).is_err());
34 assert!(Ipv4Addr::from_str(IPV6_STR_PORT).is_err());
35 }
36
37 #[test]
parse_ipv6()38 fn parse_ipv6() {
39 let result: Ipv6Addr = IPV6_STR_FULL.parse().unwrap();
40 assert_eq!(result, IPV6);
41
42 let result: Ipv6Addr = IPV6_STR_COMPRESS.parse().unwrap();
43 assert_eq!(result, IPV6);
44
45 let result: Ipv6Addr = IPV6_STR_V4.parse().unwrap();
46 assert_eq!(result, IPV6);
47
48 assert!(Ipv6Addr::from_str(IPV6_STR_V4_WITH_OCTAL).is_err());
49 assert!(Ipv6Addr::from_str(IPV6_STR_V4_WITH_HEX).is_err());
50 assert!(Ipv6Addr::from_str(IPV4_STR).is_err());
51 assert!(Ipv6Addr::from_str(IPV4_STR_PORT).is_err());
52 assert!(Ipv6Addr::from_str(IPV6_STR_PORT).is_err());
53 }
54
55 #[test]
parse_ip()56 fn parse_ip() {
57 let result: IpAddr = IPV4_STR.parse().unwrap();
58 assert_eq!(result, IpAddr::from(IPV4));
59
60 let result: IpAddr = IPV6_STR_FULL.parse().unwrap();
61 assert_eq!(result, IpAddr::from(IPV6));
62
63 let result: IpAddr = IPV6_STR_COMPRESS.parse().unwrap();
64 assert_eq!(result, IpAddr::from(IPV6));
65
66 let result: IpAddr = IPV6_STR_V4.parse().unwrap();
67 assert_eq!(result, IpAddr::from(IPV6));
68
69 assert!(IpAddr::from_str(IPV4_STR_PORT).is_err());
70 assert!(IpAddr::from_str(IPV6_STR_PORT).is_err());
71 }
72
73 #[test]
parse_socket_v4()74 fn parse_socket_v4() {
75 let result: SocketAddrV4 = IPV4_STR_PORT.parse().unwrap();
76 assert_eq!(result, SocketAddrV4::new(IPV4, PORT));
77
78 assert!(SocketAddrV4::from_str(IPV4_STR).is_err());
79 assert!(SocketAddrV4::from_str(IPV6_STR_FULL).is_err());
80 assert!(SocketAddrV4::from_str(IPV6_STR_COMPRESS).is_err());
81 assert!(SocketAddrV4::from_str(IPV6_STR_V4).is_err());
82 assert!(SocketAddrV4::from_str(IPV6_STR_PORT).is_err());
83 }
84
85 #[test]
parse_socket_v6()86 fn parse_socket_v6() {
87 assert_eq!(IPV6_STR_PORT.parse(), Ok(SocketAddrV6::new(IPV6, PORT, 0, 0)));
88 assert_eq!(IPV6_STR_PORT_SCOPE_ID.parse(), Ok(SocketAddrV6::new(IPV6, PORT, 0, SCOPE_ID)));
89
90 assert!(SocketAddrV6::from_str(IPV4_STR).is_err());
91 assert!(SocketAddrV6::from_str(IPV4_STR_PORT).is_err());
92 assert!(SocketAddrV6::from_str(IPV6_STR_FULL).is_err());
93 assert!(SocketAddrV6::from_str(IPV6_STR_COMPRESS).is_err());
94 assert!(SocketAddrV6::from_str(IPV6_STR_V4).is_err());
95 }
96
97 #[test]
parse_socket()98 fn parse_socket() {
99 let result: SocketAddr = IPV4_STR_PORT.parse().unwrap();
100 assert_eq!(result, SocketAddr::from((IPV4, PORT)));
101
102 let result: SocketAddr = IPV6_STR_PORT.parse().unwrap();
103 assert_eq!(result, SocketAddr::from((IPV6, PORT)));
104
105 assert!(SocketAddr::from_str(IPV4_STR).is_err());
106 assert!(SocketAddr::from_str(IPV6_STR_FULL).is_err());
107 assert!(SocketAddr::from_str(IPV6_STR_COMPRESS).is_err());
108 assert!(SocketAddr::from_str(IPV6_STR_V4).is_err());
109 }
110
111 #[test]
ipv6_corner_cases()112 fn ipv6_corner_cases() {
113 let result: Ipv6Addr = "1::".parse().unwrap();
114 assert_eq!(result, Ipv6Addr::new(1, 0, 0, 0, 0, 0, 0, 0));
115
116 let result: Ipv6Addr = "1:1::".parse().unwrap();
117 assert_eq!(result, Ipv6Addr::new(1, 1, 0, 0, 0, 0, 0, 0));
118
119 let result: Ipv6Addr = "::1".parse().unwrap();
120 assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
121
122 let result: Ipv6Addr = "::1:1".parse().unwrap();
123 assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 1, 1));
124
125 let result: Ipv6Addr = "::".parse().unwrap();
126 assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));
127
128 let result: Ipv6Addr = "::192.168.0.1".parse().unwrap();
129 assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0xc0a8, 0x1));
130
131 let result: Ipv6Addr = "::1:192.168.0.1".parse().unwrap();
132 assert_eq!(result, Ipv6Addr::new(0, 0, 0, 0, 0, 1, 0xc0a8, 0x1));
133
134 let result: Ipv6Addr = "1:1:1:1:1:1:192.168.0.1".parse().unwrap();
135 assert_eq!(result, Ipv6Addr::new(1, 1, 1, 1, 1, 1, 0xc0a8, 0x1));
136 }
137
138 // Things that might not seem like failures but are
139 #[test]
ipv6_corner_failures()140 fn ipv6_corner_failures() {
141 // No IP address before the ::
142 assert!(Ipv6Addr::from_str("1:192.168.0.1::").is_err());
143
144 // :: must have at least 1 set of zeroes
145 assert!(Ipv6Addr::from_str("1:1:1:1::1:1:1:1").is_err());
146
147 // Need brackets for a port
148 assert!(SocketAddrV6::from_str("1:1:1:1:1:1:1:1:8080").is_err());
149 }
150