Use size_t for parameter and return value of CMSG_{LEN,SPACE}

Fixes: #3240

Matches all platforms except Solaris and its descendants. `size_t` is
used there regardless in order to force excessive conversions, and to
make cross-platform code easier to write.

[illumos]: https://github.com/illumos/illumos-gate/blob/118b2dbf1f4a745a7e35a5054a777c09bd90fff7/usr/src/uts/common/sys/socket.h#L499-L505

Author: gibbz00

libc-test/tests/cmsg.rs

@@ -7,17 +7,17 @@ mod t {
 
     use libc::{
         c_uchar,
-        c_uint,
         c_void,
         cmsghdr,
         msghdr,
+        size_t,
     };
 
     extern "C" {
         pub fn cmsg_firsthdr(msgh: *const msghdr) -> *mut cmsghdr;
         pub fn cmsg_nxthdr(mhdr: *const msghdr, cmsg: *const cmsghdr) -> *mut cmsghdr;
-        pub fn cmsg_space(length: c_uint) -> usize;
-        pub fn cmsg_len(length: c_uint) -> usize;
+        pub fn cmsg_space(length: size_t) -> size_t;
+        pub fn cmsg_len(length: size_t) -> size_t;
         pub fn cmsg_data(cmsg: *const cmsghdr) -> *mut c_uchar;
     }
 
@@ -47,8 +47,8 @@ mod t {
 
     #[test]
     fn test_cmsg_len() {
-        for l in 0..128 {
-            assert_eq!(libc::CMSG_LEN(l) as usize, unsafe { cmsg_len(l) });
+        for l in 0..128usize {
+            assert_eq!(libc::CMSG_LEN(l), unsafe { cmsg_len(l) });
         }
     }
 
@@ -75,8 +75,7 @@ mod t {
 
                 while !current_cmsghdr_ptr.is_null() {
                     unsafe {
-                        (*current_cmsghdr_ptr).cmsg_len =
-                            libc::CMSG_LEN(cmsg_payload_len as _) as _;
+                        (*current_cmsghdr_ptr).cmsg_len = libc::CMSG_LEN(cmsg_payload_len) as _;
 
                         let libc_next = libc::CMSG_NXTHDR(&mhdr, current_cmsghdr_ptr);
                         let system_next = cmsg_nxthdr(&mhdr, current_cmsghdr_ptr);
@@ -101,7 +100,7 @@ mod t {
     #[test]
     fn test_cmsg_space() {
         for l in 0..128 {
-            assert_eq!(libc::CMSG_SPACE(l) as usize, unsafe { cmsg_space(l) });
+            assert_eq!(libc::CMSG_SPACE(l), unsafe { cmsg_space(l) });
         }
     }
 }

src/new/common/posix/sys/socket.rs

@@ -23,21 +23,15 @@ pub(crate) const fn align_impl(len: usize, align: usize) -> usize {
     (len + mask) & !mask
 }
 
-// TODO(#3240): consider changing signatures to `CMSG_{SPACE,LEN}(length: size_t) -> size_`
-
 /// Total length of a non-padded control message for a payload of size `length`.
 ///
 /// This function is almost exclusively used setting [`cmsghdr::cmsg_len`].
 /// It should *not* be used for determining the actual ancillary data buffer
 /// size. [`CMSG_SPACE`] should instead be for that.
 #[cfg(not(any(target_os = "illumos", target_os = "solaris")))]
-pub const fn CMSG_LEN(length: c_uint) -> c_uint {
-    let length = length as size_t;
-
+pub const fn CMSG_LEN(length: size_t) -> size_t {
     // See `CMSG_SPACE` impl about this sometimes being a no-op.
-    let len = CMSG_ALIGN(size_of::<cmsghdr>()) + length;
-
-    len as c_uint
+    CMSG_ALIGN(size_of::<cmsghdr>()) + length
 }
 
 /// Total length of a padded control message for a payload of size `length`.
@@ -46,16 +40,12 @@ pub const fn CMSG_LEN(length: c_uint) -> c_uint {
 /// It should should *not* be used to initialize [cmsghdr::cmsg_len], given
 /// that the returned value includes padding bytes. Use instead [`CMSG_LEN`]
 /// for that.
-pub const fn CMSG_SPACE(length: c_uint) -> c_uint {
-    let length = length as size_t;
-
+pub const fn CMSG_SPACE(length: size_t) -> size_t {
     // NB: left hand side `align` is no-op when `size_of::<cmsghdr>() %
     // size_of::<__ALIGN_BOUNDARY>() == 0`. Such is the case on Linux, and
     // probably why some implementations there don't bother with the lhs
     // align.
-    let space = CMSG_ALIGN(size_of::<cmsghdr>()) + CMSG_ALIGN(length);
-
-    space as c_uint
+    CMSG_ALIGN(size_of::<cmsghdr>()) + CMSG_ALIGN(length)
 }
 
 /// Returns a pointer to the payload data array associated with for the provided header.

src/new/common/solarish.rs

@@ -12,8 +12,8 @@ pub(crate) mod sys {
             crate::new::common::posix::sys::socket::align_impl(p, size_of::<c_int>())
         }
 
-        pub const fn CMSG_LEN(length: c_uint) -> c_uint {
-            _CMSG_DATA_ALIGN(size_of::<cmsghdr>()) as c_uint + length
+        pub const fn CMSG_LEN(length: size_t) -> size_t {
+            _CMSG_DATA_ALIGN(size_of::<cmsghdr>()) + length
         }
 
         pub unsafe fn CMSG_DATA(cmsg: *const cmsghdr) -> *mut c_uchar {

tests/const_fn.rs

@@ -1,3 +1,3 @@
 #[cfg(target_os = "linux")]
-const _FOO: libc::c_uint = libc::CMSG_SPACE(1);
+const _FOO: libc::size_t = libc::CMSG_SPACE(1);
 //^ if CMSG_SPACE is not const, this will fail to compile