Comment puis-je convertir une chaîne C dans une Rouille de la chaîne et à l'arrière via FFI?

La meilleure façon de travailler avec les chaînes C dans la Rouille est d'utiliser les structures de la std::ffi module, à savoir CStr et CString.

CStr est une façon dynamique de taille moyenne de type et ainsi il ne peut être utilisé par l'intermédiaire d'un pointeur. De ce fait, il est très similaire à la régulière str type. Vous pouvez construire une &CStr de *const c_char à l'aide d'un dangereux CStr::from_ptr méthode statique. Cette méthode est dangereuse car il n'y a aucune garantie que le pointeur brut vous passer est valide, qu'elle n'est point valable chaîne C et que la chaîne de la durée de vie est correcte.

Vous pouvez obtenir un &str à partir d'un &CStr à l'aide de son to_str() méthode.

Voici un exemple:

extern crate libc;

use libc::c_char;
use std::ffi::CStr;
use std::str;

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

fn main() {
    let c_buf: *const c_char = unsafe { hello() };
    let c_str: &CStr = unsafe { CStr::from_ptr(c_buf) };
    let str_slice: &str = c_str.to_str().unwrap();
    let str_buf: String = str_slice.to_owned();  //if necessary
}

Vous avez besoin de prendre en compte la durée de vie de votre *const c_char pointeurs et qui les possède. Selon l'API C, vous pouvez avoir besoin de convoquer un groupe spécial de la fonction de libération sur la chaîne. Vous devez soigneusement organiser des conversions les tranches de ne pas survivre à l'pointeur. Le fait que CStr::from_ptr renvoie une &CStr arbitraire de la durée de vie utile ici (même si c'est dangereux par lui-même); par exemple, vous pouvez encapsuler votre chaîne C dans une structure et de fournir une Deref de conversion de sorte que vous pouvez utiliser votre struct comme si c'était une chaîne de tranche:

extern crate libc;

use libc::c_char;
use std::ops::Deref;
use std::ffi::CStr;

extern "C" {
    fn hello() -> *const c_char;
    fn goodbye(s: *const c_char);
}

struct Greeting {
    message: *const c_char,
}

impl Drop for Greeting {
    fn drop(&mut self) {
        unsafe {
            goodbye(self.message);
        }
    }
}

impl Greeting {
    fn new() -> Greeting {
        Greeting { message: unsafe { hello() } }
    }
}

impl Deref for Greeting {
    type Target = str;

    fn deref<'a>(&'a self) -> &'a str {
        let c_str = unsafe { CStr::from_ptr(self.message) };
        c_str.to_str().unwrap()
    }
}

Il y a aussi un autre type dans ce module, appelé CString. Il a la même relation avec CStr comme String avec str - CString est de posséder une version de CStr. Cela signifie qu'il "tient" la poignée de l'affectation de l'octet de données, et en les déposant CString permettrait de libérer la mémoire qu'il fournit (essentiellement, CString enveloppements Vec<u8>, et c'est cette dernière qui sera supprimée). Par conséquent, il est utile lorsque vous souhaitez exposer les données allouées à la Rouille comme une chaîne C.

Malheureusement, chaînes C toujours fin avec le zéro octet et ne peut pas contenir un à l'intérieur, tandis que la Rouille &[u8]/Vec<u8> sont exactement à l'opposé chose - qu'ils ne finissent pas avec de zéro octet et peut contenir un nombre arbitraire de l'intérieur. Cela signifie que passer de Vec<u8> à CString est ni exempt d'erreur, ni de l'allocation-gratuit - du CString constructeur de deux chèques pour les zéros à l'intérieur les données que vous fournissez, de retourner une erreur si il en trouve, et ajoute un zéro octet à la fin de l'octet vecteur, qui peut exiger de sa réaffectation.

Comme String, qui met en œuvre Deref<Target = str>, CString implémente Deref<Target = CStr>, de sorte que vous pouvez appeler les méthodes définies sur CStr directement sur CString. Ceci est important parce que la as_ptr() méthode qui retourne la *const c_char nécessaire pour C interopérabilité est définie sur CStr. Vous pouvez appeler cette méthode directement sur CString valeurs, ce qui est très pratique.

CString peut être créé à partir de tout ce qui peut être transformée en Vec<u8>. String, &str, Vec<u8> et &[u8] sont des arguments valables pour la fonction de constructeur, CString::new(). Naturellement, si vous passez un octet tranche ou d'une chaîne de tranche, une nouvelle allocation va être créé, alors que Vec<u8> ou String seront consommés.

extern crate libc;

use libc::c_char;
use std::ffi::CString;

fn main() {
    let c_str_1 = CString::new("hello").unwrap(); //from a &str, creates a new allocation
    let c_str_2 = CString::new(b"world" as &[u8]).unwrap(); //from a &[u8], creates a new allocation
    let data: Vec<u8> = b"12345678".to_vec(); //from a Vec<u8>, consumes it
    let c_str_3 = CString::new(data).unwrap();

    //and now you can obtain a pointer to a valid zero-terminated string
    //make sure you don't use it after c_str_2 is dropped
    let c_ptr: *const c_char = c_str_2.as_ptr();

    //the following will print an error message because the source data
    //contains zero bytes
    let data: Vec<u8> = vec![1, 2, 3, 0, 4, 5, 0, 6];
    match CString::new(data) {
        Ok(c_str_4) => println!("Got a C string: {:p}", c_str_4.as_ptr()),
        Err(e) => println!("Error getting a C string: {}", e),
    }  
}

Si vous avez besoin d'un transfert de propriété de la CString de code en C, vous pouvez appeler CString::into_raw. Vous devez ensuite obtenir le pointeur de retour et de les libérer dans la Rouille, la Rouille de l'allocateur est peu probable d'être le même que l'allocateur utilisé par malloc et free. Tout ce que vous devez faire est d'appeler CString::from_raw et ensuite permettre à la chaîne d'être tombé normalement.