View difference between Paste ID: 22LMVCbZ and qtDLyDDJ

 extern crate libc;
 
 use std::io::prelude::*;
 use std::net::{TcpStream, TcpListener, UdpSocket};
 use std::{io, mem, ptr, time};
 use std::os::unix::io::{AsRawFd, RawFd};
 use std::thread;
 
 use nix::unistd::{fork, ForkResult};
 
 pub struct FdSet(libc::fd_set);
 
 impl FdSet {
     pub fn new() -> FdSet {
         unsafe {
             let mut raw_fd_set = mem::MaybeUninit::<libc::fd_set>::uninit();
             libc::FD_ZERO(raw_fd_set.as_mut_ptr());
             FdSet(raw_fd_set.assume_init())
         }
     }
     pub fn clear(&mut self, fd: RawFd) {
         unsafe { libc::FD_CLR(fd, &mut self.0) }
     }
     pub fn set(&mut self, fd: RawFd) {
         unsafe { libc::FD_SET(fd, &mut self.0) }
     }
     pub fn is_set(&mut self, fd: RawFd) -> bool {
         unsafe { libc::FD_ISSET(fd, &mut self.0) }
     }
 }
 
 fn to_fdset_ptr(opt: Option<&mut FdSet>) -> *mut libc::fd_set {
     match opt {
         None => ptr::null_mut(),
         Some(&mut FdSet(ref mut raw_fd_set)) => raw_fd_set,
     }
 }
 
 fn to_ptr<T>(opt: Option<&T>) -> *const T {
     match opt {
         None => ptr::null::<T>(),
         Some(p) => p,
     }
 }
 
 pub fn make_timeval(duration: time::Duration) -> libc::timeval {
     libc::timeval {
         tv_sec: duration.as_secs() as i64,
         tv_usec: duration.subsec_micros() as i64,
     }
 }
 
 pub fn select(
     nfds: libc::c_int,
     readfds: Option<&mut FdSet>,
     writefds: Option<&mut FdSet>,
     errorfds: Option<&mut FdSet>,
     timeout: Option<&libc::timeval>,
 ) -> io::Result<usize> {
     match unsafe {
         libc::select(
             nfds,
             to_fdset_ptr(readfds),
             to_fdset_ptr(writefds),
             to_fdset_ptr(errorfds),
             to_ptr::<libc::timeval>(timeout) as *mut libc::timeval,
         )
     } {
         -1 => Err(io::Error::last_os_error()),
         res => Ok(res as usize),
     }
 }
 
 pub fn main(){
     let mut msg: [u8; 128] = [0; 128];
 
     #[allow(unused_unsafe)]
     match unsafe{fork()} {
         Ok(ForkResult::Parent { child, .. }) => {
             println!("Waiting for a while on the parent process so that listener can start on child process with pid: {}!", child);
             thread::sleep(time::Duration::from_secs(10));
             println!("Trying to connect to listener in parent. \n");
             let mut tcp_stream = TcpStream::connect("127.0.0.1:8080").expect("Error connecting to listener!");
 
             let udp_socket = UdpSocket::bind("127.0.0.1:8080").expect("Failed creating a client side udp socket.");
             udp_socket.connect("127.0.0.1:8081").expect("Udp connection failure");
 
             let rfd1 = tcp_stream.as_raw_fd();
             let rfd2 = udp_socket.as_raw_fd();
 
             println!("TCP Socket: {}", rfd1);
             println!("UDP Socket: {}", rfd2);
 
             let max_fd = rfd1.max(rfd2);
 
             let mut fd_set = FdSet::new();
             fd_set.set(rfd1);
             fd_set.set(rfd2);
             match select(
                 max_fd + 1,
                 Some(&mut fd_set),                               // read
                 None,                                            // write
                 None,                                            // error
                 Some(&make_timeval(time::Duration::new(10, 0))), // timeout
             ) {
                 Ok(res) => {
                     println!("Select result: {}", res);
 
                     if (fd_set).is_set(rfd1) {
                         println!("TCP socket recieved something!");
                         let bytes = tcp_stream.read(&mut msg).expect("Failed to recieve message from listener!").expect("Error reading message");
                         println!("TCP Socket Recieved: {}", String::from_utf8_lossy(&msg[..bytes]));
                     }
                     if (fd_set).is_set(rfd2) {
                         println!("UDP socket recieved something!");
                         let bytes = udp_socket.recv(&mut msg).expect("Error reading message");
                         println!("UDP Socket Recieved: {}", String::from_utf8_lossy(&msg[..bytes]));
                     }
                 }
                 Err(err) => {
                     println!("Failed to select: {:?}", err);
                 }
             }
         }
         Ok(ForkResult::Child) => {
             println!("Starting listener in child process");
 
             let tcp_listener = TcpListener::bind("127.0.0.1:8080").expect("Error starting a TCP listener!");
             println!("TCP Listener started in child process.\n");
 
             let socket = UdpSocket::bind("127.0.0.1:8081").expect("Error starting a UDP socket");
             println!("UDP socket started in child process.\n");
 
             socket.connect("127.0.0.1:8080").expect("Connect to socket failed.");
             socket.send("Hello socket!".as_bytes()).expect("data broadcast on udp failed");
 
             println!("Listening for tcp connections");
             let mut stream = tcp_listener.incoming().next().expect("Failed to find a peer").expect("Failed to connect to reciever");
             stream.write("hello world!".as_bytes()).expect("Failed to respond");
 
         }
         Err(_) => println!("Fork failed"),
     }
 }