Appel de rouille à partir de Python avec une chaîne dans les paramètres de la fonction

Question

Je peux appeler mon programme de test Rust avec des entiers en entrée et les gérer correctement, même sans référence à ctypes. Cependant, je n'arrive pas à obtenir une chaîne sans segfaulting dans Rust.

Voici mon test code Rust:

use std::env; 

#[no_mangle] 
pub extern fn helloworld(names: &str) { 
    println!("{}", names); 
    println!("helloworld..."); 
} 

#[no_mangle] 
pub extern fn ihelloworld(names: i32) { 
    println!("{}", names); 
    println!("ihelloworld..."); 
} 

ihelloworld fonctionne très bien. Mais je ne peux pas trouver un moyen d'obtenir une chaîne de Python dans Rust même si j'utilise ctypes.

Voici le code d'appel Python:

import sys, ctypes, os 
from ctypes import cdll 
from ctypes import c_char_p 
from ctypes import * 


if __name__ == "__main__": 
    directory = os.path.dirname(os.path.abspath(__file__)) 
    lib = cdll.LoadLibrary(os.path.join(directory, "target/release/libembeded.so")) 

    lib.ihelloworld(1) 
    lib.helloworld.argtypes = [c_char_p] 
    #lib.helloworld(str("test user")) 
    #lib.helloworld(u'test user') 
    lib.helloworld(c_char_p("test user")) 

    print("finished running!") 

La sortie est:

1 
ihelloworld... 
Segmentation fault (core dumped) 

La ihellowworld fonction de Rust fonctionne très bien, mais je ne peux pas sembler obtenir helloworld travail.

Answer 1

J'ai utilisé the Rust FFI Omnibus et maintenant mon code semble fonctionner correctement.

use std::env; 
use std::ffi::{CString, CStr}; 
use std::os::raw::c_char; 

#[no_mangle] 
pub extern "C" fn helloworld(names: *const c_char) { 

    unsafe { 
     let c_str = CStr::from_ptr(names).to_str().unwrap(); 
     println!("{:?}", c_str); 

    } 
    println!("helloworld..."); 

} 

Answer 2

La chaîne envoyée à partir de Python doit être représentée dans Rust en tant que CString à la place.