Changeset - 3a0142804667
[Not reviewed]
0 1 0
MH - 3 years ago 2022-04-01 17:11:42
contact@maxhenger.nl
WIP on nonblocking before implementing epoll
1 file changed with 94 insertions and 7 deletions:
0 comments (0 inline, 0 general)
src/runtime2/stdlib/internet.rs
Show inline comments
 
@@ -10,6 +10,7 @@ use libc::{
 
#[derive(Debug)]
 
pub enum SocketError {
 
    Opening,
 
    Modifying,
 
    Binding,
 
    Listening,
 
    Connecting,
 
@@ -24,17 +25,25 @@ enum SocketState {
 

	
 
/// TCP connection
 
pub struct SocketTcpClient {
 
    socket_handle: libc::c_int
 
    socket_handle: libc::c_int,
 
    is_blocking: bool,
 
}
 

	
 
impl SocketTcpClient {
 
    pub fn new(ip: IpAddr, port: u16) -> Result<Self, SocketError> {
 
        const BLOCKING: bool = false;
 

	
 
        let socket_handle = create_and_connect_socket(
 
            libc::SOCK_STREAM, libc::IPPROTO_TCP, ip, port
 
        )?;
 
        if !set_socket_blocking(socket_handle, BLOCKING) {
 
            unsafe{ libc::close(socket_handle); }
 
            return Err(SocketError::Modifying);
 
        }
 

	
 
        return Ok(SocketTcpClient{
 
            socket_handle,
 
            is_blocking: BLOCKING,
 
        })
 
    }
 

	
 
@@ -50,17 +59,59 @@ impl SocketTcpClient {
 
        return Ok(result as usize);
 
    }
 

	
 
    /// Receives data from the TCP socket. Returns the number of bytes received.
 
    /// More bytes may be present even thought `used < buffer.len()`.
 
    pub fn receive(&self, buffer: &mut [u8]) -> Result<usize, ()> {
 
        if self.is_blocking {
 
            return self.receive_blocking(buffer);
 
        } else {
 
            return self.receive_nonblocking(buffer);
 
        }
 
    }
 

	
 
    #[inline]
 
    fn receive_blocking(&self, buffer: &mut [u8]) -> Result<usize, ()> {
 
        let result = unsafe {
 
            let message_pointer = buffer.as_mut_ptr().cast();
 
            libc::recv(self.socket_handle, message_pointer, buffer.len() as libc::size_t, 0)
 
            libc::recv(self.socket_handle, message_pointer, buffer.len(), 0)
 
        };
 
        if result < 0 {
 
            return Err(())
 
            return Err(());
 
        }
 

	
 
        return Ok(result as usize);
 
    }
 

	
 
    #[inline]
 
    fn receive_nonblocking(&self, buffer: &mut [u8]) -> Result<usize, ()> {
 
        unsafe {
 
            let mut message_pointer = buffer.as_mut_ptr().cast();
 
            let mut remaining = buffer.len();
 

	
 
            loop {
 
                // Receive more data
 
                let result = libc::recv(self.socket_handle, message_pointer, remaining, 0);
 
                if result < 0 {
 
                    // Check reason
 
                    let errno = std::io::Error::last_os_error().raw_os_error().expect("os error after failed recv");
 
                    if errno == libc::EWOULDBLOCK || errno == libc::EAGAIN {
 
                        return Ok(buffer.len() - remaining);
 
                    } else {
 
                        return Err(());
 
                    }
 
                }
 

	
 
                // Modify pointer and remaining bytes
 
                let received = result as usize;
 
                message_pointer = message_pointer.add(received);
 
                remaining -= received;
 

	
 
                if remaining == 0 {
 
                    return Ok(buffer.len());
 
                }
 
            }
 
        }
 
    }
 
}
 

	
 
impl Drop for SocketTcpClient {
 
@@ -248,6 +299,33 @@ fn create_sockaddr_in_v6(ip: Ipv6Addr, port: u16) -> (sockaddr_in6, libc::sockle
 
    return (socket_address, address_size as _);
 
}
 

	
 
#[inline]
 
fn set_socket_blocking(handle: libc::c_int, blocking: bool) -> bool {
 
    if handle < 0 {
 
        return false;
 
    }
 

	
 
    unsafe{
 
        let mut flags = libc::fcntl(handle, libc::F_GETFL, 0);
 
        if flags < 0 {
 
            return false;
 
        }
 

	
 
        if blocking {
 
            flags &= !libc::O_NONBLOCK;
 
        } else {
 
            flags |= libc::O_NONBLOCK;
 
        }
 

	
 
        let result = libc::fcntl(handle, libc::F_SETFL, flags);
 
        if result < 0 {
 
            return false;
 
        }
 
    }
 

	
 
    return true;
 
}
 

	
 
#[inline]
 
fn socket_family_from_ip(ip: IpAddr) -> libc::c_int {
 
    return match ip {
 
@@ -267,11 +345,20 @@ mod tests {
 

	
 
    #[test]
 
    fn test_inet_thingo() {
 
        const SIZE: usize = 1024;
 

	
 
        let s = SocketTcpClient::new(IpAddr::V4(Ipv4Addr::new(142, 250, 179, 163)), 80).expect("connect");
 
        s.send(b"GET / HTTP/1.1\r\n\r\n").expect("sending");
 
        let mut buffer = [0;65000];
 
        s.receive(&mut buffer).expect("receiving");
 
        let as_str = String::from_utf8_lossy(&buffer);
 
        println!("Yay! Got:\n{}", as_str);
 
        let mut total = Vec::<u8>::new();
 
        let mut buffer = [0; SIZE];
 
        let mut received = SIZE;
 

	
 
        while received > 0 {
 
            received = s.receive(&mut buffer).expect("receiving");
 
            println!("DEBUG: Received {} bytes", received);
 
            total.extend_from_slice(&buffer[..received]);
 
        }
 
        let as_str = String::from_utf8_lossy(total.as_slice());
 
        println!("Yay! Got {} bytes:\n{}", as_str.len(), as_str);
 
    }
 
}
 
\ No newline at end of file
0 comments (0 inline, 0 general)