squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

std: Camel case net modules

Browse source
This commit is contained in:
Brian Anderson 2012-08-30 11:01:39 -07:00
parent afc1ccd282
commit dbf6abf6bf
4 changed files with 256 additions and 252 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
src/libstd/net_ip.rs
View file

@ -21,21 +21,21 @@ import get_data_for_req = uv::ll::get_data_for_req;
import ll = uv::ll;
import comm = core::comm;
export ip_addr, parse_addr_err;
export IpAddr, parse_addr_err;
export format_addr;
export v4, v6;
export get_addr;
export ipv4, ipv6;
export Ipv4, Ipv6;
/// An IP address
enum ip_addr {
enum IpAddr {
/// An IPv4 address
ipv4(sockaddr_in),
ipv6(sockaddr_in6)
Ipv4(sockaddr_in),
Ipv6(sockaddr_in6)
}
/// Human-friendly feedback on why a parse_addr attempt failed
type parse_addr_err = {
type ParseAddrErr = {
err_msg: ~str
};
@ -46,16 +46,16 @@ type parse_addr_err = {
*
* * ip - a `std::net::ip::ip_addr`
*/
fn format_addr(ip: ip_addr) -> ~str {
fn format_addr(ip: IpAddr) -> ~str {
match ip {
ipv4(addr) => unsafe {
Ipv4(addr) => unsafe {
let result = uv_ip4_name(&addr);
if result == ~"" {
fail ~"failed to convert inner sockaddr_in address to str"
}
result
},
ipv6(addr) => unsafe {
Ipv6(addr) => unsafe {
let result = uv_ip6_name(&addr);
if result == ~"" {
fail ~"failed to convert inner sockaddr_in address to str"
@ -66,8 +66,8 @@ fn format_addr(ip: ip_addr) -> ~str {
}
/// Represents errors returned from `net::ip::get_addr()`
enum ip_get_addr_err {
get_addr_unknown_error
enum IpGetAddrErr {
GetAddrUnknownError
}
/**
@ -85,13 +85,13 @@ enum ip_get_addr_err {
* object in the case of failure
*/
fn get_addr(++node: ~str, iotask: iotask)
-> result::Result<~[ip_addr], ip_get_addr_err> {
-> result::Result<~[IpAddr], IpGetAddrErr> {
do core::comm::listen |output_ch| {
do str::as_buf(node) |node_ptr, len| unsafe {
log(debug, fmt!("slice len %?", len));
let handle = create_uv_getaddrinfo_t();
let handle_ptr = ptr::addr_of(handle);
let handle_data: get_addr_data = {
let handle_data: GetAddrData = {
output_ch: output_ch
};
let handle_data_ptr = ptr::addr_of(handle_data);
@ -108,7 +108,7 @@ fn get_addr(++node: ~str, iotask: iotask)
set_data_for_req(handle_ptr, handle_data_ptr);
}
_ => {
output_ch.send(result::Err(get_addr_unknown_error));
output_ch.send(result::Err(GetAddrUnknownError));
}
}
};
@ -133,7 +133,7 @@ mod v4 {
*
* * an `ip_addr` of the `ipv4` variant
*/
fn parse_addr(ip: ~str) -> ip_addr {
fn parse_addr(ip: ~str) -> IpAddr {
match try_parse_addr(ip) {
result::Ok(addr) => copy(addr),
result::Err(err_data) => fail err_data.err_msg
@ -141,19 +141,19 @@ mod v4 {
}
// the simple, old style numberic representation of
// ipv4
type ipv4_rep = { a: u8, b: u8, c: u8, d:u8 };
type Ipv4Rep = { a: u8, b: u8, c: u8, d:u8 };
trait as_unsafe_u32 {
trait AsUnsafeU32 {
unsafe fn as_u32() -> u32;
}
impl ipv4_rep: as_unsafe_u32 {
impl Ipv4Rep: AsUnsafeU32 {
// this is pretty dastardly, i know
unsafe fn as_u32() -> u32 {
*((ptr::addr_of(self)) as *u32)
}
}
fn parse_to_ipv4_rep(ip: ~str) -> result::Result<ipv4_rep, ~str> {
fn parse_to_ipv4_rep(ip: ~str) -> result::Result<Ipv4Rep, ~str> {
let parts = vec::map(str::split_char(ip, '.'), |s| {
match uint::from_str(s) {
Some(n) if n <= 255u => n,
@ -171,7 +171,7 @@ mod v4 {
c: parts[2] as u8, d: parts[3] as u8})
}
}
fn try_parse_addr(ip: ~str) -> result::Result<ip_addr,parse_addr_err> {
fn try_parse_addr(ip: ~str) -> result::Result<IpAddr,ParseAddrErr> {
unsafe {
let INADDR_NONE = ll::get_INADDR_NONE();
let ip_rep_result = parse_to_ipv4_rep(ip);
@ -198,7 +198,7 @@ mod v4 {
{err_msg: ~"uv_ip4_name produced invalid result."})
}
else {
result::Ok(ipv4(copy(new_addr)))
result::Ok(Ipv4(copy(new_addr)))
}
}
}
@ -219,13 +219,13 @@ mod v6 {
*
* * an `ip_addr` of the `ipv6` variant
*/
fn parse_addr(ip: ~str) -> ip_addr {
fn parse_addr(ip: ~str) -> IpAddr {
match try_parse_addr(ip) {
result::Ok(addr) => copy(addr),
result::Err(err_data) => fail err_data.err_msg
}
}
fn try_parse_addr(ip: ~str) -> result::Result<ip_addr,parse_addr_err> {
fn try_parse_addr(ip: ~str) -> result::Result<IpAddr,ParseAddrErr> {
unsafe {
// need to figure out how to establish a parse failure..
let new_addr = uv_ip6_addr(ip, 22);
@ -239,21 +239,21 @@ mod v6 {
ip)})
}
else {
result::Ok(ipv6(new_addr))
result::Ok(Ipv6(new_addr))
}
}
}
}
type get_addr_data = {
output_ch: comm::Chan<result::Result<~[ip_addr],ip_get_addr_err>>
type GetAddrData = {
output_ch: comm::Chan<result::Result<~[IpAddr],IpGetAddrErr>>
};
extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
res: *addrinfo) unsafe {
log(debug, ~"in get_addr_cb");
let handle_data = get_data_for_req(handle) as
*get_addr_data;
*GetAddrData;
if status == 0i32 {
if res != (ptr::null::<addrinfo>()) {
let mut out_vec = ~[];
@ -261,18 +261,18 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
let mut curr_addr = res;
loop {
let new_ip_addr = if ll::is_ipv4_addrinfo(curr_addr) {
ipv4(copy((
Ipv4(copy((
*ll::addrinfo_as_sockaddr_in(curr_addr))))
}
else if ll::is_ipv6_addrinfo(curr_addr) {
ipv6(copy((
Ipv6(copy((
*ll::addrinfo_as_sockaddr_in6(curr_addr))))
}
else {
log(debug, ~"curr_addr is not of family AF_INET or "+
~"AF_INET6. Error.");
(*handle_data).output_ch.send(
result::Err(get_addr_unknown_error));
result::Err(GetAddrUnknownError));
break;
};
out_vec += ~[new_ip_addr];
@ -294,13 +294,13 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
else {
log(debug, ~"addrinfo pointer is NULL");
(*handle_data).output_ch.send(
result::Err(get_addr_unknown_error));
result::Err(GetAddrUnknownError));
}
}
else {
log(debug, ~"status != 0 error in get_addr_cb");
(*handle_data).output_ch.send(
result::Err(get_addr_unknown_error));
result::Err(GetAddrUnknownError));
}
if res != (ptr::null::<addrinfo>()) {
uv_freeaddrinfo(res);
@ -365,8 +365,8 @@ mod test {
localhost_name, vec::len(results)));
for vec::each(results) |r| {
let ipv_prefix = match r {
ipv4(_) => ~"IPv4",
ipv6(_) => ~"IPv6"
Ipv4(_) => ~"IPv4",
Ipv6(_) => ~"IPv6"
};
log(debug, fmt!("test_get_addr: result %s: '%s'",
ipv_prefix, format_addr(r)));

292
src/libstd/net_tcp.rs
View file

@ -12,11 +12,11 @@ import io::{Reader, ReaderUtil, Writer};
import comm = core::comm;
// tcp interfaces
export tcp_socket;
export TcpSocket;
// buffered socket
export tcp_socket_buf, socket_buf;
export TcpSocketBuf, SocketBuf;
// errors
export tcp_err_data, tcp_connect_err_data;
export TcpErrData, TcpConnectErrData;
// operations on a tcp_socket
export write, write_future, read_start, read_stop;
// tcp server stuff
@ -38,9 +38,9 @@ extern mod rustrt {
* underlying libuv data structures when it goes out of scope. This is the
* data structure that is used for read/write operations over a TCP stream.
*/
struct tcp_socket {
let socket_data: @tcp_socket_data;
new(socket_data: @tcp_socket_data) { self.socket_data = socket_data; }
struct TcpSocket {
let socket_data: @TcpSocketData;
new(socket_data: @TcpSocketData) { self.socket_data = socket_data; }
drop {
unsafe {
tear_down_socket_data(self.socket_data)
@ -54,23 +54,23 @@ struct tcp_socket {
* It is created with a call to `net::tcp::socket_buf()` and has impls that
* satisfy both the `io::reader` and `io::writer` traits.
*/
struct tcp_socket_buf {
let data: @tcp_buffered_socket_data;
new(data: @tcp_buffered_socket_data) { self.data = data; }
struct TcpSocketBuf {
let data: @TcpBufferedSocketData;
new(data: @TcpBufferedSocketData) { self.data = data; }
}
/// Contains raw, string-based, error information returned from libuv
type tcp_err_data = {
type TcpErrData = {
err_name: ~str,
err_msg: ~str
};
/// Details returned as part of a `result::err` result from `tcp::listen`
enum tcp_listen_err_data {
enum TcpListenErrData {
/**
* Some unplanned-for error. The first and second fields correspond
* to libuv's `err_name` and `err_msg` fields, respectively.
*/
generic_listen_err(~str, ~str),
GenericListenErr(~str, ~str),
/**
* Failed to bind to the requested IP/Port, because it is already in use.
*
@ -78,7 +78,7 @@ enum tcp_listen_err_data {
*
* * Attempting to bind to a port already bound to another listener
*/
address_in_use,
AddressInUse,
/**
* Request to bind to an IP/Port was denied by the system.
*
@ -89,17 +89,17 @@ enum tcp_listen_err_data {
* * Attempting to bind, as a non-priv'd
* user, to 'privileged' ports (< 1024) on *nix
*/
access_denied
AccessDenied
}
/// Details returned as part of a `result::err` result from `tcp::connect`
enum tcp_connect_err_data {
enum TcpConnectErrData {
/**
* Some unplanned-for error. The first and second fields correspond
* to libuv's `err_name` and `err_msg` fields, respectively.
*/
generic_connect_err(~str, ~str),
GenericConnectErr(~str, ~str),
/// Invalid IP or invalid port
connection_refused
ConnectionRefused
}
/**
@ -118,17 +118,17 @@ enum tcp_connect_err_data {
* the remote host. In the event of failure, a
* `net::tcp::tcp_connect_err_data` instance will be returned
*/
fn connect(-input_ip: ip::ip_addr, port: uint,
fn connect(-input_ip: ip::IpAddr, port: uint,
iotask: IoTask)
-> result::Result<tcp_socket, tcp_connect_err_data> unsafe {
let result_po = core::comm::Port::<conn_attempt>();
-> result::Result<TcpSocket, TcpConnectErrData> unsafe {
let result_po = core::comm::Port::<ConnAttempt>();
let closed_signal_po = core::comm::Port::<()>();
let conn_data = {
result_ch: core::comm::Chan(result_po),
closed_signal_ch: core::comm::Chan(closed_signal_po)
};
let conn_data_ptr = ptr::addr_of(conn_data);
let reader_po = core::comm::Port::<result::Result<~[u8], tcp_err_data>>();
let reader_po = core::comm::Port::<result::Result<~[u8], TcpErrData>>();
let stream_handle_ptr = malloc_uv_tcp_t();
*(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
let socket_data = @{
@ -157,7 +157,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
ptr::addr_of((*socket_data_ptr).connect_req);
let addr_str = ip::format_addr(input_ip);
let connect_result = match input_ip {
ip::ipv4(addr) => {
ip::Ipv4(addr) => {
// have to "recreate" the sockaddr_in/6
// since the ip_addr discards the port
// info.. should probably add an additional
@ -171,7 +171,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
ptr::addr_of(in_addr),
tcp_connect_on_connect_cb)
}
ip::ipv6(addr) => {
ip::Ipv6(addr) => {
log(debug, fmt!("addr: %?", addr));
let in_addr = uv::ll::ip6_addr(addr_str, port as int);
uv::ll::tcp_connect6(
@ -202,7 +202,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
// ip or somesuch
let err_data = uv::ll::get_last_err_data(loop_ptr);
core::comm::send((*conn_data_ptr).result_ch,
conn_failure(err_data.to_tcp_err()));
ConnFailure(err_data.to_tcp_err()));
uv::ll::set_data_for_uv_handle(stream_handle_ptr,
conn_data_ptr);
uv::ll::close(stream_handle_ptr, stream_error_close_cb);
@ -213,24 +213,24 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
// failure to create a tcp handle
let err_data = uv::ll::get_last_err_data(loop_ptr);
core::comm::send((*conn_data_ptr).result_ch,
conn_failure(err_data.to_tcp_err()));
ConnFailure(err_data.to_tcp_err()));
}
}
};
match core::comm::recv(result_po) {
conn_success => {
ConnSuccess => {
log(debug, ~"tcp::connect - received success on result_po");
result::Ok(tcp_socket(socket_data))
result::Ok(TcpSocket(socket_data))
}
conn_failure(err_data) => {
ConnFailure(err_data) => {
core::comm::recv(closed_signal_po);
log(debug, ~"tcp::connect - received failure on result_po");
// still have to free the malloc'd stream handle..
rustrt::rust_uv_current_kernel_free(stream_handle_ptr
as *libc::c_void);
let tcp_conn_err = match err_data.err_name {
~"ECONNREFUSED" => connection_refused,
_ => generic_connect_err(err_data.err_name, err_data.err_msg)
~"ECONNREFUSED" => ConnectionRefused,
_ => GenericConnectErr(err_data.err_name, err_data.err_msg)
};
result::Err(tcp_conn_err)
}
@ -251,8 +251,8 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
* A `result` object with a `nil` value as the `ok` variant, or a
* `tcp_err_data` value as the `err` variant
*/
fn write(sock: tcp_socket, raw_write_data: ~[u8])
-> result::Result<(), tcp_err_data> unsafe {
fn write(sock: TcpSocket, raw_write_data: ~[u8])
-> result::Result<(), TcpErrData> unsafe {
let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
write_common_impl(socket_data_ptr, raw_write_data)
}
@ -288,8 +288,8 @@ fn write(sock: tcp_socket, raw_write_data: ~[u8])
* `result` object with a `nil` value as the `ok` variant, or a `tcp_err_data`
* value as the `err` variant
*/
fn write_future(sock: tcp_socket, raw_write_data: ~[u8])
-> future::Future<result::Result<(), tcp_err_data>> unsafe {
fn write_future(sock: TcpSocket, raw_write_data: ~[u8])
-> future::Future<result::Result<(), TcpErrData>> unsafe {
let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
do future_spawn {
let data_copy = copy(raw_write_data);
@ -312,9 +312,9 @@ fn write_future(sock: tcp_socket, raw_write_data: ~[u8])
* optionally, loop on) from until `read_stop` is called, or a
* `tcp_err_data` record
*/
fn read_start(sock: tcp_socket)
fn read_start(sock: TcpSocket)
-> result::Result<comm::Port<
result::Result<~[u8], tcp_err_data>>, tcp_err_data> unsafe {
result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe {
let socket_data = ptr::addr_of(*(sock.socket_data));
read_start_common_impl(socket_data)
}
@ -326,9 +326,9 @@ fn read_start(sock: tcp_socket)
*
* * `sock` - a `net::tcp::tcp_socket` that you wish to stop reading on
*/
fn read_stop(sock: tcp_socket,
-read_port: comm::Port<result::Result<~[u8], tcp_err_data>>) ->
result::Result<(), tcp_err_data> unsafe {
fn read_stop(sock: TcpSocket,
-read_port: comm::Port<result::Result<~[u8], TcpErrData>>) ->
result::Result<(), TcpErrData> unsafe {
log(debug, fmt!("taking the read_port out of commission %?", read_port));
let socket_data = ptr::addr_of(*sock.socket_data);
read_stop_common_impl(socket_data)
@ -349,8 +349,8 @@ fn read_stop(sock: tcp_socket,
* * `timeout_msecs` - a `uint` value, in msecs, to wait before dropping the
* read attempt. Pass `0u` to wait indefinitely
*/
fn read(sock: tcp_socket, timeout_msecs: uint)
-> result::Result<~[u8],tcp_err_data> {
fn read(sock: TcpSocket, timeout_msecs: uint)
-> result::Result<~[u8],TcpErrData> {
let socket_data = ptr::addr_of(*(sock.socket_data));
read_common_impl(socket_data, timeout_msecs)
}
@ -384,8 +384,8 @@ fn read(sock: tcp_socket, timeout_msecs: uint)
* * `timeout_msecs` - a `uint` value, in msecs, to wait before dropping the
* read attempt. Pass `0u` to wait indefinitely
*/
fn read_future(sock: tcp_socket, timeout_msecs: uint)
-> future::Future<result::Result<~[u8],tcp_err_data>> {
fn read_future(sock: TcpSocket, timeout_msecs: uint)
-> future::Future<result::Result<~[u8],TcpErrData>> {
let socket_data = ptr::addr_of(*(sock.socket_data));
do future_spawn {
read_common_impl(socket_data, timeout_msecs)
@ -461,13 +461,13 @@ fn read_future(sock: tcp_socket, timeout_msecs: uint)
* this function will return a `net::tcp::tcp_err_data` record
* as the `err` variant of a `result`.
*/
fn accept(new_conn: tcp_new_connection)
-> result::Result<tcp_socket, tcp_err_data> unsafe {
fn accept(new_conn: TcpNewConnection)
-> result::Result<TcpSocket, TcpErrData> unsafe {
match new_conn{
new_tcp_conn(server_handle_ptr) => {
NewTcpConn(server_handle_ptr) => {
let server_data_ptr = uv::ll::get_data_for_uv_handle(
server_handle_ptr) as *tcp_listen_fc_data;
server_handle_ptr) as *TcpListenFcData;
let reader_po = core::comm::Port();
let iotask = (*server_data_ptr).iotask;
let stream_handle_ptr = malloc_uv_tcp_t();
@ -484,7 +484,7 @@ fn accept(new_conn: tcp_new_connection)
let client_stream_handle_ptr =
(*client_socket_data_ptr).stream_handle_ptr;
let result_po = core::comm::Port::<Option<tcp_err_data>>();
let result_po = core::comm::Port::<Option<TcpErrData>>();
let result_ch = core::comm::Chan(result_po);
// UNSAFE LIBUV INTERACTION BEGIN
@ -525,7 +525,7 @@ fn accept(new_conn: tcp_new_connection)
// UNSAFE LIBUV INTERACTION END
match core::comm::recv(result_po) {
Some(err_data) => result::Err(err_data),
None => result::Ok(tcp_socket(client_socket_data))
None => result::Ok(TcpSocket(client_socket_data))
}
}
}
@ -559,30 +559,30 @@ fn accept(new_conn: tcp_new_connection)
* successful/normal shutdown, and a `tcp_listen_err_data` enum in the event
* of listen exiting because of an error
*/
fn listen(-host_ip: ip::ip_addr, port: uint, backlog: uint,
fn listen(-host_ip: ip::IpAddr, port: uint, backlog: uint,
iotask: IoTask,
on_establish_cb: fn~(comm::Chan<Option<tcp_err_data>>),
+new_connect_cb: fn~(tcp_new_connection,
comm::Chan<Option<tcp_err_data>>))
-> result::Result<(), tcp_listen_err_data> unsafe {
on_establish_cb: fn~(comm::Chan<Option<TcpErrData>>),
+new_connect_cb: fn~(TcpNewConnection,
comm::Chan<Option<TcpErrData>>))
-> result::Result<(), TcpListenErrData> unsafe {
do listen_common(host_ip, port, backlog, iotask, on_establish_cb)
// on_connect_cb
|handle| unsafe {
let server_data_ptr = uv::ll::get_data_for_uv_handle(handle)
as *tcp_listen_fc_data;
let new_conn = new_tcp_conn(handle);
as *TcpListenFcData;
let new_conn = NewTcpConn(handle);
let kill_ch = (*server_data_ptr).kill_ch;
new_connect_cb(new_conn, kill_ch);
}
}
fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
fn listen_common(-host_ip: ip::IpAddr, port: uint, backlog: uint,
iotask: IoTask,
on_establish_cb: fn~(comm::Chan<Option<tcp_err_data>>),
on_establish_cb: fn~(comm::Chan<Option<TcpErrData>>),
-on_connect_cb: fn~(*uv::ll::uv_tcp_t))
-> result::Result<(), tcp_listen_err_data> unsafe {
-> result::Result<(), TcpListenErrData> unsafe {
let stream_closed_po = core::comm::Port::<()>();
let kill_po = core::comm::Port::<Option<tcp_err_data>>();
let kill_po = core::comm::Port::<Option<TcpErrData>>();
let kill_ch = core::comm::Chan(kill_po);
let server_stream = uv::ll::tcp_t();
let server_stream_ptr = ptr::addr_of(server_stream);
@ -612,13 +612,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
server_data_ptr);
let addr_str = ip::format_addr(loc_ip);
let bind_result = match loc_ip {
ip::ipv4(addr) => {
ip::Ipv4(addr) => {
log(debug, fmt!("addr: %?", addr));
let in_addr = uv::ll::ip4_addr(addr_str, port as int);
uv::ll::tcp_bind(server_stream_ptr,
ptr::addr_of(in_addr))
}
ip::ipv6(addr) => {
ip::Ipv6(addr) => {
log(debug, fmt!("addr: %?", addr));
let in_addr = uv::ll::ip6_addr(addr_str, port as int);
uv::ll::tcp_bind6(server_stream_ptr,
@ -666,17 +666,17 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
match err_data.err_name {
~"EACCES" => {
log(debug, ~"Got EACCES error");
result::Err(access_denied)
result::Err(AccessDenied)
}
~"EADDRINUSE" => {
log(debug, ~"Got EADDRINUSE error");
result::Err(address_in_use)
result::Err(AddressInUse)
}
_ => {
log(debug, fmt!("Got '%s' '%s' libuv error",
err_data.err_name, err_data.err_msg));
result::Err(
generic_listen_err(err_data.err_name, err_data.err_msg))
GenericListenErr(err_data.err_name, err_data.err_msg))
}
}
}
@ -692,7 +692,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
stream_closed_po.recv();
match kill_result {
// some failure post bind/listen
Some(err_data) => result::Err(generic_listen_err(err_data.err_name,
Some(err_data) => result::Err(GenericListenErr(err_data.err_name,
err_data.err_msg)),
// clean exit
None => result::Ok(())
@ -716,41 +716,41 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
*
* A buffered wrapper that you can cast as an `io::reader` or `io::writer`
*/
fn socket_buf(-sock: tcp_socket) -> tcp_socket_buf {
tcp_socket_buf(@{ sock: sock, mut buf: ~[] })
fn socket_buf(-sock: TcpSocket) -> TcpSocketBuf {
TcpSocketBuf(@{ sock: sock, mut buf: ~[] })
}
/// Convenience methods extending `net::tcp::tcp_socket`
impl tcp_socket {
impl TcpSocket {
fn read_start() -> result::Result<comm::Port<
result::Result<~[u8], tcp_err_data>>, tcp_err_data> {
result::Result<~[u8], TcpErrData>>, TcpErrData> {
read_start(self)
}
fn read_stop(-read_port:
comm::Port<result::Result<~[u8], tcp_err_data>>) ->
result::Result<(), tcp_err_data> {
comm::Port<result::Result<~[u8], TcpErrData>>) ->
result::Result<(), TcpErrData> {
read_stop(self, read_port)
}
fn read(timeout_msecs: uint) ->
result::Result<~[u8], tcp_err_data> {
result::Result<~[u8], TcpErrData> {
read(self, timeout_msecs)
}
fn read_future(timeout_msecs: uint) ->
future::Future<result::Result<~[u8], tcp_err_data>> {
future::Future<result::Result<~[u8], TcpErrData>> {
read_future(self, timeout_msecs)
}
fn write(raw_write_data: ~[u8])
-> result::Result<(), tcp_err_data> {
-> result::Result<(), TcpErrData> {
write(self, raw_write_data)
}
fn write_future(raw_write_data: ~[u8])
-> future::Future<result::Result<(), tcp_err_data>> {
-> future::Future<result::Result<(), TcpErrData>> {
write_future(self, raw_write_data)
}
}
/// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
impl tcp_socket_buf: io::Reader {
impl TcpSocketBuf: io::Reader {
fn read(buf: &[mut u8], len: uint) -> uint {
// Loop until our buffer has enough data in it for us to read from.
while self.data.buf.len() < len {
@ -803,7 +803,7 @@ impl tcp_socket_buf: io::Reader {
}
/// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
impl tcp_socket_buf: io::Writer {
impl TcpSocketBuf: io::Writer {
fn write(data: &[const u8]) unsafe {
let socket_data_ptr =
ptr::addr_of(*((*(self.data)).sock).socket_data);
@ -832,7 +832,7 @@ impl tcp_socket_buf: io::Writer {
// INTERNAL API
fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
fn tear_down_socket_data(socket_data: @TcpSocketData) unsafe {
let closed_po = core::comm::Port::<()>();
let closed_ch = core::comm::Chan(closed_po);
let close_data = {
@ -855,8 +855,8 @@ fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
}
// shared implementation for tcp::read
fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
-> result::Result<~[u8],tcp_err_data> unsafe {
fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint)
-> result::Result<~[u8],TcpErrData> unsafe {
log(debug, ~"starting tcp::read");
let iotask = (*socket_data).iotask;
let rs_result = read_start_common_impl(socket_data);
@ -893,10 +893,10 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
}
// shared impl for read_stop
fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
result::Result<(), tcp_err_data> unsafe {
fn read_stop_common_impl(socket_data: *TcpSocketData) ->
result::Result<(), TcpErrData> unsafe {
let stream_handle_ptr = (*socket_data).stream_handle_ptr;
let stop_po = core::comm::Port::<Option<tcp_err_data>>();
let stop_po = core::comm::Port::<Option<TcpErrData>>();
let stop_ch = core::comm::Chan(stop_po);
do iotask::interact((*socket_data).iotask) |loop_ptr| unsafe {
log(debug, ~"in interact cb for tcp::read_stop");
@ -919,9 +919,9 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
}
// shared impl for read_start
fn read_start_common_impl(socket_data: *tcp_socket_data)
fn read_start_common_impl(socket_data: *TcpSocketData)
-> result::Result<comm::Port<
result::Result<~[u8], tcp_err_data>>, tcp_err_data> unsafe {
result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe {
let stream_handle_ptr = (*socket_data).stream_handle_ptr;
let start_po = core::comm::Port::<Option<uv::ll::uv_err_data>>();
let start_ch = core::comm::Chan(start_po);
@ -951,9 +951,9 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
// helper to convert a "class" vector of [u8] to a *[uv::ll::uv_buf_t]
// shared implementation used by write and write_future
fn write_common_impl(socket_data_ptr: *tcp_socket_data,
fn write_common_impl(socket_data_ptr: *TcpSocketData,
raw_write_data: ~[u8])
-> result::Result<(), tcp_err_data> unsafe {
-> result::Result<(), TcpErrData> unsafe {
let write_req_ptr = ptr::addr_of((*socket_data_ptr).write_req);
let stream_handle_ptr =
(*socket_data_ptr).stream_handle_ptr;
@ -961,7 +961,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
vec::unsafe::to_ptr(raw_write_data),
vec::len(raw_write_data)) ];
let write_buf_vec_ptr = ptr::addr_of(write_buf_vec);
let result_po = core::comm::Port::<tcp_write_result>();
let result_po = core::comm::Port::<TcpWriteResult>();
let write_data = {
result_ch: core::comm::Chan(result_po)
};
@ -980,7 +980,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
log(debug, ~"error invoking uv_write()");
let err_data = uv::ll::get_last_err_data(loop_ptr);
core::comm::send((*write_data_ptr).result_ch,
tcp_write_error(err_data.to_tcp_err()));
TcpWriteError(err_data.to_tcp_err()));
}
}
};
@ -989,19 +989,19 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
// ownership of everything to the I/O task and let it deal with the
// aftermath, so we don't have to sit here blocking.
match core::comm::recv(result_po) {
tcp_write_success => result::Ok(()),
tcp_write_error(err_data) => result::Err(err_data.to_tcp_err())
TcpWriteSuccess => result::Ok(()),
TcpWriteError(err_data) => result::Err(err_data.to_tcp_err())
}
}
enum tcp_new_connection {
new_tcp_conn(*uv::ll::uv_tcp_t)
enum TcpNewConnection {
NewTcpConn(*uv::ll::uv_tcp_t)
}
type tcp_listen_fc_data = {
type TcpListenFcData = {
server_stream_ptr: *uv::ll::uv_tcp_t,
stream_closed_ch: comm::Chan<()>,
kill_ch: comm::Chan<Option<tcp_err_data>>,
kill_ch: comm::Chan<Option<TcpErrData>>,
on_connect_cb: fn~(*uv::ll::uv_tcp_t),
iotask: IoTask,
mut active: bool
@ -1009,14 +1009,14 @@ type tcp_listen_fc_data = {
extern fn tcp_lfc_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
let server_data_ptr = uv::ll::get_data_for_uv_handle(
handle) as *tcp_listen_fc_data;
handle) as *TcpListenFcData;
core::comm::send((*server_data_ptr).stream_closed_ch, ());
}
extern fn tcp_lfc_on_connection_cb(handle: *uv::ll::uv_tcp_t,
status: libc::c_int) unsafe {
let server_data_ptr = uv::ll::get_data_for_uv_handle(handle)
as *tcp_listen_fc_data;
as *TcpListenFcData;
let kill_ch = (*server_data_ptr).kill_ch;
if (*server_data_ptr).active {
match status {
@ -1037,33 +1037,33 @@ fn malloc_uv_tcp_t() -> *uv::ll::uv_tcp_t unsafe {
rustrt::rust_uv_helper_uv_tcp_t_size()) as *uv::ll::uv_tcp_t
}
enum tcp_connect_result {
tcp_connected(tcp_socket),
tcp_connect_error(tcp_err_data)
enum TcpConnectResult {
TcpConnected(TcpSocket),
TcpConnectError(TcpErrData)
}
enum tcp_write_result {
tcp_write_success,
tcp_write_error(tcp_err_data)
enum TcpWriteResult {
TcpWriteSuccess,
TcpWriteError(TcpErrData)
}
enum tcp_read_start_result {
tcp_read_start_success(comm::Port<tcp_read_result>),
tcp_read_start_error(tcp_err_data)
enum TcpReadStartResult {
TcpReadStartSuccess(comm::Port<TcpReadResult>),
TcpReadStartError(TcpErrData)
}
enum tcp_read_result {
tcp_read_data(~[u8]),
tcp_read_done,
tcp_read_err(tcp_err_data)
enum TcpReadResult {
TcpReadData(~[u8]),
TcpReadDone,
TcpReadErr(TcpErrData)
}
trait to_tcp_err {
fn to_tcp_err() -> tcp_err_data;
trait ToTcpErr {
fn to_tcp_err() -> TcpErrData;
}
impl uv::ll::uv_err_data: to_tcp_err {
fn to_tcp_err() -> tcp_err_data {
impl uv::ll::uv_err_data: ToTcpErr {
fn to_tcp_err() -> TcpErrData {
{ err_name: self.err_name, err_msg: self.err_msg }
}
}
@ -1075,7 +1075,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
stream, nread));
let loop_ptr = uv::ll::get_loop_for_uv_handle(stream);
let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream)
as *tcp_socket_data;
as *TcpSocketData;
match nread as int {
// incoming err.. probably eof
-1 => {
@ -1113,13 +1113,13 @@ extern fn on_alloc_cb(handle: *libc::c_void,
uv::ll::buf_init(char_ptr, suggested_size as uint)
}
type tcp_socket_close_data = {
type TcpSocketCloseData = {
closed_ch: comm::Chan<()>
};
extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
let data = uv::ll::get_data_for_uv_handle(handle)
as *tcp_socket_close_data;
as *TcpSocketCloseData;
let closed_ch = (*data).closed_ch;
core::comm::send(closed_ch, ());
log(debug, ~"tcp_socket_dtor_close_cb exiting..");
@ -1128,10 +1128,10 @@ extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t,
status: libc::c_int) unsafe {
let write_data_ptr = uv::ll::get_data_for_req(write_req)
as *write_req_data;
as *WriteReqData;
if status == 0i32 {
log(debug, ~"successful write complete");
core::comm::send((*write_data_ptr).result_ch, tcp_write_success);
core::comm::send((*write_data_ptr).result_ch, TcpWriteSuccess);
} else {
let stream_handle_ptr = uv::ll::get_stream_handle_from_write_req(
write_req);
@ -1139,22 +1139,22 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t,
let err_data = uv::ll::get_last_err_data(loop_ptr);
log(debug, ~"failure to write");
core::comm::send((*write_data_ptr).result_ch,
tcp_write_error(err_data));
TcpWriteError(err_data));
}
}
type write_req_data = {
result_ch: comm::Chan<tcp_write_result>
type WriteReqData = {
result_ch: comm::Chan<TcpWriteResult>
};
type connect_req_data = {
result_ch: comm::Chan<conn_attempt>,
type ConnectReqData = {
result_ch: comm::Chan<ConnAttempt>,
closed_signal_ch: comm::Chan<()>
};
extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
let data = uv::ll::get_data_for_uv_handle(handle) as
*connect_req_data;
*ConnectReqData;
core::comm::send((*data).closed_signal_ch, ());
log(debug, fmt!("exiting steam_error_close_cb for %?", handle));
}
@ -1166,7 +1166,7 @@ extern fn tcp_connect_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
status: libc::c_int) unsafe {
let conn_data_ptr = (uv::ll::get_data_for_req(connect_req_ptr)
as *connect_req_data);
as *ConnectReqData);
let result_ch = (*conn_data_ptr).result_ch;
log(debug, fmt!("tcp_connect result_ch %?", result_ch));
let tcp_stream_ptr =
@ -1174,7 +1174,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
match status {
0i32 => {
log(debug, ~"successful tcp connection!");
core::comm::send(result_ch, conn_success);
core::comm::send(result_ch, ConnSuccess);
}
_ => {
log(debug, ~"error in tcp_connect_on_connect_cb");
@ -1182,7 +1182,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
let err_data = uv::ll::get_last_err_data(loop_ptr);
log(debug, fmt!("err_data %? %?", err_data.err_name,
err_data.err_msg));
core::comm::send(result_ch, conn_failure(err_data));
core::comm::send(result_ch, ConnFailure(err_data));
uv::ll::set_data_for_uv_handle(tcp_stream_ptr,
conn_data_ptr);
uv::ll::close(tcp_stream_ptr, stream_error_close_cb);
@ -1191,22 +1191,22 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
log(debug, ~"leaving tcp_connect_on_connect_cb");
}
enum conn_attempt {
conn_success,
conn_failure(uv::ll::uv_err_data)
enum ConnAttempt {
ConnSuccess,
ConnFailure(uv::ll::uv_err_data)
}
type tcp_socket_data = {
reader_po: comm::Port<result::Result<~[u8], tcp_err_data>>,
reader_ch: comm::Chan<result::Result<~[u8], tcp_err_data>>,
type TcpSocketData = {
reader_po: comm::Port<result::Result<~[u8], TcpErrData>>,
reader_ch: comm::Chan<result::Result<~[u8], TcpErrData>>,
stream_handle_ptr: *uv::ll::uv_tcp_t,
connect_req: uv::ll::uv_connect_t,
write_req: uv::ll::uv_write_t,
iotask: IoTask
};
type tcp_buffered_socket_data = {
sock: tcp_socket,
type TcpBufferedSocketData = {
sock: TcpSocket,
mut buf: ~[u8]
};
@ -1333,7 +1333,7 @@ mod test {
hl_loop)
};
match actual_resp_result.get_err() {
connection_refused => (),
ConnectionRefused => (),
_ => fail ~"unknown error.. expected connection_refused"
}
}
@ -1379,7 +1379,7 @@ mod test {
hl_loop)
};
match listen_err {
address_in_use => {
AddressInUse => {
assert true;
}
_ => {
@ -1398,7 +1398,7 @@ mod test {
server_port,
hl_loop);
match listen_err {
access_denied => {
AccessDenied => {
assert true;
}
_ => {
@ -1544,14 +1544,14 @@ mod test {
// err check on listen_result
if result::is_err(listen_result) {
match result::get_err(listen_result) {
generic_listen_err(name, msg) => {
GenericListenErr(name, msg) => {
fail fmt!("SERVER: exited abnormally name %s msg %s",
name, msg);
}
access_denied => {
AccessDenied => {
fail ~"SERVER: exited abnormally, got access denied..";
}
address_in_use => {
AddressInUse => {
fail ~"SERVER: exited abnormally, got address in use...";
}
}
@ -1562,7 +1562,7 @@ mod test {
}
fn run_tcp_test_server_fail(server_ip: ~str, server_port: uint,
iotask: IoTask) -> tcp_listen_err_data {
iotask: IoTask) -> TcpListenErrData {
let server_ip_addr = ip::v4::parse_addr(server_ip);
let listen_result = listen(server_ip_addr, server_port, 128u, iotask,
// on_establish_cb -- called when listener is set up
@ -1586,7 +1586,7 @@ mod test {
fn run_tcp_test_client(server_ip: ~str, server_port: uint, resp: ~str,
client_ch: comm::Chan<~str>,
iotask: IoTask) -> result::Result<~str,
tcp_connect_err_data> {
TcpConnectErrData> {
let server_ip_addr = ip::v4::parse_addr(server_ip);
log(debug, ~"CLIENT: starting..");
@ -1615,7 +1615,7 @@ mod test {
}
}
fn tcp_write_single(sock: tcp_socket, val: ~[u8]) {
fn tcp_write_single(sock: TcpSocket, val: ~[u8]) {
let write_result_future = sock.write_future(val);
let write_result = write_result_future.get();
if result::is_err(write_result) {

144
src/libstd/net_url.rs
View file

@ -6,7 +6,7 @@ import map::{hashmap, str_hash};
import io::{Reader, ReaderUtil};
import dvec::DVec;
export url, userinfo, query;
export Url, userinfo, query;
export from_str, to_str;
export get_scheme;
@ -14,31 +14,31 @@ export encode, decode;
export encode_component, decode_component;
export encode_form_urlencoded, decode_form_urlencoded;
type url = {
type Url = {
scheme: ~str,
user: Option<userinfo>,
user: Option<UserInfo>,
host: ~str,
port: Option<~str>,
path: ~str,
query: query,
query: Query,
fragment: Option<~str>
};
type userinfo = {
type UserInfo = {
user: ~str,
pass: Option<~str>
};
type query = ~[(~str, ~str)];
type Query = ~[(~str, ~str)];
fn url(-scheme: ~str, -user: Option<userinfo>, -host: ~str,
-port: Option<~str>, -path: ~str, -query: query,
-fragment: Option<~str>) -> url {
fn url(-scheme: ~str, -user: Option<UserInfo>, -host: ~str,
-port: Option<~str>, -path: ~str, -query: Query,
-fragment: Option<~str>) -> Url {
{ scheme: scheme, user: user, host: host, port: port,
path: path, query: query, fragment: fragment }
}
fn userinfo(-user: ~str, -pass: Option<~str>) -> userinfo {
fn userinfo(-user: ~str, -pass: Option<~str>) -> UserInfo {
{user: user, pass: pass}
}
@ -290,7 +290,7 @@ fn split_char_first(s: ~str, c: char) -> (~str, ~str) {
}
}
fn userinfo_from_str(uinfo: ~str) -> userinfo {
fn userinfo_from_str(uinfo: ~str) -> UserInfo {
let (user, p) = split_char_first(uinfo, ':');
let pass = if str::len(p) == 0 {
option::None
@ -300,7 +300,7 @@ fn userinfo_from_str(uinfo: ~str) -> userinfo {
return userinfo(user, pass);
}
fn userinfo_to_str(-userinfo: userinfo) -> ~str {
fn userinfo_to_str(-userinfo: UserInfo) -> ~str {
if option::is_some(userinfo.pass) {
return str::concat(~[copy userinfo.user, ~":",
option::unwrap(copy userinfo.pass),
@ -310,14 +310,14 @@ fn userinfo_to_str(-userinfo: userinfo) -> ~str {
}
}
impl userinfo : Eq {
pure fn eq(&&other: userinfo) -> bool {
impl UserInfo : Eq {
pure fn eq(&&other: UserInfo) -> bool {
self.user == other.user && self.pass == other.pass
}
}
fn query_from_str(rawquery: ~str) -> query {
let mut query: query = ~[];
fn query_from_str(rawquery: ~str) -> Query {
let mut query: Query = ~[];
if str::len(rawquery) != 0 {
for str::split_char(rawquery, '&').each |p| {
let (k, v) = split_char_first(p, '=');
@ -327,7 +327,7 @@ fn query_from_str(rawquery: ~str) -> query {
return query;
}
fn query_to_str(query: query) -> ~str {
fn query_to_str(query: Query) -> ~str {
let mut strvec = ~[];
for query.each |kv| {
let (k, v) = copy kv;
@ -363,47 +363,47 @@ fn get_scheme(rawurl: ~str) -> result::Result<(~str, ~str), @~str> {
return result::Err(@~"url: Scheme must be terminated with a colon.");
}
enum input {
digit, // all digits
hex, // digits and letters a-f
unreserved // all other legal characters
enum Input {
Digit, // all digits
Hex, // digits and letters a-f
Unreserved // all other legal characters
}
impl input: Eq {
pure fn eq(&&other: input) -> bool {
impl Input: Eq {
pure fn eq(&&other: Input) -> bool {
match (self, other) {
(digit, digit) => true,
(hex, hex) => true,
(unreserved, unreserved) => true,
(digit, _) => false,
(hex, _) => false,
(unreserved, _) => false
(Digit, Digit) => true,
(Hex, Hex) => true,
(Unreserved, Unreserved) => true,
(Digit, _) => false,
(Hex, _) => false,
(Unreserved, _) => false
}
}
}
// returns userinfo, host, port, and unparsed part, or an error
fn get_authority(rawurl: ~str) ->
result::Result<(Option<userinfo>, ~str, Option<~str>, ~str), @~str> {
result::Result<(Option<UserInfo>, ~str, Option<~str>, ~str), @~str> {
if !str::starts_with(rawurl, ~"//") {
// there is no authority.
return result::Ok((option::None, ~"", option::None, copy rawurl));
}
enum state {
start, // starting state
pass_host_port, // could be in user or port
ip6_port, // either in ipv6 host or port
ip6_host, // are in an ipv6 host
in_host, // are in a host - may be ipv6, but don't know yet
in_port // are in port
enum State {
Start, // starting state
PassHostPort, // could be in user or port
Ip6Port, // either in ipv6 host or port
Ip6Host, // are in an ipv6 host
InHost, // are in a host - may be ipv6, but don't know yet
InPort // are in port
}
let len = str::len(rawurl);
let mut st : state = start;
let mut in : input = digit; // most restricted, start here.
let mut st : State = Start;
let mut in : Input = Digit; // most restricted, start here.
let mut userinfo : Option<userinfo> = option::None;
let mut userinfo : Option<UserInfo> = option::None;
let mut host : ~str = ~"";
let mut port : option::Option<~str> = option::None;
@ -417,13 +417,13 @@ fn get_authority(rawurl: ~str) ->
match c {
'0' to '9' => (),
'A' to 'F' | 'a' to 'f' => {
if in == digit {
in = hex;
if in == Digit {
in = Hex;
}
}
'G' to 'Z' | 'g' to 'z' | '-' | '.' | '_' | '~' | '%' |
'&' |'\'' | '(' | ')' | '+' | '!' | '*' | ',' | ';' | '=' => {
in = unreserved;
in = Unreserved;
}
':' | '@' | '?' | '#' | '/' => {
// separators, don't change anything
@ -438,62 +438,62 @@ fn get_authority(rawurl: ~str) ->
':' => {
colon_count += 1;
match st {
start => {
Start => {
pos = i;
st = pass_host_port;
st = PassHostPort;
}
pass_host_port => {
PassHostPort => {
// multiple colons means ipv6 address.
if in == unreserved {
if in == Unreserved {
return result::Err(
@~"Illegal characters in IPv6 address.");
}
st = ip6_host;
st = Ip6Host;
}
in_host => {
InHost => {
pos = i;
// can't be sure whether this is an ipv6 address or a port
if in == unreserved {
if in == Unreserved {
return result::Err(@~"Illegal characters in authority.");
}
st = ip6_port;
st = Ip6Port;
}
ip6_port => {
if in == unreserved {
Ip6Port => {
if in == Unreserved {
return result::Err(@~"Illegal characters in authority.");
}
st = ip6_host;
st = Ip6Host;
}
ip6_host => {
Ip6Host => {
if colon_count > 7 {
host = str::slice(rawurl, begin, i);
pos = i;
st = in_port;
st = InPort;
}
}
_ => {
return result::Err(@~"Invalid ':' in authority.");
}
}
in = digit; // reset input class
in = Digit; // reset input class
}
'@' => {
in = digit; // reset input class
in = Digit; // reset input class
colon_count = 0; // reset count
match st {
start => {
Start => {
let user = str::slice(rawurl, begin, i);
userinfo = option::Some({user : user,
pass: option::None});
st = in_host;
st = InHost;
}
pass_host_port => {
PassHostPort => {
let user = str::slice(rawurl, begin, pos);
let pass = str::slice(rawurl, pos+1, i);
userinfo = option::Some({user: user,
pass: option::Some(pass)});
st = in_host;
st = InHost;
}
_ => {
return result::Err(@~"Invalid '@' in authority.");
@ -520,25 +520,25 @@ fn get_authority(rawurl: ~str) ->
// finish up
match st {
start => {
Start => {
if host_is_end_plus_one() {
host = str::slice(rawurl, begin, end+1);
} else {
host = str::slice(rawurl, begin, end);
}
}
pass_host_port | ip6_port => {
if in != digit {
PassHostPort | Ip6Port => {
if in != Digit {
return result::Err(@~"Non-digit characters in port.");
}
host = str::slice(rawurl, begin, pos);
port = option::Some(str::slice(rawurl, pos+1, end));
}
ip6_host | in_host => {
Ip6Host | InHost => {
host = str::slice(rawurl, begin, end);
}
in_port => {
if in != digit {
InPort => {
if in != Digit {
return result::Err(@~"Non-digit characters in port.");
}
port = option::Some(str::slice(rawurl, pos+1, end));
@ -584,7 +584,7 @@ fn get_path(rawurl: ~str, authority : bool) ->
// returns the parsed query and the fragment, if present
fn get_query_fragment(rawurl: ~str) ->
result::Result<(query, Option<~str>), @~str> {
result::Result<(Query, Option<~str>), @~str> {
if !str::starts_with(rawurl, ~"?") {
if str::starts_with(rawurl, ~"#") {
let f = decode_component(str::slice(rawurl,
@ -615,7 +615,7 @@ fn get_query_fragment(rawurl: ~str) ->
*
*/
fn from_str(rawurl: ~str) -> result::Result<url, ~str> {
fn from_str(rawurl: ~str) -> result::Result<Url, ~str> {
// scheme
let mut schm = get_scheme(rawurl);
if result::is_err(schm) {
@ -664,7 +664,7 @@ fn from_str(rawurl: ~str) -> result::Result<url, ~str> {
* result in just "http://somehost.com".
*
*/
fn to_str(url: url) -> ~str {
fn to_str(url: Url) -> ~str {
let user = if option::is_some(url.user) {
userinfo_to_str(option::unwrap(copy url.user))
} else {
@ -695,7 +695,7 @@ fn to_str(url: url) -> ~str {
fragment]);
}
impl url: to_str::ToStr {
impl Url: to_str::ToStr {
fn to_str() -> ~str {
to_str(self)
}

4
src/libstd/std.rc
View file

@ -30,9 +30,13 @@ export cell;
// General io and system-services modules
#[warn(non_camel_case_types)]
mod net;
#[warn(non_camel_case_types)]
mod net_ip;
#[warn(non_camel_case_types)]
mod net_tcp;
#[warn(non_camel_case_types)]
mod net_url;
// libuv modules