survey/src/lib.rs

#![warn(rust_2018_idioms)]

/*
#define MAX_EVENTS 10
           struct epoll_event ev, events[MAX_EVENTS];
           int listen_sock, conn_sock, nfds, epollfd;

           /* Code to set up listening socket, 'listen_sock',
              (socket(), bind(), listen()) omitted */

           epollfd = epoll_create1(0);
           if (epollfd == -1) {
               perror("epoll_create1");
               exit(EXIT_FAILURE);
           }

           ev.events = EPOLLIN;
           ev.data.fd = listen_sock;
           if (epoll_ctl(epollfd, EPOLL_CTL_ADD, listen_sock, &ev) == -1) {
               perror("epoll_ctl: listen_sock");
               exit(EXIT_FAILURE);
           }

           for (;;) {
               nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
               if (nfds == -1) {
                   perror("epoll_wait");
                   exit(EXIT_FAILURE);
               }

               for (n = 0; n < nfds; ++n) {
                   if (events[n].data.fd == listen_sock) {
                       conn_sock = accept(listen_sock,
                                          (struct sockaddr *) &addr, &addrlen);
                       if (conn_sock == -1) {
                           perror("accept");
                           exit(EXIT_FAILURE);
                       }
                       setnonblocking(conn_sock);
                       ev.events = EPOLLIN | EPOLLET;
                       ev.data.fd = conn_sock;
                       if (epoll_ctl(epollfd, EPOLL_CTL_ADD, conn_sock,
                                   &ev) == -1) {
                           perror("epoll_ctl: conn_sock");
                           exit(EXIT_FAILURE);
                       }
                   } else {
                       do_use_fd(events[n].data.fd);
                   }
               }
           }
 */

const MAX_EVENTS: usize = 10;

pub fn example_from_man_page() -> Result<(), &'static str> {
    // SAFETY: I trust man pages (maybe a mistake)
    unsafe {
        let listen_sock: i32 = todo!();
        let mut events = [libc::epoll_event { events: 0, u64: 0 }; MAX_EVENTS]; // empty value

        let epollfd = libc::epoll_create1(1);
        if epollfd == -1 {
            return Err("Failed to crate epoll instance");
        }

        let ev = libc::epoll_event {
            events: libc::EPOLLIN.try_into().unwrap(),
            u64: listen_sock.try_into().unwrap(),
        };

        loop {
            let nfds = libc::epoll_wait(
                epollfd,
                events.as_mut_ptr(),
                MAX_EVENTS.try_into().unwrap(),
                -1,
            );
            if nfds == -1 {
                return Err("Failed to wait for next event");
            }

            for i in 0usize..nfds.try_into().unwrap() {
                if events[i].u64 == listen_sock.try_into().unwrap() {
                    let conn_sock = libc::accept(listen_sock, todo!(), todo!());
                    if conn_sock != -1 {
                        return Err("Failed to accept");
                    }
                    todo!()
                }
            }
        }
    }

    Ok(()) // this is safe.
}