Rust: Rename QUIC_ERROR to QUIC_STATUS (#4765)

src/error.rs

@@ -1,85 +1,85 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use crate::ffi::QUIC_ERROR;
+use crate::ffi::QUIC_STATUS;
 
-/// Defines quic error code enum and its conversion
+/// Defines quic error status enum and its conversion
 /// to raw type using macro.
-macro_rules! define_quic_error_code{
+macro_rules! define_quic_status_code{
   ($( $code1:ident ),*) =>{
     /// Enum of quic status codes.
     #[allow(non_camel_case_types)]
     #[derive(Debug, Clone, PartialEq)]
     #[repr(u32)]
-    pub enum ErrorCode {
+    pub enum StatusCode {
       $(
         $code1 = crate::ffi::$code1 as u32,
       )*
     }
 
     /// Convert from ffi type to enum.
     /// Conversion failes when the status value is not a quic status.
-    impl std::convert::TryFrom<crate::ffi::QUIC_ERROR> for ErrorCode {
+    impl std::convert::TryFrom<crate::ffi::QUIC_STATUS> for StatusCode {
       type Error = &'static str;
-      fn try_from(value: crate::ffi::QUIC_ERROR) -> Result<Self, Self::Error> {
+      fn try_from(value: crate::ffi::QUIC_STATUS) -> Result<Self, Self::Error> {
           match value {
               $(
                 crate::ffi::$code1 => Ok(Self::$code1),
               )*
-              _ => Err("Unknown QUIC_ERROR")
+              _ => Err("Unknown QUIC_STATUS")
           }
       }
     }
   }
 }
 
 // defines all quic error codes.
-define_quic_error_code!(
-    QUIC_ERROR_SUCCESS,
-    QUIC_ERROR_PENDING,
-    QUIC_ERROR_CONTINUE,
-    QUIC_ERROR_OUT_OF_MEMORY,
-    QUIC_ERROR_INVALID_PARAMETER,
-    QUIC_ERROR_INVALID_STATE,
-    QUIC_ERROR_NOT_SUPPORTED,
-    QUIC_ERROR_NOT_FOUND,
-    QUIC_ERROR_BUFFER_TOO_SMALL,
-    QUIC_ERROR_HANDSHAKE_FAILURE,
-    QUIC_ERROR_ABORTED,
-    QUIC_ERROR_ADDRESS_IN_USE,
-    QUIC_ERROR_INVALID_ADDRESS,
-    QUIC_ERROR_CONNECTION_TIMEOUT,
-    QUIC_ERROR_CONNECTION_IDLE,
-    QUIC_ERROR_UNREACHABLE,
-    QUIC_ERROR_INTERNAL_ERROR,
-    QUIC_ERROR_CONNECTION_REFUSED,
-    QUIC_ERROR_PROTOCOL_ERROR,
-    QUIC_ERROR_VER_NEG_ERROR,
-    QUIC_ERROR_TLS_ERROR,
-    QUIC_ERROR_USER_CANCELED,
-    QUIC_ERROR_ALPN_NEG_FAILURE,
-    QUIC_ERROR_STREAM_LIMIT_REACHED,
-    QUIC_ERROR_ALPN_IN_USE,
-    QUIC_ERROR_CLOSE_NOTIFY,
-    QUIC_ERROR_BAD_CERTIFICATE,
-    QUIC_ERROR_UNSUPPORTED_CERTIFICATE,
-    QUIC_ERROR_REVOKED_CERTIFICATE,
-    QUIC_ERROR_EXPIRED_CERTIFICATE,
-    QUIC_ERROR_UNKNOWN_CERTIFICATE,
-    QUIC_ERROR_REQUIRED_CERTIFICATE,
-    QUIC_ERROR_CERT_EXPIRED,
-    QUIC_ERROR_CERT_UNTRUSTED_ROOT,
-    QUIC_ERROR_CERT_NO_CERT
+define_quic_status_code!(
+    QUIC_STATUS_SUCCESS,
+    QUIC_STATUS_PENDING,
+    QUIC_STATUS_CONTINUE,
+    QUIC_STATUS_OUT_OF_MEMORY,
+    QUIC_STATUS_INVALID_PARAMETER,
+    QUIC_STATUS_INVALID_STATE,
+    QUIC_STATUS_NOT_SUPPORTED,
+    QUIC_STATUS_NOT_FOUND,
+    QUIC_STATUS_BUFFER_TOO_SMALL,
+    QUIC_STATUS_HANDSHAKE_FAILURE,
+    QUIC_STATUS_ABORTED,
+    QUIC_STATUS_ADDRESS_IN_USE,
+    QUIC_STATUS_INVALID_ADDRESS,
+    QUIC_STATUS_CONNECTION_TIMEOUT,
+    QUIC_STATUS_CONNECTION_IDLE,
+    QUIC_STATUS_UNREACHABLE,
+    QUIC_STATUS_INTERNAL_ERROR,
+    QUIC_STATUS_CONNECTION_REFUSED,
+    QUIC_STATUS_PROTOCOL_ERROR,
+    QUIC_STATUS_VER_NEG_ERROR,
+    QUIC_STATUS_TLS_ERROR,
+    QUIC_STATUS_USER_CANCELED,
+    QUIC_STATUS_ALPN_NEG_FAILURE,
+    QUIC_STATUS_STREAM_LIMIT_REACHED,
+    QUIC_STATUS_ALPN_IN_USE,
+    QUIC_STATUS_CLOSE_NOTIFY,
+    QUIC_STATUS_BAD_CERTIFICATE,
+    QUIC_STATUS_UNSUPPORTED_CERTIFICATE,
+    QUIC_STATUS_REVOKED_CERTIFICATE,
+    QUIC_STATUS_EXPIRED_CERTIFICATE,
+    QUIC_STATUS_UNKNOWN_CERTIFICATE,
+    QUIC_STATUS_REQUIRED_CERTIFICATE,
+    QUIC_STATUS_CERT_EXPIRED,
+    QUIC_STATUS_CERT_UNTRUSTED_ROOT,
+    QUIC_STATUS_CERT_NO_CERT
 );
 
-impl From<ErrorCode> for QUIC_ERROR {
-    fn from(value: ErrorCode) -> Self {
-        value as QUIC_ERROR
+impl From<StatusCode> for QUIC_STATUS {
+    fn from(value: StatusCode) -> Self {
+        value as QUIC_STATUS
     }
 }
 
 /// The display string is the same as the debug string, i.e. the enum string.
-impl core::fmt::Display for ErrorCode {
+impl core::fmt::Display for StatusCode {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         core::write!(f, "{:?}", self)
     }
@@ -88,21 +88,21 @@ impl core::fmt::Display for ErrorCode {
 /// Quic error used in non-ffi code.
 /// Internal representation matches the os platfrom type.
 #[derive(Clone)]
-pub struct Error(pub QUIC_ERROR);
+pub struct Error(pub QUIC_STATUS);
 
 impl Error {
     /// Create an error from enum.
-    pub fn new(ec: ErrorCode) -> Self {
-        Self(ec as QUIC_ERROR)
+    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<ErrorCode, &str> {
+    pub fn try_as_error_code(&self) -> Result<StatusCode, &str> {
         use std::convert::TryFrom;
-        ErrorCode::try_from(self.0 as QUIC_ERROR)
+        StatusCode::try_from(self.0 as QUIC_STATUS)
     }
 
     /// Convert from raw ffi error type.
-    pub fn ok_from_raw(ec: QUIC_ERROR) -> Result<(), Self> {
+    pub fn ok_from_raw(ec: QUIC_STATUS) -> Result<(), Self> {
         let e = Self(ec);
         if e.is_ok() {
             Ok(())
@@ -125,14 +125,14 @@ impl Error {
 
 impl std::error::Error for Error {}
 
-impl From<QUIC_ERROR> for Error {
-    fn from(value: QUIC_ERROR) -> Self {
+impl From<QUIC_STATUS> for Error {
+    fn from(value: QUIC_STATUS) -> Self {
         Self(value)
     }
 }
 
-impl From<ErrorCode> for Error {
-    fn from(value: ErrorCode) -> Self {
+impl From<StatusCode> for Error {
+    fn from(value: StatusCode) -> Self {
         Self::new(value)
     }
 }
@@ -170,29 +170,29 @@ impl core::fmt::Display for Error {
 
 #[cfg(test)]
 mod tests {
-    use crate::ffi::QUIC_ERROR;
+    use crate::ffi::QUIC_STATUS;
 
-    use super::{Error, ErrorCode};
+    use super::{Error, StatusCode};
 
     #[test]
     fn error_fmt_test() {
-        let err = Error::new(ErrorCode::QUIC_ERROR_ABORTED);
+        let err = Error::new(StatusCode::QUIC_STATUS_ABORTED);
         // message is platform dependent.
         #[cfg(target_os = "windows")]
-        assert_eq!(format!("{err}"), "QUIC_ERROR_ABORTED (0x80004004)");
+        assert_eq!(format!("{err}"), "QUIC_STATUS_ABORTED (0x80004004)");
         #[cfg(target_os = "windows")]
         assert_eq!(
             format!("{err:?}"),
-            "Error { code: 0x80004004, message: QUIC_ERROR_ABORTED }"
+            "Error { code: 0x80004004, message: QUIC_STATUS_ABORTED }"
         );
         let ec = err.try_as_error_code().unwrap();
-        assert_eq!(format!("{ec}"), "QUIC_ERROR_ABORTED");
+        assert_eq!(format!("{ec}"), "QUIC_STATUS_ABORTED");
     }
 
     #[test]
     fn error_ok_test() {
-        assert!(!Error::new(ErrorCode::QUIC_ERROR_ABORTED).is_ok());
-        assert!(Error::new(ErrorCode::QUIC_ERROR_SUCCESS).is_ok());
-        assert!(Error::ok_from_raw(ErrorCode::QUIC_ERROR_PENDING as QUIC_ERROR).is_ok());
+        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());
     }
 }

src/ffi/linux_bindings.rs

@@ -5658,39 +5658,39 @@ const _: () = {
         ConnectionCertificateValidationComplete
     ) - 240usize];
 };
-pub const QUIC_ERROR_SUCCESS: QUIC_ERROR = 0;
-pub const QUIC_ERROR_PENDING: QUIC_ERROR = 4294967294;
-pub const QUIC_ERROR_CONTINUE: QUIC_ERROR = 4294967295;
-pub const QUIC_ERROR_OUT_OF_MEMORY: QUIC_ERROR = 12;
-pub const QUIC_ERROR_INVALID_PARAMETER: QUIC_ERROR = 22;
-pub const QUIC_ERROR_INVALID_STATE: QUIC_ERROR = 1;
-pub const QUIC_ERROR_NOT_SUPPORTED: QUIC_ERROR = 95;
-pub const QUIC_ERROR_NOT_FOUND: QUIC_ERROR = 2;
-pub const QUIC_ERROR_BUFFER_TOO_SMALL: QUIC_ERROR = 75;
-pub const QUIC_ERROR_HANDSHAKE_FAILURE: QUIC_ERROR = 103;
-pub const QUIC_ERROR_ABORTED: QUIC_ERROR = 125;
-pub const QUIC_ERROR_ADDRESS_IN_USE: QUIC_ERROR = 98;
-pub const QUIC_ERROR_INVALID_ADDRESS: QUIC_ERROR = 97;
-pub const QUIC_ERROR_CONNECTION_TIMEOUT: QUIC_ERROR = 110;
-pub const QUIC_ERROR_CONNECTION_IDLE: QUIC_ERROR = 62;
-pub const QUIC_ERROR_UNREACHABLE: QUIC_ERROR = 113;
-pub const QUIC_ERROR_INTERNAL_ERROR: QUIC_ERROR = 5;
-pub const QUIC_ERROR_CONNECTION_REFUSED: QUIC_ERROR = 111;
-pub const QUIC_ERROR_PROTOCOL_ERROR: QUIC_ERROR = 71;
-pub const QUIC_ERROR_VER_NEG_ERROR: QUIC_ERROR = 93;
-pub const QUIC_ERROR_TLS_ERROR: QUIC_ERROR = 126;
-pub const QUIC_ERROR_USER_CANCELED: QUIC_ERROR = 130;
-pub const QUIC_ERROR_ALPN_NEG_FAILURE: QUIC_ERROR = 92;
-pub const QUIC_ERROR_STREAM_LIMIT_REACHED: QUIC_ERROR = 86;
-pub const QUIC_ERROR_ALPN_IN_USE: QUIC_ERROR = 91;
-pub const QUIC_ERROR_CLOSE_NOTIFY: QUIC_ERROR = 200000256;
-pub const QUIC_ERROR_BAD_CERTIFICATE: QUIC_ERROR = 200000298;
-pub const QUIC_ERROR_UNSUPPORTED_CERTIFICATE: QUIC_ERROR = 200000299;
-pub const QUIC_ERROR_REVOKED_CERTIFICATE: QUIC_ERROR = 200000300;
-pub const QUIC_ERROR_EXPIRED_CERTIFICATE: QUIC_ERROR = 200000301;
-pub const QUIC_ERROR_UNKNOWN_CERTIFICATE: QUIC_ERROR = 200000302;
-pub const QUIC_ERROR_REQUIRED_CERTIFICATE: QUIC_ERROR = 200000372;
-pub const QUIC_ERROR_CERT_EXPIRED: QUIC_ERROR = 200000513;
-pub const QUIC_ERROR_CERT_UNTRUSTED_ROOT: QUIC_ERROR = 200000514;
-pub const QUIC_ERROR_CERT_NO_CERT: QUIC_ERROR = 200000515;
-pub type QUIC_ERROR = ::std::os::raw::c_uint;
+pub const QUIC_STATUS_SUCCESS: QUIC_STATUS = 0;
+pub const QUIC_STATUS_PENDING: QUIC_STATUS = 4294967294;
+pub const QUIC_STATUS_CONTINUE: QUIC_STATUS = 4294967295;
+pub const QUIC_STATUS_OUT_OF_MEMORY: QUIC_STATUS = 12;
+pub const QUIC_STATUS_INVALID_PARAMETER: QUIC_STATUS = 22;
+pub const QUIC_STATUS_INVALID_STATE: QUIC_STATUS = 1;
+pub const QUIC_STATUS_NOT_SUPPORTED: QUIC_STATUS = 95;
+pub const QUIC_STATUS_NOT_FOUND: QUIC_STATUS = 2;
+pub const QUIC_STATUS_BUFFER_TOO_SMALL: QUIC_STATUS = 75;
+pub const QUIC_STATUS_HANDSHAKE_FAILURE: QUIC_STATUS = 103;
+pub const QUIC_STATUS_ABORTED: QUIC_STATUS = 125;
+pub const QUIC_STATUS_ADDRESS_IN_USE: QUIC_STATUS = 98;
+pub const QUIC_STATUS_INVALID_ADDRESS: QUIC_STATUS = 97;
+pub const QUIC_STATUS_CONNECTION_TIMEOUT: QUIC_STATUS = 110;
+pub const QUIC_STATUS_CONNECTION_IDLE: QUIC_STATUS = 62;
+pub const QUIC_STATUS_UNREACHABLE: QUIC_STATUS = 113;
+pub const QUIC_STATUS_INTERNAL_ERROR: QUIC_STATUS = 5;
+pub const QUIC_STATUS_CONNECTION_REFUSED: QUIC_STATUS = 111;
+pub const QUIC_STATUS_PROTOCOL_ERROR: QUIC_STATUS = 71;
+pub const QUIC_STATUS_VER_NEG_ERROR: QUIC_STATUS = 93;
+pub const QUIC_STATUS_TLS_ERROR: QUIC_STATUS = 126;
+pub const QUIC_STATUS_USER_CANCELED: QUIC_STATUS = 130;
+pub const QUIC_STATUS_ALPN_NEG_FAILURE: QUIC_STATUS = 92;
+pub const QUIC_STATUS_STREAM_LIMIT_REACHED: QUIC_STATUS = 86;
+pub const QUIC_STATUS_ALPN_IN_USE: QUIC_STATUS = 91;
+pub const QUIC_STATUS_CLOSE_NOTIFY: QUIC_STATUS = 200000256;
+pub const QUIC_STATUS_BAD_CERTIFICATE: QUIC_STATUS = 200000298;
+pub const QUIC_STATUS_UNSUPPORTED_CERTIFICATE: QUIC_STATUS = 200000299;
+pub const QUIC_STATUS_REVOKED_CERTIFICATE: QUIC_STATUS = 200000300;
+pub const QUIC_STATUS_EXPIRED_CERTIFICATE: QUIC_STATUS = 200000301;
+pub const QUIC_STATUS_UNKNOWN_CERTIFICATE: QUIC_STATUS = 200000302;
+pub const QUIC_STATUS_REQUIRED_CERTIFICATE: QUIC_STATUS = 200000372;
+pub const QUIC_STATUS_CERT_EXPIRED: QUIC_STATUS = 200000513;
+pub const QUIC_STATUS_CERT_UNTRUSTED_ROOT: QUIC_STATUS = 200000514;
+pub const QUIC_STATUS_CERT_NO_CERT: QUIC_STATUS = 200000515;
+pub type QUIC_STATUS = ::std::os::raw::c_uint;

src/ffi/win_bindings.rs

@@ -5683,39 +5683,39 @@ const _: () = {
         ConnectionCertificateValidationComplete
     ) - 240usize];
 };
-pub const QUIC_ERROR_SUCCESS: QUIC_ERROR = 0;
-pub const QUIC_ERROR_PENDING: QUIC_ERROR = 459749;
-pub const QUIC_ERROR_CONTINUE: QUIC_ERROR = 459998;
-pub const QUIC_ERROR_OUT_OF_MEMORY: QUIC_ERROR = -2147024882;
-pub const QUIC_ERROR_INVALID_PARAMETER: QUIC_ERROR = -2147024809;
-pub const QUIC_ERROR_INVALID_STATE: QUIC_ERROR = -2147019873;
-pub const QUIC_ERROR_NOT_SUPPORTED: QUIC_ERROR = -2147467262;
-pub const QUIC_ERROR_NOT_FOUND: QUIC_ERROR = -2147023728;
-pub const QUIC_ERROR_BUFFER_TOO_SMALL: QUIC_ERROR = -2147024774;
-pub const QUIC_ERROR_HANDSHAKE_FAILURE: QUIC_ERROR = -2143223808;
-pub const QUIC_ERROR_ABORTED: QUIC_ERROR = -2147467260;
-pub const QUIC_ERROR_ADDRESS_IN_USE: QUIC_ERROR = -2147014848;
-pub const QUIC_ERROR_INVALID_ADDRESS: QUIC_ERROR = -2147014847;
-pub const QUIC_ERROR_CONNECTION_TIMEOUT: QUIC_ERROR = -2143223802;
-pub const QUIC_ERROR_CONNECTION_IDLE: QUIC_ERROR = -2143223803;
-pub const QUIC_ERROR_UNREACHABLE: QUIC_ERROR = -2147023664;
-pub const QUIC_ERROR_INTERNAL_ERROR: QUIC_ERROR = -2143223805;
-pub const QUIC_ERROR_CONNECTION_REFUSED: QUIC_ERROR = -2147023671;
-pub const QUIC_ERROR_PROTOCOL_ERROR: QUIC_ERROR = -2143223804;
-pub const QUIC_ERROR_VER_NEG_ERROR: QUIC_ERROR = -2143223807;
-pub const QUIC_ERROR_TLS_ERROR: QUIC_ERROR = -2147013864;
-pub const QUIC_ERROR_USER_CANCELED: QUIC_ERROR = -2143223806;
-pub const QUIC_ERROR_ALPN_NEG_FAILURE: QUIC_ERROR = -2143223801;
-pub const QUIC_ERROR_STREAM_LIMIT_REACHED: QUIC_ERROR = -2143223800;
-pub const QUIC_ERROR_ALPN_IN_USE: QUIC_ERROR = -2143223799;
-pub const QUIC_ERROR_CLOSE_NOTIFY: QUIC_ERROR = -2143223552;
-pub const QUIC_ERROR_BAD_CERTIFICATE: QUIC_ERROR = -2143223510;
-pub const QUIC_ERROR_UNSUPPORTED_CERTIFICATE: QUIC_ERROR = -2143223509;
-pub const QUIC_ERROR_REVOKED_CERTIFICATE: QUIC_ERROR = -2143223508;
-pub const QUIC_ERROR_EXPIRED_CERTIFICATE: QUIC_ERROR = -2143223507;
-pub const QUIC_ERROR_UNKNOWN_CERTIFICATE: QUIC_ERROR = -2143223506;
-pub const QUIC_ERROR_REQUIRED_CERTIFICATE: QUIC_ERROR = -2143223436;
-pub const QUIC_ERROR_CERT_EXPIRED: QUIC_ERROR = -2146762495;
-pub const QUIC_ERROR_CERT_UNTRUSTED_ROOT: QUIC_ERROR = -2146762487;
-pub const QUIC_ERROR_CERT_NO_CERT: QUIC_ERROR = -2146893042;
-pub type QUIC_ERROR = ::std::os::raw::c_int;
+pub const QUIC_STATUS_SUCCESS: QUIC_STATUS = 0;
+pub const QUIC_STATUS_PENDING: QUIC_STATUS = 459749;
+pub const QUIC_STATUS_CONTINUE: QUIC_STATUS = 459998;
+pub const QUIC_STATUS_OUT_OF_MEMORY: QUIC_STATUS = -2147024882;
+pub const QUIC_STATUS_INVALID_PARAMETER: QUIC_STATUS = -2147024809;
+pub const QUIC_STATUS_INVALID_STATE: QUIC_STATUS = -2147019873;
+pub const QUIC_STATUS_NOT_SUPPORTED: QUIC_STATUS = -2147467262;
+pub const QUIC_STATUS_NOT_FOUND: QUIC_STATUS = -2147023728;
+pub const QUIC_STATUS_BUFFER_TOO_SMALL: QUIC_STATUS = -2147024774;
+pub const QUIC_STATUS_HANDSHAKE_FAILURE: QUIC_STATUS = -2143223808;
+pub const QUIC_STATUS_ABORTED: QUIC_STATUS = -2147467260;
+pub const QUIC_STATUS_ADDRESS_IN_USE: QUIC_STATUS = -2147014848;
+pub const QUIC_STATUS_INVALID_ADDRESS: QUIC_STATUS = -2147014847;
+pub const QUIC_STATUS_CONNECTION_TIMEOUT: QUIC_STATUS = -2143223802;
+pub const QUIC_STATUS_CONNECTION_IDLE: QUIC_STATUS = -2143223803;
+pub const QUIC_STATUS_UNREACHABLE: QUIC_STATUS = -2147023664;
+pub const QUIC_STATUS_INTERNAL_ERROR: QUIC_STATUS = -2143223805;
+pub const QUIC_STATUS_CONNECTION_REFUSED: QUIC_STATUS = -2147023671;
+pub const QUIC_STATUS_PROTOCOL_ERROR: QUIC_STATUS = -2143223804;
+pub const QUIC_STATUS_VER_NEG_ERROR: QUIC_STATUS = -2143223807;
+pub const QUIC_STATUS_TLS_ERROR: QUIC_STATUS = -2147013864;
+pub const QUIC_STATUS_USER_CANCELED: QUIC_STATUS = -2143223806;
+pub const QUIC_STATUS_ALPN_NEG_FAILURE: QUIC_STATUS = -2143223801;
+pub const QUIC_STATUS_STREAM_LIMIT_REACHED: QUIC_STATUS = -2143223800;
+pub const QUIC_STATUS_ALPN_IN_USE: QUIC_STATUS = -2143223799;
+pub const QUIC_STATUS_CLOSE_NOTIFY: QUIC_STATUS = -2143223552;
+pub const QUIC_STATUS_BAD_CERTIFICATE: QUIC_STATUS = -2143223510;
+pub const QUIC_STATUS_UNSUPPORTED_CERTIFICATE: QUIC_STATUS = -2143223509;
+pub const QUIC_STATUS_REVOKED_CERTIFICATE: QUIC_STATUS = -2143223508;
+pub const QUIC_STATUS_EXPIRED_CERTIFICATE: QUIC_STATUS = -2143223507;
+pub const QUIC_STATUS_UNKNOWN_CERTIFICATE: QUIC_STATUS = -2143223506;
+pub const QUIC_STATUS_REQUIRED_CERTIFICATE: QUIC_STATUS = -2143223436;
+pub const QUIC_STATUS_CERT_EXPIRED: QUIC_STATUS = -2146762495;
+pub const QUIC_STATUS_CERT_UNTRUSTED_ROOT: QUIC_STATUS = -2146762487;
+pub const QUIC_STATUS_CERT_NO_CERT: QUIC_STATUS = -2146893042;
+pub type QUIC_STATUS = ::std::os::raw::c_int;

src/ffi/wrapper.hpp

@@ -2,10 +2,14 @@
 
 #include "msquic.h"
 
-// bindgen or clang has problem with c marcro functions
-// This forces clang to evaluate macros.
-// Cannot reuse QUIC_STATUS as the name because it is an macro type.
-typedef enum QUIC_ERROR {
+// undef the macro type and define the enum type.
+// This is ugly here but makes Rust code aligned with c code.
+#undef QUIC_STATUS
+typedef enum QUIC_STATUS {
+#ifndef _WIN32
+// on posix all status code relies on the macro type so we redefine it.
+#define QUIC_STATUS unsigned int
+#endif
     SUCCESS = QUIC_STATUS_SUCCESS,
     PENDING = QUIC_STATUS_PENDING,
     CONTINUE = QUIC_STATUS_CONTINUE,
@@ -41,4 +45,8 @@ typedef enum QUIC_ERROR {
     CERT_EXPIRED = QUIC_STATUS_CERT_EXPIRED,
     CERT_UNTRUSTED_ROOT = QUIC_STATUS_CERT_UNTRUSTED_ROOT,
     CERT_NO_CERT = QUIC_STATUS_CERT_NO_CERT
-} QUIC_ERROR;
+#ifndef _WIN32
+// posix need to undef the redefine.
+#undef QUIC_STATUS
+#endif
+} QUIC_STATUS;