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 prelude::v1::*;
  17
  18 use error::Error;
  19 use fmt;
  20 use net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
  21 use str::FromStr;
  22
  23 struct Parser<'a> {
  24     // parsing as ASCII, so can use byte array
  25     s: &'a [u8],
  26     pos: usize,
  27 }
  28
  29 impl<'a> Parser<'a> {
  30     fn new(s: &'a str) -> Parser<'a> {
  31         Parser {
  32             s: s.as_bytes(),
  33             pos: 0,
  34         }
  35     }
  36
  37     fn is_eof(&self) -> bool {
  38         self.pos == self.s.len()
  39     }
  40
  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>,
  44     {
  45         let pos = self.pos;
  46         let r = cb(self);
  47         if r.is_none() {
  48             self.pos = pos;
  49         }
  50         r
  51     }
  52
  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>,
  56     {
  57         self.read_atomically(move |p| {
  58             match cb(p) {
  59                 Some(x) => if p.is_eof() {Some(x)} else {None},
  60                 None => None,
  61             }
  62         })
  63     }
  64
  65     // Return result of first successful parser
  66     fn read_or<T>(&mut self, parsers: &mut [Box<FnMut(&mut Parser) -> Option<T> + 'static>])
  67                -> Option<T> {
  68         for pf in parsers {
  69             if let Some(r) = self.read_atomically(|p: &mut Parser| pf(p)) {
  70                 return Some(r);
  71             }
  72         }
  73         None
  74     }
  75
  76     // Apply 3 parsers sequentially
  77     fn read_seq_3<A, B, C, PA, PB, PC>(&mut self,
  78                                        pa: PA,
  79                                        pb: PB,
  80                                        pc: PC)
  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>,
  85     {
  86         self.read_atomically(move |p| {
  87             let a = pa(p);
  88             let b = if a.is_some() { pb(p) } else { None };
  89             let c = if b.is_some() { pc(p) } else { None };
  90             match (a, b, c) {
  91                 (Some(a), Some(b), Some(c)) => Some((a, b, c)),
  92                 _ => None
  93             }
  94         })
  95     }
  96
  97     // Read next char
  98     fn read_char(&mut self) -> Option<char> {
  99         if self.is_eof() {
 100             None
 101         } else {
 102             let r = self.s[self.pos] as char;
 103             self.pos += 1;
 104             Some(r)
 105         }
 106     }
 107
 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),
 113                 _ => None,
 114             }
 115         })
 116     }
 117
 118     // Read digit
 119     fn read_digit(&mut self, radix: u8) -> Option<u8> {
 120         fn parse_digit(c: char, radix: u8) -> Option<u8> {
 121             let c = c as u8;
 122             // assuming radix is either 10 or 16
 123             if c >= b'0' && c <= b'9' {
 124                 Some(c - b'0')
 125             } else if radix > 10 && c >= b'a' && c < b'a' + (radix - 10) {
 126                 Some(c - b'a' + 10)
 127             } else if radix > 10 && c >= b'A' && c < b'A' + (radix - 10) {
 128                 Some(c - b'A' + 10)
 129             } else {
 130                 None
 131             }
 132         }
 133
 134         self.read_atomically(|p| {
 135             p.read_char().and_then(|c| parse_digit(c, radix))
 136         })
 137     }
 138
 139     fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {
 140         let mut r = 0;
 141         let mut digit_count = 0;
 142         loop {
 143             match self.read_digit(radix) {
 144                 Some(d) => {
 145                     r = r * (radix as u32) + (d as u32);
 146                     digit_count += 1;
 147                     if digit_count > max_digits || r >= upto {
 148                         return None
 149                     }
 150                 }
 151                 None => {
 152                     if digit_count == 0 {
 153                         return None
 154                     } else {
 155                         return Some(r)
 156                     }
 157                 }
 158             };
 159         }
 160     }
 161
 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))
 165     }
 166
 167     fn read_ipv4_addr_impl(&mut self) -> Option<Ipv4Addr> {
 168         let mut bs = [0; 4];
 169         let mut i = 0;
 170         while i < 4 {
 171             if i != 0 && self.read_given_char('.').is_none() {
 172                 return None;
 173             }
 174
 175             let octet = self.read_number(10, 3, 0x100).map(|n| n as u8);
 176             match octet {
 177                 Some(d) => bs[i] = d,
 178                 None => return None,
 179             };
 180             i += 1;
 181         }
 182         Some(Ipv4Addr::new(bs[0], bs[1], bs[2], bs[3]))
 183     }
 184
 185     // Read IPv4 address
 186     fn read_ipv4_addr(&mut self) -> Option<Ipv4Addr> {
 187         self.read_atomically(|p| p.read_ipv4_addr_impl())
 188     }
 189
 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);
 193             let mut gs = [0; 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])
 197         }
 198
 199         fn read_groups(p: &mut Parser, groups: &mut [u16; 8], limit: usize)
 200                        -> (usize, bool) {
 201             let mut i = 0;
 202             while i < limit {
 203                 if i < limit - 1 {
 204                     let ipv4 = p.read_atomically(|p| {
 205                         if i == 0 || p.read_given_char(':').is_some() {
 206                             p.read_ipv4_addr()
 207                         } else {
 208                             None
 209                         }
 210                     });
 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);
 216                     }
 217                 }
 218
 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)
 222                     } else {
 223                         None
 224                     }
 225                 });
 226                 match group {
 227                     Some(g) => groups[i] = g,
 228                     None => return (i, false)
 229                 }
 230                 i += 1;
 231             }
 232             (i, false)
 233         }
 234
 235         let mut head = [0; 8];
 236         let (head_size, head_ipv4) = read_groups(self, &mut head, 8);
 237
 238         if head_size == 8 {
 239             return Some(Ipv6Addr::new(
 240                 head[0], head[1], head[2], head[3],
 241                 head[4], head[5], head[6], head[7]))
 242         }
 243
 244         // IPv4 part is not allowed before `::`
 245         if head_ipv4 {
 246             return None
 247         }
 248
 249         // read `::` if previous code parsed less than 8 groups
 250         if !self.read_given_char(':').is_some() || !self.read_given_char(':').is_some() {
 251             return None;
 252         }
 253
 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]))
 257     }
 258
 259     fn read_ipv6_addr(&mut self) -> Option<Ipv6Addr> {
 260         self.read_atomically(|p| p.read_ipv6_addr_impl())
 261     }
 262
 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)])
 267     }
 268
 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)
 274         };
 275
 276         self.read_seq_3(ip_addr, colon, port).map(|t| {
 277             let (ip, _, port): (Ipv4Addr, char, u16) = t;
 278             SocketAddrV4::new(ip, port)
 279         })
 280     }
 281
 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)
 288         };
 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)
 292         };
 293
 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)
 297         })
 298     }
 299
 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)])
 304     }
 305 }
 306
 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()) {
 312             Some(s) => Ok(s),
 313             None => Err(AddrParseError(()))
 314         }
 315     }
 316 }
 317
 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()) {
 323             Some(s) => Ok(s),
 324             None => Err(AddrParseError(()))
 325         }
 326     }
 327 }
 328
 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()) {
 334             Some(s) => Ok(s),
 335             None => Err(AddrParseError(()))
 336         }
 337     }
 338 }
 339
 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()) {
 345             Some(s) => Ok(s),
 346             None => Err(AddrParseError(())),
 347         }
 348     }
 349 }
 350
 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()) {
 356             Some(s) => Ok(s),
 357             None => Err(AddrParseError(())),
 358         }
 359     }
 360 }
 361
 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()) {
 367             Some(s) => Ok(s),
 368             None => Err(AddrParseError(())),
 369         }
 370     }
 371 }
 372
 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(());
 377
 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())
 382     }
 383 }
 384
 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"
 389     }
 390 }