ffi.rs 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251
  1. // Copyright (c) 2016-2018, The Tor Project, Inc. */
  2. // See LICENSE for licensing information */
  3. //! FFI functions, only to be called from C.
  4. //!
  5. //! Equivalent C versions of this api are in `protover.c`
  6. use libc::{c_char, c_int, uint32_t};
  7. use std::ffi::CStr;
  8. use std::ffi::CString;
  9. use smartlist::*;
  10. use tor_allocate::allocate_and_copy_string;
  11. use errors::ProtoverError;
  12. use protover::*;
  13. /// Translate C enums to Rust Proto enums, using the integer value of the C
  14. /// enum to map to its associated Rust enum.
  15. ///
  16. /// C_RUST_COUPLED: protover.h `protocol_type_t`
  17. fn translate_to_rust(c_proto: uint32_t) -> Result<Protocol, ProtoverError> {
  18. match c_proto {
  19. 0 => Ok(Protocol::Link),
  20. 1 => Ok(Protocol::LinkAuth),
  21. 2 => Ok(Protocol::Relay),
  22. 3 => Ok(Protocol::DirCache),
  23. 4 => Ok(Protocol::HSDir),
  24. 5 => Ok(Protocol::HSIntro),
  25. 6 => Ok(Protocol::HSRend),
  26. 7 => Ok(Protocol::Desc),
  27. 8 => Ok(Protocol::Microdesc),
  28. 9 => Ok(Protocol::Cons),
  29. _ => Err(ProtoverError::UnknownProtocol),
  30. }
  31. }
  32. /// Provide an interface for C to translate arguments and return types for
  33. /// protover::all_supported
  34. #[no_mangle]
  35. pub extern "C" fn protover_all_supported(
  36. c_relay_version: *const c_char,
  37. missing_out: *mut *mut c_char,
  38. ) -> c_int {
  39. if c_relay_version.is_null() {
  40. return 1;
  41. }
  42. // Require an unsafe block to read the version from a C string. The pointer
  43. // is checked above to ensure it is not null.
  44. let c_str: &CStr = unsafe { CStr::from_ptr(c_relay_version) };
  45. let relay_version = match c_str.to_str() {
  46. Ok(n) => n,
  47. Err(_) => return 1,
  48. };
  49. let relay_proto_entry: UnvalidatedProtoEntry =
  50. match UnvalidatedProtoEntry::from_str_any_len(relay_version) {
  51. Ok(n) => n,
  52. Err(_) => return 1,
  53. };
  54. if let Some(unsupported) = relay_proto_entry.all_supported() {
  55. if missing_out.is_null() {
  56. return 0;
  57. }
  58. let c_unsupported: CString = match CString::new(unsupported.to_string()) {
  59. Ok(n) => n,
  60. Err(_) => return 1,
  61. };
  62. let ptr = c_unsupported.into_raw();
  63. unsafe { *missing_out = ptr };
  64. return 0;
  65. }
  66. 1
  67. }
  68. /// Provide an interface for C to translate arguments and return types for
  69. /// protover::list_supports_protocol
  70. #[no_mangle]
  71. pub extern "C" fn protocol_list_supports_protocol(
  72. c_protocol_list: *const c_char,
  73. c_protocol: uint32_t,
  74. version: uint32_t,
  75. ) -> c_int {
  76. if c_protocol_list.is_null() {
  77. return 1;
  78. }
  79. // Require an unsafe block to read the version from a C string. The pointer
  80. // is checked above to ensure it is not null.
  81. let c_str: &CStr = unsafe { CStr::from_ptr(c_protocol_list) };
  82. let protocol_list = match c_str.to_str() {
  83. Ok(n) => n,
  84. Err(_) => return 1,
  85. };
  86. let proto_entry: UnvalidatedProtoEntry = match protocol_list.parse() {
  87. Ok(n) => n,
  88. Err(_) => return 0,
  89. };
  90. let protocol: UnknownProtocol = match translate_to_rust(c_protocol) {
  91. Ok(n) => n.into(),
  92. Err(_) => return 0,
  93. };
  94. if proto_entry.supports_protocol(&protocol, &version) {
  95. 1
  96. } else {
  97. 0
  98. }
  99. }
  100. #[no_mangle]
  101. pub extern "C" fn protover_contains_long_protocol_names_(c_protocol_list: *const c_char) -> c_int {
  102. if c_protocol_list.is_null() {
  103. return 1;
  104. }
  105. // Require an unsafe block to read the version from a C string. The pointer
  106. // is checked above to ensure it is not null.
  107. let c_str: &CStr = unsafe { CStr::from_ptr(c_protocol_list) };
  108. let protocol_list = match c_str.to_str() {
  109. Ok(n) => n,
  110. Err(_) => return 1,
  111. };
  112. match protocol_list.parse::<UnvalidatedProtoEntry>() {
  113. Ok(_) => 0,
  114. Err(_) => 1,
  115. }
  116. }
  117. /// Provide an interface for C to translate arguments and return types for
  118. /// protover::list_supports_protocol_or_later
  119. #[no_mangle]
  120. pub extern "C" fn protocol_list_supports_protocol_or_later(
  121. c_protocol_list: *const c_char,
  122. c_protocol: uint32_t,
  123. version: uint32_t,
  124. ) -> c_int {
  125. if c_protocol_list.is_null() {
  126. return 1;
  127. }
  128. // Require an unsafe block to read the version from a C string. The pointer
  129. // is checked above to ensure it is not null.
  130. let c_str: &CStr = unsafe { CStr::from_ptr(c_protocol_list) };
  131. let protocol_list = match c_str.to_str() {
  132. Ok(n) => n,
  133. Err(_) => return 1,
  134. };
  135. let protocol = match translate_to_rust(c_protocol) {
  136. Ok(n) => n,
  137. Err(_) => return 0,
  138. };
  139. let proto_entry: UnvalidatedProtoEntry = match protocol_list.parse() {
  140. Ok(n) => n,
  141. Err(_) => return 1,
  142. };
  143. if proto_entry.supports_protocol_or_later(&protocol.into(), &version) {
  144. return 1;
  145. }
  146. 0
  147. }
  148. /// Provide an interface for C to translate arguments and return types for
  149. /// protover::get_supported_protocols
  150. #[no_mangle]
  151. pub extern "C" fn protover_get_supported_protocols() -> *const c_char {
  152. let supported: &'static CStr;
  153. supported = get_supported_protocols_cstr();
  154. supported.as_ptr()
  155. }
  156. /// Provide an interface for C to translate arguments and return types for
  157. /// protover::compute_vote
  158. //
  159. // Why is the threshold a signed integer? —isis
  160. #[no_mangle]
  161. pub extern "C" fn protover_compute_vote(list: *const Stringlist, threshold: c_int) -> *mut c_char {
  162. if list.is_null() {
  163. return allocate_and_copy_string("");
  164. }
  165. // Dereference of raw pointer requires an unsafe block. The pointer is
  166. // checked above to ensure it is not null.
  167. let data: Vec<String> = unsafe { (*list).get_list() };
  168. let hold: usize = threshold as usize;
  169. let mut proto_entries: Vec<UnvalidatedProtoEntry> = Vec::new();
  170. for datum in data {
  171. let entry: UnvalidatedProtoEntry = match datum.parse() {
  172. Ok(n) => n,
  173. Err(_) => continue,
  174. };
  175. proto_entries.push(entry);
  176. }
  177. let vote: UnvalidatedProtoEntry = ProtoverVote::compute(&proto_entries, &hold);
  178. allocate_and_copy_string(&vote.to_string())
  179. }
  180. /// Provide an interface for C to translate arguments and return types for
  181. /// protover::is_supported_here
  182. #[no_mangle]
  183. pub extern "C" fn protover_is_supported_here(c_protocol: uint32_t, version: uint32_t) -> c_int {
  184. let protocol = match translate_to_rust(c_protocol) {
  185. Ok(n) => n,
  186. Err(_) => return 0,
  187. };
  188. let is_supported = is_supported_here(&protocol, &version);
  189. return if is_supported { 1 } else { 0 };
  190. }
  191. /// Provide an interface for C to translate arguments and return types for
  192. /// protover::compute_for_old_tor
  193. #[no_mangle]
  194. pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const c_char {
  195. let supported: &'static CStr;
  196. let empty: &'static CStr;
  197. empty = cstr!("");
  198. if version.is_null() {
  199. return empty.as_ptr();
  200. }
  201. // Require an unsafe block to read the version from a C string. The pointer
  202. // is checked above to ensure it is not null.
  203. let c_str: &CStr = unsafe { CStr::from_ptr(version) };
  204. let version = match c_str.to_str() {
  205. Ok(n) => n,
  206. Err(_) => return empty.as_ptr(),
  207. };
  208. supported = compute_for_old_tor_cstr(&version);
  209. supported.as_ptr()
  210. }