things

src/lib.rs

@@ -1,10 +1,96 @@
 #![warn(rust_2018_idioms)]
 
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn it_works() {
-        let result = 2 + 2;
-        assert_eq!(result, 4);
+/*
+#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.
 }