Jeremy Soller
728 lines
22 KiB
Rust
728 lines
22 KiB
Rust
use libc;
|
|
use types::{in_addr, sockaddr, socklen_t};
|
|
use RawLineBuffer;
|
|
use core::ptr::null;
|
|
use core::{mem, str};
|
|
use alloc::vec::IntoIter;
|
|
use alloc::string::ToString;
|
|
use alloc::{Vec, String};
|
|
use alloc::str::SplitWhitespace;
|
|
use alloc::boxed::Box;
|
|
use dns::{Dns, DnsQuery};
|
|
use syscall::{self, Result, EINVAL, Error};
|
|
use libc::c_char;
|
|
|
|
const MAXADDRS: usize = 35;
|
|
const MAXALIASES: usize = 35;
|
|
|
|
struct LookupHost(IntoIter<in_addr>);
|
|
|
|
impl Iterator for LookupHost {
|
|
type Item = in_addr;
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
self.0.next()
|
|
}
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct hostent {
|
|
h_name: *const libc::c_char,
|
|
h_aliases: *const *const libc::c_char,
|
|
h_addrtype: libc::c_int,
|
|
h_length: libc::c_int,
|
|
h_addr_list: *const *const libc::c_char,
|
|
}
|
|
|
|
/*
|
|
*#[repr(C)]
|
|
*pub struct netent {
|
|
* n_name: *const libc::c_char, [> official name of net <]
|
|
* n_aliases: *const *const libc::c_char, [> alias list <]
|
|
* n_addrtype: libc::c_int, [> net address type <]
|
|
* n_net: libc::c_ulong, [> network # <]
|
|
*}
|
|
*/
|
|
|
|
#[repr(C)]
|
|
pub struct servent {
|
|
s_name: *const libc::c_char, /* official service name */
|
|
s_aliases: *const *const libc::c_char, /* alias list */
|
|
s_port: libc::c_int, /* port # */
|
|
s_proto: *const libc::c_char, /* protocol to use */
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct protoent {
|
|
p_name: *const libc::c_char, /* official protocol name */
|
|
p_aliases: *const *const libc::c_char, /* alias list */
|
|
p_proto: libc::c_int, /* protocol # */
|
|
}
|
|
|
|
#[repr(C)]
|
|
pub struct addrinfo {
|
|
ai_flags: libc::c_int, /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
|
|
ai_family: libc::c_int, /* PF_xxx */
|
|
ai_socktype: libc::c_int, /* SOCK_xxx */
|
|
ai_protocol: libc::c_int, /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
|
|
ai_addrlen: libc::size_t, /* length of ai_addr */
|
|
ai_canonname: *const libc::c_char, /* canonical name for hostname */
|
|
ai_addr: *const sockaddr, /* binary address */
|
|
ai_next: *const addrinfo, /* next structure in linked list */
|
|
}
|
|
|
|
static mut HOSTDB: usize = 0;
|
|
//static mut NETDB: usize = 0;
|
|
static mut PROTODB: usize = 0;
|
|
static mut SERVDB: usize = 0;
|
|
|
|
/*
|
|
*static mut NET_ENTRY: netent = netent {
|
|
* n_name: 0 as *const libc::c_char,
|
|
* n_aliases: 0 as *const *const libc::c_char,
|
|
* n_addrtype: 0,
|
|
* n_net: 0 as u64,
|
|
*};
|
|
*static mut NET_NAME: Option<Vec<u8>> = None;
|
|
*static mut NET_ALIASES: [*const c_char; MAXALIASES] = [null(); MAXALIASES];
|
|
*static mut NET_NUM: Option<u64> = None;
|
|
*/
|
|
|
|
static mut HOST_ENTRY: hostent = hostent {
|
|
h_name: 0 as *const libc::c_char,
|
|
h_aliases: 0 as *const *const libc::c_char,
|
|
h_addrtype: 0,
|
|
h_length: 0,
|
|
h_addr_list: 0 as *const *const libc::c_char,
|
|
};
|
|
static mut HOST_NAME: Option<Vec<u8>> = None;
|
|
static mut HOST_ALIASES: Option<Vec<Vec<u8>>> = None;
|
|
static mut HOST_ADDR: Option<in_addr> = None;
|
|
static mut HOST_ADDR_LIST: [*const c_char; 2] = [null(); 2];
|
|
static mut H_LINE: RawLineBuffer = RawLineBuffer {
|
|
fd: 0,
|
|
cur: 0,
|
|
read: 0,
|
|
buf: [0; 8 * 1024],
|
|
};
|
|
|
|
static mut PROTO_ENTRY: protoent = protoent {
|
|
p_name: 0 as *const libc::c_char,
|
|
p_aliases: 0 as *const *const libc::c_char,
|
|
p_proto: 0 as libc::c_int,
|
|
};
|
|
static mut PROTO_NAME: Option<Vec<u8>> = None;
|
|
static mut PROTO_ALIASES: Option<Vec<Vec<u8>>> = None;
|
|
static mut PROTO_NUM: Option<libc::c_int> = None;
|
|
static mut P_LINE: RawLineBuffer = RawLineBuffer {
|
|
fd: 0,
|
|
cur: 0,
|
|
read: 0,
|
|
buf: [0; 8 * 1024],
|
|
};
|
|
|
|
static mut SERV_ENTRY: servent = servent {
|
|
s_name: 0 as *const libc::c_char,
|
|
s_aliases: 0 as *const *const libc::c_char,
|
|
s_port: 0 as libc::c_int,
|
|
s_proto: 0 as *const libc::c_char,
|
|
};
|
|
static mut SERV_NAME: Option<Vec<u8>> = None;
|
|
static mut SERV_ALIASES: Option<Vec<Vec<u8>>> = None;
|
|
static mut SERV_PORT: Option<libc::c_int> = None;
|
|
static mut SERV_PROTO: Option<Vec<u8>> = None;
|
|
static mut S_LINE: RawLineBuffer = RawLineBuffer {
|
|
fd: 0,
|
|
cur: 0,
|
|
read: 0,
|
|
buf: [0; 8 * 1024],
|
|
};
|
|
|
|
|
|
fn lookup_host(host: &str) -> Result<LookupHost> {
|
|
// XXX better error handling
|
|
let ip_string = String::from_utf8(::file_read_all("/etc/net/ip")?).or(Err(
|
|
Error::new(syscall::EIO),
|
|
))?;
|
|
let ip: Vec<u8> = ip_string
|
|
.trim()
|
|
.split(".")
|
|
.map(|part| part.parse::<u8>().unwrap_or(0))
|
|
.collect();
|
|
|
|
let dns_string = String::from_utf8(::file_read_all("/etc/net/dns")?).or(Err(
|
|
Error::new(syscall::EIO),
|
|
))?;
|
|
let dns: Vec<u8> = dns_string
|
|
.trim()
|
|
.split(".")
|
|
.map(|part| part.parse::<u8>().unwrap_or(0))
|
|
.collect();
|
|
|
|
if ip.len() == 4 && dns.len() == 4 {
|
|
let mut timespec = syscall::TimeSpec::default();
|
|
syscall::clock_gettime(syscall::CLOCK_REALTIME, &mut timespec).unwrap();
|
|
let tid = (timespec.tv_nsec >> 16) as u16;
|
|
|
|
let packet = Dns {
|
|
transaction_id: tid,
|
|
flags: 0x0100,
|
|
queries: vec![
|
|
DnsQuery {
|
|
name: host.to_string(),
|
|
q_type: 0x0001,
|
|
q_class: 0x0001,
|
|
},
|
|
],
|
|
answers: vec![],
|
|
};
|
|
|
|
let packet_data = packet.compile();
|
|
|
|
let fd = ::RawFile::open(
|
|
format!("udp:/{}.{}.{}.{}:0", ip[0], ip[1], ip[2], ip[3]).as_bytes(),
|
|
syscall::O_RDWR,
|
|
)?;
|
|
|
|
let timeout = syscall::TimeSpec {
|
|
tv_sec: 5,
|
|
tv_nsec: 0,
|
|
};
|
|
let rt = fd.dup(b"read_timeout")?;
|
|
syscall::write(*rt, &timeout)?;
|
|
drop(rt);
|
|
let wt = fd.dup(b"write_timeout")?;
|
|
syscall::write(*wt, &timeout)?;
|
|
drop(wt);
|
|
|
|
let sendrecvfd = fd.dup(
|
|
format!("{}.{}.{}.{}:53", dns[0], dns[1], dns[2], dns[3])
|
|
.as_bytes(),
|
|
)?;
|
|
syscall::write(*sendrecvfd, &packet_data)?;
|
|
let mut buf = [0; 65536];
|
|
let count = syscall::read(*sendrecvfd, &mut buf)?;
|
|
drop(sendrecvfd);
|
|
drop(fd);
|
|
|
|
match Dns::parse(&buf[..count]) {
|
|
Ok(response) => {
|
|
let mut addrs = vec![];
|
|
for answer in response.answers.iter() {
|
|
if answer.a_type == 0x0001 && answer.a_class == 0x0001 &&
|
|
answer.data.len() == 4
|
|
{
|
|
let addr = in_addr {
|
|
s_addr: [
|
|
answer.data[0],
|
|
answer.data[1],
|
|
answer.data[2],
|
|
answer.data[3],
|
|
],
|
|
};
|
|
addrs.push(addr);
|
|
}
|
|
}
|
|
Ok(LookupHost(addrs.into_iter()))
|
|
}
|
|
Err(_err) => Err(Error::new(EINVAL)),
|
|
}
|
|
} else {
|
|
Err(Error::new(EINVAL))
|
|
}
|
|
}
|
|
|
|
unsafe fn lookup_addr(addr: in_addr) -> Result<Vec<Vec<u8>>> {
|
|
// XXX better error handling
|
|
let ip_string = String::from_utf8(::file_read_all("/etc/net/ip")?).or(Err(
|
|
Error::new(syscall::EIO),
|
|
))?;
|
|
let ip: Vec<u8> = ip_string
|
|
.trim()
|
|
.split(".")
|
|
.map(|part| part.parse::<u8>().unwrap_or(0))
|
|
.collect();
|
|
|
|
let dns_string = String::from_utf8(::file_read_all("/etc/net/dns")?).or(Err(
|
|
Error::new(syscall::EIO),
|
|
))?;
|
|
let dns: Vec<u8> = dns_string
|
|
.trim()
|
|
.split(".")
|
|
.map(|part| part.parse::<u8>().unwrap_or(0))
|
|
.collect();
|
|
|
|
let mut addr_vec: Vec<u8> = addr.s_addr.to_vec();
|
|
addr_vec.reverse();
|
|
let mut name: Vec<u8> = vec![];
|
|
for octet in addr_vec {
|
|
for ch in format!("{}", octet).as_bytes() {
|
|
name.push(*ch);
|
|
}
|
|
name.push(b"."[0]);
|
|
}
|
|
name.pop();
|
|
for ch in b".IN-ADDR.ARPA" {
|
|
name.push(*ch);
|
|
}
|
|
let _ = syscall::write(2, name.as_slice());
|
|
let _ = syscall::write(2, "\n".as_bytes());
|
|
|
|
if ip.len() == 4 && dns.len() == 4 {
|
|
let mut timespec = syscall::TimeSpec::default();
|
|
syscall::clock_gettime(syscall::CLOCK_REALTIME, &mut timespec).unwrap();
|
|
let tid = (timespec.tv_nsec >> 16) as u16;
|
|
|
|
let packet = Dns {
|
|
transaction_id: tid,
|
|
flags: 0x0100,
|
|
queries: vec![
|
|
DnsQuery {
|
|
name: String::from_utf8(name).unwrap(),
|
|
q_type: 0x000C,
|
|
q_class: 0x0001,
|
|
},
|
|
],
|
|
answers: vec![],
|
|
};
|
|
|
|
let packet_data = packet.compile();
|
|
|
|
let fd = ::RawFile::open(
|
|
format!("udp:/{}.{}.{}.{}:0", ip[0], ip[1], ip[2], ip[3]).as_bytes(),
|
|
syscall::O_RDWR,
|
|
)?;
|
|
|
|
let timeout = syscall::TimeSpec {
|
|
tv_sec: 5,
|
|
tv_nsec: 0,
|
|
};
|
|
let rt = fd.dup(b"read_timeout")?;
|
|
syscall::write(*rt, &timeout)?;
|
|
drop(rt);
|
|
let wt = fd.dup(b"write_timeout")?;
|
|
syscall::write(*wt, &timeout)?;
|
|
drop(wt);
|
|
|
|
let sendrecvfd = fd.dup(
|
|
format!("{}.{}.{}.{}:53", dns[0], dns[1], dns[2], dns[3])
|
|
.as_bytes(),
|
|
)?;
|
|
syscall::write(*sendrecvfd, &packet_data)?;
|
|
let mut buf = [0; 65536];
|
|
let count = syscall::read(*sendrecvfd, &mut buf)?;
|
|
drop(sendrecvfd);
|
|
drop(fd);
|
|
|
|
match Dns::parse(&buf[..count]) {
|
|
Ok(response) => {
|
|
let _ = syscall::write(2, format!("{:?}", response).as_bytes());
|
|
let _ = syscall::write(2, "\n".as_bytes());
|
|
let mut names = vec![];
|
|
for answer in response.answers.iter() {
|
|
|
|
if answer.a_type == 0x000C && answer.a_class == 0x0001
|
|
{
|
|
// answer.data is encoded kinda weird.
|
|
// Basically length-prefixed strings for each
|
|
// subsection of the domain.
|
|
// We need to parse this to insert periods where
|
|
// they belong (ie at the end of each string)
|
|
let data = parse_data(answer.data.clone());
|
|
names.push(data);
|
|
}
|
|
}
|
|
Ok(names)
|
|
}
|
|
Err(_err) => Err(Error::new(EINVAL)),
|
|
}
|
|
} else {
|
|
Err(Error::new(EINVAL))
|
|
}
|
|
}
|
|
|
|
fn parse_data(mut data: Vec<u8>) -> Vec<u8> {
|
|
let mut cursor = 0;
|
|
let mut offset = 0;
|
|
let mut index = 0;
|
|
let mut output = data.clone();
|
|
while index < data.len() - 1 {
|
|
offset = data[index] as usize;
|
|
index = cursor + offset + 1;
|
|
output[index] = '.' as u8;
|
|
cursor = index;
|
|
}
|
|
//we don't want an extra period at the end
|
|
output.pop();
|
|
return output
|
|
}
|
|
|
|
|
|
|
|
libc_fn!(unsafe endhostent() {
|
|
let _ = syscall::close(HOSTDB);
|
|
});
|
|
|
|
/*
|
|
*libc_fn!(unsafe endnetent() {
|
|
* let _ = syscall::close(NETDB);
|
|
*});
|
|
*/
|
|
|
|
libc_fn!(unsafe endprotoent() {
|
|
let _ = syscall::close(PROTODB);
|
|
});
|
|
|
|
libc_fn!(unsafe endservent() {
|
|
let _ = syscall::close(SERVDB);
|
|
});
|
|
|
|
|
|
libc_fn!(unsafe gethostbyaddr(v: *const libc::c_void, length: socklen_t, format: libc::c_int) -> Result <*const hostent> {
|
|
let mut addr: in_addr = *(v as *mut in_addr);
|
|
match lookup_addr(addr) {
|
|
Ok(s) => {
|
|
HOST_ADDR_LIST = [addr.s_addr.as_mut_ptr() as *const c_char, null()];
|
|
let host_name = s[0].to_vec();
|
|
HOST_ENTRY = hostent {
|
|
h_name: host_name.as_ptr() as *const c_char,
|
|
h_aliases: [null();2].as_mut_ptr(),
|
|
h_addrtype: format,
|
|
h_length: length as i32,
|
|
h_addr_list: HOST_ADDR_LIST.as_ptr()
|
|
};
|
|
HOST_NAME = Some(host_name);
|
|
return Ok(&HOST_ENTRY)
|
|
}
|
|
Err(err) => Err(err)
|
|
}
|
|
});
|
|
|
|
libc_fn!(unsafe gethostbyname(name: *const c_char) -> Result<*const hostent> {
|
|
// XXX h_errno
|
|
let mut addr = mem::uninitialized();
|
|
let mut host_addr = if ::socket::inet_aton(name, &mut addr) == 1 {
|
|
addr
|
|
} else {
|
|
// XXX
|
|
let mut host = lookup_host(str::from_utf8_unchecked(::cstr_to_slice(name)))?;
|
|
host.next().ok_or(Error::new(syscall::ENOENT))? // XXX
|
|
};
|
|
|
|
let host_name: Vec<u8> = ::cstr_to_slice(name).to_vec();
|
|
HOST_ADDR_LIST = [host_addr.s_addr.as_mut_ptr() as *const c_char, null()];
|
|
HOST_ADDR = Some(host_addr);
|
|
|
|
HOST_ENTRY = hostent {
|
|
h_name: host_name.as_ptr() as *const c_char,
|
|
h_aliases: [null();2].as_mut_ptr(),
|
|
h_addrtype: ::socket::AF_INET,
|
|
h_length: 4,
|
|
h_addr_list: HOST_ADDR_LIST.as_ptr()
|
|
};
|
|
|
|
HOST_NAME = Some(host_name);
|
|
|
|
Ok(&HOST_ENTRY as *const hostent)
|
|
});
|
|
|
|
libc_fn!(unsafe gethostent() -> *const hostent {
|
|
if HOSTDB == 0 {
|
|
HOSTDB = syscall::open("/etc/hosts", syscall::O_RDONLY).unwrap();
|
|
H_LINE = RawLineBuffer::new(HOSTDB);
|
|
}
|
|
|
|
let mut r: Box<str> = Box::default();
|
|
while r.is_empty() || r.split_whitespace().next() == None || r.starts_with("#") {
|
|
r = match H_LINE.next() {
|
|
Some(Ok(s)) => s,
|
|
Some(Err(_)) => return null(),
|
|
None => return null(),
|
|
};
|
|
}
|
|
|
|
|
|
let mut iter: SplitWhitespace = r.split_whitespace();
|
|
|
|
let mut addr_vec = iter.next().unwrap().as_bytes().to_vec();
|
|
addr_vec.push(b'\0');
|
|
let addr_cstr = addr_vec.as_slice().as_ptr() as *const i8;
|
|
let mut addr = mem::uninitialized();
|
|
::socket::inet_aton(addr_cstr, &mut addr);
|
|
HOST_ADDR_LIST = [addr.s_addr.as_mut_ptr() as *const c_char, null()];
|
|
HOST_ADDR = Some(addr);
|
|
|
|
let mut host_name = iter.next().unwrap().as_bytes().to_vec();
|
|
host_name.push(b'\0');
|
|
|
|
let mut host_aliases: Vec<Vec<u8>> = Vec::new();
|
|
|
|
loop {
|
|
let mut alias = match iter.next() {
|
|
Some(s) => s.as_bytes().to_vec(),
|
|
None => break
|
|
};
|
|
alias.push(b'\0');
|
|
host_aliases.push(alias);
|
|
}
|
|
|
|
//push a 0 so c doesn't segfault when it tries to read the next entry
|
|
host_aliases.push(vec![b'\0']);
|
|
|
|
HOST_ENTRY = hostent {
|
|
h_name: host_name.as_ptr() as *const c_char,
|
|
h_aliases: host_aliases.as_slice().as_ptr() as *const *const i8,
|
|
h_addrtype: ::socket::AF_INET,
|
|
h_length: 4,
|
|
h_addr_list: HOST_ADDR_LIST.as_ptr()
|
|
};
|
|
HOST_ALIASES = Some(host_aliases);
|
|
HOST_NAME = Some(host_name);
|
|
&HOST_ENTRY as *const hostent
|
|
});
|
|
|
|
/*
|
|
*libc_fn!(getnetbyaddr(net: libc::uint32_t, net_type: libc::c_int) -> Result<*const netent> {
|
|
* if NETDB == 0 {
|
|
* NETDB = syscall::open("/etc/networks", syscall::O_RDONLY).unwrap();
|
|
* }
|
|
*});
|
|
*
|
|
*libc_fn!(getnetbyname(name: *const libc::c_char) -> Result<*const netent> {
|
|
* if NETDB == 0 {
|
|
* NETDB = syscall::open("/etc/networks", syscall::O_RDONLY).unwrap();
|
|
* }
|
|
*});
|
|
*
|
|
*/
|
|
|
|
|
|
/*
|
|
*libc_fn!(getnetent() -> Result<*const netent> {
|
|
* if NETDB == 0 {
|
|
* NETDB = syscall::open("/etc/networks", syscall::O_RDONLY).unwrap();
|
|
* }
|
|
*
|
|
*});
|
|
*/
|
|
|
|
libc_fn!(unsafe getprotobyname(name: *const libc::c_char) -> Result<*const protoent> {
|
|
setprotoent(0);
|
|
let mut p: *const protoent;
|
|
while {p=getprotoent();
|
|
p!=null()} {
|
|
if libc::strcmp((*p).p_name, name) == 0 {
|
|
return Ok(p);
|
|
}
|
|
loop {
|
|
let mut cp = (*p).p_aliases;
|
|
if cp == null() {
|
|
break;
|
|
}
|
|
if libc::strcmp(*cp, name) == 0 {
|
|
return Ok(p);
|
|
}
|
|
cp = cp.offset(1);
|
|
}
|
|
}
|
|
endprotoent();
|
|
Err(Error::new(syscall::ENOENT))
|
|
});
|
|
|
|
libc_fn!(unsafe getprotobynumber(number: libc::c_int) -> Result<*const protoent> {
|
|
setprotoent(0);
|
|
let mut p: *const protoent;
|
|
while {p=getprotoent();
|
|
p!=null()} {
|
|
if (*p).p_proto == number {
|
|
return Ok(p);
|
|
}
|
|
}
|
|
endprotoent();
|
|
Err(Error::new(syscall::ENOENT))
|
|
});
|
|
|
|
libc_fn!(unsafe getprotoent() -> *const protoent {
|
|
if PROTODB == 0 {
|
|
PROTODB = syscall::open("/etc/protocols", syscall::O_RDONLY).unwrap();
|
|
P_LINE = RawLineBuffer::new(PROTODB);
|
|
}
|
|
|
|
let mut r: Box<str> = Box::default();
|
|
while r.is_empty() || r.split_whitespace().next() == None || r.starts_with("#") {
|
|
r = match P_LINE.next() {
|
|
Some(Ok(s)) => s,
|
|
Some(Err(_)) => return null(),
|
|
None => return null(),
|
|
};
|
|
}
|
|
|
|
let mut iter: SplitWhitespace = r.split_whitespace();
|
|
let mut proto_name: Vec<u8> = iter.next().unwrap().as_bytes().to_vec();
|
|
proto_name.push(b'\0');
|
|
|
|
let mut num = iter.next().unwrap().as_bytes().to_vec();
|
|
num.push(b'\0');
|
|
PROTO_NUM = Some(libc::atoi(num.as_slice().as_ptr() as *mut i8));
|
|
|
|
let mut proto_aliases: Vec<Vec<u8>> = Vec::new();
|
|
loop {
|
|
let mut alias = match iter.next() {
|
|
Some(s) => s.as_bytes().to_vec(),
|
|
None => break
|
|
};
|
|
alias.push(b'\0');
|
|
proto_aliases.push(alias);
|
|
}
|
|
//push a 0 so c doesn't segfault when it tries to read the next entry
|
|
proto_aliases.push(vec![b'\0']);
|
|
|
|
PROTO_ENTRY = protoent {
|
|
p_name: proto_name.as_slice().as_ptr() as *const c_char,
|
|
p_aliases: proto_aliases.iter().map(|x| x.as_ptr() as *const i8).collect::<Vec<*const i8>>().as_ptr(),
|
|
p_proto: PROTO_NUM.unwrap()
|
|
};
|
|
PROTO_ALIASES = Some(proto_aliases);
|
|
PROTO_NAME = Some(proto_name);
|
|
&PROTO_ENTRY as *const protoent
|
|
});
|
|
|
|
libc_fn!(unsafe getservbyname(name: *const libc::c_char, proto: *const libc::c_char) -> Result<*const servent> {
|
|
setservent(0);
|
|
let mut p: *const servent;
|
|
while {p=getservent();
|
|
p!=null()} {
|
|
if libc::strcmp((*p).s_name, name) == 0 && libc::strcmp((*p).s_proto, proto) == 0 {
|
|
return Ok(p);
|
|
}
|
|
loop {
|
|
let mut cp = (*p).s_aliases;
|
|
if cp == null() {
|
|
break;
|
|
}
|
|
if libc::strcmp(*cp, name) == 0 && libc::strcmp((*p).s_proto, proto) == 0 {
|
|
return Ok(p);
|
|
}
|
|
cp = cp.offset(1);
|
|
}
|
|
}
|
|
Err(Error::new(syscall::ENOENT))
|
|
});
|
|
|
|
libc_fn!(unsafe getservbyport(port: libc::c_int, proto: *const libc::c_char) -> Result<*const servent> {
|
|
setprotoent(0);
|
|
let mut p: *const servent;
|
|
while {p=getservent();
|
|
p!=null()} {
|
|
if (*p).s_port == port && libc::strcmp((*p).s_proto, proto) == 0 {
|
|
return Ok(p);
|
|
}
|
|
}
|
|
endprotoent();
|
|
Err(Error::new(syscall::ENOENT))
|
|
|
|
});
|
|
|
|
libc_fn!(unsafe getservent() -> *const servent {
|
|
if SERVDB == 0 {
|
|
SERVDB = syscall::open("/etc/services", syscall::O_RDONLY).unwrap();
|
|
S_LINE = RawLineBuffer::new(SERVDB);
|
|
}
|
|
|
|
let mut r: Box<str> = Box::default();
|
|
while r.is_empty() || r.split_whitespace().next() == None || r.starts_with("#") {
|
|
r = match S_LINE.next() {
|
|
Some(Ok(s)) => s,
|
|
Some(Err(_)) => return null(),
|
|
None => return null(),
|
|
};
|
|
}
|
|
let mut iter: SplitWhitespace = r.split_whitespace();
|
|
|
|
let mut serv_name: Vec<u8> = iter.next().unwrap().as_bytes().to_vec();
|
|
serv_name.push(b'\0');
|
|
|
|
let port_proto = iter.next().unwrap();
|
|
let mut split = port_proto.split("/");
|
|
let port = libc::atoi(split.next().unwrap().as_ptr() as *const i8);
|
|
SERV_PORT = Some(port);
|
|
let proto = split.next().unwrap().as_bytes().to_vec();
|
|
|
|
let mut serv_aliases: Vec<Vec<u8>> = Vec::new();
|
|
loop {
|
|
let mut alias = match iter.next() {
|
|
Some(s) => s.as_bytes().to_vec(),
|
|
None => break
|
|
};
|
|
alias.push(b'\0');
|
|
serv_aliases.push(alias);
|
|
}
|
|
//push a 0 so c doesn't segfault when it tries to read the next entry
|
|
serv_aliases.push(vec![b'\0']);
|
|
|
|
SERV_ENTRY = servent {
|
|
s_name: serv_name.as_slice().as_ptr() as *const c_char,
|
|
s_aliases: serv_aliases.iter().map(|x| x.as_ptr() as *const i8).collect::<Vec<*const i8>>().as_ptr(),
|
|
s_port: SERV_PORT.unwrap(),
|
|
s_proto: proto.as_slice().as_ptr() as *const c_char
|
|
};
|
|
|
|
SERV_ALIASES = Some(serv_aliases);
|
|
SERV_NAME = Some(serv_name);
|
|
SERV_PROTO = Some(proto);
|
|
&SERV_ENTRY as *const servent
|
|
|
|
});
|
|
|
|
libc_fn!(unsafe sethostent(stayopen: libc::c_int) {
|
|
if HOSTDB == 0 {
|
|
HOSTDB = syscall::open("/etc/hosts", syscall::O_RDONLY).unwrap();
|
|
} else {
|
|
let _ = syscall::lseek(HOSTDB, 0, syscall::SEEK_SET);
|
|
}
|
|
H_LINE = RawLineBuffer::new(HOSTDB);
|
|
});
|
|
|
|
/*
|
|
*libc_fn!(unsafe setnetent(stayopen: libc::c_int) {
|
|
* if NETDB == 0 {
|
|
* NETDB = syscall::open("/etc/networks", syscall::O_RDONLY).unwrap();
|
|
* } else {
|
|
* let _ = syscall::lseek(NETDB, 0, syscall::SEEK_SET);
|
|
* }
|
|
*});
|
|
*/
|
|
|
|
libc_fn!(unsafe setprotoent(stayopen: libc::c_int) {
|
|
if PROTODB == 0 {
|
|
PROTODB = syscall::open("/etc/protocols", syscall::O_RDONLY).unwrap();
|
|
} else {
|
|
let _ = syscall::lseek(PROTODB, 0, syscall::SEEK_SET);
|
|
}
|
|
P_LINE = RawLineBuffer::new(PROTODB);
|
|
});
|
|
|
|
libc_fn!(unsafe setservent(stayopen: libc::c_int) {
|
|
if SERVDB == 0 {
|
|
SERVDB = syscall::open("/etc/services", syscall::O_RDONLY).unwrap();
|
|
} else {
|
|
let _ = syscall::lseek(SERVDB, 0, syscall::SEEK_SET);
|
|
}
|
|
S_LINE = RawLineBuffer::new(SERVDB);
|
|
});
|
|
|
|
//libc_fn!(getaddrinfo(node: *const libc::c_char, service: *const libc::c_char, hints: *const addrinfo, res: *mut *mut addrinfo) -> libc::c_int {
|
|
|
|
//});
|
|
|
|
//libc_fn!(getnameinfo(addr: *const sockaddr, addrlen: socklen_t, host: *mut libc::c_char, hostlen: socklen_t, serv: *mut libc::c_char, servlen: socklen_t, flags: libc::c_int) -> libc::c_int {
|
|
|
|
//});
|
|
|
|
//libc_fn!(freeaddrinfo(res: *mut addrinfo) {
|
|
|
|
//});
|
|
|
|
//libc_fn!(gai_strerror(errcode: libc::c_int) -> *const libc::c_char {
|
|
|
|
//});
|