use core::result;
use core::fmt;
impl_enum! {
#[repr(u32)]
#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug)]
pub enum sgx_status_t {
SGX_SUCCESS = 0x0000_0000,
SGX_ERROR_UNEXPECTED = 0x0000_0001,
SGX_ERROR_INVALID_PARAMETER = 0x0000_0002,
SGX_ERROR_OUT_OF_MEMORY = 0x0000_0003,
SGX_ERROR_ENCLAVE_LOST = 0x0000_0004,
SGX_ERROR_INVALID_STATE = 0x0000_0005,
SGX_ERROR_FEATURE_NOT_SUPPORTED = 0x0000_0008,
SGX_ERROR_INVALID_FUNCTION = 0x0000_1001,
SGX_ERROR_OUT_OF_TCS = 0x0000_1003,
SGX_ERROR_ENCLAVE_CRASHED = 0x0000_1006,
SGX_ERROR_ECALL_NOT_ALLOWED = 0x0000_1007,
SGX_ERROR_OCALL_NOT_ALLOWED = 0x0000_1008,
SGX_ERROR_STACK_OVERRUN = 0x0000_1009,
SGX_ERROR_UNDEFINED_SYMBOL = 0x0000_2000,
SGX_ERROR_INVALID_ENCLAVE = 0x0000_2001,
SGX_ERROR_INVALID_ENCLAVE_ID = 0x0000_2002,
SGX_ERROR_INVALID_SIGNATURE = 0x0000_2003,
SGX_ERROR_NDEBUG_ENCLAVE = 0x0000_2004,
SGX_ERROR_OUT_OF_EPC = 0x0000_2005,
SGX_ERROR_NO_DEVICE = 0x0000_2006,
SGX_ERROR_MEMORY_MAP_CONFLICT = 0x0000_2007,
SGX_ERROR_INVALID_METADATA = 0x0000_2009,
SGX_ERROR_DEVICE_BUSY = 0x0000_200c,
SGX_ERROR_INVALID_VERSION = 0x0000_200d,
SGX_ERROR_MODE_INCOMPATIBLE = 0x0000_200e,
SGX_ERROR_ENCLAVE_FILE_ACCESS = 0x0000_200f,
SGX_ERROR_INVALID_MISC = 0x0000_2010,
SGX_ERROR_INVALID_LAUNCH_TOKEN = 0x0000_2011,
SGX_ERROR_MAC_MISMATCH = 0x0000_3001,
SGX_ERROR_INVALID_ATTRIBUTE = 0x0000_3002,
SGX_ERROR_INVALID_CPUSVN = 0x0000_3003,
SGX_ERROR_INVALID_ISVSVN = 0x0000_3004,
SGX_ERROR_INVALID_KEYNAME = 0x0000_3005,
SGX_ERROR_SERVICE_UNAVAILABLE = 0x0000_4001,
SGX_ERROR_SERVICE_TIMEOUT = 0x0000_4002,
SGX_ERROR_AE_INVALID_EPIDBLOB = 0x0000_4003,
SGX_ERROR_SERVICE_INVALID_PRIVILEGE = 0x0000_4004,
SGX_ERROR_EPID_MEMBER_REVOKED = 0x0000_4005,
SGX_ERROR_UPDATE_NEEDED = 0x0000_4006,
SGX_ERROR_NETWORK_FAILURE = 0x0000_4007,
SGX_ERROR_AE_SESSION_INVALID = 0x0000_4008,
SGX_ERROR_BUSY = 0x0000_400a,
SGX_ERROR_MC_NOT_FOUND = 0x0000_400c,
SGX_ERROR_MC_NO_ACCESS_RIGHT = 0x0000_400d,
SGX_ERROR_MC_USED_UP = 0x0000_400e,
SGX_ERROR_MC_OVER_QUOTA = 0x0000_400f,
SGX_ERROR_KDF_MISMATCH = 0x0000_4011,
SGX_ERROR_UNRECOGNIZED_PLATFORM = 0x0000_4012,
SGX_ERROR_NO_PRIVILEGE = 0x0000_5002,
SGX_ERROR_PCL_ENCRYPTED = 0x0000_6001,
SGX_ERROR_PCL_NOT_ENCRYPTED = 0x0000_6002,
SGX_ERROR_PCL_MAC_MISMATCH = 0x0000_6003,
SGX_ERROR_PCL_SHA_MISMATCH = 0x0000_6004,
SGX_ERROR_PCL_GUID_MISMATCH = 0x0000_6005,
SGX_ERROR_FILE_BAD_STATUS = 0x0000_7001,
SGX_ERROR_FILE_NO_KEY_ID = 0x0000_7002,
SGX_ERROR_FILE_NAME_MISMATCH = 0x0000_7003,
SGX_ERROR_FILE_NOT_SGX_FILE = 0x0000_7004,
SGX_ERROR_FILE_CANT_OPEN_RECOVERY_FILE = 0x0000_7005,
SGX_ERROR_FILE_CANT_WRITE_RECOVERY_FILE = 0x0000_7006,
SGX_ERROR_FILE_RECOVERY_NEEDED = 0x0000_7007,
SGX_ERROR_FILE_FLUSH_FAILED = 0x0000_7008,
SGX_ERROR_FILE_CLOSE_FAILED = 0x0000_7009,
SGX_INTERNAL_ERROR_ENCLAVE_CREATE_INTERRUPTED = 0x0000_F001,
SGX_ERROR_WASM_BUFFER_TOO_SHORT = 0x0F00_F001,
SGX_ERROR_WASM_INTERPRETER_ERROR = 0x0F00_F002,
SGX_ERROR_WASM_LOAD_MODULE_ERROR = 0x0F00_F003,
SGX_ERROR_WASM_TRY_LOAD_ERROR = 0x0F00_F004,
SGX_ERROR_WASM_REGISTER_ERROR = 0x0F00_F005,
SGX_ERROR_FAAS_BUFFER_TOO_SHORT = 0x0F00_E001,
SGX_ERROR_FAAS_INTERNAL_ERROR = 0x0F00_E002,
}
}
impl sgx_status_t {
pub fn __description(&self) -> &str {
match *self {
sgx_status_t::SGX_SUCCESS => "Success.",
sgx_status_t::SGX_ERROR_UNEXPECTED => "Unexpected error occurred.",
sgx_status_t::SGX_ERROR_INVALID_PARAMETER => "The parameter is incorrect.",
sgx_status_t::SGX_ERROR_OUT_OF_MEMORY => "Not enough memory is available to complete this operation.",
sgx_status_t::SGX_ERROR_ENCLAVE_LOST => "Enclave lost after power transition or used in child process created.",
sgx_status_t::SGX_ERROR_INVALID_STATE => "SGX API is invoked in incorrect order or state.",
sgx_status_t::SGX_ERROR_FEATURE_NOT_SUPPORTED => "Feature is not supported on this platform.",
sgx_status_t::SGX_ERROR_INVALID_FUNCTION => "The ecall/ocall index is invalid.",
sgx_status_t::SGX_ERROR_OUT_OF_TCS => "The enclave is out of TCS.",
sgx_status_t::SGX_ERROR_ENCLAVE_CRASHED => "The enclave is crashed.",
sgx_status_t::SGX_ERROR_ECALL_NOT_ALLOWED => "The ECALL is not allowed at this time.",
sgx_status_t::SGX_ERROR_OCALL_NOT_ALLOWED => "The OCALL is not allowed at this time.",
sgx_status_t::SGX_ERROR_STACK_OVERRUN => "The enclave is running out of stack.",
sgx_status_t::SGX_ERROR_UNDEFINED_SYMBOL => "The enclave image has undefined symbol.",
sgx_status_t::SGX_ERROR_INVALID_ENCLAVE => "The enclave image is not correct.",
sgx_status_t::SGX_ERROR_INVALID_ENCLAVE_ID => "The enclave id is invalid.",
sgx_status_t::SGX_ERROR_INVALID_SIGNATURE => "The signature is invalid.",
sgx_status_t::SGX_ERROR_NDEBUG_ENCLAVE => "The enclave can not be created as debuggable enclave.",
sgx_status_t::SGX_ERROR_OUT_OF_EPC => "Not enough EPC is available to load the enclave.",
sgx_status_t::SGX_ERROR_NO_DEVICE => "Can't open SGX device.",
sgx_status_t::SGX_ERROR_MEMORY_MAP_CONFLICT => "Page mapping failed in driver.",
sgx_status_t::SGX_ERROR_INVALID_METADATA => "The metadata is incorrect.",
sgx_status_t::SGX_ERROR_DEVICE_BUSY => "Device is busy, mostly EINIT failed.",
sgx_status_t::SGX_ERROR_INVALID_VERSION => "Enclave version was invalid.",
sgx_status_t::SGX_ERROR_MODE_INCOMPATIBLE => "The target enclave mode is incompatible with the mode of current uRTS.",
sgx_status_t::SGX_ERROR_ENCLAVE_FILE_ACCESS => "Can't open enclave file.",
sgx_status_t::SGX_ERROR_INVALID_MISC => "The MiscSelct/MiscMask settings are not correct.",
sgx_status_t::SGX_ERROR_INVALID_LAUNCH_TOKEN => "The launch token is not correct.",
sgx_status_t::SGX_ERROR_MAC_MISMATCH => "Indicates verification error for reports, sealed datas, etc.",
sgx_status_t::SGX_ERROR_INVALID_ATTRIBUTE => "The enclave is not authorized.",
sgx_status_t::SGX_ERROR_INVALID_CPUSVN => "The cpu svn is beyond platform's cpu svn value.",
sgx_status_t::SGX_ERROR_INVALID_ISVSVN => "The isv svn is greater than the enclave's isv svn.",
sgx_status_t::SGX_ERROR_INVALID_KEYNAME => "The key name is an unsupported value.",
sgx_status_t::SGX_ERROR_SERVICE_UNAVAILABLE => "Indicates aesm didn't response or the requested service is not supported.",
sgx_status_t::SGX_ERROR_SERVICE_TIMEOUT => "The request to aesm time out.",
sgx_status_t::SGX_ERROR_AE_INVALID_EPIDBLOB => "Indicates epid blob verification error.",
sgx_status_t::SGX_ERROR_SERVICE_INVALID_PRIVILEGE => "Enclave has no privilege to get launch token.",
sgx_status_t::SGX_ERROR_EPID_MEMBER_REVOKED => "The EPID group membership is revoked.",
sgx_status_t::SGX_ERROR_UPDATE_NEEDED => "SGX needs to be updated.",
sgx_status_t::SGX_ERROR_NETWORK_FAILURE => "Network connecting or proxy setting issue is encountered.",
sgx_status_t::SGX_ERROR_AE_SESSION_INVALID => "Session is invalid or ended by server.",
sgx_status_t::SGX_ERROR_BUSY => "The requested service is temporarily not availabe.",
sgx_status_t::SGX_ERROR_MC_NOT_FOUND => "The Monotonic Counter doesn't exist or has been invalided.",
sgx_status_t::SGX_ERROR_MC_NO_ACCESS_RIGHT => "Caller doesn't have the access right to specified VMC.",
sgx_status_t::SGX_ERROR_MC_USED_UP => "Monotonic counters are used out.",
sgx_status_t::SGX_ERROR_MC_OVER_QUOTA => "Monotonic counters exceeds quota limitation.",
sgx_status_t::SGX_ERROR_KDF_MISMATCH => "Key derivation function doesn't match during key exchange.",
sgx_status_t::SGX_ERROR_UNRECOGNIZED_PLATFORM => "EPID Provisioning failed due to platform not recognized by backend server.",
sgx_status_t::SGX_ERROR_NO_PRIVILEGE => "Not enough privilege to perform the operation.",
sgx_status_t::SGX_ERROR_PCL_ENCRYPTED => "Trying to encrypt an already encrypted enclave.",
sgx_status_t::SGX_ERROR_PCL_NOT_ENCRYPTED => "Trying to load a plain enclave using sgx_create_encrypted_enclave.",
sgx_status_t::SGX_ERROR_PCL_MAC_MISMATCH => "Section mac result does not match build time mac.",
sgx_status_t::SGX_ERROR_PCL_SHA_MISMATCH => "Unsealed key MAC does not match MAC of key hardcoded in enclave binary.",
sgx_status_t::SGX_ERROR_PCL_GUID_MISMATCH => "GUID in sealed blob does not match GUID hardcoded in enclave binary.",
sgx_status_t::SGX_ERROR_FILE_BAD_STATUS => "The file is in bad status.",
sgx_status_t::SGX_ERROR_FILE_NO_KEY_ID => "The Key ID field is all zeros, can't regenerate the encryption key.",
sgx_status_t::SGX_ERROR_FILE_NAME_MISMATCH => "The current file name is different then the original file name.",
sgx_status_t::SGX_ERROR_FILE_NOT_SGX_FILE => "The file is not an SGX file.",
sgx_status_t::SGX_ERROR_FILE_CANT_OPEN_RECOVERY_FILE => "A recovery file can't be opened, so flush operation can't continue.",
sgx_status_t::SGX_ERROR_FILE_CANT_WRITE_RECOVERY_FILE => "A recovery file can't be written, so flush operation can't continue.",
sgx_status_t::SGX_ERROR_FILE_RECOVERY_NEEDED => "When openeing the file, recovery is needed, but the recovery process failed.",
sgx_status_t::SGX_ERROR_FILE_FLUSH_FAILED => "fflush operation failed.",
sgx_status_t::SGX_ERROR_FILE_CLOSE_FAILED => "fclose operation failed.",
sgx_status_t::SGX_INTERNAL_ERROR_ENCLAVE_CREATE_INTERRUPTED => "The ioctl for enclave_create unexpectedly failed with EINTR.",
sgx_status_t::SGX_ERROR_WASM_BUFFER_TOO_SHORT => "sgx wasm output buffer too small.",
sgx_status_t::SGX_ERROR_WASM_INTERPRETER_ERROR => "sgx wasm interpreter error.",
sgx_status_t::SGX_ERROR_WASM_LOAD_MODULE_ERROR => "sgxwasm loadmodule error.",
sgx_status_t::SGX_ERROR_WASM_TRY_LOAD_ERROR => "sgxwasm tryload error.",
sgx_status_t::SGX_ERROR_WASM_REGISTER_ERROR => "sgxwasm register error.",
sgx_status_t::SGX_ERROR_FAAS_BUFFER_TOO_SHORT => "faas output buffer too short.",
sgx_status_t::SGX_ERROR_FAAS_INTERNAL_ERROR => "faas exec internal error.",
}
}
pub fn as_str(&self) -> &str {
match *self {
sgx_status_t::SGX_SUCCESS => "SGX_SUCCESS.",
sgx_status_t::SGX_ERROR_UNEXPECTED => "SGX_ERROR_UNEXPECTED",
sgx_status_t::SGX_ERROR_INVALID_PARAMETER => "SGX_ERROR_INVALID_PARAMETER",
sgx_status_t::SGX_ERROR_OUT_OF_MEMORY => "SGX_ERROR_OUT_OF_MEMORY",
sgx_status_t::SGX_ERROR_ENCLAVE_LOST => "SGX_ERROR_ENCLAVE_LOST",
sgx_status_t::SGX_ERROR_INVALID_STATE => "SGX_ERROR_INVALID_STATE",
sgx_status_t::SGX_ERROR_FEATURE_NOT_SUPPORTED => "SGX_ERROR_FEATURE_NOT_SUPPORTED",
sgx_status_t::SGX_ERROR_INVALID_FUNCTION => "SGX_ERROR_INVALID_FUNCTION",
sgx_status_t::SGX_ERROR_OUT_OF_TCS => "SGX_ERROR_OUT_OF_TCS",
sgx_status_t::SGX_ERROR_ENCLAVE_CRASHED => "SGX_ERROR_ENCLAVE_CRASHED",
sgx_status_t::SGX_ERROR_ECALL_NOT_ALLOWED => "SGX_ERROR_ECALL_NOT_ALLOWED",
sgx_status_t::SGX_ERROR_OCALL_NOT_ALLOWED => "SGX_ERROR_OCALL_NOT_ALLOWED",
sgx_status_t::SGX_ERROR_STACK_OVERRUN => "SGX_ERROR_STACK_OVERRUN",
sgx_status_t::SGX_ERROR_UNDEFINED_SYMBOL => "SGX_ERROR_UNDEFINED_SYMBOL",
sgx_status_t::SGX_ERROR_INVALID_ENCLAVE => "SGX_ERROR_INVALID_ENCLAVE",
sgx_status_t::SGX_ERROR_INVALID_ENCLAVE_ID => "SGX_ERROR_INVALID_ENCLAVE_ID",
sgx_status_t::SGX_ERROR_INVALID_SIGNATURE => "SGX_ERROR_INVALID_SIGNATURE",
sgx_status_t::SGX_ERROR_NDEBUG_ENCLAVE => "SGX_ERROR_NDEBUG_ENCLAVE",
sgx_status_t::SGX_ERROR_OUT_OF_EPC => "SGX_ERROR_OUT_OF_EPC",
sgx_status_t::SGX_ERROR_NO_DEVICE => "SGX_ERROR_NO_DEVICE",
sgx_status_t::SGX_ERROR_MEMORY_MAP_CONFLICT => "SGX_ERROR_MEMORY_MAP_CONFLICT",
sgx_status_t::SGX_ERROR_INVALID_METADATA => "SGX_ERROR_INVALID_METADATA",
sgx_status_t::SGX_ERROR_DEVICE_BUSY => "SGX_ERROR_DEVICE_BUSY",
sgx_status_t::SGX_ERROR_INVALID_VERSION => "SGX_ERROR_INVALID_VERSION",
sgx_status_t::SGX_ERROR_MODE_INCOMPATIBLE => "SGX_ERROR_MODE_INCOMPATIBLE",
sgx_status_t::SGX_ERROR_ENCLAVE_FILE_ACCESS => "SGX_ERROR_ENCLAVE_FILE_ACCESS",
sgx_status_t::SGX_ERROR_INVALID_MISC => "SGX_ERROR_INVALID_MISC",
sgx_status_t::SGX_ERROR_INVALID_LAUNCH_TOKEN => "SGX_ERROR_INVALID_LAUNCH_TOKEN",
sgx_status_t::SGX_ERROR_MAC_MISMATCH => "SGX_ERROR_MAC_MISMATCH",
sgx_status_t::SGX_ERROR_INVALID_ATTRIBUTE => "SGX_ERROR_INVALID_ATTRIBUTE",
sgx_status_t::SGX_ERROR_INVALID_CPUSVN => "SGX_ERROR_INVALID_CPUSVN",
sgx_status_t::SGX_ERROR_INVALID_ISVSVN => "SGX_ERROR_INVALID_ISVSVN",
sgx_status_t::SGX_ERROR_INVALID_KEYNAME => "SGX_ERROR_INVALID_KEYNAME",
sgx_status_t::SGX_ERROR_SERVICE_UNAVAILABLE => "SGX_ERROR_SERVICE_UNAVAILABLE",
sgx_status_t::SGX_ERROR_SERVICE_TIMEOUT => "SGX_ERROR_SERVICE_TIMEOUT",
sgx_status_t::SGX_ERROR_AE_INVALID_EPIDBLOB => "SGX_ERROR_AE_INVALID_EPIDBLOB",
sgx_status_t::SGX_ERROR_SERVICE_INVALID_PRIVILEGE => "SGX_ERROR_SERVICE_INVALID_PRIVILEGE",
sgx_status_t::SGX_ERROR_EPID_MEMBER_REVOKED => "SGX_ERROR_EPID_MEMBER_REVOKED",
sgx_status_t::SGX_ERROR_UPDATE_NEEDED => "SGX_ERROR_UPDATE_NEEDED",
sgx_status_t::SGX_ERROR_NETWORK_FAILURE => "SGX_ERROR_NETWORK_FAILURE",
sgx_status_t::SGX_ERROR_AE_SESSION_INVALID => "SGX_ERROR_AE_SESSION_INVALID",
sgx_status_t::SGX_ERROR_BUSY => "SGX_ERROR_BUSY",
sgx_status_t::SGX_ERROR_MC_NOT_FOUND => "SGX_ERROR_MC_NOT_FOUND",
sgx_status_t::SGX_ERROR_MC_NO_ACCESS_RIGHT => "SGX_ERROR_MC_NO_ACCESS_RIGHT",
sgx_status_t::SGX_ERROR_MC_USED_UP => "SGX_ERROR_MC_USED_UP",
sgx_status_t::SGX_ERROR_MC_OVER_QUOTA => "SGX_ERROR_MC_OVER_QUOTA",
sgx_status_t::SGX_ERROR_KDF_MISMATCH => "SGX_ERROR_KDF_MISMATCH",
sgx_status_t::SGX_ERROR_UNRECOGNIZED_PLATFORM => "SGX_ERROR_UNRECOGNIZED_PLATFORM",
sgx_status_t::SGX_ERROR_NO_PRIVILEGE => "SGX_ERROR_NO_PRIVILEGE",
sgx_status_t::SGX_ERROR_PCL_ENCRYPTED => "SGX_ERROR_PCL_ENCRYPTED",
sgx_status_t::SGX_ERROR_PCL_NOT_ENCRYPTED => "SGX_ERROR_PCL_NOT_ENCRYPTED",
sgx_status_t::SGX_ERROR_PCL_MAC_MISMATCH => "SGX_ERROR_PCL_MAC_MISMATCH",
sgx_status_t::SGX_ERROR_PCL_SHA_MISMATCH => "SGX_ERROR_PCL_SHA_MISMATCH",
sgx_status_t::SGX_ERROR_PCL_GUID_MISMATCH => "SGX_ERROR_PCL_GUID_MISMATCH",
sgx_status_t::SGX_ERROR_FILE_BAD_STATUS => "SGX_ERROR_FILE_BAD_STATUS",
sgx_status_t::SGX_ERROR_FILE_NO_KEY_ID => "SGX_ERROR_FILE_NO_KEY_ID",
sgx_status_t::SGX_ERROR_FILE_NAME_MISMATCH => "SGX_ERROR_FILE_NAME_MISMATCH",
sgx_status_t::SGX_ERROR_FILE_NOT_SGX_FILE => "SGX_ERROR_FILE_NOT_SGX_FILE",
sgx_status_t::SGX_ERROR_FILE_CANT_OPEN_RECOVERY_FILE => "SGX_ERROR_FILE_CANT_OPEN_RECOVERY_FILE",
sgx_status_t::SGX_ERROR_FILE_CANT_WRITE_RECOVERY_FILE => "SGX_ERROR_FILE_CANT_WRITE_RECOVERY_FILE",
sgx_status_t::SGX_ERROR_FILE_RECOVERY_NEEDED => "SGX_ERROR_FILE_RECOVERY_NEEDED",
sgx_status_t::SGX_ERROR_FILE_FLUSH_FAILED => "SGX_ERROR_FILE_FLUSH_FAILED",
sgx_status_t::SGX_ERROR_FILE_CLOSE_FAILED => "SGX_ERROR_FILE_CLOSE_FAILED",
sgx_status_t::SGX_INTERNAL_ERROR_ENCLAVE_CREATE_INTERRUPTED => "SGX_INTERNAL_ERROR_ENCLAVE_CREATE_INTERRUPTED",
sgx_status_t::SGX_ERROR_WASM_BUFFER_TOO_SHORT => "SGX_ERROR_WASM_BUFFER_TOO_SHORT",
sgx_status_t::SGX_ERROR_WASM_INTERPRETER_ERROR => "SGX_ERROR_WASM_INTERPRETER_ERROR",
sgx_status_t::SGX_ERROR_WASM_LOAD_MODULE_ERROR => "SGX_ERROR_WASM_LOAD_MODULE_ERROR",
sgx_status_t::SGX_ERROR_WASM_TRY_LOAD_ERROR => "SGX_ERROR_WASM_TRY_LOAD_ERROR",
sgx_status_t::SGX_ERROR_WASM_REGISTER_ERROR => "SGX_ERROR_WASM_REGISTER_ERROR",
sgx_status_t::SGX_ERROR_FAAS_BUFFER_TOO_SHORT => "SGX_ERROR_FAAS_BUFFER_TOO_SHORT",
sgx_status_t::SGX_ERROR_FAAS_INTERNAL_ERROR => "SGX_ERROR_FAAS_INTERNAL_ERROR",
}
}
}
impl fmt::Display for sgx_status_t {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.as_str())
}
}
pub type sys_error_t = ::int32_t;
pub type SgxResult<T> = result::Result<T, sgx_status_t>;
pub type SgxError = result::Result<(), sgx_status_t>;
pub type SysResult<T> = result::Result<T, sys_error_t>;
pub type SysError = result::Result<(), sys_error_t>;