blob: 03c1fc4059b06b657748dcfef5b3593979a231af [file]
// SPDX-License-Identifier: MPL-2.0 OR LGPL-3.0-or-later
/*
* libpathrs: safe path resolution on Linux
* Copyright (C) 2019-2025 SUSE LLC
* Copyright (C) 2026 Aleksa Sarai <cyphar@cyphar.com>
*
* == MPL-2.0 ==
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/.
*
* Alternatively, this Source Code Form may also (at your option) be used
* under the terms of the GNU Lesser General Public License Version 3, as
* described below:
*
* == LGPL-3.0-or-later ==
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or (at
* your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
* Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use crate::error::{Error, ErrorImpl};
use std::{
any,
cmp::{self, Ordering},
ffi::{CStr, CString, OsStr},
marker::PhantomData,
mem,
os::unix::{
ffi::OsStrExt,
io::{AsRawFd, BorrowedFd, RawFd},
},
path::Path,
ptr, slice,
};
use bytemuck::{NoUninit, Pod};
use libc::{c_char, c_int, size_t};
/// Generate `.symver` entries for a given function.
///
/// On platforms without stabilised `global_asm!` implementations, this macro is
/// a no-op but will eventually work once they are supported.
///
/// ```ignore
/// # use pathrs::capi::utils::symver;
/// // Create a symbol version with the same name.
/// #[no_mangle]
/// fn foo_bar(a: u64) -> u64 { a + 32 }
/// symver!{
/// fn foo_bar <- (foo_bar, version = "LIBFOO_2.0", default);
/// }
/// // Create a compatibility symbol with a different name. In this case, you
/// // should actually name the implementation function something like __foo_v1
/// // because the symbol will still be public (still unclear why...).
/// fn __foo_bar_v1(a: u64) -> u64 { a + 16 }
/// symver!{
/// #[cfg(feature = "v1_compat")] // meta attributes work
/// fn __foo_bar_v1 <- (foo_bar, version = "LIBFOO_1.0");
/// }
/// ```
macro_rules! symver {
() => {};
(@with-meta $(#[$meta:meta])* $($block:tt)+) => {
// Only generate .symver entries for cdylib.
#[cfg(cdylib)]
// Some architectures still have unstable ASM, which stops us from
// injecting the ".symver" section. You can see the list in
// LoweringContext::lower_inline_asm (compiler/rustc_asm_lowering).
#[cfg(any(
target_arch = "arm",
target_arch = "aarch64",
target_arch = "x86",
target_arch = "x86_64",
target_arch = "riscv32",
target_arch = "riscv64",
// These are only supported after our MSRV and have corresponding
// #[rustversion::since(1.XY)] tags below.
target_arch = "loongarch64",
target_arch = "arm64ec",
target_arch = "s390x",
target_arch = "loongarch32",
// TODO: Once stabilised, add these arches:
//target_arch = "powerpc",
//target_arch = "powerpc64",
//target_arch = "sparc64",
))]
#[cfg_attr(target_arch = "loongarch64", ::rustversion::since(1.72))]
#[cfg_attr(target_arch = "arm64ec", ::rustversion::since(1.84))]
#[cfg_attr(target_arch = "s390x", ::rustversion::since(1.84))]
#[cfg_attr(target_arch = "loongarch32", ::rustversion::since(1.91))]
$(#[$meta])*
$($block)*
};
($(#[$meta:meta])* fn $implsym:ident <- ($symname:ident, version = $version:literal); $($tail:tt)*) => {
$crate::capi::utils::symver! {
@with-meta $(#[$meta])*
// .symver $implsym, $symname@$version
::std::arch::global_asm! {concat!(
".symver ",
stringify!($implsym),
", ",
stringify!($symname),
"@",
$version,
)}
}
$crate::capi::utils::symver! { $($tail)* }
};
($(#[$meta:meta])* fn $implsym:ident <- ($symname:ident, version = $version:literal, default); $($tail:tt)*) => {
$crate::capi::utils::symver! {
@with-meta $(#[$meta])*
// .symver $implsym, $symname@@$version
::std::arch::global_asm! {concat!(
".symver ",
stringify!($implsym),
", ",
stringify!($symname),
"@@",
$version,
)}
}
$crate::capi::utils::symver! { $($tail)* }
};
}
pub(crate) use symver;
/// Equivalent to [`BorrowedFd`], except that there are no restrictions on what
/// value the inner [`RawFd`] can take. This is necessary because C callers
/// could reasonably pass `-1` as a file descriptor value and we need to verify
/// that the value is valid to avoid UB.
///
/// This type is FFI-safe and is intended for use in `extern "C" fn` signatures.
/// While [`BorrowedFd`] (and `Option<BorrowedFd>`) are technically FFI-safe,
/// apparently using them in `extern "C" fn` signatures directly is not
/// recommended for the above reason.
#[derive(PartialEq, Eq, Debug, Copy, Clone)]
#[repr(transparent)]
pub struct CBorrowedFd<'fd> {
inner: RawFd,
_phantom: PhantomData<BorrowedFd<'fd>>,
}
impl<'fd> CBorrowedFd<'fd> {
/// Construct a [`CBorrowedFd`] in a `const`-friendly context.
///
/// # Safety
/// The caller guarantees that the file descriptor will live long enough for
/// the returned lifetime `'fd`.
pub(crate) const unsafe fn from_raw_fd(fd: RawFd) -> Self {
Self {
inner: fd,
_phantom: PhantomData,
}
}
/// Take a [`CBorrowedFd`] from C FFI and convert it to a proper
/// [`BorrowedFd`] after making sure that it has a valid value (ie. is not
/// negative).
pub(crate) fn try_as_borrowed_fd(&self) -> Result<BorrowedFd<'fd>, Error> {
// TODO: We might want to support AT_FDCWD in the future. The
// openat2 resolver handles it correctly, but the O_PATH
// resolver and try_clone() probably need some work.
// MSRV(1.66): Use match ..0?
if self.inner.is_negative() {
Err(ErrorImpl::InvalidArgument {
// TODO: Should this error be EBADF?
name: "fd".into(),
description: "passed file descriptors must not be negative".into(),
}
.into())
} else {
// SAFETY: The C caller guarantees that the file descriptor is valid
// for the lifetime of CBorrowedFd (which is the same lifetime as
// BorrowedFd). We verify that the file descriptor is not negative,
// so it is definitely valid.
Ok(unsafe { BorrowedFd::borrow_raw(self.inner) })
}
}
}
impl<'fd> AsRawFd for CBorrowedFd<'fd> {
fn as_raw_fd(&self) -> RawFd {
self.inner
}
}
impl<'fd> From<BorrowedFd<'fd>> for CBorrowedFd<'fd> {
fn from(fd: BorrowedFd<'_>) -> CBorrowedFd<'_> {
CBorrowedFd {
inner: fd.as_raw_fd(),
_phantom: PhantomData,
}
}
}
// TODO: An AsFd impl would be even nicer but I suspect the lifetimes can't be
// expressed.
pub(crate) unsafe fn parse_path<'a>(path: *const c_char) -> Result<&'a Path, Error> {
if path.is_null() {
Err(ErrorImpl::InvalidArgument {
name: "path".into(),
description: "cannot be NULL".into(),
})?
}
// SAFETY: C caller guarantees that the path is a valid C-style string.
let bytes = unsafe { CStr::from_ptr(path) }.to_bytes();
Ok(OsStr::from_bytes(bytes).as_ref())
}
pub(crate) unsafe fn copy_path_into_buffer(
path: impl AsRef<Path>,
buf: *mut c_char,
bufsize: size_t,
) -> Result<c_int, Error> {
let path = CString::new(path.as_ref().as_os_str().as_bytes())
.expect("link from readlink should not contain any nulls");
// MSRV(1.79): Switch to .count_bytes().
let path_len = path.to_bytes().len();
// If the linkbuf is null, we just return the number of bytes we
// would've written.
if !buf.is_null() && bufsize > 0 {
// SAFETY: The C caller guarantees that buf is safe to write to
// up to bufsize bytes.
unsafe {
let to_copy = cmp::min(path_len, bufsize);
ptr::copy_nonoverlapping(path.as_ptr(), buf, to_copy);
}
}
Ok(path_len as c_int)
}
pub(crate) unsafe fn copy_from_extensible_struct<T: Pod>(
ptr: *const T,
size: usize,
) -> Result<T, Error> {
// SAFETY: The C caller guarantees that ptr is from a single allocation, is
// aligned for a u8 slice (generally true for all arrays), and is at least
// size bytes in length.
let raw_data = unsafe { slice::from_raw_parts(ptr as *const u8, size) };
let struct_size = mem::size_of::<T>();
// We may need to make a copy if the structure is smaller than sizeof(T) to
// zero-pad it, and the Vec needs to live for the rest of this function.
#[allow(unused_assignments)] // only needed for storage
let mut struct_data_buf: Option<Vec<u8>> = None;
// MSRV(1.80): Use slice::split_at_checked()?
let (struct_data, trailing) = if raw_data.len() >= struct_size {
raw_data.split_at(struct_size)
} else {
let mut buf = vec![0u8; struct_size];
buf[0..raw_data.len()].copy_from_slice(raw_data);
struct_data_buf = Some(buf);
(
&struct_data_buf
.as_ref()
.expect("Option just assigned with Some must contain Some")[..],
&[][..],
)
};
debug_assert!(
struct_data.len() == struct_size,
"copy_from_extensible_struct should compute the struct size correctly"
);
// TODO: Can we get an optimised memchr_inv implementation? Unfortunately,
// see <https://github.com/BurntSushi/memchr/issues/166> -- memchr doesn't
// have this and is unlikely to have it in the future.
if trailing.iter().any(|&ch| ch != 0) {
return Err(ErrorImpl::UnsupportedStructureData {
name: format!("c struct {}", any::type_name::<T>()).into(),
}
.into());
}
// NOTE: Even though we have a slice, we can only be sure it's aligned to u8
// (i.e., any alignment). It's better to just return a copy than error out
// in the non-aligned case...
bytemuck::try_pod_read_unaligned(struct_data).map_err(|err| {
ErrorImpl::BytemuckPodCastError {
description: format!("cannot cast passed buffer into {}", any::type_name::<T>()).into(),
source: err,
}
.into()
})
}
/// Copy a `repr(C)` extensible structure to a buffer owned by a C caller. If
/// the C caller's buffer is larger than the library type, the trailing bytes
/// will be zero-filled. If the library type is larger than the C callers buffer
/// and the trailing portion contains non-zero bytes, `Ok(true)` is returned to
/// indicate the data was truncated.
pub(crate) unsafe fn copy_into_extensible_struct<T: NoUninit>(
dst: *mut T,
dst_size: usize,
src: &T,
) -> Result<bool, Error> {
let raw_src = bytemuck::bytes_of(src);
if dst.is_null() {
if dst_size > 0 {
Err(ErrorImpl::InvalidArgument {
name: "dst".into(),
description: "cannot be NULL with non-zero buffer size".into(),
})?
}
// Pretend we "truncated" at size 0.
return Ok(raw_src.iter().any(|&b| b != 0u8));
}
// SAFETY: The C caller guarantees that dst is from a single allocation, is
// aligned for a u8 slice (generally true for all arrays) and is at least
// dst_size bytes in length.
let dst_buffer = unsafe { slice::from_raw_parts_mut(dst as *mut u8, dst_size) };
let struct_size = mem::size_of::<T>();
let to_copy = cmp::min(dst_size, struct_size);
let rest = to_copy..;
// Copy the common bytes.
dst_buffer[..to_copy].copy_from_slice(&raw_src[..to_copy]);
Ok(match dst_size.cmp(&struct_size) {
// (dst_size < struct_size)
Ordering::Less => {
// Were there any non-zero bytes we just truncated?
raw_src[rest].iter().any(|&b| b != 0u8)
}
// (dst_size > struct_size)
Ordering::Greater => {
// Clear any trailing bytes.
bytemuck::fill_zeroes(&mut dst_buffer[rest]);
false
}
// (dst_size == struct_size)
Ordering::Equal => false, // nothing truncated
})
}
pub(crate) trait Leakable: Sized {
/// Leak a structure such that it can be passed through C-FFI.
fn leak(self) -> &'static mut Self {
Box::leak(Box::new(self))
}
/// Given a structure leaked through Leakable::leak, un-leak it.
///
/// SAFETY: Callers must be sure to only ever call this once on a given
/// pointer (otherwise memory corruption will occur).
unsafe fn unleak(&'static mut self) -> Self {
// SAFETY: Box::from_raw is safe because the caller guarantees that
// the pointer we get is the same one we gave them, and it will only
// ever be called once with the same pointer.
*unsafe { Box::from_raw(self as *mut Self) }
}
/// Shorthand for `std::mem::drop(self.unleak())`.
///
/// SAFETY: Same unsafety issue as `self.unleak()`.
unsafe fn free(&'static mut self) {
// SAFETY: Caller guarantees this is safe to do.
let _ = unsafe { self.unleak() };
// drop Self
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error::ErrorKind;
use bytemuck::{Pod, Zeroable};
use pretty_assertions::assert_eq;
#[derive(PartialEq, Eq, Default, Debug, Clone, Copy, Pod, Zeroable)]
#[repr(C)]
struct Struct {
foo: u64,
bar: u32,
baz: u32,
}
/// Wrap a structure and ensure that operations on it do not write outside
/// of its bounds. This is checked on `Drop` but can also be manually
/// checked with [`assert`][Self::assert].
#[derive(Debug, Clone)]
#[repr(C)]
struct Guarded<T> {
guard_before: [u8; 16],
data: T,
guard_after: [u8; 16],
}
impl<T> Guarded<T> {
const GUARD_DATA: [u8; 16] = [0xa5; 16];
fn new(data: T) -> Self {
Self {
guard_before: Self::GUARD_DATA,
data,
guard_after: Self::GUARD_DATA,
}
}
fn assert(&self) {
assert_eq!(
self.guard_before,
Self::GUARD_DATA,
"guard_before was modified",
);
assert_eq!(
self.guard_after,
Self::GUARD_DATA,
"guard_after was modified",
);
}
}
impl<T> Drop for Guarded<T> {
fn drop(&mut self) {
// Don't mask an existing panic.
if !std::thread::panicking() {
self.assert();
}
}
}
#[test]
fn from_extensible_struct() {
let example = Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
};
assert_eq!(
unsafe {
copy_from_extensible_struct(&example as *const Struct, mem::size_of::<Struct>())
}
.expect("copy_from_extensible_struct with size=sizeof(struct)"),
example,
"copy_from_extensible_struct(struct, sizeof(struct))",
);
}
#[test]
fn from_extensible_struct_short() {
let example = Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
};
assert_eq!(
unsafe { copy_from_extensible_struct(&example as *const Struct, 0) }
.expect("copy_from_extensible_struct with size=0"),
Struct::default(),
"copy_from_extensible_struct(struct, 0)",
);
assert_eq!(
unsafe {
copy_from_extensible_struct(
&example as *const Struct,
bytemuck::offset_of!(Struct, bar),
)
}
.expect("copy_from_extensible_struct with size=offsetof(struct.bar)"),
Struct {
foo: example.foo,
..Default::default()
},
"copy_from_extensible_struct(struct, offsetof(struct, bar))",
);
assert_eq!(
unsafe {
copy_from_extensible_struct(
&example as *const Struct,
bytemuck::offset_of!(Struct, baz),
)
}
.expect("copy_from_extensible_struct with size=offsetof(struct.baz)"),
Struct {
foo: example.foo,
bar: example.bar,
..Default::default()
},
"copy_from_extensible_struct(struct, offsetof(struct, bar))",
);
}
#[test]
fn from_extensible_struct_long() {
#[repr(C)]
#[derive(PartialEq, Eq, Default, Debug, Clone, Copy, Pod, Zeroable)]
struct StructV2 {
inner: Struct,
extra: u64,
}
let example_compatible = StructV2 {
inner: Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
},
extra: 0,
};
assert_eq!(
unsafe {
copy_from_extensible_struct(
&example_compatible as *const StructV2 as *const Struct,
mem::size_of::<StructV2>(),
)
}
.expect("copy_from_extensible_struct with size=sizeof(structv2)"),
example_compatible.inner,
"copy_from_extensible_struct(structv2, sizeof(structv2)) with only trailing zero bytes",
);
let example_compatible = StructV2 {
inner: Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
},
extra: 0x1,
};
assert_eq!(
unsafe {
copy_from_extensible_struct(
&example_compatible as *const StructV2 as *const Struct,
mem::size_of::<StructV2>(),
)
}
.map_err(|err| err.kind()),
Err(ErrorKind::UnsupportedStructureData),
"copy_from_extensible_struct(structv2, sizeof(structv2)) with trailing non-zero bytes",
);
}
#[test]
fn into_extensible_struct() {
let example = Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
};
let mut guarded = Guarded::new(Struct::default());
assert_eq!(
unsafe {
copy_into_extensible_struct(
&mut guarded.data as *mut Struct,
mem::size_of::<Struct>(),
&example,
)
}
.expect("copy_into_extensible_struct with dst_size=sizeof(struct)"),
false,
"copy_into_extensible_struct(struct, sizeof(struct)) should not be truncated",
);
assert_eq!(
guarded.data, example,
"copy_into_extensible_struct(struct, sizeof(struct)) should write the full struct",
);
}
#[test]
fn into_extensible_struct_short() {
let example = Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
};
let sentinel_dst = Struct {
foo: 0xaaaaaaaaaaaaaaaa,
bar: 0xbbbbbbbb,
baz: 0xcccccccc,
};
// Short size (one field) with non-zero trailing data should not
// overwrite later fields and returns Ok(true) to indicate that non-zero
// data was truncated.
let mut guarded = Guarded::new(sentinel_dst);
assert_eq!(
unsafe {
copy_into_extensible_struct(
&mut guarded.data as *mut Struct,
bytemuck::offset_of!(Struct, bar),
&example,
)
}
.expect("copy_into_extensible_struct with dst_size=offsetof(struct, bar)"),
true,
"copy_into_extensible_struct(struct, offsetof(struct, bar)) with non-zero src trailing should be truncated",
);
assert_eq!(
guarded.data,
Struct {
foo: example.foo,
bar: sentinel_dst.bar,
baz: sentinel_dst.baz,
},
"copy_into_extensible_struct(struct, offsetof(struct, bar)) should only write foo, leaving trailing dst bytes untouched",
);
guarded.assert();
// Short size (two fields) with non-zero trailing data should not
// overwrite later fields and returns Ok(true) to indicate that non-zero
// data was truncated.
let mut guarded = Guarded::new(sentinel_dst);
assert_eq!(
unsafe {
copy_into_extensible_struct(
&mut guarded.data as *mut Struct,
bytemuck::offset_of!(Struct, baz),
&example,
)
}
.expect("copy_into_extensible_struct with dst_size=offsetof(struct.baz)"),
true,
"copy_into_extensible_struct(struct, offsetof(struct.baz)) with non-zero src trailing should be truncated",
);
assert_eq!(
guarded.data,
Struct {
foo: example.foo,
bar: example.bar,
baz: sentinel_dst.baz,
},
"copy_into_extensible_struct(struct, offsetof(struct.baz)) should only write foo and bar, leaving trailing dst bytes untouched",
);
guarded.assert();
// Short size (one fields) with zero trailing data should not overwrite
// later fields and returns Ok(false) to indicate that non-zero data was
// *not* truncated.
let example_zero_trailing = Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0,
baz: 0,
};
let mut guarded = Guarded::new(sentinel_dst);
assert_eq!(
unsafe {
copy_into_extensible_struct(
&mut guarded.data as *mut Struct,
bytemuck::offset_of!(Struct, bar),
&example_zero_trailing,
)
}
.expect("copy_into_extensible_struct with dst_size=offsetof(struct, bar) and zero-trailing src"),
false,
"copy_into_extensible_struct(struct, offsetof(struct, bar)) with zero-trailing src should not be truncated",
);
assert_eq!(
guarded.data,
Struct {
foo: example_zero_trailing.foo,
bar: sentinel_dst.bar,
baz: sentinel_dst.baz,
},
"copy_into_extensible_struct(struct, offsetof(struct, bar)) with zero-trailing src should write foo only",
);
guarded.assert();
}
#[test]
fn into_extensible_struct_long() {
#[repr(C)]
#[derive(PartialEq, Eq, Default, Debug, Clone, Copy, Pod, Zeroable)]
struct StructV2 {
inner: Struct,
extra: u64,
}
let example = Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
};
// Copy to a larger buffer provided by the user will cause the trailing
// data (StructV2.extra) to get zeroed.
let mut guarded = Guarded::new(StructV2 {
inner: Struct {
foo: 0xaaaaaaaaaaaaaaaa,
bar: 0xbbbbbbbb,
baz: 0xcccccccc,
},
extra: 0xffffffffffffffff,
});
assert_eq!(
unsafe {
copy_into_extensible_struct(
&mut guarded.data as *mut StructV2 as *mut Struct,
mem::size_of::<StructV2>(),
&example,
)
}
.expect("copy_into_extensible_struct with dst_size=sizeof(StructV2)"),
false,
"copy_into_extensible_struct(struct, sizeof(StructV2)) should not be truncated",
);
assert_eq!(
guarded.data,
StructV2 {
inner: example,
extra: 0,
},
"copy_into_extensible_struct(struct, sizeof(StructV2)) should write src and zero-fill trailing dst bytes",
);
}
#[test]
fn into_extensible_struct_zerosize() {
let example = Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
};
let sentinel_dst = Struct {
foo: 0xaaaaaaaaaaaaaaaa,
bar: 0xbbbbbbbb,
baz: 0xcccccccc,
};
// Zero size with non-zero struct should write nothing to the struct,
// and act as though it was truncated (i.e., return Ok(true)).
let mut guarded = Guarded::new(sentinel_dst);
assert_eq!(
unsafe { copy_into_extensible_struct(&mut guarded.data as *mut Struct, 0, &example) }
.expect("copy_into_extensible_struct with dst_size=0"),
true,
"copy_into_extensible_struct(struct, 0) with non-zero src should be truncated",
);
assert_eq!(
guarded.data, sentinel_dst,
"copy_into_extensible_struct(struct, 0) should not modify dst",
);
guarded.assert();
// Zero size with all-zero struct should write nothing to the struct,
// and act as though it was *not* truncated (i.e., return Ok(false)).
let mut guarded = Guarded::new(sentinel_dst);
assert_eq!(
unsafe {
copy_into_extensible_struct(&mut guarded.data as *mut Struct, 0, &Struct::default())
}
.expect("copy_into_extensible_struct with dst_size=0 and all-zero src"),
false,
"copy_into_extensible_struct(zero-struct, 0) should not be truncated",
);
assert_eq!(
guarded.data, sentinel_dst,
"copy_into_extensible_struct(zero-struct, 0) should not modify dst",
);
guarded.assert();
}
#[test]
fn into_extensible_struct_null() {
let example = Struct {
foo: 0xdeadbeeff00dcafe,
bar: 0x01234567,
baz: 0x89abcdef,
};
// NULL with zero size acts like zero size with any pointer value --
// "write" nothing to NULL and act as though it was truncated if the
// data was non-zero (i.e., return Ok(true)).
assert_eq!(
unsafe { copy_into_extensible_struct(ptr::null_mut::<Struct>(), 0, &example) }
.expect("copy_into_extensible_struct with NULL dst and dst_size=0"),
true,
"copy_into_extensible_struct(NULL, 0) should return Ok(true) for non-zero struct",
);
assert_eq!(
unsafe {
copy_into_extensible_struct(ptr::null_mut::<Struct>(), 0, &Struct::default())
}
.expect("copy_into_extensible_struct with NULL dst and dst_size=0"),
false,
"copy_into_extensible_struct(NULL, 0) should return Ok(false) for zero struct",
);
// NULL with non-zero size is an error.
assert_eq!(
unsafe {
copy_into_extensible_struct(
ptr::null_mut::<Struct>(),
mem::size_of::<Struct>(),
&example,
)
}
.map_err(|err| err.kind()),
Err(ErrorKind::InvalidArgument),
"copy_into_extensible_struct(NULL, sizeof(struct)) should be InvalidArgument",
);
}
}