Warning
Info
Hi, my problem is that FFI works on ubuntu but doesn't work on alpine. I develop my algorithm on Ubuntu, and once I implement a new feature, I package it into an Alpine container(based on rust:alpine3.22). I implement the solver in C++, and the server is built using Rust. The server receives network requests and then calls the C++ solver to process them.
I used to use CLI, and my solver on Alpine worked fine. But today, I replaced the CLI with FFI. The Rust server transmits C-style strings as parameters to the C++ solve function. It works fine on Ubuntu, successfully solving the problem and printing the solution. However, when I package the program into the Alpine container, it runs successfully until it transmits the parameters to the C++ function. My program is able to print "calc begin", but then it doesn't proceed. Then it throw Segmentation fault instead of print "read problem". So I suspect the issue occurs when transmitting the parameters.
Rust
use crate::request_data::ToProblem;
use crate::response::response_v3::ResponseV3;
use crate::CliError;
use crate::request_data::request_data_v3::RequestDataV3;
use crate::response::Response;
use libc::{c_char, c_void};
use std::ffi::{CStr, CString};
unsafe extern "C" {
fn solve(problem_string: *const c_char, config_string: *const c_char)->*mut c_void;
fn get_c_str(result:*mut c_void)->*const c_char;
fn free_result(result:*mut c_void);
}
pub async fn handle_request(data: RequestDataV3) -> Result<warp::reply::Json, warp::Rejection> {
println!("start handle");
let problem_string=serde_json::to_string(&data.to_problem()).unwrap();
let config_string=serde_json::to_string(&data.config).unwrap();
let problem_cstr = CString::new(problem_string).unwrap();
let config_cstr = CString::new(config_string).unwrap();
println!("{:?}",problem_cstr);
println!("{:?}",config_cstr);
let solution;
println!("calc begin");
unsafe {
let result=solve(problem_cstr.as_ptr(), config_cstr.as_ptr());
println!("calc end");
solution = CStr::from_ptr(get_c_str(result)).to_string_lossy().into_owned();
println!("get string");
free_result(result);
println!("free");
}
let solution_json = serde_json::from_str(&solution);
if let Err(e) = solution_json{
return Err(warp::reject::custom(CliError(e.to_string())));
}
let solution_json=solution_json.unwrap();
let response = Response {
solution:solution_json,
};
let response_v3=ResponseV3::from_response(&data, response);
Ok(warp::reply::json(&response_v3))
}
C++
#include <solver.hpp>
extern "C"{
struct Result{
std::string result;
};
Result* solve(const char * problem_string,const char * config_string){
std::cout<<"read problem"<<std::endl;
SolverConfig config(json::parse(config_string));
json problem_json=json::parse(problem_string);
Problem problem(problem_json);
std::cout<<"solve"<<std::endl;
Solver solver(&problem,config);
Solution solution=solver.solve();
std::cout<<"return"<<std::endl;
Result* result=new Result();
result->result=solution.to_json().dump();
return result;
}
const char* get_c_str(Result* result) {
return result->result.c_str();
}
void free_result(Result* result) {
delete result;
}
}
2 posts - 2 participants
🏷️ Rust_feed