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.
17 use net
::{lookup_host, ntoh, hton, IpAddr, Ipv4Addr, Ipv6Addr}
;
19 use sys
::net
::netc
as c
;
20 use sys_common
::{FromInner, AsInner, IntoInner}
;
25 /// Representation of a socket address for networking applications.
27 /// A socket address can either represent the IPv4 or IPv6 protocol and is
28 /// paired with at least a port number as well. Each protocol may have more
29 /// specific information about the address available to it as well.
30 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
31 #[stable(feature = "rust1", since = "1.0.0")]
33 /// An IPv4 socket address which is a (ip, port) combination.
34 #[stable(feature = "rust1", since = "1.0.0")]
35 V4(#[stable(feature = "rust1", since = "1.0.0")] SocketAddrV4),
36 /// An IPv6 socket address
37 #[stable(feature = "rust1", since = "1.0.0")]
38 V6(#[stable(feature = "rust1", since = "1.0.0")] SocketAddrV6),
41 /// An IPv4 socket address which is a (ip, port) combination.
43 #[stable(feature = "rust1", since = "1.0.0")]
44 pub struct SocketAddrV4 { inner: c::sockaddr_in }
46 /// An IPv6 socket address.
48 #[stable(feature = "rust1", since = "1.0.0")]
49 pub struct SocketAddrV6 { inner: c::sockaddr_in6 }
52 /// Creates a new socket address from the (ip, port) pair.
53 #[stable(feature = "ip_addr", since = "1.7.0")]
54 pub fn new(ip
: IpAddr
, port
: u16) -> SocketAddr
{
56 IpAddr
::V4(a
) => SocketAddr
::V4(SocketAddrV4
::new(a
, port
)),
57 IpAddr
::V6(a
) => SocketAddr
::V6(SocketAddrV6
::new(a
, port
, 0, 0)),
61 /// Returns the IP address associated with this socket address.
62 #[stable(feature = "ip_addr", since = "1.7.0")]
63 pub fn ip(&self) -> IpAddr
{
65 SocketAddr
::V4(ref a
) => IpAddr
::V4(*a
.ip()),
66 SocketAddr
::V6(ref a
) => IpAddr
::V6(*a
.ip()),
70 /// Change the IP address associated with this socket address.
71 #[stable(feature = "sockaddr_setters", since = "1.9.0")]
72 pub fn set_ip(&mut self, new_ip
: IpAddr
) {
73 // `match (*self, new_ip)` would have us mutate a copy of self only to throw it away.
74 match (self, new_ip
) {
75 (&mut SocketAddr
::V4(ref mut a
), IpAddr
::V4(new_ip
)) => a
.set_ip(new_ip
),
76 (&mut SocketAddr
::V6(ref mut a
), IpAddr
::V6(new_ip
)) => a
.set_ip(new_ip
),
77 (self_
, new_ip
) => *self_
= Self::new(new_ip
, self_
.port()),
81 /// Returns the port number associated with this socket address.
82 #[stable(feature = "rust1", since = "1.0.0")]
83 pub fn port(&self) -> u16 {
85 SocketAddr
::V4(ref a
) => a
.port(),
86 SocketAddr
::V6(ref a
) => a
.port(),
90 /// Change the port number associated with this socket address.
91 #[stable(feature = "sockaddr_setters", since = "1.9.0")]
92 pub fn set_port(&mut self, new_port
: u16) {
94 SocketAddr
::V4(ref mut a
) => a
.set_port(new_port
),
95 SocketAddr
::V6(ref mut a
) => a
.set_port(new_port
),
101 /// Creates a new socket address from the (ip, port) pair.
102 #[stable(feature = "rust1", since = "1.0.0")]
103 pub fn new(ip
: Ipv4Addr
, port
: u16) -> SocketAddrV4
{
105 inner
: c
::sockaddr_in
{
106 sin_family
: c
::AF_INET
as c
::sa_family_t
,
107 sin_port
: hton(port
),
108 sin_addr
: *ip
.as_inner(),
109 .. unsafe { mem::zeroed() }
114 /// Returns the IP address associated with this socket address.
115 #[stable(feature = "rust1", since = "1.0.0")]
116 pub fn ip(&self) -> &Ipv4Addr
{
118 &*(&self.inner
.sin_addr
as *const c
::in_addr
as *const Ipv4Addr
)
122 /// Change the IP address associated with this socket address.
123 #[stable(feature = "sockaddr_setters", since = "1.9.0")]
124 pub fn set_ip(&mut self, new_ip
: Ipv4Addr
) {
125 self.inner
.sin_addr
= *new_ip
.as_inner()
128 /// Returns the port number associated with this socket address.
129 #[stable(feature = "rust1", since = "1.0.0")]
130 pub fn port(&self) -> u16 {
131 ntoh(self.inner
.sin_port
)
134 /// Change the port number associated with this socket address.
135 #[stable(feature = "sockaddr_setters", since = "1.9.0")]
136 pub fn set_port(&mut self, new_port
: u16) {
137 self.inner
.sin_port
= hton(new_port
);
142 /// Creates a new socket address from the ip/port/flowinfo/scope_id
144 #[stable(feature = "rust1", since = "1.0.0")]
145 pub fn new(ip
: Ipv6Addr
, port
: u16, flowinfo
: u32, scope_id
: u32)
148 inner
: c
::sockaddr_in6
{
149 sin6_family
: c
::AF_INET6
as c
::sa_family_t
,
150 sin6_port
: hton(port
),
151 sin6_addr
: *ip
.as_inner(),
152 sin6_flowinfo
: flowinfo
,
153 sin6_scope_id
: scope_id
,
154 .. unsafe { mem::zeroed() }
159 /// Returns the IP address associated with this socket address.
160 #[stable(feature = "rust1", since = "1.0.0")]
161 pub fn ip(&self) -> &Ipv6Addr
{
163 &*(&self.inner
.sin6_addr
as *const c
::in6_addr
as *const Ipv6Addr
)
167 /// Change the IP address associated with this socket address.
168 #[stable(feature = "sockaddr_setters", since = "1.9.0")]
169 pub fn set_ip(&mut self, new_ip
: Ipv6Addr
) {
170 self.inner
.sin6_addr
= *new_ip
.as_inner()
173 /// Returns the port number associated with this socket address.
174 #[stable(feature = "rust1", since = "1.0.0")]
175 pub fn port(&self) -> u16 {
176 ntoh(self.inner
.sin6_port
)
179 /// Change the port number associated with this socket address.
180 #[stable(feature = "sockaddr_setters", since = "1.9.0")]
181 pub fn set_port(&mut self, new_port
: u16) {
182 self.inner
.sin6_port
= hton(new_port
);
185 /// Returns the flow information associated with this address,
186 /// corresponding to the `sin6_flowinfo` field in C.
187 #[stable(feature = "rust1", since = "1.0.0")]
188 pub fn flowinfo(&self) -> u32 {
189 self.inner
.sin6_flowinfo
192 /// Change the flow information associated with this socket address.
193 #[stable(feature = "sockaddr_setters", since = "1.9.0")]
194 pub fn set_flowinfo(&mut self, new_flowinfo
: u32) {
195 self.inner
.sin6_flowinfo
= new_flowinfo
;
198 /// Returns the scope ID associated with this address,
199 /// corresponding to the `sin6_scope_id` field in C.
200 #[stable(feature = "rust1", since = "1.0.0")]
201 pub fn scope_id(&self) -> u32 {
202 self.inner
.sin6_scope_id
205 /// Change the scope ID associated with this socket address.
206 #[stable(feature = "sockaddr_setters", since = "1.9.0")]
207 pub fn set_scope_id(&mut self, new_scope_id
: u32) {
208 self.inner
.sin6_scope_id
= new_scope_id
;
212 impl FromInner
<c
::sockaddr_in
> for SocketAddrV4
{
213 fn from_inner(addr
: c
::sockaddr_in
) -> SocketAddrV4
{
214 SocketAddrV4 { inner: addr }
218 impl FromInner
<c
::sockaddr_in6
> for SocketAddrV6
{
219 fn from_inner(addr
: c
::sockaddr_in6
) -> SocketAddrV6
{
220 SocketAddrV6 { inner: addr }
224 impl<'a
> IntoInner
<(*const c
::sockaddr
, c
::socklen_t
)> for &'a SocketAddr
{
225 fn into_inner(self) -> (*const c
::sockaddr
, c
::socklen_t
) {
227 SocketAddr
::V4(ref a
) => {
228 (a
as *const _
as *const _
, mem
::size_of_val(a
) as c
::socklen_t
)
230 SocketAddr
::V6(ref a
) => {
231 (a
as *const _
as *const _
, mem
::size_of_val(a
) as c
::socklen_t
)
237 #[stable(feature = "rust1", since = "1.0.0")]
238 impl fmt
::Display
for SocketAddr
{
239 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
241 SocketAddr
::V4(ref a
) => a
.fmt(f
),
242 SocketAddr
::V6(ref a
) => a
.fmt(f
),
247 #[stable(feature = "rust1", since = "1.0.0")]
248 impl fmt
::Display
for SocketAddrV4
{
249 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
250 write
!(f
, "{}:{}", self.ip(), self.port())
254 #[stable(feature = "rust1", since = "1.0.0")]
255 impl fmt
::Debug
for SocketAddrV4
{
256 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
257 fmt
::Display
::fmt(self, fmt
)
261 #[stable(feature = "rust1", since = "1.0.0")]
262 impl fmt
::Display
for SocketAddrV6
{
263 fn fmt(&self, f
: &mut fmt
::Formatter
) -> fmt
::Result
{
264 write
!(f
, "[{}]:{}", self.ip(), self.port())
268 #[stable(feature = "rust1", since = "1.0.0")]
269 impl fmt
::Debug
for SocketAddrV6
{
270 fn fmt(&self, fmt
: &mut fmt
::Formatter
) -> fmt
::Result
{
271 fmt
::Display
::fmt(self, fmt
)
275 #[stable(feature = "rust1", since = "1.0.0")]
276 impl Clone
for SocketAddrV4
{
277 fn clone(&self) -> SocketAddrV4 { *self }
279 #[stable(feature = "rust1", since = "1.0.0")]
280 impl Clone
for SocketAddrV6
{
281 fn clone(&self) -> SocketAddrV6 { *self }
284 #[stable(feature = "rust1", since = "1.0.0")]
285 impl PartialEq
for SocketAddrV4
{
286 fn eq(&self, other
: &SocketAddrV4
) -> bool
{
287 self.inner
.sin_port
== other
.inner
.sin_port
&&
288 self.inner
.sin_addr
.s_addr
== other
.inner
.sin_addr
.s_addr
291 #[stable(feature = "rust1", since = "1.0.0")]
292 impl PartialEq
for SocketAddrV6
{
293 fn eq(&self, other
: &SocketAddrV6
) -> bool
{
294 self.inner
.sin6_port
== other
.inner
.sin6_port
&&
295 self.inner
.sin6_addr
.s6_addr
== other
.inner
.sin6_addr
.s6_addr
&&
296 self.inner
.sin6_flowinfo
== other
.inner
.sin6_flowinfo
&&
297 self.inner
.sin6_scope_id
== other
.inner
.sin6_scope_id
300 #[stable(feature = "rust1", since = "1.0.0")]
301 impl Eq
for SocketAddrV4 {}
302 #[stable(feature = "rust1", since = "1.0.0")]
303 impl Eq
for SocketAddrV6 {}
305 #[stable(feature = "rust1", since = "1.0.0")]
306 impl hash
::Hash
for SocketAddrV4
{
307 fn hash
<H
: hash
::Hasher
>(&self, s
: &mut H
) {
308 (self.inner
.sin_port
, self.inner
.sin_addr
.s_addr
).hash(s
)
311 #[stable(feature = "rust1", since = "1.0.0")]
312 impl hash
::Hash
for SocketAddrV6
{
313 fn hash
<H
: hash
::Hasher
>(&self, s
: &mut H
) {
314 (self.inner
.sin6_port
, &self.inner
.sin6_addr
.s6_addr
,
315 self.inner
.sin6_flowinfo
, self.inner
.sin6_scope_id
).hash(s
)
319 /// A trait for objects which can be converted or resolved to one or more
320 /// `SocketAddr` values.
322 /// This trait is used for generic address resolution when constructing network
323 /// objects. By default it is implemented for the following types:
325 /// * `SocketAddr`, `SocketAddrV4`, `SocketAddrV6` - `to_socket_addrs` is
326 /// identity function.
328 /// * `(IpvNAddr, u16)` - `to_socket_addrs` constructs `SocketAddr` trivially.
330 /// * `(&str, u16)` - the string should be either a string representation of an
331 /// IP address expected by `FromStr` implementation for `IpvNAddr` or a host
334 /// * `&str` - the string should be either a string representation of a
335 /// `SocketAddr` as expected by its `FromStr` implementation or a string like
336 /// `<host_name>:<port>` pair where `<port>` is a `u16` value.
338 /// This trait allows constructing network objects like `TcpStream` or
339 /// `UdpSocket` easily with values of various types for the bind/connection
340 /// address. It is needed because sometimes one type is more appropriate than
341 /// the other: for simple uses a string like `"localhost:12345"` is much nicer
342 /// than manual construction of the corresponding `SocketAddr`, but sometimes
343 /// `SocketAddr` value is *the* main source of the address, and converting it to
344 /// some other type (e.g. a string) just for it to be converted back to
345 /// `SocketAddr` in constructor methods is pointless.
350 /// use std::net::{SocketAddrV4, TcpStream, UdpSocket, TcpListener, Ipv4Addr};
353 /// let ip = Ipv4Addr::new(127, 0, 0, 1);
354 /// let port = 12345;
356 /// // The following lines are equivalent modulo possible "localhost" name
357 /// // resolution differences
358 /// let tcp_s = TcpStream::connect(SocketAddrV4::new(ip, port));
359 /// let tcp_s = TcpStream::connect((ip, port));
360 /// let tcp_s = TcpStream::connect(("127.0.0.1", port));
361 /// let tcp_s = TcpStream::connect(("localhost", port));
362 /// let tcp_s = TcpStream::connect("127.0.0.1:12345");
363 /// let tcp_s = TcpStream::connect("localhost:12345");
365 /// // TcpListener::bind(), UdpSocket::bind() and UdpSocket::send_to()
366 /// // behave similarly
367 /// let tcp_l = TcpListener::bind("localhost:12345");
369 /// let mut udp_s = UdpSocket::bind(("127.0.0.1", port)).unwrap();
370 /// udp_s.send_to(&[7], (ip, 23451)).unwrap();
373 #[stable(feature = "rust1", since = "1.0.0")]
374 pub trait ToSocketAddrs
{
375 /// Returned iterator over socket addresses which this type may correspond
377 #[stable(feature = "rust1", since = "1.0.0")]
378 type Iter
: Iterator
<Item
=SocketAddr
>;
380 /// Converts this object to an iterator of resolved `SocketAddr`s.
382 /// The returned iterator may not actually yield any values depending on the
383 /// outcome of any resolution performed.
385 /// Note that this function may block the current thread while resolution is
390 /// Any errors encountered during resolution will be returned as an `Err`.
391 #[stable(feature = "rust1", since = "1.0.0")]
392 fn to_socket_addrs(&self) -> io
::Result
<Self::Iter
>;
395 #[stable(feature = "rust1", since = "1.0.0")]
396 impl ToSocketAddrs
for SocketAddr
{
397 type Iter
= option
::IntoIter
<SocketAddr
>;
398 fn to_socket_addrs(&self) -> io
::Result
<option
::IntoIter
<SocketAddr
>> {
399 Ok(Some(*self).into_iter())
403 #[stable(feature = "rust1", since = "1.0.0")]
404 impl ToSocketAddrs
for SocketAddrV4
{
405 type Iter
= option
::IntoIter
<SocketAddr
>;
406 fn to_socket_addrs(&self) -> io
::Result
<option
::IntoIter
<SocketAddr
>> {
407 SocketAddr
::V4(*self).to_socket_addrs()
411 #[stable(feature = "rust1", since = "1.0.0")]
412 impl ToSocketAddrs
for SocketAddrV6
{
413 type Iter
= option
::IntoIter
<SocketAddr
>;
414 fn to_socket_addrs(&self) -> io
::Result
<option
::IntoIter
<SocketAddr
>> {
415 SocketAddr
::V6(*self).to_socket_addrs()
419 #[stable(feature = "rust1", since = "1.0.0")]
420 impl ToSocketAddrs
for (IpAddr
, u16) {
421 type Iter
= option
::IntoIter
<SocketAddr
>;
422 fn to_socket_addrs(&self) -> io
::Result
<option
::IntoIter
<SocketAddr
>> {
423 let (ip
, port
) = *self;
425 IpAddr
::V4(ref a
) => (*a
, port
).to_socket_addrs(),
426 IpAddr
::V6(ref a
) => (*a
, port
).to_socket_addrs(),
431 #[stable(feature = "rust1", since = "1.0.0")]
432 impl ToSocketAddrs
for (Ipv4Addr
, u16) {
433 type Iter
= option
::IntoIter
<SocketAddr
>;
434 fn to_socket_addrs(&self) -> io
::Result
<option
::IntoIter
<SocketAddr
>> {
435 let (ip
, port
) = *self;
436 SocketAddrV4
::new(ip
, port
).to_socket_addrs()
440 #[stable(feature = "rust1", since = "1.0.0")]
441 impl ToSocketAddrs
for (Ipv6Addr
, u16) {
442 type Iter
= option
::IntoIter
<SocketAddr
>;
443 fn to_socket_addrs(&self) -> io
::Result
<option
::IntoIter
<SocketAddr
>> {
444 let (ip
, port
) = *self;
445 SocketAddrV6
::new(ip
, port
, 0, 0).to_socket_addrs()
449 fn resolve_socket_addr(s
: &str, p
: u16) -> io
::Result
<vec
::IntoIter
<SocketAddr
>> {
450 let ips
= lookup_host(s
)?
;
451 let v
: Vec
<_
> = ips
.map(|a
| {
460 #[stable(feature = "rust1", since = "1.0.0")]
461 impl<'a
> ToSocketAddrs
for (&'a
str, u16) {
462 type Iter
= vec
::IntoIter
<SocketAddr
>;
463 fn to_socket_addrs(&self) -> io
::Result
<vec
::IntoIter
<SocketAddr
>> {
464 let (host
, port
) = *self;
466 // try to parse the host as a regular IP address first
467 if let Ok(addr
) = host
.parse
::<Ipv4Addr
>() {
468 let addr
= SocketAddrV4
::new(addr
, port
);
469 return Ok(vec
![SocketAddr
::V4(addr
)].into_iter())
471 if let Ok(addr
) = host
.parse
::<Ipv6Addr
>() {
472 let addr
= SocketAddrV6
::new(addr
, port
, 0, 0);
473 return Ok(vec
![SocketAddr
::V6(addr
)].into_iter())
476 resolve_socket_addr(host
, port
)
480 // accepts strings like 'localhost:12345'
481 #[stable(feature = "rust1", since = "1.0.0")]
482 impl ToSocketAddrs
for str {
483 type Iter
= vec
::IntoIter
<SocketAddr
>;
484 fn to_socket_addrs(&self) -> io
::Result
<vec
::IntoIter
<SocketAddr
>> {
485 // try to parse as a regular SocketAddr first
486 if let Some(addr
) = self.parse().ok() {
487 return Ok(vec
![addr
].into_iter());
490 macro_rules
! try_opt
{
491 ($e
:expr
, $msg
:expr
) => (
494 None
=> return Err(io
::Error
::new(io
::ErrorKind
::InvalidInput
,
500 // split the string by ':' and convert the second part to u16
501 let mut parts_iter
= self.rsplitn(2, '
:'
);
502 let port_str
= try_opt
!(parts_iter
.next(), "invalid socket address");
503 let host
= try_opt
!(parts_iter
.next(), "invalid socket address");
504 let port
: u16 = try_opt
!(port_str
.parse().ok(), "invalid port value");
505 resolve_socket_addr(host
, port
)
509 #[stable(feature = "slice_to_socket_addrs", since = "1.8.0")]
510 impl<'a
> ToSocketAddrs
for &'a
[SocketAddr
] {
511 type Iter
= iter
::Cloned
<slice
::Iter
<'a
, SocketAddr
>>;
513 fn to_socket_addrs(&self) -> io
::Result
<Self::Iter
> {
514 Ok(self.iter().cloned())
518 #[stable(feature = "rust1", since = "1.0.0")]
519 impl<'a
, T
: ToSocketAddrs
+ ?Sized
> ToSocketAddrs
for &'a T
{
521 fn to_socket_addrs(&self) -> io
::Result
<T
::Iter
> {
522 (**self).to_socket_addrs()
530 use net
::test
::{tsa, sa6, sa4}
;
533 fn to_socket_addr_ipaddr_u16() {
534 let a
= Ipv4Addr
::new(77, 88, 21, 11);
536 let e
= SocketAddr
::V4(SocketAddrV4
::new(a
, p
));
537 assert_eq
!(Ok(vec
![e
]), tsa((a
, p
)));
541 fn to_socket_addr_str_u16() {
542 let a
= sa4(Ipv4Addr
::new(77, 88, 21, 11), 24352);
543 assert_eq
!(Ok(vec
![a
]), tsa(("77.88.21.11", 24352)));
545 let a
= sa6(Ipv6Addr
::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53);
546 assert_eq
!(Ok(vec
![a
]), tsa(("2a02:6b8:0:1::1", 53)));
548 let a
= sa4(Ipv4Addr
::new(127, 0, 0, 1), 23924);
549 assert
!(tsa(("localhost", 23924)).unwrap().contains(&a
));
553 fn to_socket_addr_str() {
554 let a
= sa4(Ipv4Addr
::new(77, 88, 21, 11), 24352);
555 assert_eq
!(Ok(vec
![a
]), tsa("77.88.21.11:24352"));
557 let a
= sa6(Ipv6Addr
::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53);
558 assert_eq
!(Ok(vec
![a
]), tsa("[2a02:6b8:0:1::1]:53"));
560 let a
= sa4(Ipv4Addr
::new(127, 0, 0, 1), 23924);
561 assert
!(tsa("localhost:23924").unwrap().contains(&a
));
564 // FIXME: figure out why this fails on openbsd and bitrig and fix it
566 #[cfg(not(any(windows, target_os = "openbsd", target_os = "bitrig")))]
567 fn to_socket_addr_str_bad() {
568 assert
!(tsa("1200::AB00:1234::2552:7777:1313:34300").is_err());
573 fn ip4(low
: u8) -> Ipv4Addr { Ipv4Addr::new(77, 88, 21, low) }
574 fn ip6(low
: u16) -> Ipv6Addr { Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, low) }
576 let mut v4
= SocketAddrV4
::new(ip4(11), 80);
577 assert_eq
!(v4
.ip(), &ip4(11));
579 assert_eq
!(v4
.ip(), &ip4(12));
581 let mut addr
= SocketAddr
::V4(v4
);
582 assert_eq
!(addr
.ip(), IpAddr
::V4(ip4(12)));
583 addr
.set_ip(IpAddr
::V4(ip4(13)));
584 assert_eq
!(addr
.ip(), IpAddr
::V4(ip4(13)));
585 addr
.set_ip(IpAddr
::V6(ip6(14)));
586 assert_eq
!(addr
.ip(), IpAddr
::V6(ip6(14)));
588 let mut v6
= SocketAddrV6
::new(ip6(1), 80, 0, 0);
589 assert_eq
!(v6
.ip(), &ip6(1));
591 assert_eq
!(v6
.ip(), &ip6(2));
593 let mut addr
= SocketAddr
::V6(v6
);
594 assert_eq
!(addr
.ip(), IpAddr
::V6(ip6(2)));
595 addr
.set_ip(IpAddr
::V6(ip6(3)));
596 assert_eq
!(addr
.ip(), IpAddr
::V6(ip6(3)));
597 addr
.set_ip(IpAddr
::V4(ip4(4)));
598 assert_eq
!(addr
.ip(), IpAddr
::V4(ip4(4)));
603 let mut v4
= SocketAddrV4
::new(Ipv4Addr
::new(77, 88, 21, 11), 80);
604 assert_eq
!(v4
.port(), 80);
606 assert_eq
!(v4
.port(), 443);
608 let mut addr
= SocketAddr
::V4(v4
);
609 assert_eq
!(addr
.port(), 443);
611 assert_eq
!(addr
.port(), 8080);
613 let mut v6
= SocketAddrV6
::new(Ipv6Addr
::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 0, 0);
614 assert_eq
!(v6
.port(), 80);
616 assert_eq
!(v6
.port(), 443);
618 let mut addr
= SocketAddr
::V6(v6
);
619 assert_eq
!(addr
.port(), 443);
621 assert_eq
!(addr
.port(), 8080);
626 let mut v6
= SocketAddrV6
::new(Ipv6Addr
::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 10, 0);
627 assert_eq
!(v6
.flowinfo(), 10);
629 assert_eq
!(v6
.flowinfo(), 20);
634 let mut v6
= SocketAddrV6
::new(Ipv6Addr
::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 0, 10);
635 assert_eq
!(v6
.scope_id(), 10);
637 assert_eq
!(v6
.scope_id(), 20);