chore: apply some clippy lints

nyurik · nyurik · commit f092873ffedb · 2025-04-15T00:46:20.000-04:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -143,17 +143,16 @@ members = [
     "libc-test",
 ]
 
-#
-# TODO: These should be renamed as `[workspace.lints.*]` once MSRV is abve 1.64
+# FIXME(msrv): These should be renamed as `[workspace.lints.*]` once MSRV is above 1.64
 #       This way all crates can use it with `[lints] workspace=true` section
-#
 
 [lints.rust]
-# TODO: make ident usage consistent in each file
+# FIXME(cleanup): make ident usage consistent in each file
 unused_qualifications = "allow"
 
 [lints.clippy]
-# TODO: enable pedantic lints with exceptions
-non_minimal_cfg = "allow"  # for some reason cfg_if! sometimes trigger this
 identity_op = "allow"  # some expressions like `0 | x` are clearer for bit ops
 missing_safety_doc = "allow"  # safety? in libc? seriously?
+
+# FIXME(clippy): all these should probably be fixed
+non_minimal_cfg = "allow"  # for some reason cfg_if! sometimes trigger this
diff --git a/src/fuchsia/mod.rs b/src/fuchsia/mod.rs
@@ -3429,9 +3429,9 @@ f! {
 
     pub fn CMSG_NXTHDR(mhdr: *const msghdr, cmsg: *const cmsghdr) -> *mut cmsghdr {
         if ((*cmsg).cmsg_len as size_t) < mem::size_of::<cmsghdr>() {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else if __CMSG_NEXT(cmsg).add(mem::size_of::<cmsghdr>()) >= __MHDR_END(mhdr) {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             __CMSG_NEXT(cmsg).cast()
         }
@@ -3441,7 +3441,7 @@ f! {
         if (*mhdr).msg_controllen as size_t >= mem::size_of::<cmsghdr>() {
             (*mhdr).msg_control.cast()
         } else {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         }
     }
 
diff --git a/src/unix/aix/mod.rs b/src/unix/aix/mod.rs
@@ -2441,7 +2441,7 @@ f! {
         if (*mhdr).msg_controllen as usize >= mem::size_of::<cmsghdr>() {
             (*mhdr).msg_control as *mut cmsghdr
         } else {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         }
     }
 
@@ -2452,7 +2452,7 @@ f! {
             if (cmsg as usize + (*cmsg).cmsg_len as usize + mem::size_of::<cmsghdr>())
                 > ((*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize)
             {
-                0 as *mut cmsghdr
+                core::ptr::null_mut::<cmsghdr>()
             } else {
                 // AIX does not have any alignment/padding for ancillary data, so we don't need _CMSG_ALIGN here.
                 (cmsg as usize + (*cmsg).cmsg_len as usize) as *mut cmsghdr
diff --git a/src/unix/bsd/freebsdlike/dragonfly/mod.rs b/src/unix/bsd/freebsdlike/dragonfly/mod.rs
@@ -1560,7 +1560,7 @@ f! {
         if next <= max {
             (cmsg as usize + _CMSG_ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr
         } else {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         }
     }
 
diff --git a/src/unix/bsd/freebsdlike/freebsd/mod.rs b/src/unix/bsd/freebsdlike/freebsd/mod.rs
@@ -4921,7 +4921,7 @@ f! {
             cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize) + _ALIGN(mem::size_of::<cmsghdr>());
         let max = (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize;
         if next > max {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             (cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr
         }
@@ -4952,30 +4952,28 @@ f! {
         __xuname(256, buf as *mut c_void)
     }
 
-    pub fn CPU_ZERO(cpuset: &mut cpuset_t) -> () {
+    pub fn CPU_ZERO(cpuset: &mut cpuset_t) {
         for slot in cpuset.__bits.iter_mut() {
             *slot = 0;
         }
     }
 
-    pub fn CPU_FILL(cpuset: &mut cpuset_t) -> () {
+    pub fn CPU_FILL(cpuset: &mut cpuset_t) {
         for slot in cpuset.__bits.iter_mut() {
             *slot = !0;
         }
     }
 
-    pub fn CPU_SET(cpu: usize, cpuset: &mut cpuset_t) -> () {
+    pub fn CPU_SET(cpu: usize, cpuset: &mut cpuset_t) {
         let bitset_bits = 8 * mem::size_of::<c_long>();
         let (idx, offset) = (cpu / bitset_bits, cpu % bitset_bits);
         cpuset.__bits[idx] |= 1 << offset;
-        ()
     }
 
-    pub fn CPU_CLR(cpu: usize, cpuset: &mut cpuset_t) -> () {
+    pub fn CPU_CLR(cpu: usize, cpuset: &mut cpuset_t) {
         let bitset_bits = 8 * mem::size_of::<c_long>();
         let (idx, offset) = (cpu / bitset_bits, cpu % bitset_bits);
         cpuset.__bits[idx] &= !(1 << offset);
-        ()
     }
 
     pub fn CPU_ISSET(cpu: usize, cpuset: &cpuset_t) -> bool {
diff --git a/src/unix/bsd/netbsdlike/netbsd/mod.rs b/src/unix/bsd/netbsdlike/netbsd/mod.rs
@@ -2438,7 +2438,7 @@ f! {
             cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize) + _ALIGN(mem::size_of::<cmsghdr>());
         let max = (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize;
         if next > max {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             (cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr
         }
diff --git a/src/unix/bsd/netbsdlike/openbsd/mod.rs b/src/unix/bsd/netbsdlike/openbsd/mod.rs
@@ -1940,7 +1940,7 @@ f! {
             cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize) + _ALIGN(mem::size_of::<cmsghdr>());
         let max = (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize;
         if next > max {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             (cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr
         }
diff --git a/src/unix/haiku/mod.rs b/src/unix/haiku/mod.rs
@@ -1570,7 +1570,7 @@ f! {
         if (*mhdr).msg_controllen as usize >= mem::size_of::<cmsghdr>() {
             (*mhdr).msg_control as *mut cmsghdr
         } else {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         }
     }
 
@@ -1595,7 +1595,7 @@ f! {
             + CMSG_ALIGN(mem::size_of::<cmsghdr>());
         let max = (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize;
         if next > max {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             (cmsg as usize + CMSG_ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr
         }
diff --git a/src/unix/hurd/mod.rs b/src/unix/hurd/mod.rs
@@ -3444,7 +3444,7 @@ f! {
         if (*mhdr).msg_controllen as usize >= mem::size_of::<cmsghdr>() {
             (*mhdr).msg_control as *mut cmsghdr
         } else {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         }
     }
 
@@ -3462,14 +3462,14 @@ f! {
 
     pub fn CMSG_NXTHDR(mhdr: *const msghdr, cmsg: *const cmsghdr) -> *mut cmsghdr {
         if ((*cmsg).cmsg_len as usize) < mem::size_of::<cmsghdr>() {
-            return 0 as *mut cmsghdr;
+            return core::ptr::null_mut::<cmsghdr>();
         };
         let next = (cmsg as usize + CMSG_ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr;
         let max = (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize;
         if (next.offset(1)) as usize > max
             || next as usize + CMSG_ALIGN((*next).cmsg_len as usize) > max
         {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             next as *mut cmsghdr
         }
diff --git a/src/unix/linux_like/android/mod.rs b/src/unix/linux_like/android/mod.rs
@@ -3611,7 +3611,7 @@ f! {
         let next = (cmsg as usize + super::CMSG_ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr;
         let max = (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize;
         if (next.offset(1)) as usize > max {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             next as *mut cmsghdr
         }
diff --git a/src/unix/linux_like/emscripten/mod.rs b/src/unix/linux_like/emscripten/mod.rs
@@ -1412,12 +1412,12 @@ pub const SOMAXCONN: c_int = 128;
 f! {
     pub fn CMSG_NXTHDR(mhdr: *const msghdr, cmsg: *const cmsghdr) -> *mut cmsghdr {
         if ((*cmsg).cmsg_len as usize) < mem::size_of::<cmsghdr>() {
-            return 0 as *mut cmsghdr;
+            return core::ptr::null_mut::<cmsghdr>();
         };
         let next = (cmsg as usize + super::CMSG_ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr;
         let max = (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize;
         if (next.offset(1)) as usize > max {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             next as *mut cmsghdr
         }
diff --git a/src/unix/nto/mod.rs b/src/unix/nto/mod.rs
@@ -2801,15 +2801,15 @@ f! {
         if (*mhdr).msg_controllen as usize >= mem::size_of::<cmsghdr>() {
             (*mhdr).msg_control as *mut cmsghdr
         } else {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         }
     }
 
     pub fn CMSG_NXTHDR(mhdr: *const crate::msghdr, cmsg: *const cmsghdr) -> *mut cmsghdr {
         let msg = _CMSG_ALIGN((*cmsg).cmsg_len as usize);
         let next = cmsg as usize + msg + _CMSG_ALIGN(mem::size_of::<cmsghdr>());
         if next > (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             (cmsg as usize + msg) as *mut cmsghdr
         }
diff --git a/src/unix/solarish/compat.rs b/src/unix/solarish/compat.rs
@@ -50,7 +50,7 @@ unsafe fn bail(fdm: c_int, fds: c_int) -> c_int {
         crate::close(fdm);
     }
     *___errno() = e;
-    return -1;
+    -1
 }
 
 #[cfg(target_os = "illumos")]
@@ -184,7 +184,7 @@ pub unsafe fn getpwent_r(
 ) -> c_int {
     let old_errno = *crate::___errno();
     *crate::___errno() = 0;
-    *result = native_getpwent_r(pwd, buf, min(buflen, c_int::max_value() as size_t) as c_int);
+    *result = native_getpwent_r(pwd, buf, min(buflen, c_int::MAX as size_t) as c_int);
 
     let ret = if (*result).is_null() {
         *crate::___errno()
@@ -204,7 +204,7 @@ pub unsafe fn getgrent_r(
 ) -> c_int {
     let old_errno = *crate::___errno();
     *crate::___errno() = 0;
-    *result = native_getgrent_r(grp, buf, min(buflen, c_int::max_value() as size_t) as c_int);
+    *result = native_getgrent_r(grp, buf, min(buflen, c_int::MAX as size_t) as c_int);
 
     let ret = if (*result).is_null() {
         *crate::___errno()
diff --git a/src/unix/solarish/mod.rs b/src/unix/solarish/mod.rs
@@ -2483,7 +2483,7 @@ f! {
 
     pub fn CMSG_FIRSTHDR(mhdr: *const crate::msghdr) -> *mut cmsghdr {
         if ((*mhdr).msg_controllen as usize) < size_of::<cmsghdr>() {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             (*mhdr).msg_control as *mut cmsghdr
         }
@@ -2497,14 +2497,14 @@ f! {
             _CMSG_HDR_ALIGN(cmsg as usize + (*cmsg).cmsg_len as usize + size_of::<cmsghdr>());
         let max = (*mhdr).msg_control as usize + (*mhdr).msg_controllen as usize;
         if next > max {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         } else {
             _CMSG_HDR_ALIGN(cmsg as usize + (*cmsg).cmsg_len as usize) as *mut cmsghdr
         }
     }
 
     pub {const} fn CMSG_SPACE(length: c_uint) -> c_uint {
-        _CMSG_HDR_ALIGN(size_of::<cmsghdr>() as usize + length as usize) as c_uint
+        _CMSG_HDR_ALIGN(size_of::<cmsghdr>() + length as usize) as c_uint
     }
 
     pub fn FD_CLR(fd: c_int, set: *mut fd_set) -> () {
diff --git a/src/vxworks/mod.rs b/src/vxworks/mod.rs
@@ -1139,15 +1139,15 @@ f! {
         if next <= max {
             (cmsg as usize + CMSG_ALIGN((*cmsg).cmsg_len as usize)) as *mut cmsghdr
         } else {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         }
     }
 
     pub fn CMSG_FIRSTHDR(mhdr: *const msghdr) -> *mut cmsghdr {
         if (*mhdr).msg_controllen as usize > 0 {
             (*mhdr).msg_control as *mut cmsghdr
         } else {
-            0 as *mut cmsghdr
+            core::ptr::null_mut::<cmsghdr>()
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -3429,9 +3429,9 @@ f! {`
`3429`	`3429`
`3430`	`3430`	`pub fn CMSG_NXTHDR(mhdr: const msghdr, cmsg: const cmsghdr) -> *mut cmsghdr {`
`3431`	`3431`	`if ((*cmsg).cmsg_len as size_t) < mem::size_of::<cmsghdr>() {`
`3432`		`- 0 as *mut cmsghdr`
	`3432`	`+ core::ptr::null_mut::<cmsghdr>()`
`3433`	`3433`	`} else if __CMSG_NEXT(cmsg).add(mem::size_of::<cmsghdr>()) >= __MHDR_END(mhdr) {`
`3434`		`- 0 as *mut cmsghdr`
	`3434`	`+ core::ptr::null_mut::<cmsghdr>()`
`3435`	`3435`	`} else {`
`3436`	`3436`	`__CMSG_NEXT(cmsg).cast()`
`3437`	`3437`	`}`
`@@ -3441,7 +3441,7 @@ f! {`
`3441`	`3441`	`if (*mhdr).msg_controllen as size_t >= mem::size_of::<cmsghdr>() {`
`3442`	`3442`	`(*mhdr).msg_control.cast()`
`3443`	`3443`	`} else {`
`3444`		`- 0 as *mut cmsghdr`
	`3444`	`+ core::ptr::null_mut::<cmsghdr>()`
`3445`	`3445`	`}`
`3446`	`3446`	`}`
`3447`	`3447`
Original file line number	Diff line number	Diff line change
`@@ -2441,7 +2441,7 @@ f! {`
`2441`	`2441`	`if (*mhdr).msg_controllen as usize >= mem::size_of::<cmsghdr>() {`
`2442`	`2442`	`(mhdr).msg_control as mut cmsghdr`
`2443`	`2443`	`} else {`
`2444`		`- 0 as *mut cmsghdr`
	`2444`	`+ core::ptr::null_mut::<cmsghdr>()`
`2445`	`2445`	`}`
`2446`	`2446`	`}`
`2447`	`2447`
`@@ -2452,7 +2452,7 @@ f! {`
`2452`	`2452`	`if (cmsg as usize + (*cmsg).cmsg_len as usize + mem::size_of::<cmsghdr>())`
`2453`	`2453`	`> ((mhdr).msg_control as usize + (mhdr).msg_controllen as usize)`
`2454`	`2454`	`{`
`2455`		`- 0 as *mut cmsghdr`
	`2455`	`+ core::ptr::null_mut::<cmsghdr>()`
`2456`	`2456`	`} else {`
`2457`	`2457`	`// AIX does not have any alignment/padding for ancillary data, so we don't need _CMSG_ALIGN here.`
`2458`	`2458`	`(cmsg as usize + (cmsg).cmsg_len as usize) as mut cmsghdr`
Original file line number	Diff line number	Diff line change
`@@ -1560,7 +1560,7 @@ f! {`
`1560`	`1560`	`if next <= max {`
`1561`	`1561`	`(cmsg as usize + _CMSG_ALIGN((cmsg).cmsg_len as usize)) as mut cmsghdr`
`1562`	`1562`	`} else {`
`1563`		`- 0 as *mut cmsghdr`
	`1563`	`+ core::ptr::null_mut::<cmsghdr>()`
`1564`	`1564`	`}`
`1565`	`1565`	`}`
`1566`	`1566`
Original file line number	Diff line number	Diff line change
`@@ -4921,7 +4921,7 @@ f! {`
`4921`	`4921`	`cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize) + _ALIGN(mem::size_of::<cmsghdr>());`
`4922`	`4922`	`let max = (mhdr).msg_control as usize + (mhdr).msg_controllen as usize;`
`4923`	`4923`	`if next > max {`
`4924`		`- 0 as *mut cmsghdr`
	`4924`	`+ core::ptr::null_mut::<cmsghdr>()`
`4925`	`4925`	`} else {`
`4926`	`4926`	`(cmsg as usize + _ALIGN((cmsg).cmsg_len as usize)) as mut cmsghdr`
`4927`	`4927`	`}`
`@@ -4952,30 +4952,28 @@ f! {`
`4952`	`4952`	`__xuname(256, buf as *mut c_void)`
`4953`	`4953`	`}`
`4954`	`4954`
`4955`		`- pub fn CPU_ZERO(cpuset: &mut cpuset_t) -> () {`
	`4955`	`+ pub fn CPU_ZERO(cpuset: &mut cpuset_t) {`
`4956`	`4956`	`for slot in cpuset.__bits.iter_mut() {`
`4957`	`4957`	`*slot = 0;`
`4958`	`4958`	`}`
`4959`	`4959`	`}`
`4960`	`4960`
`4961`		`- pub fn CPU_FILL(cpuset: &mut cpuset_t) -> () {`
	`4961`	`+ pub fn CPU_FILL(cpuset: &mut cpuset_t) {`
`4962`	`4962`	`for slot in cpuset.__bits.iter_mut() {`
`4963`	`4963`	`*slot = !0;`
`4964`	`4964`	`}`
`4965`	`4965`	`}`
`4966`	`4966`
`4967`		`- pub fn CPU_SET(cpu: usize, cpuset: &mut cpuset_t) -> () {`
	`4967`	`+ pub fn CPU_SET(cpu: usize, cpuset: &mut cpuset_t) {`
`4968`	`4968`	`let bitset_bits = 8 * mem::size_of::<c_long>();`
`4969`	`4969`	`let (idx, offset) = (cpu / bitset_bits, cpu % bitset_bits);`
`4970`	`4970`	`cpuset.__bits[idx] \|= 1 << offset;`
`4971`		`- ()`
`4972`	`4971`	`}`
`4973`	`4972`
`4974`		`- pub fn CPU_CLR(cpu: usize, cpuset: &mut cpuset_t) -> () {`
	`4973`	`+ pub fn CPU_CLR(cpu: usize, cpuset: &mut cpuset_t) {`
`4975`	`4974`	`let bitset_bits = 8 * mem::size_of::<c_long>();`
`4976`	`4975`	`let (idx, offset) = (cpu / bitset_bits, cpu % bitset_bits);`
`4977`	`4976`	`cpuset.__bits[idx] &= !(1 << offset);`
`4978`		`- ()`
`4979`	`4977`	`}`
`4980`	`4978`
`4981`	`4979`	`pub fn CPU_ISSET(cpu: usize, cpuset: &cpuset_t) -> bool {`
Original file line number	Diff line number	Diff line change
`@@ -2438,7 +2438,7 @@ f! {`
`2438`	`2438`	`cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize) + _ALIGN(mem::size_of::<cmsghdr>());`
`2439`	`2439`	`let max = (mhdr).msg_control as usize + (mhdr).msg_controllen as usize;`
`2440`	`2440`	`if next > max {`
`2441`		`- 0 as *mut cmsghdr`
	`2441`	`+ core::ptr::null_mut::<cmsghdr>()`
`2442`	`2442`	`} else {`
`2443`	`2443`	`(cmsg as usize + _ALIGN((cmsg).cmsg_len as usize)) as mut cmsghdr`
`2444`	`2444`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1940,7 +1940,7 @@ f! {`
`1940`	`1940`	`cmsg as usize + _ALIGN((*cmsg).cmsg_len as usize) + _ALIGN(mem::size_of::<cmsghdr>());`
`1941`	`1941`	`let max = (mhdr).msg_control as usize + (mhdr).msg_controllen as usize;`
`1942`	`1942`	`if next > max {`
`1943`		`- 0 as *mut cmsghdr`
	`1943`	`+ core::ptr::null_mut::<cmsghdr>()`
`1944`	`1944`	`} else {`
`1945`	`1945`	`(cmsg as usize + _ALIGN((cmsg).cmsg_len as usize)) as mut cmsghdr`
`1946`	`1946`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1570,7 +1570,7 @@ f! {`
`1570`	`1570`	`if (*mhdr).msg_controllen as usize >= mem::size_of::<cmsghdr>() {`
`1571`	`1571`	`(mhdr).msg_control as mut cmsghdr`
`1572`	`1572`	`} else {`
`1573`		`- 0 as *mut cmsghdr`
	`1573`	`+ core::ptr::null_mut::<cmsghdr>()`
`1574`	`1574`	`}`
`1575`	`1575`	`}`
`1576`	`1576`
`@@ -1595,7 +1595,7 @@ f! {`
`1595`	`1595`	`+ CMSG_ALIGN(mem::size_of::<cmsghdr>());`
`1596`	`1596`	`let max = (mhdr).msg_control as usize + (mhdr).msg_controllen as usize;`
`1597`	`1597`	`if next > max {`
`1598`		`- 0 as *mut cmsghdr`
	`1598`	`+ core::ptr::null_mut::<cmsghdr>()`
`1599`	`1599`	`} else {`
`1600`	`1600`	`(cmsg as usize + CMSG_ALIGN((cmsg).cmsg_len as usize)) as mut cmsghdr`
`1601`	`1601`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3444,7 +3444,7 @@ f! {`
`3444`	`3444`	`if (*mhdr).msg_controllen as usize >= mem::size_of::<cmsghdr>() {`
`3445`	`3445`	`(mhdr).msg_control as mut cmsghdr`
`3446`	`3446`	`} else {`
`3447`		`- 0 as *mut cmsghdr`
	`3447`	`+ core::ptr::null_mut::<cmsghdr>()`
`3448`	`3448`	`}`
`3449`	`3449`	`}`
`3450`	`3450`
`@@ -3462,14 +3462,14 @@ f! {`
`3462`	`3462`
`3463`	`3463`	`pub fn CMSG_NXTHDR(mhdr: const msghdr, cmsg: const cmsghdr) -> *mut cmsghdr {`
`3464`	`3464`	`if ((*cmsg).cmsg_len as usize) < mem::size_of::<cmsghdr>() {`
`3465`		`- return 0 as *mut cmsghdr;`
	`3465`	`+ return core::ptr::null_mut::<cmsghdr>();`
`3466`	`3466`	`};`
`3467`	`3467`	`let next = (cmsg as usize + CMSG_ALIGN((cmsg).cmsg_len as usize)) as mut cmsghdr;`
`3468`	`3468`	`let max = (mhdr).msg_control as usize + (mhdr).msg_controllen as usize;`
`3469`	`3469`	`if (next.offset(1)) as usize > max`
`3470`	`3470`	`\|\| next as usize + CMSG_ALIGN((*next).cmsg_len as usize) > max`
`3471`	`3471`	`{`
`3472`		`- 0 as *mut cmsghdr`
	`3472`	`+ core::ptr::null_mut::<cmsghdr>()`
`3473`	`3473`	`} else {`
`3474`	`3474`	`next as *mut cmsghdr`
`3475`	`3475`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3611,7 +3611,7 @@ f! {`
`3611`	`3611`	`let next = (cmsg as usize + super::CMSG_ALIGN((cmsg).cmsg_len as usize)) as mut cmsghdr;`
`3612`	`3612`	`let max = (mhdr).msg_control as usize + (mhdr).msg_controllen as usize;`
`3613`	`3613`	`if (next.offset(1)) as usize > max {`
`3614`		`- 0 as *mut cmsghdr`
	`3614`	`+ core::ptr::null_mut::<cmsghdr>()`
`3615`	`3615`	`} else {`
`3616`	`3616`	`next as *mut cmsghdr`
`3617`	`3617`	`}`