Add setsockopt (#320)

* Add setsockopt

* Add tests for SetSockOpt opcode

Author: ThomasHabets

io-uring-test/src/tests/net.rs

@@ -1494,11 +1494,64 @@ pub fn test_socket<S: squeue::EntryMarker, C: cqueue::EntryMarker>(
     assert_eq!(cqes.len(), 1);
     assert_eq!(cqes[0].user_data(), 42);
     assert!(cqes[0].result() >= 0);
-    assert!(cqes[0].result() != plain_fd);
+    let io_uring_socket = unsafe { Socket::from_raw_fd(cqes[0].result()) };
+    assert!(io_uring_socket.as_raw_fd() != plain_fd);
     assert_eq!(cqes[0].flags(), 0);
 
+    // Try a setsockopt.
+    {
+        let mut optval: libc::c_int = 0;
+        let mut optval_size: libc::socklen_t = std::mem::size_of_val(&optval) as libc::socklen_t;
+        // Get value before.
+        let ret = unsafe {
+            libc::getsockopt(
+                io_uring_socket.as_raw_fd(),
+                libc::SOL_SOCKET,
+                libc::SO_REUSEADDR,
+                &mut optval as *mut _ as *mut libc::c_void,
+                &mut optval_size as *mut _ as *mut libc::socklen_t,
+            )
+        };
+        assert_eq!(ret, 0);
+        assert_eq!(optval, 0);
+
+        // Set value.
+        optval = 1;
+        let op = io_uring::opcode::SetSockOpt::new(
+            io_uring::types::Fd(io_uring_socket.as_raw_fd()),
+            libc::SOL_SOCKET as u32,
+            libc::SO_REUSEADDR as u32,
+            &optval as *const _ as *const libc::c_void,
+            std::mem::size_of_val(&optval) as libc::socklen_t,
+        )
+        .build()
+        .user_data(1234);
+        unsafe {
+            ring.submission().push(&op.into()).expect("queue is full");
+        }
+        ring.submit_and_wait(1)?;
+        let cqes: Vec<cqueue::Entry> = ring.completion().map(Into::into).collect();
+        assert_eq!(cqes.len(), 1);
+        assert_eq!(cqes[0].user_data(), 1234);
+        assert_eq!(cqes[0].result(), 0);
+        assert_eq!(cqes[0].flags(), 0);
+
+        // Check value actually set.
+        optval = 0;
+        let ret = unsafe {
+            libc::getsockopt(
+                io_uring_socket.as_raw_fd(),
+                libc::SOL_SOCKET,
+                libc::SO_REUSEADDR,
+                &mut optval as *mut _ as *mut libc::c_void,
+                &mut optval_size as *mut _ as *mut libc::socklen_t,
+            )
+        };
+        assert_eq!(ret, 0);
+        assert_eq!(optval, 1);
+    }
+
     // Close both sockets, to avoid leaking FDs.
-    let io_uring_socket = unsafe { Socket::from_raw_fd(cqes[0].result()) };
     drop(plain_socket);
     drop(io_uring_socket);
 

src/opcode.rs

@@ -641,6 +641,36 @@ opcode! {
     }
 }
 
+opcode! {
+    /// Set a socket option.
+    pub struct SetSockOpt {
+        fd: { impl sealed::UseFixed },
+        level: { u32 },
+        optname: { u32 },
+        optval: { *const libc::c_void },
+        optlen: { u32 },
+        ;;
+        flags: u32 = 0
+    }
+
+    pub const CODE = sys::IORING_OP_URING_CMD;
+
+    pub fn build(self) -> Entry {
+        let SetSockOpt { fd, level, optname, optval, optlen, flags } = self;
+        let mut sqe = sqe_zeroed();
+        sqe.opcode = Self::CODE;
+        assign_fd!(sqe.fd = fd);
+        sqe.__bindgen_anon_1.__bindgen_anon_1.cmd_op = sys::SOCKET_URING_OP_SETSOCKOPT;
+
+        sqe.__bindgen_anon_2.__bindgen_anon_1.level = level;
+        sqe.__bindgen_anon_2.__bindgen_anon_1.optname = optname;
+        sqe.__bindgen_anon_3.uring_cmd_flags = flags;
+        sqe.__bindgen_anon_5.optlen = optlen;
+        unsafe { *sqe.__bindgen_anon_6.optval.as_mut() = optval as u64 };
+        Entry(sqe)
+    }
+}
+
 opcode! {
     /// Attempt to cancel an already issued request.
     pub struct AsyncCancel {