diff --git a/rules/socket/shim.rs b/rules/socket/shim.rs index f78e0f650..6d8009b0e 100644 --- a/rules/socket/shim.rs +++ b/rules/socket/shim.rs @@ -252,18 +252,20 @@ impl Sockaddr { .with_slice_mut(len, |buf| buf.copy_from_slice(&bytes[..len])); } }; - match ss.family() { + let len = match ss.family() { Some(AddressFamily::Inet) => { let l = ::libc::sockaddr_in::from(*ss.as_sockaddr_in().unwrap()); let mut bytes = [0; ::std::mem::size_of::<::libc::sockaddr_in>()]; SockaddrIn::from_libc(&l).to_bytes(&mut bytes); write(&bytes); + ::std::mem::size_of_val(&l) as u32 } Some(AddressFamily::Inet6) => { let l = ::libc::sockaddr_in6::from(*ss.as_sockaddr_in6().unwrap()); let mut bytes = [0; ::std::mem::size_of::<::libc::sockaddr_in6>()]; SockaddrIn6::from_libc(&l).to_bytes(&mut bytes); write(&bytes); + ::std::mem::size_of_val(&l) as u32 } Some(AddressFamily::Unix) => { if let Some(addr) = ss.as_unix_addr() { @@ -281,10 +283,11 @@ impl Sockaddr { }); } } + ss.len() } - _ => {} - } - out_len.write(ss.len()); + _ => panic!("unsupported socket address family"), + }; + out_len.write(len); } } diff --git a/rules/socket/tgt_refcount.rs b/rules/socket/tgt_refcount.rs index 4bc27c40c..ea3138d47 100644 --- a/rules/socket/tgt_refcount.rs +++ b/rules/socket/tgt_refcount.rs @@ -84,7 +84,11 @@ fn f17(a0: i32, a1: AnyPtr, a2: usize, a3: i32, a4: Ptr, a5: Ptr) }) { Ok((__n, __from)) => { match __from { - Some(__ss) => Sockaddr::encode(&__ss, &a4, &a5), + Some(__ss) => { + if !a4.is_null() { + Sockaddr::encode(&__ss, &a4, &a5) + } + } None => {} } __n as isize diff --git a/tests/unit/out/refcount/socket_ip_addrlen.rs b/tests/unit/out/refcount/socket_ip_addrlen.rs new file mode 100644 index 000000000..c119abc8d --- /dev/null +++ b/tests/unit/out/refcount/socket_ip_addrlen.rs @@ -0,0 +1,424 @@ +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_name_0(mut addr: Ptr, mut expected: libc::socklen_t) { + let mut receiver: i32 = { + let __family = match (addr.with(|__s| __s.sa_family) as i32) { + ::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 + } + } + }; + let mut sender: i32 = { + let __family = match (addr.with(|__s| __s.sa_family) as i32) { + ::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!((receiver >= 0)); + assert!((sender >= 0)); + let local: Value = Rc::new(RefCell::new(Default::default())); + let len: Value = Rc::new(RefCell::new((128usize as libc::socklen_t))); + assert!( + ({ + let mut __tmp_0 = { (local.as_pointer()).reinterpret_cast::() }; + let mut __tmp_1 = { (len.as_pointer()) }; + match nix::sys::socket::getsockname::(receiver) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_0, &__tmp_1); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 0) + ); + assert!(({ ((*len.borrow()) == expected) })); + (*len.borrow_mut()) = (0 as libc::socklen_t); + assert!( + ({ + let mut __tmp_2 = { (local.as_pointer()).reinterpret_cast::() }; + let mut __tmp_3 = { (len.as_pointer()) }; + match nix::sys::socket::getsockname::(receiver) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_2, &__tmp_3); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 0) + ); + assert!(({ ((*len.borrow()) == expected) })); + assert!( + (match Sockaddr::decode(&addr, expected) { + Some(__addr) => match nix::sys::socket::bind(receiver, &*__addr) { + Ok(()) => 0, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + }, + None => { + libcc2rs::cpp2rust_errno().write(::libc::EAFNOSUPPORT); + -1 + } + } == 0) + ); + (*len.borrow_mut()) = (128usize as libc::socklen_t); + assert!( + ({ + let mut __tmp_4 = { (local.as_pointer()).reinterpret_cast::() }; + let mut __tmp_5 = { (len.as_pointer()) }; + match nix::sys::socket::getsockname::(receiver) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_4, &__tmp_5); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 0) + ); + assert!(({ ((*len.borrow()) == expected) })); + assert!( + (match Sockaddr::decode( + &(local.as_pointer()).reinterpret_cast::(), + ({ (*len.borrow()) }) + ) { + Some(__addr) => match nix::sys::socket::connect(sender, &*__addr) { + Ok(()) => 0, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + }, + None => { + libcc2rs::cpp2rust_errno().write(::libc::EAFNOSUPPORT); + -1 + } + } == 0) + ); + let peer: Value = Rc::new(RefCell::new(Default::default())); + (*len.borrow_mut()) = (128usize as libc::socklen_t); + assert!( + ({ + let mut __tmp_6 = { (peer.as_pointer()).reinterpret_cast::() }; + let mut __tmp_7 = { (len.as_pointer()) }; + match nix::sys::socket::getpeername::(sender) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_6, &__tmp_7); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 0) + ); + assert!(({ ((*len.borrow()) == expected) })); + assert!( + ((local.as_pointer()) + .to_any() + .memcmp(&(peer.as_pointer()).to_any(), (expected as usize)) + == 0) + ); + let sent: Value = Rc::new(RefCell::new((('x' as i32) as i8))); + let received: Value = Rc::new(RefCell::new(0_i8)); + assert!( + ({ + let __buf = (sent.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + let from: Value = Rc::new(RefCell::new(Default::default())); + (*len.borrow_mut()) = (128usize as libc::socklen_t); + assert!( + ({ + let mut __tmp_8 = { (from.as_pointer()).reinterpret_cast::() }; + let mut __tmp_9 = { (len.as_pointer()) }; + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !__tmp_8.is_null() { + Sockaddr::encode(&__ss, &__tmp_8, &__tmp_9) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ ((*len.borrow()) == expected) })); + assert!(({ (((*received.borrow()) as i32) == ((*sent.borrow()) as i32)) })); + (*len.borrow_mut()) = (128usize as libc::socklen_t); + assert!( + ({ + let mut __tmp_10 = { (local.as_pointer()).reinterpret_cast::() }; + let mut __tmp_11 = { (len.as_pointer()) }; + match nix::sys::socket::getsockname::(sender) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_10, &__tmp_11); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 0) + ); + assert!(({ ((*len.borrow()) == expected) })); + assert!( + ((local.as_pointer()) + .to_any() + .memcmp(&(from.as_pointer()).to_any(), (expected as usize)) + == 0) + ); + (*received.borrow_mut()) = 0_i8; + assert!( + ({ + let __buf = (sent.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!( + ({ + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !Ptr::::null().is_null() { + Sockaddr::encode( + &__ss, + &Ptr::::null(), + &Ptr::::null(), + ) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ (((*received.borrow()) as i32) == ((*sent.borrow()) as i32)) })); + (*received.borrow_mut()) = 0_i8; + (*len.borrow_mut()) = (77 as libc::socklen_t); + assert!( + ({ + let __buf = (sent.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!( + ({ + let mut __tmp_12 = { (len.as_pointer()) }; + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !Ptr::::null().is_null() { + Sockaddr::encode( + &__ss, + &Ptr::::null(), + &__tmp_12, + ) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ ((*len.borrow()) == (77 as libc::socklen_t)) })); + assert!(({ (((*received.borrow()) as i32) == ((*sent.borrow()) as i32)) })); + assert!((FdRegistry::close(sender) == 0)); + assert!((FdRegistry::close(receiver) == 0)); +} +pub fn main() { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0()); +} +fn main_0() -> i32 { + let in_: Value = Rc::new(RefCell::new(Default::default())); + { + let mut __tmp_13 = { (in_.as_pointer()).to_any() }; + __tmp_13.memset((0) as u8, 16usize); + (__tmp_13).clone() + }; + (*in_.borrow_mut()).sin_family = 2_u16; + (*in_.borrow_mut()).sin_addr.s_addr = ((u32::to_be(2130706433_u32)) as ::libc::in_addr_t); + ({ + let _addr: Ptr = + (in_.as_pointer()).reinterpret_cast::(); + let _expected: libc::socklen_t = (16usize as libc::socklen_t); + check_name_0(_addr, _expected) + }); + let in6: Value = Rc::new(RefCell::new(Default::default())); + let mut fd: i32 = { + let __family = match libc::AF_INET6 { + ::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 len: Value = Rc::new(RefCell::new((28usize as libc::socklen_t))); + assert!( + ({ + let mut __tmp_14 = { (in6.as_pointer()).reinterpret_cast::() }; + let mut __tmp_15 = { (len.as_pointer()) }; + match nix::sys::socket::getsockname::(fd) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_14, &__tmp_15); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 0) + ); + assert!(({ (((*len.borrow()) as usize) == 28usize) })); + assert!((FdRegistry::close(fd) == 0)); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/refcount/socket_recvfrom_name.rs b/tests/unit/out/refcount/socket_recvfrom_name.rs new file mode 100644 index 000000000..29a4f4536 --- /dev/null +++ b/tests/unit/out/refcount/socket_recvfrom_name.rs @@ -0,0 +1,548 @@ +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_from_0( + mut receiver: i32, + mut sender: i32, + mut expected: Ptr, + mut expected_len: libc::socklen_t, +) { + let sent: Value = Rc::new(RefCell::new((('x' as i32) as i8))); + let received: Value = Rc::new(RefCell::new(0_i8)); + assert!( + ({ + let __buf = (sent.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + let from: Value = Rc::new(RefCell::new(Default::default())); + { + let mut __tmp_0 = { (from.as_pointer()).to_any() }; + __tmp_0.memset((165) as u8, 128usize); + (__tmp_0).clone() + }; + let len: Value = Rc::new(RefCell::new((128usize as libc::socklen_t))); + assert!( + ({ + let mut __tmp_1 = { (from.as_pointer()).reinterpret_cast::() }; + let mut __tmp_2 = { (len.as_pointer()) }; + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !__tmp_1.is_null() { + Sockaddr::encode(&__ss, &__tmp_1, &__tmp_2) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ ((*len.borrow()) == expected_len) })); + assert!(({ (((*received.borrow()) as i32) == ((*sent.borrow()) as i32)) })); + assert!( + ((from.as_pointer()) + .to_any() + .memcmp(&(expected).to_any(), ({ ((*len.borrow()) as usize) })) + == 0) + ); + { + let mut i: u32 = ((*len.borrow()) as u32); + 'loop_: while ((i as usize) < 128usize) { + assert!( + (((elem!(((from.as_pointer()).reinterpret_cast::()), i).read()) as i32) == 165) + ); + i.prefix_inc(); + } + } +} +pub fn main() { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0()); +} +fn main_0() -> i32 { + let mut receiver: i32 = { + let __family = match 1 { + ::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 + } + } + }; + let mut sender: i32 = { + let __family = match 1 { + ::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!((receiver >= 0)); + assert!((sender >= 0)); + let addr: Value = Rc::new(RefCell::new(Default::default())); + let len: Value = Rc::new(RefCell::new((128usize as libc::socklen_t))); + assert!( + ({ + let mut __tmp_3 = { (addr.as_pointer()).reinterpret_cast::() }; + let mut __tmp_4 = { (len.as_pointer()) }; + match nix::sys::socket::getsockname::(receiver) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_3, &__tmp_4); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 0) + ); + let mut un: Ptr = + (addr.as_pointer()).reinterpret_cast::(); + { + let mut __tmp_5 = { (array_field_ptr!(un, sun_path)).to_any() }; + __tmp_5.memcpy( + &(Ptr::::from_string_literal(b"recvfrom-receiver")).to_any(), + ::std::mem::size_of::<[i8; 18]>(), + ); + (__tmp_5).clone() + }; + (*len.borrow_mut()) = ((((2_usize as usize).wrapping_add( + array_field_ptr!(un, sun_path) + .to_c_string_iterator() + .count(), + )) + .wrapping_add(1_usize)) as libc::socklen_t); + assert!( + (match Sockaddr::decode( + &(addr.as_pointer()).reinterpret_cast::(), + ({ (*len.borrow()) }) + ) { + Some(__addr) => match nix::sys::socket::bind(receiver, &*__addr) { + Ok(()) => 0, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + }, + None => { + libcc2rs::cpp2rust_errno().write(::libc::EAFNOSUPPORT); + -1 + } + } == 0) + ); + assert!( + (match Sockaddr::decode( + &(addr.as_pointer()).reinterpret_cast::(), + ({ (*len.borrow()) }) + ) { + Some(__addr) => match nix::sys::socket::connect(sender, &*__addr) { + Ok(()) => 0, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + }, + None => { + libcc2rs::cpp2rust_errno().write(::libc::EAFNOSUPPORT); + -1 + } + } == 0) + ); + let received: Value = Rc::new(RefCell::new(0_i8)); + assert!( + ({ + let __buf = (Ptr::::from_string_literal(b"x")) + .to_any() + .reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + let from: Value = Rc::new(RefCell::new(Default::default())); + let from_len: Value = Rc::new(RefCell::new((128usize as libc::socklen_t))); + assert!( + ({ + let mut __tmp_6 = { (from.as_pointer()).reinterpret_cast::() }; + let mut __tmp_7 = { (from_len.as_pointer()) }; + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !__tmp_6.is_null() { + Sockaddr::encode(&__ss, &__tmp_6, &__tmp_7) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ (((*received.borrow()) as i32) == ('x' as i32)) })); + assert!( + ({ + let __buf = (Ptr::::from_string_literal(b"x")) + .to_any() + .reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!( + ({ + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !Ptr::::null().is_null() { + Sockaddr::encode( + &__ss, + &Ptr::::null(), + &Ptr::::null(), + ) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ (((*received.borrow()) as i32) == ('x' as i32)) })); + (*received.borrow_mut()) = 0_i8; + (*len.borrow_mut()) = (77 as libc::socklen_t); + assert!( + ({ + let __buf = (Ptr::::from_string_literal(b"x")) + .to_any() + .reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!( + ({ + let mut __tmp_8 = { (len.as_pointer()) }; + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !Ptr::::null().is_null() { + Sockaddr::encode( + &__ss, + &Ptr::::null(), + &__tmp_8, + ) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ ((*len.borrow()) == (77 as libc::socklen_t)) })); + assert!(({ (((*received.borrow()) as i32) == ('x' as i32)) })); + { + let mut __tmp_9 = { (array_field_ptr!(un, sun_path)).to_any() }; + __tmp_9.memcpy( + &(Ptr::::from_string_literal(b"recvfrom-sender")).to_any(), + ::std::mem::size_of::<[i8; 16]>(), + ); + (__tmp_9).clone() + }; + (*len.borrow_mut()) = ((((2_usize as usize).wrapping_add( + array_field_ptr!(un, sun_path) + .to_c_string_iterator() + .count(), + )) + .wrapping_add(1_usize)) as libc::socklen_t); + assert!( + (match Sockaddr::decode( + &(addr.as_pointer()).reinterpret_cast::(), + ({ (*len.borrow()) }) + ) { + Some(__addr) => match nix::sys::socket::bind(sender, &*__addr) { + Ok(()) => 0, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + }, + None => { + libcc2rs::cpp2rust_errno().write(::libc::EAFNOSUPPORT); + -1 + } + } == 0) + ); + (*len.borrow_mut()) = (128usize as libc::socklen_t); + assert!( + ({ + let mut __tmp_10 = { (addr.as_pointer()).reinterpret_cast::() }; + let mut __tmp_11 = { (len.as_pointer()) }; + match nix::sys::socket::getsockname::(sender) { + Ok(__ss) => { + Sockaddr::encode(&__ss, &__tmp_10, &__tmp_11); + 0 + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 0) + ); + ({ check_from_0(receiver, sender, (addr.as_pointer()), (*len.borrow())) }); + (*received.borrow_mut()) = 0_i8; + assert!( + ({ + let __buf = (Ptr::::from_string_literal(b"x")) + .to_any() + .reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!( + ({ + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !Ptr::::null().is_null() { + Sockaddr::encode( + &__ss, + &Ptr::::null(), + &Ptr::::null(), + ) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ (((*received.borrow()) as i32) == ('x' as i32)) })); + (*received.borrow_mut()) = 0_i8; + (*len.borrow_mut()) = (77 as libc::socklen_t); + assert!( + ({ + let __buf = (Ptr::::from_string_literal(b"x")) + .to_any() + .reinterpret_cast::(); + match __buf.with_slice(1_usize, |__s| { + nix::sys::socket::send( + sender, + __s, + nix::sys::socket::MsgFlags::from_bits_truncate(0), + ) + }) { + Ok(__n) => __n as isize, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!( + ({ + let mut __tmp_12 = { (len.as_pointer()) }; + let __buf = (received.as_pointer()).to_any().reinterpret_cast::(); + match __buf.with_slice_mut(1_usize, |__s| { + nix::sys::socket::recvfrom::(receiver, __s) + }) { + Ok((__n, __from)) => { + match __from { + Some(__ss) => { + if !Ptr::::null().is_null() { + Sockaddr::encode( + &__ss, + &Ptr::::null(), + &__tmp_12, + ) + } + } + None => {} + } + __n as isize + } + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } + } == 1_isize) + ); + assert!(({ ((*len.borrow()) == (77 as libc::socklen_t)) })); + assert!(({ (((*received.borrow()) as i32) == ('x' as i32)) })); + assert!((FdRegistry::close(sender) == 0)); + assert!((FdRegistry::close(receiver) == 0)); + assert!( + (match Ptr::::from_string_literal(b"recvfrom-sender") + .with_c_bytes(|__path| nix::unistd::unlink(__path)) + { + Ok(()) => 0, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } == 0) + ); + assert!( + (match Ptr::::from_string_literal(b"recvfrom-receiver") + .with_c_bytes(|__path| nix::unistd::unlink(__path)) + { + Ok(()) => 0, + Err(__e) => { + libcc2rs::cpp2rust_errno().write(__e as i32); + -1 + } + } == 0) + ); + return 0; +} +pub fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/refcount/socket_unix_name.rs b/tests/unit/out/refcount/socket_unix_name.rs index 927a2fb3d..513d5c0a1 100644 --- a/tests/unit/out/refcount/socket_unix_name.rs +++ b/tests/unit/out/refcount/socket_unix_name.rs @@ -34,6 +34,15 @@ pub fn check_name_0(mut fd: i32, mut path: Ptr) { assert!(({ (((*actual.borrow()) as usize) >= 2_usize) })); assert!(({ (((*actual.borrow()) as usize) < 128usize) })); if !(path).is_null() { + let mut path_len: libc::socklen_t = (((2_usize as usize) + .wrapping_add(path.to_c_string_iterator().count())) + as libc::socklen_t); + assert!( + ({ + (((*actual.borrow()) == path_len) + || ((*actual.borrow()) == (path_len).wrapping_add((1 as libc::socklen_t)))) + }) + ); assert!( ((array_field_ptr!( ((full.as_pointer()).reinterpret_cast::()), @@ -43,7 +52,23 @@ pub fn check_name_0(mut fd: i32, mut path: Ptr) { .memcmp(&(path).to_any(), path.to_c_string_iterator().count()) == 0) ); + } else { + assert!( + ({ + ((((*actual.borrow()) as usize) == 2_usize) + || (((*actual.borrow()) as usize) == 16usize)) + }) + ); } + printf!( + b"%s: length %u\n", + if !(path).is_null() { + Ptr::::from_string_literal(b"named") + } else { + Ptr::::from_string_literal(b"unnamed") + }, + ((*actual.borrow()) as u32) + ); let mut capacities: [libc::socklen_t; 6] = [ (0 as libc::socklen_t), (1 as libc::socklen_t), diff --git a/tests/unit/out/unsafe/socket_ip_addrlen.rs b/tests/unit/out/unsafe/socket_ip_addrlen.rs new file mode 100644 index 000000000..b01f6cb31 --- /dev/null +++ b/tests/unit/out/unsafe/socket_ip_addrlen.rs @@ -0,0 +1,222 @@ +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_name_0(mut addr: *mut libc::sockaddr, mut expected: libc::socklen_t) { + let mut receiver: i32 = libc::socket(((*addr).sa_family as i32), libc::SOCK_DGRAM, 0); + let mut sender: i32 = libc::socket(((*addr).sa_family as i32), libc::SOCK_DGRAM, 0); + assert!(((receiver) >= (0))); + assert!(((sender) >= (0))); + let mut local: libc::sockaddr_storage = std::mem::zeroed(); + let mut len: libc::socklen_t = + (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::getsockname( + receiver, + ((&mut local as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + assert!(((len) == (expected))); + len = (0 as libc::socklen_t); + assert!( + ((libc::getsockname( + receiver, + ((&mut local as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + assert!(((len) == (expected))); + assert!(((libc::bind(receiver, (addr).cast_const(), expected)) == (0))); + len = (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::getsockname( + receiver, + ((&mut local as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + assert!(((len) == (expected))); + assert!( + ((libc::connect( + sender, + ((&mut local as *mut libc::sockaddr_storage) as *mut libc::sockaddr).cast_const(), + len + )) == (0)) + ); + let mut peer: libc::sockaddr_storage = std::mem::zeroed(); + len = (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::getpeername( + sender, + ((&mut peer as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + assert!(((len) == (expected))); + assert!( + (({ + let mut __tmp_0 = { (expected as usize) }; + let sa = core::slice::from_raw_parts( + ((&mut local as *mut libc::sockaddr_storage) as *const ::libc::c_void) as *const u8, + __tmp_0, + ); + let sb = core::slice::from_raw_parts( + ((&mut peer as *mut libc::sockaddr_storage) as *const ::libc::c_void) as *const u8, + __tmp_0, + ); + 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 sent: libc::c_char = (('x' as i32) as libc::c_char); + let mut received: libc::c_char = (0 as libc::c_char); + assert!( + ((libc::send( + sender, + ((&mut sent as *mut libc::c_char) as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + let mut from: libc::sockaddr_storage = std::mem::zeroed(); + len = (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + ((&mut from as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (1_isize)) + ); + assert!(((len) == (expected))); + assert!(((received as i32) == (sent as i32))); + len = (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::getsockname( + sender, + ((&mut local as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + assert!(((len) == (expected))); + assert!( + (({ + let mut __tmp_1 = { (expected as usize) }; + let sa = core::slice::from_raw_parts( + ((&mut local as *mut libc::sockaddr_storage) as *const ::libc::c_void) as *const u8, + __tmp_1, + ); + let sb = core::slice::from_raw_parts( + ((&mut from as *mut libc::sockaddr_storage) as *const ::libc::c_void) 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)) + ); + received = (0 as libc::c_char); + assert!( + ((libc::send( + sender, + ((&mut sent as *mut libc::c_char) as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + std::ptr::null_mut(), + std::ptr::null_mut() + )) == (1_isize)) + ); + assert!(((received as i32) == (sent as i32))); + received = (0 as libc::c_char); + len = (77 as libc::socklen_t); + assert!( + ((libc::send( + sender, + ((&mut sent as *mut libc::c_char) as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + std::ptr::null_mut(), + (&mut len as *mut libc::socklen_t) + )) == (1_isize)) + ); + assert!(((len) == (77 as libc::socklen_t))); + assert!(((received as i32) == (sent as i32))); + assert!(((libc::close(sender)) == (0))); + assert!(((libc::close(receiver)) == (0))); +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut in_: ::libc::sockaddr_in = std::mem::zeroed(); + { + let mut __tmp_2 = { ((&mut in_ as *mut ::libc::sockaddr_in) as *mut ::libc::c_void) }; + let byte_0 = __tmp_2 as *mut u8; + for offset in 0..::std::mem::size_of::<::libc::sockaddr_in>() { + *byte_0.offset(offset as isize) = 0 as u8; + } + __tmp_2 + }; + in_.sin_family = (2 as libc::sa_family_t); + in_.sin_addr.s_addr = ((u32::to_be(2130706433_u32)) as ::libc::in_addr_t); + (unsafe { + let _addr: *mut libc::sockaddr = + ((&mut in_ as *mut ::libc::sockaddr_in) as *mut libc::sockaddr); + let _expected: libc::socklen_t = + (::std::mem::size_of::<::libc::sockaddr_in>() as libc::socklen_t); + check_name_0(_addr, _expected) + }); + let mut in6: ::libc::sockaddr_in6 = std::mem::zeroed(); + let mut fd: i32 = libc::socket(libc::AF_INET6, libc::SOCK_DGRAM, 0); + assert!(((fd) >= (0))); + let mut len: libc::socklen_t = + (::std::mem::size_of::<::libc::sockaddr_in6>() as libc::socklen_t); + assert!( + ((libc::getsockname( + fd, + ((&mut in6 as *mut ::libc::sockaddr_in6) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + assert!(((len as usize) == (::std::mem::size_of::<::libc::sockaddr_in6>()))); + assert!(((libc::close(fd)) == (0))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/socket_recvfrom_name.rs b/tests/unit/out/unsafe/socket_recvfrom_name.rs new file mode 100644 index 000000000..a9557f9af --- /dev/null +++ b/tests/unit/out/unsafe/socket_recvfrom_name.rs @@ -0,0 +1,281 @@ +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_from_0( + mut receiver: i32, + mut sender: i32, + mut expected: *mut libc::sockaddr_storage, + mut expected_len: libc::socklen_t, +) { + let mut sent: libc::c_char = (('x' as i32) as libc::c_char); + let mut received: libc::c_char = (0 as libc::c_char); + assert!( + ((libc::send( + sender, + ((&mut sent as *mut libc::c_char) as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + let mut from: libc::sockaddr_storage = std::mem::zeroed(); + { + let mut __tmp_0 = { ((&mut from as *mut libc::sockaddr_storage) as *mut ::libc::c_void) }; + let byte_0 = __tmp_0 as *mut u8; + for offset in 0..::std::mem::size_of::() { + *byte_0.offset(offset as isize) = 165 as u8; + } + __tmp_0 + }; + let mut len: libc::socklen_t = + (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + ((&mut from as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (1_isize)) + ); + assert!(((len) == (expected_len))); + assert!(((received as i32) == (sent as i32))); + assert!( + (({ + let mut __tmp_1 = { (len as usize) }; + let sa = core::slice::from_raw_parts( + ((&mut from as *mut libc::sockaddr_storage) as *const ::libc::c_void) as *const u8, + __tmp_1, + ); + let sb = core::slice::from_raw_parts( + (expected as *const ::libc::c_void) 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 i: u32 = (len as u32); + 'loop_: while ((i as usize) < (::std::mem::size_of::())) { + assert!( + (((*((&mut from as *mut libc::sockaddr_storage) as *mut u8).offset((i) as isize)) + as i32) + == (165)) + ); + i.prefix_inc(); + } + } +} +pub fn main() { + unsafe { + __cpp2rust_init_globals(); + libcc2rs::cpp2rust_exit(main_0() as i32); + } +} +unsafe fn main_0() -> i32 { + let mut receiver: i32 = libc::socket(1, libc::SOCK_DGRAM, 0); + let mut sender: i32 = libc::socket(1, libc::SOCK_DGRAM, 0); + assert!(((receiver) >= (0))); + assert!(((sender) >= (0))); + let mut addr: libc::sockaddr_storage = std::mem::zeroed(); + let mut len: libc::socklen_t = + (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::getsockname( + receiver, + ((&mut addr as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + let mut un: *mut libc::sockaddr_un = + ((&mut addr as *mut libc::sockaddr_storage) as *mut libc::sockaddr_un); + { + let mut __tmp_2 = { ((*un).sun_path.as_mut_ptr() as *mut ::libc::c_void) }; + if ::std::mem::size_of::<[libc::c_char; 18]>() != 0 { + ::std::ptr::copy_nonoverlapping( + (c"recvfrom-receiver".as_ptr().cast_mut() as *const ::libc::c_void), + __tmp_2, + ::std::mem::size_of::<[libc::c_char; 18]>(), + ) + } + __tmp_2 + }; + len = ((((::std::mem::offset_of!(libc::sockaddr_un, sun_path) as usize) + .wrapping_add(libc::strlen(((*un).sun_path.as_mut_ptr()).cast_const()))) + .wrapping_add(1_usize)) as libc::socklen_t); + assert!( + ((libc::bind( + receiver, + ((&mut addr as *mut libc::sockaddr_storage) as *mut libc::sockaddr).cast_const(), + len + )) == (0)) + ); + assert!( + ((libc::connect( + sender, + ((&mut addr as *mut libc::sockaddr_storage) as *mut libc::sockaddr).cast_const(), + len + )) == (0)) + ); + let mut received: libc::c_char = (0 as libc::c_char); + assert!( + ((libc::send( + sender, + (c"x".as_ptr().cast_mut() as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + let mut from: libc::sockaddr_storage = std::mem::zeroed(); + let mut from_len: libc::socklen_t = + (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + ((&mut from as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut from_len as *mut libc::socklen_t) + )) == (1_isize)) + ); + assert!(((received as i32) == ('x' as i32))); + assert!( + ((libc::send( + sender, + (c"x".as_ptr().cast_mut() as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + std::ptr::null_mut(), + std::ptr::null_mut() + )) == (1_isize)) + ); + assert!(((received as i32) == ('x' as i32))); + received = (0 as libc::c_char); + len = (77 as libc::socklen_t); + assert!( + ((libc::send( + sender, + (c"x".as_ptr().cast_mut() as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + std::ptr::null_mut(), + (&mut len as *mut libc::socklen_t) + )) == (1_isize)) + ); + assert!(((len) == (77 as libc::socklen_t))); + assert!(((received as i32) == ('x' as i32))); + { + let mut __tmp_3 = { ((*un).sun_path.as_mut_ptr() as *mut ::libc::c_void) }; + if ::std::mem::size_of::<[libc::c_char; 16]>() != 0 { + ::std::ptr::copy_nonoverlapping( + (c"recvfrom-sender".as_ptr().cast_mut() as *const ::libc::c_void), + __tmp_3, + ::std::mem::size_of::<[libc::c_char; 16]>(), + ) + } + __tmp_3 + }; + len = ((((::std::mem::offset_of!(libc::sockaddr_un, sun_path) as usize) + .wrapping_add(libc::strlen(((*un).sun_path.as_mut_ptr()).cast_const()))) + .wrapping_add(1_usize)) as libc::socklen_t); + assert!( + ((libc::bind( + sender, + ((&mut addr as *mut libc::sockaddr_storage) as *mut libc::sockaddr).cast_const(), + len + )) == (0)) + ); + len = (::std::mem::size_of::() as libc::socklen_t); + assert!( + ((libc::getsockname( + sender, + ((&mut addr as *mut libc::sockaddr_storage) as *mut libc::sockaddr), + (&mut len as *mut libc::socklen_t) + )) == (0)) + ); + (unsafe { + check_from_0( + receiver, + sender, + (&mut addr as *mut libc::sockaddr_storage), + len, + ) + }); + received = (0 as libc::c_char); + assert!( + ((libc::send( + sender, + (c"x".as_ptr().cast_mut() as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + std::ptr::null_mut(), + std::ptr::null_mut() + )) == (1_isize)) + ); + assert!(((received as i32) == ('x' as i32))); + received = (0 as libc::c_char); + len = (77 as libc::socklen_t); + assert!( + ((libc::send( + sender, + (c"x".as_ptr().cast_mut() as *const ::libc::c_void), + 1_usize, + 0 + )) == (1_isize)) + ); + assert!( + ((libc::recvfrom( + receiver, + ((&mut received as *mut libc::c_char) as *mut ::libc::c_void), + 1_usize, + 0, + std::ptr::null_mut(), + (&mut len as *mut libc::socklen_t) + )) == (1_isize)) + ); + assert!(((len) == (77 as libc::socklen_t))); + assert!(((received as i32) == ('x' as i32))); + assert!(((libc::close(sender)) == (0))); + assert!(((libc::close(receiver)) == (0))); + assert!(((libc::unlink((c"recvfrom-sender".as_ptr().cast_mut()).cast_const())) == (0))); + assert!(((libc::unlink((c"recvfrom-receiver".as_ptr().cast_mut()).cast_const())) == (0))); + return 0; +} +pub unsafe fn __cpp2rust_init_globals() {} diff --git a/tests/unit/out/unsafe/socket_unix_name.rs b/tests/unit/out/unsafe/socket_unix_name.rs index d23b5bb72..4356ac516 100644 --- a/tests/unit/out/unsafe/socket_unix_name.rs +++ b/tests/unit/out/unsafe/socket_unix_name.rs @@ -29,6 +29,13 @@ pub unsafe fn check_name_0(mut fd: i32, mut path: *const libc::c_char) { assert!(((actual as usize) >= (::std::mem::offset_of!(libc::sockaddr_un, sun_path)))); assert!(((actual as usize) < (::std::mem::size_of::()))); if !(path).is_null() { + let mut path_len: libc::socklen_t = + (((::std::mem::offset_of!(libc::sockaddr_un, sun_path) as usize) + .wrapping_add(libc::strlen(path))) as libc::socklen_t); + assert!( + (((actual) == (path_len)) + || ((actual) == ((path_len).wrapping_add((1 as libc::socklen_t))))) + ); assert!( (({ let mut __tmp_1 = { libc::strlen(path) }; @@ -52,7 +59,23 @@ pub unsafe fn check_name_0(mut fd: i32, mut path: *const libc::c_char) { diff }) == (0)) ); + } else { + assert!( + (((actual as usize) == (::std::mem::offset_of!(libc::sockaddr_un, sun_path))) + || ((actual as usize) == (::std::mem::size_of::()))) + ); } + (unsafe { + libc::printf( + (c"%s: length %u\n".as_ptr().cast_mut()).cast_const() as *const libc::c_char, + (if !(path).is_null() { + c"named".as_ptr().cast_mut() + } else { + c"unnamed".as_ptr().cast_mut() + }), + (actual as u32), + ) + }); let mut capacities: [libc::socklen_t; 6] = [ (0 as libc::socklen_t), (1 as libc::socklen_t), diff --git a/tests/unit/socket_ip_addrlen.c b/tests/unit/socket_ip_addrlen.c new file mode 100644 index 000000000..dfaffc315 --- /dev/null +++ b/tests/unit/socket_ip_addrlen.c @@ -0,0 +1,77 @@ +#include +#include +#include +#include +#include +#include + +static void check_name(struct sockaddr *addr, socklen_t expected) { + int receiver = socket(addr->sa_family, SOCK_DGRAM, 0); + int sender = socket(addr->sa_family, SOCK_DGRAM, 0); + assert(receiver >= 0); + assert(sender >= 0); + + struct sockaddr_storage local; + socklen_t len = sizeof(local); + assert(getsockname(receiver, (struct sockaddr *)&local, &len) == 0); + assert(len == expected); + len = 0; + assert(getsockname(receiver, (struct sockaddr *)&local, &len) == 0); + assert(len == expected); + + assert(bind(receiver, addr, expected) == 0); + len = sizeof(local); + assert(getsockname(receiver, (struct sockaddr *)&local, &len) == 0); + assert(len == expected); + assert(connect(sender, (struct sockaddr *)&local, len) == 0); + + struct sockaddr_storage peer; + len = sizeof(peer); + assert(getpeername(sender, (struct sockaddr *)&peer, &len) == 0); + assert(len == expected); + assert(memcmp(&local, &peer, expected) == 0); + + char sent = 'x', received = 0; + assert(send(sender, &sent, 1, 0) == 1); + struct sockaddr_storage from; + len = sizeof(from); + assert(recvfrom(receiver, &received, 1, 0, (struct sockaddr *)&from, &len) == + 1); + assert(len == expected); + assert(received == sent); + len = sizeof(local); + assert(getsockname(sender, (struct sockaddr *)&local, &len) == 0); + assert(len == expected); + assert(memcmp(&local, &from, expected) == 0); + + received = 0; + assert(send(sender, &sent, 1, 0) == 1); + assert(recvfrom(receiver, &received, 1, 0, NULL, NULL) == 1); + assert(received == sent); + received = 0; + len = 77; + assert(send(sender, &sent, 1, 0) == 1); + assert(recvfrom(receiver, &received, 1, 0, NULL, &len) == 1); + assert(len == 77); + assert(received == sent); + + assert(close(sender) == 0); + assert(close(receiver) == 0); +} + +int main(void) { + struct sockaddr_in in; + memset(&in, 0, sizeof(in)); + in.sin_family = AF_INET; + in.sin_addr.s_addr = htonl(0x7f000001); + check_name((struct sockaddr *)&in, sizeof(in)); + + struct sockaddr_in6 in6; + int fd = socket(AF_INET6, SOCK_DGRAM, 0); + assert(fd >= 0); + socklen_t len = sizeof(in6); + assert(getsockname(fd, (struct sockaddr *)&in6, &len) == 0); + assert(len == sizeof(struct sockaddr_in6)); + assert(close(fd) == 0); + return 0; +} diff --git a/tests/unit/socket_recvfrom_name.c b/tests/unit/socket_recvfrom_name.c new file mode 100644 index 000000000..4028d2978 --- /dev/null +++ b/tests/unit/socket_recvfrom_name.c @@ -0,0 +1,78 @@ +#include +#include +#include +#include +#include +#include + +static void check_from(int receiver, int sender, + struct sockaddr_storage *expected, + socklen_t expected_len) { + char sent = 'x', received = 0; + assert(send(sender, &sent, 1, 0) == 1); + struct sockaddr_storage from; + memset(&from, 0xa5, sizeof(from)); + socklen_t len = sizeof(from); + assert(recvfrom(receiver, &received, 1, 0, (struct sockaddr *)&from, &len) == + 1); + assert(len == expected_len); + assert(received == sent); + assert(memcmp(&from, expected, len) == 0); + for (unsigned i = len; i < sizeof(from); ++i) + assert(((unsigned char *)&from)[i] == 0xa5); +} + +int main(void) { + int receiver = socket(AF_UNIX, SOCK_DGRAM, 0); + int sender = socket(AF_UNIX, SOCK_DGRAM, 0); + assert(receiver >= 0); + assert(sender >= 0); + + struct sockaddr_storage addr; + socklen_t len = sizeof(addr); + assert(getsockname(receiver, (struct sockaddr *)&addr, &len) == 0); + struct sockaddr_un *un = (struct sockaddr_un *)&addr; + memcpy(un->sun_path, "recvfrom-receiver", sizeof("recvfrom-receiver")); + len = offsetof(struct sockaddr_un, sun_path) + strlen(un->sun_path) + 1; + assert(bind(receiver, (struct sockaddr *)&addr, len) == 0); + assert(connect(sender, (struct sockaddr *)&addr, len) == 0); + char received = 0; + assert(send(sender, "x", 1, 0) == 1); + struct sockaddr_storage from; + socklen_t from_len = sizeof(from); + assert(recvfrom(receiver, &received, 1, 0, (struct sockaddr *)&from, + &from_len) == 1); + assert(received == 'x'); + assert(send(sender, "x", 1, 0) == 1); + assert(recvfrom(receiver, &received, 1, 0, NULL, NULL) == 1); + assert(received == 'x'); + received = 0; + len = 77; + assert(send(sender, "x", 1, 0) == 1); + assert(recvfrom(receiver, &received, 1, 0, NULL, &len) == 1); + assert(len == 77); + assert(received == 'x'); + + memcpy(un->sun_path, "recvfrom-sender", sizeof("recvfrom-sender")); + len = offsetof(struct sockaddr_un, sun_path) + strlen(un->sun_path) + 1; + assert(bind(sender, (struct sockaddr *)&addr, len) == 0); + len = sizeof(addr); + assert(getsockname(sender, (struct sockaddr *)&addr, &len) == 0); + check_from(receiver, sender, &addr, len); + received = 0; + assert(send(sender, "x", 1, 0) == 1); + assert(recvfrom(receiver, &received, 1, 0, NULL, NULL) == 1); + assert(received == 'x'); + received = 0; + len = 77; + assert(send(sender, "x", 1, 0) == 1); + assert(recvfrom(receiver, &received, 1, 0, NULL, &len) == 1); + assert(len == 77); + assert(received == 'x'); + assert(close(sender) == 0); + assert(close(receiver) == 0); + assert(unlink("recvfrom-sender") == 0); + assert(unlink("recvfrom-receiver") == 0); + + return 0; +} diff --git a/tests/unit/socket_unix_name.c b/tests/unit/socket_unix_name.c index 629be9992..1b87bb3f5 100644 --- a/tests/unit/socket_unix_name.c +++ b/tests/unit/socket_unix_name.c @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -13,9 +14,16 @@ static void check_name(int fd, const char *path) { assert(full.ss_family == AF_UNIX); assert(actual >= offsetof(struct sockaddr_un, sun_path)); assert(actual < sizeof(full)); - if (path) + if (path) { + socklen_t path_len = offsetof(struct sockaddr_un, sun_path) + strlen(path); + assert(actual == path_len || actual == path_len + 1); assert(memcmp(((struct sockaddr_un *)&full)->sun_path, path, strlen(path)) == 0); + } else { + assert(actual == offsetof(struct sockaddr_un, sun_path) || + actual == sizeof(struct sockaddr)); + } + printf("%s: length %u\n", path ? "named" : "unnamed", (unsigned)actual); socklen_t capacities[] = {0, 1, 2, actual - 1, actual, actual + 1}; for (unsigned i = 0; i < sizeof(capacities) / sizeof(capacities[0]); ++i) {