f94d671bfa
This commit revisits the `cast` module in libcore and libstd, and scrutinizes
all functions inside of it. The result was to remove the `cast` module entirely,
folding all functionality into the `mem` module. Specifically, this is the fate
of each function in the `cast` module.
* transmute - This function was moved to `mem`, but it is now marked as
#[unstable]. This is due to planned changes to the `transmute`
function and how it can be invoked (see the #[unstable] comment).
For more information, see RFC 5 and #12898
* transmute_copy - This function was moved to `mem`, with clarification that is
is not an error to invoke it with T/U that are different
sizes, but rather that it is strongly discouraged. This
function is now #[stable]
* forget - This function was moved to `mem` and marked #[stable]
* bump_box_refcount - This function was removed due to the deprecation of
managed boxes as well as its questionable utility.
* transmute_mut - This function was previously deprecated, and removed as part
of this commit.
* transmute_mut_unsafe - This function doesn't serve much of a purpose when it
can be achieved with an `as` in safe code, so it was
removed.
* transmute_lifetime - This function was removed because it is likely a strong
indication that code is incorrect in the first place.
* transmute_mut_lifetime - This function was removed for the same reasons as
`transmute_lifetime`
* copy_lifetime - This function was moved to `mem`, but it is marked
`#[unstable]` now due to the likelihood of being removed in
the future if it is found to not be very useful.
* copy_mut_lifetime - This function was also moved to `mem`, but had the same
treatment as `copy_lifetime`.
* copy_lifetime_vec - This function was removed because it is not used today,
and its existence is not necessary with DST
(copy_lifetime will suffice).
In summary, the cast module was stripped down to these functions, and then the
functions were moved to the `mem` module.
transmute - #[unstable]
transmute_copy - #[stable]
forget - #[stable]
copy_lifetime - #[unstable]
copy_mut_lifetime - #[unstable]
[breaking-change]
115 lines
3.5 KiB
Rust
115 lines
3.5 KiB
Rust
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use ai = std::io::net::addrinfo;
|
|
use libc::{c_char, c_int};
|
|
use libc;
|
|
use std::c_str::CString;
|
|
use std::io::IoError;
|
|
use std::mem;
|
|
use std::ptr::{null, mut_null};
|
|
|
|
use super::net::sockaddr_to_addr;
|
|
|
|
pub struct GetAddrInfoRequest;
|
|
|
|
impl GetAddrInfoRequest {
|
|
pub fn run(host: Option<&str>, servname: Option<&str>,
|
|
hint: Option<ai::Hint>) -> Result<Vec<ai::Info>, IoError> {
|
|
assert!(host.is_some() || servname.is_some());
|
|
|
|
let c_host = host.map_or(unsafe { CString::new(null(), true) }, |x| x.to_c_str());
|
|
let c_serv = servname.map_or(unsafe { CString::new(null(), true) }, |x| x.to_c_str());
|
|
|
|
let hint = hint.map(|hint| {
|
|
libc::addrinfo {
|
|
ai_flags: hint.flags as c_int,
|
|
ai_family: hint.family as c_int,
|
|
ai_socktype: 0,
|
|
ai_protocol: 0,
|
|
ai_addrlen: 0,
|
|
ai_canonname: null(),
|
|
ai_addr: null(),
|
|
ai_next: null()
|
|
}
|
|
});
|
|
|
|
let hint_ptr = hint.as_ref().map_or(null(), |x| x as *libc::addrinfo);
|
|
let mut res = mut_null();
|
|
|
|
// Make the call
|
|
let s = unsafe {
|
|
let ch = if c_host.is_null() { null() } else { c_host.with_ref(|x| x) };
|
|
let cs = if c_serv.is_null() { null() } else { c_serv.with_ref(|x| x) };
|
|
getaddrinfo(ch, cs, hint_ptr, &mut res)
|
|
};
|
|
|
|
// Error?
|
|
if s != 0 {
|
|
return Err(get_error(s));
|
|
}
|
|
|
|
// Collect all the results we found
|
|
let mut addrs = Vec::new();
|
|
let mut rp = res;
|
|
while rp.is_not_null() {
|
|
unsafe {
|
|
let addr = match sockaddr_to_addr(mem::transmute((*rp).ai_addr),
|
|
(*rp).ai_addrlen as uint) {
|
|
Ok(a) => a,
|
|
Err(e) => return Err(e)
|
|
};
|
|
addrs.push(ai::Info {
|
|
address: addr,
|
|
family: (*rp).ai_family as uint,
|
|
socktype: None,
|
|
protocol: None,
|
|
flags: (*rp).ai_flags as uint
|
|
});
|
|
|
|
rp = (*rp).ai_next as *mut libc::addrinfo;
|
|
}
|
|
}
|
|
|
|
unsafe { freeaddrinfo(res); }
|
|
|
|
Ok(addrs)
|
|
}
|
|
}
|
|
|
|
extern "system" {
|
|
fn getaddrinfo(node: *c_char, service: *c_char,
|
|
hints: *libc::addrinfo, res: *mut *mut libc::addrinfo) -> c_int;
|
|
fn freeaddrinfo(res: *mut libc::addrinfo);
|
|
#[cfg(not(windows))]
|
|
fn gai_strerror(errcode: c_int) -> *c_char;
|
|
#[cfg(windows)]
|
|
fn WSAGetLastError() -> c_int;
|
|
}
|
|
|
|
#[cfg(windows)]
|
|
fn get_error(_: c_int) -> IoError {
|
|
unsafe {
|
|
IoError::from_errno(WSAGetLastError() as uint, true)
|
|
}
|
|
}
|
|
|
|
#[cfg(not(windows))]
|
|
fn get_error(s: c_int) -> IoError {
|
|
use std::io;
|
|
use std::str::raw::from_c_str;
|
|
|
|
let err_str = unsafe { from_c_str(gai_strerror(s)) };
|
|
IoError {
|
|
kind: io::OtherIoError,
|
|
desc: "unable to resolve host",
|
|
detail: Some(err_str),
|
|
}
|
|
}
|