tor-commits February 2018

tor-commits@lists.torproject.org

19 participants
1579 discussions

[tor/master] Merge branch 'onion_ntor_malloc_less'
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit ed1d630f0e3d2d733989eefe9fce5c287a7ca6c9 Merge: 28c3f538e e3d415448 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Feb 15 20:40:03 2018 -0500 Merge branch 'onion_ntor_malloc_less' changes/feature25150 | 4 ++++ src/or/onion.c | 5 ++--- 2 files changed, 6 insertions(+), 3 deletions(-)

1 0

[tor/master] Fix a stack-protector warning: don't use a variable-length buffer
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 4d994e7a9c8936c9e33df90b7468e7327f1794e9 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Feb 15 20:52:01 2018 -0500 Fix a stack-protector warning: don't use a variable-length buffer Instead, define a maximum size, and enforce it with an assertion. --- src/or/onion.c | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/or/onion.c b/src/or/onion.c index 4fc501383..0c88c4d7e 100644 --- a/src/or/onion.c +++ b/src/or/onion.c @@ -521,6 +521,11 @@ onion_skin_create(int type, return r; } +/* This is the maximum value for keys_out_len passed to + * onion_skin_server_handshake, plus 16. We can make it bigger if needed: + * It just defines how many bytes to stack-allocate. */ +#define MAX_KEYS_TMP_LEN 128 + /** Perform the second (server-side) step of a circuit-creation handshake of * type type, responding to the client request in onion_skin * using the keys in keys. On success, write our response into @@ -563,7 +568,8 @@ onion_skin_server_handshake(int type, return -1; { size_t keys_tmp_len = keys_out_len + DIGEST_LEN; - uint8_t keys_tmp[keys_tmp_len]; + tor_assert(keys_tmp_len <= MAX_KEYS_TMP_LEN); + uint8_t keys_tmp[MAX_KEYS_TMP_LEN]; if (onion_skin_ntor_server_handshake( onion_skin, keys->curve25519_key_map, @@ -573,9 +579,10 @@ onion_skin_server_handshake(int type, /* no need to memwipe here, since the output will never be used */ return -1; } + memcpy(keys_out, keys_tmp, keys_out_len); memcpy(rend_nonce_out, keys_tmp+keys_out_len, DIGEST_LEN); - memwipe(keys_tmp, 0, keys_tmp_len); + memwipe(keys_tmp, 0, sizeof(keys_tmp)); r = NTOR_REPLY_LEN; } break;

1 0

[tor/master] Avoid a malloc/free pair for each (server-side) ntor handshake
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit e3d4154486b278e1ee68f97c3445817759b0f73c Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Feb 5 11:50:16 2018 -0500 Avoid a malloc/free pair for each (server-side) ntor handshake Closes ticket 25150 --- changes/feature25150 | 4 ++++ src/or/onion.c | 5 ++--- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/changes/feature25150 b/changes/feature25150 new file mode 100644 index 000000000..eb65327a8 --- /dev/null +++ b/changes/feature25150 @@ -0,0 +1,4 @@ + o Minor features (performance, allocation): + - Avoid a needless malloc()/free() pair every time we handle an ntor + handshake. Closes ticket 25150. + diff --git a/src/or/onion.c b/src/or/onion.c index bd80c2f50..4fc501383 100644 --- a/src/or/onion.c +++ b/src/or/onion.c @@ -563,20 +563,19 @@ onion_skin_server_handshake(int type, return -1; { size_t keys_tmp_len = keys_out_len + DIGEST_LEN; - uint8_t *keys_tmp = tor_malloc(keys_out_len + DIGEST_LEN); + uint8_t keys_tmp[keys_tmp_len]; if (onion_skin_ntor_server_handshake( onion_skin, keys->curve25519_key_map, keys->junk_keypair, keys->my_identity, reply_out, keys_tmp, keys_tmp_len)<0) { - tor_free(keys_tmp); + /* no need to memwipe here, since the output will never be used */ return -1; } memcpy(keys_out, keys_tmp, keys_out_len); memcpy(rend_nonce_out, keys_tmp+keys_out_len, DIGEST_LEN); memwipe(keys_tmp, 0, keys_tmp_len); - tor_free(keys_tmp); r = NTOR_REPLY_LEN; } break;

1 0

[tor/master] Merge branch 'bug24914'
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 8da6bfa5dedbbb03d12bb81974a265feb88122c1 Merge: 4d994e7a9 91c63aae8 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Feb 15 20:53:50 2018 -0500 Merge branch 'bug24914' changes/bug24914 | 3 +++ configure.ac | 4 ++++ src/common/crypto.c | 28 ++++++++++++++++++++++++++++ src/common/crypto.h | 11 +++++++++++ src/or/relay.c | 16 +++++++++------- 5 files changed, 55 insertions(+), 7 deletions(-)

1 0

[tor/master] Documentation fixes suggested by catalyst.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 28c3f538e50af1b4a10e613856841ea8ca41bc33 Author: Nick Mathewson <nickm(a)torproject.org> Date: Thu Feb 15 20:38:08 2018 -0500 Documentation fixes suggested by catalyst. --- src/rust/tor_util/strings.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs index 4e26e7369..505191d91 100644 --- a/src/rust/tor_util/strings.rs +++ b/src/rust/tor_util/strings.rs @@ -83,10 +83,10 @@ /// # Note /// /// An unfortunate limitation of the rustc compiler (as of 1.25.0-nightly), is -/// that the above code compiles, however if we were to change the assignment of -/// `tuesday` as follows, it will fail to compile, because Rust macros are -/// expanded at parse time, and at parse time there is no symbols table -/// available. +/// that the first example above compiles, but if we were to change the +/// assignment of `tuesday` as follows, it will fail to compile, because Rust +/// macros are expanded at parse time, and at parse time there is no symbol +/// table available. /// /// ```ignore /// tuesday = cstr!(message);

1 0

[tor/master] rust: Use tor_util::strings utils for protover_get_supported_protocols.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 3c4e006e7e9597ef0d478ef63c811c764926bfbe Author: Isis Lovecruft <isis(a)torproject.org> Date: Thu Feb 8 22:08:11 2018 +0000 rust: Use tor_util::strings utils for protover_get_supported_protocols. --- src/rust/protover/ffi.rs | 14 +-------- src/rust/protover/lib.rs | 1 + src/rust/protover/protover.rs | 71 ++++++++++++++++++++++++------------------- 3 files changed, 41 insertions(+), 45 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index 2ee0286ec..404b15838 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -15,7 +15,6 @@ use tor_allocate::allocate_and_copy_string; use tor_util::strings::byte_slice_is_c_like; use tor_util::strings::empty_static_cstr; - /// Translate C enums to Rust Proto enums, using the integer value of the C /// enum to map to its associated Rust enum /// @@ -143,18 +142,7 @@ pub extern "C" fn protocol_list_supports_protocol_or_later( pub extern "C" fn protover_get_supported_protocols() -> *const c_char { let supported: &'static CStr; - // If we're going to pass it to C, there cannot be any intermediate NUL - // bytes. An assert is okay here, since changing the const byte slice - // in protover.rs to contain a NUL byte somewhere in the middle would be a - // programming error. - assert!(byte_slice_is_c_like(SUPPORTED_PROTOCOLS)); - - // It's okay to unwrap the result of this function because - // we can see that the bytes we're passing into it 1) are valid UTF-8, - // 2) have no intermediate NUL bytes, and 3) are terminated with a NUL - // byte. - supported = CStr::from_bytes_with_nul(SUPPORTED_PROTOCOLS).unwrap(); - + supported = get_supported_protocols_cstr(); supported.as_ptr() } diff --git a/src/rust/protover/lib.rs b/src/rust/protover/lib.rs index fe8c0f9bb..8e80fcef4 100644 --- a/src/rust/protover/lib.rs +++ b/src/rust/protover/lib.rs @@ -26,6 +26,7 @@ extern crate libc; extern crate smartlist; extern crate external; extern crate tor_allocate; +#[macro_use] extern crate tor_util; mod protover; diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs index 25f776aed..d354d8e25 100644 --- a/src/rust/protover/protover.rs +++ b/src/rust/protover/protover.rs @@ -5,6 +5,7 @@ use external::c_tor_version_as_new_as; use std::str; use std::str::FromStr; +use std::ffi::CStr; use std::fmt; use std::collections::{HashMap, HashSet}; use std::ops::Range; @@ -25,30 +26,6 @@ const FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS: &'static str = "0.2.9.3-alpha"; /// C_RUST_COUPLED: src/or/protover.c `MAX_PROTOCOLS_TO_EXPAND` const MAX_PROTOCOLS_TO_EXPAND: u32 = 500; -/// Currently supported protocols and their versions, as a byte-slice. -/// -/// # Warning -/// -/// This byte-slice ends in a NUL byte. This is so that we can directly convert -/// it to an `&'static CStr` in the FFI code, in order to hand the static string -/// to C in a way that is compatible with C static strings. -/// -/// Rust code which wishes to accesses this string should use -/// `protover::get_supported_protocols()` instead. -/// -/// C_RUST_COUPLED: src/or/protover.c `protover_get_supported_protocols` -pub(crate) const SUPPORTED_PROTOCOLS: &'static [u8] = - b"Cons=1-2 \ - Desc=1-2 \ - DirCache=1-2 \ - HSDir=1-2 \ - HSIntro=3-4 \ - HSRend=1-2 \ - Link=1-5 \ - LinkAuth=1,3 \ - Microdesc=1-2 \ - Relay=1-2\0"; - /// Known subprotocols in Tor. Indicates which subprotocol a relay supports. /// /// C_RUST_COUPLED: src/or/protover.h `protocol_type_t` @@ -96,21 +73,51 @@ impl FromStr for Proto { } } -/// Get the string representation of current supported protocols +/// Get a CStr representation of current supported protocols, for +/// passing to C, or for converting to a `&str` for Rust. /// /// # Returns /// -/// A `String` whose value is the existing protocols supported by tor. +/// An `&'static CStr` whose value is the existing protocols supported by tor. /// Returned data is in the format as follows: /// /// "HSDir=1-1 LinkAuth=1" /// -pub fn get_supported_protocols() -> &'static str { - // The `len() - 1` is to remove the NUL byte. - // The `unwrap` is safe becauase we SUPPORTED_PROTOCOLS is under - // our control. - str::from_utf8(&SUPPORTED_PROTOCOLS[..SUPPORTED_PROTOCOLS.len() - 1]) - .unwrap_or("") +/// # Note +/// +/// Rust code can use the `&'static CStr` as a normal `&'a str` by +/// calling `protover::get_supported_protocols`. +/// +// C_RUST_COUPLED: src/or/protover.c `protover_get_supported_protocols` +pub(crate) fn get_supported_protocols_cstr() -> &'static CStr { + cstr!("Cons=1-2 \ + Desc=1-2 \ + DirCache=1-2 \ + HSDir=1-2 \ + HSIntro=3-4 \ + HSRend=1-2 \ + Link=1-5 \ + LinkAuth=1,3 \ + Microdesc=1-2 \ + Relay=1-2") +} + +/// Get a string representation of current supported protocols. +/// +/// # Returns +/// +/// An `&'a str` whose value is the existing protocols supported by tor. +/// Returned data is in the format as follows: +/// +/// "HSDir=1-1 LinkAuth=1" +pub fn get_supported_protocols<'a>() -> &'a str { + let supported_cstr: &'static CStr = get_supported_protocols_cstr(); + let supported: &str = match supported_cstr.to_str() { + Ok(x) => x, + Err(_) => "", + }; + + supported } pub struct SupportedProtocols(HashMap<Proto, Versions>);

1 0

[tor/master] rust: Remove empty_static_cstr() in favour of new cstr!() macro.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 081e99c16f754ffd5605acdfddec527a2a426ed8 Author: Isis Lovecruft <isis(a)torproject.org> Date: Sat Feb 10 01:41:06 2018 +0000 rust: Remove empty_static_cstr() in favour of new cstr!() macro. --- src/rust/protover/ffi.rs | 3 +-- src/rust/tor_util/strings.rs | 39 --------------------------------------- 2 files changed, 1 insertion(+), 41 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index c86fe7522..1df0b6675 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -13,7 +13,6 @@ use protover::*; use smartlist::*; use tor_allocate::allocate_and_copy_string; use tor_util::strings::byte_slice_is_c_like; -use tor_util::strings::empty_static_cstr; /// Translate C enums to Rust Proto enums, using the integer value of the C /// enum to map to its associated Rust enum @@ -192,7 +191,7 @@ pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const let supported: &'static CStr; let empty: &'static CStr; - empty = empty_static_cstr(); + empty = cstr!(""); if version.is_null() { return empty.as_ptr(); diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs index 659e792a3..dc4919d80 100644 --- a/src/rust/tor_util/strings.rs +++ b/src/rust/tor_util/strings.rs @@ -3,8 +3,6 @@ //! Utilities for working with static strings. -use std::ffi::CStr; - /// A byte-array containing a single NUL byte (`b"\0"`). pub const NUL_BYTE: &'static [u8] = b"\0"; @@ -44,43 +42,6 @@ pub fn byte_slice_is_c_like(bytes: &[u8]) -> bool { false } -/// Get a static `CStr` containing a single `NUL_BYTE`. -/// -/// # Examples -/// -/// When used as follows in a Rust FFI function, which could be called -/// from C: -/// -/// ``` -/// # extern crate libc; -/// # extern crate tor_util; -/// # -/// # use tor_util::strings::empty_static_cstr; -/// use libc::c_char; -/// use std::ffi::CStr; -/// -/// pub extern "C" fn give_c_code_an_empty_static_string() -> *const c_char { -/// let empty: &'static CStr = empty_static_cstr(); -/// -/// empty.as_ptr() -/// } -/// -/// # fn main() { -/// # give_c_code_an_empty_static_string(); -/// # } -/// ``` -/// -/// This equates to an "empty" `const char*` static string in C. -pub fn empty_static_cstr() -> &'static CStr { - let empty: &'static CStr; - - unsafe { - empty = CStr::from_bytes_with_nul_unchecked(NUL_BYTE); - } - - empty -} - /// Create a `CStr` from a literal byte slice, appending a NUL byte to it first. /// /// # Warning

1 0

[tor/master] rust: Add macro for passing static borrowed strings from Rust to C.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 8fff331bb095dc6f5e2fe2ecfc9ab08ea9e2fe97 Author: Isis Lovecruft <isis(a)torproject.org> Date: Thu Feb 8 20:06:19 2018 +0000 rust: Add macro for passing static borrowed strings from Rust to C. * ADD a new macro, tor_util::string::cstr!() which takes Rust strings, concatenates them together, appends a NUL byte, and converts it into a std::ffi::CStr for handing to C. --- src/rust/tor_util/strings.rs | 136 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 136 insertions(+) diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs index 9321ce4f8..659e792a3 100644 --- a/src/rust/tor_util/strings.rs +++ b/src/rust/tor_util/strings.rs @@ -80,3 +80,139 @@ pub fn empty_static_cstr() -> &'static CStr { empty } + +/// Create a `CStr` from a literal byte slice, appending a NUL byte to it first. +/// +/// # Warning +/// +/// The literal byte slice which is taken as an argument *MUST NOT* have any NUL +/// bytes (`b"\0"`) in it, anywhere, or else an empty string will be returned +/// (`CStr::from_bytes_with_nul_unchecked(b"\0")`) so as to avoid `panic!()`ing. +/// +/// # Examples +/// +/// ``` +/// #[macro_use] +/// extern crate tor_util; +/// +/// use std::ffi::CStr; +/// +/// # fn do_test() -> Result<&'static CStr, &'static str> { +/// let message: &'static str = "This is a test of the tsunami warning system."; +/// let tuesday: &'static CStr; +/// let original: &str; +/// +/// tuesday = cstr!("This is a test of the tsunami warning system."); +/// original = tuesday.to_str().or(Err("Couldn't unwrap CStr!"))?; +/// +/// assert!(original == message); +/// # +/// # Ok(tuesday) +/// # } +/// # fn main() { +/// # do_test(); // so that we can use the ? operator in the test +/// # } +/// ``` +/// It is also possible to pass several string literals to this macro. They +/// will be concatenated together in the order of the arguments, unmodified, +/// before finally being suffixed with a NUL byte: +/// +/// ``` +/// #[macro_use] +/// extern crate tor_util; +/// # +/// # use std::ffi::CStr; +/// # +/// # fn do_test() -> Result<&'static CStr, &'static str> { +/// +/// let quux: &'static CStr = cstr!("foo", "bar", "baz"); +/// let orig: &'static str = quux.to_str().or(Err("Couldn't unwrap CStr!"))?; +/// +/// assert!(orig == "foobarbaz"); +/// # Ok(quux) +/// # } +/// # fn main() { +/// # do_test(); // so that we can use the ? operator in the test +/// # } +/// ``` +/// This is useful for passing static strings to C from Rust FFI code. To do so +/// so, use the `.as_ptr()` method on the resulting `&'static CStr` to convert +/// it to the Rust equivalent of a C `const char*`: +/// +/// ``` +/// #[macro_use] +/// extern crate tor_util; +/// +/// use std::ffi::CStr; +/// use std::os::raw::c_char; +/// +/// pub extern "C" fn give_static_borrowed_string_to_c() -> *const c_char { +/// let hello: &'static CStr = cstr!("Hello, language my parents wrote."); +/// +/// hello.as_ptr() +/// } +/// # fn main() { +/// # let greetings = give_static_borrowed_string_to_c(); +/// # } +/// ``` +/// Note that the C code this static borrowed string is passed to *MUST NOT* +/// attempt to free the memory for the string. +/// +/// # Note +/// +/// An unfortunate limitation of the rustc compiler (as of 1.25.0-nightly), is +/// that the above code compiles, however if we were to change the assignment of +/// `tuesday` as follows, it will fail to compile, because Rust macros are +/// expanded at parse time, and at parse time there is no symbols table +/// available. +/// +/// ```ignore +/// tuesday = cstr!(message); +/// ``` +/// with the error message `error: expected a literal`. +/// +/// # Returns +/// +/// If the string literals passed as arguments contain no NUL bytes anywhere, +/// then an `&'static CStr` containing the (concatenated) bytes of the string +/// literal(s) passed as arguments, with a NUL byte appended, is returned. +/// Otherwise, an `&'static CStr` containing a single NUL byte is returned (an +/// "empty" string in C). +#[macro_export] +macro_rules! cstr { + ($($bytes:expr),*) => ( + ::std::ffi::CStr::from_bytes_with_nul( + concat!($($bytes),*, "\0").as_bytes() + ).unwrap_or( + unsafe{ + ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"\0") + } + ) + ) +} + +#[cfg(test)] +mod test { + use std::ffi::CStr; + + #[test] + fn cstr_macro() { + let _: &'static CStr = cstr!("boo"); + } + + #[test] + fn cstr_macro_multi_input() { + let quux: &'static CStr = cstr!("foo", "bar", "baz"); + + assert!(quux.to_str().unwrap() == "foobarbaz"); + } + + #[test] + fn cstr_macro_bad_input() { + let waving: &'static CStr = cstr!("waving not drowning o/"); + let drowning: &'static CStr = cstr!("\0 drowning not waving"); + + assert!(waving.to_str().unwrap() == "waving not drowning o/"); + assert!(drowning.to_str().unwrap() == "") + } +}

1 0

[tor/master] rust: Remove now unused byte_slice_is_c_like() utility.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit a4797a7e62f3f53326b3d33fa72b23f1dc0bc061 Author: Isis Lovecruft <isis(a)torproject.org> Date: Sat Feb 10 02:20:50 2018 +0000 rust: Remove now unused byte_slice_is_c_like() utility. --- src/rust/protover/ffi.rs | 1 - src/rust/tor_util/strings.rs | 39 --------------------------------------- 2 files changed, 40 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index 1df0b6675..e4cf0a7e8 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -12,7 +12,6 @@ use std::ffi::CString; use protover::*; use smartlist::*; use tor_allocate::allocate_and_copy_string; -use tor_util::strings::byte_slice_is_c_like; /// Translate C enums to Rust Proto enums, using the integer value of the C /// enum to map to its associated Rust enum diff --git a/src/rust/tor_util/strings.rs b/src/rust/tor_util/strings.rs index dc4919d80..4e26e7369 100644 --- a/src/rust/tor_util/strings.rs +++ b/src/rust/tor_util/strings.rs @@ -3,45 +3,6 @@ //! Utilities for working with static strings. -/// A byte-array containing a single NUL byte (`b"\0"`). -pub const NUL_BYTE: &'static [u8] = b"\0"; - -/// Determine if a byte slice is a C-like string. -/// -/// These checks guarantee that: -/// -/// 1. there are no intermediate NUL bytes -/// 2. the last byte *is* a NUL byte -/// -/// # Warning -/// -/// This function does _not_ guarantee that the bytes represent any valid -/// encoding such as ASCII or UTF-8. -/// -/// # Examples -/// -/// ``` -/// # use tor_util::strings::byte_slice_is_c_like; -/// # -/// let bytes: &[u8] = b"foo bar baz"; -/// -/// assert!(byte_slice_is_c_like(&bytes) == false); -/// -/// let bytes: &[u8] = b"foo\0bar baz"; -/// -/// assert!(byte_slice_is_c_like(&bytes) == false); -/// -/// let bytes: &[u8] = b"foo bar baz\0"; -/// -/// assert!(byte_slice_is_c_like(&bytes) == true); -/// ``` -pub fn byte_slice_is_c_like(bytes: &[u8]) -> bool { - if !bytes[..bytes.len() - 1].contains(&0x00) && bytes[bytes.len() - 1] == 0x00 { - return true; - } - false -} - /// Create a `CStr` from a literal byte slice, appending a NUL byte to it first. /// /// # Warning

1 0

[tor/master] rust: Use tor_util::strings utils for protover_compute_for_old_tor.
by nickm＠torproject.org 16 Feb '18

16 Feb '18

commit 6c77593a57d5a22a2fb3105d1466fb3ed26b1244 Author: Isis Lovecruft <isis(a)torproject.org> Date: Sat Feb 10 01:52:26 2018 +0000 rust: Use tor_util::strings utils for protover_compute_for_old_tor. --- src/rust/protover/ffi.rs | 16 +--------------- src/rust/protover/protover.rs | 24 ++++++++++++------------ 2 files changed, 13 insertions(+), 27 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index 404b15838..c86fe7522 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -190,7 +190,6 @@ pub extern "C" fn protover_is_supported_here( #[no_mangle] pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const c_char { let supported: &'static CStr; - let elder_protocols: &'static [u8]; let empty: &'static CStr; empty = empty_static_cstr(); @@ -208,19 +207,6 @@ pub extern "C" fn protover_compute_for_old_tor(version: *const c_char) -> *const Err(_) => return empty.as_ptr(), }; - elder_protocols = compute_for_old_tor(&version); - - // If we're going to pass it to C, there cannot be any intermediate NUL - // bytes. An assert is okay here, since changing the const byte slice - // in protover.rs to contain a NUL byte somewhere in the middle would be a - // programming error. - assert!(byte_slice_is_c_like(elder_protocols)); - - // It's okay to unwrap the result of this function because - // we can see that the bytes we're passing into it 1) are valid UTF-8, - // 2) have no intermediate NUL bytes, and 3) are terminated with a NUL - // byte. - supported = CStr::from_bytes_with_nul(elder_protocols).unwrap_or(empty); - + supported = compute_for_old_tor(&version); supported.as_ptr() } diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs index d354d8e25..e9fcdddd9 100644 --- a/src/rust/protover/protover.rs +++ b/src/rust/protover/protover.rs @@ -11,8 +11,6 @@ use std::collections::{HashMap, HashSet}; use std::ops::Range; use std::string::String; -use tor_util::strings::NUL_BYTE; - /// The first version of Tor that included "proto" entries in its descriptors. /// Authorities should use this to decide whether to guess proto lines. /// @@ -744,7 +742,7 @@ pub fn is_supported_here(proto: Proto, vers: Version) -> bool { /// /// # Returns /// -/// A `&'static [u8]` encoding a list of protocol names and supported +/// A `&'static CStr` encoding a list of protocol names and supported /// versions. The string takes the following format: /// /// "HSDir=1-1 LinkAuth=1" @@ -753,27 +751,29 @@ pub fn is_supported_here(proto: Proto, vers: Version) -> bool { /// only for tor versions older than FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS. /// /// C_RUST_COUPLED: src/rust/protover.c `compute_for_old_tor` -pub fn compute_for_old_tor(version: &str) -> &'static [u8] { +pub fn compute_for_old_tor(version: &str) -> &'static CStr { + let empty: &'static CStr = cstr!(""); + if c_tor_version_as_new_as(version, FIRST_TOR_VERSION_TO_ADVERTISE_PROTOCOLS) { - return NUL_BYTE; + return empty; } if c_tor_version_as_new_as(version, "0.2.9.1-alpha") { - return b"Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1-2 \ - Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2\0"; + return cstr!("Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1-2 \ + Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2"); } if c_tor_version_as_new_as(version, "0.2.7.5") { - return b"Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \ - Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2\0"; + return cstr!("Cons=1-2 Desc=1-2 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \ + Link=1-4 LinkAuth=1 Microdesc=1-2 Relay=1-2"); } if c_tor_version_as_new_as(version, "0.2.4.19") { - return b"Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \ - Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2\0"; + return cstr!("Cons=1 Desc=1 DirCache=1 HSDir=1 HSIntro=3 HSRend=1 \ + Link=1-4 LinkAuth=1 Microdesc=1 Relay=1-2"); } - NUL_BYTE + empty } #[cfg(test)]

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits February 2018