mirror
/
r2r
mirror of https://github.com/sequenceplanner/r2r.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Check for null in `from_raw_parts` which rust 1.78 does not like. 

Revert temporary fix for CI. Closes #96.
This commit is contained in:
Martin Dahl 2024-05-17 11:40:05 +02:00
parent 33b82da466
commit 381f810d54
7 changed files with 172 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
r2r/src/msg_types.rs
View File

@ -93,8 +93,12 @@ pub trait WrappedTypesupport:
) )
}; };
let data_bytes = unsafe { let data_bytes = if msg_buf.buffer == std::ptr::null_mut() {
std::slice::from_raw_parts(msg_buf.buffer, msg_buf.buffer_length).to_vec() Vec::new()
} else {
unsafe {
std::slice::from_raw_parts(msg_buf.buffer, msg_buf.buffer_length).to_vec()
}
}; };
Self::destroy_msg(msg); Self::destroy_msg(msg);

140
r2r/src/nodes.rs
View File

@ -115,6 +115,15 @@ impl Node {
return Ok(()); return Ok(());
} }
unsafe {
if (*(*params.as_ref())).node_names == std::ptr::null_mut()
|| (*(*params.as_ref())).params == std::ptr::null_mut()
{
rcl_yaml_node_struct_fini(*params);
return Ok(());
}
}
let node_names = unsafe { let node_names = unsafe {
std::slice::from_raw_parts( std::slice::from_raw_parts(
(*(*params.as_ref())).node_names, (*(*params.as_ref())).node_names,
@ -148,18 +157,22 @@ impl Node {
} }
// make key value pairs. // make key value pairs.
let param_names =
unsafe { std::slice::from_raw_parts(np.parameter_names, np.num_params) };
let param_values =
unsafe { std::slice::from_raw_parts(np.parameter_values, np.num_params) };
let mut params = self.params.lock().unwrap(); let mut params = self.params.lock().unwrap();
for (s, v) in param_names.iter().zip(param_values) { if np.parameter_names != std::ptr::null_mut()
let s = unsafe { CStr::from_ptr(*s) }; && np.parameter_values != std::ptr::null_mut()
let key = s.to_str().unwrap_or(""); {
let val = ParameterValue::from_rcl(v); let param_names =
params.insert(key.to_owned(), Parameter::new(val)); unsafe { std::slice::from_raw_parts(np.parameter_names, np.num_params) };
let param_values =
unsafe { std::slice::from_raw_parts(np.parameter_values, np.num_params) };
for (s, v) in param_names.iter().zip(param_values) {
let s = unsafe { CStr::from_ptr(*s) };
let key = s.to_str().unwrap_or("");
let val = ParameterValue::from_rcl(v);
params.insert(key.to_owned(), Parameter::new(val));
}
} }
} }
@ -1028,29 +1041,33 @@ impl Node {
return; return;
} }
let ws_subs =
unsafe { std::slice::from_raw_parts(ws.subscriptions, self.subscribers.len()) };
let mut subs_to_remove = vec![]; let mut subs_to_remove = vec![];
for (s, ws_s) in self.subscribers.iter_mut().zip(ws_subs) { if ws.subscriptions != std::ptr::null_mut() {
if ws_s != &std::ptr::null() { let ws_subs =
let dropped = s.handle_incoming(); unsafe { std::slice::from_raw_parts(ws.subscriptions, self.subscribers.len()) };
if dropped { for (s, ws_s) in self.subscribers.iter_mut().zip(ws_subs) {
s.destroy(&mut self.node_handle); if ws_s != &std::ptr::null() {
subs_to_remove.push(*s.handle()); let dropped = s.handle_incoming();
if dropped {
s.destroy(&mut self.node_handle);
subs_to_remove.push(*s.handle());
}
} }
} }
} }
self.subscribers self.subscribers
.retain(|s| !subs_to_remove.contains(s.handle())); .retain(|s| !subs_to_remove.contains(s.handle()));
let ws_timers = unsafe { std::slice::from_raw_parts(ws.timers, self.timers.len()) };
let mut timers_to_remove = vec![]; let mut timers_to_remove = vec![];
for (s, ws_s) in self.timers.iter_mut().zip(ws_timers) { if ws.timers != std::ptr::null_mut() {
if ws_s != &std::ptr::null() { let ws_timers = unsafe { std::slice::from_raw_parts(ws.timers, self.timers.len()) };
// TODO: move this to impl Timer for (s, ws_s) in self.timers.iter_mut().zip(ws_timers) {
let dropped = s.handle_incoming(); if ws_s != &std::ptr::null() {
if dropped { // TODO: move this to impl Timer
timers_to_remove.push((*s.timer_handle).to_owned()); let dropped = s.handle_incoming();
if dropped {
timers_to_remove.push((*s.timer_handle).to_owned());
}
} }
} }
} }
@ -1058,23 +1075,28 @@ impl Node {
self.timers self.timers
.retain(|t| !timers_to_remove.contains(&*t.timer_handle)); .retain(|t| !timers_to_remove.contains(&*t.timer_handle));
let ws_clients = unsafe { std::slice::from_raw_parts(ws.clients, self.clients.len()) }; if ws.clients != std::ptr::null_mut() {
for (s, ws_s) in self.clients.iter_mut().zip(ws_clients) { let ws_clients = unsafe { std::slice::from_raw_parts(ws.clients, self.clients.len()) };
if ws_s != &std::ptr::null() { for (s, ws_s) in self.clients.iter_mut().zip(ws_clients) {
let mut s = s.lock().unwrap(); if ws_s != &std::ptr::null() {
s.handle_response(); let mut s = s.lock().unwrap();
s.handle_response();
}
} }
} }
let ws_services = unsafe { std::slice::from_raw_parts(ws.services, self.services.len()) };
let mut services_to_remove = vec![]; let mut services_to_remove = vec![];
for (s, ws_s) in self.services.iter_mut().zip(ws_services) { if ws.services != std::ptr::null_mut() {
if ws_s != &std::ptr::null() { let ws_services =
let mut service = s.lock().unwrap(); unsafe { std::slice::from_raw_parts(ws.services, self.services.len()) };
let dropped = service.handle_request(s.clone()); for (s, ws_s) in self.services.iter_mut().zip(ws_services) {
if dropped { if ws_s != &std::ptr::null() {
service.destroy(&mut self.node_handle); let mut service = s.lock().unwrap();
services_to_remove.push(*service.handle()); let dropped = service.handle_request(s.clone());
if dropped {
service.destroy(&mut self.node_handle);
services_to_remove.push(*service.handle());
}
} }
} }
} }
@ -1194,20 +1216,22 @@ impl Node {
return Err(Error::from_rcl_error(ret)); return Err(Error::from_rcl_error(ret));
} }
let names = unsafe { std::slice::from_raw_parts(tnat.names.data, tnat.names.size) };
let types = unsafe { std::slice::from_raw_parts(tnat.types, tnat.names.size) };
let mut res = HashMap::new(); let mut res = HashMap::new();
for (n, t) in names.iter().zip(types) { if tnat.names.data != std::ptr::null_mut() && tnat.types != std::ptr::null_mut() {
let topic_name = unsafe { CStr::from_ptr(*n).to_str().unwrap().to_owned() }; let names = unsafe { std::slice::from_raw_parts(tnat.names.data, tnat.names.size) };
let topic_types = unsafe { std::slice::from_raw_parts(t, t.size) }; let types = unsafe { std::slice::from_raw_parts(tnat.types, tnat.names.size) };
let topic_types: Vec<String> = unsafe {
topic_types for (n, t) in names.iter().zip(types) {
.iter() let topic_name = unsafe { CStr::from_ptr(*n).to_str().unwrap().to_owned() };
.map(|t| CStr::from_ptr(*(t.data)).to_str().unwrap().to_owned()) let topic_types = unsafe { std::slice::from_raw_parts(t, t.size) };
.collect() let topic_types: Vec<String> = unsafe {
}; topic_types
res.insert(topic_name, topic_types); .iter()
.map(|t| CStr::from_ptr(*(t.data)).to_str().unwrap().to_owned())
.collect()
};
res.insert(topic_name, topic_types);
}
} }
unsafe { unsafe {
rmw_names_and_types_fini(&mut tnat); rmw_names_and_types_fini(&mut tnat);
@ -1532,11 +1556,13 @@ fn convert_info_array_to_vec(
) -> Vec<TopicEndpointInfo> { ) -> Vec<TopicEndpointInfo> {
let mut topic_info_list = Vec::with_capacity(info_array.size); let mut topic_info_list = Vec::with_capacity(info_array.size);
unsafe { if info_array.info_array != std::ptr::null_mut() {
let infos = std::slice::from_raw_parts(info_array.info_array, info_array.size); unsafe {
for &info in infos { let infos = std::slice::from_raw_parts(info_array.info_array, info_array.size);
let endpoint_info = TopicEndpointInfo::from(info); for &info in infos {
topic_info_list.push(endpoint_info); let endpoint_info = TopicEndpointInfo::from(info);
topic_info_list.push(endpoint_info);
}
} }
} }

54
r2r/src/parameters.rs
View File

@ -34,36 +34,62 @@ impl ParameterValue {
ParameterValue::String(string) ParameterValue::String(string)
} else if !v.byte_array_value.is_null() { } else if !v.byte_array_value.is_null() {
let vals = unsafe { let vals = unsafe {
std::slice::from_raw_parts((*v.byte_array_value).values, (*v.byte_array_value).size) if (*v.byte_array_value).values == std::ptr::null_mut() {
&[]
} else {
std::slice::from_raw_parts(
(*v.byte_array_value).values,
(*v.byte_array_value).size,
)
}
}; };
ParameterValue::ByteArray(vals.to_vec()) ParameterValue::ByteArray(vals.to_vec())
} else if !v.bool_array_value.is_null() { } else if !v.bool_array_value.is_null() {
let vals = unsafe { let vals = unsafe {
std::slice::from_raw_parts((*v.bool_array_value).values, (*v.bool_array_value).size) if (*v.bool_array_value).values == std::ptr::null_mut() {
&[]
} else {
std::slice::from_raw_parts(
(*v.bool_array_value).values,
(*v.bool_array_value).size,
)
}
}; };
ParameterValue::BoolArray(vals.to_vec()) ParameterValue::BoolArray(vals.to_vec())
} else if !v.integer_array_value.is_null() { } else if !v.integer_array_value.is_null() {
let vals = unsafe { let vals = unsafe {
std::slice::from_raw_parts( if (*v.integer_array_value).values == std::ptr::null_mut() {
(*v.integer_array_value).values, &[]
(*v.integer_array_value).size, } else {
) std::slice::from_raw_parts(
(*v.integer_array_value).values,
(*v.integer_array_value).size,
)
}
}; };
ParameterValue::IntegerArray(vals.to_vec()) ParameterValue::IntegerArray(vals.to_vec())
} else if !v.double_array_value.is_null() { } else if !v.double_array_value.is_null() {
let vals = unsafe { let vals = unsafe {
std::slice::from_raw_parts( if (*v.double_array_value).values == std::ptr::null_mut() {
(*v.double_array_value).values, &[]
(*v.double_array_value).size, } else {
) std::slice::from_raw_parts(
(*v.double_array_value).values,
(*v.double_array_value).size,
)
}
}; };
ParameterValue::DoubleArray(vals.to_vec()) ParameterValue::DoubleArray(vals.to_vec())
} else if !v.string_array_value.is_null() { } else if !v.string_array_value.is_null() {
let vals = unsafe { let vals = unsafe {
std::slice::from_raw_parts( if (*v.string_array_value).data == std::ptr::null_mut() {
(*v.string_array_value).data, &[]
(*v.string_array_value).size, } else {
) std::slice::from_raw_parts(
(*v.string_array_value).data,
(*v.string_array_value).size,
)
}
}; };
let s = vals let s = vals
.iter() .iter()

8
r2r/src/subscribers.rs
View File

@ -203,8 +203,12 @@ impl Subscriber_ for RawSubscriber {
return false; return false;
} }
let data_bytes = unsafe { let data_bytes = if self.msg_buf.buffer == std::ptr::null_mut() {
std::slice::from_raw_parts(self.msg_buf.buffer, self.msg_buf.buffer_length).to_vec() Vec::new()
} else {
unsafe {
std::slice::from_raw_parts(self.msg_buf.buffer, self.msg_buf.buffer_length).to_vec()
}
}; };
if let Err(e) = self.sender.try_send(data_bytes) { if let Err(e) = self.sender.try_send(data_bytes) {

26
r2r_msg_gen/src/lib.rs
View File

@ -446,14 +446,16 @@ pub fn generate_rust_msg(module_: &str, prefix_: &str, name_: &str) -> proc_macr
quote! { quote! {
#field_name : { #field_name : {
let mut temp = Vec::with_capacity(msg. #field_name .size); let mut temp = Vec::with_capacity(msg. #field_name .size);
let slice = unsafe { if msg. #field_name .data != std::ptr::null_mut() {
std::slice::from_raw_parts( let slice = unsafe {
msg. #field_name .data, std::slice::from_raw_parts(
msg. #field_name .size msg. #field_name .data,
) msg. #field_name .size
}; )
for s in slice { };
temp.push( #module :: #prefix :: #name :: from_native(s)); for s in slice {
temp.push( #module :: #prefix :: #name :: from_native(s));
}
} }
temp temp
}, },
@ -589,9 +591,11 @@ pub fn generate_rust_msg(module_: &str, prefix_: &str, name_: &str) -> proc_macr
#fini_func (&mut msg. #field_name); #fini_func (&mut msg. #field_name);
#init_func (&mut msg. #field_name , self. #field_name .len()); #init_func (&mut msg. #field_name , self. #field_name .len());
let slice = std::slice::from_raw_parts_mut(msg. #field_name .data, msg. #field_name .size); if msg. #field_name .data != std::ptr::null_mut() {
for (t, s) in slice.iter_mut().zip(&self. #field_name ) { let slice = std::slice::from_raw_parts_mut(msg. #field_name .data, msg. #field_name .size);
s.copy_to_native(t); for (t, s) in slice.iter_mut().zip(&self. #field_name ) {
s.copy_to_native(t);
}
} }
} }
} }

29
r2r_rcl/src/lib.rs
View File

@ -56,13 +56,18 @@ impl rosidl_runtime_c__U16String__Sequence {
unsafe { unsafe {
rosidl_runtime_c__U16String__Sequence__init(self as *mut _, values.len()); rosidl_runtime_c__U16String__Sequence__init(self as *mut _, values.len());
} }
let strs = unsafe { std::slice::from_raw_parts_mut(self.data, values.len()) }; if self.data != std::ptr::null_mut() {
for (target, source) in strs.iter_mut().zip(values) { let strs = unsafe { std::slice::from_raw_parts_mut(self.data, values.len()) };
target.assign(source); for (target, source) in strs.iter_mut().zip(values) {
target.assign(source);
}
} }
} }
pub fn to_vec(&self) -> Vec<String> { pub fn to_vec(&self) -> Vec<String> {
if self.data == std::ptr::null_mut() {
return Vec::new();
}
let mut target = Vec::with_capacity(self.size); let mut target = Vec::with_capacity(self.size);
let strs = unsafe { std::slice::from_raw_parts(self.data, self.size) }; let strs = unsafe { std::slice::from_raw_parts(self.data, self.size) };
for s in strs { for s in strs {
@ -80,13 +85,18 @@ impl rosidl_runtime_c__String__Sequence {
unsafe { unsafe {
rosidl_runtime_c__String__Sequence__init(self as *mut _, values.len()); rosidl_runtime_c__String__Sequence__init(self as *mut _, values.len());
} }
let strs = unsafe { std::slice::from_raw_parts_mut(self.data, values.len()) }; if self.data != std::ptr::null_mut() {
for (target, source) in strs.iter_mut().zip(values) { let strs = unsafe { std::slice::from_raw_parts_mut(self.data, values.len()) };
target.assign(source); for (target, source) in strs.iter_mut().zip(values) {
target.assign(source);
}
} }
} }
pub fn to_vec(&self) -> Vec<String> { pub fn to_vec(&self) -> Vec<String> {
if self.data == std::ptr::null_mut() {
return Vec::new();
}
let mut target = Vec::with_capacity(self.size); let mut target = Vec::with_capacity(self.size);
let strs = unsafe { std::slice::from_raw_parts(self.data, self.size) }; let strs = unsafe { std::slice::from_raw_parts(self.data, self.size) };
for s in strs { for s in strs {
@ -105,10 +115,15 @@ macro_rules! primitive_sequence {
pub fn update(&mut self, values: &[$element_type]) { pub fn update(&mut self, values: &[$element_type]) {
unsafe { [<$ctype __Sequence__fini>] (self as *mut _); } unsafe { [<$ctype __Sequence__fini>] (self as *mut _); }
unsafe { [<$ctype __Sequence__init>] (self as *mut _, values.len()); } unsafe { [<$ctype __Sequence__init>] (self as *mut _, values.len()); }
unsafe { std::ptr::copy(values.as_ptr(), self.data, values.len()); } if self.data != std::ptr::null_mut() {
unsafe { std::ptr::copy(values.as_ptr(), self.data, values.len()); }
}
} }
pub fn to_vec(&self) -> Vec<$element_type> { pub fn to_vec(&self) -> Vec<$element_type> {
if self.data == std::ptr::null_mut() {
return Vec::new();
}
let mut target = Vec::with_capacity(self.size); let mut target = Vec::with_capacity(self.size);
unsafe { unsafe {
std::ptr::copy(self.data, target.as_mut_ptr(), self.size); std::ptr::copy(self.data, target.as_mut_ptr(), self.size);

4
tests/test.bash
View File

@ -5,10 +5,6 @@
# run rustup to test with latest rust version # run rustup to test with latest rust version
rustup update rustup update
# temporary fix for CI until #96 is resolved
rustup toolchain install 1.77
rustup default 1.77
if [ -e "/opt/ros/iron/setup.bash" ]; then if [ -e "/opt/ros/iron/setup.bash" ]; then
source "/opt/ros/iron/setup.bash" source "/opt/ros/iron/setup.bash"
elif [ -e "/opt/ros/humble/setup.bash" ]; then elif [ -e "/opt/ros/humble/setup.bash" ]; then