CODEWITHSUNDEEP
c++rustc-strings
Scony
Scony

Reputation: 4138

Interfacing C++ with Rust - returning CString panics

I am trying to call some functions written in Rust from C++. So far I've been quite successful but I still have one little problem with a CString-related panic during runtime.

The function hello is supposed to take an input string, concatenate it with some other string and return the product.

Here's my fun.rs:

use std::ffi::CString;

#[no_mangle]
pub extern "C" fn add(a: i32, b: i32) -> i32 {
    a + b
}

#[no_mangle]
pub extern "C" fn hello(cs: CString) -> CString {
    let slice = cs.to_str().unwrap();
    let mut s = "Hello, ".to_string();
    s = s + slice;

    CString::new(&s[..]).unwrap() // runtime error
    // CString::new(cs).unwrap()  // empty string if no borrow
    // cs                         // works if no borrow, but this is not what I meant
}

Here's main.cpp:

#include <iostream>
using namespace std;

extern "C" {
  int add(int a, int b);
  const char* hello(const char*x);
}

int main()
{
  int a, b;
  cin >> a >> b;
  cout << add(a,b) << ";" << hello("Pawel") << std::endl;
  return 0;
}

And makefile:

rust:
        rustc --crate-type=staticlib -C panic=abort fun.rs

cpp:
        g++ -c main.cpp

link:
        g++ main.o -L . libfun.a -o main -lpthread -ldl -lgcc_s -lc -lm -lrt -lutil

Commands to run executable:

$ make rust
$ make cpp
$ make link
$ ./main
1 2

Executable output:

1 2
thread '<unnamed>' panicked at 'index 18446744073709551615 out of range for slice of length 0', ../src/libcore/slice.rs:549
note: Run with `RUST_BACKTRACE=1` for a backtrace..

Backtrace:

stack backtrace:
   1:           0x435d4f - std::sys::backtrace::tracing::imp::write::h46e546df6e4e4fe6
   2:           0x44405b - std::panicking::default_hook::_$u7b$$u7b$closure$u7d$$u7d$::h077deeda8b799591
   3:           0x443c8f - std::panicking::default_hook::heb8b6fd640571a4f
   4:           0x4099fe - std::panicking::rust_panic_with_hook::hd7b83626099d3416
   5:           0x4442a1 - std::panicking::begin_panic::h941ea76fc945d925
   6:           0x40b74a - std::panicking::begin_panic_fmt::h30280d4dd3f149f5
   7:           0x44423e - rust_begin_unwind
   8:           0x451d8f - core::panicking::panic_fmt::h2d3cc8234dde51b4
   9:           0x452073 - core::slice::slice_index_len_fail::ha4faf37254d75f20
  10:           0x40e903 - std::ffi::c_str::CStr::to_str::ha9642252376bab15
  11:           0x4048e0 - hello
  12:           0x40476f - main
  13:     0x7f78ff688f44 - __libc_start_main
  14:           0x404678 - <unknown>
  15:                0x0 - <unknown>

Any ideas why Rust is panicking?

Upvotes: 2

Views: 1129

Answers (1)

Francis Gagn&#233;
Francis Gagn&#233;

Reputation: 65722

Rust's CString is not compatible with C's const char *. Here's the definition of CString from the standard library:

pub struct CString {
    inner: Box<[u8]>,
}

This Box<[u8]> type is a fat pointer, i.e. a tuple that contains a pointer to the slice's items and the length of the slice as a usize.

What you should do instead is make your Rust function take a *const c_char argument and then call CStr::from_ptr with that pointer as the argument to obtain a CStr value.

As for the return value, there's a bit of a problem: your function allocates a new string and then returns a pointer to it. Again, you should return a *const c_char, which you can do by calling CString::into_raw on your concatenated CString value. But to avoid memory leaks, you must also provide a Rust function that will take back a pointer returned by hello and call CString::from_raw on it, which will recreate the CString. The CString's destructor will then run, freeing the memory.

Upvotes: 5

Related Questions