tor-commits March 2018

tor-commits@lists.torproject.org

15 participants
1430 discussions

[tor/master] cargo fmt fixes
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit cd8bcacfe1053d067127507b4ebd8bd7b33309e9 Author: Chelsea Holland Komlo <me(a)chelseakomlo.com> Date: Mon Nov 27 23:00:33 2017 -0500 cargo fmt fixes --- src/rust/protover/ffi.rs | 8 +++++--- src/rust/protover/protover.rs | 4 +--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/rust/protover/ffi.rs b/src/rust/protover/ffi.rs index 3eb22c933..02b7dec37 100644 --- a/src/rust/protover/ffi.rs +++ b/src/rust/protover/ffi.rs @@ -127,9 +127,11 @@ pub extern "C" fn protocol_list_supports_protocol_or_later( Err(_) => return 0, }; - let is_supported = - protover_string_supports_protocol_or_later( - protocol_list, protocol, version); + let is_supported = protover_string_supports_protocol_or_later( + protocol_list, + protocol, + version, + ); return if is_supported { 1 } else { 0 }; } diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs index 1c159afef..bb2b8f056 100644 --- a/src/rust/protover/protover.rs +++ b/src/rust/protover/protover.rs @@ -496,9 +496,7 @@ fn find_range(list: &Vec<u32>) -> (bool, u32) { /// A `String` representation of this set in ascending order. /// fn contract_protocol_list<'a>(supported_set: &'a HashSet<u32>) -> String { - let mut supported: Vec<u32> = supported_set.iter() - .map(|x| *x) - .collect(); + let mut supported: Vec<u32> = supported_set.iter().map(|x| *x).collect(); supported.sort(); let mut final_output: Vec<String> = Vec::new();

1 0

[tor/master] allow running protover test with a testing feature flag
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit d4be1b1e76a8f31bfd38109f91cffda949c1ebba Author: Chelsea Holland Komlo <me(a)chelseakomlo.com> Date: Wed Dec 20 00:07:30 2017 -0500 allow running protover test with a testing feature flag --- src/rust/protover/Cargo.toml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/rust/protover/Cargo.toml b/src/rust/protover/Cargo.toml index 279916bd2..3f70155ef 100644 --- a/src/rust/protover/Cargo.toml +++ b/src/rust/protover/Cargo.toml @@ -3,6 +3,9 @@ authors = ["The Tor Project"] version = "0.0.1" name = "protover" +[features] +testing = ["tor_log/testing"] + [dependencies] libc = "0.2.22"

1 0

[tor/master] move macro body to inline rust function
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit 71a53761415885b3d5f290c3996d1f1634364f8e Author: Chelsea Holland Komlo <me(a)chelseakomlo.com> Date: Sat Dec 16 20:22:21 2017 -0500 move macro body to inline rust function --- src/rust/protover/lib.rs | 2 + src/rust/protover/protover.rs | 2 +- src/rust/tor_log/tor_log.rs | 155 +++++++++++++----------------------------- src/rust/tor_util/ffi.rs | 2 +- src/rust/tor_util/lib.rs | 2 + 5 files changed, 52 insertions(+), 111 deletions(-) diff --git a/src/rust/protover/lib.rs b/src/rust/protover/lib.rs index a9e8e1ee6..05687c1fb 100644 --- a/src/rust/protover/lib.rs +++ b/src/rust/protover/lib.rs @@ -26,6 +26,8 @@ extern crate libc; extern crate smartlist; extern crate external; extern crate tor_allocate; + +#[macro_use] extern crate tor_log; mod protover; diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs index bb2b8f056..33d49ea48 100644 --- a/src/rust/protover/protover.rs +++ b/src/rust/protover/protover.rs @@ -6,7 +6,7 @@ use std::fmt; use std::collections::{HashMap, HashSet}; use std::string::String; -use tor_log::*; +use tor_log::{LogSeverity, LogDomain}; use external::c_tor_version_as_new_as; /// The first version of Tor that included "proto" entries in its descriptors. diff --git a/src/rust/tor_log/tor_log.rs b/src/rust/tor_log/tor_log.rs index badbf3a29..f583ac6dc 100644 --- a/src/rust/tor_log/tor_log.rs +++ b/src/rust/tor_log/tor_log.rs @@ -1,6 +1,8 @@ // Copyright (c) 2016-2017, The Tor Project, Inc. */ // See LICENSE for licensing information */ +// Note that these functions are untested due to the fact that there are no +// return variables to test and they are calling into a C API. /// The related domain which the logging message is relevant. For example, /// log messages relevant to networking would use LogDomain::LdNet, whereas @@ -39,64 +41,65 @@ macro_rules! tor_log_msg { $($message:tt)*) => { { - use std::ffi::CString; - - /// Default function name to log in case of errors when converting - /// a function name to a CString - const ERR_LOG_FUNCTION: &str = "tor_log_msg"; + let msg = format!($($message)*); + $crate::tor_log_msg_impl($severity, $domain, $function, msg) + } + }; +} - /// Default message to log in case of errors when converting a log - /// message to a CString - const ERR_LOG_MSG: &str = "Unable to log message from Rust +#[inline] +pub fn tor_log_msg_impl( + severity: LogSeverity, + domain: LogDomain, + function: &str, + message: String, +) { + use std::ffi::CString; + + /// Default function name to log in case of errors when converting + /// a function name to a CString + const ERR_LOG_FUNCTION: &str = "tor_log_msg"; + + /// Default message to log in case of errors when converting a log + /// message to a CString + const ERR_LOG_MSG: &str = "Unable to log message from Rust module due to error when converting to CString"; - let func = match CString::new($function) { - Ok(n) => n, - Err(_) => CString::new(ERR_LOG_FUNCTION).unwrap(), - }; + let func = match CString::new(function) { + Ok(n) => n, + Err(_) => CString::new(ERR_LOG_FUNCTION).unwrap(), + }; - let msg = match CString::new(format!($($message)*)) { - Ok(n) => n, - Err(_) => CString::new(ERR_LOG_MSG).unwrap(), - }; + let msg = match CString::new(message) { + Ok(n) => n, + Err(_) => CString::new(ERR_LOG_MSG).unwrap(), + }; - let func_ptr = func.as_ptr(); - let msg_ptr = msg.as_ptr(); + // Bind to a local variable to preserve ownership. This is essential so + // that ownership is guaranteed until these local variables go out of scope + let func_ptr = func.as_ptr(); + let msg_ptr = msg.as_ptr(); - let c_severity = unsafe { translate_severity($severity) }; - let c_domain = unsafe { translate_domain($domain) }; + let c_severity = unsafe { log::translate_severity(severity) }; + let c_domain = unsafe { log::translate_domain(domain) }; - unsafe { - $crate::tor_log_string(c_severity, c_domain, func_ptr, msg_ptr ) - } - } - }; + unsafe { log::tor_log_string(c_severity, c_domain, func_ptr, msg_ptr) } } -/// This module exposes no-op functionality purely for the purpose of testing -/// Rust at the module level. +/// This module exposes no-op functionality for testing other Rust modules +/// without linking to C. #[cfg(any(test, feature = "testing"))] pub mod log { use libc::{c_char, c_int}; use super::LogDomain; use super::LogSeverity; - /// Expose a no-op logging interface purely for testing Rust modules at the - /// module level. - pub fn tor_log_string<'a>( - severity: c_int, - domain: u32, - function: *const c_char, - message: *const c_char, - ) -> (c_int, u32, String, String) { - use std::ffi::CStr; - - let func = unsafe { CStr::from_ptr(function) }.to_str().unwrap(); - let func_allocated = String::from(func); - - let msg = unsafe { CStr::from_ptr(message) }.to_str().unwrap(); - let msg_allocated = String::from(msg); - (severity, domain, func_allocated, msg_allocated) + pub unsafe fn tor_log_string<'a>( + _severity: c_int, + _domain: u32, + _function: *const c_char, + _message: *const c_char, + ) { } pub unsafe fn translate_domain(_domain: LogDomain) -> u32 { @@ -143,7 +146,6 @@ pub mod log { /// Translate Rust defintions of log severity levels to C. This exposes a /// 1:1 mapping between types. - #[allow(unreachable_patterns)] pub unsafe fn translate_severity(severity: LogSeverity) -> c_int { match severity { LogSeverity::Warn => _LOG_WARN, @@ -162,68 +164,3 @@ pub mod log { ); } } - -#[cfg(test)] -mod test { - use tor_log::*; - use tor_log::log::*; - - use libc::c_int; - - #[test] - fn test_get_log_message() { - - fn test_macro<'a>() -> (c_int, u32, String, String) { - let (x, y, z, a) = - tor_log_msg!( - LogSeverity::Warn, - LogDomain::LdNet, - "test_macro", - "test log message {}", - "a", - ); - (x, y, z, a) - } - - let (severity, domain, function_name, log_msg) = test_macro(); - - let expected_severity = - unsafe { translate_severity(LogSeverity::Warn) }; - assert_eq!(severity, expected_severity); - - let expected_domain = unsafe { translate_domain(LogDomain::LdNet) }; - assert_eq!(domain, expected_domain); - - assert_eq!("test_macro", function_name); - assert_eq!("test log message a", log_msg); - } - - #[test] - fn test_get_log_message_multiple_values() { - fn test_macro<'a>() -> (c_int, u32, String, String) { - let (x, y, z, a) = tor_log_msg!( - LogSeverity::Warn, - LogDomain::LdNet, - "test_macro 2", - "test log message {} {} {} {}", - 10, - 9, - 8, - 7 - ); - (x, y, z, a) - } - - let (severity, domain, function_name, log_msg) = test_macro(); - - let expected_severity = - unsafe { translate_severity(LogSeverity::Warn) }; - assert_eq!(severity, expected_severity); - - let expected_domain = unsafe { translate_domain(LogDomain::LdNet) }; - assert_eq!(domain, expected_domain); - - assert_eq!("test_macro 2", function_name); - assert_eq!("test log message 10 9 8 7", log_msg); - } -} diff --git a/src/rust/tor_util/ffi.rs b/src/rust/tor_util/ffi.rs index 866d11974..a9a6cf895 100644 --- a/src/rust/tor_util/ffi.rs +++ b/src/rust/tor_util/ffi.rs @@ -5,7 +5,7 @@ //! called from C. //! -use tor_log::*; +use tor_log::{LogSeverity, LogDomain}; /// Returns a short string to announce Rust support during startup. /// diff --git a/src/rust/tor_util/lib.rs b/src/rust/tor_util/lib.rs index 86785c344..4d5cbb568 100644 --- a/src/rust/tor_util/lib.rs +++ b/src/rust/tor_util/lib.rs @@ -7,6 +7,8 @@ extern crate libc; extern crate tor_allocate; + +#[macro_use] extern crate tor_log; pub mod ffi;

1 0

[tor/master] fixups from code review
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit 0e032fe9ea494ab03e5db5ca901ddbddd147eb19 Author: Chelsea Holland Komlo <me(a)chelseakomlo.com> Date: Fri Dec 15 21:23:10 2017 -0500 fixups from code review --- src/rust/tor_log/tor_log.rs | 19 ++++++------------- 1 file changed, 6 insertions(+), 13 deletions(-) diff --git a/src/rust/tor_log/tor_log.rs b/src/rust/tor_log/tor_log.rs index 394e23244..badbf3a29 100644 --- a/src/rust/tor_log/tor_log.rs +++ b/src/rust/tor_log/tor_log.rs @@ -43,11 +43,11 @@ macro_rules! tor_log_msg { /// Default function name to log in case of errors when converting /// a function name to a CString - const ERR_LOG_FUNCTION: &'static str = "tor_log_msg"; + const ERR_LOG_FUNCTION: &str = "tor_log_msg"; /// Default message to log in case of errors when converting a log /// message to a CString - const ERR_LOG_MSG: &'static str = "Unable to log message from Rust + const ERR_LOG_MSG: &str = "Unable to log message from Rust module due to error when converting to CString"; let func = match CString::new($function) { @@ -63,11 +63,11 @@ macro_rules! tor_log_msg { let func_ptr = func.as_ptr(); let msg_ptr = msg.as_ptr(); + let c_severity = unsafe { translate_severity($severity) }; + let c_domain = unsafe { translate_domain($domain) }; + unsafe { - tor_log_string(translate_severity($severity), - translate_domain($domain), - func_ptr, msg_ptr - ) + $crate::tor_log_string(c_severity, c_domain, func_ptr, msg_ptr ) } } }; @@ -134,27 +134,20 @@ pub mod log { /// Translate Rust defintions of log domain levels to C. This exposes a 1:1 /// mapping between types. - /// - /// Allow for default cases in case Rust and C log types get out of sync - #[allow(unreachable_patterns)] pub unsafe fn translate_domain(domain: LogDomain) -> u32 { match domain { LogDomain::LdNet => _LD_NET, LogDomain::LdGeneral => _LD_GENERAL, - _ => _LD_GENERAL, } } /// Translate Rust defintions of log severity levels to C. This exposes a /// 1:1 mapping between types. - /// - /// Allow for default cases in case Rust and C log types get out of sync #[allow(unreachable_patterns)] pub unsafe fn translate_severity(severity: LogSeverity) -> c_int { match severity { LogSeverity::Warn => _LOG_WARN, LogSeverity::Notice => _LOG_NOTICE, - _ => _LOG_NOTICE, } }

1 0

[tor/master] fixups from code review
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit d0184963f9731bea82db1958c885ea1e7f7c42d1 Author: Chelsea Holland Komlo <me(a)chelseakomlo.com> Date: Mon Jan 22 18:33:22 2018 -0500 fixups from code review --- src/common/log.c | 8 +++--- src/common/torlog.h | 8 +++--- src/or/main.c | 4 +-- src/rust/protover/protover.rs | 8 +++--- src/rust/tor_log/tor_log.rs | 59 ++++++++++++++++++++++++++++++++++--------- src/rust/tor_util/ffi.rs | 4 +-- 6 files changed, 63 insertions(+), 28 deletions(-) diff --git a/src/common/log.c b/src/common/log.c index ebe6c228c..365a4673a 100644 --- a/src/common/log.c +++ b/src/common/log.c @@ -54,10 +54,10 @@ /** Defining compile-time constants for Tor log levels (used by the Rust * log wrapper at src/rust/tor_log) */ -const int _LOG_WARN = LOG_WARN; -const int _LOG_NOTICE = LOG_NOTICE; -const log_domain_mask_t _LD_GENERAL = LD_GENERAL; -const log_domain_mask_t _LD_NET = LD_NET; +const int LOG_WARN_ = LOG_WARN; +const int LOG_NOTICE_ = LOG_NOTICE; +const log_domain_mask_t LD_GENERAL_ = LD_GENERAL; +const log_domain_mask_t LD_NET_ = LD_NET; /** Information for a single logfile; only used in log.c */ typedef struct logfile_t { diff --git a/src/common/torlog.h b/src/common/torlog.h index 0ed990b6e..3ecaf50af 100644 --- a/src/common/torlog.h +++ b/src/common/torlog.h @@ -36,10 +36,10 @@ * * C_RUST_COUPLED src/rust/tor_log LogSeverity, LogDomain */ -extern const int _LOG_WARN; -extern const int _LOG_NOTICE; -extern const log_domain_mask_t _LD_NET; -extern const log_domain_mask_t _LD_GENERAL; +extern const int LOG_WARN_; +extern const int LOG_NOTICE_; +extern const log_domain_mask_t LD_NET_; +extern const log_domain_mask_t LD_GENERAL_; /** Debug-level severity: for hyper-verbose messages of no interest to * anybody but developers. */ diff --git a/src/or/main.c b/src/or/main.c index c19d4f690..b42b0b620 100644 --- a/src/or/main.c +++ b/src/or/main.c @@ -132,7 +132,7 @@ void evdns_shutdown(int); #ifdef HAVE_RUST // helper function defined in Rust to output a log message indicating if tor is // running with Rust enabled. See src/rust/tor_util -void rust_welcome_string(void); +void rust_log_welcome_string(void); #endif /********* PROTOTYPES **********/ @@ -3283,7 +3283,7 @@ tor_init(int argc, char *argv[]) } #ifdef HAVE_RUST - rust_welcome_string(); + rust_log_welcome_string(); #endif /* defined(HAVE_RUST) */ if (network_init()<0) { diff --git a/src/rust/protover/protover.rs b/src/rust/protover/protover.rs index 33d49ea48..22a94a164 100644 --- a/src/rust/protover/protover.rs +++ b/src/rust/protover/protover.rs @@ -243,11 +243,11 @@ fn contains_only_supported_protocols(proto_entry: &str) -> bool { Err("Too many versions to expand") => { tor_log_msg!( LogSeverity::Warn, - LogDomain::LdNet, + LogDomain::Net, "get_versions", - "When expanding a protocol list from an authority, I - got too many protocols. This is possibly an attack or a bug, - unless the Tor network truly has expanded to support over {} + "When expanding a protocol list from an authority, I \ + got too many protocols. This is possibly an attack or a bug, \ + unless the Tor network truly has expanded to support over {} \ different subprotocol versions. The offending string was: {}", MAX_PROTOCOLS_TO_EXPAND, proto_entry diff --git a/src/rust/tor_log/tor_log.rs b/src/rust/tor_log/tor_log.rs index f8bf19069..a88184cda 100644 --- a/src/rust/tor_log/tor_log.rs +++ b/src/rust/tor_log/tor_log.rs @@ -9,8 +9,8 @@ /// general messages can use LdGeneral. #[derive(Eq, PartialEq)] pub enum LogDomain { - LdNet, - LdGeneral, + Net, + General, } /// The severity level at which to log messages. @@ -98,33 +98,35 @@ pub mod log { /// C_RUST_COUPLED: src/common/log.c, log domain types extern "C" { #[no_mangle] - static _LOG_WARN: c_int; - static _LOG_NOTICE: c_int; + static LOG_WARN_: c_int; + static LOG_NOTICE_: c_int; } /// Domain log types. These mirror definitions in /src/common/torlog.h /// C_RUST_COUPLED: src/common/log.c, log severity types extern "C" { #[no_mangle] - static _LD_NET: u32; - static _LD_GENERAL: u32; + static LD_NET_: u32; + static LD_GENERAL_: u32; } /// Translate Rust defintions of log domain levels to C. This exposes a 1:1 /// mapping between types. + #[inline] pub unsafe fn translate_domain(domain: LogDomain) -> u32 { match domain { - LogDomain::LdNet => _LD_NET, - LogDomain::LdGeneral => _LD_GENERAL, + LogDomain::Net => LD_NET_, + LogDomain::General => LD_GENERAL_, } } /// Translate Rust defintions of log severity levels to C. This exposes a /// 1:1 mapping between types. + #[inline] pub unsafe fn translate_severity(severity: LogSeverity) -> c_int { match severity { - LogSeverity::Warn => _LOG_WARN, - LogSeverity::Notice => _LOG_NOTICE, + LogSeverity::Warn => LOG_WARN_, + LogSeverity::Notice => LOG_NOTICE_, } } @@ -194,7 +196,7 @@ mod test { fn test_macro() { tor_log_msg!( LogSeverity::Warn, - LogDomain::LdNet, + LogDomain::Net, "test_macro", "test log message {}", "a", @@ -210,11 +212,12 @@ mod test { assert_eq!("test log message a", *message); } + // test multiple inputs into the log message { fn test_macro() { tor_log_msg!( LogSeverity::Warn, - LogDomain::LdNet, + LogDomain::Net, "next_test_macro", "test log message {} {} {} {} {}", 1, @@ -233,5 +236,37 @@ mod test { let message = unsafe { Box::from_raw(LAST_LOGGED_MESSAGE) }; assert_eq!("test log message 1 2 3 4 5", *message); } + + // test how a long log message will be formatted + { + fn test_macro() { + tor_log_msg!( + LogSeverity::Warn, + LogDomain::Net, + "test_macro", + "{}", + "All the world's a stage, and all the men and women \ + merely players: they have their exits and their \ + entrances; and one man in his time plays many parts, his \ + acts being seven ages." + ); + } + + test_macro(); + + let expected_string = "All the world's a \ + stage, and all the men \ + and women merely players: \ + they have their exits and \ + their entrances; and one man \ + in his time plays many parts, \ + his acts being seven ages."; + + let function = unsafe { Box::from_raw(LAST_LOGGED_FUNCTION) }; + assert_eq!("test_macro", *function); + + let message = unsafe { Box::from_raw(LAST_LOGGED_MESSAGE) }; + assert_eq!(expected_string, *message); + } } } diff --git a/src/rust/tor_util/ffi.rs b/src/rust/tor_util/ffi.rs index a9a6cf895..a803dae26 100644 --- a/src/rust/tor_util/ffi.rs +++ b/src/rust/tor_util/ffi.rs @@ -16,10 +16,10 @@ use tor_log::{LogSeverity, LogDomain}; /// tor_free(rust_str); /// ``` #[no_mangle] -pub extern "C" fn rust_welcome_string() { +pub extern "C" fn rust_log_welcome_string() { tor_log_msg!( LogSeverity::Notice, - LogDomain::LdGeneral, + LogDomain::General, "rust_welcome_string", "Tor is running with Rust integration. Please report \ any bugs you encounter."

1 0

[tor/master] add testing implementation for tor logging
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit 4cdf0c8899796582b058d289bcd21b95dd1bd452 Author: Chelsea Holland Komlo <me(a)chelseakomlo.com> Date: Thu Dec 21 14:47:41 2017 -0500 add testing implementation for tor logging --- src/rust/tor_log/lib.rs | 1 - src/rust/tor_log/tor_log.rs | 121 +++++++++++++++++++++++++++++++++++--------- 2 files changed, 96 insertions(+), 26 deletions(-) diff --git a/src/rust/tor_log/lib.rs b/src/rust/tor_log/lib.rs index 915910d00..72f9e3833 100644 --- a/src/rust/tor_log/lib.rs +++ b/src/rust/tor_log/lib.rs @@ -14,4 +14,3 @@ extern crate tor_allocate; mod tor_log; pub use tor_log::*; -pub use tor_log::log::*; diff --git a/src/rust/tor_log/tor_log.rs b/src/rust/tor_log/tor_log.rs index f583ac6dc..9380934f3 100644 --- a/src/rust/tor_log/tor_log.rs +++ b/src/rust/tor_log/tor_log.rs @@ -86,31 +86,6 @@ pub fn tor_log_msg_impl( unsafe { log::tor_log_string(c_severity, c_domain, func_ptr, msg_ptr) } } -/// This module exposes no-op functionality for testing other Rust modules -/// without linking to C. -#[cfg(any(test, feature = "testing"))] -pub mod log { - use libc::{c_char, c_int}; - use super::LogDomain; - use super::LogSeverity; - - pub unsafe fn tor_log_string<'a>( - _severity: c_int, - _domain: u32, - _function: *const c_char, - _message: *const c_char, - ) { - } - - pub unsafe fn translate_domain(_domain: LogDomain) -> u32 { - 1 - } - - pub unsafe fn translate_severity(_severity: LogSeverity) -> c_int { - 1 - } -} - /// This implementation is used when compiling for actual use, as opposed to /// testing. #[cfg(all(not(test), not(feature = "testing")))] @@ -164,3 +139,99 @@ pub mod log { ); } } + +/// This module exposes no-op functionality for testing other Rust modules +/// without linking to C. +#[cfg(any(test, feature = "testing"))] +pub mod log { + use libc::{c_char, c_int}; + use super::LogDomain; + use super::LogSeverity; + + pub static mut LAST_LOGGED_FUNCTION: *mut String = 0 as *mut String; + pub static mut LAST_LOGGED_MESSAGE: *mut String = 0 as *mut String; + + pub unsafe fn tor_log_string<'a>( + _severity: c_int, + _domain: u32, + function: *const c_char, + message: *const c_char, + ) { + use std::ffi::CStr; + + let f = CStr::from_ptr(function); + let fct = match f.to_str() { + Ok(n) => n, + Err(_) => "", + }; + LAST_LOGGED_FUNCTION = Box::into_raw(Box::new(String::from(fct))); + + let m = CStr::from_ptr(message); + let msg = match m.to_str() { + Ok(n) => n, + Err(_) => "", + }; + LAST_LOGGED_MESSAGE = Box::into_raw(Box::new(String::from(msg))); + } + + pub unsafe fn translate_domain(_domain: LogDomain) -> u32 { + 1 + } + + pub unsafe fn translate_severity(_severity: LogSeverity) -> c_int { + 1 + } +} + +#[cfg(test)] +mod test { + use tor_log::*; + use tor_log::log::{LAST_LOGGED_FUNCTION, LAST_LOGGED_MESSAGE}; + + #[test] + fn test_get_log_message() { + { + fn test_macro() { + tor_log_msg!( + LogSeverity::Warn, + LogDomain::LdNet, + "test_macro", + "test log message {}", + "a", + ); + } + + test_macro(); + + let function = unsafe { Box::from_raw(LAST_LOGGED_FUNCTION) }; + assert_eq!("test_macro", *function); + + let message = unsafe { Box::from_raw(LAST_LOGGED_MESSAGE) }; + assert_eq!("test log message a", *message); + } + + { + fn test_macro() { + tor_log_msg!( + LogSeverity::Warn, + LogDomain::LdNet, + "next_test_macro", + "test log message {} {} {} {} {}", + 1, + 2, + 3, + 4, + 5 + ); + } + + test_macro(); + + let function = unsafe { Box::from_raw(LAST_LOGGED_FUNCTION) }; + assert_eq!("next_test_macro", *function); + + let message = unsafe { Box::from_raw(LAST_LOGGED_MESSAGE) }; + assert_eq!("test log message 1 2 3 4 5", *message); + } + } +}

1 0

[tor/master] remove unnecessary lifetime
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit 510a91af533afb48f9ad8b64d3d2bc4cd707d9b6 Author: Chelsea Holland Komlo <me(a)chelseakomlo.com> Date: Fri Dec 22 00:26:52 2017 -0500 remove unnecessary lifetime --- src/rust/tor_log/tor_log.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/rust/tor_log/tor_log.rs b/src/rust/tor_log/tor_log.rs index 9380934f3..f8bf19069 100644 --- a/src/rust/tor_log/tor_log.rs +++ b/src/rust/tor_log/tor_log.rs @@ -151,7 +151,7 @@ pub mod log { pub static mut LAST_LOGGED_FUNCTION: *mut String = 0 as *mut String; pub static mut LAST_LOGGED_MESSAGE: *mut String = 0 as *mut String; - pub unsafe fn tor_log_string<'a>( + pub unsafe fn tor_log_string( _severity: c_int, _domain: u32, function: *const c_char,

1 0

[tor/master] rust: Remove extra whitespace from a static log/error message.
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit 167da4bc81da7de0214357cbe08404703bc8c86a Author: Isis Lovecruft <isis(a)torproject.org> Date: Tue Feb 27 20:43:54 2018 +0000 rust: Remove extra whitespace from a static log/error message. --- src/rust/tor_log/tor_log.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/rust/tor_log/tor_log.rs b/src/rust/tor_log/tor_log.rs index a88184cda..df032c51f 100644 --- a/src/rust/tor_log/tor_log.rs +++ b/src/rust/tor_log/tor_log.rs @@ -62,7 +62,7 @@ pub fn tor_log_msg_impl( /// Default message to log in case of errors when converting a log /// message to a CString - const ERR_LOG_MSG: &str = "Unable to log message from Rust + const ERR_LOG_MSG: &str = "Unable to log message from Rust \ module due to error when converting to CString"; let func = match CString::new(function) {

1 0

[tor/master] rust: Remove #[no_mangle]s on two constants.
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit 547c62840e2fc2700ac917dfdc4e6e451e5c1359 Author: Isis Lovecruft <isis(a)torproject.org> Date: Tue Feb 27 21:01:17 2018 +0000 rust: Remove #[no_mangle]s on two constants. These won't/shouldn't ever be called from C, so there's no reason to preserve naming. --- src/rust/tor_log/tor_log.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/rust/tor_log/tor_log.rs b/src/rust/tor_log/tor_log.rs index df032c51f..1fdc0026b 100644 --- a/src/rust/tor_log/tor_log.rs +++ b/src/rust/tor_log/tor_log.rs @@ -97,7 +97,6 @@ pub mod log { /// Severity log types. These mirror definitions in /src/common/torlog.h /// C_RUST_COUPLED: src/common/log.c, log domain types extern "C" { - #[no_mangle] static LOG_WARN_: c_int; static LOG_NOTICE_: c_int; } @@ -105,7 +104,6 @@ pub mod log { /// Domain log types. These mirror definitions in /src/common/torlog.h /// C_RUST_COUPLED: src/common/log.c, log severity types extern "C" { - #[no_mangle] static LD_NET_: u32; static LD_GENERAL_: u32; }

1 0

[tor/master] Merge remote-tracking branch 'isis/bug23881_r1'
by nickm＠torproject.org 19 Mar '18

19 Mar '18

commit d8893bc93c52e1edd0a76b81f5d65bb10d790474 Merge: 3716611fe 1f8bd93ec Author: Nick Mathewson <nickm(a)torproject.org> Date: Mon Mar 19 17:20:37 2018 -0400 Merge remote-tracking branch 'isis/bug23881_r1' src/common/log.c | 31 ++++ src/common/torlog.h | 14 ++ src/or/main.c | 8 +- src/rust/Cargo.lock | 10 ++ src/rust/Cargo.toml | 3 +- src/rust/protover/Cargo.toml | 6 + src/rust/protover/ffi.rs | 8 +- src/rust/protover/lib.rs | 3 + src/rust/protover/protover.rs | 20 ++- src/rust/tor_allocate/tor_allocate.rs | 19 ++- src/rust/tor_log/Cargo.toml | 18 +++ src/rust/tor_log/lib.rs | 16 ++ src/rust/tor_log/tor_log.rs | 270 ++++++++++++++++++++++++++++++++++ src/rust/tor_util/Cargo.toml | 3 + src/rust/tor_util/ffi.rs | 13 +- src/rust/tor_util/lib.rs | 3 + src/test/test_rust.sh | 2 +- 17 files changed, 423 insertions(+), 24 deletions(-) diff --cc src/rust/protover/lib.rs index 8e80fcef4,05687c1fb..d1d49d2a5 --- a/src/rust/protover/lib.rs +++ b/src/rust/protover/lib.rs @@@ -26,9 -26,10 +26,12 @@@ extern crate libc extern crate smartlist; extern crate external; extern crate tor_allocate; +#[macro_use] +extern crate tor_util; + #[macro_use] + extern crate tor_log; + mod protover; pub mod ffi; diff --cc src/rust/protover/protover.rs index 03776411c,22a94a164..fd1f41d78 --- a/src/rust/protover/protover.rs +++ b/src/rust/protover/protover.rs @@@ -1,17 -1,14 +1,18 @@@ // Copyright (c) 2016-2017, The Tor Project, Inc. */ // See LICENSE for licensing information */ - 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; use std::string::String; +use std::u32; + use tor_log::{LogSeverity, LogDomain}; + use external::c_tor_version_as_new_as; + /// The first version of Tor that included "proto" entries in its descriptors. /// Authorities should use this to decide whether to guess proto lines. /// @@@ -105,127 -126,67 +106,126 @@@ pub(crate) fn get_supported_protocols_c /// /// # Returns /// -/// A `Result` whose `Ok` value is a `HashMap<Proto, <u32>>` holding all -/// subprotocols and versions currently supported by tor. -/// -/// The returned `Result`'s `Err` value is an `&'static str` with a description -/// of the error. +/// An `&'a str` whose value is the existing protocols supported by tor. +/// Returned data is in the format as follows: /// -fn tor_supported() -> Result<HashMap<Proto, HashSet<u32>>, &'static str> { - parse_protocols(&SUPPORTED_PROTOCOLS) +/// "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 } -/// Get the unique version numbers supported by a subprotocol. -/// -/// # Inputs -/// -/// * `version_string`, a string comprised of "[0-9,-]" -/// -/// # Returns -/// -/// A `Result` whose `Ok` value is a `HashSet<u32>` holding all of the unique -/// version numbers. If there were ranges in the `version_string`, then these -/// are expanded, i.e. `"1-3"` would expand to `HashSet<u32>::new([1, 2, 3])`. -/// The returned HashSet is *unordered*. -/// -/// The returned `Result`'s `Err` value is an `&'static str` with a description -/// of the error. -/// -/// # Errors -/// -/// This function will error if: -/// -/// * the `version_string` is empty or contains an equals (`"="`) sign, -/// * the expansion of a version range produces an error (see -/// `expand_version_range`), -/// * any single version number is not parseable as an `u32` in radix 10, or -/// * there are greater than 2^16 version numbers to expand. -/// -fn get_versions(version_string: &str) -> Result<HashSet<u32>, &'static str> { - if version_string.is_empty() { - return Err("version string is empty"); +pub struct SupportedProtocols(HashMap<Proto, Versions>); + +impl SupportedProtocols { + pub fn from_proto_entries<I, S>(protocol_strs: I) -> Result<Self, &'static str> + where + I: Iterator<Item = S>, + S: AsRef<str>, + { + let mut parsed = HashMap::new(); + for subproto in protocol_strs { + let (name, version) = get_proto_and_vers(subproto.as_ref())?; + parsed.insert(name, version); + } + Ok(SupportedProtocols(parsed)) } - let mut versions = HashSet::<u32>::new(); + /// Translates a string representation of a protocol list to a + /// SupportedProtocols instance. + /// + /// # Examples + /// + /// ``` + /// use protover::SupportedProtocols; + /// + /// let supported_protocols = SupportedProtocols::from_proto_entries_string( + /// "HSDir=1-2 HSIntro=3-4" + /// ); + /// ``` + pub fn from_proto_entries_string( + proto_entries: &str, + ) -> Result<Self, &'static str> { + Self::from_proto_entries(proto_entries.split(" ")) + } - for piece in version_string.split(",") { - if piece.contains("-") { - for p in expand_version_range(piece)? { - versions.insert(p); + /// Translate the supported tor versions from a string into a + /// HashMap, which is useful when looking up a specific + /// subprotocol. + /// + fn tor_supported() -> Result<Self, &'static str> { + Self::from_proto_entries_string(get_supported_protocols()) + } +} + +type Version = u32; + +/// Set of versions for a protocol. +#[derive(Debug, PartialEq, Eq)] +pub struct Versions(HashSet<Version>); + +impl Versions { + /// Get the unique version numbers supported by a subprotocol. + /// + /// # Inputs + /// + /// * `version_string`, a string comprised of "[0-9,-]" + /// + /// # Returns + /// + /// A `Result` whose `Ok` value is a `HashSet<u32>` holding all of the unique + /// version numbers. If there were ranges in the `version_string`, then these + /// are expanded, i.e. `"1-3"` would expand to `HashSet<u32>::new([1, 2, 3])`. + /// The returned HashSet is *unordered*. + /// + /// The returned `Result`'s `Err` value is an `&'static str` with a description + /// of the error. + /// + /// # Errors + /// + /// This function will error if: + /// + /// * the `version_string` is empty or contains an equals (`"="`) sign, + /// * the expansion of a version range produces an error (see + /// `expand_version_range`), + /// * any single version number is not parseable as an `u32` in radix 10, or + /// * there are greater than 2^16 version numbers to expand. + /// + fn from_version_string( + version_string: &str, + ) -> Result<Self, &'static str> { + let mut versions = HashSet::<Version>::new(); + + for piece in version_string.split(",") { + if piece.contains("-") { + for p in expand_version_range(piece)? { + versions.insert(p); + } + } else if piece == "" { + continue; + } else { + let v = u32::from_str(piece).or( + Err("invalid protocol entry"), + )?; + if v == u32::MAX { + return Err("invalid protocol entry"); + } + versions.insert(v); } - } else { - versions.insert(u32::from_str(piece).or( - Err("invalid protocol entry"), - )?); - } - if versions.len() > MAX_PROTOCOLS_TO_EXPAND as usize { - return Err("Too many versions to expand"); + if versions.len() > MAX_PROTOCOLS_TO_EXPAND { + return Err("Too many versions to expand"); + } } + Ok(Versions(versions)) } - Ok(versions) } - /// Parse the subprotocol type and its version numbers. /// /// # Inputs diff --cc src/rust/tor_util/lib.rs index 12cb3896b,4d5cbb568..94697b606 --- a/src/rust/tor_util/lib.rs +++ b/src/rust/tor_util/lib.rs @@@ -7,5 -8,7 +7,8 @@@ extern crate libc; extern crate tor_allocate; + #[macro_use] + extern crate tor_log; + pub mod ffi; +pub mod strings;

1 0

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

tor-commits March 2018