From 6167ec576238a699d65fc47d03d3c0b7996f7da7 Mon Sep 17 00:00:00 2001 From: Youyuan Wu Date: Sun, 2 Feb 2025 12:27:51 -0800 Subject: [PATCH] rename error to status --- src/error.rs | 43 ++++++++++++++------------- src/lib.rs | 84 ++++++++++++++++++++++++++-------------------------- 2 files changed, 64 insertions(+), 63 deletions(-) diff --git a/src/error.rs b/src/error.rs index f3a7695d32..c66afb9fa0 100644 --- a/src/error.rs +++ b/src/error.rs @@ -85,23 +85,24 @@ impl core::fmt::Display for StatusCode { } } -/// Quic error used in non-ffi code. +/// Quic status used in non-ffi code. /// Internal representation matches the os platfrom type. +/// Used for all non-ffi error return and callback status code fields. #[derive(Clone)] -pub struct Error(pub QUIC_STATUS); +pub struct Status(pub QUIC_STATUS); -impl Error { - /// Create an error from enum. +impl Status { + /// Create an status from enum. pub fn new(ec: StatusCode) -> Self { Self(ec as QUIC_STATUS) } - /// Convert to error code if possible. - pub fn try_as_error_code(&self) -> Result { + /// Convert to status code if possible. + pub fn try_as_status_code(&self) -> Result { use std::convert::TryFrom; StatusCode::try_from(self.0 as QUIC_STATUS) } - /// Convert from raw ffi error type. + /// Convert from raw ffi status type. pub fn ok_from_raw(ec: QUIC_STATUS) -> Result<(), Self> { let e = Self(ec); if e.is_ok() { @@ -111,7 +112,7 @@ impl Error { } } - /// Return Err if the error is considered a failure. + /// Return Err if the status is considered a failure. /// Ok includes both "no error" and "pending" status codes. pub fn is_ok(&self) -> bool { // on windows it is signed. @@ -123,25 +124,25 @@ impl Error { } } -impl std::error::Error for Error {} +impl std::error::Error for Status {} -impl From for Error { +impl From for Status { fn from(value: QUIC_STATUS) -> Self { Self(value) } } -impl From for Error { +impl From for Status { fn from(value: StatusCode) -> Self { Self::new(value) } } /// The debug message is in the same format as error in windows crate. -impl core::fmt::Debug for Error { +impl core::fmt::Debug for Status { fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { let mut debug = fmt.debug_struct("Error"); - let str_code = match self.try_as_error_code() { + let str_code = match self.try_as_status_code() { Ok(c) => Some(c), Err(_) => None, }; @@ -155,9 +156,9 @@ impl core::fmt::Debug for Error { } /// The display message is in the same format as error in windows crate. -impl core::fmt::Display for Error { +impl core::fmt::Display for Status { fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { - let str_code = match self.try_as_error_code() { + let str_code = match self.try_as_status_code() { Ok(c) => Some(c), Err(_) => None, }; @@ -172,11 +173,11 @@ impl core::fmt::Display for Error { mod tests { use crate::ffi::QUIC_STATUS; - use super::{Error, StatusCode}; + use super::{Status, StatusCode}; #[test] fn error_fmt_test() { - let err = Error::new(StatusCode::QUIC_STATUS_ABORTED); + let err = Status::new(StatusCode::QUIC_STATUS_ABORTED); // message is platform dependent. #[cfg(target_os = "windows")] assert_eq!(format!("{err}"), "QUIC_STATUS_ABORTED (0x80004004)"); @@ -185,14 +186,14 @@ mod tests { format!("{err:?}"), "Error { code: 0x80004004, message: QUIC_STATUS_ABORTED }" ); - let ec = err.try_as_error_code().unwrap(); + let ec = err.try_as_status_code().unwrap(); assert_eq!(format!("{ec}"), "QUIC_STATUS_ABORTED"); } #[test] fn error_ok_test() { - assert!(!Error::new(StatusCode::QUIC_STATUS_ABORTED).is_ok()); - assert!(Error::new(StatusCode::QUIC_STATUS_SUCCESS).is_ok()); - assert!(Error::ok_from_raw(StatusCode::QUIC_STATUS_PENDING as QUIC_STATUS).is_ok()); + assert!(!Status::new(StatusCode::QUIC_STATUS_ABORTED).is_ok()); + assert!(Status::new(StatusCode::QUIC_STATUS_SUCCESS).is_ok()); + assert!(Status::ok_from_raw(StatusCode::QUIC_STATUS_PENDING as QUIC_STATUS).is_ok()); } } diff --git a/src/lib.rs b/src/lib.rs index 6ca6c1424d..bbe261adcd 100755 --- a/src/lib.rs +++ b/src/lib.rs @@ -25,7 +25,7 @@ use std::sync::Once; extern crate bitfield; mod error; pub mod ffi; -pub use error::{Error, StatusCode}; +pub use error::{Status, StatusCode}; // // The following starts the C interop layer of MsQuic API. @@ -1134,7 +1134,7 @@ impl Api { START_MSQUIC.call_once(|| { let mut table: *const QUIC_API_TABLE = ptr::null(); let status = MsQuicOpenVersion(2, std::ptr::addr_of_mut!(table)); - if let Err(err) = Error::ok_from_raw(status as QUIC_STATUS) { + if let Err(err) = Status::ok_from_raw(status as QUIC_STATUS) { panic!("Failed to open MsQuic: {}", err); } APITABLE = table; @@ -1277,11 +1277,11 @@ impl Api { param: u32, buffer_length: *const u32, buffer: *mut c_void, - ) -> Result<(), Error> { + ) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().GetParam.unwrap()(handle, param, buffer_length as *mut u32, buffer) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } /// # Safety @@ -1291,13 +1291,13 @@ impl Api { param: u32, buffer_length: u32, buffer: *const c_void, - ) -> Result<(), Error> { + ) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().SetParam.unwrap()(handle, param, buffer_length, buffer) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } - pub fn get_perf(&self) -> Result { + pub fn get_perf(&self) -> Result { let mut perf = QuicPerformance { counters: [0; PERF_COUNTER_MAX as usize], }; @@ -1385,7 +1385,7 @@ macro_rules! define_quic_handle_impl { } impl Registration { - pub fn new(config: *const RegistrationConfig) -> Result { + pub fn new(config: *const RegistrationConfig) -> Result { // Initialize the global api table. // Registration is the first created in all msquic apps. let api = Api::get_ffi(); @@ -1397,7 +1397,7 @@ impl Registration { ) }; - Error::ok_from_raw(status)?; + Status::ok_from_raw(status)?; Ok(Registration { handle: h }) } @@ -1419,7 +1419,7 @@ impl Configuration { registration: &Registration, alpn: &[Buffer], settings: *const Settings, - ) -> Result { + ) -> Result { let context: *mut c_void = ptr::null_mut(); let mut new_configuration: HQUIC = ptr::null_mut(); let mut settings_size: u32 = 0; @@ -1438,20 +1438,20 @@ impl Configuration { std::ptr::addr_of_mut!(new_configuration), ) }; - Error::ok_from_raw(status)?; + Status::ok_from_raw(status)?; Ok(Configuration { handle: new_configuration, }) } - pub fn load_credential(&self, cred_config: &CredentialConfig) -> Result<(), Error> { + pub fn load_credential(&self, cred_config: &CredentialConfig) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().ConfigurationLoadCredential.unwrap()( self.handle, cred_config as *const CredentialConfig as *const QUIC_CREDENTIAL_CONFIG, ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } fn close_inner(&self) { @@ -1483,7 +1483,7 @@ impl Connection { registration: &Registration, handler: ffi::QUIC_CONNECTION_CALLBACK_HANDLER, context: *const c_void, - ) -> Result<(), Error> { + ) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().ConnectionOpen.unwrap()( registration.handle, @@ -1492,7 +1492,7 @@ impl Connection { std::ptr::addr_of_mut!(self.handle), ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } pub fn start( @@ -1500,7 +1500,7 @@ impl Connection { configuration: &Configuration, server_name: &str, server_port: u16, - ) -> Result<(), Error> { + ) -> Result<(), Status> { let server_name_safe = std::ffi::CString::new(server_name).unwrap(); let status = unsafe { Api::ffi_ref().ConnectionStart.unwrap()( @@ -1511,7 +1511,7 @@ impl Connection { server_port, ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } fn close_inner(&self) { @@ -1532,7 +1532,7 @@ impl Connection { } } - pub fn get_stats(&self) -> Result { + pub fn get_stats(&self) -> Result { let mut stat_buffer: [u8; std::mem::size_of::()] = [0; std::mem::size_of::()]; let stat_size_mut = std::mem::size_of::(); @@ -1547,7 +1547,7 @@ impl Connection { Ok(unsafe { *(stat_buffer.as_ptr() as *const c_void as *const QuicStatistics) }) } - pub fn get_stats_v2(&self) -> Result { + pub fn get_stats_v2(&self) -> Result { let mut stat_buffer: [u8; std::mem::size_of::()] = [0; std::mem::size_of::()]; let stat_size_mut = std::mem::size_of::(); @@ -1562,11 +1562,11 @@ impl Connection { Ok(unsafe { *(stat_buffer.as_ptr() as *const c_void as *const QuicStatisticsV2) }) } - pub fn set_configuration(&self, configuration: &Configuration) -> Result<(), Error> { + pub fn set_configuration(&self, configuration: &Configuration) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().ConnectionSetConfiguration.unwrap()(self.handle, configuration.handle) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } /// # Safety @@ -1605,7 +1605,7 @@ impl Connection { buffer_count: u32, flags: SendFlags, client_send_context: *const c_void, - ) -> Result<(), Error> { + ) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().DatagramSend.unwrap()( self.handle, @@ -1615,32 +1615,32 @@ impl Connection { client_send_context as *mut c_void, ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } - pub fn resumption_ticket_validation_complete(&self, result: BOOLEAN) -> Result<(), Error> { + pub fn resumption_ticket_validation_complete(&self, result: BOOLEAN) -> Result<(), Status> { let status = unsafe { Api::ffi_ref() .ConnectionResumptionTicketValidationComplete .unwrap()(self.handle, result) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } pub fn certificate_validation_complete( &self, result: BOOLEAN, tls_alert: TlsAlertCode, - ) -> Result<(), Error> { + ) -> Result<(), Status> { let status = unsafe { Api::ffi_ref() .ConnectionCertificateValidationComplete .unwrap()(self.handle, result, tls_alert as crate::ffi::QuicFlag) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } - pub fn get_local_addr(&self) -> Result { + pub fn get_local_addr(&self) -> Result { let mut addr_buffer: [u8; mem::size_of::()] = [0; mem::size_of::()]; let addr_size_mut = mem::size_of::(); unsafe { @@ -1654,7 +1654,7 @@ impl Connection { Ok(unsafe { *(addr_buffer.as_ptr() as *const c_void as *const Addr) }) } - pub fn get_remote_addr(&self) -> Result { + pub fn get_remote_addr(&self) -> Result { let mut addr_buffer: [u8; mem::size_of::()] = [0; mem::size_of::()]; let addr_size_mut = mem::size_of::(); unsafe { @@ -1690,7 +1690,7 @@ impl Listener { registration: &Registration, handler: ffi::QUIC_LISTENER_CALLBACK_HANDLER, context: *const c_void, - ) -> Result<(), Error> { + ) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().ListenerOpen.unwrap()( registration.handle, @@ -1699,10 +1699,10 @@ impl Listener { std::ptr::addr_of_mut!(self.handle), ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } - pub fn start(&self, alpn: &[Buffer], local_address: Option<&Addr>) -> Result<(), Error> { + pub fn start(&self, alpn: &[Buffer], local_address: Option<&Addr>) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().ListenerStart.unwrap()( self.handle, @@ -1713,7 +1713,7 @@ impl Listener { .unwrap_or(ptr::null()), ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } pub fn stop(&self) { @@ -1722,7 +1722,7 @@ impl Listener { } } - pub fn get_local_addr(&self) -> Result { + pub fn get_local_addr(&self) -> Result { let mut addr_buffer: [u8; mem::size_of::()] = [0; mem::size_of::()]; let addr_size_mut = mem::size_of::(); unsafe { @@ -1766,7 +1766,7 @@ impl Stream { flags: StreamOpenFlags, handler: StreamEventHandler, context: *const c_void, - ) -> Result<(), Error> { + ) -> Result<(), Status> { // TODO: remove transmute. #[allow(clippy::missing_transmute_annotations)] let status = unsafe { @@ -1778,17 +1778,17 @@ impl Stream { std::ptr::addr_of_mut!(self.handle), ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } - pub fn start(&self, flags: StreamStartFlags) -> Result<(), Error> { + pub fn start(&self, flags: StreamStartFlags) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().StreamStart.unwrap()(self.handle, flags as crate::ffi::QuicFlag) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } - pub fn shutdown(&self, flags: StreamShutdownFlags, error_code: u62) -> Result<(), Error> { + pub fn shutdown(&self, flags: StreamShutdownFlags, error_code: u62) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().StreamShutdown.unwrap()( self.handle, @@ -1796,7 +1796,7 @@ impl Stream { error_code, ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } pub fn close_inner(&self) { @@ -1813,7 +1813,7 @@ impl Stream { buffer_count: u32, flags: SendFlags, client_send_context: *const c_void, - ) -> Result<(), Error> { + ) -> Result<(), Status> { let status = unsafe { Api::ffi_ref().StreamSend.unwrap()( self.handle, @@ -1823,7 +1823,7 @@ impl Stream { client_send_context as *mut c_void, //(self as *const Stream) as *const c_void, ) }; - Error::ok_from_raw(status) + Status::ok_from_raw(status) } /// # Safety