From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001
From: Valentin Popov <valentin@popov.link>
Date: Fri, 19 Jul 2024 16:37:58 +0400
Subject: Deleted vendor folder
---
.../rustix/src/backend/linux_raw/net/syscalls.rs | 949 ---------------------
1 file changed, 949 deletions(-)
delete mode 100644 vendor/rustix/src/backend/linux_raw/net/syscalls.rs
(limited to 'vendor/rustix/src/backend/linux_raw/net/syscalls.rs')
diff --git a/vendor/rustix/src/backend/linux_raw/net/syscalls.rs b/vendor/rustix/src/backend/linux_raw/net/syscalls.rs
deleted file mode 100644
index 726f022..0000000
--- a/vendor/rustix/src/backend/linux_raw/net/syscalls.rs
+++ /dev/null
@@ -1,949 +0,0 @@
-//! linux_raw syscalls supporting `rustix::net`.
-//!
-//! # Safety
-//!
-//! See the `rustix::backend` module documentation for details.
-#![allow(unsafe_code, clippy::undocumented_unsafe_blocks)]
-
-use super::msghdr::{
- with_noaddr_msghdr, with_recv_msghdr, with_unix_msghdr, with_v4_msghdr, with_v6_msghdr,
-};
-use super::read_sockaddr::{initialize_family_to_unspec, maybe_read_sockaddr_os, read_sockaddr_os};
-use super::send_recv::{RecvFlags, SendFlags};
-use super::write_sockaddr::{encode_sockaddr_v4, encode_sockaddr_v6};
-use crate::backend::c;
-use crate::backend::conv::{
- by_mut, by_ref, c_int, c_uint, pass_usize, ret, ret_owned_fd, ret_usize, size_of, slice,
- socklen_t, zero,
-};
-use crate::fd::{BorrowedFd, OwnedFd};
-use crate::io::{self, IoSlice, IoSliceMut};
-use crate::net::{
- AddressFamily, Protocol, RecvAncillaryBuffer, RecvMsgReturn, SendAncillaryBuffer, Shutdown,
- SocketAddrAny, SocketAddrUnix, SocketAddrV4, SocketAddrV6, SocketFlags, SocketType,
-};
-use c::{sockaddr, sockaddr_in, sockaddr_in6, socklen_t};
-use core::mem::MaybeUninit;
-#[cfg(target_arch = "x86")]
-use {
- crate::backend::conv::{slice_just_addr, x86_sys},
- crate::backend::reg::{ArgReg, SocketArg},
- linux_raw_sys::net::{
- SYS_ACCEPT, SYS_ACCEPT4, SYS_BIND, SYS_CONNECT, SYS_GETPEERNAME, SYS_GETSOCKNAME,
- SYS_LISTEN, SYS_RECV, SYS_RECVFROM, SYS_RECVMSG, SYS_SEND, SYS_SENDMSG, SYS_SENDTO,
- SYS_SHUTDOWN, SYS_SOCKET, SYS_SOCKETPAIR,
- },
-};
-
-#[inline]
-pub(crate) fn socket(
- family: AddressFamily,
- type_: SocketType,
- protocol: Option<Protocol>,
-) -> io::Result<OwnedFd> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret_owned_fd(syscall_readonly!(__NR_socket, family, type_, protocol))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret_owned_fd(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_SOCKET),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- family.into(),
- type_.into(),
- protocol.into(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn socket_with(
- family: AddressFamily,
- type_: SocketType,
- flags: SocketFlags,
- protocol: Option<Protocol>,
-) -> io::Result<OwnedFd> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret_owned_fd(syscall_readonly!(
- __NR_socket,
- family,
- (type_, flags),
- protocol
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret_owned_fd(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_SOCKET),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- family.into(),
- (type_, flags).into(),
- protocol.into(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn socketpair(
- family: AddressFamily,
- type_: SocketType,
- flags: SocketFlags,
- protocol: Option<Protocol>,
-) -> io::Result<(OwnedFd, OwnedFd)> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
- ret(syscall!(
- __NR_socketpair,
- family,
- (type_, flags),
- protocol,
- &mut result
- ))?;
- let [fd0, fd1] = result.assume_init();
- Ok((fd0, fd1))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- let mut result = MaybeUninit::<[OwnedFd; 2]>::uninit();
- ret(syscall!(
- __NR_socketcall,
- x86_sys(SYS_SOCKETPAIR),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- family.into(),
- (type_, flags).into(),
- protocol.into(),
- (&mut result).into(),
- ])
- ))?;
- let [fd0, fd1] = result.assume_init();
- Ok((fd0, fd1))
- }
-}
-
-#[inline]
-pub(crate) fn accept(fd: BorrowedFd<'_>) -> io::Result<OwnedFd> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- let fd = ret_owned_fd(syscall_readonly!(__NR_accept, fd, zero(), zero()))?;
- Ok(fd)
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- let fd = ret_owned_fd(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_ACCEPT),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[fd.into(), zero(), zero()])
- ))?;
- Ok(fd)
- }
-}
-
-#[inline]
-pub(crate) fn accept_with(fd: BorrowedFd<'_>, flags: SocketFlags) -> io::Result<OwnedFd> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- let fd = ret_owned_fd(syscall_readonly!(__NR_accept4, fd, zero(), zero(), flags))?;
- Ok(fd)
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- let fd = ret_owned_fd(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_ACCEPT4),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[fd.into(), zero(), zero(), flags.into()])
- ))?;
- Ok(fd)
- }
-}
-
-#[inline]
-pub(crate) fn acceptfrom(fd: BorrowedFd<'_>) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
- let fd = ret_owned_fd(syscall!(
- __NR_accept,
- fd,
- &mut storage,
- by_mut(&mut addrlen)
- ))?;
- Ok((
- fd,
- maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
- let fd = ret_owned_fd(syscall!(
- __NR_socketcall,
- x86_sys(SYS_ACCEPT),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- (&mut storage).into(),
- by_mut(&mut addrlen),
- ])
- ))?;
- Ok((
- fd,
- maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
- ))
- }
-}
-
-#[inline]
-pub(crate) fn acceptfrom_with(
- fd: BorrowedFd<'_>,
- flags: SocketFlags,
-) -> io::Result<(OwnedFd, Option<SocketAddrAny>)> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
- let fd = ret_owned_fd(syscall!(
- __NR_accept4,
- fd,
- &mut storage,
- by_mut(&mut addrlen),
- flags
- ))?;
- Ok((
- fd,
- maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
- let fd = ret_owned_fd(syscall!(
- __NR_socketcall,
- x86_sys(SYS_ACCEPT4),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- (&mut storage).into(),
- by_mut(&mut addrlen),
- flags.into(),
- ])
- ))?;
- Ok((
- fd,
- maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
- ))
- }
-}
-
-#[inline]
-pub(crate) fn recvmsg(
- sockfd: BorrowedFd<'_>,
- iov: &mut [IoSliceMut<'_>],
- control: &mut RecvAncillaryBuffer<'_>,
- msg_flags: RecvFlags,
-) -> io::Result<RecvMsgReturn> {
- let mut storage = MaybeUninit::<c::sockaddr_storage>::uninit();
-
- with_recv_msghdr(&mut storage, iov, control, |msghdr| {
- #[cfg(not(target_arch = "x86"))]
- let result =
- unsafe { ret_usize(syscall!(__NR_recvmsg, sockfd, by_mut(msghdr), msg_flags)) };
-
- #[cfg(target_arch = "x86")]
- let result = unsafe {
- ret_usize(syscall!(
- __NR_socketcall,
- x86_sys(SYS_RECVMSG),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- sockfd.into(),
- by_mut(msghdr),
- msg_flags.into(),
- ])
- ))
- };
-
- result.map(|bytes| {
- // Get the address of the sender, if any.
- let addr =
- unsafe { maybe_read_sockaddr_os(msghdr.msg_name as _, msghdr.msg_namelen as _) };
-
- RecvMsgReturn {
- bytes,
- address: addr,
- flags: RecvFlags::from_bits_retain(msghdr.msg_flags),
- }
- })
- })
-}
-
-#[inline]
-pub(crate) fn sendmsg(
- sockfd: BorrowedFd<'_>,
- iov: &[IoSlice<'_>],
- control: &mut SendAncillaryBuffer<'_, '_, '_>,
- msg_flags: SendFlags,
-) -> io::Result<usize> {
- with_noaddr_msghdr(iov, control, |msghdr| {
- #[cfg(not(target_arch = "x86"))]
- let result =
- unsafe { ret_usize(syscall!(__NR_sendmsg, sockfd, by_ref(&msghdr), msg_flags)) };
-
- #[cfg(target_arch = "x86")]
- let result = unsafe {
- ret_usize(syscall!(
- __NR_socketcall,
- x86_sys(SYS_SENDMSG),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- sockfd.into(),
- by_ref(&msghdr),
- msg_flags.into()
- ])
- ))
- };
-
- result
- })
-}
-
-#[inline]
-pub(crate) fn sendmsg_v4(
- sockfd: BorrowedFd<'_>,
- addr: &SocketAddrV4,
- iov: &[IoSlice<'_>],
- control: &mut SendAncillaryBuffer<'_, '_, '_>,
- msg_flags: SendFlags,
-) -> io::Result<usize> {
- with_v4_msghdr(addr, iov, control, |msghdr| {
- #[cfg(not(target_arch = "x86"))]
- let result =
- unsafe { ret_usize(syscall!(__NR_sendmsg, sockfd, by_ref(&msghdr), msg_flags)) };
-
- #[cfg(target_arch = "x86")]
- let result = unsafe {
- ret_usize(syscall!(
- __NR_socketcall,
- x86_sys(SYS_SENDMSG),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- sockfd.into(),
- by_ref(&msghdr),
- msg_flags.into(),
- ])
- ))
- };
-
- result
- })
-}
-
-#[inline]
-pub(crate) fn sendmsg_v6(
- sockfd: BorrowedFd<'_>,
- addr: &SocketAddrV6,
- iov: &[IoSlice<'_>],
- control: &mut SendAncillaryBuffer<'_, '_, '_>,
- msg_flags: SendFlags,
-) -> io::Result<usize> {
- with_v6_msghdr(addr, iov, control, |msghdr| {
- #[cfg(not(target_arch = "x86"))]
- let result =
- unsafe { ret_usize(syscall!(__NR_sendmsg, sockfd, by_ref(&msghdr), msg_flags)) };
-
- #[cfg(target_arch = "x86")]
- let result = unsafe {
- ret_usize(syscall!(
- __NR_socketcall,
- x86_sys(SYS_SENDMSG),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- sockfd.into(),
- by_ref(&msghdr),
- msg_flags.into()
- ])
- ))
- };
-
- result
- })
-}
-
-#[inline]
-pub(crate) fn sendmsg_unix(
- sockfd: BorrowedFd<'_>,
- addr: &SocketAddrUnix,
- iov: &[IoSlice<'_>],
- control: &mut SendAncillaryBuffer<'_, '_, '_>,
- msg_flags: SendFlags,
-) -> io::Result<usize> {
- with_unix_msghdr(addr, iov, control, |msghdr| {
- #[cfg(not(target_arch = "x86"))]
- let result =
- unsafe { ret_usize(syscall!(__NR_sendmsg, sockfd, by_ref(&msghdr), msg_flags)) };
-
- #[cfg(target_arch = "x86")]
- let result = unsafe {
- ret_usize(syscall!(
- __NR_socketcall,
- x86_sys(SYS_SENDMSG),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- sockfd.into(),
- by_ref(&msghdr),
- msg_flags.into()
- ])
- ))
- };
-
- result
- })
-}
-
-#[inline]
-pub(crate) fn shutdown(fd: BorrowedFd<'_>, how: Shutdown) -> io::Result<()> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(
- __NR_shutdown,
- fd,
- c_uint(how as c::c_uint)
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_SHUTDOWN),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[fd.into(), c_uint(how as c::c_uint)])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn send(fd: BorrowedFd<'_>, buf: &[u8], flags: SendFlags) -> io::Result<usize> {
- let (buf_addr, buf_len) = slice(buf);
-
- #[cfg(not(any(
- target_arch = "aarch64",
- target_arch = "mips64",
- target_arch = "mips64r6",
- target_arch = "riscv64",
- target_arch = "x86",
- target_arch = "x86_64",
- )))]
- unsafe {
- ret_usize(syscall_readonly!(__NR_send, fd, buf_addr, buf_len, flags))
- }
- #[cfg(any(
- target_arch = "aarch64",
- target_arch = "mips64",
- target_arch = "mips64r6",
- target_arch = "riscv64",
- target_arch = "x86_64",
- ))]
- unsafe {
- ret_usize(syscall_readonly!(
- __NR_sendto,
- fd,
- buf_addr,
- buf_len,
- flags,
- zero(),
- zero()
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret_usize(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_SEND),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- buf_addr,
- buf_len,
- flags.into()
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn sendto_v4(
- fd: BorrowedFd<'_>,
- buf: &[u8],
- flags: SendFlags,
- addr: &SocketAddrV4,
-) -> io::Result<usize> {
- let (buf_addr, buf_len) = slice(buf);
-
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret_usize(syscall_readonly!(
- __NR_sendto,
- fd,
- buf_addr,
- buf_len,
- flags,
- by_ref(&encode_sockaddr_v4(addr)),
- size_of::<sockaddr_in, _>()
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret_usize(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_SENDTO),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- buf_addr,
- buf_len,
- flags.into(),
- by_ref(&encode_sockaddr_v4(addr)),
- size_of::<sockaddr_in, _>(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn sendto_v6(
- fd: BorrowedFd<'_>,
- buf: &[u8],
- flags: SendFlags,
- addr: &SocketAddrV6,
-) -> io::Result<usize> {
- let (buf_addr, buf_len) = slice(buf);
-
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret_usize(syscall_readonly!(
- __NR_sendto,
- fd,
- buf_addr,
- buf_len,
- flags,
- by_ref(&encode_sockaddr_v6(addr)),
- size_of::<sockaddr_in6, _>()
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret_usize(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_SENDTO),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- buf_addr,
- buf_len,
- flags.into(),
- by_ref(&encode_sockaddr_v6(addr)),
- size_of::<sockaddr_in6, _>(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn sendto_unix(
- fd: BorrowedFd<'_>,
- buf: &[u8],
- flags: SendFlags,
- addr: &SocketAddrUnix,
-) -> io::Result<usize> {
- let (buf_addr, buf_len) = slice(buf);
-
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret_usize(syscall_readonly!(
- __NR_sendto,
- fd,
- buf_addr,
- buf_len,
- flags,
- by_ref(&addr.unix),
- socklen_t(addr.addr_len())
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret_usize(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_SENDTO),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- buf_addr,
- buf_len,
- flags.into(),
- by_ref(&addr.unix),
- socklen_t(addr.addr_len()),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) unsafe fn recv(
- fd: BorrowedFd<'_>,
- buf: *mut u8,
- len: usize,
- flags: RecvFlags,
-) -> io::Result<usize> {
- #[cfg(not(any(
- target_arch = "aarch64",
- target_arch = "mips64",
- target_arch = "mips64r6",
- target_arch = "riscv64",
- target_arch = "x86",
- target_arch = "x86_64",
- )))]
- {
- ret_usize(syscall!(__NR_recv, fd, buf, pass_usize(len), flags))
- }
- #[cfg(any(
- target_arch = "aarch64",
- target_arch = "mips64",
- target_arch = "mips64r6",
- target_arch = "riscv64",
- target_arch = "x86_64",
- ))]
- {
- ret_usize(syscall!(
- __NR_recvfrom,
- fd,
- buf,
- pass_usize(len),
- flags,
- zero(),
- zero()
- ))
- }
- #[cfg(target_arch = "x86")]
- {
- ret_usize(syscall!(
- __NR_socketcall,
- x86_sys(SYS_RECV),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- buf.into(),
- pass_usize(len),
- flags.into(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) unsafe fn recvfrom(
- fd: BorrowedFd<'_>,
- buf: *mut u8,
- len: usize,
- flags: RecvFlags,
-) -> io::Result<(usize, Option<SocketAddrAny>)> {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
-
- // `recvfrom` does not write to the storage if the socket is
- // connection-oriented sockets, so we initialize the family field to
- // `AF_UNSPEC` so that we can detect this case.
- initialize_family_to_unspec(storage.as_mut_ptr());
-
- #[cfg(not(target_arch = "x86"))]
- let nread = ret_usize(syscall!(
- __NR_recvfrom,
- fd,
- buf,
- pass_usize(len),
- flags,
- &mut storage,
- by_mut(&mut addrlen)
- ))?;
- #[cfg(target_arch = "x86")]
- let nread = ret_usize(syscall!(
- __NR_socketcall,
- x86_sys(SYS_RECVFROM),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- buf.into(),
- pass_usize(len),
- flags.into(),
- (&mut storage).into(),
- by_mut(&mut addrlen),
- ])
- ))?;
-
- Ok((
- nread,
- maybe_read_sockaddr_os(&storage.assume_init(), addrlen.try_into().unwrap()),
- ))
-}
-
-#[inline]
-pub(crate) fn getpeername(fd: BorrowedFd<'_>) -> io::Result<Option<SocketAddrAny>> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
- ret(syscall!(
- __NR_getpeername,
- fd,
- &mut storage,
- by_mut(&mut addrlen)
- ))?;
- Ok(maybe_read_sockaddr_os(
- &storage.assume_init(),
- addrlen.try_into().unwrap(),
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
- ret(syscall!(
- __NR_socketcall,
- x86_sys(SYS_GETPEERNAME),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- (&mut storage).into(),
- by_mut(&mut addrlen),
- ])
- ))?;
- Ok(maybe_read_sockaddr_os(
- &storage.assume_init(),
- addrlen.try_into().unwrap(),
- ))
- }
-}
-
-#[inline]
-pub(crate) fn getsockname(fd: BorrowedFd<'_>) -> io::Result<SocketAddrAny> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
- ret(syscall!(
- __NR_getsockname,
- fd,
- &mut storage,
- by_mut(&mut addrlen)
- ))?;
- Ok(read_sockaddr_os(
- &storage.assume_init(),
- addrlen.try_into().unwrap(),
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- let mut addrlen = core::mem::size_of::<sockaddr>() as socklen_t;
- let mut storage = MaybeUninit::<sockaddr>::uninit();
- ret(syscall!(
- __NR_socketcall,
- x86_sys(SYS_GETSOCKNAME),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- (&mut storage).into(),
- by_mut(&mut addrlen),
- ])
- ))?;
- Ok(read_sockaddr_os(
- &storage.assume_init(),
- addrlen.try_into().unwrap(),
- ))
- }
-}
-
-#[inline]
-pub(crate) fn bind_v4(fd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(
- __NR_bind,
- fd,
- by_ref(&encode_sockaddr_v4(addr)),
- size_of::<sockaddr_in, _>()
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_BIND),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- by_ref(&encode_sockaddr_v4(addr)),
- size_of::<sockaddr_in, _>(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn bind_v6(fd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(
- __NR_bind,
- fd,
- by_ref(&encode_sockaddr_v6(addr)),
- size_of::<sockaddr_in6, _>()
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_BIND),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- by_ref(&encode_sockaddr_v6(addr)),
- size_of::<sockaddr_in6, _>(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn bind_unix(fd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(
- __NR_bind,
- fd,
- by_ref(&addr.unix),
- socklen_t(addr.addr_len())
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_BIND),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- by_ref(&addr.unix),
- socklen_t(addr.addr_len()),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn connect_v4(fd: BorrowedFd<'_>, addr: &SocketAddrV4) -> io::Result<()> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(
- __NR_connect,
- fd,
- by_ref(&encode_sockaddr_v4(addr)),
- size_of::<sockaddr_in, _>()
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_CONNECT),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- by_ref(&encode_sockaddr_v4(addr)),
- size_of::<sockaddr_in, _>(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn connect_v6(fd: BorrowedFd<'_>, addr: &SocketAddrV6) -> io::Result<()> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(
- __NR_connect,
- fd,
- by_ref(&encode_sockaddr_v6(addr)),
- size_of::<sockaddr_in6, _>()
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_CONNECT),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- by_ref(&encode_sockaddr_v6(addr)),
- size_of::<sockaddr_in6, _>(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn connect_unix(fd: BorrowedFd<'_>, addr: &SocketAddrUnix) -> io::Result<()> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(
- __NR_connect,
- fd,
- by_ref(&addr.unix),
- socklen_t(addr.addr_len())
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_CONNECT),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- by_ref(&addr.unix),
- socklen_t(addr.addr_len()),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn connect_unspec(fd: BorrowedFd<'_>) -> io::Result<()> {
- debug_assert_eq!(c::AF_UNSPEC, 0);
- let addr = MaybeUninit::<c::sockaddr_storage>::zeroed();
-
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(
- __NR_connect,
- fd,
- by_ref(&addr),
- size_of::<c::sockaddr_storage, _>()
- ))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_CONNECT),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[
- fd.into(),
- by_ref(&addr),
- size_of::<c::sockaddr_storage, _>(),
- ])
- ))
- }
-}
-
-#[inline]
-pub(crate) fn listen(fd: BorrowedFd<'_>, backlog: c::c_int) -> io::Result<()> {
- #[cfg(not(target_arch = "x86"))]
- unsafe {
- ret(syscall_readonly!(__NR_listen, fd, c_int(backlog)))
- }
- #[cfg(target_arch = "x86")]
- unsafe {
- ret(syscall_readonly!(
- __NR_socketcall,
- x86_sys(SYS_LISTEN),
- slice_just_addr::<ArgReg<'_, SocketArg>, _>(&[fd.into(), c_int(backlog)])
- ))
- }
-}
--
cgit v1.2.3