1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 //! A private parser implementation of IPv4, IPv6, and socket addresses.
13 //! This module is "publicly exported" through the `FromStr` implementations
20 use net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
24 // parsing as ASCII, so can use byte array
30 fn new(s: &'a str) -> Parser<'a> {
37 fn is_eof(&self) -> bool {
38 self.pos == self.s.len()
41 // Commit only if parser returns Some
42 fn read_atomically<T, F>(&mut self, cb: F) -> Option<T> where
43 F: FnOnce(&mut Parser) -> Option<T>,
53 // Commit only if parser read till EOF
54 fn read_till_eof<T, F>(&mut self, cb: F) -> Option<T> where
55 F: FnOnce(&mut Parser) -> Option<T>,
57 self.read_atomically(move |p| {
59 Some(x) => if p.is_eof() {Some(x)} else {None},
65 // Return result of first successful parser
66 fn read_or<T>(&mut self, parsers: &mut [Box<FnMut(&mut Parser) -> Option<T> + 'static>])
69 if let Some(r) = self.read_atomically(|p: &mut Parser| pf(p)) {
76 // Apply 3 parsers sequentially
77 fn read_seq_3<A, B, C, PA, PB, PC>(&mut self,
81 -> Option<(A, B, C)> where
82 PA: FnOnce(&mut Parser) -> Option<A>,
83 PB: FnOnce(&mut Parser) -> Option<B>,
84 PC: FnOnce(&mut Parser) -> Option<C>,
86 self.read_atomically(move |p| {
88 let b = if a.is_some() { pb(p) } else { None };
89 let c = if b.is_some() { pc(p) } else { None };
91 (Some(a), Some(b), Some(c)) => Some((a, b, c)),
98 fn read_char(&mut self) -> Option<char> {
102 let r = self.s[self.pos] as char;
108 // Return char and advance iff next char is equal to requested
109 fn read_given_char(&mut self, c: char) -> Option<char> {
110 self.read_atomically(|p| {
111 match p.read_char() {
112 Some(next) if next == c => Some(next),
119 fn read_digit(&mut self, radix: u8) -> Option<u8> {
120 fn parse_digit(c: char, radix: u8) -> Option<u8> {
122 // assuming radix is either 10 or 16
123 if c >= b'0' && c <= b'9' {
125 } else if radix > 10 && c >= b'a' && c < b'a' + (radix - 10) {
127 } else if radix > 10 && c >= b'A' && c < b'A' + (radix - 10) {
134 self.read_atomically(|p| {
135 p.read_char().and_then(|c| parse_digit(c, radix))
139 fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
141 let mut digit_count = 0;
143 match self.read_digit(radix) {
145 r = r * (radix as u32) + (d as u32);
147 if digit_count > max_digits || r >= upto {
152 if digit_count == 0 {
162 // Read number, failing if max_digits of number value exceeded
163 fn read_number(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
164 self.read_atomically(|p| p.read_number_impl(radix, max_digits, upto))
167 fn read_ipv4_addr_impl(&mut self) -> Option<Ipv4Addr> {
171 if i != 0 && self.read_given_char('.').is_none() {
175 let octet = self.read_number(10, 3, 0x100).map(|n| n as u8);
177 Some(d) => bs[i] = d,
182 Some(Ipv4Addr::new(bs[0], bs[1], bs[2], bs[3]))
186 fn read_ipv4_addr(&mut self) -> Option<Ipv4Addr> {
187 self.read_atomically(|p| p.read_ipv4_addr_impl())
190 fn read_ipv6_addr_impl(&mut self) -> Option<Ipv6Addr> {
191 fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> Ipv6Addr {
192 assert!(head.len() + tail.len() <= 8);
194 gs[..head.len()].copy_from_slice(head);
195 gs[(8 - tail.len()) .. 8].copy_from_slice(tail);
196 Ipv6Addr::new(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
199 fn read_groups(p: &mut Parser, groups: &mut [u16; 8], limit: usize)
204 let ipv4 = p.read_atomically(|p| {
205 if i == 0 || p.read_given_char(':').is_some() {
211 if let Some(v4_addr) = ipv4 {
212 let octets = v4_addr.octets();
213 groups[i + 0] = ((octets[0] as u16) << 8) | (octets[1] as u16);
214 groups[i + 1] = ((octets[2] as u16) << 8) | (octets[3] as u16);
215 return (i + 2, true);
219 let group = p.read_atomically(|p| {
220 if i == 0 || p.read_given_char(':').is_some() {
221 p.read_number(16, 4, 0x10000).map(|n| n as u16)
227 Some(g) => groups[i] = g,
228 None => return (i, false)
235 let mut head = [0; 8];
236 let (head_size, head_ipv4) = read_groups(self, &mut head, 8);
239 return Some(Ipv6Addr::new(
240 head[0], head[1], head[2], head[3],
241 head[4], head[5], head[6], head[7]))
244 // IPv4 part is not allowed before `::`
249 // read `::` if previous code parsed less than 8 groups
250 if !self.read_given_char(':').is_some() || !self.read_given_char(':').is_some() {
254 let mut tail = [0; 8];
255 let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
256 Some(ipv6_addr_from_head_tail(&head[..head_size], &tail[..tail_size]))
259 fn read_ipv6_addr(&mut self) -> Option<Ipv6Addr> {
260 self.read_atomically(|p| p.read_ipv6_addr_impl())
263 fn read_ip_addr(&mut self) -> Option<IpAddr> {
264 let ipv4_addr = |p: &mut Parser| p.read_ipv4_addr().map(IpAddr::V4);
265 let ipv6_addr = |p: &mut Parser| p.read_ipv6_addr().map(IpAddr::V6);
266 self.read_or(&mut [Box::new(ipv4_addr), Box::new(ipv6_addr)])
269 fn read_socket_addr_v4(&mut self) -> Option<SocketAddrV4> {
270 let ip_addr = |p: &mut Parser| p.read_ipv4_addr();
271 let colon = |p: &mut Parser| p.read_given_char(':');
272 let port = |p: &mut Parser| {
273 p.read_number(10, 5, 0x10000).map(|n| n as u16)
276 self.read_seq_3(ip_addr, colon, port).map(|t| {
277 let (ip, _, port): (Ipv4Addr, char, u16) = t;
278 SocketAddrV4::new(ip, port)
282 fn read_socket_addr_v6(&mut self) -> Option<SocketAddrV6> {
283 let ip_addr = |p: &mut Parser| {
284 let open_br = |p: &mut Parser| p.read_given_char('[');
285 let ip_addr = |p: &mut Parser| p.read_ipv6_addr();
286 let clos_br = |p: &mut Parser| p.read_given_char(']');
287 p.read_seq_3(open_br, ip_addr, clos_br).map(|t| t.1)
289 let colon = |p: &mut Parser| p.read_given_char(':');
290 let port = |p: &mut Parser| {
291 p.read_number(10, 5, 0x10000).map(|n| n as u16)
294 self.read_seq_3(ip_addr, colon, port).map(|t| {
295 let (ip, _, port): (Ipv6Addr, char, u16) = t;
296 SocketAddrV6::new(ip, port, 0, 0)
300 fn read_socket_addr(&mut self) -> Option<SocketAddr> {
301 let v4 = |p: &mut Parser| p.read_socket_addr_v4().map(SocketAddr::V4);
302 let v6 = |p: &mut Parser| p.read_socket_addr_v6().map(SocketAddr::V6);
303 self.read_or(&mut [Box::new(v4), Box::new(v6)])
307 #[stable(feature = "rust1", since = "1.0.0")]
308 impl FromStr for IpAddr {
309 type Err = AddrParseError;
310 fn from_str(s: &str) -> Result<IpAddr, AddrParseError> {
311 match Parser::new(s).read_till_eof(|p| p.read_ip_addr()) {
313 None => Err(AddrParseError(()))
318 #[stable(feature = "rust1", since = "1.0.0")]
319 impl FromStr for Ipv4Addr {
320 type Err = AddrParseError;
321 fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> {
322 match Parser::new(s).read_till_eof(|p| p.read_ipv4_addr()) {
324 None => Err(AddrParseError(()))
329 #[stable(feature = "rust1", since = "1.0.0")]
330 impl FromStr for Ipv6Addr {
331 type Err = AddrParseError;
332 fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError> {
333 match Parser::new(s).read_till_eof(|p| p.read_ipv6_addr()) {
335 None => Err(AddrParseError(()))
340 #[stable(feature = "socket_addr_from_str", since = "1.5.0")]
341 impl FromStr for SocketAddrV4 {
342 type Err = AddrParseError;
343 fn from_str(s: &str) -> Result<SocketAddrV4, AddrParseError> {
344 match Parser::new(s).read_till_eof(|p| p.read_socket_addr_v4()) {
346 None => Err(AddrParseError(())),
351 #[stable(feature = "socket_addr_from_str", since = "1.5.0")]
352 impl FromStr for SocketAddrV6 {
353 type Err = AddrParseError;
354 fn from_str(s: &str) -> Result<SocketAddrV6, AddrParseError> {
355 match Parser::new(s).read_till_eof(|p| p.read_socket_addr_v6()) {
357 None => Err(AddrParseError(())),
362 #[stable(feature = "rust1", since = "1.0.0")]
363 impl FromStr for SocketAddr {
364 type Err = AddrParseError;
365 fn from_str(s: &str) -> Result<SocketAddr, AddrParseError> {
366 match Parser::new(s).read_till_eof(|p| p.read_socket_addr()) {
368 None => Err(AddrParseError(())),
373 /// An error returned when parsing an IP address or a socket address.
374 #[stable(feature = "rust1", since = "1.0.0")]
375 #[derive(Debug, Clone, PartialEq)]
376 pub struct AddrParseError(());
378 #[stable(feature = "addr_parse_error_error", since = "1.4.0")]
379 impl fmt::Display for AddrParseError {
380 fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
381 fmt.write_str(self.description())
385 #[stable(feature = "addr_parse_error_error", since = "1.4.0")]
386 impl Error for AddrParseError {
387 fn description(&self) -> &str {
388 "invalid IP address syntax"