Struct cstr_core::CStr

[+] Show declaration

pub struct CStr { /* fields omitted */ }

[−] Expand description

Representation of a borrowed C string.

This dynamically sized type is only safely constructed via a borrowed version of an instance of CString. This type can be constructed from a raw C string as well and represents a C string borrowed from another location.

Note that this structure is not repr(C) and is not recommended to be placed in the signatures of FFI functions. Instead safe wrappers of FFI functions may leverage the unsafe from_ptr constructor to provide a safe interface to other consumers.

Examples

Inspecting a foreign C string:

use cstr_core::CStr;
use cstr_core::c_char;

extern { fn my_string() -> *const c_char; }

unsafe {
    let slice = CStr::from_ptr(my_string());
    println!("string length: {}", slice.to_bytes().len());
}

Passing a Rust-originating C string:

use cstr_core::{CString, CStr};
use cstr_core::c_char;

fn work(data: &CStr) {
    extern { fn work_with(data: *const c_char); }

    unsafe { work_with(data.as_ptr()) }
}

let s = CString::new("data data data data").unwrap();
work(&s);

Converting a foreign C string into a Rust String:

use cstr_core::CStr;
use cstr_core::c_char;

extern { fn my_string() -> *const c_char; }

fn my_string_safe() -> String {
    unsafe {
        CStr::from_ptr(my_string()).to_string_lossy().into_owned()
    }
}

println!("string: {}", my_string_safe());

Methods

impl CStr[−]

pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr[−]

Casts a raw C string to a safe C string wrapper.

This function will cast the provided ptr to the CStr wrapper which allows inspection and interoperation of non-owned C strings. This method is unsafe for a number of reasons:

• There is no guarantee to the validity of ptr.
• The returned lifetime is not guaranteed to be the actual lifetime of ptr.
• There is no guarantee that the memory pointed to by ptr contains a valid nul terminator byte at the end of the string.
• It is not guaranteed that the memory pointed by ptr won't change before the CStr has been destroyed.

Note: This operation is intended to be a 0-cost cast but it is currently implemented with an up-front calculation of the length of the string. This is not guaranteed to always be the case.

Examples

use cstr_core::CStr;
use cstr_core::c_char;

extern {
    fn my_string() -> *const c_char;
}

unsafe {
    let slice = CStr::from_ptr(my_string());
    println!("string returned: {}", slice.to_str().unwrap());
}

pub fn from_bytes_with_nul(bytes: &[u8]) -> Result<&CStr, FromBytesWithNulError>[−]

Creates a C string wrapper from a byte slice.

This function will cast the provided bytes to a CStr wrapper after ensuring that it is null terminated and does not contain any interior nul bytes.

Examples

use cstr_core::CStr;

let cstr = CStr::from_bytes_with_nul(b"hello\0");
assert!(cstr.is_ok());

Creating a CStr without a trailing nul byte is an error:

use cstr_core::CStr;

let c_str = CStr::from_bytes_with_nul(b"hello");
assert!(c_str.is_err());

Creating a CStr with an interior nul byte is an error:

use cstr_core::CStr;

let c_str = CStr::from_bytes_with_nul(b"he\0llo\0");
assert!(c_str.is_err());

pub unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr[−]

Unsafely creates a C string wrapper from a byte slice.

This function will cast the provided bytes to a CStr wrapper without performing any sanity checks. The provided slice must be null terminated and not contain any interior nul bytes.

Examples

use cstr_core::{CStr, CString};

unsafe {
    let cstring = CString::new("hello").unwrap();
    let cstr = CStr::from_bytes_with_nul_unchecked(cstring.to_bytes_with_nul());
    assert_eq!(cstr, &*cstring);
}

pub fn as_ptr(&self) -> *const c_char[−]

Returns the inner pointer to this C string.

The returned pointer will be valid for as long as self is and points to a contiguous region of memory terminated with a 0 byte to represent the end of the string.

WARNING

It is your responsibility to make sure that the underlying memory is not freed too early. For example, the following code will cause undefined behavior when ptr is used inside the unsafe block:

use cstr_core::{CString};

let ptr = CString::new("Hello").unwrap().as_ptr();
unsafe {
    // `ptr` is dangling
    *ptr;
}

This happens because the pointer returned by as_ptr does not carry any lifetime information and the string is deallocated immediately after the CString::new("Hello").unwrap().as_ptr() expression is evaluated. To fix the problem, bind the string to a local variable:

use cstr_core::{CString};

let hello = CString::new("Hello").unwrap();
let ptr = hello.as_ptr();
unsafe {
    // `ptr` is valid because `hello` is in scope
    *ptr;
}

pub fn to_bytes(&self) -> &[u8][−]

Converts this C string to a byte slice.

This function will calculate the length of this string (which normally requires a linear amount of work to be done) and then return the resulting slice of u8 elements.

The returned slice will not contain the trailing nul that this C string has.

Note: This method is currently implemented as a constant-time cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.

Examples

use cstr_core::CStr;

let c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap();
assert_eq!(c_str.to_bytes(), b"foo");

pub fn to_bytes_with_nul(&self) -> &[u8][−]

Converts this C string to a byte slice containing the trailing 0 byte.

This function is the equivalent of to_bytes except that it will retain the trailing nul instead of chopping it off.

Note: This method is currently implemented as a 0-cost cast, but it is planned to alter its definition in the future to perform the length calculation whenever this method is called.

Examples

use cstr_core::CStr;

let c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap();
assert_eq!(c_str.to_bytes_with_nul(), b"foo\0");

pub fn to_str(&self) -> Result<&str, Utf8Error>[−]

Yields a &str slice if the CStr contains valid UTF-8.

This function will calculate the length of this string and check for UTF-8 validity, and then return the &str if it's valid.

Note: This method is currently implemented to check for validity after a constant-time cast, but it is planned to alter its definition in the future to perform the length calculation in addition to the UTF-8 check whenever this method is called.

Examples

use cstr_core::CStr;

let c_str = CStr::from_bytes_with_nul(b"foo\0").unwrap();
assert_eq!(c_str.to_str(), Ok("foo"));

Trait Implementations

impl Debug for CStr[+]

[+] Show hidden undocumented items

fn fmt(&self, f: &mut Formatter) -> Result[−]

Formats the value using the given formatter.

impl PartialEq<CStr> for CStr[+]

[+] Show hidden undocumented items

fn eq(&self, other: &CStr) -> bool[−]

This method tests for self and other values to be equal, and is used by ==.

[+] Expand attributes

#[must_use]

fn ne(&self, other: &Rhs) -> bool[−]

This method tests for !=.

impl Eq for CStr

impl Ord for CStr[+]

[+] Show hidden undocumented items

fn cmp(&self, other: &CStr) -> Ordering[−]

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self[−]

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self[−]

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self[−]

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialOrd<CStr> for CStr[+]

[+] Show hidden undocumented items

fn partial_cmp(&self, other: &CStr) -> Option<Ordering>[−]

This method returns an ordering between self and other values if one exists.

[+] Expand attributes

#[must_use]

fn lt(&self, other: &Rhs) -> bool[−]

This method tests less than (for self and other) and is used by the < operator.

[+] Expand attributes

#[must_use]

fn le(&self, other: &Rhs) -> bool[−]

This method tests less than or equal to (for self and other) and is used by the <= operator.

[+] Expand attributes

#[must_use]

fn gt(&self, other: &Rhs) -> bool[−]

This method tests greater than (for self and other) and is used by the > operator.

[+] Expand attributes

#[must_use]

fn ge(&self, other: &Rhs) -> bool[−]

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Hash for CStr[+]

[+] Show hidden undocumented items

fn hash<__H: Hasher>(&self, state: &mut __H)[−]

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, [−]

Feeds a slice of this type into the given [Hasher].

impl AsRef<CStr> for CStr[+]

[+] Show hidden undocumented items

fn as_ref(&self) -> &CStr[−]

Performs the conversion.

impl<'a> Default for &'a CStr[+]

[+] Show hidden undocumented items

fn default() -> &'a CStr[−]

Returns the "default value" for a type.