From 16278a83fb4cb323212ad7deb33ef91d2c1c4478 Mon Sep 17 00:00:00 2001 From: Perfloop Agent Date: Thu, 19 Nov 2026 09:32:22 +0000 Subject: [PATCH] Respect caller capacity in IP socket address writeback Signed-off-by: Perfloop Agent --- rules/socket/shim.rs | 17 ++- tests/unit/out/refcount/socket_ip_name.rs | 176 ++++++++++++++++++++++ tests/unit/out/unsafe/socket_ip_name.rs | 153 +++++++++++++++++++ tests/unit/socket_ip_name.c | 48 ++++++ 4 files changed, 390 insertions(+), 4 deletions(-) create mode 100644 tests/unit/out/refcount/socket_ip_name.rs create mode 100644 tests/unit/out/unsafe/socket_ip_name.rs create mode 100644 tests/unit/socket_ip_name.c diff --git a/rules/socket/shim.rs b/rules/socket/shim.rs index ff5a3953ce..dce0984d01 100644 --- a/rules/socket/shim.rs +++ b/rules/socket/shim.rs @@ -245,16 +245,25 @@ impl Sockaddr { pub fn encode(ss: &nix::sys::socket::SockaddrStorage, out: &Ptr, out_len: &Ptr) { use nix::sys::socket::{AddressFamily, SockaddrLike}; + let write = |bytes: &[u8]| { + let len = (out_len.read() as usize).min(bytes.len()); + if len != 0 { + out.reinterpret_cast::() + .with_slice_mut(len, |buf| buf.copy_from_slice(&bytes[..len])); + } + }; match ss.family() { Some(AddressFamily::Inet) => { let l = ::libc::sockaddr_in::from(*ss.as_sockaddr_in().unwrap()); - out.reinterpret_cast::() - .write(SockaddrIn::from_libc(&l)); + let mut bytes = [0; ::std::mem::size_of::<::libc::sockaddr_in>()]; + SockaddrIn::from_libc(&l).to_bytes(&mut bytes); + write(&bytes); } Some(AddressFamily::Inet6) => { let l = ::libc::sockaddr_in6::from(*ss.as_sockaddr_in6().unwrap()); - out.reinterpret_cast::() - .write(SockaddrIn6::from_libc(&l)); + let mut bytes = [0; ::std::mem::size_of::<::libc::sockaddr_in6>()]; + SockaddrIn6::from_libc(&l).to_bytes(&mut bytes); + write(&bytes); } Some(AddressFamily::Unix) => { if let Some(addr) = ss.as_unix_addr() { diff --git a/tests/unit/out/refcount/socket_ip_name.rs b/tests/unit/out/refcount/socket_ip_name.rs new file mode 100644 index 0000000000..38f86a30e3 --- /dev/null +++ b/tests/unit/out/refcount/socket_ip_name.rs @@ -0,0 +1,176 @@ +extern crate libcc2rs; +use libcc2rs::*; +use std::cell::RefCell; +use std::collections::BTreeMap; +use std::io::prelude::*; +use std::io::{Read, Seek, Write}; +use std::os::fd::AsFd; +use std::rc::{Rc, Weak}; +pub fn check_buf_0( + mut fd: i32, + mut buf: Ptr, + mut size: u32, + mut cap: libc::socklen_t, + mut full: AnyPtr, + mut actual: libc::socklen_t, +) { + match ({ (buf).to_any() },) { + (mut __tmp_0,) => { + __tmp_0.memset((165) as u8, (size as usize)); + (__tmp_0).clone() + } + }; + let len: Value = Rc::new(RefCell::new(cap)); + assert!( + (match ({ buf.reinterpret_cast::() }, { + (len.as_pointer()) + },) + { + (mut __tmp_1, mut __tmp_2) => { + match nix::sys::socket::getsockname::(fd) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_1, &__tmp_2); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } + } == 0) + ); + let mut copied: u32 = (if (cap < actual) { cap } else { actual } as u32); + assert!(((buf).to_any().memcmp(&full, (copied as usize)) == 0)); + { + let mut j: u32 = copied; + 'loop_: while (j < size) { + assert!((((elem!(buf, j).read()) as i32) == 165)); + j.prefix_inc(); + } + } +} +pub fn check_name_1(mut family: i32) { + let mut fd: i32 = { + let __family = match family { + ::libc::AF_INET => nix::sys::socket::AddressFamily::Inet, + ::libc::AF_INET6 => nix::sys::socket::AddressFamily::Inet6, + ::libc::AF_UNIX => nix::sys::socket::AddressFamily::Unix, + __d => panic!("socket: unsupported domain {__d}"), + }; + let __flags = nix::sys::socket::SockFlag::from_bits_truncate(libc::SOCK_DGRAM); + let __ty = match libc::SOCK_DGRAM & !nix::sys::socket::SockFlag::all().bits() { + ::libc::SOCK_STREAM => nix::sys::socket::SockType::Stream, + ::libc::SOCK_DGRAM => nix::sys::socket::SockType::Datagram, + __t => panic!("socket: unsupported type {__t}"), + }; + let __proto = match 0 { + 0 => None, + ::libc::IPPROTO_TCP => Some(nix::sys::socket::SockProtocol::Tcp), + ::libc::IPPROTO_UDP => Some(nix::sys::socket::SockProtocol::Udp), + __p => panic!("socket: unsupported protocol {__p}"), + }; + match nix::sys::socket::socket(__family, __ty, __flags, __proto) { + Ok(__ofd) => FdRegistry::register(__ofd), + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + }; + assert!((fd >= 0)); + let full: Value = Rc::new(RefCell::new(Default::default())); + match ({ (full.as_pointer()).to_any() },) { + (mut __tmp_3,) => { + __tmp_3.memset((165) as u8, 128usize); + (__tmp_3).clone() + } + }; + let len: Value = Rc::new(RefCell::new((128usize as libc::socklen_t))); + assert!( + (match ( + { (full.as_pointer()).reinterpret_cast::() }, + { (len.as_pointer()) }, + ) { + (mut __tmp_4, mut __tmp_5) => { + match nix::sys::socket::getsockname::(fd) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_4, &__tmp_5); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } + } == 0) + ); + assert!(({ (({ (*full.borrow()).ss_family } as i32) == family) })); + let mut actual: libc::socklen_t = (if (family == libc::AF_INET) { + 16usize + } else { + 28usize + } as libc::socklen_t); + let mut capacities: [libc::socklen_t; 6] = [ + (0 as libc::socklen_t), + (1 as libc::socklen_t), + (2 as libc::socklen_t), + (actual).wrapping_sub((1 as libc::socklen_t)), + actual, + (actual).wrapping_add((1 as libc::socklen_t)), + ]; + { + let mut i: u32 = 0_u32; + 'loop_: while ((i as usize) + < (::std::mem::size_of::<[libc::socklen_t; 6]>() as usize) + .wrapping_div((::std::mem::size_of::() as usize))) + { + let out: Value> = + Rc::new(RefCell::new((0..136).map(|_| 0_u8).collect::>())); + ({ + let _buf: Ptr = out.decay(); + let _size: u32 = (::std::mem::size_of::<[u8; 136]>() as u32); + check_buf_0( + fd, + _buf, + _size, + capacities[(i) as usize], + (full.as_pointer()).to_any(), + actual, + ) + }); + let mut size: u32 = (if (capacities[(i) as usize] != 0) { + capacities[(i) as usize] + } else { + (1 as libc::socklen_t) + } as u32); + let mut small: Ptr = + libcc2rs::malloc_refcount((size as usize)).reinterpret_cast::(); + assert!(!(small).is_null()); + ({ + check_buf_0( + fd, + (small).clone(), + size, + capacities[(i) as usize], + (full.as_pointer()).to_any(), + actual, + ) + }); + libcc2rs::free_refcount((small).to_any()); + i.prefix_inc(); + } + } + assert!((FdRegistry::close(fd) == 0)); +} +pub fn main() { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0()); +} +fn main_0() -> i32 { + ({ check_name_1(libc::AF_INET) }); + ({ check_name_1(libc::AF_INET6) }); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/socket_ip_name.rs b/tests/unit/out/unsafe/socket_ip_name.rs new file mode 100644 index 0000000000..dd7636d98e --- /dev/null +++ b/tests/unit/out/unsafe/socket_ip_name.rs @@ -0,0 +1,153 @@ +extern crate libc; +use libc::*; +extern crate libcc2rs; +use libcc2rs::*; +use std::collections::BTreeMap; +use std::io::{Read, Seek, Write}; +use std::os::fd::{AsFd, FromRawFd, IntoRawFd}; +use std::rc::Rc; +pub unsafe fn check_buf_0( + mut fd: i32, + mut buf: *mut u8, + mut size: u32, + mut cap: libc::socklen_t, + mut full: *const ::libc::c_void, + mut actual: libc::socklen_t, +) { + match ({ (buf as *mut ::libc::c_void) },) { + (mut __tmp_0,) => { + let byte_0 = __tmp_0 as *mut u8; + for offset in 0..(size as usize) { + *byte_0.offset(offset as isize) = 165 as u8; + } + __tmp_0 + } + }; + let mut len: libc::socklen_t = cap; + assert!( + ((libc::getsockname( + fd, + (buf as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + let mut copied: u32 = (if ((cap) < (actual)) { cap } else { actual } as u32); + assert!( + ((match ({ (copied as usize) },) { + (mut __tmp_1,) => { + { + let sa = core::slice::from_raw_parts( + (buf as *const ::libc::c_void) as *const u8, + __tmp_1, + ); + let sb = core::slice::from_raw_parts(full as *const u8, __tmp_1); + let mut diff = 0_i32; + for (x, y) in sa.iter().zip(sb.iter()) { + if x != y { + diff = (*x as i32) - (*y as i32); + break; + } + } + diff + } + } + }) == (0)) + ); + { + let mut j: u32 = copied; + 'loop_: while ((j) < (size)) { + assert!((((*buf.offset((j) as isize)) as i32) == (165))); + j.prefix_inc(); + } + } +} +pub unsafe fn check_name_1(mut family: i32) { + let mut fd: i32 = libc::socket(family, libc::SOCK_DGRAM, 0); + assert!(((fd) >= (0))); + let mut full: libc::sockaddr_storage = unsafe { std::mem::zeroed() }; + match ({ ((&mut full as *mut libc::sockaddr_storage) as *mut ::libc::c_void) },) { + (mut __tmp_2,) => { + let byte_0 = __tmp_2 as *mut u8; + for offset in 0..::std::mem::size_of::() { + *byte_0.offset(offset as isize) = 165 as u8; + } + __tmp_2 + } + }; + let mut len: libc::socklen_t = + (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::getsockname( + fd, + ((&mut full as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + assert!(((full.ss_family as i32) == (family))); + let mut actual: libc::socklen_t = (if ((family) == (libc::AF_INET)) { + ::std::mem::size_of::<::libc::sockaddr_in>() + } else { + ::std::mem::size_of::<::libc::sockaddr_in6>() + } as libc::socklen_t); + let mut capacities: [libc::socklen_t; 6] = [ + (0 as libc::socklen_t), + (1 as libc::socklen_t), + (2 as libc::socklen_t), + (actual).wrapping_sub((1 as libc::socklen_t)), + actual, + (actual).wrapping_add((1 as libc::socklen_t)), + ]; + { + let mut i: u32 = 0_u32; + 'loop_: while ((i as usize) + < ((::std::mem::size_of::<[libc::socklen_t; 6]>() as usize) + .wrapping_div((::std::mem::size_of::() as usize)))) + { + let mut out: [u8; 136] = [0_u8; 136]; + (unsafe { + let _buf: *mut u8 = out.as_mut_ptr(); + let _size: u32 = (::std::mem::size_of::<[u8; 136]>() as u32); + check_buf_0( + fd, + _buf, + _size, + capacities[(i) as usize], + ((&mut full as *mut libc::sockaddr_storage) as *const ::libc::c_void), + actual, + ) + }); + let mut size: u32 = (if (capacities[(i) as usize] != 0) { + capacities[(i) as usize] + } else { + (1 as libc::socklen_t) + } as u32); + let mut small: *mut u8 = (libcc2rs::malloc_unsafe((size as usize)) as *mut u8); + assert!(!(small).is_null()); + (unsafe { + check_buf_0( + fd, + small, + size, + capacities[(i) as usize], + ((&mut full as *mut libc::sockaddr_storage) as *const ::libc::c_void), + actual, + ) + }); + libcc2rs::free_unsafe((small as *mut ::libc::c_void)); + i.prefix_inc(); + } + } + assert!(((libc::close(fd)) == (0))); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + (unsafe { check_name_1(libc::AF_INET) }); + (unsafe { check_name_1(libc::AF_INET6) }); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/socket_ip_name.c b/tests/unit/socket_ip_name.c new file mode 100644 index 0000000000..fc73e80316 --- /dev/null +++ b/tests/unit/socket_ip_name.c @@ -0,0 +1,48 @@ +#include +#include +#include +#include +#include +#include + +static void check_buf(int fd, unsigned char *buf, unsigned size, socklen_t cap, + const void *full, socklen_t actual) { + memset(buf, 0xa5, size); + socklen_t len = cap; + assert(getsockname(fd, (struct sockaddr *)buf, &len) == 0); + unsigned copied = cap < actual ? cap : actual; + assert(memcmp(buf, full, copied) == 0); + for (unsigned j = copied; j < size; ++j) + assert(buf[j] == 0xa5); +} + +static void check_name(int family) { + int fd = socket(family, SOCK_DGRAM, 0); + assert(fd >= 0); + struct sockaddr_storage full; + memset(&full, 0xa5, sizeof(full)); + socklen_t len = sizeof(full); + assert(getsockname(fd, (struct sockaddr *)&full, &len) == 0); + assert(full.ss_family == family); + socklen_t actual = family == AF_INET ? sizeof(struct sockaddr_in) + : sizeof(struct sockaddr_in6); + + socklen_t capacities[] = {0, 1, 2, actual - 1, actual, actual + 1}; + for (unsigned i = 0; i < sizeof(capacities) / sizeof(capacities[0]); ++i) { + unsigned char out[sizeof(struct sockaddr_storage) + 8]; + check_buf(fd, out, sizeof(out), capacities[i], &full, actual); + + unsigned size = capacities[i] ? capacities[i] : 1; + unsigned char *small = malloc(size); + assert(small); + check_buf(fd, small, size, capacities[i], &full, actual); + free(small); + } + assert(close(fd) == 0); +} + +int main(void) { + check_name(AF_INET); + check_name(AF_INET6); + return 0; +}