src/libstd/net/parser.rs

   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.
   4 //
   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.
  10
  11 //! A private parser implementation of IPv4, IPv6, and socket addresses.
  12 //!
  13 //! This module is "publicly exported" through the `FromStr` implementations
  14 //! below.
  15
  16 use error::Error;
  17 use fmt;
  18 use net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
  19 use str::FromStr;
  20
  21 struct Parser<'a> {
  22     // parsing as ASCII, so can use byte array
  23     s: &'a [u8],
  24     pos: usize,
  25 }
  26
  27 impl<'a> Parser<'a> {
  28     fn new(s: &'a str) -> Parser<'a> {
  29         Parser {
  30             s: s.as_bytes(),
  31             pos: 0,
  32         }
  33     }
  34
  35     fn is_eof(&self) -> bool {
  36         self.pos == self.s.len()
  37     }
  38
  39     // Commit only if parser returns Some
  40     fn read_atomically<T, F>(&mut self, cb: F) -> Option<T> where
  41         F: FnOnce(&mut Parser) -> Option<T>,
  42     {
  43         let pos = self.pos;
  44         let r = cb(self);
  45         if r.is_none() {
  46             self.pos = pos;
  47         }
  48         r
  49     }
  50
  51     // Commit only if parser read till EOF
  52     fn read_till_eof<T, F>(&mut self, cb: F) -> Option<T> where
  53         F: FnOnce(&mut Parser) -> Option<T>,
  54     {
  55         self.read_atomically(move |p| {
  56             match cb(p) {
  57                 Some(x) => if p.is_eof() {Some(x)} else {None},
  58                 None => None,
  59             }
  60         })
  61     }
  62
  63     // Return result of first successful parser
  64     fn read_or<T>(&mut self, parsers: &mut [Box<FnMut(&mut Parser) -> Option<T> + 'static>])
  65                -> Option<T> {
  66         for pf in parsers {
  67             if let Some(r) = self.read_atomically(|p: &mut Parser| pf(p)) {
  68                 return Some(r);
  69             }
  70         }
  71         None
  72     }
  73
  74     // Apply 3 parsers sequentially
  75     fn read_seq_3<A, B, C, PA, PB, PC>(&mut self,
  76                                        pa: PA,
  77                                        pb: PB,
  78                                        pc: PC)
  79                                        -> Option<(A, B, C)> where
  80         PA: FnOnce(&mut Parser) -> Option<A>,
  81         PB: FnOnce(&mut Parser) -> Option<B>,
  82         PC: FnOnce(&mut Parser) -> Option<C>,
  83     {
  84         self.read_atomically(move |p| {
  85             let a = pa(p);
  86             let b = if a.is_some() { pb(p) } else { None };
  87             let c = if b.is_some() { pc(p) } else { None };
  88             match (a, b, c) {
  89                 (Some(a), Some(b), Some(c)) => Some((a, b, c)),
  90                 _ => None
  91             }
  92         })
  93     }
  94
  95     // Read next char
  96     fn read_char(&mut self) -> Option<char> {
  97         if self.is_eof() {
  98             None
  99         } else {
 100             let r = self.s[self.pos] as char;
 101             self.pos += 1;
 102             Some(r)
 103         }
 104     }
 105
 106     // Return char and advance iff next char is equal to requested
 107     fn read_given_char(&mut self, c: char) -> Option<char> {
 108         self.read_atomically(|p| {
 109             match p.read_char() {
 110                 Some(next) if next == c => Some(next),
 111                 _ => None,
 112             }
 113         })
 114     }
 115
 116     // Read digit
 117     fn read_digit(&mut self, radix: u8) -> Option<u8> {
 118         fn parse_digit(c: char, radix: u8) -> Option<u8> {
 119             let c = c as u8;
 120             // assuming radix is either 10 or 16
 121             if c >= b'0' && c <= b'9' {
 122                 Some(c - b'0')
 123             } else if radix > 10 && c >= b'a' && c < b'a' + (radix - 10) {
 124                 Some(c - b'a' + 10)
 125             } else if radix > 10 && c >= b'A' && c < b'A' + (radix - 10) {
 126                 Some(c - b'A' + 10)
 127             } else {
 128                 None
 129             }
 130         }
 131
 132         self.read_atomically(|p| {
 133             p.read_char().and_then(|c| parse_digit(c, radix))
 134         })
 135     }
 136
 137     fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
 138         let mut r = 0;
 139         let mut digit_count = 0;
 140         loop {
 141             match self.read_digit(radix) {
 142                 Some(d) => {
 143                     r = r * (radix as u32) + (d as u32);
 144                     digit_count += 1;
 145                     if digit_count > max_digits || r >= upto {
 146                         return None
 147                     }
 148                 }
 149                 None => {
 150                     if digit_count == 0 {
 151                         return None
 152                     } else {
 153                         return Some(r)
 154                     }
 155                 }
 156             };
 157         }
 158     }
 159
 160     // Read number, failing if max_digits of number value exceeded
 161     fn read_number(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
 162         self.read_atomically(|p| p.read_number_impl(radix, max_digits, upto))
 163     }
 164
 165     fn read_ipv4_addr_impl(&mut self) -> Option<Ipv4Addr> {
 166         let mut bs = [0; 4];
 167         let mut i = 0;
 168         while i < 4 {
 169             if i != 0 && self.read_given_char('.').is_none() {
 170                 return None;
 171             }
 172
 173             let octet = self.read_number(10, 3, 0x100).map(|n| n as u8);
 174             match octet {
 175                 Some(d) => bs[i] = d,
 176                 None => return None,
 177             };
 178             i += 1;
 179         }
 180         Some(Ipv4Addr::new(bs[0], bs[1], bs[2], bs[3]))
 181     }
 182
 183     // Read IPv4 address
 184     fn read_ipv4_addr(&mut self) -> Option<Ipv4Addr> {
 185         self.read_atomically(|p| p.read_ipv4_addr_impl())
 186     }
 187
 188     fn read_ipv6_addr_impl(&mut self) -> Option<Ipv6Addr> {
 189         fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> Ipv6Addr {
 190             assert!(head.len() + tail.len() <= 8);
 191             let mut gs = [0; 8];
 192             gs[..head.len()].copy_from_slice(head);
 193             gs[(8 - tail.len()) .. 8].copy_from_slice(tail);
 194             Ipv6Addr::new(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])
 195         }
 196
 197         fn read_groups(p: &mut Parser, groups: &mut [u16; 8], limit: usize)
 198                        -> (usize, bool) {
 199             let mut i = 0;
 200             while i < limit {
 201                 if i < limit - 1 {
 202                     let ipv4 = p.read_atomically(|p| {
 203                         if i == 0 || p.read_given_char(':').is_some() {
 204                             p.read_ipv4_addr()
 205                         } else {
 206                             None
 207                         }
 208                     });
 209                     if let Some(v4_addr) = ipv4 {
 210                         let octets = v4_addr.octets();
 211                         groups[i + 0] = ((octets[0] as u16) << 8) | (octets[1] as u16);
 212                         groups[i + 1] = ((octets[2] as u16) << 8) | (octets[3] as u16);
 213                         return (i + 2, true);
 214                     }
 215                 }
 216
 217                 let group = p.read_atomically(|p| {
 218                     if i == 0 || p.read_given_char(':').is_some() {
 219                         p.read_number(16, 4, 0x10000).map(|n| n as u16)
 220                     } else {
 221                         None
 222                     }
 223                 });
 224                 match group {
 225                     Some(g) => groups[i] = g,
 226                     None => return (i, false)
 227                 }
 228                 i += 1;
 229             }
 230             (i, false)
 231         }
 232
 233         let mut head = [0; 8];
 234         let (head_size, head_ipv4) = read_groups(self, &mut head, 8);
 235
 236         if head_size == 8 {
 237             return Some(Ipv6Addr::new(
 238                 head[0], head[1], head[2], head[3],
 239                 head[4], head[5], head[6], head[7]))
 240         }
 241
 242         // IPv4 part is not allowed before `::`
 243         if head_ipv4 {
 244             return None
 245         }
 246
 247         // read `::` if previous code parsed less than 8 groups
 248         if !self.read_given_char(':').is_some() || !self.read_given_char(':').is_some() {
 249             return None;
 250         }
 251
 252         let mut tail = [0; 8];
 253         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
 254         Some(ipv6_addr_from_head_tail(&head[..head_size], &tail[..tail_size]))
 255     }
 256
 257     fn read_ipv6_addr(&mut self) -> Option<Ipv6Addr> {
 258         self.read_atomically(|p| p.read_ipv6_addr_impl())
 259     }
 260
 261     fn read_ip_addr(&mut self) -> Option<IpAddr> {
 262         let ipv4_addr = |p: &mut Parser| p.read_ipv4_addr().map(IpAddr::V4);
 263         let ipv6_addr = |p: &mut Parser| p.read_ipv6_addr().map(IpAddr::V6);
 264         self.read_or(&mut [Box::new(ipv4_addr), Box::new(ipv6_addr)])
 265     }
 266
 267     fn read_socket_addr_v4(&mut self) -> Option<SocketAddrV4> {
 268         let ip_addr = |p: &mut Parser| p.read_ipv4_addr();
 269         let colon = |p: &mut Parser| p.read_given_char(':');
 270         let port = |p: &mut Parser| {
 271             p.read_number(10, 5, 0x10000).map(|n| n as u16)
 272         };
 273
 274         self.read_seq_3(ip_addr, colon, port).map(|t| {
 275             let (ip, _, port): (Ipv4Addr, char, u16) = t;
 276             SocketAddrV4::new(ip, port)
 277         })
 278     }
 279
 280     fn read_socket_addr_v6(&mut self) -> Option<SocketAddrV6> {
 281         let ip_addr = |p: &mut Parser| {
 282             let open_br = |p: &mut Parser| p.read_given_char('[');
 283             let ip_addr = |p: &mut Parser| p.read_ipv6_addr();
 284             let clos_br = |p: &mut Parser| p.read_given_char(']');
 285             p.read_seq_3(open_br, ip_addr, clos_br).map(|t| t.1)
 286         };
 287         let colon = |p: &mut Parser| p.read_given_char(':');
 288         let port = |p: &mut Parser| {
 289             p.read_number(10, 5, 0x10000).map(|n| n as u16)
 290         };
 291
 292         self.read_seq_3(ip_addr, colon, port).map(|t| {
 293             let (ip, _, port): (Ipv6Addr, char, u16) = t;
 294             SocketAddrV6::new(ip, port, 0, 0)
 295         })
 296     }
 297
 298     fn read_socket_addr(&mut self) -> Option<SocketAddr> {
 299         let v4 = |p: &mut Parser| p.read_socket_addr_v4().map(SocketAddr::V4);
 300         let v6 = |p: &mut Parser| p.read_socket_addr_v6().map(SocketAddr::V6);
 301         self.read_or(&mut [Box::new(v4), Box::new(v6)])
 302     }
 303 }
 304
 305 #[stable(feature = "rust1", since = "1.0.0")]
 306 impl FromStr for IpAddr {
 307     type Err = AddrParseError;
 308     fn from_str(s: &str) -> Result<IpAddr, AddrParseError> {
 309         match Parser::new(s).read_till_eof(|p| p.read_ip_addr()) {
 310             Some(s) => Ok(s),
 311             None => Err(AddrParseError(()))
 312         }
 313     }
 314 }
 315
 316 #[stable(feature = "rust1", since = "1.0.0")]
 317 impl FromStr for Ipv4Addr {
 318     type Err = AddrParseError;
 319     fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> {
 320         match Parser::new(s).read_till_eof(|p| p.read_ipv4_addr()) {
 321             Some(s) => Ok(s),
 322             None => Err(AddrParseError(()))
 323         }
 324     }
 325 }
 326
 327 #[stable(feature = "rust1", since = "1.0.0")]
 328 impl FromStr for Ipv6Addr {
 329     type Err = AddrParseError;
 330     fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError> {
 331         match Parser::new(s).read_till_eof(|p| p.read_ipv6_addr()) {
 332             Some(s) => Ok(s),
 333             None => Err(AddrParseError(()))
 334         }
 335     }
 336 }
 337
 338 #[stable(feature = "socket_addr_from_str", since = "1.5.0")]
 339 impl FromStr for SocketAddrV4 {
 340     type Err = AddrParseError;
 341     fn from_str(s: &str) -> Result<SocketAddrV4, AddrParseError> {
 342         match Parser::new(s).read_till_eof(|p| p.read_socket_addr_v4()) {
 343             Some(s) => Ok(s),
 344             None => Err(AddrParseError(())),
 345         }
 346     }
 347 }
 348
 349 #[stable(feature = "socket_addr_from_str", since = "1.5.0")]
 350 impl FromStr for SocketAddrV6 {
 351     type Err = AddrParseError;
 352     fn from_str(s: &str) -> Result<SocketAddrV6, AddrParseError> {
 353         match Parser::new(s).read_till_eof(|p| p.read_socket_addr_v6()) {
 354             Some(s) => Ok(s),
 355             None => Err(AddrParseError(())),
 356         }
 357     }
 358 }
 359
 360 #[stable(feature = "rust1", since = "1.0.0")]
 361 impl FromStr for SocketAddr {
 362     type Err = AddrParseError;
 363     fn from_str(s: &str) -> Result<SocketAddr, AddrParseError> {
 364         match Parser::new(s).read_till_eof(|p| p.read_socket_addr()) {
 365             Some(s) => Ok(s),
 366             None => Err(AddrParseError(())),
 367         }
 368     }
 369 }
 370
 371 /// An error returned when parsing an IP address or a socket address.
 372 #[stable(feature = "rust1", since = "1.0.0")]
 373 #[derive(Debug, Clone, PartialEq)]
 374 pub struct AddrParseError(());
 375
 376 #[stable(feature = "addr_parse_error_error", since = "1.4.0")]
 377 impl fmt::Display for AddrParseError {
 378     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
 379         fmt.write_str(self.description())
 380     }
 381 }
 382
 383 #[stable(feature = "addr_parse_error_error", since = "1.4.0")]
 384 impl Error for AddrParseError {
 385     fn description(&self) -> &str {
 386         "invalid IP address syntax"
 387     }
 388 }