从 String 到 *const i8 的正确方法是什么？

Question

在我为Cassandra C++ driver 编写safe wrapper 的过程中，现在我的注意力转向了在调用具有以下签名的C 函数时避免内存泄漏：

cass_string_init2(const char* data, cass_size_t length);

或

cass_string_init(const char* null_terminated);

我尝试了几种名义上可行的不同方法，并产生了正确的结果，但我还没有找到一种方法来正确管理这些数据的生命周期。下面是两个示例方法。

pub fn str_to_ref(mystr:&str) -> *const i8 {unsafe{
    let cstr = CString::from_slice(mystr.as_bytes());
    cstr.as_slice().as_ptr()
}}

和

pub fn str_to_ref(mystr: &str) -> *const i8 {
    let l = mystr.as_bytes();
    unsafe {
        let b = alloc::heap::allocate(mystr.len()+1, 8);
        let s = slice::from_raw_parts_mut(b, mystr.len()+1);
        slice::bytes::copy_memory(s, l);
        s[mystr.len()] = 0;
        return b as *const i8;
    }
}

第一个执行无效的内存访问，例如

==26355==  Address 0x782d140 is 0 bytes inside a block of size 320 free'd
==26355==    at 0x1361A8: je_valgrind_freelike_block (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==26355==    by 0x11272D: heap::imp::deallocate::h7b540039fbffea4dPha (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==26355==    by 0x112679: heap::deallocate::h3897fed87b942253tba (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==26355==    by 0x112627: vec::dealloc::h7978768019700822177 (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==26355==    by 0x112074: vec::Vec$LT$T$GT$.Drop::drop::h239007174869221309 (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==26355==    by 0x111F9D: collections..vec..Vec$LT$i8$GT$::glue_drop.5732::h978a83960ecb86a4 (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==26355==    by 0x111F6D: std..ffi..c_str..CString::glue_drop.5729::h953a595760f34a9d (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==26355==    by 0x112903: cql_ffi::helpers::str_to_ref::hef3994fa55168b90bqd (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
=

而第二个不知道何时释放其内存，导致：

==29782== 8 bytes in 1 blocks are definitely lost in loss record 1 of 115
==29782==    at 0x12A5B2: je_mallocx (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==29782==    by 0x1142D5: heap::imp::allocate::h3fa8a1c097e9ea53Tfa (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==29782==    by 0x114221: heap::allocate::h18d191ce51ab2236gaa (in /home/tupshin/workspaces/rust/cql-ffi/target/basic)
==29782==    by 0x112874: cql_ffi::helpers::str_to_ref::h5b60f207d1e31841bqd (helpers.rs:25)

使用这两种方法中的任何一种作为起点，或者完全不同的方法，我真的很感激一些关于正确方法的指导。

编辑：

Shep 的回答 完美 使用 cass_string_init 和 cass_string_init2 解决了我的问题。太感谢了。但是，我仍然不清楚将 *const i8 参数传递给其他函数，例如：

CASS_EXPORT CassError
cass_cluster_set_contact_points(CassCluster* cluster,
const char* contact_points);

它期望被传递一个对空终止字符串的引用。

基于之前适用于 CassStrings 的方法以及 CString 文档，我提出了以下建议：

pub struct ContactPoints(*const c_char);

pub trait AsContactPoints {
    fn as_contact_points(&self) -> ContactPoints;
}

impl AsContactPoints for str {
    fn as_contact_points(&self) -> ContactPoints {
        let cstr = CString::new(self).unwrap();
        let bytes = cstr.as_bytes_with_nul();
        let ptr = bytes.as_ptr();
        ContactPoints(ptr as *const i8)
    }
}

（过多的 let 绑定只是为了确保我没有遗漏任何细微之处）

运行正常，但 valgrind 抱怨：

==22043== Invalid read of size 1
==22043==    at 0x4C2E0E2: strlen (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==22043==    by 0x4F8AED8: cass_cluster_set_contact_points (in /usr/local/lib/libcassandra.so.1.0.0)
==22043==    by 0x11367A: cql_ffi::cluster::CassCluster::set_contact_points::h575496cbf7644b9e6oa (cluster.rs:76)

Answer 1

Cassandra C API for cass_string_init2 看起来像：

注意：这不分配内存。该对象包装了传递给该函数的指针。

CASS_EXPORT CassString
cass_string_init2(const char* data, cass_size_t length);

也就是说，它接受一个字符串，并返回一个字符串的替代表示。那representation looks like：

typedef struct CassString_ {
    const char* data;
    cass_size_t length;
} CassString;

这是你想在 Rust 代码中使用 #[repr(C)] 的地方：

#[repr(C)]
struct CassStr {
    data: *const c_char,
    length: size_t,
}

你能做的最好的事情就是让字符串自动转换成这个结构：

trait AsCassStr {
    fn as_cass_str(&self) -> CassStr;
}

impl AsCassStr for str {
    fn as_cass_str(&self) -> CassStr {
        CassStr {
            data: self.as_bytes(),
            length: self.len(),
        }
    }
}

然后让您的 API 接受任何实现 AsCassStr 的内容。这也允许您拥有自己的变体。您可能还想查看 PhantomData 以允许强制执行 CassStr 对象的生命周期。

注意通常您希望使用CString 来避免带有内部 NUL 字节的字符串。但是，由于 API 接受长度参数，因此它可能原生支持它们。您需要进行实验才能找到答案。如果没有，那么您需要使用CString，如下所示。

问题的后半部分

让我们逐行看看你的函数：

impl AsContactPoints for str {
    fn as_contact_points(&self) -> ContactPoints {
        let cstr = CString::new(self).unwrap(); // 1
        let bytes = cstr.as_bytes_with_nul();   // 2
        let ptr = bytes.as_ptr();               // 3
        ContactPoints(ptr as *const i8)         // 4
    }                                           // 5
}

1. 我们创建一个新的CString。这会在某处分配一点内存，验证字符串没有内部 NUL 字节，然后逐字节复制我们的字符串，并添加一个尾随零。
2. 我们得到一个切片，它引用我们在第 1 步中复制和验证的字节。回想一下，切片是一个指向数据的指针加上一个长度。
3. 我们将切片转换为指针，忽略长度。
4. 我们将指针存储在一个结构中，并使用它作为我们的返回值
5. 函数退出，所有局部变量都被释放。请注意，cstr 是一个局部变量，因此它所保存的字节也同样被释放。你现在有一个悬空指针。不好！

您需要确保CString 的使用寿命与需要一样长。希望您调用的函数不会保留对它的引用，但是没有简单的方法可以从函数签名中分辨出来。你可能想要这样的代码：

fn my_cass_call(s: &str) {
    let s = CString::new(s).unwrap();
    cass_call(s.as_ptr()) // `s` is still alive here
}

这里的好处是您永远不会将指针存储在您自己的变量中。请记住，原始指针没有生命周期，因此您必须非常小心它们！