#![allow(dead_code)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct __BindgenBitfieldUnit<Storage> {
storage: Storage,
}
impl<Storage> __BindgenBitfieldUnit<Storage> {
#[inline]
pub const fn new(storage: Storage) -> Self {
Self { storage }
}
}
impl<Storage> __BindgenBitfieldUnit<Storage>
where
Storage: AsRef<[u8]> + AsMut<[u8]>,
{
#[inline]
pub fn get_bit(&self, index: usize) -> bool {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = self.storage.as_ref()[byte_index];
let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 };
let mask = 1 << bit_index;
byte & mask == mask
}
#[inline]
pub fn set_bit(&mut self, index: usize, val: bool) {
debug_assert!(index / 8 < self.storage.as_ref().len());
let byte_index = index / 8;
let byte = &mut self.storage.as_mut()[byte_index];
let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 };
let mask = 1 << bit_index;
if val {
*byte |= mask;
} else {
*byte &= !mask;
}
}
#[inline]
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
let mut val = 0;
for i in 0..(bit_width as usize) {
if self.get_bit(i + bit_offset) {
let index =
if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i };
val |= 1 << index;
}
}
val
}
#[inline]
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
debug_assert!(bit_width <= 64);
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
for i in 0..(bit_width as usize) {
let mask = 1 << i;
let val_bit_is_set = val & mask == mask;
let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i };
self.set_bit(index + bit_offset, val_bit_is_set);
}
}
}
pub const OT_LOG_LEVEL_NONE: u32 = 0;
pub const OT_LOG_LEVEL_CRIT: u32 = 1;
pub const OT_LOG_LEVEL_WARN: u32 = 2;
pub const OT_LOG_LEVEL_NOTE: u32 = 3;
pub const OT_LOG_LEVEL_INFO: u32 = 4;
pub const OT_LOG_LEVEL_DEBG: u32 = 5;
pub const OPENTHREAD_API_VERSION: u32 = 409;
pub const OT_UPTIME_STRING_SIZE: u32 = 24;
pub const OT_CHANGED_IP6_ADDRESS_ADDED: u32 = 1;
pub const OT_CHANGED_IP6_ADDRESS_REMOVED: u32 = 2;
pub const OT_CHANGED_THREAD_ROLE: u32 = 4;
pub const OT_CHANGED_THREAD_LL_ADDR: u32 = 8;
pub const OT_CHANGED_THREAD_ML_ADDR: u32 = 16;
pub const OT_CHANGED_THREAD_RLOC_ADDED: u32 = 32;
pub const OT_CHANGED_THREAD_RLOC_REMOVED: u32 = 64;
pub const OT_CHANGED_THREAD_PARTITION_ID: u32 = 128;
pub const OT_CHANGED_THREAD_KEY_SEQUENCE_COUNTER: u32 = 256;
pub const OT_CHANGED_THREAD_NETDATA: u32 = 512;
pub const OT_CHANGED_THREAD_CHILD_ADDED: u32 = 1024;
pub const OT_CHANGED_THREAD_CHILD_REMOVED: u32 = 2048;
pub const OT_CHANGED_IP6_MULTICAST_SUBSCRIBED: u32 = 4096;
pub const OT_CHANGED_IP6_MULTICAST_UNSUBSCRIBED: u32 = 8192;
pub const OT_CHANGED_THREAD_CHANNEL: u32 = 16384;
pub const OT_CHANGED_THREAD_PANID: u32 = 32768;
pub const OT_CHANGED_THREAD_NETWORK_NAME: u32 = 65536;
pub const OT_CHANGED_THREAD_EXT_PANID: u32 = 131072;
pub const OT_CHANGED_NETWORK_KEY: u32 = 262144;
pub const OT_CHANGED_PSKC: u32 = 524288;
pub const OT_CHANGED_SECURITY_POLICY: u32 = 1048576;
pub const OT_CHANGED_CHANNEL_MANAGER_NEW_CHANNEL: u32 = 2097152;
pub const OT_CHANGED_SUPPORTED_CHANNEL_MASK: u32 = 4194304;
pub const OT_CHANGED_COMMISSIONER_STATE: u32 = 8388608;
pub const OT_CHANGED_THREAD_NETIF_STATE: u32 = 16777216;
pub const OT_CHANGED_THREAD_BACKBONE_ROUTER_STATE: u32 = 33554432;
pub const OT_CHANGED_THREAD_BACKBONE_ROUTER_LOCAL: u32 = 67108864;
pub const OT_CHANGED_JOINER_STATE: u32 = 134217728;
pub const OT_CHANGED_ACTIVE_DATASET: u32 = 268435456;
pub const OT_CHANGED_PENDING_DATASET: u32 = 536870912;
pub const OT_CHANGED_NAT64_TRANSLATOR_STATE: u32 = 1073741824;
pub const OT_CHANGED_PARENT_LINK_QUALITY: u32 = 2147483648;
pub const OT_CRYPTO_SHA256_HASH_SIZE: u32 = 32;
pub const OT_CRYPTO_ECDSA_MAX_DER_SIZE: u32 = 125;
pub const OT_CRYPTO_ECDSA_PUBLIC_KEY_SIZE: u32 = 64;
pub const OT_CRYPTO_ECDSA_SIGNATURE_SIZE: u32 = 64;
pub const OT_CRYPTO_PBDKF2_MAX_SALT_SIZE: u32 = 30;
pub const OT_PANID_BROADCAST: u32 = 65535;
pub const OT_EXT_ADDRESS_SIZE: u32 = 8;
pub const OT_MAC_KEY_SIZE: u32 = 16;
pub const OT_IP6_PREFIX_SIZE: u32 = 8;
pub const OT_IP6_PREFIX_BITSIZE: u32 = 64;
pub const OT_IP6_IID_SIZE: u32 = 8;
pub const OT_IP6_ADDRESS_SIZE: u32 = 16;
pub const OT_IP6_ADDRESS_BITSIZE: u32 = 128;
pub const OT_IP6_HEADER_SIZE: u32 = 40;
pub const OT_IP6_HEADER_PROTO_OFFSET: u32 = 6;
pub const OT_IP6_ADDRESS_STRING_SIZE: u32 = 40;
pub const OT_IP6_SOCK_ADDR_STRING_SIZE: u32 = 48;
pub const OT_IP6_PREFIX_STRING_SIZE: u32 = 45;
pub const OT_IP6_MAX_MLR_ADDRESSES: u32 = 15;
pub const OT_NETWORK_KEY_SIZE: u32 = 16;
pub const OT_NETWORK_NAME_MAX_SIZE: u32 = 16;
pub const OT_EXT_PAN_ID_SIZE: u32 = 8;
pub const OT_MESH_LOCAL_PREFIX_SIZE: u32 = 8;
pub const OT_PSKC_MAX_SIZE: u32 = 16;
pub const OT_CHANNEL_1_MASK: u32 = 2;
pub const OT_CHANNEL_2_MASK: u32 = 4;
pub const OT_CHANNEL_3_MASK: u32 = 8;
pub const OT_CHANNEL_4_MASK: u32 = 16;
pub const OT_CHANNEL_5_MASK: u32 = 32;
pub const OT_CHANNEL_6_MASK: u32 = 64;
pub const OT_CHANNEL_7_MASK: u32 = 128;
pub const OT_CHANNEL_8_MASK: u32 = 256;
pub const OT_CHANNEL_9_MASK: u32 = 512;
pub const OT_CHANNEL_10_MASK: u32 = 1024;
pub const OT_CHANNEL_11_MASK: u32 = 2048;
pub const OT_CHANNEL_12_MASK: u32 = 4096;
pub const OT_CHANNEL_13_MASK: u32 = 8192;
pub const OT_CHANNEL_14_MASK: u32 = 16384;
pub const OT_CHANNEL_15_MASK: u32 = 32768;
pub const OT_CHANNEL_16_MASK: u32 = 65536;
pub const OT_CHANNEL_17_MASK: u32 = 131072;
pub const OT_CHANNEL_18_MASK: u32 = 262144;
pub const OT_CHANNEL_19_MASK: u32 = 524288;
pub const OT_CHANNEL_20_MASK: u32 = 1048576;
pub const OT_CHANNEL_21_MASK: u32 = 2097152;
pub const OT_CHANNEL_22_MASK: u32 = 4194304;
pub const OT_CHANNEL_23_MASK: u32 = 8388608;
pub const OT_CHANNEL_24_MASK: u32 = 16777216;
pub const OT_CHANNEL_25_MASK: u32 = 33554432;
pub const OT_CHANNEL_26_MASK: u32 = 67108864;
pub const OT_OPERATIONAL_DATASET_MAX_LENGTH: u32 = 254;
pub const OT_JOINER_MAX_DISCERNER_LENGTH: u32 = 64;
pub const OT_COMMISSIONING_PASSPHRASE_MIN_SIZE: u32 = 6;
pub const OT_COMMISSIONING_PASSPHRASE_MAX_SIZE: u32 = 255;
pub const OT_PROVISIONING_URL_MAX_SIZE: u32 = 64;
pub const OT_STEERING_DATA_MAX_LENGTH: u32 = 16;
pub const OT_JOINER_MAX_PSKD_LENGTH: u32 = 32;
pub const OT_NETWORK_DATA_ITERATOR_INIT: u32 = 0;
pub const OT_SERVICE_DATA_MAX_SIZE: u32 = 252;
pub const OT_SERVER_DATA_MAX_SIZE: u32 = 248;
pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ITERATOR_INIT: u32 = 0;
pub const OT_BORDER_AGENT_ID_LENGTH: u32 = 16;
pub const OT_BORDER_AGENT_MIN_EPHEMERAL_KEY_LENGTH: u32 = 6;
pub const OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_LENGTH: u32 = 32;
pub const OT_BORDER_AGENT_DEFAULT_EPHEMERAL_KEY_TIMEOUT: u32 = 120000;
pub const OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT: u32 = 600000;
pub const OT_DEFAULT_COAP_PORT: u32 = 5683;
pub const OT_COAP_DEFAULT_TOKEN_LENGTH: u32 = 2;
pub const OT_COAP_MAX_TOKEN_LENGTH: u32 = 8;
pub const OT_COAP_MAX_RETRANSMIT: u32 = 20;
pub const OT_COAP_MIN_ACK_TIMEOUT: u32 = 1000;
pub const OT_DEFAULT_COAP_SECURE_PORT: u32 = 5684;
pub const OPENTHREAD_POSIX_CONFIG_RCP_TIME_SYNC_INTERVAL: u32 = 60000000;
pub const OPENTHREAD_SPINEL_CONFIG_ABORT_ON_UNEXPECTED_RCP_RESET_ENABLE: u32 = 1;
pub const OT_DNS_MAX_NAME_SIZE: u32 = 255;
pub const OT_DNS_MAX_LABEL_SIZE: u32 = 64;
pub const OT_DNS_TXT_KEY_MIN_LENGTH: u32 = 1;
pub const OT_DNS_TXT_KEY_MAX_LENGTH: u32 = 9;
pub const OT_DNS_TXT_KEY_ITER_MAX_LENGTH: u32 = 64;
pub const OT_ICMP6_HEADER_DATA_SIZE: u32 = 4;
pub const OT_ICMP6_ROUTER_ADVERT_MIN_SIZE: u32 = 16;
pub const OT_MAC_FILTER_FIXED_RSS_DISABLED: u32 = 127;
pub const OT_MAC_FILTER_ITERATOR_INIT: u32 = 0;
pub const OT_LINK_CSL_PERIOD_TEN_SYMBOLS_UNIT_IN_USEC: u32 = 160;
pub const OT_LOG_HEX_DUMP_LINE_SIZE: u32 = 73;
pub const OT_IP4_ADDRESS_SIZE: u32 = 4;
pub const OT_IP4_ADDRESS_STRING_SIZE: u32 = 17;
pub const OT_IP4_CIDR_STRING_SIZE: u32 = 20;
pub const OT_NETWORK_BASE_TLV_MAX_LENGTH: u32 = 254;
pub const OT_NETWORK_MAX_ROUTER_ID: u32 = 62;
pub const OT_NEIGHBOR_INFO_ITERATOR_INIT: u32 = 0;
pub const OT_JOINER_ADVDATA_MAX_LENGTH: u32 = 64;
pub const OT_DURATION_STRING_SIZE: u32 = 21;
pub const OT_NETWORK_DIAGNOSTIC_TLV_EXT_ADDRESS: u32 = 0;
pub const OT_NETWORK_DIAGNOSTIC_TLV_SHORT_ADDRESS: u32 = 1;
pub const OT_NETWORK_DIAGNOSTIC_TLV_MODE: u32 = 2;
pub const OT_NETWORK_DIAGNOSTIC_TLV_TIMEOUT: u32 = 3;
pub const OT_NETWORK_DIAGNOSTIC_TLV_CONNECTIVITY: u32 = 4;
pub const OT_NETWORK_DIAGNOSTIC_TLV_ROUTE: u32 = 5;
pub const OT_NETWORK_DIAGNOSTIC_TLV_LEADER_DATA: u32 = 6;
pub const OT_NETWORK_DIAGNOSTIC_TLV_NETWORK_DATA: u32 = 7;
pub const OT_NETWORK_DIAGNOSTIC_TLV_IP6_ADDR_LIST: u32 = 8;
pub const OT_NETWORK_DIAGNOSTIC_TLV_MAC_COUNTERS: u32 = 9;
pub const OT_NETWORK_DIAGNOSTIC_TLV_BATTERY_LEVEL: u32 = 14;
pub const OT_NETWORK_DIAGNOSTIC_TLV_SUPPLY_VOLTAGE: u32 = 15;
pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD_TABLE: u32 = 16;
pub const OT_NETWORK_DIAGNOSTIC_TLV_CHANNEL_PAGES: u32 = 17;
pub const OT_NETWORK_DIAGNOSTIC_TLV_TYPE_LIST: u32 = 18;
pub const OT_NETWORK_DIAGNOSTIC_TLV_MAX_CHILD_TIMEOUT: u32 = 19;
pub const OT_NETWORK_DIAGNOSTIC_TLV_EUI64: u32 = 23;
pub const OT_NETWORK_DIAGNOSTIC_TLV_VERSION: u32 = 24;
pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_NAME: u32 = 25;
pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_MODEL: u32 = 26;
pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_SW_VERSION: u32 = 27;
pub const OT_NETWORK_DIAGNOSTIC_TLV_THREAD_STACK_VERSION: u32 = 28;
pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD: u32 = 29;
pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD_IP6_ADDR_LIST: u32 = 30;
pub const OT_NETWORK_DIAGNOSTIC_TLV_ROUTER_NEIGHBOR: u32 = 31;
pub const OT_NETWORK_DIAGNOSTIC_TLV_ANSWER: u32 = 32;
pub const OT_NETWORK_DIAGNOSTIC_TLV_QUERY_ID: u32 = 33;
pub const OT_NETWORK_DIAGNOSTIC_TLV_MLE_COUNTERS: u32 = 34;
pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_APP_URL: u32 = 35;
pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_NAME_TLV_LENGTH: u32 = 32;
pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_MODEL_TLV_LENGTH: u32 = 32;
pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_SW_VERSION_TLV_LENGTH: u32 = 16;
pub const OT_NETWORK_DIAGNOSTIC_MAX_THREAD_STACK_VERSION_TLV_LENGTH: u32 = 64;
pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_APP_URL_TLV_LENGTH: u32 = 96;
pub const OT_NETWORK_DIAGNOSTIC_ITERATOR_INIT: u32 = 0;
pub const OT_TIME_SYNC_INVALID_SEQ: u32 = 0;
pub const OT_SNTP_DEFAULT_SERVER_IP: &[u8; 19] = b"2001:4860:4806:8::\0";
pub const OT_SNTP_DEFAULT_SERVER_PORT: u32 = 123;
pub const OT_TCP_ENDPOINT_TCB_SIZE_BASE: u32 = 392;
pub const OT_TCP_ENDPOINT_TCB_NUM_PTR: u32 = 36;
pub const OT_TCP_RECEIVE_BUFFER_SIZE_FEW_HOPS: u32 = 2598;
pub const OT_TCP_RECEIVE_BUFFER_SIZE_MANY_HOPS: u32 = 4157;
pub const OT_TCP_LISTENER_TCB_SIZE_BASE: u32 = 16;
pub const OT_TCP_LISTENER_TCB_NUM_PTR: u32 = 3;
pub const OT_CHILD_IP6_ADDRESS_ITERATOR_INIT: u32 = 0;
#[doc = " No error."]
pub const OT_ERROR_NONE: otError = 0;
#[doc = " Operational failed."]
pub const OT_ERROR_FAILED: otError = 1;
#[doc = " Message was dropped."]
pub const OT_ERROR_DROP: otError = 2;
#[doc = " Insufficient buffers."]
pub const OT_ERROR_NO_BUFS: otError = 3;
#[doc = " No route available."]
pub const OT_ERROR_NO_ROUTE: otError = 4;
#[doc = " Service is busy and could not service the operation."]
pub const OT_ERROR_BUSY: otError = 5;
#[doc = " Failed to parse message."]
pub const OT_ERROR_PARSE: otError = 6;
#[doc = " Input arguments are invalid."]
pub const OT_ERROR_INVALID_ARGS: otError = 7;
#[doc = " Security checks failed."]
pub const OT_ERROR_SECURITY: otError = 8;
#[doc = " Address resolution requires an address query operation."]
pub const OT_ERROR_ADDRESS_QUERY: otError = 9;
#[doc = " Address is not in the source match table."]
pub const OT_ERROR_NO_ADDRESS: otError = 10;
#[doc = " Operation was aborted."]
pub const OT_ERROR_ABORT: otError = 11;
#[doc = " Function or method is not implemented."]
pub const OT_ERROR_NOT_IMPLEMENTED: otError = 12;
#[doc = " Cannot complete due to invalid state."]
pub const OT_ERROR_INVALID_STATE: otError = 13;
#[doc = " No acknowledgment was received after macMaxFrameRetries (IEEE 802.15.4-2006)."]
pub const OT_ERROR_NO_ACK: otError = 14;
#[doc = " A transmission could not take place due to activity on the channel, i.e., the CSMA-CA mechanism has failed\n (IEEE 802.15.4-2006)."]
pub const OT_ERROR_CHANNEL_ACCESS_FAILURE: otError = 15;
#[doc = " Not currently attached to a Thread Partition."]
pub const OT_ERROR_DETACHED: otError = 16;
#[doc = " FCS check failure while receiving."]
pub const OT_ERROR_FCS: otError = 17;
#[doc = " No frame received."]
pub const OT_ERROR_NO_FRAME_RECEIVED: otError = 18;
#[doc = " Received a frame from an unknown neighbor."]
pub const OT_ERROR_UNKNOWN_NEIGHBOR: otError = 19;
#[doc = " Received a frame from an invalid source address."]
pub const OT_ERROR_INVALID_SOURCE_ADDRESS: otError = 20;
#[doc = " Received a frame filtered by the address filter (allowlisted or denylisted)."]
pub const OT_ERROR_ADDRESS_FILTERED: otError = 21;
#[doc = " Received a frame filtered by the destination address check."]
pub const OT_ERROR_DESTINATION_ADDRESS_FILTERED: otError = 22;
#[doc = " The requested item could not be found."]
pub const OT_ERROR_NOT_FOUND: otError = 23;
#[doc = " The operation is already in progress."]
pub const OT_ERROR_ALREADY: otError = 24;
#[doc = " The creation of IPv6 address failed."]
pub const OT_ERROR_IP6_ADDRESS_CREATION_FAILURE: otError = 26;
#[doc = " Operation prevented by mode flags"]
pub const OT_ERROR_NOT_CAPABLE: otError = 27;
#[doc = " Coap response or acknowledgment or DNS, SNTP response not received."]
pub const OT_ERROR_RESPONSE_TIMEOUT: otError = 28;
#[doc = " Received a duplicated frame."]
pub const OT_ERROR_DUPLICATED: otError = 29;
#[doc = " Message is being dropped from reassembly list due to timeout."]
pub const OT_ERROR_REASSEMBLY_TIMEOUT: otError = 30;
#[doc = " Message is not a TMF Message."]
pub const OT_ERROR_NOT_TMF: otError = 31;
#[doc = " Received a non-lowpan data frame."]
pub const OT_ERROR_NOT_LOWPAN_DATA_FRAME: otError = 32;
#[doc = " The link margin was too low."]
pub const OT_ERROR_LINK_MARGIN_LOW: otError = 34;
#[doc = " Input (CLI) command is invalid."]
pub const OT_ERROR_INVALID_COMMAND: otError = 35;
#[doc = " Special error code used to indicate success/error status is pending and not yet known.\n"]
pub const OT_ERROR_PENDING: otError = 36;
#[doc = " Request rejected."]
pub const OT_ERROR_REJECTED: otError = 37;
#[doc = " The number of defined errors."]
pub const OT_NUM_ERRORS: otError = 38;
#[doc = " Generic error (should not use)."]
pub const OT_ERROR_GENERIC: otError = 255;
#[doc = " Represents error codes used throughout OpenThread.\n"]
pub type otError = ::std::os::raw::c_uint;
extern "C" {
#[doc = " Converts an otError enum into a string.\n\n @param[in] aError An otError enum.\n\n @returns A string representation of an otError.\n"]
pub fn otThreadErrorToString(aError: otError) -> *const ::std::os::raw::c_char;
}
pub type va_list = __builtin_va_list;
#[doc = " Represents the log level.\n"]
pub type otLogLevel = ::std::os::raw::c_int;
#[doc = "< OpenThread API"]
pub const OT_LOG_REGION_API: otLogRegion = 1;
#[doc = "< MLE"]
pub const OT_LOG_REGION_MLE: otLogRegion = 2;
#[doc = "< EID-to-RLOC mapping."]
pub const OT_LOG_REGION_ARP: otLogRegion = 3;
#[doc = "< Network Data"]
pub const OT_LOG_REGION_NET_DATA: otLogRegion = 4;
#[doc = "< ICMPv6"]
pub const OT_LOG_REGION_ICMP: otLogRegion = 5;
#[doc = "< IPv6"]
pub const OT_LOG_REGION_IP6: otLogRegion = 6;
#[doc = "< TCP"]
pub const OT_LOG_REGION_TCP: otLogRegion = 7;
#[doc = "< IEEE 802.15.4 MAC"]
pub const OT_LOG_REGION_MAC: otLogRegion = 8;
#[doc = "< Memory"]
pub const OT_LOG_REGION_MEM: otLogRegion = 9;
#[doc = "< NCP"]
pub const OT_LOG_REGION_NCP: otLogRegion = 10;
#[doc = "< Mesh Commissioning Protocol"]
pub const OT_LOG_REGION_MESH_COP: otLogRegion = 11;
#[doc = "< Network Diagnostic"]
pub const OT_LOG_REGION_NET_DIAG: otLogRegion = 12;
#[doc = "< Platform"]
pub const OT_LOG_REGION_PLATFORM: otLogRegion = 13;
#[doc = "< CoAP"]
pub const OT_LOG_REGION_COAP: otLogRegion = 14;
#[doc = "< CLI"]
pub const OT_LOG_REGION_CLI: otLogRegion = 15;
#[doc = "< OpenThread Core"]
pub const OT_LOG_REGION_CORE: otLogRegion = 16;
#[doc = "< Utility module"]
pub const OT_LOG_REGION_UTIL: otLogRegion = 17;
#[doc = "< Backbone Router (available since Thread 1.2)"]
pub const OT_LOG_REGION_BBR: otLogRegion = 18;
#[doc = "< Multicast Listener Registration (available since Thread 1.2)"]
pub const OT_LOG_REGION_MLR: otLogRegion = 19;
#[doc = "< Domain Unicast Address (available since Thread 1.2)"]
pub const OT_LOG_REGION_DUA: otLogRegion = 20;
#[doc = "< Border Router"]
pub const OT_LOG_REGION_BR: otLogRegion = 21;
#[doc = "< Service Registration Protocol (SRP)"]
pub const OT_LOG_REGION_SRP: otLogRegion = 22;
#[doc = "< DNS"]
pub const OT_LOG_REGION_DNS: otLogRegion = 23;
#[doc = " Represents log regions.\n\n The support for log region is removed and instead each core module can define its own name to appended to the logs.\n However, the `otLogRegion` enumeration is still defined as before to help with platforms which we may be using it\n in their `otPlatLog()` implementation. The OT core will always emit all logs with `OT_LOG_REGION_CORE`.\n"]
pub type otLogRegion = ::std::os::raw::c_uint;
extern "C" {
#[doc = " Outputs logs.\n\n Note that the support for log region is removed. The OT core will always emit all logs with `OT_LOG_REGION_CORE`\n as @p aLogRegion.\n\n @param[in] aLogLevel The log level.\n @param[in] aLogRegion The log region.\n @param[in] aFormat A pointer to the format string.\n @param[in] ... Arguments for the format specification.\n"]
pub fn otPlatLog(
aLogLevel: otLogLevel,
aLogRegion: otLogRegion,
aFormat: *const ::std::os::raw::c_char,
...
);
}
extern "C" {
#[doc = " This function handles OpenThread log level changes.\n\n This platform function is called whenever the OpenThread log level changes.\n This platform function is optional since an empty weak implementation has been provided.\n\n @note Only applicable when `OPENTHREAD_CONFIG_LOG_LEVEL_DYNAMIC_ENABLE=1`.\n\n @param[in] aLogLevel The new OpenThread log level.\n"]
pub fn otPlatLogHandleLevelChanged(aLogLevel: otLogLevel);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otInstance {
_unused: [u8; 0],
}
extern "C" {
#[doc = " Initializes the OpenThread library.\n\n Initializes OpenThread and prepares it for subsequent OpenThread API calls. This function must be\n called before any other calls to OpenThread.\n\n Is available and can only be used when support for multiple OpenThread instances is enabled.\n\n @param[in] aInstanceBuffer The buffer for OpenThread to use for allocating the otInstance structure.\n @param[in,out] aInstanceBufferSize On input, the size of aInstanceBuffer. On output, if not enough space for\n otInstance, the number of bytes required for otInstance.\n\n @returns A pointer to the new OpenThread instance.\n\n @sa otInstanceFinalize\n"]
pub fn otInstanceInit(
aInstanceBuffer: *mut ::std::os::raw::c_void,
aInstanceBufferSize: *mut usize,
) -> *mut otInstance;
}
extern "C" {
#[doc = " Initializes the static single instance of the OpenThread library.\n\n Initializes OpenThread and prepares it for subsequent OpenThread API calls. This function must be\n called before any other calls to OpenThread.\n\n Is available and can only be used when support for multiple OpenThread instances is disabled.\n\n @returns A pointer to the single OpenThread instance.\n"]
pub fn otInstanceInitSingle() -> *mut otInstance;
}
extern "C" {
#[doc = " Initializes the OpenThread instance.\n\n This function initializes OpenThread and prepares it for subsequent OpenThread API calls. This function must be\n called before any other calls to OpenThread. This method utilizes static buffer to initialize the OpenThread\n instance.\n\n This function is available and can only be used when support for multiple OpenThread static instances is\n enabled (`OPENTHREAD_CONFIG_MULTIPLE_STATIC_INSTANCE_ENABLE`)\n\n @param[in] aIdx The index of the OpenThread instance to initialize.\n\n @returns A pointer to the new OpenThread instance.\n"]
pub fn otInstanceInitMultiple(aIdx: u8) -> *mut otInstance;
}
extern "C" {
#[doc = " Gets the instance identifier.\n\n The instance identifier is set to a random value when the instance is constructed, and then its value will not\n change after initialization.\n\n @returns The instance identifier.\n"]
pub fn otInstanceGetId(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Indicates whether or not the instance is valid/initialized.\n\n The instance is considered valid if it is acquired and initialized using either `otInstanceInitSingle()` (in single\n instance case) or `otInstanceInit()` (in multi instance case). A subsequent call to `otInstanceFinalize()` causes\n the instance to be considered as uninitialized.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if the given instance is valid/initialized, FALSE otherwise.\n"]
pub fn otInstanceIsInitialized(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Disables the OpenThread library.\n\n Call this function when OpenThread is no longer in use.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otInstanceFinalize(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Returns the current instance uptime (in msec).\n\n Requires `OPENTHREAD_CONFIG_UPTIME_ENABLE` to be enabled.\n\n The uptime is given as number of milliseconds since OpenThread instance was initialized.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The uptime (number of milliseconds).\n"]
pub fn otInstanceGetUptime(aInstance: *mut otInstance) -> u64;
}
extern "C" {
#[doc = " Returns the current instance uptime as a human-readable string.\n\n Requires `OPENTHREAD_CONFIG_UPTIME_ENABLE` to be enabled.\n\n The string follows the format \"<hh>:<mm>:<ss>.<mmmm>\" for hours, minutes, seconds and millisecond (if uptime is\n shorter than one day) or \"<dd>d.<hh>:<mm>:<ss>.<mmmm>\" (if longer than a day).\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aBuffer A pointer to a char array to output the string.\n @param[in] aSize The size of @p aBuffer (in bytes). Recommended to use `OT_UPTIME_STRING_SIZE`.\n"]
pub fn otInstanceGetUptimeAsString(
aInstance: *mut otInstance,
aBuffer: *mut ::std::os::raw::c_char,
aSize: u16,
);
}
#[doc = " Represents a bit-field indicating specific state/configuration that has changed. See `OT_CHANGED_*`\n definitions.\n"]
pub type otChangedFlags = u32;
#[doc = " Pointer is called to notify certain configuration or state changes within OpenThread.\n\n @param[in] aFlags A bit-field indicating specific state that has changed. See `OT_CHANGED_*` definitions.\n @param[in] aContext A pointer to application-specific context.\n"]
pub type otStateChangedCallback = ::std::option::Option<
unsafe extern "C" fn(aFlags: otChangedFlags, aContext: *mut ::std::os::raw::c_void),
>;
extern "C" {
#[doc = " Registers a callback to indicate when certain configuration or state changes within OpenThread.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called with certain configuration or state changes.\n @param[in] aContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Added the callback to the list of callbacks.\n @retval OT_ERROR_ALREADY The callback was already registered.\n @retval OT_ERROR_NO_BUFS Could not add the callback due to resource constraints.\n"]
pub fn otSetStateChangedCallback(
aInstance: *mut otInstance,
aCallback: otStateChangedCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Removes a callback to indicate when certain configuration or state changes within OpenThread.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called with certain configuration or state changes.\n @param[in] aContext A pointer to application-specific context.\n"]
pub fn otRemoveStateChangeCallback(
aInstance: *mut otInstance,
aCallback: otStateChangedCallback,
aContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Triggers a platform reset.\n\n The reset process ensures that all the OpenThread state/info (stored in volatile memory) is erased. Note that the\n `otPlatformReset` does not erase any persistent state/info saved in non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otInstanceReset(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Triggers a platform reset to bootloader mode, if supported.\n\n Requires `OPENTHREAD_CONFIG_PLATFORM_BOOTLOADER_MODE_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Reset to bootloader successfully.\n @retval OT_ERROR_BUSY Failed due to another operation is ongoing.\n @retval OT_ERROR_NOT_CAPABLE Not capable of resetting to bootloader.\n"]
pub fn otInstanceResetToBootloader(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Deletes all the settings stored on non-volatile memory, and then triggers a platform reset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otInstanceFactoryReset(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Resets the internal states of the OpenThread radio stack.\n\n Callbacks and configurations are preserved.\n\n This API is only available under radio builds (`OPENTHREAD_RADIO = 1`).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otInstanceResetRadioStack(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Erases all the OpenThread persistent info (network settings) stored on non-volatile memory.\n Erase is successful only if the device is in `disabled` state/role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE All persistent info/state was erased successfully.\n @retval OT_ERROR_INVALID_STATE Device is not in `disabled` state/role.\n"]
pub fn otInstanceErasePersistentInfo(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Gets the OpenThread version string.\n\n @returns A pointer to the OpenThread version.\n"]
pub fn otGetVersionString() -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Gets the OpenThread radio version string.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the OpenThread radio version.\n"]
pub fn otGetRadioVersionString(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
}
#[doc = " Represents Backbone Router configuration.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otBackboneRouterConfig {
#[doc = "< Only used when get Primary Backbone Router information in the Thread Network"]
pub mServer16: u16,
#[doc = "< Reregistration Delay (in seconds)"]
pub mReregistrationDelay: u16,
#[doc = "< Multicast Listener Registration Timeout (in seconds)"]
pub mMlrTimeout: u32,
#[doc = "< Sequence Number"]
pub mSequenceNumber: u8,
}
extern "C" {
#[doc = " Gets the Primary Backbone Router information in the Thread Network.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aConfig A pointer to where to put Primary Backbone Router information.\n\n @retval OT_ERROR_NONE Successfully got Primary Backbone Router information.\n @retval OT_ERROR_NOT_FOUND No Primary Backbone Router exists.\n"]
pub fn otBackboneRouterGetPrimary(
aInstance: *mut otInstance,
aConfig: *mut otBackboneRouterConfig,
) -> otError;
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otMessage {
_unused: [u8; 0],
}
#[doc = "< Low priority level."]
pub const OT_MESSAGE_PRIORITY_LOW: otMessagePriority = 0;
#[doc = "< Normal priority level."]
pub const OT_MESSAGE_PRIORITY_NORMAL: otMessagePriority = 1;
#[doc = "< High priority level."]
pub const OT_MESSAGE_PRIORITY_HIGH: otMessagePriority = 2;
#[doc = " Defines the OpenThread message priority levels.\n"]
pub type otMessagePriority = ::std::os::raw::c_uint;
#[doc = "< Message from Thread Netif."]
pub const OT_MESSAGE_ORIGIN_THREAD_NETIF: otMessageOrigin = 0;
#[doc = "< Message from a trusted source on host."]
pub const OT_MESSAGE_ORIGIN_HOST_TRUSTED: otMessageOrigin = 1;
#[doc = "< Message from an untrusted source on host."]
pub const OT_MESSAGE_ORIGIN_HOST_UNTRUSTED: otMessageOrigin = 2;
#[doc = " Defines the OpenThread message origins.\n"]
pub type otMessageOrigin = ::std::os::raw::c_uint;
#[doc = " Represents a message settings.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otMessageSettings {
#[doc = "< TRUE if the message should be secured at Layer 2."]
pub mLinkSecurityEnabled: bool,
#[doc = "< Priority level (MUST be a `OT_MESSAGE_PRIORITY_*` from `otMessagePriority`)."]
pub mPriority: u8,
}
#[doc = " Represents link-specific information for messages received from the Thread radio.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otThreadLinkInfo {
#[doc = "< Source PAN ID"]
pub mPanId: u16,
#[doc = "< 802.15.4 Channel"]
pub mChannel: u8,
#[doc = "< Received Signal Strength in dBm (averaged over fragments)"]
pub mRss: i8,
#[doc = "< Average Link Quality Indicator (averaged over fragments)"]
pub mLqi: u8,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
#[doc = "< The time sync sequence."]
pub mTimeSyncSeq: u8,
#[doc = "< The time offset to the Thread network time, in microseconds."]
pub mNetworkTimeOffset: i64,
#[doc = "< Radio link type."]
pub mRadioType: u8,
}
impl otThreadLinkInfo {
#[inline]
pub fn mLinkSecurity(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mLinkSecurity(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn mIsDstPanIdBroadcast(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsDstPanIdBroadcast(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mLinkSecurity: bool,
mIsDstPanIdBroadcast: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mLinkSecurity: u8 = unsafe { ::std::mem::transmute(mLinkSecurity) };
mLinkSecurity as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let mIsDstPanIdBroadcast: u8 = unsafe { ::std::mem::transmute(mIsDstPanIdBroadcast) };
mIsDstPanIdBroadcast as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
#[doc = " Free an allocated message buffer.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite\n"]
pub fn otMessageFree(aMessage: *mut otMessage);
}
extern "C" {
#[doc = " Get the message length in bytes.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @returns The message length in bytes.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite\n @sa otMessageSetLength\n"]
pub fn otMessageGetLength(aMessage: *const otMessage) -> u16;
}
extern "C" {
#[doc = " Set the message length in bytes.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aLength A length in bytes.\n\n @retval OT_ERROR_NONE Successfully set the message length.\n @retval OT_ERROR_NO_BUFS No available buffers to grow the message.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite\n"]
pub fn otMessageSetLength(aMessage: *mut otMessage, aLength: u16) -> otError;
}
extern "C" {
#[doc = " Get the message offset in bytes.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @returns The message offset value.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite\n"]
pub fn otMessageGetOffset(aMessage: *const otMessage) -> u16;
}
extern "C" {
#[doc = " Set the message offset in bytes.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aOffset An offset in bytes.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageRead\n @sa otMessageWrite\n"]
pub fn otMessageSetOffset(aMessage: *mut otMessage, aOffset: u16);
}
extern "C" {
#[doc = " Indicates whether or not link security is enabled for the message.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @retval TRUE If link security is enabled.\n @retval FALSE If link security is not enabled.\n"]
pub fn otMessageIsLinkSecurityEnabled(aMessage: *const otMessage) -> bool;
}
extern "C" {
#[doc = " Indicates whether or not the message is allowed to be looped back to host.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @retval TRUE If the message is allowed to be looped back to host.\n @retval FALSE If the message is not allowed to be looped back to host.\n"]
pub fn otMessageIsLoopbackToHostAllowed(aMessage: *const otMessage) -> bool;
}
extern "C" {
#[doc = " Sets whether or not the message is allowed to be looped back to host.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aAllowLoopbackToHost Whether to allow the message to be looped back to host.\n"]
pub fn otMessageSetLoopbackToHostAllowed(aMessage: *mut otMessage, aAllowLoopbackToHost: bool);
}
extern "C" {
#[doc = " Indicates whether the given message may be looped back in a case of a multicast destination address.\n\n If @p aMessage is used along with an `otMessageInfo`, the `mMulticastLoop` field from `otMessageInfo` structure\n takes precedence and will be used instead of the the value set on @p aMessage.\n\n This API is mainly intended for use along with `otIp6Send()` which expects an already prepared IPv6 message.\n\n @param[in] aMessage A pointer to the message.\n"]
pub fn otMessageIsMulticastLoopEnabled(aMessage: *mut otMessage) -> bool;
}
extern "C" {
#[doc = " Controls whether the given message may be looped back in a case of a multicast destination address.\n\n @param[in] aMessage A pointer to the message.\n @param[in] aEnabled The configuration value.\n"]
pub fn otMessageSetMulticastLoopEnabled(aMessage: *mut otMessage, aEnabled: bool);
}
extern "C" {
#[doc = " Gets the message origin.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @returns The message origin.\n"]
pub fn otMessageGetOrigin(aMessage: *const otMessage) -> otMessageOrigin;
}
extern "C" {
#[doc = " Sets the message origin.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aOrigin The message origin.\n"]
pub fn otMessageSetOrigin(aMessage: *mut otMessage, aOrigin: otMessageOrigin);
}
extern "C" {
#[doc = " Sets/forces the message to be forwarded using direct transmission.\n Default setting for a new message is `false`.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aEnabled If `true`, the message is forced to use direct transmission. If `false`, the message follows\n the normal procedure.\n"]
pub fn otMessageSetDirectTransmission(aMessage: *mut otMessage, aEnabled: bool);
}
extern "C" {
#[doc = " Returns the average RSS (received signal strength) associated with the message.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @returns The average RSS value (in dBm) or OT_RADIO_RSSI_INVALID if no average RSS is available.\n"]
pub fn otMessageGetRss(aMessage: *const otMessage) -> i8;
}
extern "C" {
#[doc = " Retrieves the link-specific information for a message received over Thread radio.\n\n @param[in] aMessage The message from which to retrieve `otThreadLinkInfo`.\n @pram[out] aLinkInfo A pointer to an `otThreadLinkInfo` to populate.\n\n @retval OT_ERROR_NONE Successfully retrieved the link info, @p `aLinkInfo` is updated.\n @retval OT_ERROR_NOT_FOUND Message origin is not `OT_MESSAGE_ORIGIN_THREAD_NETIF`.\n"]
pub fn otMessageGetThreadLinkInfo(
aMessage: *const otMessage,
aLinkInfo: *mut otThreadLinkInfo,
) -> otError;
}
extern "C" {
#[doc = " Append bytes to a message.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aBuf A pointer to the data to append.\n @param[in] aLength Number of bytes to append.\n\n @retval OT_ERROR_NONE Successfully appended to the message\n @retval OT_ERROR_NO_BUFS No available buffers to grow the message.\n\n @sa otMessageFree\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n @sa otMessageWrite\n"]
pub fn otMessageAppend(
aMessage: *mut otMessage,
aBuf: *const ::std::os::raw::c_void,
aLength: u16,
) -> otError;
}
extern "C" {
#[doc = " Read bytes from a message.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aOffset An offset in bytes.\n @param[in] aBuf A pointer to a buffer that message bytes are read to.\n @param[in] aLength Number of bytes to read.\n\n @returns The number of bytes read.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageWrite\n"]
pub fn otMessageRead(
aMessage: *const otMessage,
aOffset: u16,
aBuf: *mut ::std::os::raw::c_void,
aLength: u16,
) -> u16;
}
extern "C" {
#[doc = " Write bytes to a message.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aOffset An offset in bytes.\n @param[in] aBuf A pointer to a buffer that message bytes are written from.\n @param[in] aLength Number of bytes to write.\n\n @returns The number of bytes written.\n\n @sa otMessageFree\n @sa otMessageAppend\n @sa otMessageGetLength\n @sa otMessageSetLength\n @sa otMessageGetOffset\n @sa otMessageSetOffset\n @sa otMessageRead\n"]
pub fn otMessageWrite(
aMessage: *mut otMessage,
aOffset: u16,
aBuf: *const ::std::os::raw::c_void,
aLength: u16,
) -> ::std::os::raw::c_int;
}
#[doc = " Represents an OpenThread message queue."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otMessageQueue {
#[doc = "< Opaque data used by the implementation."]
pub mData: *mut ::std::os::raw::c_void,
}
impl Default for otMessageQueue {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Represents information about a message queue.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otMessageQueueInfo {
#[doc = "< Number of messages in the queue."]
pub mNumMessages: u16,
#[doc = "< Number of data buffers used by messages in the queue."]
pub mNumBuffers: u16,
#[doc = "< Total number of bytes used by all messages in the queue."]
pub mTotalBytes: u32,
}
#[doc = " Represents the message buffer information for different queues used by OpenThread stack.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otBufferInfo {
#[doc = "< The total number of buffers in the messages pool (0xffff if unknown)."]
pub mTotalBuffers: u16,
#[doc = "< The number of free buffers (0xffff if unknown)."]
pub mFreeBuffers: u16,
#[doc = " The maximum number of used buffers at the same time since OT stack initialization or last call to\n `otMessageResetBufferInfo()`.\n"]
pub mMaxUsedBuffers: u16,
#[doc = "< Info about 6LoWPAN send queue."]
pub m6loSendQueue: otMessageQueueInfo,
#[doc = "< Info about 6LoWPAN reassembly queue."]
pub m6loReassemblyQueue: otMessageQueueInfo,
#[doc = "< Info about IPv6 send queue."]
pub mIp6Queue: otMessageQueueInfo,
#[doc = "< Info about MPL send queue."]
pub mMplQueue: otMessageQueueInfo,
#[doc = "< Info about MLE delayed message queue."]
pub mMleQueue: otMessageQueueInfo,
#[doc = "< Info about CoAP/TMF send queue."]
pub mCoapQueue: otMessageQueueInfo,
#[doc = "< Info about CoAP secure send queue."]
pub mCoapSecureQueue: otMessageQueueInfo,
#[doc = "< Info about application CoAP send queue."]
pub mApplicationCoapQueue: otMessageQueueInfo,
}
extern "C" {
#[doc = " Initialize the message queue.\n\n MUST be called once and only once for a `otMessageQueue` instance before any other `otMessageQueue`\n functions. The behavior is undefined if other queue APIs are used with an `otMessageQueue` before it being\n initialized or if it is initialized more than once.\n\n @param[in] aQueue A pointer to a message queue.\n"]
pub fn otMessageQueueInit(aQueue: *mut otMessageQueue);
}
extern "C" {
#[doc = " Adds a message to the end of the given message queue.\n\n @param[in] aQueue A pointer to the message queue.\n @param[in] aMessage The message to add.\n"]
pub fn otMessageQueueEnqueue(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
}
extern "C" {
#[doc = " Adds a message at the head/front of the given message queue.\n\n @param[in] aQueue A pointer to the message queue.\n @param[in] aMessage The message to add.\n"]
pub fn otMessageQueueEnqueueAtHead(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
}
extern "C" {
#[doc = " Removes a message from the given message queue.\n\n @param[in] aQueue A pointer to the message queue.\n @param[in] aMessage The message to remove.\n"]
pub fn otMessageQueueDequeue(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
}
extern "C" {
#[doc = " Returns a pointer to the message at the head of the queue.\n\n @param[in] aQueue A pointer to a message queue.\n\n @returns A pointer to the message at the head of queue or NULL if queue is empty.\n"]
pub fn otMessageQueueGetHead(aQueue: *mut otMessageQueue) -> *mut otMessage;
}
extern "C" {
#[doc = " Returns a pointer to the next message in the queue by iterating forward (from head to tail).\n\n @param[in] aQueue A pointer to a message queue.\n @param[in] aMessage A pointer to current message buffer.\n\n @returns A pointer to the next message in the queue after `aMessage` or NULL if `aMessage is the tail of queue.\n NULL is returned if `aMessage` is not in the queue `aQueue`.\n"]
pub fn otMessageQueueGetNext(
aQueue: *mut otMessageQueue,
aMessage: *const otMessage,
) -> *mut otMessage;
}
extern "C" {
#[doc = " Get the Message Buffer information.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[out] aBufferInfo A pointer where the message buffer information is written.\n"]
pub fn otMessageGetBufferInfo(aInstance: *mut otInstance, aBufferInfo: *mut otBufferInfo);
}
extern "C" {
#[doc = " Reset the Message Buffer information counter tracking the maximum number buffers in use at the same time.\n\n This resets `mMaxUsedBuffers` in `otBufferInfo`.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n"]
pub fn otMessageResetBufferInfo(aInstance: *mut otInstance);
}
#[doc = "< Key Type: Raw Data."]
pub const OT_CRYPTO_KEY_TYPE_RAW: otCryptoKeyType = 0;
#[doc = "< Key Type: AES."]
pub const OT_CRYPTO_KEY_TYPE_AES: otCryptoKeyType = 1;
#[doc = "< Key Type: HMAC."]
pub const OT_CRYPTO_KEY_TYPE_HMAC: otCryptoKeyType = 2;
#[doc = "< Key Type: ECDSA."]
pub const OT_CRYPTO_KEY_TYPE_ECDSA: otCryptoKeyType = 3;
#[doc = " Defines the key types.\n"]
pub type otCryptoKeyType = ::std::os::raw::c_uint;
#[doc = "< Key Algorithm: Vendor Defined."]
pub const OT_CRYPTO_KEY_ALG_VENDOR: otCryptoKeyAlgorithm = 0;
#[doc = "< Key Algorithm: AES ECB."]
pub const OT_CRYPTO_KEY_ALG_AES_ECB: otCryptoKeyAlgorithm = 1;
#[doc = "< Key Algorithm: HMAC SHA-256."]
pub const OT_CRYPTO_KEY_ALG_HMAC_SHA_256: otCryptoKeyAlgorithm = 2;
#[doc = "< Key Algorithm: ECDSA."]
pub const OT_CRYPTO_KEY_ALG_ECDSA: otCryptoKeyAlgorithm = 3;
#[doc = " Defines the key algorithms.\n"]
pub type otCryptoKeyAlgorithm = ::std::os::raw::c_uint;
#[doc = "< Key Usage: Key Usage is empty."]
pub const OT_CRYPTO_KEY_USAGE_NONE: _bindgen_ty_1 = 0;
#[doc = "< Key Usage: Key can be exported."]
pub const OT_CRYPTO_KEY_USAGE_EXPORT: _bindgen_ty_1 = 1;
#[doc = "< Key Usage: Encryption (vendor defined)."]
pub const OT_CRYPTO_KEY_USAGE_ENCRYPT: _bindgen_ty_1 = 2;
#[doc = "< Key Usage: AES ECB."]
pub const OT_CRYPTO_KEY_USAGE_DECRYPT: _bindgen_ty_1 = 4;
#[doc = "< Key Usage: Sign Hash."]
pub const OT_CRYPTO_KEY_USAGE_SIGN_HASH: _bindgen_ty_1 = 8;
#[doc = "< Key Usage: Verify Hash."]
pub const OT_CRYPTO_KEY_USAGE_VERIFY_HASH: _bindgen_ty_1 = 16;
#[doc = " Defines the key usage flags.\n"]
pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
#[doc = "< Key Persistence: Key is volatile."]
pub const OT_CRYPTO_KEY_STORAGE_VOLATILE: otCryptoKeyStorage = 0;
#[doc = "< Key Persistence: Key is persistent."]
pub const OT_CRYPTO_KEY_STORAGE_PERSISTENT: otCryptoKeyStorage = 1;
#[doc = " Defines the key storage types.\n"]
pub type otCryptoKeyStorage = ::std::os::raw::c_uint;
#[doc = " This datatype represents the key reference.\n"]
pub type otCryptoKeyRef = u32;
#[doc = " @struct otCryptoKey\n\n Represents the Key Material required for Crypto operations.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otCryptoKey {
#[doc = "< Pointer to the buffer containing key. NULL indicates to use `mKeyRef`."]
pub mKey: *const u8,
#[doc = "< The key length in bytes (applicable when `mKey` is not NULL)."]
pub mKeyLength: u16,
#[doc = "< The PSA key ref (requires `mKey` to be NULL)."]
pub mKeyRef: u32,
}
impl Default for otCryptoKey {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " @struct otCryptoContext\n\n Stores the context object for platform APIs.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otCryptoContext {
#[doc = "< Pointer to the context."]
pub mContext: *mut ::std::os::raw::c_void,
#[doc = "< The length of the context in bytes."]
pub mContextSize: u16,
}
impl Default for otCryptoContext {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " @struct otPlatCryptoSha256Hash\n\n Represents a SHA-256 hash.\n"]
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otPlatCryptoSha256Hash {
#[doc = "< Hash bytes."]
pub m8: [u8; 32usize],
}
#[doc = " @struct otPlatCryptoEcdsaKeyPair\n\n Represents an ECDSA key pair (public and private keys).\n\n The key pair is stored using Distinguished Encoding Rules (DER) format (per RFC 5915).\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otPlatCryptoEcdsaKeyPair {
pub mDerBytes: [u8; 125usize],
pub mDerLength: u8,
}
impl Default for otPlatCryptoEcdsaKeyPair {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " @struct otPlatCryptoEcdsaPublicKey\n\n Represents a ECDSA public key.\n\n The public key is stored as a byte sequence representation of an uncompressed curve point (RFC 6605 - sec 4).\n"]
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct otPlatCryptoEcdsaPublicKey {
pub m8: [u8; 64usize],
}
impl Default for otPlatCryptoEcdsaPublicKey {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " @struct otPlatCryptoEcdsaSignature\n\n Represents an ECDSA signature.\n\n The signature is encoded as the concatenated binary representation of two MPIs `r` and `s` which are calculated\n during signing (RFC 6605 - section 4).\n"]
#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct otPlatCryptoEcdsaSignature {
pub m8: [u8; 64usize],
}
impl Default for otPlatCryptoEcdsaSignature {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
#[doc = " Initialize the Crypto module.\n"]
pub fn otPlatCryptoInit();
}
extern "C" {
#[doc = " Import a key into PSA ITS.\n\n @param[in,out] aKeyRef Pointer to the key ref to be used for crypto operations.\n @param[in] aKeyType Key Type encoding for the key.\n @param[in] aKeyAlgorithm Key algorithm encoding for the key.\n @param[in] aKeyUsage Key Usage encoding for the key (combinations of `OT_CRYPTO_KEY_USAGE_*`).\n @param[in] aKeyPersistence Key Persistence for this key\n @param[in] aKey Actual key to be imported.\n @param[in] aKeyLen Length of the key to be imported.\n\n @retval OT_ERROR_NONE Successfully imported the key.\n @retval OT_ERROR_FAILED Failed to import the key.\n @retval OT_ERROR_INVALID_ARGS @p aKey was set to NULL.\n\n @note If OT_CRYPTO_KEY_STORAGE_PERSISTENT is passed for aKeyPersistence then @p aKeyRef is input and platform\n should use the given aKeyRef and MUST not change it.\n\n If OT_CRYPTO_KEY_STORAGE_VOLATILE is passed for aKeyPersistence then @p aKeyRef is output, the initial\n value does not matter and platform API MUST update it to return the new key ref.\n\n This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled.\n"]
pub fn otPlatCryptoImportKey(
aKeyRef: *mut otCryptoKeyRef,
aKeyType: otCryptoKeyType,
aKeyAlgorithm: otCryptoKeyAlgorithm,
aKeyUsage: ::std::os::raw::c_int,
aKeyPersistence: otCryptoKeyStorage,
aKey: *const u8,
aKeyLen: usize,
) -> otError;
}
extern "C" {
#[doc = " Export a key stored in PSA ITS.\n\n @param[in] aKeyRef The key ref to be used for crypto operations.\n @param[out] aBuffer Pointer to the buffer where key needs to be exported.\n @param[in] aBufferLen Length of the buffer passed to store the exported key.\n @param[out] aKeyLen Pointer to return the length of the exported key.\n\n @retval OT_ERROR_NONE Successfully exported @p aKeyRef.\n @retval OT_ERROR_FAILED Failed to export @p aKeyRef.\n @retval OT_ERROR_INVALID_ARGS @p aBuffer was NULL\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled.\n"]
pub fn otPlatCryptoExportKey(
aKeyRef: otCryptoKeyRef,
aBuffer: *mut u8,
aBufferLen: usize,
aKeyLen: *mut usize,
) -> otError;
}
extern "C" {
#[doc = " Destroy a key stored in PSA ITS.\n\n @param[in] aKeyRef The key ref to be destroyed\n\n @retval OT_ERROR_NONE Successfully destroyed the key.\n @retval OT_ERROR_FAILED Failed to destroy the key.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled.\n"]
pub fn otPlatCryptoDestroyKey(aKeyRef: otCryptoKeyRef) -> otError;
}
extern "C" {
#[doc = " Check if the key ref passed has an associated key in PSA ITS.\n\n @param[in] aKeyRef The Key Ref to check.\n\n @retval TRUE There is an associated key with @p aKeyRef.\n @retval FALSE There is no associated key with @p aKeyRef.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled.\n"]
pub fn otPlatCryptoHasKey(aKeyRef: otCryptoKeyRef) -> bool;
}
extern "C" {
#[doc = " Initialize the HMAC operation.\n\n @param[in] aContext Context for HMAC operation.\n\n @retval OT_ERROR_NONE Successfully initialized HMAC operation.\n @retval OT_ERROR_FAILED Failed to initialize HMAC operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n\n @note The platform driver shall point the context to the correct object such as psa_mac_operation_t or\n mbedtls_md_context_t.\n"]
pub fn otPlatCryptoHmacSha256Init(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Uninitialize the HMAC operation.\n\n @param[in] aContext Context for HMAC operation.\n\n @retval OT_ERROR_NONE Successfully uninitialized HMAC operation.\n @retval OT_ERROR_FAILED Failed to uninitialized HMAC operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n"]
pub fn otPlatCryptoHmacSha256Deinit(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Start HMAC operation.\n\n @param[in] aContext Context for HMAC operation.\n @param[in] aKey Key material to be used for HMAC operation.\n\n @retval OT_ERROR_NONE Successfully started HMAC operation.\n @retval OT_ERROR_FAILED Failed to start HMAC operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext or @p aKey was NULL\n"]
pub fn otPlatCryptoHmacSha256Start(
aContext: *mut otCryptoContext,
aKey: *const otCryptoKey,
) -> otError;
}
extern "C" {
#[doc = " Update the HMAC operation with new input.\n\n @param[in] aContext Context for HMAC operation.\n @param[in] aBuf A pointer to the input buffer.\n @param[in] aBufLength The length of @p aBuf in bytes.\n\n @retval OT_ERROR_NONE Successfully updated HMAC with new input operation.\n @retval OT_ERROR_FAILED Failed to update HMAC operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext or @p aBuf was NULL\n"]
pub fn otPlatCryptoHmacSha256Update(
aContext: *mut otCryptoContext,
aBuf: *const ::std::os::raw::c_void,
aBufLength: u16,
) -> otError;
}
extern "C" {
#[doc = " Complete the HMAC operation.\n\n @param[in] aContext Context for HMAC operation.\n @param[out] aBuf A pointer to the output buffer.\n @param[in] aBufLength The length of @p aBuf in bytes.\n\n @retval OT_ERROR_NONE Successfully completed HMAC operation.\n @retval OT_ERROR_FAILED Failed to complete HMAC operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext or @p aBuf was NULL\n"]
pub fn otPlatCryptoHmacSha256Finish(
aContext: *mut otCryptoContext,
aBuf: *mut u8,
aBufLength: usize,
) -> otError;
}
extern "C" {
#[doc = " Initialise the AES operation.\n\n @param[in] aContext Context for AES operation.\n\n @retval OT_ERROR_NONE Successfully Initialised AES operation.\n @retval OT_ERROR_FAILED Failed to Initialise AES operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n @retval OT_ERROR_NO_BUFS Cannot allocate the context.\n\n @note The platform driver shall point the context to the correct object such as psa_key_id\n or mbedtls_aes_context_t.\n"]
pub fn otPlatCryptoAesInit(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Set the key for AES operation.\n\n @param[in] aContext Context for AES operation.\n @param[out] aKey Key to use for AES operation.\n\n @retval OT_ERROR_NONE Successfully set the key for AES operation.\n @retval OT_ERROR_FAILED Failed to set the key for AES operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext or @p aKey was NULL\n"]
pub fn otPlatCryptoAesSetKey(
aContext: *mut otCryptoContext,
aKey: *const otCryptoKey,
) -> otError;
}
extern "C" {
#[doc = " Encrypt the given data.\n\n @param[in] aContext Context for AES operation.\n @param[in] aInput Pointer to the input buffer.\n @param[in] aOutput Pointer to the output buffer.\n\n @retval OT_ERROR_NONE Successfully encrypted @p aInput.\n @retval OT_ERROR_FAILED Failed to encrypt @p aInput.\n @retval OT_ERROR_INVALID_ARGS @p aContext or @p aKey or @p aOutput were NULL\n"]
pub fn otPlatCryptoAesEncrypt(
aContext: *mut otCryptoContext,
aInput: *const u8,
aOutput: *mut u8,
) -> otError;
}
extern "C" {
#[doc = " Free the AES context.\n\n @param[in] aContext Context for AES operation.\n\n @retval OT_ERROR_NONE Successfully freed AES context.\n @retval OT_ERROR_FAILED Failed to free AES context.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n"]
pub fn otPlatCryptoAesFree(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Initialise the HKDF context.\n\n @param[in] aContext Context for HKDF operation.\n\n @retval OT_ERROR_NONE Successfully Initialised AES operation.\n @retval OT_ERROR_FAILED Failed to Initialise AES operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n\n @note The platform driver shall point the context to the correct object such as psa_key_derivation_operation_t\n or HmacSha256::Hash\n"]
pub fn otPlatCryptoHkdfInit(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Perform HKDF Expand step.\n\n @param[in] aContext Operation context for HKDF operation.\n @param[in] aInfo Pointer to the Info sequence.\n @param[in] aInfoLength Length of the Info sequence.\n @param[out] aOutputKey Pointer to the output Key.\n @param[in] aOutputKeyLength Size of the output key buffer.\n\n @retval OT_ERROR_NONE HKDF Expand was successful.\n @retval OT_ERROR_FAILED HKDF Expand failed.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n"]
pub fn otPlatCryptoHkdfExpand(
aContext: *mut otCryptoContext,
aInfo: *const u8,
aInfoLength: u16,
aOutputKey: *mut u8,
aOutputKeyLength: u16,
) -> otError;
}
extern "C" {
#[doc = " Perform HKDF Extract step.\n\n @param[in] aContext Operation context for HKDF operation.\n @param[in] aSalt Pointer to the Salt for HKDF.\n @param[in] aSaltLength Length of Salt.\n @param[in] aInputKey Pointer to the input key.\n\n @retval OT_ERROR_NONE HKDF Extract was successful.\n @retval OT_ERROR_FAILED HKDF Extract failed.\n"]
pub fn otPlatCryptoHkdfExtract(
aContext: *mut otCryptoContext,
aSalt: *const u8,
aSaltLength: u16,
aInputKey: *const otCryptoKey,
) -> otError;
}
extern "C" {
#[doc = " Uninitialize the HKDF context.\n\n @param[in] aContext Context for HKDF operation.\n\n @retval OT_ERROR_NONE Successfully un-initialised HKDF operation.\n @retval OT_ERROR_FAILED Failed to un-initialised HKDF operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n"]
pub fn otPlatCryptoHkdfDeinit(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Initialise the SHA-256 operation.\n\n @param[in] aContext Context for SHA-256 operation.\n\n @retval OT_ERROR_NONE Successfully initialised SHA-256 operation.\n @retval OT_ERROR_FAILED Failed to initialise SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n\n\n @note The platform driver shall point the context to the correct object such as psa_hash_operation_t\n or mbedtls_sha256_context."]
pub fn otPlatCryptoSha256Init(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Uninitialize the SHA-256 operation.\n\n @param[in] aContext Context for SHA-256 operation.\n\n @retval OT_ERROR_NONE Successfully un-initialised SHA-256 operation.\n @retval OT_ERROR_FAILED Failed to un-initialised SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n"]
pub fn otPlatCryptoSha256Deinit(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Start SHA-256 operation.\n\n @param[in] aContext Context for SHA-256 operation.\n\n @retval OT_ERROR_NONE Successfully started SHA-256 operation.\n @retval OT_ERROR_FAILED Failed to start SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext was NULL\n"]
pub fn otPlatCryptoSha256Start(aContext: *mut otCryptoContext) -> otError;
}
extern "C" {
#[doc = " Update SHA-256 operation with new input.\n\n @param[in] aContext Context for SHA-256 operation.\n @param[in] aBuf A pointer to the input buffer.\n @param[in] aBufLength The length of @p aBuf in bytes.\n\n @retval OT_ERROR_NONE Successfully updated SHA-256 with new input operation.\n @retval OT_ERROR_FAILED Failed to update SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext or @p aBuf was NULL\n"]
pub fn otPlatCryptoSha256Update(
aContext: *mut otCryptoContext,
aBuf: *const ::std::os::raw::c_void,
aBufLength: u16,
) -> otError;
}
extern "C" {
#[doc = " Finish SHA-256 operation.\n\n @param[in] aContext Context for SHA-256 operation.\n @param[in] aHash A pointer to the output buffer, where hash needs to be stored.\n @param[in] aHashSize The length of @p aHash in bytes.\n\n @retval OT_ERROR_NONE Successfully completed the SHA-256 operation.\n @retval OT_ERROR_FAILED Failed to complete SHA-256 operation.\n @retval OT_ERROR_INVALID_ARGS @p aContext or @p aHash was NULL\n"]
pub fn otPlatCryptoSha256Finish(
aContext: *mut otCryptoContext,
aHash: *mut u8,
aHashSize: u16,
) -> otError;
}
extern "C" {
#[doc = " Initialize cryptographically-secure pseudorandom number generator (CSPRNG).\n"]
pub fn otPlatCryptoRandomInit();
}
extern "C" {
#[doc = " Deinitialize cryptographically-secure pseudorandom number generator (CSPRNG).\n"]
pub fn otPlatCryptoRandomDeinit();
}
extern "C" {
#[doc = " Fills a given buffer with cryptographically secure random bytes.\n\n @param[out] aBuffer A pointer to a buffer to fill with the random bytes.\n @param[in] aSize Size of buffer (number of bytes to fill).\n\n @retval OT_ERROR_NONE Successfully filled buffer with random values.\n @retval OT_ERROR_FAILED Operation failed.\n"]
pub fn otPlatCryptoRandomGet(aBuffer: *mut u8, aSize: u16) -> otError;
}
extern "C" {
#[doc = " Generate and populate the output buffer with a new ECDSA key-pair.\n\n @param[out] aKeyPair A pointer to an ECDSA key-pair structure to store the generated key-pair.\n\n @retval OT_ERROR_NONE A new key-pair was generated successfully.\n @retval OT_ERROR_NO_BUFS Failed to allocate buffer for key generation.\n @retval OT_ERROR_NOT_CAPABLE Feature not supported.\n @retval OT_ERROR_FAILED Failed to generate key-pair.\n"]
pub fn otPlatCryptoEcdsaGenerateKey(aKeyPair: *mut otPlatCryptoEcdsaKeyPair) -> otError;
}
extern "C" {
#[doc = " Get the associated public key from the input context.\n\n @param[in] aKeyPair A pointer to an ECDSA key-pair structure where the key-pair is stored.\n @param[out] aPublicKey A pointer to an ECDSA public key structure to store the public key.\n\n @retval OT_ERROR_NONE Public key was retrieved successfully, and @p aBuffer is updated.\n @retval OT_ERROR_PARSE The key-pair DER format could not be parsed (invalid format).\n @retval OT_ERROR_INVALID_ARGS The @p aContext is NULL.\n"]
pub fn otPlatCryptoEcdsaGetPublicKey(
aKeyPair: *const otPlatCryptoEcdsaKeyPair,
aPublicKey: *mut otPlatCryptoEcdsaPublicKey,
) -> otError;
}
extern "C" {
#[doc = " Calculate the ECDSA signature for a hashed message using the private key from the input context.\n\n Uses the deterministic digital signature generation procedure from RFC 6979.\n\n @param[in] aKeyPair A pointer to an ECDSA key-pair structure where the key-pair is stored.\n @param[in] aHash A pointer to a SHA-256 hash structure where the hash value for signature calculation\n is stored.\n @param[out] aSignature A pointer to an ECDSA signature structure to output the calculated signature.\n\n @retval OT_ERROR_NONE The signature was calculated successfully, @p aSignature was updated.\n @retval OT_ERROR_PARSE The key-pair DER format could not be parsed (invalid format).\n @retval OT_ERROR_NO_BUFS Failed to allocate buffer for signature calculation.\n @retval OT_ERROR_INVALID_ARGS The @p aContext is NULL.\n"]
pub fn otPlatCryptoEcdsaSign(
aKeyPair: *const otPlatCryptoEcdsaKeyPair,
aHash: *const otPlatCryptoSha256Hash,
aSignature: *mut otPlatCryptoEcdsaSignature,
) -> otError;
}
extern "C" {
#[doc = " Use the key from the input context to verify the ECDSA signature of a hashed message.\n\n @param[in] aPublicKey A pointer to an ECDSA public key structure where the public key for signature\n verification is stored.\n @param[in] aHash A pointer to a SHA-256 hash structure where the hash value for signature verification\n is stored.\n @param[in] aSignature A pointer to an ECDSA signature structure where the signature value to be verified is\n stored.\n\n @retval OT_ERROR_NONE The signature was verified successfully.\n @retval OT_ERROR_SECURITY The signature is invalid.\n @retval OT_ERROR_INVALID_ARGS The key or hash is invalid.\n @retval OT_ERROR_NO_BUFS Failed to allocate buffer for signature verification.\n"]
pub fn otPlatCryptoEcdsaVerify(
aPublicKey: *const otPlatCryptoEcdsaPublicKey,
aHash: *const otPlatCryptoSha256Hash,
aSignature: *const otPlatCryptoEcdsaSignature,
) -> otError;
}
extern "C" {
#[doc = " Calculate the ECDSA signature for a hashed message using the Key reference passed.\n\n Uses the deterministic digital signature generation procedure from RFC 6979.\n\n @param[in] aKeyRef Key Reference to the slot where the key-pair is stored.\n @param[in] aHash A pointer to a SHA-256 hash structure where the hash value for signature calculation\n is stored.\n @param[out] aSignature A pointer to an ECDSA signature structure to output the calculated signature.\n\n @retval OT_ERROR_NONE The signature was calculated successfully, @p aSignature was updated.\n @retval OT_ERROR_PARSE The key-pair DER format could not be parsed (invalid format).\n @retval OT_ERROR_NO_BUFS Failed to allocate buffer for signature calculation.\n @retval OT_ERROR_INVALID_ARGS The @p aContext is NULL.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled.\n"]
pub fn otPlatCryptoEcdsaSignUsingKeyRef(
aKeyRef: otCryptoKeyRef,
aHash: *const otPlatCryptoSha256Hash,
aSignature: *mut otPlatCryptoEcdsaSignature,
) -> otError;
}
extern "C" {
#[doc = " Get the associated public key from the key reference passed.\n\n The public key is stored differently depending on the crypto backend library being used\n (OPENTHREAD_CONFIG_CRYPTO_LIB).\n\n This API must make sure to return the public key as a byte sequence representation of an\n uncompressed curve point (RFC 6605 - sec 4)\n\n @param[in] aKeyRef Key Reference to the slot where the key-pair is stored.\n @param[out] aPublicKey A pointer to an ECDSA public key structure to store the public key.\n\n @retval OT_ERROR_NONE Public key was retrieved successfully, and @p aBuffer is updated.\n @retval OT_ERROR_PARSE The key-pair DER format could not be parsed (invalid format).\n @retval OT_ERROR_INVALID_ARGS The @p aContext is NULL.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled.\n"]
pub fn otPlatCryptoEcdsaExportPublicKey(
aKeyRef: otCryptoKeyRef,
aPublicKey: *mut otPlatCryptoEcdsaPublicKey,
) -> otError;
}
extern "C" {
#[doc = " Generate and import a new ECDSA key-pair at reference passed.\n\n @param[in] aKeyRef Key Reference to the slot where the key-pair is stored.\n\n @retval OT_ERROR_NONE A new key-pair was generated successfully.\n @retval OT_ERROR_NO_BUFS Failed to allocate buffer for key generation.\n @retval OT_ERROR_NOT_CAPABLE Feature not supported.\n @retval OT_ERROR_FAILED Failed to generate key-pair.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled.\n"]
pub fn otPlatCryptoEcdsaGenerateAndImportKey(aKeyRef: otCryptoKeyRef) -> otError;
}
extern "C" {
#[doc = " Use the keyref to verify the ECDSA signature of a hashed message.\n\n @param[in] aKeyRef Key Reference to the slot where the key-pair is stored.\n @param[in] aHash A pointer to a SHA-256 hash structure where the hash value for signature verification\n is stored.\n @param[in] aSignature A pointer to an ECDSA signature structure where the signature value to be verified is\n stored.\n\n @retval OT_ERROR_NONE The signature was verified successfully.\n @retval OT_ERROR_SECURITY The signature is invalid.\n @retval OT_ERROR_INVALID_ARGS The key or hash is invalid.\n @retval OT_ERROR_NO_BUFS Failed to allocate buffer for signature verification.\n\n @note This API is only used by OT core when `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` is enabled.\n"]
pub fn otPlatCryptoEcdsaVerifyUsingKeyRef(
aKeyRef: otCryptoKeyRef,
aHash: *const otPlatCryptoSha256Hash,
aSignature: *const otPlatCryptoEcdsaSignature,
) -> otError;
}
extern "C" {
#[doc = " Perform PKCS#5 PBKDF2 using CMAC (AES-CMAC-PRF-128).\n\n @param[in] aPassword Password to use when generating key.\n @param[in] aPasswordLen Length of password.\n @param[in] aSalt Salt to use when generating key.\n @param[in] aSaltLen Length of salt.\n @param[in] aIterationCounter Iteration count.\n @param[in] aKeyLen Length of generated key in bytes.\n @param[out] aKey A pointer to the generated key.\n\n @retval OT_ERROR_NONE A new key-pair was generated successfully.\n @retval OT_ERROR_NO_BUFS Failed to allocate buffer for key generation.\n @retval OT_ERROR_NOT_CAPABLE Feature not supported.\n @retval OT_ERROR_FAILED Failed to generate key."]
pub fn otPlatCryptoPbkdf2GenerateKey(
aPassword: *const u8,
aPasswordLen: u16,
aSalt: *const u8,
aSaltLen: u16,
aIterationCounter: u32,
aKeyLen: u16,
aKey: *mut u8,
) -> otError;
}
#[doc = "< aMaxPHYPacketSize (IEEE 802.15.4-2006)"]
pub const OT_RADIO_FRAME_MAX_SIZE: _bindgen_ty_2 = 127;
#[doc = "< Minimal size of frame FCS + CONTROL"]
pub const OT_RADIO_FRAME_MIN_SIZE: _bindgen_ty_2 = 3;
#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
pub const OT_RADIO_SYMBOLS_PER_OCTET: _bindgen_ty_2 = 2;
#[doc = "< 2.4 GHz IEEE 802.15.4 (bits per second)"]
pub const OT_RADIO_BIT_RATE: _bindgen_ty_2 = 250000;
#[doc = "< Number of bits per octet"]
pub const OT_RADIO_BITS_PER_OCTET: _bindgen_ty_2 = 8;
#[doc = "< The O-QPSK PHY symbol rate when operating in the 780MHz, 915MHz, 2380MHz, 2450MHz"]
pub const OT_RADIO_SYMBOL_RATE: _bindgen_ty_2 = 62500;
#[doc = "< Symbol duration time in unit of microseconds"]
pub const OT_RADIO_SYMBOL_TIME: _bindgen_ty_2 = 16;
#[doc = "< Time for 10 symbols in unit of microseconds"]
pub const OT_RADIO_TEN_SYMBOLS_TIME: _bindgen_ty_2 = 160;
#[doc = "< LQI measurement not supported"]
pub const OT_RADIO_LQI_NONE: _bindgen_ty_2 = 0;
#[doc = "< Invalid or unknown RSSI value"]
pub const OT_RADIO_RSSI_INVALID: _bindgen_ty_2 = 127;
#[doc = "< Invalid or unknown power value"]
pub const OT_RADIO_POWER_INVALID: _bindgen_ty_2 = 127;
#[doc = " @defgroup radio-types Radio Types\n\n @brief\n This module includes the platform abstraction for a radio frame.\n\n @{\n"]
pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
pub const OT_RADIO_CHANNEL_PAGE_0: _bindgen_ty_3 = 0;
#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
pub const OT_RADIO_CHANNEL_PAGE_0_MASK: _bindgen_ty_3 = 1;
#[doc = "< 915 MHz IEEE 802.15.4-2006"]
pub const OT_RADIO_CHANNEL_PAGE_2: _bindgen_ty_3 = 2;
#[doc = "< 915 MHz IEEE 802.15.4-2006"]
pub const OT_RADIO_CHANNEL_PAGE_2_MASK: _bindgen_ty_3 = 4;
#[doc = " Defines the channel page.\n"]
pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
#[doc = "< 915 MHz IEEE 802.15.4-2006"]
pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MIN: _bindgen_ty_4 = 1;
#[doc = "< 915 MHz IEEE 802.15.4-2006"]
pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MAX: _bindgen_ty_4 = 10;
#[doc = "< 915 MHz IEEE 802.15.4-2006"]
pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MASK: _bindgen_ty_4 = 2046;
#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MIN: _bindgen_ty_4 = 11;
#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MAX: _bindgen_ty_4 = 26;
#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MASK: _bindgen_ty_4 = 134215680;
#[doc = " Defines the frequency band channel range.\n"]
pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
#[doc = " Represents radio capabilities.\n\n The value is a bit-field indicating the capabilities supported by the radio. See `OT_RADIO_CAPS_*` definitions.\n"]
pub type otRadioCaps = u16;
#[doc = "< Radio supports no capability."]
pub const OT_RADIO_CAPS_NONE: _bindgen_ty_5 = 0;
#[doc = "< Radio supports AckTime event."]
pub const OT_RADIO_CAPS_ACK_TIMEOUT: _bindgen_ty_5 = 1;
#[doc = "< Radio supports Energy Scans."]
pub const OT_RADIO_CAPS_ENERGY_SCAN: _bindgen_ty_5 = 2;
#[doc = "< Radio supports tx retry logic with collision avoidance (CSMA)."]
pub const OT_RADIO_CAPS_TRANSMIT_RETRIES: _bindgen_ty_5 = 4;
#[doc = "< Radio supports CSMA backoff for frame transmission (but no retry)."]
pub const OT_RADIO_CAPS_CSMA_BACKOFF: _bindgen_ty_5 = 8;
#[doc = "< Radio supports direct transition from sleep to TX with CSMA."]
pub const OT_RADIO_CAPS_SLEEP_TO_TX: _bindgen_ty_5 = 16;
#[doc = "< Radio supports tx security."]
pub const OT_RADIO_CAPS_TRANSMIT_SEC: _bindgen_ty_5 = 32;
#[doc = "< Radio supports tx at specific time."]
pub const OT_RADIO_CAPS_TRANSMIT_TIMING: _bindgen_ty_5 = 64;
#[doc = "< Radio supports rx at specific time."]
pub const OT_RADIO_CAPS_RECEIVE_TIMING: _bindgen_ty_5 = 128;
#[doc = "< Radio supports RxOnWhenIdle handling."]
pub const OT_RADIO_CAPS_RX_ON_WHEN_IDLE: _bindgen_ty_5 = 256;
#[doc = " Defines constants that are used to indicate different radio capabilities. See `otRadioCaps`.\n"]
pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
#[doc = " Represents the IEEE 802.15.4 PAN ID.\n"]
pub type otPanId = u16;
#[doc = " Represents the IEEE 802.15.4 Short Address.\n"]
pub type otShortAddress = u16;
#[doc = "< Size of IE header in bytes."]
pub const OT_IE_HEADER_SIZE: _bindgen_ty_6 = 2;
#[doc = "< Size of CSL IE content in bytes."]
pub const OT_CSL_IE_SIZE: _bindgen_ty_6 = 4;
#[doc = "< Max length for header IE in ACK."]
pub const OT_ACK_IE_MAX_SIZE: _bindgen_ty_6 = 16;
#[doc = "< Max length of Link Metrics data in Vendor-Specific IE."]
pub const OT_ENH_PROBING_IE_DATA_MAX_SIZE: _bindgen_ty_6 = 2;
#[doc = " Defines constants about size of header IE in ACK.\n"]
pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
#[doc = " @struct otExtAddress\n\n Represents the IEEE 802.15.4 Extended Address.\n"]
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otExtAddress {
#[doc = "< IEEE 802.15.4 Extended Address bytes"]
pub m8: [u8; 8usize],
}
#[doc = " @struct otMacKey\n\n Represents a MAC Key.\n"]
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otMacKey {
#[doc = "< MAC Key bytes."]
pub m8: [u8; 16usize],
}
#[doc = " Represents a MAC Key Ref used by PSA.\n"]
pub type otMacKeyRef = otCryptoKeyRef;
#[doc = " @struct otMacKeyMaterial\n\n Represents a MAC Key.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otMacKeyMaterial {
pub mKeyMaterial: otMacKeyMaterial__bindgen_ty_1,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union otMacKeyMaterial__bindgen_ty_1 {
#[doc = "< Reference to the key stored."]
pub mKeyRef: otMacKeyRef,
#[doc = "< Key stored as literal."]
pub mKey: otMacKey,
}
impl Default for otMacKeyMaterial__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for otMacKeyMaterial {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = "< Use Literal Keys."]
pub const OT_KEY_TYPE_LITERAL_KEY: otRadioKeyType = 0;
#[doc = "< Use Reference to Key."]
pub const OT_KEY_TYPE_KEY_REF: otRadioKeyType = 1;
#[doc = " Defines constants about key types.\n"]
pub type otRadioKeyType = ::std::os::raw::c_uint;
#[doc = " Represents the IEEE 802.15.4 Header IE (Information Element) related information of a radio frame."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otRadioIeInfo {
#[doc = "< The time offset to the Thread network time."]
pub mNetworkTimeOffset: i64,
#[doc = "< The Time IE offset from the start of PSDU."]
pub mTimeIeOffset: u8,
#[doc = "< The Time sync sequence."]
pub mTimeSyncSeq: u8,
}
#[doc = " Represents an IEEE 802.15.4 radio frame."]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otRadioFrame {
#[doc = "< The PSDU."]
pub mPsdu: *mut u8,
#[doc = "< Length of the PSDU."]
pub mLength: u16,
#[doc = "< Channel used to transmit/receive the frame."]
pub mChannel: u8,
#[doc = "< Radio link type - should be ignored by radio driver."]
pub mRadioType: u8,
pub mInfo: otRadioFrame__bindgen_ty_1,
}
#[doc = " The union of transmit and receive information for a radio frame."]
#[repr(C)]
#[derive(Copy, Clone)]
pub union otRadioFrame__bindgen_ty_1 {
pub mTxInfo: otRadioFrame__bindgen_ty_1__bindgen_ty_1,
pub mRxInfo: otRadioFrame__bindgen_ty_1__bindgen_ty_2,
}
#[doc = " Structure representing radio frame transmit information."]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
#[doc = "< The key material used for AES-CCM frame security."]
pub mAesKey: *const otMacKeyMaterial,
#[doc = "< The pointer to the Header IE(s) related information."]
pub mIeInfo: *mut otRadioIeInfo,
#[doc = " The base time in microseconds for scheduled transmissions\n relative to the local radio clock, see `otPlatRadioGetNow` and\n `mTxDelay`."]
pub mTxDelayBaseTime: u32,
#[doc = " The delay time in microseconds for this transmission referenced\n to `mTxDelayBaseTime`.\n\n Note: `mTxDelayBaseTime` + `mTxDelay` SHALL point to the point in\n time when the end of the SFD will be present at the local\n antenna, relative to the local radio clock."]
pub mTxDelay: u32,
#[doc = "< Maximum number of backoffs attempts before declaring CCA failure."]
pub mMaxCsmaBackoffs: u8,
#[doc = "< Maximum number of retries allowed after a transmission failure."]
pub mMaxFrameRetries: u8,
#[doc = " The RX channel after frame TX is done (after all frame retries - ack received, or timeout, or abort).\n\n Radio platforms can choose to fully ignore this. OT stack will make sure to call `otPlatRadioReceive()`\n with the desired RX channel after a frame TX is done and signaled in `otPlatRadioTxDone()` callback.\n Radio platforms that don't provide `OT_RADIO_CAPS_TRANSMIT_RETRIES` must always ignore this.\n\n This is intended for situations where there may be delay in interactions between OT stack and radio, as\n an example this is used in RCP/host architecture to make sure RCP switches to PAN channel more quickly.\n In particular, this can help with CSL tx to a sleepy child, where the child may use a different channel\n for CSL than the PAN channel. After frame tx, we want the radio/RCP to go back to the PAN channel\n quickly to ensure that parent does not miss tx from child afterwards, e.g., child responding to the\n earlier CSL transmitted frame from parent using PAN channel while radio still staying on CSL channel.\n\n The switch to the RX channel MUST happen after the frame TX is fully done, i.e., after all retries and\n when ack is received (when \"Ack Request\" flag is set on the TX frame) or ack timeout. Note that ack is\n expected on the same channel that frame is sent on.\n"]
pub mRxChannelAfterTxDone: u8,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: u32,
}
impl Default for otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
#[inline]
pub fn mIsHeaderUpdated(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsHeaderUpdated(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn mIsARetx(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsARetx(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn mCsmaCaEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mCsmaCaEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn mCslPresent(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_mCslPresent(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn mIsSecurityProcessed(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsSecurityProcessed(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mIsHeaderUpdated: bool,
mIsARetx: bool,
mCsmaCaEnabled: bool,
mCslPresent: bool,
mIsSecurityProcessed: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mIsHeaderUpdated: u8 = unsafe { ::std::mem::transmute(mIsHeaderUpdated) };
mIsHeaderUpdated as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let mIsARetx: u8 = unsafe { ::std::mem::transmute(mIsARetx) };
mIsARetx as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mCsmaCaEnabled: u8 = unsafe { ::std::mem::transmute(mCsmaCaEnabled) };
mCsmaCaEnabled as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let mCslPresent: u8 = unsafe { ::std::mem::transmute(mCslPresent) };
mCslPresent as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let mIsSecurityProcessed: u8 = unsafe { ::std::mem::transmute(mIsSecurityProcessed) };
mIsSecurityProcessed as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " Structure representing radio frame receive information."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otRadioFrame__bindgen_ty_1__bindgen_ty_2 {
#[doc = " The time of the local radio clock in microseconds when the end of\n the SFD was present at the local antenna."]
pub mTimestamp: u64,
#[doc = "< ACK security frame counter (applicable when `mAckedWithSecEnhAck` is set)."]
pub mAckFrameCounter: u32,
#[doc = "< ACK security key index (applicable when `mAckedWithSecEnhAck` is set)."]
pub mAckKeyId: u8,
#[doc = "< Received signal strength indicator in dBm for received frames."]
pub mRssi: i8,
#[doc = "< Link Quality Indicator for received frames."]
pub mLqi: u8,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
}
impl otRadioFrame__bindgen_ty_1__bindgen_ty_2 {
#[inline]
pub fn mAckedWithFramePending(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mAckedWithFramePending(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn mAckedWithSecEnhAck(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_mAckedWithSecEnhAck(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mAckedWithFramePending: bool,
mAckedWithSecEnhAck: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mAckedWithFramePending: u8 =
unsafe { ::std::mem::transmute(mAckedWithFramePending) };
mAckedWithFramePending as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let mAckedWithSecEnhAck: u8 = unsafe { ::std::mem::transmute(mAckedWithSecEnhAck) };
mAckedWithSecEnhAck as u64
});
__bindgen_bitfield_unit
}
}
impl Default for otRadioFrame__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for otRadioFrame {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const OT_RADIO_STATE_DISABLED: otRadioState = 0;
pub const OT_RADIO_STATE_SLEEP: otRadioState = 1;
pub const OT_RADIO_STATE_RECEIVE: otRadioState = 2;
pub const OT_RADIO_STATE_TRANSMIT: otRadioState = 3;
pub const OT_RADIO_STATE_INVALID: otRadioState = 255;
#[doc = " Represents the state of a radio.\n Initially, a radio is in the Disabled state."]
pub type otRadioState = ::std::os::raw::c_uint;
#[doc = " Represents radio coexistence metrics."]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otRadioCoexMetrics {
#[doc = "< Number of grant glitches."]
pub mNumGrantGlitch: u32,
#[doc = "< Number of tx requests."]
pub mNumTxRequest: u32,
#[doc = "< Number of tx requests while grant was active."]
pub mNumTxGrantImmediate: u32,
#[doc = "< Number of tx requests while grant was inactive."]
pub mNumTxGrantWait: u32,
#[doc = "< Number of tx requests while grant was inactive that were ultimately granted."]
pub mNumTxGrantWaitActivated: u32,
#[doc = "< Number of tx requests while grant was inactive that timed out."]
pub mNumTxGrantWaitTimeout: u32,
#[doc = "< Number of tx that were in progress when grant was deactivated."]
pub mNumTxGrantDeactivatedDuringRequest: u32,
#[doc = "< Number of tx requests that were not granted within 50us."]
pub mNumTxDelayedGrant: u32,
#[doc = "< Average time in usec from tx request to grant."]
pub mAvgTxRequestToGrantTime: u32,
#[doc = "< Number of rx requests."]
pub mNumRxRequest: u32,
#[doc = "< Number of rx requests while grant was active."]
pub mNumRxGrantImmediate: u32,
#[doc = "< Number of rx requests while grant was inactive."]
pub mNumRxGrantWait: u32,
#[doc = "< Number of rx requests while grant was inactive that were ultimately granted."]
pub mNumRxGrantWaitActivated: u32,
#[doc = "< Number of rx requests while grant was inactive that timed out."]
pub mNumRxGrantWaitTimeout: u32,
#[doc = "< Number of rx that were in progress when grant was deactivated."]
pub mNumRxGrantDeactivatedDuringRequest: u32,
#[doc = "< Number of rx requests that were not granted within 50us."]
pub mNumRxDelayedGrant: u32,
#[doc = "< Average time in usec from rx request to grant."]
pub mAvgRxRequestToGrantTime: u32,
#[doc = "< Number of rx requests that completed without receiving grant."]
pub mNumRxGrantNone: u32,
#[doc = "< Stats collection stopped due to saturation."]
pub mStopped: bool,
}
#[doc = " Represents what metrics are specified to query.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otLinkMetrics {
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
}
impl otLinkMetrics {
#[inline]
pub fn mPduCount(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mPduCount(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn mLqi(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_mLqi(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn mLinkMargin(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mLinkMargin(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn mRssi(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_mRssi(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn mReserved(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_mReserved(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mPduCount: bool,
mLqi: bool,
mLinkMargin: bool,
mRssi: bool,
mReserved: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mPduCount: u8 = unsafe { ::std::mem::transmute(mPduCount) };
mPduCount as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let mLqi: u8 = unsafe { ::std::mem::transmute(mLqi) };
mLqi as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mLinkMargin: u8 = unsafe { ::std::mem::transmute(mLinkMargin) };
mLinkMargin as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let mRssi: u8 = unsafe { ::std::mem::transmute(mRssi) };
mRssi as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let mReserved: u8 = unsafe { ::std::mem::transmute(mReserved) };
mReserved as u64
});
__bindgen_bitfield_unit
}
}
extern "C" {
#[doc = " Get the radio capabilities.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The radio capability bit vector (see `OT_RADIO_CAP_*` definitions).\n"]
pub fn otPlatRadioGetCaps(aInstance: *mut otInstance) -> otRadioCaps;
}
extern "C" {
#[doc = " Get the radio version string.\n\n This is an optional radio driver platform function. If not provided by platform radio driver, OpenThread uses\n the OpenThread version instead (@sa otGetVersionString()).\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns A pointer to the OpenThread radio version.\n"]
pub fn otPlatRadioGetVersionString(aInstance: *mut otInstance)
-> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Get the radio receive sensitivity value.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The radio receive sensitivity value in dBm.\n"]
pub fn otPlatRadioGetReceiveSensitivity(aInstance: *mut otInstance) -> i8;
}
extern "C" {
#[doc = " Gets the factory-assigned IEEE EUI-64 for this interface.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[out] aIeeeEui64 A pointer to the factory-assigned IEEE EUI-64.\n"]
pub fn otPlatRadioGetIeeeEui64(aInstance: *mut otInstance, aIeeeEui64: *mut u8);
}
extern "C" {
#[doc = " Set the PAN ID for address filtering.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aPanId The IEEE 802.15.4 PAN ID.\n"]
pub fn otPlatRadioSetPanId(aInstance: *mut otInstance, aPanId: otPanId);
}
extern "C" {
#[doc = " Set the Extended Address for address filtering.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aExtAddress A pointer to the IEEE 802.15.4 Extended Address stored in little-endian byte order.\n\n"]
pub fn otPlatRadioSetExtendedAddress(
aInstance: *mut otInstance,
aExtAddress: *const otExtAddress,
);
}
extern "C" {
#[doc = " Set the Short Address for address filtering.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aShortAddress The IEEE 802.15.4 Short Address.\n"]
pub fn otPlatRadioSetShortAddress(aInstance: *mut otInstance, aShortAddress: otShortAddress);
}
extern "C" {
#[doc = " Get the radio's transmit power in dBm.\n\n @note The transmit power returned will be no larger than the power specified in the max power table for\n the current channel.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[out] aPower The transmit power in dBm.\n\n @retval OT_ERROR_NONE Successfully retrieved the transmit power.\n @retval OT_ERROR_INVALID_ARGS @p aPower was NULL.\n @retval OT_ERROR_NOT_IMPLEMENTED Transmit power configuration via dBm is not implemented.\n"]
pub fn otPlatRadioGetTransmitPower(aInstance: *mut otInstance, aPower: *mut i8) -> otError;
}
extern "C" {
#[doc = " Set the radio's transmit power in dBm.\n\n @note The real transmit power will be no larger than the power specified in the max power table for\n the current channel.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aPower The transmit power in dBm.\n\n @retval OT_ERROR_NONE Successfully set the transmit power.\n @retval OT_ERROR_NOT_IMPLEMENTED Transmit power configuration via dBm is not implemented.\n"]
pub fn otPlatRadioSetTransmitPower(aInstance: *mut otInstance, aPower: i8) -> otError;
}
extern "C" {
#[doc = " Get the radio's CCA ED threshold in dBm measured at antenna connector per IEEE 802.15.4 - 2015 section 10.1.4.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[out] aThreshold The CCA ED threshold in dBm.\n\n @retval OT_ERROR_NONE Successfully retrieved the CCA ED threshold.\n @retval OT_ERROR_INVALID_ARGS @p aThreshold was NULL.\n @retval OT_ERROR_NOT_IMPLEMENTED CCA ED threshold configuration via dBm is not implemented.\n"]
pub fn otPlatRadioGetCcaEnergyDetectThreshold(
aInstance: *mut otInstance,
aThreshold: *mut i8,
) -> otError;
}
extern "C" {
#[doc = " Set the radio's CCA ED threshold in dBm measured at antenna connector per IEEE 802.15.4 - 2015 section 10.1.4.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aThreshold The CCA ED threshold in dBm.\n\n @retval OT_ERROR_NONE Successfully set the transmit power.\n @retval OT_ERROR_INVALID_ARGS Given threshold is out of range.\n @retval OT_ERROR_NOT_IMPLEMENTED CCA ED threshold configuration via dBm is not implemented.\n"]
pub fn otPlatRadioSetCcaEnergyDetectThreshold(
aInstance: *mut otInstance,
aThreshold: i8,
) -> otError;
}
extern "C" {
#[doc = " Gets the external FEM's Rx LNA gain in dBm.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[out] aGain The external FEM's Rx LNA gain in dBm.\n\n @retval OT_ERROR_NONE Successfully retrieved the external FEM's LNA gain.\n @retval OT_ERROR_INVALID_ARGS @p aGain was NULL.\n @retval OT_ERROR_NOT_IMPLEMENTED External FEM's LNA setting is not implemented.\n"]
pub fn otPlatRadioGetFemLnaGain(aInstance: *mut otInstance, aGain: *mut i8) -> otError;
}
extern "C" {
#[doc = " Sets the external FEM's Rx LNA gain in dBm.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aGain The external FEM's Rx LNA gain in dBm.\n\n @retval OT_ERROR_NONE Successfully set the external FEM's LNA gain.\n @retval OT_ERROR_NOT_IMPLEMENTED External FEM's LNA gain setting is not implemented.\n"]
pub fn otPlatRadioSetFemLnaGain(aInstance: *mut otInstance, aGain: i8) -> otError;
}
extern "C" {
#[doc = " Get the status of promiscuous mode.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @retval TRUE Promiscuous mode is enabled.\n @retval FALSE Promiscuous mode is disabled.\n"]
pub fn otPlatRadioGetPromiscuous(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Enable or disable promiscuous mode.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aEnable TRUE to enable or FALSE to disable promiscuous mode.\n"]
pub fn otPlatRadioSetPromiscuous(aInstance: *mut otInstance, aEnable: bool);
}
extern "C" {
#[doc = " Sets the rx-on-when-idle state to the radio platform.\n\n There are a few situations that the radio can enter sleep state if the device is in rx-off-when-idle state but\n it's hard and costly for the SubMac to identify these situations and instruct the radio to enter sleep:\n\n - Finalization of a regular frame reception task, provided that:\n - The frame is received without errors and passes the filtering and it's not an spurious ACK.\n - ACK is not requested or transmission of ACK is not possible due to internal conditions.\n - Finalization of a frame transmission or transmission of an ACK frame, when ACK is not requested in the transmitted\n frame.\n - Finalization of the reception operation of a requested ACK due to:\n - ACK timeout expiration.\n - Reception of an invalid ACK or not an ACK frame.\n - Reception of the proper ACK, unless the transmitted frame was a Data Request Command and the frame pending bit\n on the received ACK is set to true. In this case the radio platform implementation SHOULD keep the receiver on\n until a determined timeout which triggers an idle period start.`OPENTHREAD_CONFIG_MAC_DATA_POLL_TIMEOUT` can be\n taken as a reference for this.\n - Finalization of a stand alone CCA task.\n - Finalization of a CCA operation with busy result during CSMA/CA procedure.\n - Finalization of an Energy Detection task.\n - Finalization of a radio reception window scheduled with `otPlatRadioReceiveAt`.\n\n If a platform supports `OT_RADIO_CAPS_RX_ON_WHEN_IDLE` it must also support `OT_RADIO_CAPS_CSMA_BACKOFF` and handle\n idle periods after CCA as described above.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aEnable TRUE to keep radio in Receive state, FALSE to put to Sleep state during idle periods.\n"]
pub fn otPlatRadioSetRxOnWhenIdle(aInstance: *mut otInstance, aEnable: bool);
}
extern "C" {
#[doc = " Update MAC keys and key index\n\n Is used when radio provides OT_RADIO_CAPS_TRANSMIT_SEC capability.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aKeyIdMode The key ID mode.\n @param[in] aKeyId Current MAC key index.\n @param[in] aPrevKey A pointer to the previous MAC key.\n @param[in] aCurrKey A pointer to the current MAC key.\n @param[in] aNextKey A pointer to the next MAC key.\n @param[in] aKeyType Key Type used.\n"]
pub fn otPlatRadioSetMacKey(
aInstance: *mut otInstance,
aKeyIdMode: u8,
aKeyId: u8,
aPrevKey: *const otMacKeyMaterial,
aCurrKey: *const otMacKeyMaterial,
aNextKey: *const otMacKeyMaterial,
aKeyType: otRadioKeyType,
);
}
extern "C" {
#[doc = " Sets the current MAC frame counter value.\n\n Is used when radio provides `OT_RADIO_CAPS_TRANSMIT_SEC` capability.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMacFrameCounter The MAC frame counter value.\n"]
pub fn otPlatRadioSetMacFrameCounter(aInstance: *mut otInstance, aMacFrameCounter: u32);
}
extern "C" {
#[doc = " Sets the current MAC frame counter value only if the new given value is larger than the current value.\n\n Is used when radio provides `OT_RADIO_CAPS_TRANSMIT_SEC` capability.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMacFrameCounter The MAC frame counter value.\n"]
pub fn otPlatRadioSetMacFrameCounterIfLarger(aInstance: *mut otInstance, aMacFrameCounter: u32);
}
extern "C" {
#[doc = " Get the current time in microseconds referenced to a continuous monotonic\n local radio clock (64 bits width).\n\n The radio clock SHALL NOT wrap during the device's uptime. Implementations\n SHALL therefore identify and compensate for internal counter overflows. The\n clock does not have a defined epoch and it SHALL NOT introduce any continuous\n or discontinuous adjustments (e.g. leap seconds). Implementations SHALL\n compensate for any sleep times of the device.\n\n Implementations MAY choose to discipline the radio clock and compensate for\n sleep times by any means (e.g. by combining a high precision/low power RTC\n with a high resolution counter) as long as the exposed combined clock\n provides continuous monotonic microsecond resolution ticks within the\n accuracy limits announced by @ref otPlatRadioGetCslAccuracy.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current time in microseconds. UINT64_MAX when platform does not\n support or radio time is not ready.\n"]
pub fn otPlatRadioGetNow(aInstance: *mut otInstance) -> u64;
}
extern "C" {
#[doc = " Get the bus speed in bits/second between the host and the radio chip.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The bus speed in bits/second between the host and the radio chip.\n Return 0 when the MAC and above layer and Radio layer resides on the same chip.\n"]
pub fn otPlatRadioGetBusSpeed(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Get current state of the radio.\n\n Is not required by OpenThread. It may be used for debugging and/or application-specific purposes.\n\n @note This function may be not implemented. It does not affect OpenThread.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @return Current state of the radio.\n"]
pub fn otPlatRadioGetState(aInstance: *mut otInstance) -> otRadioState;
}
extern "C" {
#[doc = " Enable the radio.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @retval OT_ERROR_NONE Successfully enabled.\n @retval OT_ERROR_FAILED The radio could not be enabled.\n"]
pub fn otPlatRadioEnable(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Disable the radio.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @retval OT_ERROR_NONE Successfully transitioned to Disabled.\n @retval OT_ERROR_INVALID_STATE The radio was not in sleep state.\n"]
pub fn otPlatRadioDisable(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Check whether radio is enabled or not.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns TRUE if the radio is enabled, FALSE otherwise.\n"]
pub fn otPlatRadioIsEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Transition the radio from Receive to Sleep (turn off the radio).\n\n @param[in] aInstance The OpenThread instance structure.\n\n @retval OT_ERROR_NONE Successfully transitioned to Sleep.\n @retval OT_ERROR_BUSY The radio was transmitting.\n @retval OT_ERROR_INVALID_STATE The radio was disabled.\n"]
pub fn otPlatRadioSleep(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Transition the radio from Sleep to Receive (turn on the radio).\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aChannel The channel to use for receiving.\n\n @retval OT_ERROR_NONE Successfully transitioned to Receive.\n @retval OT_ERROR_INVALID_STATE The radio was disabled or transmitting.\n"]
pub fn otPlatRadioReceive(aInstance: *mut otInstance, aChannel: u8) -> otError;
}
extern "C" {
#[doc = " Schedule a radio reception window at a specific time and duration.\n\n @param[in] aChannel The radio channel on which to receive.\n @param[in] aStart The receive window start time relative to the local\n radio clock, see `otPlatRadioGetNow`. The radio\n receiver SHALL be on and ready to receive the first\n symbol of a frame's SHR at the window start time.\n @param[in] aDuration The receive window duration, in microseconds, as\n measured by the local radio clock. The radio SHOULD be\n turned off (or switched to TX mode if an ACK frame\n needs to be sent) after that duration unless it is\n still actively receiving a frame. In the latter case\n the radio SHALL be kept in reception mode until frame\n reception has either succeeded or failed.\n\n @retval OT_ERROR_NONE Successfully scheduled receive window.\n @retval OT_ERROR_FAILED The receive window could not be scheduled."]
pub fn otPlatRadioReceiveAt(
aInstance: *mut otInstance,
aChannel: u8,
aStart: u32,
aDuration: u32,
) -> otError;
}
extern "C" {
#[doc = " The radio driver calls this method to notify OpenThread of a received frame.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aFrame A pointer to the received frame or NULL if the receive operation failed.\n @param[in] aError OT_ERROR_NONE when successfully received a frame,\n OT_ERROR_ABORT when reception was aborted and a frame was not received,\n OT_ERROR_NO_BUFS when a frame could not be received due to lack of rx buffer space.\n"]
pub fn otPlatRadioReceiveDone(
aInstance: *mut otInstance,
aFrame: *mut otRadioFrame,
aError: otError,
);
}
extern "C" {
#[doc = " The radio driver calls this method to notify OpenThread diagnostics module of a received frame.\n\n Is used when diagnostics is enabled.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aFrame A pointer to the received frame or NULL if the receive operation failed.\n @param[in] aError OT_ERROR_NONE when successfully received a frame,\n OT_ERROR_ABORT when reception was aborted and a frame was not received,\n OT_ERROR_NO_BUFS when a frame could not be received due to lack of rx buffer space.\n"]
pub fn otPlatDiagRadioReceiveDone(
aInstance: *mut otInstance,
aFrame: *mut otRadioFrame,
aError: otError,
);
}
extern "C" {
#[doc = " Get the radio transmit frame buffer.\n\n OpenThread forms the IEEE 802.15.4 frame in this buffer then calls `otPlatRadioTransmit()` to request transmission.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns A pointer to the transmit frame buffer.\n"]
pub fn otPlatRadioGetTransmitBuffer(aInstance: *mut otInstance) -> *mut otRadioFrame;
}
extern "C" {
#[doc = " Begin the transmit sequence on the radio.\n\n The caller must form the IEEE 802.15.4 frame in the buffer provided by `otPlatRadioGetTransmitBuffer()` before\n requesting transmission. The channel and transmit power are also included in the otRadioFrame structure.\n\n The transmit sequence consists of:\n 1. Transitioning the radio to Transmit from one of the following states:\n - Receive if RX is on when the device is idle or OT_RADIO_CAPS_SLEEP_TO_TX is not supported\n - Sleep if RX is off when the device is idle and OT_RADIO_CAPS_SLEEP_TO_TX is supported.\n 2. Transmits the psdu on the given channel and at the given transmit power.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aFrame A pointer to the frame to be transmitted.\n\n @retval OT_ERROR_NONE Successfully transitioned to Transmit.\n @retval OT_ERROR_INVALID_STATE The radio was not in the Receive state.\n"]
pub fn otPlatRadioTransmit(aInstance: *mut otInstance, aFrame: *mut otRadioFrame) -> otError;
}
extern "C" {
#[doc = " The radio driver calls this method to notify OpenThread that the transmission has started.\n\n @note This function should be called by the same thread that executes all of the other OpenThread code. It should\n not be called by ISR or any other task.\n\n @param[in] aInstance A pointer to the OpenThread instance structure.\n @param[in] aFrame A pointer to the frame that is being transmitted.\n"]
pub fn otPlatRadioTxStarted(aInstance: *mut otInstance, aFrame: *mut otRadioFrame);
}
extern "C" {
#[doc = " The radio driver calls this function to notify OpenThread that the transmit operation has completed,\n providing both the transmitted frame and, if applicable, the received ack frame.\n\n When radio provides `OT_RADIO_CAPS_TRANSMIT_SEC` capability, radio platform layer updates @p aFrame\n with the security frame counter and key index values maintained by the radio.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aFrame A pointer to the frame that was transmitted.\n @param[in] aAckFrame A pointer to the ACK frame, NULL if no ACK was received.\n @param[in] aError OT_ERROR_NONE when the frame was transmitted,\n OT_ERROR_NO_ACK when the frame was transmitted but no ACK was received,\n OT_ERROR_CHANNEL_ACCESS_FAILURE tx could not take place due to activity on the channel,\n OT_ERROR_ABORT when transmission was aborted for other reasons.\n"]
pub fn otPlatRadioTxDone(
aInstance: *mut otInstance,
aFrame: *mut otRadioFrame,
aAckFrame: *mut otRadioFrame,
aError: otError,
);
}
extern "C" {
#[doc = " The radio driver calls this method to notify OpenThread diagnostics module that the transmission has completed.\n\n Is used when diagnostics is enabled.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aFrame A pointer to the frame that was transmitted.\n @param[in] aError OT_ERROR_NONE when the frame was transmitted,\n OT_ERROR_CHANNEL_ACCESS_FAILURE tx could not take place due to activity on the channel,\n OT_ERROR_ABORT when transmission was aborted for other reasons.\n"]
pub fn otPlatDiagRadioTransmitDone(
aInstance: *mut otInstance,
aFrame: *mut otRadioFrame,
aError: otError,
);
}
extern "C" {
#[doc = " Get the most recent RSSI measurement.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The RSSI in dBm when it is valid. 127 when RSSI is invalid.\n"]
pub fn otPlatRadioGetRssi(aInstance: *mut otInstance) -> i8;
}
extern "C" {
#[doc = " Begin the energy scan sequence on the radio.\n\n Is used when radio provides OT_RADIO_CAPS_ENERGY_SCAN capability.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aScanChannel The channel to perform the energy scan on.\n @param[in] aScanDuration The duration, in milliseconds, for the channel to be scanned.\n\n @retval OT_ERROR_NONE Successfully started scanning the channel.\n @retval OT_ERROR_BUSY The radio is performing energy scanning.\n @retval OT_ERROR_NOT_IMPLEMENTED The radio doesn't support energy scanning.\n"]
pub fn otPlatRadioEnergyScan(
aInstance: *mut otInstance,
aScanChannel: u8,
aScanDuration: u16,
) -> otError;
}
extern "C" {
#[doc = " The radio driver calls this method to notify OpenThread that the energy scan is complete.\n\n Is used when radio provides OT_RADIO_CAPS_ENERGY_SCAN capability.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aEnergyScanMaxRssi The maximum RSSI encountered on the scanned channel.\n"]
pub fn otPlatRadioEnergyScanDone(aInstance: *mut otInstance, aEnergyScanMaxRssi: i8);
}
extern "C" {
#[doc = " Enable/Disable source address match feature.\n\n The source address match feature controls how the radio layer decides the \"frame pending\" bit for acks sent in\n response to data request commands from children.\n\n If disabled, the radio layer must set the \"frame pending\" on all acks to data request commands.\n\n If enabled, the radio layer uses the source address match table to determine whether to set or clear the \"frame\n pending\" bit in an ack to a data request command.\n\n The source address match table provides the list of children for which there is a pending frame. Either a short\n address or an extended/long address can be added to the source address match table.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aEnable Enable/disable source address match feature.\n"]
pub fn otPlatRadioEnableSrcMatch(aInstance: *mut otInstance, aEnable: bool);
}
extern "C" {
#[doc = " Add a short address to the source address match table.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aShortAddress The short address to be added.\n\n @retval OT_ERROR_NONE Successfully added short address to the source match table.\n @retval OT_ERROR_NO_BUFS No available entry in the source match table.\n"]
pub fn otPlatRadioAddSrcMatchShortEntry(
aInstance: *mut otInstance,
aShortAddress: otShortAddress,
) -> otError;
}
extern "C" {
#[doc = " Add an extended address to the source address match table.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aExtAddress The extended address to be added stored in little-endian byte order.\n\n @retval OT_ERROR_NONE Successfully added extended address to the source match table.\n @retval OT_ERROR_NO_BUFS No available entry in the source match table.\n"]
pub fn otPlatRadioAddSrcMatchExtEntry(
aInstance: *mut otInstance,
aExtAddress: *const otExtAddress,
) -> otError;
}
extern "C" {
#[doc = " Remove a short address from the source address match table.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aShortAddress The short address to be removed.\n\n @retval OT_ERROR_NONE Successfully removed short address from the source match table.\n @retval OT_ERROR_NO_ADDRESS The short address is not in source address match table.\n"]
pub fn otPlatRadioClearSrcMatchShortEntry(
aInstance: *mut otInstance,
aShortAddress: otShortAddress,
) -> otError;
}
extern "C" {
#[doc = " Remove an extended address from the source address match table.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aExtAddress The extended address to be removed stored in little-endian byte order.\n\n @retval OT_ERROR_NONE Successfully removed the extended address from the source match table.\n @retval OT_ERROR_NO_ADDRESS The extended address is not in source address match table.\n"]
pub fn otPlatRadioClearSrcMatchExtEntry(
aInstance: *mut otInstance,
aExtAddress: *const otExtAddress,
) -> otError;
}
extern "C" {
#[doc = " Clear all short addresses from the source address match table.\n\n @param[in] aInstance The OpenThread instance structure.\n"]
pub fn otPlatRadioClearSrcMatchShortEntries(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Clear all the extended/long addresses from source address match table.\n\n @param[in] aInstance The OpenThread instance structure.\n"]
pub fn otPlatRadioClearSrcMatchExtEntries(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Get the radio supported channel mask that the device is allowed to be on.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The radio supported channel mask.\n"]
pub fn otPlatRadioGetSupportedChannelMask(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Gets the radio preferred channel mask that the device prefers to form on.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The radio preferred channel mask.\n"]
pub fn otPlatRadioGetPreferredChannelMask(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Enable the radio coex.\n\n Is used when feature OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE is enabled.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aEnabled TRUE to enable the radio coex, FALSE otherwise.\n\n @retval OT_ERROR_NONE Successfully enabled.\n @retval OT_ERROR_FAILED The radio coex could not be enabled.\n"]
pub fn otPlatRadioSetCoexEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
}
extern "C" {
#[doc = " Check whether radio coex is enabled or not.\n\n Is used when feature OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE is enabled.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns TRUE if the radio coex is enabled, FALSE otherwise.\n"]
pub fn otPlatRadioIsCoexEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Get the radio coexistence metrics.\n\n Is used when feature OPENTHREAD_CONFIG_PLATFORM_RADIO_COEX_ENABLE is enabled.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[out] aCoexMetrics A pointer to the coexistence metrics structure.\n\n @retval OT_ERROR_NONE Successfully retrieved the coex metrics.\n @retval OT_ERROR_INVALID_ARGS @p aCoexMetrics was NULL."]
pub fn otPlatRadioGetCoexMetrics(
aInstance: *mut otInstance,
aCoexMetrics: *mut otRadioCoexMetrics,
) -> otError;
}
extern "C" {
#[doc = " Enable or disable CSL receiver.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aCslPeriod CSL period, 0 for disabling CSL. CSL period is in unit of 10 symbols.\n @param[in] aShortAddr The short source address of CSL receiver's peer.\n @param[in] aExtAddr The extended source address of CSL receiver's peer.\n\n @note Platforms should use CSL peer addresses to include CSL IE when generating enhanced acks.\n\n @retval OT_ERROR_NOT_IMPLEMENTED Radio driver doesn't support CSL.\n @retval OT_ERROR_FAILED Other platform specific errors.\n @retval OT_ERROR_NONE Successfully enabled or disabled CSL.\n"]
pub fn otPlatRadioEnableCsl(
aInstance: *mut otInstance,
aCslPeriod: u32,
aShortAddr: otShortAddress,
aExtAddr: *const otExtAddress,
) -> otError;
}
extern "C" {
#[doc = " Reset CSL receiver in the platform.\n\n @note Defaults to `otPlatRadioEnableCsl(aInstance,0, Mac::kShortAddrInvalid, nullptr);`\n\n @param[in] aInstance The OpenThread instance structure.\n\n @retval OT_ERROR_NOT_IMPLEMENTED Radio driver doesn't support CSL.\n @retval OT_ERROR_FAILED Other platform specific errors.\n @retval OT_ERROR_NONE Successfully disabled CSL.\n"]
pub fn otPlatRadioResetCsl(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Update CSL sample time in radio driver.\n\n Sample time is stored in radio driver as a copy to calculate phase when\n sending ACK with CSL IE. The CSL sample (window) of the CSL receiver extends\n before and after the sample time. The CSL sample time marks a timestamp in\n the CSL sample window when a frame should be received in \"ideal conditions\"\n if there would be no inaccuracy/clock-drift.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aCslSampleTime The next sample time, in microseconds. It is\n the time when the first symbol of the MHR of\n the frame is expected."]
pub fn otPlatRadioUpdateCslSampleTime(aInstance: *mut otInstance, aCslSampleTime: u32);
}
extern "C" {
#[doc = " Get the current estimated worst case accuracy (maximum ± deviation from the\n nominal frequency) of the local radio clock in units of PPM. This is the\n clock used to schedule CSL operations.\n\n @note Implementations MAY estimate this value based on current operating\n conditions (e.g. temperature).\n\n In case the implementation does not estimate the current value but returns a\n fixed value, this value MUST be the worst-case accuracy over all possible\n foreseen operating conditions (temperature, pressure, etc) of the\n implementation.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current CSL rx/tx scheduling drift, in PPM.\n"]
pub fn otPlatRadioGetCslAccuracy(aInstance: *mut otInstance) -> u8;
}
extern "C" {
#[doc = " The fixed uncertainty (i.e. random jitter) of the arrival time of CSL\n transmissions received by this device in units of 10 microseconds.\n\n This designates the worst case constant positive or negative deviation of\n the actual arrival time of a transmission from the transmission time\n calculated relative to the local radio clock independent of elapsed time. In\n addition to uncertainty accumulated over elapsed time, the CSL channel sample\n (\"RX window\") must be extended by twice this deviation such that an actual\n transmission is guaranteed to be detected by the local receiver in the\n presence of random arrival time jitter.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The CSL Uncertainty in units of 10 us.\n"]
pub fn otPlatRadioGetCslUncertainty(aInstance: *mut otInstance) -> u8;
}
extern "C" {
#[doc = " Set the max transmit power for a specific channel.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aChannel The radio channel.\n @param[in] aMaxPower The max power in dBm, passing OT_RADIO_RSSI_INVALID will disable this channel.\n\n @retval OT_ERROR_NOT_IMPLEMENTED The feature is not implemented\n @retval OT_ERROR_INVALID_ARGS The specified channel is not valid.\n @retval OT_ERROR_FAILED Other platform specific errors.\n @retval OT_ERROR_NONE Successfully set max transmit power.\n"]
pub fn otPlatRadioSetChannelMaxTransmitPower(
aInstance: *mut otInstance,
aChannel: u8,
aMaxPower: i8,
) -> otError;
}
extern "C" {
#[doc = " Set the region code.\n\n The radio region format is the 2-bytes ascii representation of the\n ISO 3166 alpha-2 code.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aRegionCode The radio region code. The `aRegionCode >> 8` is first ascii char\n and the `aRegionCode & 0xff` is the second ascii char.\n\n @retval OT_ERROR_FAILED Other platform specific errors.\n @retval OT_ERROR_NONE Successfully set region code.\n @retval OT_ERROR_NOT_IMPLEMENTED The feature is not implemented.\n"]
pub fn otPlatRadioSetRegion(aInstance: *mut otInstance, aRegionCode: u16) -> otError;
}
extern "C" {
#[doc = " Get the region code.\n\n The radio region format is the 2-bytes ascii representation of the\n ISO 3166 alpha-2 code.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[out] aRegionCode The radio region.\n\n @retval OT_ERROR_INVALID_ARGS @p aRegionCode is nullptr.\n @retval OT_ERROR_FAILED Other platform specific errors.\n @retval OT_ERROR_NONE Successfully got region code.\n @retval OT_ERROR_NOT_IMPLEMENTED The feature is not implemented.\n"]
pub fn otPlatRadioGetRegion(aInstance: *mut otInstance, aRegionCode: *mut u16) -> otError;
}
extern "C" {
#[doc = " Enable/disable or update Enhanced-ACK Based Probing in radio for a specific Initiator.\n\n After Enhanced-ACK Based Probing is configured by a specific Probing Initiator, the Enhanced-ACK sent to that\n node should include Vendor-Specific IE containing Link Metrics data. This method informs the radio to start/stop to\n collect Link Metrics data and include Vendor-Specific IE that containing the data in Enhanced-ACK sent to that\n Probing Initiator.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aLinkMetrics This parameter specifies what metrics to query. Per spec 4.11.3.4.4.6, at most 2 metrics\n can be specified. The probing would be disabled if @p `aLinkMetrics` is bitwise 0.\n @param[in] aShortAddress The short address of the Probing Initiator.\n @param[in] aExtAddress The extended source address of the Probing Initiator. @p aExtAddr MUST NOT be `NULL`.\n\n @retval OT_ERROR_NONE Successfully configured the Enhanced-ACK Based Probing.\n @retval OT_ERROR_INVALID_ARGS @p aExtAddress is `NULL`.\n @retval OT_ERROR_NOT_FOUND The Initiator indicated by @p aShortAddress is not found when trying to clear.\n @retval OT_ERROR_NO_BUFS No more Initiator can be supported.\n @retval OT_ERROR_NOT_IMPLEMENTED The feature is not implemented.\n"]
pub fn otPlatRadioConfigureEnhAckProbing(
aInstance: *mut otInstance,
aLinkMetrics: otLinkMetrics,
aShortAddress: otShortAddress,
aExtAddress: *const otExtAddress,
) -> otError;
}
extern "C" {
#[doc = " Add a calibrated power of the specified channel to the power calibration table.\n\n @note This API is an optional radio platform API. It's up to the platform layer to implement it.\n\n The @p aActualPower is the actual measured output power when the parameters of the radio hardware modules\n are set to the @p aRawPowerSetting.\n\n The raw power setting is an opaque byte array. OpenThread doesn't define the format of the raw power setting.\n Its format is radio hardware related and it should be defined by the developers in the platform radio driver.\n For example, if the radio hardware contains both the radio chip and the FEM chip, the raw power setting can be\n a combination of the radio power register and the FEM gain value.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aChannel The radio channel.\n @param[in] aActualPower The actual power in 0.01dBm.\n @param[in] aRawPowerSetting A pointer to the raw power setting byte array.\n @param[in] aRawPowerSettingLength The length of the @p aRawPowerSetting.\n\n @retval OT_ERROR_NONE Successfully added the calibrated power to the power calibration table.\n @retval OT_ERROR_NO_BUFS No available entry in the power calibration table.\n @retval OT_ERROR_INVALID_ARGS The @p aChannel, @p aActualPower or @p aRawPowerSetting is invalid or the\n @p aActualPower already exists in the power calibration table.\n @retval OT_ERROR_NOT_IMPLEMENTED This feature is not implemented.\n"]
pub fn otPlatRadioAddCalibratedPower(
aInstance: *mut otInstance,
aChannel: u8,
aActualPower: i16,
aRawPowerSetting: *const u8,
aRawPowerSettingLength: u16,
) -> otError;
}
extern "C" {
#[doc = " Clear all calibrated powers from the power calibration table.\n\n @note This API is an optional radio platform API. It's up to the platform layer to implement it.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @retval OT_ERROR_NONE Successfully cleared all calibrated powers from the power calibration table.\n @retval OT_ERROR_NOT_IMPLEMENTED This feature is not implemented.\n"]
pub fn otPlatRadioClearCalibratedPowers(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Set the target power for the given channel.\n\n @note This API is an optional radio platform API. It's up to the platform layer to implement it.\n If this API is implemented, the function `otPlatRadioSetTransmitPower()` should be disabled.\n\n The radio driver should set the actual output power to be less than or equal to the target power and as close\n as possible to the target power.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aChannel The radio channel.\n @param[in] aTargetPower The target power in 0.01dBm. Passing `INT16_MAX` will disable this channel to use the\n target power.\n\n @retval OT_ERROR_NONE Successfully set the target power.\n @retval OT_ERROR_INVALID_ARGS The @p aChannel or @p aTargetPower is invalid.\n @retval OT_ERROR_NOT_IMPLEMENTED The feature is not implemented.\n"]
pub fn otPlatRadioSetChannelTargetPower(
aInstance: *mut otInstance,
aChannel: u8,
aTargetPower: i16,
) -> otError;
}
extern "C" {
#[doc = " Get the raw power setting for the given channel.\n\n @note OpenThread `src/core/utils` implements a default implementation of the API `otPlatRadioAddCalibratedPower()`,\n `otPlatRadioClearCalibratedPowers()` and `otPlatRadioSetChannelTargetPower()`. This API is provided by\n the default implementation to get the raw power setting for the given channel. If the platform doesn't\n use the default implementation, it can ignore this API.\n\n Platform radio layer should parse the raw power setting based on the radio layer defined format and set the\n parameters of each radio hardware module.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aChannel The radio channel.\n @param[out] aRawPowerSetting A pointer to the raw power setting byte array.\n @param[in,out] aRawPowerSettingLength On input, a pointer to the size of @p aRawPowerSetting.\n On output, a pointer to the length of the raw power setting data.\n\n @retval OT_ERROR_NONE Successfully got the target power.\n @retval OT_ERROR_INVALID_ARGS The @p aChannel is invalid, @p aRawPowerSetting or @p aRawPowerSettingLength is NULL\n or @aRawPowerSettingLength is too short.\n @retval OT_ERROR_NOT_FOUND The raw power setting for the @p aChannel was not found.\n"]
pub fn otPlatRadioGetRawPowerSetting(
aInstance: *mut otInstance,
aChannel: u8,
aRawPowerSetting: *mut u8,
aRawPowerSettingLength: *mut u16,
) -> otError;
}
#[doc = " @struct otIp6InterfaceIdentifier\n\n Represents the Interface Identifier of an IPv6 address.\n"]
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct otIp6InterfaceIdentifier {
#[doc = "< The Interface Identifier accessor fields"]
pub mFields: otIp6InterfaceIdentifier__bindgen_ty_1,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union otIp6InterfaceIdentifier__bindgen_ty_1 {
#[doc = "< 8-bit fields"]
pub m8: [u8; 8usize],
#[doc = "< 16-bit fields"]
pub m16: [u16; 4usize],
#[doc = "< 32-bit fields"]
pub m32: [u32; 2usize],
}
impl Default for otIp6InterfaceIdentifier__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for otIp6InterfaceIdentifier {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " @struct otIp6NetworkPrefix\n\n Represents the Network Prefix of an IPv6 address (most significant 64 bits of the address).\n"]
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otIp6NetworkPrefix {
#[doc = "< The Network Prefix."]
pub m8: [u8; 8usize],
}
#[doc = " @struct otIp6AddressComponents\n\n Represents the components of an IPv6 address.\n"]
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct otIp6AddressComponents {
#[doc = "< The Network Prefix (most significant 64 bits of the address)"]
pub mNetworkPrefix: otIp6NetworkPrefix,
#[doc = "< The Interface Identifier (least significant 64 bits of the address)"]
pub mIid: otIp6InterfaceIdentifier,
}
impl Default for otIp6AddressComponents {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " @struct otIp6Address\n\n Represents an IPv6 address.\n"]
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct otIp6Address {
#[doc = "< IPv6 accessor fields"]
pub mFields: otIp6Address__bindgen_ty_1,
}
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub union otIp6Address__bindgen_ty_1 {
#[doc = "< 8-bit fields"]
pub m8: [u8; 16usize],
#[doc = "< 16-bit fields"]
pub m16: [u16; 8usize],
#[doc = "< 32-bit fields"]
pub m32: [u32; 4usize],
#[doc = "< IPv6 address components"]
pub mComponents: otIp6AddressComponents,
}
impl Default for otIp6Address__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for otIp6Address {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " @struct otIp6Prefix\n\n Represents an IPv6 prefix.\n"]
#[repr(C, packed)]
#[derive(Copy, Clone)]
pub struct otIp6Prefix {
#[doc = "< The IPv6 prefix."]
pub mPrefix: otIp6Address,
#[doc = "< The IPv6 prefix length (in bits)."]
pub mLength: u8,
}
impl Default for otIp6Prefix {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = "< Thread assigned address (ALOC, RLOC, MLEID, etc)"]
pub const OT_ADDRESS_ORIGIN_THREAD: _bindgen_ty_7 = 0;
#[doc = "< SLAAC assigned address"]
pub const OT_ADDRESS_ORIGIN_SLAAC: _bindgen_ty_7 = 1;
#[doc = "< DHCPv6 assigned address"]
pub const OT_ADDRESS_ORIGIN_DHCPV6: _bindgen_ty_7 = 2;
#[doc = "< Manually assigned address"]
pub const OT_ADDRESS_ORIGIN_MANUAL: _bindgen_ty_7 = 3;
#[doc = " IPv6 Address origins\n"]
pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
#[doc = " Represents an IPv6 network interface unicast address.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otNetifAddress {
#[doc = "< The IPv6 unicast address."]
pub mAddress: otIp6Address,
#[doc = "< The Prefix length (in bits)."]
pub mPrefixLength: u8,
#[doc = "< The IPv6 address origin."]
pub mAddressOrigin: u8,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
#[doc = "< A pointer to the next network interface address."]
pub mNext: *const otNetifAddress,
}
impl Default for otNetifAddress {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl otNetifAddress {
#[inline]
pub fn mPreferred(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mPreferred(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn mValid(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_mValid(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn mScopeOverrideValid(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mScopeOverrideValid(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn mScopeOverride(&self) -> ::std::os::raw::c_uint {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 4u8) as u32) }
}
#[inline]
pub fn set_mScopeOverride(&mut self, val: ::std::os::raw::c_uint) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 4u8, val as u64)
}
}
#[inline]
pub fn mRloc(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
}
#[inline]
pub fn set_mRloc(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn mMeshLocal(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
}
#[inline]
pub fn set_mMeshLocal(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub fn mSrpRegistered(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
}
#[inline]
pub fn set_mSrpRegistered(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mPreferred: bool,
mValid: bool,
mScopeOverrideValid: bool,
mScopeOverride: ::std::os::raw::c_uint,
mRloc: bool,
mMeshLocal: bool,
mSrpRegistered: bool,
) -> __BindgenBitfieldUnit<[u8; 2usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
mPreferred as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let mValid: u8 = unsafe { ::std::mem::transmute(mValid) };
mValid as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mScopeOverrideValid: u8 = unsafe { ::std::mem::transmute(mScopeOverrideValid) };
mScopeOverrideValid as u64
});
__bindgen_bitfield_unit.set(3usize, 4u8, {
let mScopeOverride: u32 = unsafe { ::std::mem::transmute(mScopeOverride) };
mScopeOverride as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let mRloc: u8 = unsafe { ::std::mem::transmute(mRloc) };
mRloc as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let mMeshLocal: u8 = unsafe { ::std::mem::transmute(mMeshLocal) };
mMeshLocal as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let mSrpRegistered: u8 = unsafe { ::std::mem::transmute(mSrpRegistered) };
mSrpRegistered as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " Represents an IPv6 network interface multicast address.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otNetifMulticastAddress {
#[doc = "< The IPv6 multicast address."]
pub mAddress: otIp6Address,
#[doc = "< A pointer to the next network interface multicast address."]
pub mNext: *const otNetifMulticastAddress,
}
impl Default for otNetifMulticastAddress {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Represents an IPv6 socket address.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otSockAddr {
#[doc = "< An IPv6 address."]
pub mAddress: otIp6Address,
#[doc = "< A transport-layer port."]
pub mPort: u16,
}
impl Default for otSockAddr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = "< Non-ECT"]
pub const OT_ECN_NOT_CAPABLE: _bindgen_ty_8 = 0;
#[doc = "< ECT(0)"]
pub const OT_ECN_CAPABLE_0: _bindgen_ty_8 = 2;
#[doc = "< ECT(1)"]
pub const OT_ECN_CAPABLE_1: _bindgen_ty_8 = 1;
#[doc = "< Congestion encountered (CE)"]
pub const OT_ECN_MARKED: _bindgen_ty_8 = 3;
#[doc = " ECN statuses, represented as in the IP header.\n"]
pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
#[doc = " Represents the local and peer IPv6 socket addresses.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otMessageInfo {
#[doc = "< The local IPv6 address."]
pub mSockAddr: otIp6Address,
#[doc = "< The peer IPv6 address."]
pub mPeerAddr: otIp6Address,
#[doc = "< The local transport-layer port."]
pub mSockPort: u16,
#[doc = "< The peer transport-layer port."]
pub mPeerPort: u16,
#[doc = "< The IPv6 Hop Limit value. Only applies if `mAllowZeroHopLimit` is FALSE.\n< If `0`, IPv6 Hop Limit is default value `OPENTHREAD_CONFIG_IP6_HOP_LIMIT_DEFAULT`.\n< Otherwise, specifies the IPv6 Hop Limit."]
pub mHopLimit: u8,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
}
impl Default for otMessageInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl otMessageInfo {
#[inline]
pub fn mEcn(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
}
#[inline]
pub fn set_mEcn(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn mIsHostInterface(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsHostInterface(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn mAllowZeroHopLimit(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_mAllowZeroHopLimit(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn mMulticastLoop(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_mMulticastLoop(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mEcn: u8,
mIsHostInterface: bool,
mAllowZeroHopLimit: bool,
mMulticastLoop: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let mEcn: u8 = unsafe { ::std::mem::transmute(mEcn) };
mEcn as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mIsHostInterface: u8 = unsafe { ::std::mem::transmute(mIsHostInterface) };
mIsHostInterface as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let mAllowZeroHopLimit: u8 = unsafe { ::std::mem::transmute(mAllowZeroHopLimit) };
mAllowZeroHopLimit as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let mMulticastLoop: u8 = unsafe { ::std::mem::transmute(mMulticastLoop) };
mMulticastLoop as u64
});
__bindgen_bitfield_unit
}
}
#[doc = "< IPv6 Hop-by-Hop Option"]
pub const OT_IP6_PROTO_HOP_OPTS: _bindgen_ty_9 = 0;
#[doc = "< Transmission Control Protocol"]
pub const OT_IP6_PROTO_TCP: _bindgen_ty_9 = 6;
#[doc = "< User Datagram"]
pub const OT_IP6_PROTO_UDP: _bindgen_ty_9 = 17;
#[doc = "< IPv6 encapsulation"]
pub const OT_IP6_PROTO_IP6: _bindgen_ty_9 = 41;
#[doc = "< Routing Header for IPv6"]
pub const OT_IP6_PROTO_ROUTING: _bindgen_ty_9 = 43;
#[doc = "< Fragment Header for IPv6"]
pub const OT_IP6_PROTO_FRAGMENT: _bindgen_ty_9 = 44;
#[doc = "< ICMP for IPv6"]
pub const OT_IP6_PROTO_ICMP6: _bindgen_ty_9 = 58;
#[doc = "< No Next Header for IPv6"]
pub const OT_IP6_PROTO_NONE: _bindgen_ty_9 = 59;
#[doc = "< Destination Options for IPv6"]
pub const OT_IP6_PROTO_DST_OPTS: _bindgen_ty_9 = 60;
#[doc = " Internet Protocol Numbers.\n"]
pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
extern "C" {
#[doc = " Brings the IPv6 interface up or down.\n\n Call this to enable or disable IPv6 communication.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE to enable IPv6, FALSE otherwise.\n\n @retval OT_ERROR_NONE Successfully brought the IPv6 interface up/down.\n @retval OT_ERROR_INVALID_STATE IPv6 interface is not available since device is operating in raw-link mode\n (applicable only when `OPENTHREAD_CONFIG_LINK_RAW_ENABLE` feature is enabled).\n"]
pub fn otIp6SetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
}
extern "C" {
#[doc = " Indicates whether or not the IPv6 interface is up.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE The IPv6 interface is enabled.\n @retval FALSE The IPv6 interface is disabled.\n"]
pub fn otIp6IsEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Adds a Network Interface Address to the Thread interface.\n\n The passed-in instance @p aAddress is copied by the Thread interface. The Thread interface only\n supports a fixed number of externally added unicast addresses. See `OPENTHREAD_CONFIG_IP6_MAX_EXT_UCAST_ADDRS`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aAddress A pointer to a Network Interface Address.\n\n @retval OT_ERROR_NONE Successfully added (or updated) the Network Interface Address.\n @retval OT_ERROR_INVALID_ARGS The IP Address indicated by @p aAddress is an internal address.\n @retval OT_ERROR_NO_BUFS The Network Interface is already storing the maximum allowed external addresses.\n"]
pub fn otIp6AddUnicastAddress(
aInstance: *mut otInstance,
aAddress: *const otNetifAddress,
) -> otError;
}
extern "C" {
#[doc = " Removes a Network Interface Address from the Thread interface.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aAddress A pointer to an IP Address.\n\n @retval OT_ERROR_NONE Successfully removed the Network Interface Address.\n @retval OT_ERROR_INVALID_ARGS The IP Address indicated by @p aAddress is an internal address.\n @retval OT_ERROR_NOT_FOUND The IP Address indicated by @p aAddress was not found.\n"]
pub fn otIp6RemoveUnicastAddress(
aInstance: *mut otInstance,
aAddress: *const otIp6Address,
) -> otError;
}
extern "C" {
#[doc = " Gets the list of IPv6 addresses assigned to the Thread interface.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the first Network Interface Address.\n"]
pub fn otIp6GetUnicastAddresses(aInstance: *mut otInstance) -> *const otNetifAddress;
}
extern "C" {
#[doc = " Indicates whether or not a unicast IPv6 address is assigned to the Thread interface.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aAddress A pointer to the unicast address.\n\n @retval TRUE If @p aAddress is assigned to the Thread interface.\n @retval FALSE If @p aAddress is not assigned to the Thread interface.\n"]
pub fn otIp6HasUnicastAddress(
aInstance: *mut otInstance,
aAddress: *const otIp6Address,
) -> bool;
}
extern "C" {
#[doc = " Subscribes the Thread interface to a Network Interface Multicast Address.\n\n The passed in instance @p aAddress will be copied by the Thread interface. The Thread interface only\n supports a fixed number of externally added multicast addresses. See `OPENTHREAD_CONFIG_IP6_MAX_EXT_MCAST_ADDRS`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aAddress A pointer to an IP Address.\n\n @retval OT_ERROR_NONE Successfully subscribed to the Network Interface Multicast Address.\n @retval OT_ERROR_ALREADY The multicast address is already subscribed.\n @retval OT_ERROR_INVALID_ARGS The IP Address indicated by @p aAddress is an invalid multicast address.\n @retval OT_ERROR_REJECTED The IP Address indicated by @p aAddress is an internal multicast address.\n @retval OT_ERROR_NO_BUFS The Network Interface is already storing the maximum allowed external multicast\n addresses.\n"]
pub fn otIp6SubscribeMulticastAddress(
aInstance: *mut otInstance,
aAddress: *const otIp6Address,
) -> otError;
}
extern "C" {
#[doc = " Unsubscribes the Thread interface to a Network Interface Multicast Address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aAddress A pointer to an IP Address.\n\n @retval OT_ERROR_NONE Successfully unsubscribed to the Network Interface Multicast Address.\n @retval OT_ERROR_REJECTED The IP Address indicated by @p aAddress is an internal address.\n @retval OT_ERROR_NOT_FOUND The IP Address indicated by @p aAddress was not found.\n"]
pub fn otIp6UnsubscribeMulticastAddress(
aInstance: *mut otInstance,
aAddress: *const otIp6Address,
) -> otError;
}
extern "C" {
#[doc = " Gets the list of IPv6 multicast addresses subscribed to the Thread interface.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the first Network Interface Multicast Address.\n"]
pub fn otIp6GetMulticastAddresses(aInstance: *mut otInstance)
-> *const otNetifMulticastAddress;
}
extern "C" {
#[doc = " Checks if multicast promiscuous mode is enabled on the Thread interface.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @sa otIp6SetMulticastPromiscuousEnabled\n"]
pub fn otIp6IsMulticastPromiscuousEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Enables or disables multicast promiscuous mode on the Thread interface.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE to enable Multicast Promiscuous mode, FALSE otherwise.\n\n @sa otIp6IsMulticastPromiscuousEnabled\n"]
pub fn otIp6SetMulticastPromiscuousEnabled(aInstance: *mut otInstance, aEnabled: bool);
}
extern "C" {
#[doc = " Allocate a new message buffer for sending an IPv6 message.\n\n @note If @p aSettings is 'NULL', the link layer security is enabled and the message priority is set to\n OT_MESSAGE_PRIORITY_NORMAL by default.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSettings A pointer to the message settings or NULL to set default settings.\n\n @returns A pointer to the message buffer or NULL if no message buffers are available or parameters are invalid.\n\n @sa otMessageFree\n"]
pub fn otIp6NewMessage(
aInstance: *mut otInstance,
aSettings: *const otMessageSettings,
) -> *mut otMessage;
}
extern "C" {
#[doc = " Allocate a new message buffer and write the IPv6 datagram to the message buffer for sending an IPv6 message.\n\n @note If @p aSettings is NULL, the link layer security is enabled and the message priority is obtained from IPv6\n message itself.\n If @p aSettings is not NULL, the @p aSetting->mPriority is ignored and obtained from IPv6 message itself.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aData A pointer to the IPv6 datagram buffer.\n @param[in] aDataLength The size of the IPv6 datagram buffer pointed by @p aData.\n @param[in] aSettings A pointer to the message settings or NULL to set default settings.\n\n @returns A pointer to the message or NULL if malformed IPv6 header or insufficient message buffers are available.\n\n @sa otMessageFree\n"]
pub fn otIp6NewMessageFromBuffer(
aInstance: *mut otInstance,
aData: *const u8,
aDataLength: u16,
aSettings: *const otMessageSettings,
) -> *mut otMessage;
}
#[doc = " Pointer is called when an IPv6 datagram is received.\n\n @param[in] aMessage A pointer to the message buffer containing the received IPv6 datagram. This function transfers\n the ownership of the @p aMessage to the receiver of the callback. The message should be\n freed by the receiver of the callback after it is processed (see otMessageFree()).\n @param[in] aContext A pointer to application-specific context.\n"]
pub type otIp6ReceiveCallback = ::std::option::Option<
unsafe extern "C" fn(aMessage: *mut otMessage, aContext: *mut ::std::os::raw::c_void),
>;
extern "C" {
#[doc = " Registers a callback to provide received IPv6 datagrams.\n\n By default, this callback does not pass Thread control traffic. See otIp6SetReceiveFilterEnabled() to\n change the Thread control traffic filter setting.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called when an IPv6 datagram is received or\n NULL to disable the callback.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @sa otIp6IsReceiveFilterEnabled\n @sa otIp6SetReceiveFilterEnabled\n"]
pub fn otIp6SetReceiveCallback(
aInstance: *mut otInstance,
aCallback: otIp6ReceiveCallback,
aCallbackContext: *mut ::std::os::raw::c_void,
);
}
#[doc = " Represents IPv6 address information.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otIp6AddressInfo {
#[doc = "< A pointer to the IPv6 address."]
pub mAddress: *const otIp6Address,
#[doc = "< The prefix length of mAddress if it is a unicast address."]
pub mPrefixLength: u8,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: [u16; 3usize],
}
impl Default for otIp6AddressInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl otIp6AddressInfo {
#[inline]
pub fn mScope(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
}
#[inline]
pub fn set_mScope(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 4u8, val as u64)
}
}
#[inline]
pub fn mPreferred(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_mPreferred(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn mMeshLocal(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
}
#[inline]
pub fn set_mMeshLocal(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mScope: u8,
mPreferred: bool,
mMeshLocal: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 4u8, {
let mScope: u8 = unsafe { ::std::mem::transmute(mScope) };
mScope as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
mPreferred as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let mMeshLocal: u8 = unsafe { ::std::mem::transmute(mMeshLocal) };
mMeshLocal as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " Pointer is called when an internal IPv6 address is added or removed.\n\n @param[in] aAddressInfo A pointer to the IPv6 address information.\n @param[in] aIsAdded TRUE if the @p aAddress was added, FALSE if @p aAddress was removed.\n @param[in] aContext A pointer to application-specific context.\n"]
pub type otIp6AddressCallback = ::std::option::Option<
unsafe extern "C" fn(
aAddressInfo: *const otIp6AddressInfo,
aIsAdded: bool,
aContext: *mut ::std::os::raw::c_void,
),
>;
extern "C" {
#[doc = " Registers a callback to notify internal IPv6 address changes.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called when an internal IPv6 address is added or\n removed. NULL to disable the callback.\n @param[in] aCallbackContext A pointer to application-specific context.\n"]
pub fn otIp6SetAddressCallback(
aInstance: *mut otInstance,
aCallback: otIp6AddressCallback,
aCallbackContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Indicates whether or not Thread control traffic is filtered out when delivering IPv6 datagrams\n via the callback specified in otIp6SetReceiveCallback().\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if Thread control traffic is filtered out, FALSE otherwise.\n\n @sa otIp6SetReceiveCallback\n @sa otIp6SetReceiveFilterEnabled\n"]
pub fn otIp6IsReceiveFilterEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Sets whether or not Thread control traffic is filtered out when delivering IPv6 datagrams\n via the callback specified in otIp6SetReceiveCallback().\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE if Thread control traffic is filtered out, FALSE otherwise.\n\n @sa otIp6SetReceiveCallback\n @sa otIsReceiveIp6FilterEnabled\n"]
pub fn otIp6SetReceiveFilterEnabled(aInstance: *mut otInstance, aEnabled: bool);
}
extern "C" {
#[doc = " Sends an IPv6 datagram via the Thread interface.\n\n The caller transfers ownership of @p aMessage when making this call. OpenThread will free @p aMessage when\n processing is complete, including when a value other than `OT_ERROR_NONE` is returned.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the message buffer containing the IPv6 datagram.\n\n @retval OT_ERROR_NONE Successfully processed the message.\n @retval OT_ERROR_DROP Message was well-formed but not fully processed due to packet processing\n rules.\n @retval OT_ERROR_NO_BUFS Could not allocate necessary message buffers when processing the datagram.\n @retval OT_ERROR_NO_ROUTE No route to host.\n @retval OT_ERROR_INVALID_SOURCE_ADDRESS Source address is invalid, e.g. an anycast address or a multicast address.\n @retval OT_ERROR_PARSE Encountered a malformed header when processing the message.\n @retval OT_ERROR_INVALID_ARGS The message's metadata is invalid, e.g. the message uses\n `OT_MESSAGE_ORIGIN_THREAD_NETIF` as the origin.\n"]
pub fn otIp6Send(aInstance: *mut otInstance, aMessage: *mut otMessage) -> otError;
}
extern "C" {
#[doc = " Adds a port to the allowed unsecured port list.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPort The port value.\n\n @retval OT_ERROR_NONE The port was successfully added to the allowed unsecure port list.\n @retval OT_ERROR_INVALID_ARGS The port is invalid (value 0 is reserved for internal use).\n @retval OT_ERROR_NO_BUFS The unsecure port list is full.\n"]
pub fn otIp6AddUnsecurePort(aInstance: *mut otInstance, aPort: u16) -> otError;
}
extern "C" {
#[doc = " Removes a port from the allowed unsecure port list.\n\n @note This function removes @p aPort by overwriting @p aPort with the element after @p aPort in the internal port\n list. Be careful when calling otIp6GetUnsecurePorts() followed by otIp6RemoveUnsecurePort() to remove unsecure\n ports.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPort The port value.\n\n @retval OT_ERROR_NONE The port was successfully removed from the allowed unsecure port list.\n @retval OT_ERROR_INVALID_ARGS The port is invalid (value 0 is reserved for internal use).\n @retval OT_ERROR_NOT_FOUND The port was not found in the unsecure port list.\n"]
pub fn otIp6RemoveUnsecurePort(aInstance: *mut otInstance, aPort: u16) -> otError;
}
extern "C" {
#[doc = " Removes all ports from the allowed unsecure port list.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otIp6RemoveAllUnsecurePorts(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Returns a pointer to the unsecure port list.\n\n @note Port value 0 is used to indicate an invalid entry.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aNumEntries The number of entries in the list.\n\n @returns A pointer to the unsecure port list.\n"]
pub fn otIp6GetUnsecurePorts(aInstance: *mut otInstance, aNumEntries: *mut u8) -> *const u16;
}
extern "C" {
#[doc = " Test if two IPv6 addresses are the same.\n\n @param[in] aFirst A pointer to the first IPv6 address to compare.\n @param[in] aSecond A pointer to the second IPv6 address to compare.\n\n @retval TRUE The two IPv6 addresses are the same.\n @retval FALSE The two IPv6 addresses are not the same.\n"]
pub fn otIp6IsAddressEqual(aFirst: *const otIp6Address, aSecond: *const otIp6Address) -> bool;
}
extern "C" {
#[doc = " Test if two IPv6 prefixes are the same.\n\n @param[in] aFirst A pointer to the first IPv6 prefix to compare.\n @param[in] aSecond A pointer to the second IPv6 prefix to compare.\n\n @retval TRUE The two IPv6 prefixes are the same.\n @retval FALSE The two IPv6 prefixes are not the same.\n"]
pub fn otIp6ArePrefixesEqual(aFirst: *const otIp6Prefix, aSecond: *const otIp6Prefix) -> bool;
}
extern "C" {
#[doc = " Converts a human-readable IPv6 address string into a binary representation.\n\n @param[in] aString A pointer to a NULL-terminated string.\n @param[out] aAddress A pointer to an IPv6 address.\n\n @retval OT_ERROR_NONE Successfully parsed @p aString and updated @p aAddress.\n @retval OT_ERROR_PARSE Failed to parse @p aString as an IPv6 address.\n"]
pub fn otIp6AddressFromString(
aString: *const ::std::os::raw::c_char,
aAddress: *mut otIp6Address,
) -> otError;
}
extern "C" {
#[doc = " Converts a human-readable IPv6 prefix string into a binary representation.\n\n The @p aString parameter should be a string in the format \"<address>/<plen>\", where `<address>` is an IPv6\n address and `<plen>` is a prefix length.\n\n @param[in] aString A pointer to a NULL-terminated string.\n @param[out] aPrefix A pointer to an IPv6 prefix.\n\n @retval OT_ERROR_NONE Successfully parsed the string as an IPv6 prefix and updated @p aPrefix.\n @retval OT_ERROR_PARSE Failed to parse @p aString as an IPv6 prefix.\n"]
pub fn otIp6PrefixFromString(
aString: *const ::std::os::raw::c_char,
aPrefix: *mut otIp6Prefix,
) -> otError;
}
extern "C" {
#[doc = " Converts a given IPv6 address to a human-readable string.\n\n The IPv6 address string is formatted as 16 hex values separated by ':' (i.e., \"%x:%x:%x:...:%x\").\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n @param[in] aAddress A pointer to an IPv6 address (MUST NOT be NULL).\n @param[out] aBuffer A pointer to a char array to output the string (MUST NOT be NULL).\n @param[in] aSize The size of @p aBuffer (in bytes). Recommended to use `OT_IP6_ADDRESS_STRING_SIZE`.\n"]
pub fn otIp6AddressToString(
aAddress: *const otIp6Address,
aBuffer: *mut ::std::os::raw::c_char,
aSize: u16,
);
}
extern "C" {
#[doc = " Converts a given IPv6 socket address to a human-readable string.\n\n The IPv6 socket address string is formatted as [`address`]:`port` where `address` is shown\n as 16 hex values separated by `:` and `port` is the port number in decimal format,\n for example \"[%x:%x:...:%x]:%u\".\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n @param[in] aSockAddr A pointer to an IPv6 socket address (MUST NOT be NULL).\n @param[out] aBuffer A pointer to a char array to output the string (MUST NOT be NULL).\n @param[in] aSize The size of @p aBuffer (in bytes). Recommended to use `OT_IP6_SOCK_ADDR_STRING_SIZE`.\n"]
pub fn otIp6SockAddrToString(
aSockAddr: *const otSockAddr,
aBuffer: *mut ::std::os::raw::c_char,
aSize: u16,
);
}
extern "C" {
#[doc = " Converts a given IPv6 prefix to a human-readable string.\n\n The IPv6 address string is formatted as \"%x:%x:%x:...[::]/plen\".\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be truncated\n but the outputted string is always null-terminated.\n\n @param[in] aPrefix A pointer to an IPv6 prefix (MUST NOT be NULL).\n @param[out] aBuffer A pointer to a char array to output the string (MUST NOT be NULL).\n @param[in] aSize The size of @p aBuffer (in bytes). Recommended to use `OT_IP6_PREFIX_STRING_SIZE`.\n"]
pub fn otIp6PrefixToString(
aPrefix: *const otIp6Prefix,
aBuffer: *mut ::std::os::raw::c_char,
aSize: u16,
);
}
extern "C" {
#[doc = " Returns the prefix match length (bits) for two IPv6 addresses.\n\n @param[in] aFirst A pointer to the first IPv6 address.\n @param[in] aSecond A pointer to the second IPv6 address.\n\n @returns The prefix match length in bits.\n"]
pub fn otIp6PrefixMatch(aFirst: *const otIp6Address, aSecond: *const otIp6Address) -> u8;
}
extern "C" {
#[doc = " Gets a prefix with @p aLength from @p aAddress.\n\n @param[in] aAddress A pointer to an IPv6 address.\n @param[in] aLength The length of prefix in bits.\n @param[out] aPrefix A pointer to output the IPv6 prefix.\n"]
pub fn otIp6GetPrefix(aAddress: *const otIp6Address, aLength: u8, aPrefix: *mut otIp6Prefix);
}
extern "C" {
#[doc = " Indicates whether or not a given IPv6 address is the Unspecified Address.\n\n @param[in] aAddress A pointer to an IPv6 address.\n\n @retval TRUE If the IPv6 address is the Unspecified Address.\n @retval FALSE If the IPv6 address is not the Unspecified Address.\n"]
pub fn otIp6IsAddressUnspecified(aAddress: *const otIp6Address) -> bool;
}
extern "C" {
#[doc = " Perform OpenThread source address selection.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aMessageInfo A pointer to the message information.\n\n @retval OT_ERROR_NONE Found a source address and is filled into mSockAddr of @p aMessageInfo.\n @retval OT_ERROR_NOT_FOUND No source address was found and @p aMessageInfo is unchanged.\n"]
pub fn otIp6SelectSourceAddress(
aInstance: *mut otInstance,
aMessageInfo: *mut otMessageInfo,
) -> otError;
}
extern "C" {
#[doc = " Indicates whether the SLAAC module is enabled or not.\n\n `OPENTHREAD_CONFIG_IP6_SLAAC_ENABLE` build-time feature must be enabled.\n\n @retval TRUE SLAAC module is enabled.\n @retval FALSE SLAAC module is disabled.\n"]
pub fn otIp6IsSlaacEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Enables/disables the SLAAC module.\n\n `OPENTHREAD_CONFIG_IP6_SLAAC_ENABLE` build-time feature must be enabled.\n\n When SLAAC module is enabled, SLAAC addresses (based on on-mesh prefixes in Network Data) are added to the interface.\n When SLAAC module is disabled any previously added SLAAC address is removed.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE to enable, FALSE to disable.\n"]
pub fn otIp6SetSlaacEnabled(aInstance: *mut otInstance, aEnabled: bool);
}
#[doc = " Pointer allows user to filter prefixes and not allow an SLAAC address based on a prefix to be added.\n\n `otIp6SetSlaacPrefixFilter()` can be used to set the filter handler. The filter handler is invoked by SLAAC module\n when it is about to add a SLAAC address based on a prefix. Its boolean return value determines whether the address\n is filtered (not added) or not.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPrefix A pointer to prefix for which SLAAC address is about to be added.\n\n @retval TRUE Indicates that the SLAAC address based on the prefix should be filtered and NOT added.\n @retval FALSE Indicates that the SLAAC address based on the prefix should be added.\n"]
pub type otIp6SlaacPrefixFilter = ::std::option::Option<
unsafe extern "C" fn(aInstance: *mut otInstance, aPrefix: *const otIp6Prefix) -> bool,
>;
extern "C" {
#[doc = " Sets the SLAAC module filter handler.\n\n `OPENTHREAD_CONFIG_IP6_SLAAC_ENABLE` build-time feature must be enabled.\n\n The filter handler is called by SLAAC module when it is about to add a SLAAC address based on a prefix to decide\n whether the address should be added or not.\n\n A NULL filter handler disables filtering and allows all SLAAC addresses to be added.\n\n If this function is not called, the default filter used by SLAAC module will be NULL (filtering is disabled).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aFilter A pointer to SLAAC prefix filter handler, or NULL to disable filtering.\n"]
pub fn otIp6SetSlaacPrefixFilter(aInstance: *mut otInstance, aFilter: otIp6SlaacPrefixFilter);
}
#[doc = " Pointer is called with results of `otIp6RegisterMulticastListeners`.\n\n @param[in] aContext A pointer to the user context.\n @param[in] aError OT_ERROR_NONE when successfully sent MLR.req and received MLR.rsp,\n OT_ERROR_RESPONSE_TIMEOUT when failed to receive MLR.rsp,\n OT_ERROR_PARSE when failed to parse MLR.rsp.\n @param[in] aMlrStatus The Multicast Listener Registration status when @p aError is OT_ERROR_NONE.\n @param[in] aFailedAddresses A pointer to the failed IPv6 addresses when @p aError is OT_ERROR_NONE.\n @param[in] aFailedAddressNum The number of failed IPv6 addresses when @p aError is OT_ERROR_NONE.\n\n @sa otIp6RegisterMulticastListeners\n"]
pub type otIp6RegisterMulticastListenersCallback = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aError: otError,
aMlrStatus: u8,
aFailedAddresses: *const otIp6Address,
aFailedAddressNum: u8,
),
>;
extern "C" {
#[doc = " Registers Multicast Listeners to Primary Backbone Router.\n\n `OPENTHREAD_CONFIG_TMF_PROXY_MLR_ENABLE` and `OPENTHREAD_CONFIG_COMMISSIONER_ENABLE`\n must be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aAddresses A Multicast Address Array to register.\n @param[in] aAddressNum The number of Multicast Address to register (0 if @p aAddresses is NULL).\n @param[in] aTimeout A pointer to the timeout value (in seconds) to be included in MLR.req. A timeout value of 0\n removes the corresponding Multicast Listener. If NULL, MLR.req would have no Timeout Tlv by\n default.\n @param[in] aCallback A pointer to the callback function.\n @param[in] aContext A pointer to the user context.\n\n @retval OT_ERROR_NONE Successfully sent MLR.req. The @p aCallback will be called iff this method\n returns OT_ERROR_NONE.\n @retval OT_ERROR_BUSY If a previous registration was ongoing.\n @retval OT_ERROR_INVALID_ARGS If one or more arguments are invalid.\n @retval OT_ERROR_INVALID_STATE If the device was not in a valid state to send MLR.req (e.g. Commissioner not\n started, Primary Backbone Router not found).\n @retval OT_ERROR_NO_BUFS If insufficient message buffers available.\n\n @sa otIp6RegisterMulticastListenersCallback\n"]
pub fn otIp6RegisterMulticastListeners(
aInstance: *mut otInstance,
aAddresses: *const otIp6Address,
aAddressNum: u8,
aTimeout: *const u32,
aCallback: otIp6RegisterMulticastListenersCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Sets the Mesh Local IID (for test purpose).\n\n Requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aIid A pointer to the Mesh Local IID to set.\n\n @retval OT_ERROR_NONE Successfully set the Mesh Local IID.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n"]
pub fn otIp6SetMeshLocalIid(
aInstance: *mut otInstance,
aIid: *const otIp6InterfaceIdentifier,
) -> otError;
}
extern "C" {
#[doc = " Converts a given IP protocol number to a human-readable string.\n\n @param[in] aIpProto An IP protocol number (`OT_IP6_PROTO_*` enumeration).\n\n @returns A string representing @p aIpProto.\n"]
pub fn otIp6ProtoToString(aIpProto: u8) -> *const ::std::os::raw::c_char;
}
#[doc = " Represents the counters for packets and bytes.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otPacketsAndBytes {
#[doc = "< The number of packets."]
pub mPackets: u64,
#[doc = "< The number of bytes."]
pub mBytes: u64,
}
#[doc = " Represents the counters of packets forwarded via Border Routing.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otBorderRoutingCounters {
#[doc = "< The counters for inbound unicast."]
pub mInboundUnicast: otPacketsAndBytes,
#[doc = "< The counters for inbound multicast."]
pub mInboundMulticast: otPacketsAndBytes,
#[doc = "< The counters for outbound unicast."]
pub mOutboundUnicast: otPacketsAndBytes,
#[doc = "< The counters for outbound multicast."]
pub mOutboundMulticast: otPacketsAndBytes,
#[doc = "< The counters for inbound Internet when DHCPv6 PD enabled."]
pub mInboundInternet: otPacketsAndBytes,
#[doc = "< The counters for outbound Internet when DHCPv6 PD enabled."]
pub mOutboundInternet: otPacketsAndBytes,
#[doc = "< The number of received RA packets."]
pub mRaRx: u32,
#[doc = "< The number of RA packets successfully transmitted."]
pub mRaTxSuccess: u32,
#[doc = "< The number of RA packets failed to transmit."]
pub mRaTxFailure: u32,
#[doc = "< The number of received RS packets."]
pub mRsRx: u32,
#[doc = "< The number of RS packets successfully transmitted."]
pub mRsTxSuccess: u32,
#[doc = "< The number of RS packets failed to transmit."]
pub mRsTxFailure: u32,
}
extern "C" {
#[doc = " Gets the Border Routing counters.\n\n `OPENTHREAD_CONFIG_IP6_BR_COUNTERS_ENABLE` build-time feature must be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Border Routing counters.\n"]
pub fn otIp6GetBorderRoutingCounters(
aInstance: *mut otInstance,
) -> *const otBorderRoutingCounters;
}
extern "C" {
#[doc = " Resets the Border Routing counters.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otIp6ResetBorderRoutingCounters(aInstance: *mut otInstance);
}
#[doc = " @struct otNetworkKey\n\n Represents a Thread Network Key.\n"]
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otNetworkKey {
#[doc = "< Byte values"]
pub m8: [u8; 16usize],
}
#[doc = " This datatype represents KeyRef to NetworkKey.\n"]
pub type otNetworkKeyRef = otCryptoKeyRef;
#[doc = " Represents a Network Name.\n\n The `otNetworkName` is a null terminated C string (i.e., `m8` char array MUST end with null char `\\0`).\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otNetworkName {
#[doc = "< Byte values. The `+ 1` is for null char."]
pub m8: [::std::os::raw::c_char; 17usize],
}
#[doc = " Represents an Extended PAN ID.\n"]
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otExtendedPanId {
#[doc = "< Byte values"]
pub m8: [u8; 8usize],
}
#[doc = " Represents a Mesh Local Prefix.\n"]
pub type otMeshLocalPrefix = otIp6NetworkPrefix;
#[doc = " Represents PSKc.\n"]
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otPskc {
#[doc = "< Byte values"]
pub m8: [u8; 16usize],
}
#[doc = " This datatype represents KeyRef to PSKc.\n"]
pub type otPskcRef = otCryptoKeyRef;
#[doc = " Represent Security Policy.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otSecurityPolicy {
#[doc = "< The value for thrKeyRotation in units of hours."]
pub mRotationTime: u16,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
}
impl otSecurityPolicy {
#[inline]
pub fn mObtainNetworkKeyEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mObtainNetworkKeyEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn mNativeCommissioningEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_mNativeCommissioningEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn mRoutersEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mRoutersEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn mExternalCommissioningEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_mExternalCommissioningEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn mCommercialCommissioningEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_mCommercialCommissioningEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn mAutonomousEnrollmentEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
}
#[inline]
pub fn set_mAutonomousEnrollmentEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn mNetworkKeyProvisioningEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
}
#[inline]
pub fn set_mNetworkKeyProvisioningEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub fn mTobleLinkEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
}
#[inline]
pub fn set_mTobleLinkEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn mNonCcmRoutersEnabled(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
}
#[inline]
pub fn set_mNonCcmRoutersEnabled(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub fn mVersionThresholdForRouting(&self) -> u8 {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 3u8) as u8) }
}
#[inline]
pub fn set_mVersionThresholdForRouting(&mut self, val: u8) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 3u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mObtainNetworkKeyEnabled: bool,
mNativeCommissioningEnabled: bool,
mRoutersEnabled: bool,
mExternalCommissioningEnabled: bool,
mCommercialCommissioningEnabled: bool,
mAutonomousEnrollmentEnabled: bool,
mNetworkKeyProvisioningEnabled: bool,
mTobleLinkEnabled: bool,
mNonCcmRoutersEnabled: bool,
mVersionThresholdForRouting: u8,
) -> __BindgenBitfieldUnit<[u8; 2usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mObtainNetworkKeyEnabled: u8 =
unsafe { ::std::mem::transmute(mObtainNetworkKeyEnabled) };
mObtainNetworkKeyEnabled as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let mNativeCommissioningEnabled: u8 =
unsafe { ::std::mem::transmute(mNativeCommissioningEnabled) };
mNativeCommissioningEnabled as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mRoutersEnabled: u8 = unsafe { ::std::mem::transmute(mRoutersEnabled) };
mRoutersEnabled as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let mExternalCommissioningEnabled: u8 =
unsafe { ::std::mem::transmute(mExternalCommissioningEnabled) };
mExternalCommissioningEnabled as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let mCommercialCommissioningEnabled: u8 =
unsafe { ::std::mem::transmute(mCommercialCommissioningEnabled) };
mCommercialCommissioningEnabled as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let mAutonomousEnrollmentEnabled: u8 =
unsafe { ::std::mem::transmute(mAutonomousEnrollmentEnabled) };
mAutonomousEnrollmentEnabled as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let mNetworkKeyProvisioningEnabled: u8 =
unsafe { ::std::mem::transmute(mNetworkKeyProvisioningEnabled) };
mNetworkKeyProvisioningEnabled as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let mTobleLinkEnabled: u8 = unsafe { ::std::mem::transmute(mTobleLinkEnabled) };
mTobleLinkEnabled as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let mNonCcmRoutersEnabled: u8 = unsafe { ::std::mem::transmute(mNonCcmRoutersEnabled) };
mNonCcmRoutersEnabled as u64
});
__bindgen_bitfield_unit.set(9usize, 3u8, {
let mVersionThresholdForRouting: u8 =
unsafe { ::std::mem::transmute(mVersionThresholdForRouting) };
mVersionThresholdForRouting as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " Represents Channel Mask.\n"]
pub type otChannelMask = u32;
#[doc = " Represents presence of different components in Active or Pending Operational Dataset.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otOperationalDatasetComponents {
#[doc = "< TRUE if Active Timestamp is present, FALSE otherwise."]
pub mIsActiveTimestampPresent: bool,
#[doc = "< TRUE if Pending Timestamp is present, FALSE otherwise."]
pub mIsPendingTimestampPresent: bool,
#[doc = "< TRUE if Network Key is present, FALSE otherwise."]
pub mIsNetworkKeyPresent: bool,
#[doc = "< TRUE if Network Name is present, FALSE otherwise."]
pub mIsNetworkNamePresent: bool,
#[doc = "< TRUE if Extended PAN ID is present, FALSE otherwise."]
pub mIsExtendedPanIdPresent: bool,
#[doc = "< TRUE if Mesh Local Prefix is present, FALSE otherwise."]
pub mIsMeshLocalPrefixPresent: bool,
#[doc = "< TRUE if Delay Timer is present, FALSE otherwise."]
pub mIsDelayPresent: bool,
#[doc = "< TRUE if PAN ID is present, FALSE otherwise."]
pub mIsPanIdPresent: bool,
#[doc = "< TRUE if Channel is present, FALSE otherwise."]
pub mIsChannelPresent: bool,
#[doc = "< TRUE if PSKc is present, FALSE otherwise."]
pub mIsPskcPresent: bool,
#[doc = "< TRUE if Security Policy is present, FALSE otherwise."]
pub mIsSecurityPolicyPresent: bool,
#[doc = "< TRUE if Channel Mask is present, FALSE otherwise."]
pub mIsChannelMaskPresent: bool,
}
#[doc = " Represents a Thread Dataset timestamp component.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otTimestamp {
pub mSeconds: u64,
pub mTicks: u16,
pub mAuthoritative: bool,
}
#[doc = " Represents an Active or Pending Operational Dataset.\n\n Components in Dataset are optional. `mComponents` structure specifies which components are present in the Dataset.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otOperationalDataset {
#[doc = "< Active Timestamp"]
pub mActiveTimestamp: otTimestamp,
#[doc = "< Pending Timestamp"]
pub mPendingTimestamp: otTimestamp,
#[doc = "< Network Key"]
pub mNetworkKey: otNetworkKey,
#[doc = "< Network Name"]
pub mNetworkName: otNetworkName,
#[doc = "< Extended PAN ID"]
pub mExtendedPanId: otExtendedPanId,
#[doc = "< Mesh Local Prefix"]
pub mMeshLocalPrefix: otMeshLocalPrefix,
#[doc = "< Delay Timer"]
pub mDelay: u32,
#[doc = "< PAN ID"]
pub mPanId: otPanId,
#[doc = "< Channel"]
pub mChannel: u16,
#[doc = "< PSKc"]
pub mPskc: otPskc,
#[doc = "< Security Policy"]
pub mSecurityPolicy: otSecurityPolicy,
#[doc = "< Channel Mask"]
pub mChannelMask: otChannelMask,
#[doc = "< Specifies which components are set in the Dataset."]
pub mComponents: otOperationalDatasetComponents,
}
#[doc = " Represents an Active or Pending Operational Dataset.\n\n The Operational Dataset is TLV encoded as specified by Thread.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otOperationalDatasetTlvs {
#[doc = "< Operational Dataset TLVs."]
pub mTlvs: [u8; 254usize],
#[doc = "< Size of Operational Dataset in bytes."]
pub mLength: u8,
}
impl Default for otOperationalDatasetTlvs {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = "< meshcop Channel TLV"]
pub const OT_MESHCOP_TLV_CHANNEL: otMeshcopTlvType = 0;
#[doc = "< meshcop Pan Id TLV"]
pub const OT_MESHCOP_TLV_PANID: otMeshcopTlvType = 1;
#[doc = "< meshcop Extended Pan Id TLV"]
pub const OT_MESHCOP_TLV_EXTPANID: otMeshcopTlvType = 2;
#[doc = "< meshcop Network Name TLV"]
pub const OT_MESHCOP_TLV_NETWORKNAME: otMeshcopTlvType = 3;
#[doc = "< meshcop PSKc TLV"]
pub const OT_MESHCOP_TLV_PSKC: otMeshcopTlvType = 4;
#[doc = "< meshcop Network Key TLV"]
pub const OT_MESHCOP_TLV_NETWORKKEY: otMeshcopTlvType = 5;
#[doc = "< meshcop Network Key Sequence TLV"]
pub const OT_MESHCOP_TLV_NETWORK_KEY_SEQUENCE: otMeshcopTlvType = 6;
#[doc = "< meshcop Mesh Local Prefix TLV"]
pub const OT_MESHCOP_TLV_MESHLOCALPREFIX: otMeshcopTlvType = 7;
#[doc = "< meshcop Steering Data TLV"]
pub const OT_MESHCOP_TLV_STEERING_DATA: otMeshcopTlvType = 8;
#[doc = "< meshcop Border Agent Locator TLV"]
pub const OT_MESHCOP_TLV_BORDER_AGENT_RLOC: otMeshcopTlvType = 9;
#[doc = "< meshcop Commissioner ID TLV"]
pub const OT_MESHCOP_TLV_COMMISSIONER_ID: otMeshcopTlvType = 10;
#[doc = "< meshcop Commissioner Session ID TLV"]
pub const OT_MESHCOP_TLV_COMM_SESSION_ID: otMeshcopTlvType = 11;
#[doc = "< meshcop Security Policy TLV"]
pub const OT_MESHCOP_TLV_SECURITYPOLICY: otMeshcopTlvType = 12;
#[doc = "< meshcop Get TLV"]
pub const OT_MESHCOP_TLV_GET: otMeshcopTlvType = 13;
#[doc = "< meshcop Active Timestamp TLV"]
pub const OT_MESHCOP_TLV_ACTIVETIMESTAMP: otMeshcopTlvType = 14;
#[doc = "< meshcop Commissioner UDP Port TLV"]
pub const OT_MESHCOP_TLV_COMMISSIONER_UDP_PORT: otMeshcopTlvType = 15;
#[doc = "< meshcop State TLV"]
pub const OT_MESHCOP_TLV_STATE: otMeshcopTlvType = 16;
#[doc = "< meshcop Joiner DTLS Encapsulation TLV"]
pub const OT_MESHCOP_TLV_JOINER_DTLS: otMeshcopTlvType = 17;
#[doc = "< meshcop Joiner UDP Port TLV"]
pub const OT_MESHCOP_TLV_JOINER_UDP_PORT: otMeshcopTlvType = 18;
#[doc = "< meshcop Joiner IID TLV"]
pub const OT_MESHCOP_TLV_JOINER_IID: otMeshcopTlvType = 19;
#[doc = "< meshcop Joiner Router Locator TLV"]
pub const OT_MESHCOP_TLV_JOINER_RLOC: otMeshcopTlvType = 20;
#[doc = "< meshcop Joiner Router KEK TLV"]
pub const OT_MESHCOP_TLV_JOINER_ROUTER_KEK: otMeshcopTlvType = 21;
#[doc = "< meshcop Provisioning URL TLV"]
pub const OT_MESHCOP_TLV_PROVISIONING_URL: otMeshcopTlvType = 32;
#[doc = "< meshcop Vendor Name TLV"]
pub const OT_MESHCOP_TLV_VENDOR_NAME_TLV: otMeshcopTlvType = 33;
#[doc = "< meshcop Vendor Model TLV"]
pub const OT_MESHCOP_TLV_VENDOR_MODEL_TLV: otMeshcopTlvType = 34;
#[doc = "< meshcop Vendor SW Version TLV"]
pub const OT_MESHCOP_TLV_VENDOR_SW_VERSION_TLV: otMeshcopTlvType = 35;
#[doc = "< meshcop Vendor Data TLV"]
pub const OT_MESHCOP_TLV_VENDOR_DATA_TLV: otMeshcopTlvType = 36;
#[doc = "< meshcop Vendor Stack Version TLV"]
pub const OT_MESHCOP_TLV_VENDOR_STACK_VERSION_TLV: otMeshcopTlvType = 37;
#[doc = "< meshcop UDP encapsulation TLV"]
pub const OT_MESHCOP_TLV_UDP_ENCAPSULATION_TLV: otMeshcopTlvType = 48;
#[doc = "< meshcop IPv6 address TLV"]
pub const OT_MESHCOP_TLV_IPV6_ADDRESS_TLV: otMeshcopTlvType = 49;
#[doc = "< meshcop Pending Timestamp TLV"]
pub const OT_MESHCOP_TLV_PENDINGTIMESTAMP: otMeshcopTlvType = 51;
#[doc = "< meshcop Delay Timer TLV"]
pub const OT_MESHCOP_TLV_DELAYTIMER: otMeshcopTlvType = 52;
#[doc = "< meshcop Channel Mask TLV"]
pub const OT_MESHCOP_TLV_CHANNELMASK: otMeshcopTlvType = 53;
#[doc = "< meshcop Count TLV"]
pub const OT_MESHCOP_TLV_COUNT: otMeshcopTlvType = 54;
#[doc = "< meshcop Period TLV"]
pub const OT_MESHCOP_TLV_PERIOD: otMeshcopTlvType = 55;
#[doc = "< meshcop Scan Duration TLV"]
pub const OT_MESHCOP_TLV_SCAN_DURATION: otMeshcopTlvType = 56;
#[doc = "< meshcop Energy List TLV"]
pub const OT_MESHCOP_TLV_ENERGY_LIST: otMeshcopTlvType = 57;
#[doc = "< meshcop Discovery Request TLV"]
pub const OT_MESHCOP_TLV_DISCOVERYREQUEST: otMeshcopTlvType = 128;
#[doc = "< meshcop Discovery Response TLV"]
pub const OT_MESHCOP_TLV_DISCOVERYRESPONSE: otMeshcopTlvType = 129;
#[doc = "< meshcop Joiner Advertisement TLV"]
pub const OT_MESHCOP_TLV_JOINERADVERTISEMENT: otMeshcopTlvType = 241;
#[doc = " Represents meshcop TLV types.\n"]
pub type otMeshcopTlvType = ::std::os::raw::c_uint;
#[doc = " Pointer is called when a response to a MGMT_SET request is received or times out.\n\n @param[in] aResult A result of the operation.\n @param[in] aContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE The request was accepted by the leader.\n @retval OT_ERROR_REJECTED The request was rejected by the leader.\n @retval OT_ERROR_PARSE An error occurred during parsing the response.\n @retval OT_ERROR_ABORT The request was reset by peer.\n @retval OT_ERROR_RESPONSE_TIMEOUT No response or acknowledgment received during timeout period.\n"]
pub type otDatasetMgmtSetCallback = ::std::option::Option<
unsafe extern "C" fn(aResult: otError, aContext: *mut ::std::os::raw::c_void),
>;
extern "C" {
#[doc = " Indicates whether a valid network is present in the Active Operational Dataset or not.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if a valid network is present in the Active Operational Dataset, FALSE otherwise.\n"]
pub fn otDatasetIsCommissioned(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Gets the Active Operational Dataset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aDataset A pointer to where the Active Operational Dataset will be placed.\n\n @retval OT_ERROR_NONE Successfully retrieved the Active Operational Dataset.\n @retval OT_ERROR_NOT_FOUND No corresponding value in the setting store.\n"]
pub fn otDatasetGetActive(
aInstance: *mut otInstance,
aDataset: *mut otOperationalDataset,
) -> otError;
}
extern "C" {
#[doc = " Gets the Active Operational Dataset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aDataset A pointer to where the Active Operational Dataset will be placed.\n\n @retval OT_ERROR_NONE Successfully retrieved the Active Operational Dataset.\n @retval OT_ERROR_NOT_FOUND No corresponding value in the setting store.\n"]
pub fn otDatasetGetActiveTlvs(
aInstance: *mut otInstance,
aDataset: *mut otOperationalDatasetTlvs,
) -> otError;
}
extern "C" {
#[doc = " Sets the Active Operational Dataset.\n\n If the dataset does not include an Active Timestamp, the dataset is only partially complete.\n\n If Thread is enabled on a device that has a partially complete Active Dataset, the device will attempt to attach to\n an existing Thread network using any existing information in the dataset. Only the Thread Network Key is needed to\n attach to a network.\n\n If channel is not included in the dataset, the device will send MLE Announce messages across different channels to\n find neighbors on other channels.\n\n If the device successfully attaches to a Thread network, the device will then retrieve the full Active Dataset from\n its Parent. Note that a router-capable device will not transition to the Router or Leader roles until it has a\n complete Active Dataset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDataset A pointer to the Active Operational Dataset.\n\n @retval OT_ERROR_NONE Successfully set the Active Operational Dataset.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to set the Active Operational Dataset.\n @retval OT_ERROR_NOT_IMPLEMENTED The platform does not implement settings functionality.\n"]
pub fn otDatasetSetActive(
aInstance: *mut otInstance,
aDataset: *const otOperationalDataset,
) -> otError;
}
extern "C" {
#[doc = " Sets the Active Operational Dataset.\n\n If the dataset does not include an Active Timestamp, the dataset is only partially complete.\n\n If Thread is enabled on a device that has a partially complete Active Dataset, the device will attempt to attach to\n an existing Thread network using any existing information in the dataset. Only the Thread Network Key is needed to\n attach to a network.\n\n If channel is not included in the dataset, the device will send MLE Announce messages across different channels to\n find neighbors on other channels.\n\n If the device successfully attaches to a Thread network, the device will then retrieve the full Active Dataset from\n its Parent. Note that a router-capable device will not transition to the Router or Leader roles until it has a\n complete Active Dataset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDataset A pointer to the Active Operational Dataset.\n\n @retval OT_ERROR_NONE Successfully set the Active Operational Dataset.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to set the Active Operational Dataset.\n @retval OT_ERROR_NOT_IMPLEMENTED The platform does not implement settings functionality.\n"]
pub fn otDatasetSetActiveTlvs(
aInstance: *mut otInstance,
aDataset: *const otOperationalDatasetTlvs,
) -> otError;
}
extern "C" {
#[doc = " Gets the Pending Operational Dataset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aDataset A pointer to where the Pending Operational Dataset will be placed.\n\n @retval OT_ERROR_NONE Successfully retrieved the Pending Operational Dataset.\n @retval OT_ERROR_NOT_FOUND No corresponding value in the setting store.\n"]
pub fn otDatasetGetPending(
aInstance: *mut otInstance,
aDataset: *mut otOperationalDataset,
) -> otError;
}
extern "C" {
#[doc = " Gets the Pending Operational Dataset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aDataset A pointer to where the Pending Operational Dataset will be placed.\n\n @retval OT_ERROR_NONE Successfully retrieved the Pending Operational Dataset.\n @retval OT_ERROR_NOT_FOUND No corresponding value in the setting store.\n"]
pub fn otDatasetGetPendingTlvs(
aInstance: *mut otInstance,
aDataset: *mut otOperationalDatasetTlvs,
) -> otError;
}
extern "C" {
#[doc = " Sets the Pending Operational Dataset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDataset A pointer to the Pending Operational Dataset.\n\n @retval OT_ERROR_NONE Successfully set the Pending Operational Dataset.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to set the Pending Operational Dataset.\n @retval OT_ERROR_NOT_IMPLEMENTED The platform does not implement settings functionality.\n"]
pub fn otDatasetSetPending(
aInstance: *mut otInstance,
aDataset: *const otOperationalDataset,
) -> otError;
}
extern "C" {
#[doc = " Sets the Pending Operational Dataset.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDataset A pointer to the Pending Operational Dataset.\n\n @retval OT_ERROR_NONE Successfully set the Pending Operational Dataset.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to set the Pending Operational Dataset.\n @retval OT_ERROR_NOT_IMPLEMENTED The platform does not implement settings functionality.\n"]
pub fn otDatasetSetPendingTlvs(
aInstance: *mut otInstance,
aDataset: *const otOperationalDatasetTlvs,
) -> otError;
}
extern "C" {
#[doc = " Sends MGMT_ACTIVE_GET.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDatasetComponents A pointer to a Dataset Components structure specifying which components to request.\n @param[in] aTlvTypes A pointer to array containing additional raw TLV types to be requested.\n @param[in] aLength The length of @p aTlvTypes.\n @param[in] aAddress A pointer to the IPv6 destination, if it is NULL, will use Leader ALOC as default.\n\n @retval OT_ERROR_NONE Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to send.\n"]
pub fn otDatasetSendMgmtActiveGet(
aInstance: *mut otInstance,
aDatasetComponents: *const otOperationalDatasetComponents,
aTlvTypes: *const u8,
aLength: u8,
aAddress: *const otIp6Address,
) -> otError;
}
extern "C" {
#[doc = " Sends MGMT_ACTIVE_SET.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDataset A pointer to operational dataset.\n @param[in] aTlvs A pointer to TLVs.\n @param[in] aLength The length of TLVs.\n @param[in] aCallback A pointer to a function that is called on response reception or timeout.\n @param[in] aContext A pointer to application-specific context for @p aCallback.\n\n @retval OT_ERROR_NONE Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to send.\n @retval OT_ERROR_BUSY A previous request is ongoing.\n"]
pub fn otDatasetSendMgmtActiveSet(
aInstance: *mut otInstance,
aDataset: *const otOperationalDataset,
aTlvs: *const u8,
aLength: u8,
aCallback: otDatasetMgmtSetCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Sends MGMT_PENDING_GET.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDatasetComponents A pointer to a Dataset Components structure specifying which components to request.\n @param[in] aTlvTypes A pointer to array containing additional raw TLV types to be requested.\n @param[in] aLength The length of @p aTlvTypes.\n @param[in] aAddress A pointer to the IPv6 destination, if it is NULL, will use Leader ALOC as default.\n\n @retval OT_ERROR_NONE Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to send.\n"]
pub fn otDatasetSendMgmtPendingGet(
aInstance: *mut otInstance,
aDatasetComponents: *const otOperationalDatasetComponents,
aTlvTypes: *const u8,
aLength: u8,
aAddress: *const otIp6Address,
) -> otError;
}
extern "C" {
#[doc = " Sends MGMT_PENDING_SET.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDataset A pointer to operational dataset.\n @param[in] aTlvs A pointer to TLVs.\n @param[in] aLength The length of TLVs.\n @param[in] aCallback A pointer to a function that is called on response reception or timeout.\n @param[in] aContext A pointer to application-specific context for @p aCallback.\n\n @retval OT_ERROR_NONE Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to send.\n @retval OT_ERROR_BUSY A previous request is ongoing.\n"]
pub fn otDatasetSendMgmtPendingSet(
aInstance: *mut otInstance,
aDataset: *const otOperationalDataset,
aTlvs: *const u8,
aLength: u8,
aCallback: otDatasetMgmtSetCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Generates PSKc from a given pass-phrase, network name, and extended PAN ID.\n\n PSKc is used to establish the Commissioner Session.\n\n @param[in] aPassPhrase The commissioning pass-phrase.\n @param[in] aNetworkName The network name for PSKc computation.\n @param[in] aExtPanId The extended PAN ID for PSKc computation.\n @param[out] aPskc A pointer to variable to output the generated PSKc.\n\n @retval OT_ERROR_NONE Successfully generate PSKc.\n @retval OT_ERROR_INVALID_ARGS If any of the input arguments is invalid.\n"]
pub fn otDatasetGeneratePskc(
aPassPhrase: *const ::std::os::raw::c_char,
aNetworkName: *const otNetworkName,
aExtPanId: *const otExtendedPanId,
aPskc: *mut otPskc,
) -> otError;
}
extern "C" {
#[doc = " Sets an `otNetworkName` instance from a given null terminated C string.\n\n @p aNameString must follow UTF-8 encoding and the Network Name length must not be longer than\n `OT_NETWORK_NAME_MAX_SIZE`.\n\n @param[out] aNetworkName A pointer to the `otNetworkName` to set.\n @param[in] aNameString A name C string.\n\n @retval OT_ERROR_NONE Successfully set @p aNetworkName from @p aNameString.\n @retval OT_ERROR_INVALID_ARGS @p aNameStrng is invalid (too long or does not follow UTF-8 encoding).\n"]
pub fn otNetworkNameFromString(
aNetworkName: *mut otNetworkName,
aNameString: *const ::std::os::raw::c_char,
) -> otError;
}
extern "C" {
#[doc = " Parses an Operational Dataset from a given `otOperationalDatasetTlvs`.\n\n @param[in] aDatasetTlvs A pointer to dataset TLVs.\n @param[out] aDataset A pointer to where the dataset will be placed.\n\n @retval OT_ERROR_NONE Successfully set @p aDataset from @p aDatasetTlvs.\n @retval OT_ERROR_INVALID_ARGS @p aDatasetTlvs is invalid.\n"]
pub fn otDatasetParseTlvs(
aDatasetTlvs: *const otOperationalDatasetTlvs,
aDataset: *mut otOperationalDataset,
) -> otError;
}
extern "C" {
#[doc = " Converts a given Operational Dataset to `otOperationalDatasetTlvs`.\n\n @param[in] aDataset An Operational dataset to convert to TLVs.\n @param[out] aDatasetTlvs A pointer to dataset TLVs to return the result.\n\n @retval OT_ERROR_NONE Successfully converted @p aDataset and updated @p aDatasetTlvs.\n @retval OT_ERROR_INVALID_ARGS @p aDataset is invalid, does not contain active or pending timestamps.\n"]
pub fn otDatasetConvertToTlvs(
aDataset: *const otOperationalDataset,
aDatasetTlvs: *mut otOperationalDatasetTlvs,
) -> otError;
}
extern "C" {
#[doc = " Updates a given Operational Dataset.\n\n @p aDataset contains the fields to be updated and their new value.\n\n @param[in] aDataset Specifies the set of types and values to update.\n @param[in,out] aDatasetTlvs A pointer to dataset TLVs to update.\n\n @retval OT_ERROR_NONE Successfully updated @p aDatasetTlvs.\n @retval OT_ERROR_INVALID_ARGS @p aDataset contains invalid values.\n @retval OT_ERROR_NO_BUFS Not enough space space in @p aDatasetTlvs to apply the update.\n"]
pub fn otDatasetUpdateTlvs(
aDataset: *const otOperationalDataset,
aDatasetTlvs: *mut otOperationalDatasetTlvs,
) -> otError;
}
pub const OT_JOINER_STATE_IDLE: otJoinerState = 0;
pub const OT_JOINER_STATE_DISCOVER: otJoinerState = 1;
pub const OT_JOINER_STATE_CONNECT: otJoinerState = 2;
pub const OT_JOINER_STATE_CONNECTED: otJoinerState = 3;
pub const OT_JOINER_STATE_ENTRUST: otJoinerState = 4;
pub const OT_JOINER_STATE_JOINED: otJoinerState = 5;
#[doc = " Defines the Joiner State.\n"]
pub type otJoinerState = ::std::os::raw::c_uint;
#[doc = " Represents a Joiner Discerner.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otJoinerDiscerner {
#[doc = "< Discerner value (the lowest `mLength` bits specify the discerner)."]
pub mValue: u64,
#[doc = "< Length (number of bits) - must be non-zero and at most `OT_JOINER_MAX_DISCERNER_LENGTH`."]
pub mLength: u8,
}
#[doc = " Pointer is called to notify the completion of a join operation.\n\n @param[in] aError OT_ERROR_NONE if the join process succeeded.\n OT_ERROR_SECURITY if the join process failed due to security credentials.\n OT_ERROR_NOT_FOUND if no joinable network was discovered.\n OT_ERROR_RESPONSE_TIMEOUT if a response timed out.\n @param[in] aContext A pointer to application-specific context.\n"]
pub type otJoinerCallback = ::std::option::Option<
unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
>;
extern "C" {
#[doc = " Enables the Thread Joiner role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPskd A pointer to the PSKd.\n @param[in] aProvisioningUrl A pointer to the Provisioning URL (may be NULL).\n @param[in] aVendorName A pointer to the Vendor Name (may be NULL).\n @param[in] aVendorModel A pointer to the Vendor Model (may be NULL).\n @param[in] aVendorSwVersion A pointer to the Vendor SW Version (may be NULL).\n @param[in] aVendorData A pointer to the Vendor Data (may be NULL).\n @param[in] aCallback A pointer to a function that is called when the join operation completes.\n @param[in] aContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully started the Joiner role.\n @retval OT_ERROR_BUSY The previous attempt is still on-going.\n @retval OT_ERROR_INVALID_ARGS @p aPskd or @p aProvisioningUrl is invalid.\n @retval OT_ERROR_INVALID_STATE The IPv6 stack is not enabled or Thread stack is fully enabled.\n"]
pub fn otJoinerStart(
aInstance: *mut otInstance,
aPskd: *const ::std::os::raw::c_char,
aProvisioningUrl: *const ::std::os::raw::c_char,
aVendorName: *const ::std::os::raw::c_char,
aVendorModel: *const ::std::os::raw::c_char,
aVendorSwVersion: *const ::std::os::raw::c_char,
aVendorData: *const ::std::os::raw::c_char,
aCallback: otJoinerCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Disables the Thread Joiner role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otJoinerStop(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Gets the Joiner State.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The joiner state.\n"]
pub fn otJoinerGetState(aInstance: *mut otInstance) -> otJoinerState;
}
extern "C" {
#[doc = " Gets the Joiner ID.\n\n If a Joiner Discerner is not set, Joiner ID is the first 64 bits of the result of computing SHA-256 over\n factory-assigned IEEE EUI-64. Otherwise the Joiner ID is calculated from the Joiner Discerner value.\n\n The Joiner ID is also used as the device's IEEE 802.15.4 Extended Address during the commissioning process.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns A pointer to the Joiner ID.\n"]
pub fn otJoinerGetId(aInstance: *mut otInstance) -> *const otExtAddress;
}
extern "C" {
#[doc = " Sets the Joiner Discerner.\n\n The Joiner Discerner is used to calculate the Joiner ID during the Thread Commissioning process. For more\n information, refer to #otJoinerGetId.\n @note The Joiner Discerner takes the place of the Joiner EUI-64 during the joiner session of Thread Commissioning.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aDiscerner A pointer to a Joiner Discerner. If NULL clears any previously set discerner.\n\n @retval OT_ERROR_NONE The Joiner Discerner updated successfully.\n @retval OT_ERROR_INVALID_ARGS @p aDiscerner is not valid (specified length is not within valid range).\n @retval OT_ERROR_INVALID_STATE There is an ongoing Joining process so Joiner Discerner could not be changed.\n"]
pub fn otJoinerSetDiscerner(
aInstance: *mut otInstance,
aDiscerner: *mut otJoinerDiscerner,
) -> otError;
}
extern "C" {
#[doc = " Gets the Joiner Discerner. For more information, refer to #otJoinerSetDiscerner.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns A pointer to Joiner Discerner or NULL if none is set.\n"]
pub fn otJoinerGetDiscerner(aInstance: *mut otInstance) -> *const otJoinerDiscerner;
}
extern "C" {
#[doc = " Converts a given joiner state enumeration value to a human-readable string.\n\n @param[in] aState The joiner state.\n\n @returns A human-readable string representation of @p aState.\n"]
pub fn otJoinerStateToString(aState: otJoinerState) -> *const ::std::os::raw::c_char;
}
#[doc = "< Commissioner role is disabled."]
pub const OT_COMMISSIONER_STATE_DISABLED: otCommissionerState = 0;
#[doc = "< Currently petitioning to become a Commissioner."]
pub const OT_COMMISSIONER_STATE_PETITION: otCommissionerState = 1;
#[doc = "< Commissioner role is active."]
pub const OT_COMMISSIONER_STATE_ACTIVE: otCommissionerState = 2;
#[doc = " Defines the Commissioner State.\n"]
pub type otCommissionerState = ::std::os::raw::c_uint;
pub const OT_COMMISSIONER_JOINER_START: otCommissionerJoinerEvent = 0;
pub const OT_COMMISSIONER_JOINER_CONNECTED: otCommissionerJoinerEvent = 1;
pub const OT_COMMISSIONER_JOINER_FINALIZE: otCommissionerJoinerEvent = 2;
pub const OT_COMMISSIONER_JOINER_END: otCommissionerJoinerEvent = 3;
pub const OT_COMMISSIONER_JOINER_REMOVED: otCommissionerJoinerEvent = 4;
#[doc = " Defines a Joiner Event on the Commissioner.\n"]
pub type otCommissionerJoinerEvent = ::std::os::raw::c_uint;
#[doc = " Represents the steering data.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otSteeringData {
#[doc = "< Length of steering data (bytes)"]
pub mLength: u8,
#[doc = "< Byte values"]
pub m8: [u8; 16usize],
}
#[doc = " Represents a Commissioning Dataset.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otCommissioningDataset {
#[doc = "< Border Router RLOC16"]
pub mLocator: u16,
#[doc = "< Commissioner Session Id"]
pub mSessionId: u16,
#[doc = "< Steering Data"]
pub mSteeringData: otSteeringData,
#[doc = "< Joiner UDP Port"]
pub mJoinerUdpPort: u16,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: u8,
}
impl otCommissioningDataset {
#[inline]
pub fn mIsLocatorSet(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsLocatorSet(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn mIsSessionIdSet(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsSessionIdSet(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn mIsSteeringDataSet(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsSteeringDataSet(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn mIsJoinerUdpPortSet(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_mIsJoinerUdpPortSet(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn mHasExtraTlv(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_mHasExtraTlv(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mIsLocatorSet: bool,
mIsSessionIdSet: bool,
mIsSteeringDataSet: bool,
mIsJoinerUdpPortSet: bool,
mHasExtraTlv: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mIsLocatorSet: u8 = unsafe { ::std::mem::transmute(mIsLocatorSet) };
mIsLocatorSet as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let mIsSessionIdSet: u8 = unsafe { ::std::mem::transmute(mIsSessionIdSet) };
mIsSessionIdSet as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mIsSteeringDataSet: u8 = unsafe { ::std::mem::transmute(mIsSteeringDataSet) };
mIsSteeringDataSet as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let mIsJoinerUdpPortSet: u8 = unsafe { ::std::mem::transmute(mIsJoinerUdpPortSet) };
mIsJoinerUdpPortSet as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let mHasExtraTlv: u8 = unsafe { ::std::mem::transmute(mHasExtraTlv) };
mHasExtraTlv as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " Represents a Joiner PSKd.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otJoinerPskd {
#[doc = "< Char string array (must be null terminated - +1 is for null char)."]
pub m8: [::std::os::raw::c_char; 33usize],
}
impl Default for otJoinerPskd {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = "< Accept any Joiner (no EUI64 or Discerner is specified)."]
pub const OT_JOINER_INFO_TYPE_ANY: otJoinerInfoType = 0;
#[doc = "< Joiner EUI-64 is specified (`mSharedId.mEui64` in `otJoinerInfo`)."]
pub const OT_JOINER_INFO_TYPE_EUI64: otJoinerInfoType = 1;
#[doc = "< Joiner Discerner is specified (`mSharedId.mDiscerner` in `otJoinerInfo`)."]
pub const OT_JOINER_INFO_TYPE_DISCERNER: otJoinerInfoType = 2;
#[doc = " Defines a Joiner Info Type.\n"]
pub type otJoinerInfoType = ::std::os::raw::c_uint;
#[doc = " Represents a Joiner Info.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otJoinerInfo {
#[doc = "< Joiner type."]
pub mType: otJoinerInfoType,
#[doc = "< Shared fields"]
pub mSharedId: otJoinerInfo__bindgen_ty_1,
#[doc = "< Joiner PSKd"]
pub mPskd: otJoinerPskd,
#[doc = "< Joiner expiration time in msec"]
pub mExpirationTime: u32,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union otJoinerInfo__bindgen_ty_1 {
#[doc = "< Joiner EUI64 (when `mType` is `OT_JOINER_INFO_TYPE_EUI64`)"]
pub mEui64: otExtAddress,
#[doc = "< Joiner Discerner (when `mType` is `OT_JOINER_INFO_TYPE_DISCERNER`)"]
pub mDiscerner: otJoinerDiscerner,
}
impl Default for otJoinerInfo__bindgen_ty_1 {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl Default for otJoinerInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Pointer is called whenever the commissioner state changes.\n\n @param[in] aState The Commissioner state.\n @param[in] aContext A pointer to application-specific context.\n"]
pub type otCommissionerStateCallback = ::std::option::Option<
unsafe extern "C" fn(aState: otCommissionerState, aContext: *mut ::std::os::raw::c_void),
>;
#[doc = " Pointer is called whenever the joiner state changes.\n\n @param[in] aEvent The joiner event type.\n @param[in] aJoinerInfo A pointer to the Joiner Info.\n @param[in] aJoinerId A pointer to the Joiner ID (if not known, it will be NULL).\n @param[in] aContext A pointer to application-specific context.\n"]
pub type otCommissionerJoinerCallback = ::std::option::Option<
unsafe extern "C" fn(
aEvent: otCommissionerJoinerEvent,
aJoinerInfo: *const otJoinerInfo,
aJoinerId: *const otExtAddress,
aContext: *mut ::std::os::raw::c_void,
),
>;
extern "C" {
#[doc = " Enables the Thread Commissioner role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aStateCallback A pointer to a function that is called when the commissioner state changes.\n @param[in] aJoinerCallback A pointer to a function that is called with a joiner event occurs.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully started the Commissioner service.\n @retval OT_ERROR_ALREADY Commissioner is already started.\n @retval OT_ERROR_INVALID_STATE Device is not currently attached to a network.\n"]
pub fn otCommissionerStart(
aInstance: *mut otInstance,
aStateCallback: otCommissionerStateCallback,
aJoinerCallback: otCommissionerJoinerCallback,
aCallbackContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Disables the Thread Commissioner role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully stopped the Commissioner service.\n @retval OT_ERROR_ALREADY Commissioner is already stopped.\n"]
pub fn otCommissionerStop(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Returns the Commissioner Id.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Commissioner Id.\n"]
pub fn otCommissionerGetId(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Sets the Commissioner Id.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aId A pointer to a string character array. Must be null terminated.\n\n @retval OT_ERROR_NONE Successfully set the Commissioner Id.\n @retval OT_ERROR_INVALID_ARGS Given name is too long.\n @retval OT_ERROR_INVALID_STATE The commissioner is active and id cannot be changed.\n"]
pub fn otCommissionerSetId(
aInstance: *mut otInstance,
aId: *const ::std::os::raw::c_char,
) -> otError;
}
extern "C" {
#[doc = " Adds a Joiner entry.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEui64 A pointer to the Joiner's IEEE EUI-64 or NULL for any Joiner.\n @param[in] aPskd A pointer to the PSKd.\n @param[in] aTimeout A time after which a Joiner is automatically removed, in seconds.\n\n @retval OT_ERROR_NONE Successfully added the Joiner.\n @retval OT_ERROR_NO_BUFS No buffers available to add the Joiner.\n @retval OT_ERROR_INVALID_ARGS @p aEui64 or @p aPskd is invalid.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart().\n"]
pub fn otCommissionerAddJoiner(
aInstance: *mut otInstance,
aEui64: *const otExtAddress,
aPskd: *const ::std::os::raw::c_char,
aTimeout: u32,
) -> otError;
}
extern "C" {
#[doc = " Adds a Joiner entry with a given Joiner Discerner value.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDiscerner A pointer to the Joiner Discerner.\n @param[in] aPskd A pointer to the PSKd.\n @param[in] aTimeout A time after which a Joiner is automatically removed, in seconds.\n\n @retval OT_ERROR_NONE Successfully added the Joiner.\n @retval OT_ERROR_NO_BUFS No buffers available to add the Joiner.\n @retval OT_ERROR_INVALID_ARGS @p aDiscerner or @p aPskd is invalid.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart().\n"]
pub fn otCommissionerAddJoinerWithDiscerner(
aInstance: *mut otInstance,
aDiscerner: *const otJoinerDiscerner,
aPskd: *const ::std::os::raw::c_char,
aTimeout: u32,
) -> otError;
}
extern "C" {
#[doc = " Get joiner info at aIterator position.\n\n @param[in] aInstance A pointer to instance.\n @param[in,out] aIterator A pointer to the Joiner Info iterator context.\n @param[out] aJoiner A reference to Joiner info.\n\n @retval OT_ERROR_NONE Successfully get the Joiner info.\n @retval OT_ERROR_NOT_FOUND Not found next Joiner.\n"]
pub fn otCommissionerGetNextJoinerInfo(
aInstance: *mut otInstance,
aIterator: *mut u16,
aJoiner: *mut otJoinerInfo,
) -> otError;
}
extern "C" {
#[doc = " Removes a Joiner entry.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEui64 A pointer to the Joiner's IEEE EUI-64 or NULL for any Joiner.\n\n @retval OT_ERROR_NONE Successfully removed the Joiner.\n @retval OT_ERROR_NOT_FOUND The Joiner specified by @p aEui64 was not found.\n @retval OT_ERROR_INVALID_ARGS @p aEui64 is invalid.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart().\n"]
pub fn otCommissionerRemoveJoiner(
aInstance: *mut otInstance,
aEui64: *const otExtAddress,
) -> otError;
}
extern "C" {
#[doc = " Removes a Joiner entry.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDiscerner A pointer to the Joiner Discerner.\n\n @retval OT_ERROR_NONE Successfully removed the Joiner.\n @retval OT_ERROR_NOT_FOUND The Joiner specified by @p aEui64 was not found.\n @retval OT_ERROR_INVALID_ARGS @p aDiscerner is invalid.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart().\n"]
pub fn otCommissionerRemoveJoinerWithDiscerner(
aInstance: *mut otInstance,
aDiscerner: *const otJoinerDiscerner,
) -> otError;
}
extern "C" {
#[doc = " Gets the Provisioning URL.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the URL string.\n"]
pub fn otCommissionerGetProvisioningUrl(
aInstance: *mut otInstance,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Sets the Provisioning URL.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aProvisioningUrl A pointer to the Provisioning URL (may be NULL to set as empty string).\n\n @retval OT_ERROR_NONE Successfully set the Provisioning URL.\n @retval OT_ERROR_INVALID_ARGS @p aProvisioningUrl is invalid (too long).\n"]
pub fn otCommissionerSetProvisioningUrl(
aInstance: *mut otInstance,
aProvisioningUrl: *const ::std::os::raw::c_char,
) -> otError;
}
extern "C" {
#[doc = " Sends an Announce Begin message.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask The channel mask value.\n @param[in] aCount The number of Announcement messages per channel.\n @param[in] aPeriod The time between two successive MLE Announce transmissions (in milliseconds).\n @param[in] aAddress A pointer to the IPv6 destination.\n\n @retval OT_ERROR_NONE Successfully enqueued the Announce Begin message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers to generate an Announce Begin message.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart().\n"]
pub fn otCommissionerAnnounceBegin(
aInstance: *mut otInstance,
aChannelMask: u32,
aCount: u8,
aPeriod: u16,
aAddress: *const otIp6Address,
) -> otError;
}
#[doc = " Pointer is called when the Commissioner receives an Energy Report.\n\n @param[in] aChannelMask The channel mask value.\n @param[in] aEnergyList A pointer to the energy measurement list.\n @param[in] aEnergyListLength Number of entries in @p aEnergyListLength.\n @param[in] aContext A pointer to application-specific context.\n"]
pub type otCommissionerEnergyReportCallback = ::std::option::Option<
unsafe extern "C" fn(
aChannelMask: u32,
aEnergyList: *const u8,
aEnergyListLength: u8,
aContext: *mut ::std::os::raw::c_void,
),
>;
extern "C" {
#[doc = " Sends an Energy Scan Query message.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask The channel mask value.\n @param[in] aCount The number of energy measurements per channel.\n @param[in] aPeriod The time between energy measurements (milliseconds).\n @param[in] aScanDuration The scan duration for each energy measurement (milliseconds).\n @param[in] aAddress A pointer to the IPv6 destination.\n @param[in] aCallback A pointer to a function called on receiving an Energy Report message.\n @param[in] aContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully enqueued the Energy Scan Query message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers to generate an Energy Scan Query message.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart().\n"]
pub fn otCommissionerEnergyScan(
aInstance: *mut otInstance,
aChannelMask: u32,
aCount: u8,
aPeriod: u16,
aScanDuration: u16,
aAddress: *const otIp6Address,
aCallback: otCommissionerEnergyReportCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
#[doc = " Pointer is called when the Commissioner receives a PAN ID Conflict message.\n\n @param[in] aPanId The PAN ID value.\n @param[in] aChannelMask The channel mask value.\n @param[in] aContext A pointer to application-specific context.\n"]
pub type otCommissionerPanIdConflictCallback = ::std::option::Option<
unsafe extern "C" fn(aPanId: u16, aChannelMask: u32, aContext: *mut ::std::os::raw::c_void),
>;
extern "C" {
#[doc = " Sends a PAN ID Query message.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPanId The PAN ID to query.\n @param[in] aChannelMask The channel mask value.\n @param[in] aAddress A pointer to the IPv6 destination.\n @param[in] aCallback A pointer to a function called on receiving a PAN ID Conflict message.\n @param[in] aContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully enqueued the PAN ID Query message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers to generate a PAN ID Query message.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n\n @note Only use this after successfully starting the Commissioner role with otCommissionerStart().\n"]
pub fn otCommissionerPanIdQuery(
aInstance: *mut otInstance,
aPanId: u16,
aChannelMask: u32,
aAddress: *const otIp6Address,
aCallback: otCommissionerPanIdConflictCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Sends MGMT_COMMISSIONER_GET.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aTlvs A pointer to TLVs.\n @param[in] aLength The length of TLVs.\n\n @retval OT_ERROR_NONE Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to send.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n"]
pub fn otCommissionerSendMgmtGet(
aInstance: *mut otInstance,
aTlvs: *const u8,
aLength: u8,
) -> otError;
}
extern "C" {
#[doc = " Sends MGMT_COMMISSIONER_SET.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDataset A pointer to commissioning dataset.\n @param[in] aTlvs A pointer to TLVs.\n @param[in] aLength The length of TLVs.\n\n @retval OT_ERROR_NONE Successfully send the meshcop dataset command.\n @retval OT_ERROR_NO_BUFS Insufficient buffer space to send.\n @retval OT_ERROR_INVALID_STATE The commissioner is not active.\n"]
pub fn otCommissionerSendMgmtSet(
aInstance: *mut otInstance,
aDataset: *const otCommissioningDataset,
aTlvs: *const u8,
aLength: u8,
) -> otError;
}
extern "C" {
#[doc = " Returns the Commissioner Session ID.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current commissioner session id.\n"]
pub fn otCommissionerGetSessionId(aInstance: *mut otInstance) -> u16;
}
extern "C" {
#[doc = " Returns the Commissioner State.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_COMMISSIONER_STATE_DISABLED Commissioner disabled.\n @retval OT_COMMISSIONER_STATE_PETITION Becoming the commissioner.\n @retval OT_COMMISSIONER_STATE_ACTIVE Commissioner enabled.\n"]
pub fn otCommissionerGetState(aInstance: *mut otInstance) -> otCommissionerState;
}
pub type otNetworkDataIterator = u32;
#[doc = " Represents a Border Router configuration."]
#[repr(C)]
#[repr(align(4))]
#[derive(Copy, Clone)]
pub struct otBorderRouterConfig {
#[doc = "< The IPv6 prefix."]
pub mPrefix: otIp6Prefix,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
#[doc = "< The border router's RLOC16 (value ignored on config add)."]
pub mRloc16: u16,
}
impl Default for otBorderRouterConfig {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl otBorderRouterConfig {
#[inline]
pub fn mPreference(&self) -> ::std::os::raw::c_int {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
}
#[inline]
pub fn set_mPreference(&mut self, val: ::std::os::raw::c_int) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn mPreferred(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mPreferred(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn mSlaac(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_mSlaac(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn mDhcp(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_mDhcp(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn mConfigure(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
}
#[inline]
pub fn set_mConfigure(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn mDefaultRoute(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
}
#[inline]
pub fn set_mDefaultRoute(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(6usize, 1u8, val as u64)
}
}
#[inline]
pub fn mOnMesh(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
}
#[inline]
pub fn set_mOnMesh(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(7usize, 1u8, val as u64)
}
}
#[inline]
pub fn mStable(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
}
#[inline]
pub fn set_mStable(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(8usize, 1u8, val as u64)
}
}
#[inline]
pub fn mNdDns(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
}
#[inline]
pub fn set_mNdDns(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(9usize, 1u8, val as u64)
}
}
#[inline]
pub fn mDp(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8) }
}
#[inline]
pub fn set_mDp(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(10usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mPreference: ::std::os::raw::c_int,
mPreferred: bool,
mSlaac: bool,
mDhcp: bool,
mConfigure: bool,
mDefaultRoute: bool,
mOnMesh: bool,
mStable: bool,
mNdDns: bool,
mDp: bool,
) -> __BindgenBitfieldUnit<[u8; 2usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let mPreference: u32 = unsafe { ::std::mem::transmute(mPreference) };
mPreference as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
mPreferred as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let mSlaac: u8 = unsafe { ::std::mem::transmute(mSlaac) };
mSlaac as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let mDhcp: u8 = unsafe { ::std::mem::transmute(mDhcp) };
mDhcp as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let mConfigure: u8 = unsafe { ::std::mem::transmute(mConfigure) };
mConfigure as u64
});
__bindgen_bitfield_unit.set(6usize, 1u8, {
let mDefaultRoute: u8 = unsafe { ::std::mem::transmute(mDefaultRoute) };
mDefaultRoute as u64
});
__bindgen_bitfield_unit.set(7usize, 1u8, {
let mOnMesh: u8 = unsafe { ::std::mem::transmute(mOnMesh) };
mOnMesh as u64
});
__bindgen_bitfield_unit.set(8usize, 1u8, {
let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
mStable as u64
});
__bindgen_bitfield_unit.set(9usize, 1u8, {
let mNdDns: u8 = unsafe { ::std::mem::transmute(mNdDns) };
mNdDns as u64
});
__bindgen_bitfield_unit.set(10usize, 1u8, {
let mDp: u8 = unsafe { ::std::mem::transmute(mDp) };
mDp as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " Represents 6LoWPAN Context ID information associated with a prefix in Network Data.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otLowpanContextInfo {
#[doc = "< The 6LoWPAN Context ID."]
pub mContextId: u8,
#[doc = "< The compress flag."]
pub mCompressFlag: bool,
#[doc = "< The associated IPv6 prefix."]
pub mPrefix: otIp6Prefix,
}
impl Default for otLowpanContextInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Represents an External Route configuration.\n"]
#[repr(C)]
#[repr(align(4))]
#[derive(Copy, Clone)]
pub struct otExternalRouteConfig {
#[doc = "< The IPv6 prefix."]
pub mPrefix: otIp6Prefix,
#[doc = "< The border router's RLOC16 (value ignored on config add)."]
pub mRloc16: u16,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
pub __bindgen_padding_0: [u8; 3usize],
}
impl Default for otExternalRouteConfig {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl otExternalRouteConfig {
#[inline]
pub fn mPreference(&self) -> ::std::os::raw::c_int {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
}
#[inline]
pub fn set_mPreference(&mut self, val: ::std::os::raw::c_int) {
unsafe {
let val: u32 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 2u8, val as u64)
}
}
#[inline]
pub fn mNat64(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mNat64(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn mStable(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
}
#[inline]
pub fn set_mStable(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(3usize, 1u8, val as u64)
}
}
#[inline]
pub fn mNextHopIsThisDevice(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
}
#[inline]
pub fn set_mNextHopIsThisDevice(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(4usize, 1u8, val as u64)
}
}
#[inline]
pub fn mAdvPio(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
}
#[inline]
pub fn set_mAdvPio(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(5usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mPreference: ::std::os::raw::c_int,
mNat64: bool,
mStable: bool,
mNextHopIsThisDevice: bool,
mAdvPio: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 2u8, {
let mPreference: u32 = unsafe { ::std::mem::transmute(mPreference) };
mPreference as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mNat64: u8 = unsafe { ::std::mem::transmute(mNat64) };
mNat64 as u64
});
__bindgen_bitfield_unit.set(3usize, 1u8, {
let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
mStable as u64
});
__bindgen_bitfield_unit.set(4usize, 1u8, {
let mNextHopIsThisDevice: u8 = unsafe { ::std::mem::transmute(mNextHopIsThisDevice) };
mNextHopIsThisDevice as u64
});
__bindgen_bitfield_unit.set(5usize, 1u8, {
let mAdvPio: u8 = unsafe { ::std::mem::transmute(mAdvPio) };
mAdvPio as u64
});
__bindgen_bitfield_unit
}
}
#[doc = "< Low route preference."]
pub const OT_ROUTE_PREFERENCE_LOW: otRoutePreference = -1;
#[doc = "< Medium route preference."]
pub const OT_ROUTE_PREFERENCE_MED: otRoutePreference = 0;
#[doc = "< High route preference."]
pub const OT_ROUTE_PREFERENCE_HIGH: otRoutePreference = 1;
#[doc = " Defines valid values for `mPreference` in `otExternalRouteConfig` and `otBorderRouterConfig`.\n"]
pub type otRoutePreference = ::std::os::raw::c_int;
#[doc = " Represents a Server configuration.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otServerConfig {
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
#[doc = "< Length of server data."]
pub mServerDataLength: u8,
#[doc = "< Server data bytes."]
pub mServerData: [u8; 248usize],
#[doc = "< The Server RLOC16."]
pub mRloc16: u16,
}
impl Default for otServerConfig {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl otServerConfig {
#[inline]
pub fn mStable(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mStable(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(mStable: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
mStable as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " Represents a Service configuration.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otServiceConfig {
#[doc = "< Service ID (when iterating over the Network Data)."]
pub mServiceId: u8,
#[doc = "< IANA Enterprise Number."]
pub mEnterpriseNumber: u32,
#[doc = "< Length of service data."]
pub mServiceDataLength: u8,
#[doc = "< Service data bytes."]
pub mServiceData: [u8; 252usize],
#[doc = "< The Server configuration."]
pub mServerConfig: otServerConfig,
}
impl Default for otServiceConfig {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
#[doc = " Provide full or stable copy of the Partition's Thread Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aStable TRUE when copying the stable version, FALSE when copying the full version.\n @param[out] aData A pointer to the data buffer.\n @param[in,out] aDataLength On entry, size of the data buffer pointed to by @p aData.\n On exit, number of copied bytes.\n\n @retval OT_ERROR_NONE Successfully copied the Thread Network Data into @p aData and updated @p aDataLength.\n @retval OT_ERROR_NO_BUFS Not enough space in @p aData to fully copy the Thread Network Data.\n"]
pub fn otNetDataGet(
aInstance: *mut otInstance,
aStable: bool,
aData: *mut u8,
aDataLength: *mut u8,
) -> otError;
}
extern "C" {
#[doc = " Get the current length (number of bytes) of Partition's Thread Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @return The length of the Network Data.\n"]
pub fn otNetDataGetLength(aInstance: *mut otInstance) -> u8;
}
extern "C" {
#[doc = " Get the maximum observed length of the Thread Network Data since OT stack initialization or since the last call to\n `otNetDataResetMaxLength()`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @return The maximum length of the Network Data (high water mark for Network Data length).\n"]
pub fn otNetDataGetMaxLength(aInstance: *mut otInstance) -> u8;
}
extern "C" {
#[doc = " Reset the tracked maximum length of the Thread Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @sa otNetDataGetMaxLength\n"]
pub fn otNetDataResetMaxLength(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Get the next On Mesh Prefix in the partition's Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the Network Data iterator context. To get the first on-mesh entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out] aConfig A pointer to where the On Mesh Prefix information will be placed.\n\n @retval OT_ERROR_NONE Successfully found the next On Mesh prefix.\n @retval OT_ERROR_NOT_FOUND No subsequent On Mesh prefix exists in the Thread Network Data.\n"]
pub fn otNetDataGetNextOnMeshPrefix(
aInstance: *mut otInstance,
aIterator: *mut otNetworkDataIterator,
aConfig: *mut otBorderRouterConfig,
) -> otError;
}
extern "C" {
#[doc = " Get the next external route in the partition's Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the Network Data iterator context. To get the first external route entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out] aConfig A pointer to where the External Route information will be placed.\n\n @retval OT_ERROR_NONE Successfully found the next External Route.\n @retval OT_ERROR_NOT_FOUND No subsequent external route entry exists in the Thread Network Data.\n"]
pub fn otNetDataGetNextRoute(
aInstance: *mut otInstance,
aIterator: *mut otNetworkDataIterator,
aConfig: *mut otExternalRouteConfig,
) -> otError;
}
extern "C" {
#[doc = " Get the next service in the partition's Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the Network Data iterator context. To get the first service entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out] aConfig A pointer to where the service information will be placed.\n\n @retval OT_ERROR_NONE Successfully found the next service.\n @retval OT_ERROR_NOT_FOUND No subsequent service exists in the partition's Network Data.\n"]
pub fn otNetDataGetNextService(
aInstance: *mut otInstance,
aIterator: *mut otNetworkDataIterator,
aConfig: *mut otServiceConfig,
) -> otError;
}
extern "C" {
#[doc = " Get the next 6LoWPAN Context ID info in the partition's Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the Network Data iterator. To get the first service entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out] aContextInfo A pointer to where the retrieved 6LoWPAN Context ID information will be placed.\n\n @retval OT_ERROR_NONE Successfully found the next 6LoWPAN Context ID info.\n @retval OT_ERROR_NOT_FOUND No subsequent 6LoWPAN Context info exists in the partition's Network Data.\n"]
pub fn otNetDataGetNextLowpanContextInfo(
aInstance: *mut otInstance,
aIterator: *mut otNetworkDataIterator,
aContextInfo: *mut otLowpanContextInfo,
) -> otError;
}
extern "C" {
#[doc = " Gets the Commissioning Dataset from the partition's Network Data.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[out] aDataset A pointer to a `otCommissioningDataset` to populate.\n"]
pub fn otNetDataGetCommissioningDataset(
aInstance: *mut otInstance,
aDataset: *mut otCommissioningDataset,
);
}
extern "C" {
#[doc = " Get the Network Data Version.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Network Data Version.\n"]
pub fn otNetDataGetVersion(aInstance: *mut otInstance) -> u8;
}
extern "C" {
#[doc = " Get the Stable Network Data Version.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Stable Network Data Version.\n"]
pub fn otNetDataGetStableVersion(aInstance: *mut otInstance) -> u8;
}
extern "C" {
#[doc = " Check if the steering data includes a Joiner.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEui64 A pointer to the Joiner's IEEE EUI-64.\n\n @retval OT_ERROR_NONE @p aEui64 is included in the steering data.\n @retval OT_ERROR_INVALID_STATE No steering data present.\n @retval OT_ERROR_NOT_FOUND @p aEui64 is not included in the steering data.\n"]
pub fn otNetDataSteeringDataCheckJoiner(
aInstance: *mut otInstance,
aEui64: *const otExtAddress,
) -> otError;
}
extern "C" {
#[doc = " Check if the steering data includes a Joiner with a given discerner value.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDiscerner A pointer to the Joiner Discerner.\n\n @retval OT_ERROR_NONE @p aDiscerner is included in the steering data.\n @retval OT_ERROR_INVALID_STATE No steering data present.\n @retval OT_ERROR_NOT_FOUND @p aDiscerner is not included in the steering data.\n"]
pub fn otNetDataSteeringDataCheckJoinerWithDiscerner(
aInstance: *mut otInstance,
aDiscerner: *const otJoinerDiscerner,
) -> otError;
}
extern "C" {
#[doc = " Check whether a given Prefix can act as a valid OMR prefix and also the Leader's Network Data contains this prefix.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPrefix A pointer to the IPv6 prefix.\n\n @returns Whether @p aPrefix is a valid OMR prefix and Leader's Network Data contains the OMR prefix @p aPrefix.\n\n @note This API is only available when `OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE` is used.\n"]
pub fn otNetDataContainsOmrPrefix(
aInstance: *mut otInstance,
aPrefix: *const otIp6Prefix,
) -> bool;
}
#[doc = "< Backbone function is disabled."]
pub const OT_BACKBONE_ROUTER_STATE_DISABLED: otBackboneRouterState = 0;
#[doc = "< Secondary Backbone Router."]
pub const OT_BACKBONE_ROUTER_STATE_SECONDARY: otBackboneRouterState = 1;
#[doc = "< The Primary Backbone Router."]
pub const OT_BACKBONE_ROUTER_STATE_PRIMARY: otBackboneRouterState = 2;
#[doc = " Represents the Backbone Router Status.\n"]
pub type otBackboneRouterState = ::std::os::raw::c_uint;
extern "C" {
#[doc = " Enables or disables Backbone functionality.\n\n If enabled, a Server Data Request message `SRV_DATA.ntf` is triggered for the attached\n device if there is no Backbone Router Service in the Thread Network Data.\n\n If disabled, `SRV_DATA.ntf` is triggered if the Backbone Router is in the Primary state.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnable TRUE to enable Backbone functionality, FALSE otherwise.\n\n @sa otBackboneRouterGetState\n @sa otBackboneRouterGetConfig\n @sa otBackboneRouterSetConfig\n @sa otBackboneRouterRegister\n"]
pub fn otBackboneRouterSetEnabled(aInstance: *mut otInstance, aEnable: bool);
}
extern "C" {
#[doc = " Gets the Backbone Router #otBackboneRouterState.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_BACKBONE_ROUTER_STATE_DISABLED Backbone functionality is disabled.\n @retval OT_BACKBONE_ROUTER_STATE_SECONDARY Secondary Backbone Router.\n @retval OT_BACKBONE_ROUTER_STATE_PRIMARY The Primary Backbone Router.\n\n @sa otBackboneRouterSetEnabled\n @sa otBackboneRouterGetConfig\n @sa otBackboneRouterSetConfig\n @sa otBackboneRouterRegister\n"]
pub fn otBackboneRouterGetState(aInstance: *mut otInstance) -> otBackboneRouterState;
}
extern "C" {
#[doc = " Gets the local Backbone Router configuration.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aConfig A pointer where to put local Backbone Router configuration.\n\n\n @sa otBackboneRouterSetEnabled\n @sa otBackboneRouterGetState\n @sa otBackboneRouterSetConfig\n @sa otBackboneRouterRegister\n"]
pub fn otBackboneRouterGetConfig(
aInstance: *mut otInstance,
aConfig: *mut otBackboneRouterConfig,
);
}
extern "C" {
#[doc = " Sets the local Backbone Router configuration #otBackboneRouterConfig.\n\n A Server Data Request message `SRV_DATA.ntf` is initiated automatically if BBR Dataset changes for Primary\n Backbone Router.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aConfig A pointer to the Backbone Router configuration to take effect.\n\n @retval OT_ERROR_NONE Successfully updated configuration.\n @retval OT_ERROR_INVALID_ARGS The configuration in @p aConfig is invalid.\n\n @sa otBackboneRouterSetEnabled\n @sa otBackboneRouterGetState\n @sa otBackboneRouterGetConfig\n @sa otBackboneRouterRegister\n"]
pub fn otBackboneRouterSetConfig(
aInstance: *mut otInstance,
aConfig: *const otBackboneRouterConfig,
) -> otError;
}
extern "C" {
#[doc = " Explicitly registers local Backbone Router configuration.\n\n A Server Data Request message `SRV_DATA.ntf` is triggered for the attached device.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NO_BUFS Insufficient space to add the Backbone Router service.\n @retval OT_ERROR_NONE Successfully queued a Server Data Request message for delivery.\n\n @sa otBackboneRouterSetEnabled\n @sa otBackboneRouterGetState\n @sa otBackboneRouterGetConfig\n @sa otBackboneRouterSetConfig\n"]
pub fn otBackboneRouterRegister(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Returns the Backbone Router registration jitter value.\n\n @returns The Backbone Router registration jitter value.\n\n @sa otBackboneRouterSetRegistrationJitter\n"]
pub fn otBackboneRouterGetRegistrationJitter(aInstance: *mut otInstance) -> u8;
}
extern "C" {
#[doc = " Sets the Backbone Router registration jitter value.\n\n @param[in] aJitter the Backbone Router registration jitter value to set.\n\n @sa otBackboneRouterGetRegistrationJitter\n"]
pub fn otBackboneRouterSetRegistrationJitter(aInstance: *mut otInstance, aJitter: u8);
}
extern "C" {
#[doc = " Gets the local Domain Prefix configuration.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aConfig A pointer to the Domain Prefix configuration.\n\n @retval OT_ERROR_NONE Successfully got the Domain Prefix configuration.\n @retval OT_ERROR_NOT_FOUND No Domain Prefix was configured.\n"]
pub fn otBackboneRouterGetDomainPrefix(
aInstance: *mut otInstance,
aConfig: *mut otBorderRouterConfig,
) -> otError;
}
extern "C" {
#[doc = " Configures response status for next DUA registration.\n\n Note: available only when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n Only used for test and certification.\n\n TODO: (DUA) support coap error code and corresponding process for certification purpose.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMlIid A pointer to the Mesh Local IID. If NULL, respond with @p aStatus for any\n coming DUA.req, otherwise only respond the one with matching @p aMlIid.\n @param[in] aStatus The status to respond.\n\n"]
pub fn otBackboneRouterConfigNextDuaRegistrationResponse(
aInstance: *mut otInstance,
aMlIid: *const otIp6InterfaceIdentifier,
aStatus: u8,
);
}
extern "C" {
#[doc = " Configures the response status for the next Multicast Listener Registration.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE`,\n `OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE`, and\n `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` are enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aStatus The status to respond.\n"]
pub fn otBackboneRouterConfigNextMulticastListenerRegistrationResponse(
aInstance: *mut otInstance,
aStatus: u8,
);
}
#[doc = "< Multicast Listener was added."]
pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ADDED: otBackboneRouterMulticastListenerEvent = 0;
#[doc = "< Multicast Listener was removed or expired."]
pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_REMOVED: otBackboneRouterMulticastListenerEvent = 1;
#[doc = " Represents the Multicast Listener events.\n"]
pub type otBackboneRouterMulticastListenerEvent = ::std::os::raw::c_uint;
#[doc = " Pointer is called whenever the Multicast Listeners change.\n\n @param[in] aContext The user context pointer.\n @param[in] aEvent The Multicast Listener event.\n @param[in] aAddress The IPv6 multicast address of the Multicast Listener.\n"]
pub type otBackboneRouterMulticastListenerCallback = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aEvent: otBackboneRouterMulticastListenerEvent,
aAddress: *const otIp6Address,
),
>;
extern "C" {
#[doc = " Sets the Backbone Router Multicast Listener callback.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to the Multicast Listener callback.\n @param[in] aContext A user context pointer.\n"]
pub fn otBackboneRouterSetMulticastListenerCallback(
aInstance: *mut otInstance,
aCallback: otBackboneRouterMulticastListenerCallback,
aContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Clears the Multicast Listeners.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE`,\n `OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE`, and\n `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` are enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @sa otBackboneRouterMulticastListenerAdd\n @sa otBackboneRouterMulticastListenerGetNext\n"]
pub fn otBackboneRouterMulticastListenerClear(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Adds a Multicast Listener with a timeout value, in seconds.\n\n Pass `0` to use the default MLR timeout.\n\n Available when `OPENTHREAD_CONFIG_BACKBONE_ROUTER_ENABLE`,\n `OPENTHREAD_CONFIG_BACKBONE_ROUTER_MULTICAST_ROUTING_ENABLE`, and\n `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` are enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aAddress The Multicast Listener address.\n @param[in] aTimeout The timeout (in seconds) of the Multicast Listener, or 0 to use the default MLR timeout.\n\n @retval OT_ERROR_NONE If the Multicast Listener was successfully added.\n @retval OT_ERROR_INVALID_ARGS If the Multicast Listener address was invalid.\n @retval OT_ERROR_NO_BUFS No space available to save the Multicast Listener.\n\n @sa otBackboneRouterMulticastListenerClear\n @sa otBackboneRouterMulticastListenerGetNext\n"]
pub fn otBackboneRouterMulticastListenerAdd(
aInstance: *mut otInstance,
aAddress: *const otIp6Address,
aTimeout: u32,
) -> otError;
}
pub type otBackboneRouterMulticastListenerIterator = u16;
#[doc = " Represents a Backbone Router Multicast Listener info.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otBackboneRouterMulticastListenerInfo {
pub mAddress: otIp6Address,
pub mTimeout: u32,
}
impl Default for otBackboneRouterMulticastListenerInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
#[doc = " Gets the next Multicast Listener info (using an iterator).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the iterator. On success the iterator will be updated to point to next\n Multicast Listener. To get the first entry the iterator should be set to\n OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ITERATOR_INIT.\n @param[out] aListenerInfo A pointer to an `otBackboneRouterMulticastListenerInfo` where information of next\n Multicast Listener is placed (on success).\n\n @retval OT_ERROR_NONE Successfully found the next Multicast Listener info (@p aListenerInfo was successfully\n updated).\n @retval OT_ERROR_NOT_FOUND No subsequent Multicast Listener info was found.\n\n @sa otBackboneRouterMulticastListenerClear\n @sa otBackboneRouterMulticastListenerAdd\n"]
pub fn otBackboneRouterMulticastListenerGetNext(
aInstance: *mut otInstance,
aIterator: *mut otBackboneRouterMulticastListenerIterator,
aListenerInfo: *mut otBackboneRouterMulticastListenerInfo,
) -> otError;
}
#[doc = "< ND Proxy was added."]
pub const OT_BACKBONE_ROUTER_NDPROXY_ADDED: otBackboneRouterNdProxyEvent = 0;
#[doc = "< ND Proxy was removed."]
pub const OT_BACKBONE_ROUTER_NDPROXY_REMOVED: otBackboneRouterNdProxyEvent = 1;
#[doc = "< ND Proxy was renewed."]
pub const OT_BACKBONE_ROUTER_NDPROXY_RENEWED: otBackboneRouterNdProxyEvent = 2;
#[doc = "< All ND Proxies were cleared."]
pub const OT_BACKBONE_ROUTER_NDPROXY_CLEARED: otBackboneRouterNdProxyEvent = 3;
#[doc = " Represents the ND Proxy events.\n"]
pub type otBackboneRouterNdProxyEvent = ::std::os::raw::c_uint;
#[doc = " Pointer is called whenever the Nd Proxy changed.\n\n @param[in] aContext The user context pointer.\n @param[in] aEvent The ND Proxy event.\n @param[in] aDua The Domain Unicast Address of the ND Proxy, or `nullptr` if @p aEvent is\n `OT_BACKBONE_ROUTER_NDPROXY_CLEARED`.\n"]
pub type otBackboneRouterNdProxyCallback = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aEvent: otBackboneRouterNdProxyEvent,
aDua: *const otIp6Address,
),
>;
extern "C" {
#[doc = " Sets the Backbone Router ND Proxy callback.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to the ND Proxy callback.\n @param[in] aContext A user context pointer.\n"]
pub fn otBackboneRouterSetNdProxyCallback(
aInstance: *mut otInstance,
aCallback: otBackboneRouterNdProxyCallback,
aContext: *mut ::std::os::raw::c_void,
);
}
#[doc = " Represents the Backbone Router ND Proxy info.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otBackboneRouterNdProxyInfo {
#[doc = "< Mesh-local IID"]
pub mMeshLocalIid: *mut otIp6InterfaceIdentifier,
#[doc = "< Time since last transaction (Seconds)"]
pub mTimeSinceLastTransaction: u32,
#[doc = "< RLOC16"]
pub mRloc16: u16,
}
impl Default for otBackboneRouterNdProxyInfo {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
#[doc = " Gets the Backbone Router ND Proxy info.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDua The Domain Unicast Address.\n @param[out] aNdProxyInfo A pointer to the ND Proxy info.\n\n @retval OT_ERROR_NONE Successfully got the ND Proxy info.\n @retval OT_ERROR_NOT_FOUND Failed to find the Domain Unicast Address in the ND Proxy table.\n"]
pub fn otBackboneRouterGetNdProxyInfo(
aInstance: *mut otInstance,
aDua: *const otIp6Address,
aNdProxyInfo: *mut otBackboneRouterNdProxyInfo,
) -> otError;
}
#[doc = "< Domain Prefix was added."]
pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_ADDED: otBackboneRouterDomainPrefixEvent = 0;
#[doc = "< Domain Prefix was removed."]
pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_REMOVED: otBackboneRouterDomainPrefixEvent = 1;
#[doc = "< Domain Prefix was changed."]
pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_CHANGED: otBackboneRouterDomainPrefixEvent = 2;
#[doc = " Represents the Domain Prefix events.\n"]
pub type otBackboneRouterDomainPrefixEvent = ::std::os::raw::c_uint;
#[doc = " Pointer is called whenever the Domain Prefix changed.\n\n @param[in] aContext The user context pointer.\n @param[in] aEvent The Domain Prefix event.\n @param[in] aDomainPrefix The new Domain Prefix if added or changed, nullptr otherwise.\n"]
pub type otBackboneRouterDomainPrefixCallback = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aEvent: otBackboneRouterDomainPrefixEvent,
aDomainPrefix: *const otIp6Prefix,
),
>;
extern "C" {
#[doc = " Sets the Backbone Router Domain Prefix callback.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to the Domain Prefix callback.\n @param[in] aContext A user context pointer.\n"]
pub fn otBackboneRouterSetDomainPrefixCallback(
aInstance: *mut otInstance,
aCallback: otBackboneRouterDomainPrefixCallback,
aContext: *mut ::std::os::raw::c_void,
);
}
#[doc = " @struct otBorderAgentId\n\n Represents a Border Agent ID.\n"]
#[repr(C, packed)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otBorderAgentId {
pub mId: [u8; 16usize],
}
#[doc = "< Border agent role is disabled."]
pub const OT_BORDER_AGENT_STATE_STOPPED: otBorderAgentState = 0;
#[doc = "< Border agent is started."]
pub const OT_BORDER_AGENT_STATE_STARTED: otBorderAgentState = 1;
#[doc = "< Border agent is connected with external commissioner."]
pub const OT_BORDER_AGENT_STATE_ACTIVE: otBorderAgentState = 2;
#[doc = " Defines the Border Agent state.\n"]
pub type otBorderAgentState = ::std::os::raw::c_uint;
extern "C" {
#[doc = " Gets the #otBorderAgentState of the Thread Border Agent role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current #otBorderAgentState of the Border Agent.\n"]
pub fn otBorderAgentGetState(aInstance: *mut otInstance) -> otBorderAgentState;
}
extern "C" {
#[doc = " Gets the UDP port of the Thread Border Agent service.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns UDP port of the Border Agent.\n"]
pub fn otBorderAgentGetUdpPort(aInstance: *mut otInstance) -> u16;
}
extern "C" {
#[doc = " Gets the randomly generated Border Agent ID.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_ID_ENABLE`.\n\n The ID is saved in persistent storage and survives reboots. The typical use case of the ID is to\n be published in the MeshCoP mDNS service as the `id` TXT value for the client to identify this\n Border Router/Agent device.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aId A pointer to buffer to receive the ID.\n\n @retval OT_ERROR_NONE If successfully retrieved the Border Agent ID.\n @retval ... If failed to retrieve the Border Agent ID.\n\n @sa otBorderAgentSetId\n"]
pub fn otBorderAgentGetId(aInstance: *mut otInstance, aId: *mut otBorderAgentId) -> otError;
}
extern "C" {
#[doc = " Sets the Border Agent ID.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_ID_ENABLE`.\n\n The Border Agent ID will be saved in persistent storage and survive reboots. It's required to\n set the ID only once after factory reset. If the ID has never been set by calling this function,\n a random ID will be generated and returned when `otBorderAgentGetId` is called.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aId A pointer to the Border Agent ID.\n\n @retval OT_ERROR_NONE If successfully set the Border Agent ID.\n @retval ... If failed to set the Border Agent ID.\n\n @sa otBorderAgentGetId\n"]
pub fn otBorderAgentSetId(aInstance: *mut otInstance, aId: *const otBorderAgentId) -> otError;
}
extern "C" {
#[doc = " Sets the ephemeral key for a given timeout duration.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n The ephemeral key can be set when the Border Agent is already running and is not currently connected to any external\n commissioner (i.e., it is in `OT_BORDER_AGENT_STATE_STARTED` state). Otherwise `OT_ERROR_INVALID_STATE` is returned.\n\n The given @p aKeyString is directly used as the ephemeral PSK (excluding the trailing null `\\0` character ).\n The @p aKeyString length must be between `OT_BORDER_AGENT_MIN_EPHEMERAL_KEY_LENGTH` and\n `OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_LENGTH`, inclusive.\n\n Setting the ephemeral key again before a previously set key has timed out will replace the previously set key and\n reset the timeout.\n\n While the timeout interval is in effect, the ephemeral key can be used only once by an external commissioner to\n connect. Once the commissioner disconnects, the ephemeral key is cleared, and the Border Agent reverts to using\n PSKc.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aKeyString The ephemeral key string (used as PSK excluding the trailing null `\\0` character).\n @param[in] aTimeout The timeout duration in milliseconds to use the ephemeral key.\n If zero, the default `OT_BORDER_AGENT_DEFAULT_EPHEMERAL_KEY_TIMEOUT` value will be used.\n If the given timeout value is larger than `OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT`, the\n max value `OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT` will be used instead.\n @param[in] aUdpPort The UDP port to use with ephemeral key. If zero, an ephemeral port will be used.\n `otBorderAgentGetUdpPort()` will return the current UDP port being used.\n\n @retval OT_ERROR_NONE Successfully set the ephemeral key.\n @retval OT_ERROR_INVALID_STATE Border Agent is not running or it is connected to an external commissioner.\n @retval OT_ERROR_INVALID_ARGS The given @p aKeyString is not valid (too short or too long).\n @retval OT_ERROR_FAILED Failed to set the key (e.g., could not bind to UDP port).\n\n"]
pub fn otBorderAgentSetEphemeralKey(
aInstance: *mut otInstance,
aKeyString: *const ::std::os::raw::c_char,
aTimeout: u32,
aUdpPort: u16,
) -> otError;
}
extern "C" {
#[doc = " Cancels the ephemeral key that is in use.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n Can be used to cancel a previously set ephemeral key before it times out. If the Border Agent is not running or\n there is no ephemeral key in use, calling this function has no effect.\n\n If a commissioner is connected using the ephemeral key and is currently active, calling this function does not\n change its state. In this case the `otBorderAgentIsEphemeralKeyActive()` will continue to return `TRUE` until the\n commissioner disconnects.\n\n @param[in] aInstance The OpenThread instance.\n"]
pub fn otBorderAgentClearEphemeralKey(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Indicates whether or not an ephemeral key is currently active.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n @param[in] aInstance The OpenThread instance.\n\n @retval TRUE An ephemeral key is active.\n @retval FALSE No ephemeral key is active.\n"]
pub fn otBorderAgentIsEphemeralKeyActive(aInstance: *mut otInstance) -> bool;
}
#[doc = " Callback function pointer to signal changes related to the Border Agent's ephemeral key.\n\n This callback is invoked whenever:\n\n - The Border Agent starts using an ephemeral key.\n - Any parameter related to the ephemeral key, such as the port number, changes.\n - The Border Agent stops using the ephemeral key due to:\n - A direct call to `otBorderAgentClearEphemeralKey()`.\n - The ephemeral key timing out.\n - An external commissioner successfully using the key to connect and then disconnecting.\n - Reaching the maximum number of allowed failed connection attempts.\n\n Any OpenThread API, including `otBorderAgent` APIs, can be safely called from this callback.\n\n @param[in] aContext A pointer to an arbitrary context (provided when callback is set).\n"]
pub type otBorderAgentEphemeralKeyCallback =
::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
extern "C" {
#[doc = " Sets the callback function used by the Border Agent to notify any changes related to use of ephemeral key.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n A subsequent call to this function will replace any previously set callback.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aCallback The callback function pointer.\n @param[in] aContext The arbitrary context to use with callback.\n"]
pub fn otBorderAgentSetEphemeralKeyCallback(
aInstance: *mut otInstance,
aCallback: otBorderAgentEphemeralKeyCallback,
aContext: *mut ::std::os::raw::c_void,
);
}
#[doc = " Represents an iterator to iterate through the Border Router's discovered prefix table.\n\n The fields in this type are opaque (intended for use by OpenThread core only) and therefore should not be\n accessed or used by caller.\n\n Before using an iterator, it MUST be initialized using `otBorderRoutingPrefixTableInitIterator()`.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otBorderRoutingPrefixTableIterator {
pub mPtr1: *const ::std::os::raw::c_void,
pub mPtr2: *const ::std::os::raw::c_void,
pub mData32: u32,
}
impl Default for otBorderRoutingPrefixTableIterator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Represents a discovered router on the infrastructure link.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otBorderRoutingRouterEntry {
#[doc = "< IPv6 address of the router."]
pub mAddress: otIp6Address,
pub _bitfield_align_1: [u8; 0],
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
}
impl Default for otBorderRoutingRouterEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
impl otBorderRoutingRouterEntry {
#[inline]
pub fn mManagedAddressConfigFlag(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
}
#[inline]
pub fn set_mManagedAddressConfigFlag(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(0usize, 1u8, val as u64)
}
}
#[inline]
pub fn mOtherConfigFlag(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
}
#[inline]
pub fn set_mOtherConfigFlag(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(1usize, 1u8, val as u64)
}
}
#[inline]
pub fn mStubRouterFlag(&self) -> bool {
unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
}
#[inline]
pub fn set_mStubRouterFlag(&mut self, val: bool) {
unsafe {
let val: u8 = ::std::mem::transmute(val);
self._bitfield_1.set(2usize, 1u8, val as u64)
}
}
#[inline]
pub fn new_bitfield_1(
mManagedAddressConfigFlag: bool,
mOtherConfigFlag: bool,
mStubRouterFlag: bool,
) -> __BindgenBitfieldUnit<[u8; 1usize]> {
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
__bindgen_bitfield_unit.set(0usize, 1u8, {
let mManagedAddressConfigFlag: u8 =
unsafe { ::std::mem::transmute(mManagedAddressConfigFlag) };
mManagedAddressConfigFlag as u64
});
__bindgen_bitfield_unit.set(1usize, 1u8, {
let mOtherConfigFlag: u8 = unsafe { ::std::mem::transmute(mOtherConfigFlag) };
mOtherConfigFlag as u64
});
__bindgen_bitfield_unit.set(2usize, 1u8, {
let mStubRouterFlag: u8 = unsafe { ::std::mem::transmute(mStubRouterFlag) };
mStubRouterFlag as u64
});
__bindgen_bitfield_unit
}
}
#[doc = " Represents an entry from the discovered prefix table.\n\n The entries in the discovered table track the Prefix/Route Info Options in the received Router Advertisement messages\n from other routers on the infrastructure link.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otBorderRoutingPrefixTableEntry {
#[doc = "< Information about the router advertising this prefix."]
pub mRouter: otBorderRoutingRouterEntry,
#[doc = "< The discovered IPv6 prefix."]
pub mPrefix: otIp6Prefix,
#[doc = "< Indicates whether the prefix is on-link or route prefix."]
pub mIsOnLink: bool,
#[doc = "< Milliseconds since last update of this prefix."]
pub mMsecSinceLastUpdate: u32,
#[doc = "< Valid lifetime of the prefix (in seconds)."]
pub mValidLifetime: u32,
#[doc = "< Route preference when `mIsOnlink` is false."]
pub mRoutePreference: otRoutePreference,
#[doc = "< Preferred lifetime of the on-link prefix when `mIsOnLink`."]
pub mPreferredLifetime: u32,
}
impl Default for otBorderRoutingPrefixTableEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Represents a group of data of platform-generated RA messages processed.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otPdProcessedRaInfo {
#[doc = "< The number of platform generated RA handled by ProcessPlatformGeneratedRa."]
pub mNumPlatformRaReceived: u32,
#[doc = "< The number of PIO processed for adding OMR prefixes."]
pub mNumPlatformPioProcessed: u32,
#[doc = "< The timestamp of last processed RA message."]
pub mLastPlatformRaMsec: u32,
}
#[doc = "< Routing Manager is uninitialized."]
pub const OT_BORDER_ROUTING_STATE_UNINITIALIZED: otBorderRoutingState = 0;
#[doc = "< Routing Manager is initialized but disabled."]
pub const OT_BORDER_ROUTING_STATE_DISABLED: otBorderRoutingState = 1;
#[doc = "< Routing Manager in initialized and enabled but currently stopped."]
pub const OT_BORDER_ROUTING_STATE_STOPPED: otBorderRoutingState = 2;
#[doc = "< Routing Manager is initialized, enabled, and running."]
pub const OT_BORDER_ROUTING_STATE_RUNNING: otBorderRoutingState = 3;
#[doc = " Represents the state of Border Routing Manager.\n"]
pub type otBorderRoutingState = ::std::os::raw::c_uint;
#[doc = "< DHCPv6 PD is disabled on the border router."]
pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_DISABLED: otBorderRoutingDhcp6PdState = 0;
#[doc = "< DHCPv6 PD in enabled but won't try to request and publish a prefix."]
pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_STOPPED: otBorderRoutingDhcp6PdState = 1;
#[doc = "< DHCPv6 PD is enabled and will try to request and publish a prefix."]
pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_RUNNING: otBorderRoutingDhcp6PdState = 2;
#[doc = " This enumeration represents the state of DHCPv6 Prefix Delegation State.\n"]
pub type otBorderRoutingDhcp6PdState = ::std::os::raw::c_uint;
extern "C" {
#[doc = " Initializes the Border Routing Manager on given infrastructure interface.\n\n @note This method MUST be called before any other otBorderRouting* APIs.\n @note This method can be re-called to change the infrastructure interface, but the Border Routing Manager should be\n disabled first, and re-enabled after.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aInfraIfIndex The infrastructure interface index.\n @param[in] aInfraIfIsRunning A boolean that indicates whether the infrastructure\n interface is running.\n\n @retval OT_ERROR_NONE Successfully started the Border Routing Manager on given infrastructure.\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is in a state other than disabled or uninitialized.\n @retval OT_ERROR_INVALID_ARGS The index of the infrastructure interface is not valid.\n @retval OT_ERROR_FAILED Internal failure. Usually due to failure in generating random prefixes.\n\n @sa otPlatInfraIfStateChanged.\n @sa otBorderRoutingSetEnabled.\n"]
pub fn otBorderRoutingInit(
aInstance: *mut otInstance,
aInfraIfIndex: u32,
aInfraIfIsRunning: bool,
) -> otError;
}
extern "C" {
#[doc = " Enables or disables the Border Routing Manager.\n\n @note The Border Routing Manager is disabled by default.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled A boolean to enable/disable the routing manager.\n\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not initialized yet.\n @retval OT_ERROR_NONE Successfully enabled/disabled the Border Routing Manager.\n"]
pub fn otBorderRoutingSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
}
extern "C" {
#[doc = " Gets the current state of Border Routing Manager.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current state of Border Routing Manager.\n"]
pub fn otBorderRoutingGetState(aInstance: *mut otInstance) -> otBorderRoutingState;
}
extern "C" {
#[doc = " Gets the current preference used when advertising Route Info Options (RIO) in Router Advertisement\n messages sent over the infrastructure link.\n\n The RIO preference is determined as follows:\n\n - If explicitly set by user by calling `otBorderRoutingSetRouteInfoOptionPreference()`, the given preference is\n used.\n - Otherwise, it is determined based on device's current role: Medium preference when in router/leader role and\n low preference when in child role.\n\n @returns The current Route Info Option preference.\n"]
pub fn otBorderRoutingGetRouteInfoOptionPreference(
aInstance: *mut otInstance,
) -> otRoutePreference;
}
extern "C" {
#[doc = " Explicitly sets the preference to use when advertising Route Info Options (RIO) in Router\n Advertisement messages sent over the infrastructure link.\n\n After a call to this function, BR will use the given preference for all its advertised RIOs. The preference can be\n cleared by calling `otBorderRoutingClearRouteInfoOptionPreference()`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPreference The route preference to use.\n"]
pub fn otBorderRoutingSetRouteInfoOptionPreference(
aInstance: *mut otInstance,
aPreference: otRoutePreference,
);
}
extern "C" {
#[doc = " Clears a previously set preference value for advertised Route Info Options.\n\n After a call to this function, BR will use device's role to determine the RIO preference: Medium preference when\n in router/leader role and low preference when in child role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otBorderRoutingClearRouteInfoOptionPreference(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Sets additional options to append at the end of emitted Router Advertisement (RA) messages.\n\n The content of @p aOptions is copied internally, so it can be a temporary buffer (e.g., a stack allocated array).\n\n Subsequent calls to this function overwrite the previously set value.\n\n @param[in] aOptions A pointer to the encoded options. Can be `NULL` to clear.\n @param[in] aLength Number of bytes in @p aOptions.\n\n @retval OT_ERROR_NONE Successfully set the extra option bytes.\n @retval OT_ERROR_NO_BUFS Could not allocate buffer to save the buffer.\n"]
pub fn otBorderRoutingSetExtraRouterAdvertOptions(
aInstance: *mut otInstance,
aOptions: *const u8,
aLength: u16,
) -> otError;
}
extern "C" {
#[doc = " Gets the current preference used for published routes in Network Data.\n\n The preference is determined as follows:\n\n - If explicitly set by user by calling `otBorderRoutingSetRoutePreference()`, the given preference is used.\n - Otherwise, it is determined automatically by `RoutingManager` based on the device's role and link quality.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current published route preference.\n"]
pub fn otBorderRoutingGetRoutePreference(aInstance: *mut otInstance) -> otRoutePreference;
}
extern "C" {
#[doc = " Explicitly sets the preference of published routes in Network Data.\n\n After a call to this function, BR will use the given preference. The preference can be cleared by calling\n `otBorderRoutingClearRoutePreference()`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPreference The route preference to use.\n"]
pub fn otBorderRoutingSetRoutePreference(
aInstance: *mut otInstance,
aPreference: otRoutePreference,
);
}
extern "C" {
#[doc = " Clears a previously set preference value for published routes in Network Data.\n\n After a call to this function, BR will determine the preference automatically based on the device's role and\n link quality (to the parent when acting as end-device).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otBorderRoutingClearRoutePreference(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Gets the local Off-Mesh-Routable (OMR) Prefix, for example `fdfc:1ff5:1512:5622::/64`.\n\n An OMR Prefix is a randomly generated 64-bit prefix that's published in the\n Thread network if there isn't already an OMR prefix. This prefix can be reached\n from the local Wi-Fi or Ethernet network.\n\n Note: When DHCPv6 PD is enabled, the border router may publish the prefix from\n DHCPv6 PD.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPrefix A pointer to where the prefix will be output to.\n\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not initialized yet.\n @retval OT_ERROR_NONE Successfully retrieved the OMR prefix.\n\n @sa otBorderRoutingGetPdOmrPrefix\n"]
pub fn otBorderRoutingGetOmrPrefix(
aInstance: *mut otInstance,
aPrefix: *mut otIp6Prefix,
) -> otError;
}
extern "C" {
#[doc = " Gets the DHCPv6 Prefix Delegation (PD) provided off-mesh-routable (OMR) prefix.\n\n Only mPrefix, mValidLifetime and mPreferredLifetime fields are used in the returned prefix info.\n\n `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE` must be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPrefixInfo A pointer to where the prefix info will be output to.\n\n @retval OT_ERROR_NONE Successfully retrieved the OMR prefix.\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not initialized yet.\n @retval OT_ERROR_NOT_FOUND There are no valid PD prefix on this BR.\n\n @sa otBorderRoutingGetOmrPrefix\n @sa otPlatBorderRoutingProcessIcmp6Ra\n"]
pub fn otBorderRoutingGetPdOmrPrefix(
aInstance: *mut otInstance,
aPrefixInfo: *mut otBorderRoutingPrefixTableEntry,
) -> otError;
}
extern "C" {
#[doc = " Gets the data of platform generated RA message processed..\n\n `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE` must be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPrefixInfo A pointer to where the prefix info will be output to.\n\n @retval OT_ERROR_NONE Successfully retrieved the Info.\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not initialized yet.\n @retval OT_ERROR_NOT_FOUND There are no valid Info on this BR.\n"]
pub fn otBorderRoutingGetPdProcessedRaInfo(
aInstance: *mut otInstance,
aPdProcessedRaInfo: *mut otPdProcessedRaInfo,
) -> otError;
}
extern "C" {
#[doc = " Gets the currently favored Off-Mesh-Routable (OMR) Prefix.\n\n The favored OMR prefix can be discovered from Network Data or can be this device's local OMR prefix.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPrefix A pointer to output the favored OMR prefix.\n @param[out] aPreference A pointer to output the preference associated the favored prefix.\n\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not running yet.\n @retval OT_ERROR_NONE Successfully retrieved the favored OMR prefix.\n"]
pub fn otBorderRoutingGetFavoredOmrPrefix(
aInstance: *mut otInstance,
aPrefix: *mut otIp6Prefix,
aPreference: *mut otRoutePreference,
) -> otError;
}
extern "C" {
#[doc = " Gets the local On-Link Prefix for the adjacent infrastructure link.\n\n The local On-Link Prefix is a 64-bit prefix that's advertised on the infrastructure link if there isn't already a\n usable on-link prefix being advertised on the link.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPrefix A pointer to where the prefix will be output to.\n\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not initialized yet.\n @retval OT_ERROR_NONE Successfully retrieved the local on-link prefix.\n"]
pub fn otBorderRoutingGetOnLinkPrefix(
aInstance: *mut otInstance,
aPrefix: *mut otIp6Prefix,
) -> otError;
}
extern "C" {
#[doc = " Gets the currently favored On-Link Prefix.\n\n The favored prefix is either a discovered on-link prefix on the infrastructure link or the local on-link prefix.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPrefix A pointer to where the prefix will be output to.\n\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not initialized yet.\n @retval OT_ERROR_NONE Successfully retrieved the favored on-link prefix.\n"]
pub fn otBorderRoutingGetFavoredOnLinkPrefix(
aInstance: *mut otInstance,
aPrefix: *mut otIp6Prefix,
) -> otError;
}
extern "C" {
#[doc = " Gets the local NAT64 Prefix of the Border Router.\n\n NAT64 Prefix might not be advertised in the Thread network.\n\n `OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE` must be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPrefix A pointer to where the prefix will be output to.\n\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not initialized yet.\n @retval OT_ERROR_NONE Successfully retrieved the NAT64 prefix.\n"]
pub fn otBorderRoutingGetNat64Prefix(
aInstance: *mut otInstance,
aPrefix: *mut otIp6Prefix,
) -> otError;
}
extern "C" {
#[doc = " Gets the currently favored NAT64 prefix.\n\n The favored NAT64 prefix can be discovered from infrastructure link or can be this device's local NAT64 prefix.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPrefix A pointer to output the favored NAT64 prefix.\n @param[out] aPreference A pointer to output the preference associated the favored prefix.\n\n @retval OT_ERROR_INVALID_STATE The Border Routing Manager is not initialized yet.\n @retval OT_ERROR_NONE Successfully retrieved the favored NAT64 prefix.\n"]
pub fn otBorderRoutingGetFavoredNat64Prefix(
aInstance: *mut otInstance,
aPrefix: *mut otIp6Prefix,
aPreference: *mut otRoutePreference,
) -> otError;
}
extern "C" {
#[doc = " Initializes an `otBorderRoutingPrefixTableIterator`.\n\n An iterator MUST be initialized before it is used.\n\n An iterator can be initialized again to restart from the beginning of the table.\n\n When iterating over entries in the table, to ensure the update times `mMsecSinceLastUpdate` of entries are\n consistent, they are given relative to the time the iterator was initialized.\n\n @param[in] aInstance The OpenThread instance.\n @param[out] aIterator A pointer to the iterator to initialize.\n"]
pub fn otBorderRoutingPrefixTableInitIterator(
aInstance: *mut otInstance,
aIterator: *mut otBorderRoutingPrefixTableIterator,
);
}
extern "C" {
#[doc = " Iterates over the entries in the Border Router's discovered prefix table.\n\n Prefix entries associated with the same discovered router on an infrastructure link are guaranteed to be grouped\n together (retrieved back-to-back).\n\n @param[in] aInstance The OpenThread instance.\n @param[in,out] aIterator A pointer to the iterator.\n @param[out] aEntry A pointer to the entry to populate.\n\n @retval OT_ERROR_NONE Iterated to the next entry, @p aEntry and @p aIterator are updated.\n @retval OT_ERROR_NOT_FOUND No more entries in the table.\n"]
pub fn otBorderRoutingGetNextPrefixTableEntry(
aInstance: *mut otInstance,
aIterator: *mut otBorderRoutingPrefixTableIterator,
aEntry: *mut otBorderRoutingPrefixTableEntry,
) -> otError;
}
extern "C" {
#[doc = " Iterates over the discovered router entries on the infrastructure link.\n\n @param[in] aInstance The OpenThread instance.\n @param[in,out] aIterator A pointer to the iterator.\n @param[out] aEntry A pointer to the entry to populate.\n\n @retval OT_ERROR_NONE Iterated to the next router, @p aEntry and @p aIterator are updated.\n @retval OT_ERROR_NOT_FOUND No more router entries.\n"]
pub fn otBorderRoutingGetNextRouterEntry(
aInstance: *mut otInstance,
aIterator: *mut otBorderRoutingPrefixTableIterator,
aEntry: *mut otBorderRoutingRouterEntry,
) -> otError;
}
extern "C" {
#[doc = " Enables / Disables DHCPv6 Prefix Delegation.\n\n `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE` must be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled Whether to accept platform generated RA messages.\n"]
pub fn otBorderRoutingDhcp6PdSetEnabled(aInstance: *mut otInstance, aEnabled: bool);
}
extern "C" {
#[doc = " Gets the current state of DHCPv6 Prefix Delegation.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE` to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current state of DHCPv6 Prefix Delegation.\n"]
pub fn otBorderRoutingDhcp6PdGetState(
aInstance: *mut otInstance,
) -> otBorderRoutingDhcp6PdState;
}
#[doc = " When the state of a DHCPv6 Prefix Delegation (PD) on the Thread interface changes, this callback notifies processes\n in the OS of this changed state.\n\n @param[in] aState The state of DHCPv6 Prefix Delegation State.\n @param[in] aContext A pointer to arbitrary context information.\n"]
pub type otBorderRoutingRequestDhcp6PdCallback = ::std::option::Option<
unsafe extern "C" fn(
aState: otBorderRoutingDhcp6PdState,
aContext: *mut ::std::os::raw::c_void,
),
>;
extern "C" {
#[doc = " Sets the callback whenever the DHCPv6 PD state changes on the Thread interface.\n\n Subsequent calls to this function replace the previously set callback.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called whenever the DHCPv6 PD state changes.\n @param[in] aContext A pointer to arbitrary context information.\n\n"]
pub fn otBorderRoutingDhcp6PdSetRequestCallback(
aInstance: *mut otInstance,
aCallback: otBorderRoutingRequestDhcp6PdCallback,
aContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Provides a full or stable copy of the local Thread Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aStable TRUE when copying the stable version, FALSE when copying the full version.\n @param[out] aData A pointer to the data buffer.\n @param[in,out] aDataLength On entry, size of the data buffer pointed to by @p aData.\n On exit, number of copied bytes."]
pub fn otBorderRouterGetNetData(
aInstance: *mut otInstance,
aStable: bool,
aData: *mut u8,
aDataLength: *mut u8,
) -> otError;
}
extern "C" {
#[doc = " Add a border router configuration to the local network data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aConfig A pointer to the border router configuration.\n\n @retval OT_ERROR_NONE Successfully added the configuration to the local network data.\n @retval OT_ERROR_INVALID_ARGS One or more configuration parameters were invalid.\n @retval OT_ERROR_NO_BUFS Not enough room is available to add the configuration to the local network data.\n\n @sa otBorderRouterRemoveOnMeshPrefix\n @sa otBorderRouterRegister"]
pub fn otBorderRouterAddOnMeshPrefix(
aInstance: *mut otInstance,
aConfig: *const otBorderRouterConfig,
) -> otError;
}
extern "C" {
#[doc = " Remove a border router configuration from the local network data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPrefix A pointer to an IPv6 prefix.\n\n @retval OT_ERROR_NONE Successfully removed the configuration from the local network data.\n @retval OT_ERROR_NOT_FOUND Could not find the Border Router entry.\n\n @sa otBorderRouterAddOnMeshPrefix\n @sa otBorderRouterRegister"]
pub fn otBorderRouterRemoveOnMeshPrefix(
aInstance: *mut otInstance,
aPrefix: *const otIp6Prefix,
) -> otError;
}
extern "C" {
#[doc = " Gets the next On Mesh Prefix in the local Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the Network Data iterator context. To get the first on-mesh entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out] aConfig A pointer to the On Mesh Prefix information.\n\n @retval OT_ERROR_NONE Successfully found the next On Mesh prefix.\n @retval OT_ERROR_NOT_FOUND No subsequent On Mesh prefix exists in the Thread Network Data.\n"]
pub fn otBorderRouterGetNextOnMeshPrefix(
aInstance: *mut otInstance,
aIterator: *mut otNetworkDataIterator,
aConfig: *mut otBorderRouterConfig,
) -> otError;
}
extern "C" {
#[doc = " Add an external route configuration to the local network data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aConfig A pointer to the external route configuration.\n\n @retval OT_ERROR_NONE Successfully added the configuration to the local network data.\n @retval OT_ERROR_INVALID_ARGS One or more configuration parameters were invalid.\n @retval OT_ERROR_NO_BUFS Not enough room is available to add the configuration to the local network data.\n\n @sa otBorderRouterRemoveRoute\n @sa otBorderRouterRegister"]
pub fn otBorderRouterAddRoute(
aInstance: *mut otInstance,
aConfig: *const otExternalRouteConfig,
) -> otError;
}
extern "C" {
#[doc = " Remove an external route configuration from the local network data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPrefix A pointer to an IPv6 prefix.\n\n @retval OT_ERROR_NONE Successfully removed the configuration from the local network data.\n @retval OT_ERROR_NOT_FOUND Could not find the Border Router entry.\n\n @sa otBorderRouterAddRoute\n @sa otBorderRouterRegister"]
pub fn otBorderRouterRemoveRoute(
aInstance: *mut otInstance,
aPrefix: *const otIp6Prefix,
) -> otError;
}
extern "C" {
#[doc = " Gets the next external route in the local Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the Network Data iterator context. To get the first external route entry\nit should be set to OT_NETWORK_DATA_ITERATOR_INIT.\n @param[out] aConfig A pointer to the External Route information.\n\n @retval OT_ERROR_NONE Successfully found the next External Route.\n @retval OT_ERROR_NOT_FOUND No subsequent external route entry exists in the Thread Network Data.\n"]
pub fn otBorderRouterGetNextRoute(
aInstance: *mut otInstance,
aIterator: *mut otNetworkDataIterator,
aConfig: *mut otExternalRouteConfig,
) -> otError;
}
extern "C" {
#[doc = " Immediately register the local network data with the Leader.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully queued a Server Data Request message for delivery.\n\n @sa otBorderRouterAddOnMeshPrefix\n @sa otBorderRouterRemoveOnMeshPrefix\n @sa otBorderRouterAddRoute\n @sa otBorderRouterRemoveRoute"]
pub fn otBorderRouterRegister(aInstance: *mut otInstance) -> otError;
}
#[doc = " Function pointer callback which is invoked when Network Data (local or leader) gets full.\n\n @param[in] aContext A pointer to arbitrary context information.\n"]
pub type otBorderRouterNetDataFullCallback =
::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
extern "C" {
#[doc = " Sets the callback to indicate when Network Data gets full.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTER_SIGNAL_NETWORK_DATA_FULL`.\n\n The callback is invoked whenever:\n - The device is acting as a leader and receives a Network Data registration from a Border Router (BR) that it cannot\n add to Network Data (running out of space).\n - The device is acting as a BR and new entries cannot be added to its local Network Data.\n - The device is acting as a BR and tries to register its local Network Data entries with the leader, but determines\n that its local entries will not fit.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback The callback.\n @param[in] aContext A pointer to arbitrary context information used with @p aCallback.\n"]
pub fn otBorderRouterSetNetDataFullCallback(
aInstance: *mut otInstance,
aCallback: otBorderRouterNetDataFullCallback,
aContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Requests a Thread network channel change.\n\n The network switches to the given channel after a specified delay (see #otChannelManagerSetDelay()). The channel\n change is performed by updating the Pending Operational Dataset.\n\n A subsequent call will cancel an ongoing previously requested channel change.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannel The new channel for the Thread network.\n"]
pub fn otChannelManagerRequestChannelChange(aInstance: *mut otInstance, aChannel: u8);
}
extern "C" {
#[doc = " Gets the channel from the last successful call to `otChannelManagerRequestChannelChange()`\n\n @returns The last requested channel or zero if there has been no channel change request yet.\n"]
pub fn otChannelManagerGetRequestedChannel(aInstance: *mut otInstance) -> u8;
}
extern "C" {
#[doc = " Gets the delay (in seconds) used by Channel Manager for a network channel change.\n\n Only available on FTDs.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The delay (in seconds) for channel change.\n"]
pub fn otChannelManagerGetDelay(aInstance: *mut otInstance) -> u16;
}
extern "C" {
#[doc = " Sets the delay (in seconds) used for a network channel change.\n\n Only available on FTDs. The delay should preferably be longer than the maximum data poll interval used by all\n Sleepy End Devices within the Thread network.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDelay Delay in seconds.\n\n @retval OT_ERROR_NONE Delay was updated successfully.\n @retval OT_ERROR_INVALID_ARGS The given delay @p aDelay is too short.\n"]
pub fn otChannelManagerSetDelay(aInstance: *mut otInstance, aDelay: u16) -> otError;
}
extern "C" {
#[doc = " Requests that `ChannelManager` checks and selects a new channel and starts a channel change.\n\n Unlike the `otChannelManagerRequestChannelChange()` where the channel must be given as a parameter, this function\n asks the `ChannelManager` to select a channel by itself (based on collected channel quality info).\n\n Once called, the Channel Manager will perform the following 3 steps:\n\n 1) `ChannelManager` decides if the channel change would be helpful. This check can be skipped if\n `aSkipQualityCheck` is set to true (forcing a channel selection to happen and skipping the quality check).\n This step uses the collected link quality metrics on the device (such as CCA failure rate, frame and message\n error rates per neighbor, etc.) to determine if the current channel quality is at the level that justifies\n a channel change.\n\n 2) If the first step passes, then `ChannelManager` selects a potentially better channel. It uses the collected\n channel quality data by `ChannelMonitor` module. The supported and favored channels are used at this step.\n (see `otChannelManagerSetSupportedChannels()` and `otChannelManagerSetFavoredChannels()`).\n\n 3) If the newly selected channel is different from the current channel, `ChannelManager` requests/starts the\n channel change process (internally invoking a `RequestChannelChange()`).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSkipQualityCheck Indicates whether the quality check (step 1) should be skipped.\n\n @retval OT_ERROR_NONE Channel selection finished successfully.\n @retval OT_ERROR_NOT_FOUND Supported channel mask is empty, therefore could not select a channel.\n"]
pub fn otChannelManagerRequestChannelSelect(
aInstance: *mut otInstance,
aSkipQualityCheck: bool,
) -> otError;
}
extern "C" {
#[doc = " Requests that `ChannelManager` checks and selects a new CSL channel and starts a CSL channel change.\n\n Only available with `OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE &&\n OPENTHREAD_CONFIG_CHANNEL_MANAGER_CSL_CHANNEL_SELECT_ENABLE`. This function asks the `ChannelManager` to select a\n channel by itself (based on collected channel quality info).\n\n Once called, the Channel Manager will perform the following 3 steps:\n\n 1) `ChannelManager` decides if the CSL channel change would be helpful. This check can be skipped if\n `aSkipQualityCheck` is set to true (forcing a CSL channel selection to happen and skipping the quality check).\n This step uses the collected link quality metrics on the device (such as CCA failure rate, frame and message\n error rates per neighbor, etc.) to determine if the current channel quality is at the level that justifies\n a CSL channel change.\n\n 2) If the first step passes, then `ChannelManager` selects a potentially better CSL channel. It uses the collected\n channel quality data by `ChannelMonitor` module. The supported and favored channels are used at this step.\n (see `otChannelManagerSetSupportedChannels()` and `otChannelManagerSetFavoredChannels()`).\n\n 3) If the newly selected CSL channel is different from the current CSL channel, `ChannelManager` starts the\n CSL channel change process.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSkipQualityCheck Indicates whether the quality check (step 1) should be skipped.\n\n @retval OT_ERROR_NONE Channel selection finished successfully.\n @retval OT_ERROR_NOT_FOUND Supported channel mask is empty, therefore could not select a channel.\n"]
pub fn otChannelManagerRequestCslChannelSelect(
aInstance: *mut otInstance,
aSkipQualityCheck: bool,
) -> otError;
}
extern "C" {
#[doc = " Enables or disables the auto-channel-selection functionality for network channel.\n\n When enabled, `ChannelManager` will periodically invoke a `RequestChannelSelect(false)`. The period interval\n can be set by `otChannelManagerSetAutoChannelSelectionInterval()`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled Indicates whether to enable or disable this functionality.\n"]
pub fn otChannelManagerSetAutoChannelSelectionEnabled(
aInstance: *mut otInstance,
aEnabled: bool,
);
}
extern "C" {
#[doc = " Indicates whether the auto-channel-selection functionality for a network channel is enabled or not.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if enabled, FALSE if disabled.\n"]
pub fn otChannelManagerGetAutoChannelSelectionEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Enables or disables the auto-channel-selection functionality for a CSL channel.\n\n Only available with `OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE &&\n OPENTHREAD_CONFIG_CHANNEL_MANAGER_CSL_CHANNEL_SELECT_ENABLE`. When enabled, `ChannelManager` will periodically invoke\n a `otChannelManagerRequestCslChannelSelect()`. The period interval can be set by\n `otChannelManagerSetAutoChannelSelectionInterval()`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled Indicates whether to enable or disable this functionality.\n"]
pub fn otChannelManagerSetAutoCslChannelSelectionEnabled(
aInstance: *mut otInstance,
aEnabled: bool,
);
}
extern "C" {
#[doc = " Indicates whether the auto-csl-channel-selection functionality is enabled or not.\n\n Only available with `OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE &&\n OPENTHREAD_CONFIG_CHANNEL_MANAGER_CSL_CHANNEL_SELECT_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if enabled, FALSE if disabled.\n"]
pub fn otChannelManagerGetAutoCslChannelSelectionEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Sets the period interval (in seconds) used by auto-channel-selection functionality.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aInterval The interval in seconds.\n\n @retval OT_ERROR_NONE The interval was set successfully.\n @retval OT_ERROR_INVALID_ARGS The @p aInterval is not valid (zero).\n"]
pub fn otChannelManagerSetAutoChannelSelectionInterval(
aInstance: *mut otInstance,
aInterval: u32,
) -> otError;
}
extern "C" {
#[doc = " Gets the period interval (in seconds) used by auto-channel-selection functionality.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The interval in seconds.\n"]
pub fn otChannelManagerGetAutoChannelSelectionInterval(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Gets the supported channel mask.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The supported channels as a bit-mask.\n"]
pub fn otChannelManagerGetSupportedChannels(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Sets the supported channel mask.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask A channel mask.\n"]
pub fn otChannelManagerSetSupportedChannels(aInstance: *mut otInstance, aChannelMask: u32);
}
extern "C" {
#[doc = " Gets the favored channel mask.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The favored channels as a bit-mask.\n"]
pub fn otChannelManagerGetFavoredChannels(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Sets the favored channel mask.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask A channel mask.\n"]
pub fn otChannelManagerSetFavoredChannels(aInstance: *mut otInstance, aChannelMask: u32);
}
extern "C" {
#[doc = " Gets the CCA failure rate threshold.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The CCA failure rate threshold. Value 0 maps to 0% and 0xffff maps to 100%.\n"]
pub fn otChannelManagerGetCcaFailureRateThreshold(aInstance: *mut otInstance) -> u16;
}
extern "C" {
#[doc = " Sets the CCA failure rate threshold.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aThreshold A CCA failure rate threshold. Value 0 maps to 0% and 0xffff maps to 100%.\n"]
pub fn otChannelManagerSetCcaFailureRateThreshold(aInstance: *mut otInstance, aThreshold: u16);
}
extern "C" {
#[doc = " Enables or disables the Channel Monitoring operation.\n\n Once operation starts, any previously collected data is cleared. However, after operation is disabled, the previous\n collected data is still valid and can be read.\n\n @note OpenThread core internally enables or disables the Channel Monitoring operation when the IPv6 interface is\n brought up or down, for example in a call to `otIp6SetEnabled()`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE to enable/start Channel Monitoring operation, FALSE to disable/stop it.\n\n @retval OT_ERROR_NONE Channel Monitoring state changed successfully\n @retval OT_ERROR_ALREADY Channel Monitoring is already in the same state.\n"]
pub fn otChannelMonitorSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
}
extern "C" {
#[doc = " Indicates whether the Channel Monitoring operation is enabled and running.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if the Channel Monitoring operation is enabled, FALSE otherwise.\n"]
pub fn otChannelMonitorIsEnabled(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Get channel monitoring sample interval in milliseconds.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The channel monitor sample interval in milliseconds.\n"]
pub fn otChannelMonitorGetSampleInterval(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Get channel monitoring RSSI threshold in dBm.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The RSSI threshold in dBm.\n"]
pub fn otChannelMonitorGetRssiThreshold(aInstance: *mut otInstance) -> i8;
}
extern "C" {
#[doc = " Get channel monitoring averaging sample window length (number of samples).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The averaging sample window.\n"]
pub fn otChannelMonitorGetSampleWindow(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Get channel monitoring total number of RSSI samples (per channel).\n\n The count indicates total number samples per channel by channel monitoring module since its start (since Thread\n network interface was enabled).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns Total number of RSSI samples (per channel) taken so far.\n"]
pub fn otChannelMonitorGetSampleCount(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " Gets the current channel occupancy for a given channel.\n\n The channel occupancy value represents the average rate/percentage of RSSI samples that were above RSSI threshold\n (\"bad\" RSSI samples).\n\n For the first \"sample window\" samples, the average is maintained as the actual percentage (i.e., ratio of number\n of \"bad\" samples by total number of samples). After \"window\" samples, the averager uses an exponentially\n weighted moving average. Practically, this means the average is representative of up to `3 * window` last samples\n with highest weight given to the latest `kSampleWindow` samples.\n\n Max value of `0xffff` indicates all RSSI samples were above RSSI threshold (i.e. 100% of samples were \"bad\").\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannel The channel for which to get the link occupancy.\n\n @returns The current channel occupancy for the given channel.\n"]
pub fn otChannelMonitorGetChannelOccupancy(aInstance: *mut otInstance, aChannel: u8) -> u16;
}
extern "C" {
#[doc = " Gets the Child Supervision interval (in seconds) on a child.\n\n Child Supervision feature provides a mechanism for parent to ensure that a message is sent to each sleepy child\n within the supervision interval. If there is no transmission to the child within the supervision interval, OpenThread\n enqueues and sends a Child Supervision Message to the child.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The child supervision interval. Zero indicates that supervision is disabled.\n"]
pub fn otChildSupervisionGetInterval(aInstance: *mut otInstance) -> u16;
}
extern "C" {
#[doc = " Sets the child supervision interval (in seconds) on the child.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aInterval The supervision interval (in seconds). Zero to disable supervision.\n"]
pub fn otChildSupervisionSetInterval(aInstance: *mut otInstance, aInterval: u16);
}
extern "C" {
#[doc = " Gets the supervision check timeout interval (in seconds) on the child.\n\n If the device is a sleepy child and it does not hear from its parent within the specified check timeout, it initiates\n the re-attach process (MLE Child Update Request/Response exchange with its parent).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The supervision check timeout. Zero indicates that supervision check on the child is disabled.\n"]
pub fn otChildSupervisionGetCheckTimeout(aInstance: *mut otInstance) -> u16;
}
extern "C" {
#[doc = " Sets the supervision check timeout interval (in seconds) on the child.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aTimeout The check timeout (in seconds). Zero to disable supervision check on the child.\n"]
pub fn otChildSupervisionSetCheckTimeout(aInstance: *mut otInstance, aTimeout: u16);
}
extern "C" {
#[doc = " Get the value of supervision check timeout failure counter.\n\n The counter tracks the number of supervision check failures on the child. It is incremented when the child does\n not hear from its parent within the specified check timeout interval.\n"]
pub fn otChildSupervisionGetCheckFailureCounter(aInstance: *mut otInstance) -> u16;
}
extern "C" {
#[doc = " Reset the supervision check timeout failure counter to zero.\n"]
pub fn otChildSupervisionResetCheckFailureCounter(aInstance: *mut otInstance);
}
#[doc = " Represents a CLI command.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otCliCommand {
#[doc = "< A pointer to the command string."]
pub mName: *const ::std::os::raw::c_char,
pub mCommand: ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aArgsLength: u8,
aArgs: *mut *mut ::std::os::raw::c_char,
) -> otError,
>,
}
impl Default for otCliCommand {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Pointer is called to notify about Console output.\n\n @param[out] aContext A user context pointer.\n @param[in] aFormat The format string.\n @param[in] aArguments The format string arguments.\n\n @returns Number of bytes written by the callback.\n"]
pub type otCliOutputCallback = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aFormat: *const ::std::os::raw::c_char,
aArguments: *mut __va_list_tag,
) -> ::std::os::raw::c_int,
>;
extern "C" {
#[doc = " Initialize the CLI module.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aCallback A callback method called to process CLI output.\n @param[in] aContext A user context pointer.\n"]
pub fn otCliInit(
aInstance: *mut otInstance,
aCallback: otCliOutputCallback,
aContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Is called to feed in a console input line.\n\n @param[in] aBuf A pointer to a null-terminated string.\n"]
pub fn otCliInputLine(aBuf: *mut ::std::os::raw::c_char);
}
extern "C" {
#[doc = " Set a user command table.\n\n @param[in] aUserCommands A pointer to an array with user commands.\n @param[in] aLength @p aUserCommands length.\n @param[in] aContext @p The context passed to the handler.\n\n @retval OT_ERROR_NONE Successfully updated command table with commands from @p aUserCommands.\n @retval OT_ERROR_FAILED Maximum number of command entries have already been set."]
pub fn otCliSetUserCommands(
aUserCommands: *const otCliCommand,
aLength: u8,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Write a number of bytes to the CLI console as a hex string.\n\n @param[in] aBytes A pointer to data which should be printed.\n @param[in] aLength @p aBytes length.\n"]
pub fn otCliOutputBytes(aBytes: *const u8, aLength: u8);
}
extern "C" {
#[doc = " Write formatted string to the CLI console\n\n @param[in] aFmt A pointer to the format string.\n @param[in] ... A matching list of arguments.\n"]
pub fn otCliOutputFormat(aFmt: *const ::std::os::raw::c_char, ...);
}
extern "C" {
#[doc = " Write error code to the CLI console\n\n If the @p aError is `OT_ERROR_PENDING` nothing will be outputted.\n\n @param[in] aError Error code value.\n"]
pub fn otCliAppendResult(aError: otError);
}
extern "C" {
#[doc = " Callback to write the OpenThread Log to the CLI console\n\n @param[in] aLogLevel The log level.\n @param[in] aLogRegion The log region.\n @param[in] aFormat A pointer to the format string.\n @param[in] aArgs va_list matching aFormat.\n"]
pub fn otCliPlatLogv(
aLogLevel: otLogLevel,
aLogRegion: otLogRegion,
aFormat: *const ::std::os::raw::c_char,
aArgs: *mut __va_list_tag,
);
}
extern "C" {
#[doc = " Callback to allow vendor specific commands to be added to the user command table.\n\n Available when `OPENTHREAD_CONFIG_CLI_VENDOR_COMMANDS_ENABLE` is enabled and\n `OPENTHREAD_CONFIG_CLI_MAX_USER_CMD_ENTRIES` is greater than 1.\n"]
pub fn otCliVendorSetUserCommands();
}
#[doc = "< Confirmable"]
pub const OT_COAP_TYPE_CONFIRMABLE: otCoapType = 0;
#[doc = "< Non-confirmable"]
pub const OT_COAP_TYPE_NON_CONFIRMABLE: otCoapType = 1;
#[doc = "< Acknowledgment"]
pub const OT_COAP_TYPE_ACKNOWLEDGMENT: otCoapType = 2;
#[doc = "< Reset"]
pub const OT_COAP_TYPE_RESET: otCoapType = 3;
#[doc = " CoAP Type values (2 bit unsigned integer).\n"]
pub type otCoapType = ::std::os::raw::c_uint;
#[doc = "< Empty message code"]
pub const OT_COAP_CODE_EMPTY: otCoapCode = 0;
#[doc = "< Get"]
pub const OT_COAP_CODE_GET: otCoapCode = 1;
#[doc = "< Post"]
pub const OT_COAP_CODE_POST: otCoapCode = 2;
#[doc = "< Put"]
pub const OT_COAP_CODE_PUT: otCoapCode = 3;
#[doc = "< Delete"]
pub const OT_COAP_CODE_DELETE: otCoapCode = 4;
#[doc = "< 2.00"]
pub const OT_COAP_CODE_RESPONSE_MIN: otCoapCode = 64;
#[doc = "< Created"]
pub const OT_COAP_CODE_CREATED: otCoapCode = 65;
#[doc = "< Deleted"]
pub const OT_COAP_CODE_DELETED: otCoapCode = 66;
#[doc = "< Valid"]
pub const OT_COAP_CODE_VALID: otCoapCode = 67;
#[doc = "< Changed"]
pub const OT_COAP_CODE_CHANGED: otCoapCode = 68;
#[doc = "< Content"]
pub const OT_COAP_CODE_CONTENT: otCoapCode = 69;
#[doc = "< RFC7959 Continue"]
pub const OT_COAP_CODE_CONTINUE: otCoapCode = 95;
#[doc = "< Bad Request"]
pub const OT_COAP_CODE_BAD_REQUEST: otCoapCode = 128;
#[doc = "< Unauthorized"]
pub const OT_COAP_CODE_UNAUTHORIZED: otCoapCode = 129;
#[doc = "< Bad Option"]
pub const OT_COAP_CODE_BAD_OPTION: otCoapCode = 130;
#[doc = "< Forbidden"]
pub const OT_COAP_CODE_FORBIDDEN: otCoapCode = 131;
#[doc = "< Not Found"]
pub const OT_COAP_CODE_NOT_FOUND: otCoapCode = 132;
#[doc = "< Method Not Allowed"]
pub const OT_COAP_CODE_METHOD_NOT_ALLOWED: otCoapCode = 133;
#[doc = "< Not Acceptable"]
pub const OT_COAP_CODE_NOT_ACCEPTABLE: otCoapCode = 134;
#[doc = "< RFC7959 Request Entity Incomplete"]
pub const OT_COAP_CODE_REQUEST_INCOMPLETE: otCoapCode = 136;
#[doc = "< Precondition Failed"]
pub const OT_COAP_CODE_PRECONDITION_FAILED: otCoapCode = 140;
#[doc = "< Request Entity Too Large"]
pub const OT_COAP_CODE_REQUEST_TOO_LARGE: otCoapCode = 141;
#[doc = "< Unsupported Content-Format"]
pub const OT_COAP_CODE_UNSUPPORTED_FORMAT: otCoapCode = 143;
#[doc = "< Internal Server Error"]
pub const OT_COAP_CODE_INTERNAL_ERROR: otCoapCode = 160;
#[doc = "< Not Implemented"]
pub const OT_COAP_CODE_NOT_IMPLEMENTED: otCoapCode = 161;
#[doc = "< Bad Gateway"]
pub const OT_COAP_CODE_BAD_GATEWAY: otCoapCode = 162;
#[doc = "< Service Unavailable"]
pub const OT_COAP_CODE_SERVICE_UNAVAILABLE: otCoapCode = 163;
#[doc = "< Gateway Timeout"]
pub const OT_COAP_CODE_GATEWAY_TIMEOUT: otCoapCode = 164;
#[doc = "< Proxying Not Supported"]
pub const OT_COAP_CODE_PROXY_NOT_SUPPORTED: otCoapCode = 165;
#[doc = " CoAP Code values.\n"]
pub type otCoapCode = ::std::os::raw::c_uint;
#[doc = "< If-Match"]
pub const OT_COAP_OPTION_IF_MATCH: otCoapOptionType = 1;
#[doc = "< Uri-Host"]
pub const OT_COAP_OPTION_URI_HOST: otCoapOptionType = 3;
#[doc = "< ETag"]
pub const OT_COAP_OPTION_E_TAG: otCoapOptionType = 4;
#[doc = "< If-None-Match"]
pub const OT_COAP_OPTION_IF_NONE_MATCH: otCoapOptionType = 5;
#[doc = "< Observe [RFC7641]"]
pub const OT_COAP_OPTION_OBSERVE: otCoapOptionType = 6;
#[doc = "< Uri-Port"]
pub const OT_COAP_OPTION_URI_PORT: otCoapOptionType = 7;
#[doc = "< Location-Path"]
pub const OT_COAP_OPTION_LOCATION_PATH: otCoapOptionType = 8;
#[doc = "< Uri-Path"]
pub const OT_COAP_OPTION_URI_PATH: otCoapOptionType = 11;
#[doc = "< Content-Format"]
pub const OT_COAP_OPTION_CONTENT_FORMAT: otCoapOptionType = 12;
#[doc = "< Max-Age"]
pub const OT_COAP_OPTION_MAX_AGE: otCoapOptionType = 14;
#[doc = "< Uri-Query"]
pub const OT_COAP_OPTION_URI_QUERY: otCoapOptionType = 15;
#[doc = "< Accept"]
pub const OT_COAP_OPTION_ACCEPT: otCoapOptionType = 17;
#[doc = "< Location-Query"]
pub const OT_COAP_OPTION_LOCATION_QUERY: otCoapOptionType = 20;
#[doc = "< Block2 (RFC7959)"]
pub const OT_COAP_OPTION_BLOCK2: otCoapOptionType = 23;
#[doc = "< Block1 (RFC7959)"]
pub const OT_COAP_OPTION_BLOCK1: otCoapOptionType = 27;
#[doc = "< Size2 (RFC7959)"]
pub const OT_COAP_OPTION_SIZE2: otCoapOptionType = 28;
#[doc = "< Proxy-Uri"]
pub const OT_COAP_OPTION_PROXY_URI: otCoapOptionType = 35;
#[doc = "< Proxy-Scheme"]
pub const OT_COAP_OPTION_PROXY_SCHEME: otCoapOptionType = 39;
#[doc = "< Size1"]
pub const OT_COAP_OPTION_SIZE1: otCoapOptionType = 60;
#[doc = " CoAP Option Numbers"]
pub type otCoapOptionType = ::std::os::raw::c_uint;
#[doc = " Represents a CoAP option.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otCoapOption {
#[doc = "< Option Number"]
pub mNumber: u16,
#[doc = "< Option Length"]
pub mLength: u16,
}
#[doc = " Acts as an iterator for CoAP options\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otCoapOptionIterator {
#[doc = "< CoAP message"]
pub mMessage: *const otMessage,
#[doc = "< CoAP message option"]
pub mOption: otCoapOption,
#[doc = "< Byte offset of next option"]
pub mNextOptionOffset: u16,
}
impl Default for otCoapOptionIterator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " text/plain; charset=utf-8: [RFC2046][RFC3676][RFC5147]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_TEXT_PLAIN: otCoapOptionContentFormat = 0;
#[doc = " application/cose; cose-type=\"cose-encrypt0\": [RFC8152]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_ENCRYPT0: otCoapOptionContentFormat = 16;
#[doc = " application/cose; cose-type=\"cose-mac0\": [RFC8152]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_MAC0: otCoapOptionContentFormat = 17;
#[doc = " application/cose; cose-type=\"cose-sign1\": [RFC8152]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_SIGN1: otCoapOptionContentFormat = 18;
#[doc = " application/link-format: [RFC6690]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_LINK_FORMAT: otCoapOptionContentFormat = 40;
#[doc = " application/xml: [RFC3023]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_XML: otCoapOptionContentFormat = 41;
#[doc = " application/octet-stream: [RFC2045][RFC2046]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_OCTET_STREAM: otCoapOptionContentFormat = 42;
#[doc = " application/exi:\n [\"Efficient XML Interchange (EXI) Format 1.0 (Second Edition)\", February 2014]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_EXI: otCoapOptionContentFormat = 47;
#[doc = " application/json: [RFC7159]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_JSON: otCoapOptionContentFormat = 50;
#[doc = " application/json-patch+json: [RFC6902]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_JSON_PATCH_JSON: otCoapOptionContentFormat = 51;
#[doc = " application/merge-patch+json: [RFC7396]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_MERGE_PATCH_JSON: otCoapOptionContentFormat = 52;
#[doc = " application/cbor: [RFC7049]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_CBOR: otCoapOptionContentFormat = 60;
#[doc = " application/cwt: [RFC8392]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_CWT: otCoapOptionContentFormat = 61;
#[doc = " application/cose; cose-type=\"cose-encrypt\": [RFC8152]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_ENCRYPT: otCoapOptionContentFormat = 96;
#[doc = " application/cose; cose-type=\"cose-mac\": [RFC8152]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_MAC: otCoapOptionContentFormat = 97;
#[doc = " application/cose; cose-type=\"cose-sign\": [RFC8152]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_SIGN: otCoapOptionContentFormat = 98;
#[doc = " application/cose-key: [RFC8152]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_KEY: otCoapOptionContentFormat = 101;
#[doc = " application/cose-key-set: [RFC8152]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_KEY_SET: otCoapOptionContentFormat = 102;
#[doc = " application/senml+json: [RFC8428]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_JSON: otCoapOptionContentFormat = 110;
#[doc = " application/sensml+json: [RFC8428]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_JSON: otCoapOptionContentFormat = 111;
#[doc = " application/senml+cbor: [RFC8428]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_CBOR: otCoapOptionContentFormat = 112;
#[doc = " application/sensml+cbor: [RFC8428]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_CBOR: otCoapOptionContentFormat = 113;
#[doc = " application/senml-exi: [RFC8428]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_EXI: otCoapOptionContentFormat = 114;
#[doc = " application/sensml-exi: [RFC8428]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_EXI: otCoapOptionContentFormat = 115;
#[doc = " application/coap-group+json: [RFC7390]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_COAP_GROUP_JSON: otCoapOptionContentFormat = 256;
#[doc = " application/senml+xml: [RFC8428]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_XML: otCoapOptionContentFormat = 310;
#[doc = " application/sensml+xml: [RFC8428]"]
pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_XML: otCoapOptionContentFormat = 311;
#[doc = " CoAP Content Format codes. The full list is documented at\n https://www.iana.org/assignments/core-parameters/core-parameters.xhtml#content-formats"]
pub type otCoapOptionContentFormat = ::std::os::raw::c_uint;
pub const OT_COAP_OPTION_BLOCK_SZX_16: otCoapBlockSzx = 0;
pub const OT_COAP_OPTION_BLOCK_SZX_32: otCoapBlockSzx = 1;
pub const OT_COAP_OPTION_BLOCK_SZX_64: otCoapBlockSzx = 2;
pub const OT_COAP_OPTION_BLOCK_SZX_128: otCoapBlockSzx = 3;
pub const OT_COAP_OPTION_BLOCK_SZX_256: otCoapBlockSzx = 4;
pub const OT_COAP_OPTION_BLOCK_SZX_512: otCoapBlockSzx = 5;
pub const OT_COAP_OPTION_BLOCK_SZX_1024: otCoapBlockSzx = 6;
#[doc = " CoAP Block Size Exponents"]
pub type otCoapBlockSzx = ::std::os::raw::c_uint;
#[doc = " Pointer is called when a CoAP response is received or on the request timeout.\n\n @param[in] aContext A pointer to application-specific context.\n @param[in] aMessage A pointer to the message buffer containing the response. NULL if no response was received.\n @param[in] aMessageInfo A pointer to the message info for @p aMessage. NULL if no response was received.\n @param[in] aResult A result of the CoAP transaction.\n\n @retval OT_ERROR_NONE A response was received successfully.\n @retval OT_ERROR_ABORT A CoAP transaction was reset by peer.\n @retval OT_ERROR_RESPONSE_TIMEOUT No response or acknowledgment received during timeout period.\n"]
pub type otCoapResponseHandler = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aMessage: *mut otMessage,
aMessageInfo: *const otMessageInfo,
aResult: otError,
),
>;
#[doc = " Pointer is called when a CoAP request with a given Uri-Path is received.\n\n @param[in] aContext A pointer to arbitrary context information.\n @param[in] aMessage A pointer to the message.\n @param[in] aMessageInfo A pointer to the message info for @p aMessage.\n"]
pub type otCoapRequestHandler = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aMessage: *mut otMessage,
aMessageInfo: *const otMessageInfo,
),
>;
#[doc = " Pointer is called when a CoAP message with a block-wise transfer option is received.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n @param[in] aContext A pointer to application-specific context.\n @param[in] aBlock A pointer to the block segment.\n @param[in] aPosition The position of @p aBlock in a sequence in bytes.\n @param[in] aBlockLength The length of the block segment in bytes.\n @param[in] aMore Flag if more block segments are following.\n @param[in] aTotalLength The total length in bytes of the transferred information (indicated by a Size1 or Size2\n option).\n\n @retval OT_ERROR_NONE Block segment was stored successfully.\n @retval OT_ERROR_NO_BUFS No more memory to store blocks.\n @retval OT_ERROR_NO_FRAME_RECEIVED Block segment missing.\n"]
pub type otCoapBlockwiseReceiveHook = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aBlock: *const u8,
aPosition: u32,
aBlockLength: u16,
aMore: bool,
aTotalLength: u32,
) -> otError,
>;
#[doc = " Pointer is called before the next block in a block-wise transfer is sent.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n @param[in] aContext A pointer to application-specific context.\n @param[in,out] aBlock A pointer to where the block segment can be written to.\n @param[in] aPosition The position in a sequence from which to obtain the block segment.\n @param[in,out] aBlockLength On entry, the maximum block segment length in bytes.\n @param[out] aMore A pointer to the flag if more block segments will follow.\n\n @warning By changing the value of aBlockLength, the block size of the whole exchange is\n renegotiated. It is recommended to do this after the first block has been received as\n later changes could cause problems with other CoAP implementations.\n\n @retval OT_ERROR_NONE No error occurred.\n @retval OT_ERROR_INVALID_ARGS Block at @p aPosition does not exist.\n"]
pub type otCoapBlockwiseTransmitHook = ::std::option::Option<
unsafe extern "C" fn(
aContext: *mut ::std::os::raw::c_void,
aBlock: *mut u8,
aPosition: u32,
aBlockLength: *mut u16,
aMore: *mut bool,
) -> otError,
>;
#[doc = " Represents a CoAP resource.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otCoapResource {
#[doc = "< The URI Path string"]
pub mUriPath: *const ::std::os::raw::c_char,
#[doc = "< The callback for handling a received request"]
pub mHandler: otCoapRequestHandler,
#[doc = "< Application-specific context"]
pub mContext: *mut ::std::os::raw::c_void,
#[doc = "< The next CoAP resource in the list"]
pub mNext: *mut otCoapResource,
}
impl Default for otCoapResource {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Represents a CoAP resource with block-wise transfer.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otCoapBlockwiseResource {
#[doc = "< The URI Path string"]
pub mUriPath: *const ::std::os::raw::c_char,
#[doc = "< The callback for handling a received request"]
pub mHandler: otCoapRequestHandler,
#[doc = " The callback for handling incoming block-wise transfer.\n This callback is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE\n configuration is enabled."]
pub mReceiveHook: otCoapBlockwiseReceiveHook,
#[doc = " The callback for handling outgoing block-wise transfer.\n This callback is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE\n configuration is enabled."]
pub mTransmitHook: otCoapBlockwiseTransmitHook,
#[doc = "< Application-specific context"]
pub mContext: *mut ::std::os::raw::c_void,
#[doc = "< The next CoAP resource in the list"]
pub mNext: *mut otCoapBlockwiseResource,
}
impl Default for otCoapBlockwiseResource {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Represents the CoAP transmission parameters.\n\n @note mAckTimeout * ((2 ** (mMaxRetransmit + 1)) - 1) * (mAckRandomFactorNumerator / mAckRandomFactorDenominator)\n must not exceed what can be represented by a uint32_t (0xffffffff). This limitation allows OpenThread to\n avoid 64-bit arithmetic.\n"]
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct otCoapTxParameters {
#[doc = " Minimum spacing before first retransmission when ACK is not received, in milliseconds (RFC7252 default value is\n 2000ms).\n"]
pub mAckTimeout: u32,
#[doc = " Numerator of ACK_RANDOM_FACTOR used to calculate maximum spacing before first retransmission when ACK is not\n received (RFC7252 default value of ACK_RANDOM_FACTOR is 1.5; must not be decreased below 1).\n"]
pub mAckRandomFactorNumerator: u8,
#[doc = " Denominator of ACK_RANDOM_FACTOR used to calculate maximum spacing before first retransmission when ACK is not\n received (RFC7252 default value of ACK_RANDOM_FACTOR is 1.5; must not be decreased below 1).\n"]
pub mAckRandomFactorDenominator: u8,
#[doc = " Maximum number of retransmissions for CoAP Confirmable messages (RFC7252 default value is 4).\n"]
pub mMaxRetransmit: u8,
}
extern "C" {
#[doc = " Initializes the CoAP header.\n\n @param[in,out] aMessage A pointer to the CoAP message to initialize.\n @param[in] aType CoAP message type.\n @param[in] aCode CoAP message code.\n"]
pub fn otCoapMessageInit(aMessage: *mut otMessage, aType: otCoapType, aCode: otCoapCode);
}
extern "C" {
#[doc = " Initializes a response message.\n\n @note Both message ID and token are set according to @p aRequest.\n\n @param[in,out] aResponse A pointer to the CoAP response message.\n @param[in] aRequest A pointer to the CoAP request message.\n @param[in] aType CoAP message type.\n @param[in] aCode CoAP message code.\n\n @retval OT_ERROR_NONE Successfully initialized the response message.\n @retval OT_ERROR_NO_BUFS Insufficient message buffers available to initialize the response message.\n"]
pub fn otCoapMessageInitResponse(
aResponse: *mut otMessage,
aRequest: *const otMessage,
aType: otCoapType,
aCode: otCoapCode,
) -> otError;
}
extern "C" {
#[doc = " Sets the Token value and length in a header.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aToken A pointer to the Token value.\n @param[in] aTokenLength The Length of @p aToken.\n\n @retval OT_ERROR_NONE Successfully set the Token value.\n @retval OT_ERROR_NO_BUFS Insufficient buffers to set the Token value.\n"]
pub fn otCoapMessageSetToken(
aMessage: *mut otMessage,
aToken: *const u8,
aTokenLength: u8,
) -> otError;
}
extern "C" {
#[doc = " Sets the Token length and randomizes its value.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aTokenLength The Length of a Token to set.\n"]
pub fn otCoapMessageGenerateToken(aMessage: *mut otMessage, aTokenLength: u8);
}
extern "C" {
#[doc = " Appends the Content Format CoAP option as specified in\n https://tools.ietf.org/html/rfc7252#page-92. This *must* be called before\n setting otCoapMessageSetPayloadMarker if a payload is to be included in the\n message.\n\n The function is a convenience wrapper around otCoapMessageAppendUintOption,\n and if the desired format type code isn't listed in otCoapOptionContentFormat,\n this base function should be used instead.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aContentFormat One of the content formats listed in\n otCoapOptionContentFormat above.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n"]
pub fn otCoapMessageAppendContentFormatOption(
aMessage: *mut otMessage,
aContentFormat: otCoapOptionContentFormat,
) -> otError;
}
extern "C" {
#[doc = " Appends a CoAP option in a header.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aNumber The CoAP Option number.\n @param[in] aLength The CoAP Option length.\n @param[in] aValue A pointer to the CoAP value.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n"]
pub fn otCoapMessageAppendOption(
aMessage: *mut otMessage,
aNumber: u16,
aLength: u16,
aValue: *const ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Appends an unsigned integer CoAP option as specified in\n https://tools.ietf.org/html/rfc7252#section-3.2\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aNumber The CoAP Option number.\n @param[in] aValue The CoAP Option unsigned integer value.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n\n @see otCoapMessageGetOptionUintValue"]
pub fn otCoapMessageAppendUintOption(
aMessage: *mut otMessage,
aNumber: u16,
aValue: u32,
) -> otError;
}
extern "C" {
#[doc = " Appends an Observe option.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aObserve Observe field value.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n"]
pub fn otCoapMessageAppendObserveOption(aMessage: *mut otMessage, aObserve: u32) -> otError;
}
extern "C" {
#[doc = " Appends a Uri-Path option.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aUriPath A pointer to a NULL-terminated string.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n"]
pub fn otCoapMessageAppendUriPathOptions(
aMessage: *mut otMessage,
aUriPath: *const ::std::os::raw::c_char,
) -> otError;
}
extern "C" {
#[doc = " Converts a CoAP Block option SZX field to the actual block size\n\n @param[in] aSize Block size exponent.\n\n @returns The actual size exponent value.\n"]
pub fn otCoapBlockSizeFromExponent(aSize: otCoapBlockSzx) -> u16;
}
extern "C" {
#[doc = " Appends a Block2 option\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aNum Current block number.\n @param[in] aMore Boolean to indicate more blocks are to be sent.\n @param[in] aSize Block Size Exponent.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n"]
pub fn otCoapMessageAppendBlock2Option(
aMessage: *mut otMessage,
aNum: u32,
aMore: bool,
aSize: otCoapBlockSzx,
) -> otError;
}
extern "C" {
#[doc = " Appends a Block1 option\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aNum Current block number.\n @param[in] aMore Boolean to indicate more blocks are to be sent.\n @param[in] aSize Block Size Exponent.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n"]
pub fn otCoapMessageAppendBlock1Option(
aMessage: *mut otMessage,
aNum: u32,
aMore: bool,
aSize: otCoapBlockSzx,
) -> otError;
}
extern "C" {
#[doc = " Appends a Proxy-Uri option.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aUriPath A pointer to a NULL-terminated string.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n"]
pub fn otCoapMessageAppendProxyUriOption(
aMessage: *mut otMessage,
aUriPath: *const ::std::os::raw::c_char,
) -> otError;
}
extern "C" {
#[doc = " Appends a Max-Age option.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aMaxAge The Max-Age value.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size.\n"]
pub fn otCoapMessageAppendMaxAgeOption(aMessage: *mut otMessage, aMaxAge: u32) -> otError;
}
extern "C" {
#[doc = " Appends a single Uri-Query option.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aUriQuery A pointer to NULL-terminated string, which should contain a single key=value pair.\n\n @retval OT_ERROR_NONE Successfully appended the option.\n @retval OT_ERROR_INVALID_ARGS The option type is not equal or greater than the last option type.\n @retval OT_ERROR_NO_BUFS The option length exceeds the buffer size."]
pub fn otCoapMessageAppendUriQueryOption(
aMessage: *mut otMessage,
aUriQuery: *const ::std::os::raw::c_char,
) -> otError;
}
extern "C" {
#[doc = " Adds Payload Marker indicating beginning of the payload to the CoAP header.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n\n @retval OT_ERROR_NONE Payload Marker successfully added.\n @retval OT_ERROR_NO_BUFS Header Payload Marker exceeds the buffer size.\n"]
pub fn otCoapMessageSetPayloadMarker(aMessage: *mut otMessage) -> otError;
}
extern "C" {
#[doc = " Returns the Type value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Type value.\n"]
pub fn otCoapMessageGetType(aMessage: *const otMessage) -> otCoapType;
}
extern "C" {
#[doc = " Returns the Code value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Code value.\n"]
pub fn otCoapMessageGetCode(aMessage: *const otMessage) -> otCoapCode;
}
extern "C" {
#[doc = " Sets the Code value.\n\n @param[in,out] aMessage A pointer to the CoAP message to initialize.\n @param[in] aCode CoAP message code.\n"]
pub fn otCoapMessageSetCode(aMessage: *mut otMessage, aCode: otCoapCode);
}
extern "C" {
#[doc = " Returns the CoAP Code as human readable string.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @ returns The CoAP Code as string.\n"]
pub fn otCoapMessageCodeToString(aMessage: *const otMessage) -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Returns the Message ID value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Message ID value.\n"]
pub fn otCoapMessageGetMessageId(aMessage: *const otMessage) -> u16;
}
extern "C" {
#[doc = " Returns the Token length.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Token length.\n"]
pub fn otCoapMessageGetTokenLength(aMessage: *const otMessage) -> u8;
}
extern "C" {
#[doc = " Returns a pointer to the Token value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns A pointer to the Token value.\n"]
pub fn otCoapMessageGetToken(aMessage: *const otMessage) -> *const u8;
}
extern "C" {
#[doc = " Initialises an iterator for the options in the given message.\n\n @param[in,out] aIterator A pointer to the CoAP message option iterator.\n @param[in] aMessage A pointer to the CoAP message.\n\n @retval OT_ERROR_NONE Successfully initialised.\n @retval OT_ERROR_PARSE Message state is inconsistent.\n"]
pub fn otCoapOptionIteratorInit(
aIterator: *mut otCoapOptionIterator,
aMessage: *const otMessage,
) -> otError;
}
extern "C" {
#[doc = " Returns a pointer to the first option matching the specified option number.\n\n @param[in] aIterator A pointer to the CoAP message option iterator.\n @param[in] aOption The option number sought.\n\n @returns A pointer to the first matching option. If no matching option is present NULL pointer is returned.\n"]
pub fn otCoapOptionIteratorGetFirstOptionMatching(
aIterator: *mut otCoapOptionIterator,
aOption: u16,
) -> *const otCoapOption;
}
extern "C" {
#[doc = " Returns a pointer to the first option.\n\n @param[in,out] aIterator A pointer to the CoAP message option iterator.\n\n @returns A pointer to the first option. If no option is present NULL pointer is returned.\n"]
pub fn otCoapOptionIteratorGetFirstOption(
aIterator: *mut otCoapOptionIterator,
) -> *const otCoapOption;
}
extern "C" {
#[doc = " Returns a pointer to the next option matching the specified option number.\n\n @param[in] aIterator A pointer to the CoAP message option iterator.\n @param[in] aOption The option number sought.\n\n @returns A pointer to the next matching option. If no further matching option is present NULL pointer is returned.\n"]
pub fn otCoapOptionIteratorGetNextOptionMatching(
aIterator: *mut otCoapOptionIterator,
aOption: u16,
) -> *const otCoapOption;
}
extern "C" {
#[doc = " Returns a pointer to the next option.\n\n @param[in,out] aIterator A pointer to the CoAP message option iterator.\n\n @returns A pointer to the next option. If no more options are present NULL pointer is returned.\n"]
pub fn otCoapOptionIteratorGetNextOption(
aIterator: *mut otCoapOptionIterator,
) -> *const otCoapOption;
}
extern "C" {
#[doc = " Fills current option value into @p aValue assuming the current value is an unsigned integer encoded\n according to https://tools.ietf.org/html/rfc7252#section-3.2\n\n @param[in,out] aIterator A pointer to the CoAP message option iterator.\n @param[out] aValue A pointer to an unsigned integer to receive the option value.\n\n @retval OT_ERROR_NONE Successfully filled value.\n @retval OT_ERROR_NOT_FOUND No current option.\n @retval OT_ERROR_NO_BUFS Value is too long to fit in a uint64_t.\n\n @see otCoapMessageAppendUintOption"]
pub fn otCoapOptionIteratorGetOptionUintValue(
aIterator: *mut otCoapOptionIterator,
aValue: *mut u64,
) -> otError;
}
extern "C" {
#[doc = " Fills current option value into @p aValue.\n\n @param[in,out] aIterator A pointer to the CoAP message option iterator.\n @param[out] aValue A pointer to a buffer to receive the option value.\n\n @retval OT_ERROR_NONE Successfully filled value.\n @retval OT_ERROR_NOT_FOUND No current option.\n"]
pub fn otCoapOptionIteratorGetOptionValue(
aIterator: *mut otCoapOptionIterator,
aValue: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Creates a new CoAP message.\n\n @note If @p aSettings is 'NULL', the link layer security is enabled and the message priority is set to\n OT_MESSAGE_PRIORITY_NORMAL by default.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSettings A pointer to the message settings or NULL to set default settings.\n\n @returns A pointer to the message buffer or NULL if no message buffers are available or parameters are invalid.\n"]
pub fn otCoapNewMessage(
aInstance: *mut otInstance,
aSettings: *const otMessageSettings,
) -> *mut otMessage;
}
extern "C" {
#[doc = " Sends a CoAP request with custom transmission parameters.\n\n If a response for a request is expected, respective function and context information should be provided.\n If no response is expected, these arguments should be NULL pointers.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the message to send.\n @param[in] aMessageInfo A pointer to the message info associated with @p aMessage.\n @param[in] aHandler A function pointer that shall be called on response reception or timeout.\n @param[in] aContext A pointer to arbitrary context information. May be NULL if not used.\n @param[in] aTxParameters A pointer to transmission parameters for this request. Use NULL for defaults.\n Otherwise, parameters given must meet the following conditions:\n 1. mMaxRetransmit is no more than OT_COAP_MAX_RETRANSMIT.\n 2. mAckRandomFactorNumerator / mAckRandomFactorDenominator must not be below 1.0.\n 3. The calculated exchange life time must not overflow uint32_t.\n\n @retval OT_ERROR_NONE Successfully sent CoAP message.\n @retval OT_ERROR_NO_BUFS Failed to allocate retransmission data.\n @retval OT_ERROR_INVALID_ARGS Invalid arguments are given.\n"]
pub fn otCoapSendRequestWithParameters(
aInstance: *mut otInstance,
aMessage: *mut otMessage,
aMessageInfo: *const otMessageInfo,
aHandler: otCoapResponseHandler,
aContext: *mut ::std::os::raw::c_void,
aTxParameters: *const otCoapTxParameters,
) -> otError;
}
extern "C" {
#[doc = " Sends a CoAP request block-wise with custom transmission parameters.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n If a response for a request is expected, respective function and context information should be provided.\n If the response is expected to be block-wise, a respective hook function should be provided.\n If no response is expected, these arguments should be NULL pointers.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the message to send.\n @param[in] aMessageInfo A pointer to the message info associated with @p aMessage.\n @param[in] aHandler A function pointer that shall be called on response reception or timeout.\n @param[in] aContext A pointer to arbitrary context information. May be NULL if not used.\n @param[in] aTxParameters A pointer to transmission parameters for this request. Use NULL for defaults.\n @param[in] aTransmitHook A pointer to a hook function for outgoing block-wise transfer.\n @param[in] aReceiveHook A pointer to a hook function for incoming block-wise transfer.\n\n @retval OT_ERROR_NONE Successfully sent CoAP message.\n @retval OT_ERROR_NO_BUFS Failed to allocate retransmission data.\n @retval OT_ERROR_INVALID_ARGS Invalid arguments are given.\n"]
pub fn otCoapSendRequestBlockWiseWithParameters(
aInstance: *mut otInstance,
aMessage: *mut otMessage,
aMessageInfo: *const otMessageInfo,
aHandler: otCoapResponseHandler,
aContext: *mut ::std::os::raw::c_void,
aTxParameters: *const otCoapTxParameters,
aTransmitHook: otCoapBlockwiseTransmitHook,
aReceiveHook: otCoapBlockwiseReceiveHook,
) -> otError;
}
extern "C" {
#[doc = " Starts the CoAP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPort The local UDP port to bind to.\n\n @retval OT_ERROR_NONE Successfully started the CoAP server.\n @retval OT_ERROR_FAILED Failed to start the CoAP server.\n"]
pub fn otCoapStart(aInstance: *mut otInstance, aPort: u16) -> otError;
}
extern "C" {
#[doc = " Stops the CoAP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully stopped the CoAP server.\n"]
pub fn otCoapStop(aInstance: *mut otInstance) -> otError;
}
extern "C" {
#[doc = " Adds a resource to the CoAP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aResource A pointer to the resource.\n"]
pub fn otCoapAddResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
}
extern "C" {
#[doc = " Removes a resource from the CoAP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aResource A pointer to the resource.\n"]
pub fn otCoapRemoveResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
}
extern "C" {
#[doc = " Adds a block-wise resource to the CoAP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aResource A pointer to the resource.\n"]
pub fn otCoapAddBlockWiseResource(
aInstance: *mut otInstance,
aResource: *mut otCoapBlockwiseResource,
);
}
extern "C" {
#[doc = " Removes a block-wise resource from the CoAP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aResource A pointer to the resource.\n"]
pub fn otCoapRemoveBlockWiseResource(
aInstance: *mut otInstance,
aResource: *mut otCoapBlockwiseResource,
);
}
extern "C" {
#[doc = " Sets the default handler for unhandled CoAP requests.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aHandler A function pointer that shall be called when an unhandled request arrives.\n @param[in] aContext A pointer to arbitrary context information. May be NULL if not used.\n"]
pub fn otCoapSetDefaultHandler(
aInstance: *mut otInstance,
aHandler: otCoapRequestHandler,
aContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Sends a CoAP response from the server with custom transmission parameters.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the CoAP response to send.\n @param[in] aMessageInfo A pointer to the message info associated with @p aMessage.\n @param[in] aTxParameters A pointer to transmission parameters for this response. Use NULL for defaults.\n\n @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.\n @retval OT_ERROR_INVALID_ARGS Invalid arguments are given.\n"]
pub fn otCoapSendResponseWithParameters(
aInstance: *mut otInstance,
aMessage: *mut otMessage,
aMessageInfo: *const otMessageInfo,
aTxParameters: *const otCoapTxParameters,
) -> otError;
}
extern "C" {
#[doc = " Sends a CoAP response block-wise from the server with custom transmission parameters.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the CoAP response to send.\n @param[in] aMessageInfo A pointer to the message info associated with @p aMessage.\n @param[in] aTxParameters A pointer to transmission parameters for this response. Use NULL for defaults.\n @param[in] aContext A pointer to arbitrary context information. May be NULL if not used.\n @param[in] aTransmitHook A pointer to a hook function for outgoing block-wise transfer.\n\n @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.\n @retval OT_ERROR_INVALID_ARGS Invalid arguments are given.\n"]
pub fn otCoapSendResponseBlockWiseWithParameters(
aInstance: *mut otInstance,
aMessage: *mut otMessage,
aMessageInfo: *const otMessageInfo,
aTxParameters: *const otCoapTxParameters,
aContext: *mut ::std::os::raw::c_void,
aTransmitHook: otCoapBlockwiseTransmitHook,
) -> otError;
}
#[doc = " Pointer is called when the DTLS connection state changes.\n\n @param[in] aConnected true, if a connection was established, false otherwise.\n @param[in] aContext A pointer to arbitrary context information.\n"]
pub type otHandleCoapSecureClientConnect = ::std::option::Option<
unsafe extern "C" fn(aConnected: bool, aContext: *mut ::std::os::raw::c_void),
>;
#[doc = " Callback function pointer to notify when the CoAP secure agent is automatically stopped due to reaching the maximum\n number of connection attempts.\n\n @param[in] aContext A pointer to arbitrary context information.\n"]
pub type otCoapSecureAutoStopCallback =
::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
extern "C" {
#[doc = " Starts the CoAP Secure service.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPort The local UDP port to bind to.\n\n @retval OT_ERROR_NONE Successfully started the CoAP Secure server.\n"]
pub fn otCoapSecureStart(aInstance: *mut otInstance, aPort: u16) -> otError;
}
extern "C" {
#[doc = " Starts the CoAP secure service and sets the maximum number of allowed connection attempts before stopping the\n agent automatically.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPort The local UDP port to bind to.\n @param[in] aMaxAttempts Maximum number of allowed connection request attempts. Zero indicates no limit.\n @param[in] aCallback Callback to notify if max number of attempts has reached and agent is stopped.\n @param[in] aContext A pointer to arbitrary context to use with @p aCallback.\n\n @retval OT_ERROR_NONE Successfully started the CoAP agent.\n @retval OT_ERROR_ALREADY Already started.\n"]
pub fn otCoapSecureStartWithMaxConnAttempts(
aInstance: *mut otInstance,
aPort: u16,
aMaxAttempts: u16,
aCallback: otCoapSecureAutoStopCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Stops the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otCoapSecureStop(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Sets the Pre-Shared Key (PSK) and cipher suite\n DTLS_PSK_WITH_AES_128_CCM_8.\n\n @note This function requires the build-time feature `MBEDTLS_KEY_EXCHANGE_PSK_ENABLED` to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPsk A pointer to the PSK.\n @param[in] aPskLength The PSK length.\n @param[in] aPskIdentity The Identity Name for the PSK.\n @param[in] aPskIdLength The PSK Identity Length.\n"]
pub fn otCoapSecureSetPsk(
aInstance: *mut otInstance,
aPsk: *const u8,
aPskLength: u16,
aPskIdentity: *const u8,
aPskIdLength: u16,
);
}
extern "C" {
#[doc = " Returns the peer x509 certificate base64 encoded.\n\n @note This function requires the build-time features `MBEDTLS_BASE64_C` and\n `MBEDTLS_SSL_KEEP_PEER_CERTIFICATE` to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPeerCert A pointer to the base64 encoded certificate buffer.\n @param[out] aCertLength The length of the base64 encoded peer certificate.\n @param[in] aCertBufferSize The buffer size of aPeerCert.\n\n @retval OT_ERROR_INVALID_STATE Not connected yet.\n @retval OT_ERROR_NONE Successfully get the peer certificate.\n @retval OT_ERROR_NO_BUFS Can't allocate memory for certificate.\n"]
pub fn otCoapSecureGetPeerCertificateBase64(
aInstance: *mut otInstance,
aPeerCert: *mut ::std::os::raw::c_uchar,
aCertLength: *mut usize,
aCertBufferSize: usize,
) -> otError;
}
extern "C" {
#[doc = " Sets the authentication mode for the coap secure connection.\n\n Disable or enable the verification of peer certificate.\n Must be called before start.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aVerifyPeerCertificate true, to verify the peer certificate.\n"]
pub fn otCoapSecureSetSslAuthMode(aInstance: *mut otInstance, aVerifyPeerCertificate: bool);
}
extern "C" {
#[doc = " Sets the local device's X509 certificate with corresponding private key for\n DTLS session with DTLS_ECDHE_ECDSA_WITH_AES_128_CCM_8.\n\n @note This function requires `MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED=1`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aX509Cert A pointer to the PEM formatted X509 certificate.\n @param[in] aX509Length The length of certificate.\n @param[in] aPrivateKey A pointer to the PEM formatted private key.\n @param[in] aPrivateKeyLength The length of the private key.\n"]
pub fn otCoapSecureSetCertificate(
aInstance: *mut otInstance,
aX509Cert: *const u8,
aX509Length: u32,
aPrivateKey: *const u8,
aPrivateKeyLength: u32,
);
}
extern "C" {
#[doc = " Sets the trusted top level CAs. It is needed for validating the\n certificate of the peer.\n\n DTLS mode \"ECDHE ECDSA with AES 128 CCM 8\" for Application CoAPS.\n\n @note This function requires `MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA_ENABLED=1`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aX509CaCertificateChain A pointer to the PEM formatted X509 CA chain.\n @param[in] aX509CaCertChainLength The length of chain.\n"]
pub fn otCoapSecureSetCaCertificateChain(
aInstance: *mut otInstance,
aX509CaCertificateChain: *const u8,
aX509CaCertChainLength: u32,
);
}
extern "C" {
#[doc = " Initializes DTLS session with a peer.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSockAddr A pointer to the remote socket address.\n @param[in] aHandler A pointer to a function that will be called when the DTLS connection\n state changes.\n @param[in] aContext A pointer to arbitrary context information.\n\n @retval OT_ERROR_NONE Successfully started DTLS connection.\n"]
pub fn otCoapSecureConnect(
aInstance: *mut otInstance,
aSockAddr: *const otSockAddr,
aHandler: otHandleCoapSecureClientConnect,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Stops the DTLS connection.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otCoapSecureDisconnect(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Indicates whether or not the DTLS session is connected.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE The DTLS session is connected.\n @retval FALSE The DTLS session is not connected.\n"]
pub fn otCoapSecureIsConnected(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Indicates whether or not the DTLS session is active.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE If DTLS session is active.\n @retval FALSE If DTLS session is not active.\n"]
pub fn otCoapSecureIsConnectionActive(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Indicates whether or not the DTLS session is closed.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE The DTLS session is closed.\n @retval FALSE The DTLS session is not closed.\n"]
pub fn otCoapSecureIsClosed(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Sends a CoAP request block-wise over secure DTLS connection.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n If a response for a request is expected, respective function and context information should be provided.\n If no response is expected, these arguments should be NULL pointers.\n If Message Id was not set in the header (equal to 0), this function will assign unique Message Id to the message.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A reference to the message to send.\n @param[in] aHandler A function pointer that shall be called on response reception or time-out.\n @param[in] aContext A pointer to arbitrary context information.\n @param[in] aTransmitHook A function pointer that is called on Block1 response reception.\n @param[in] aReceiveHook A function pointer that is called on Block2 response reception.\n\n @retval OT_ERROR_NONE Successfully sent CoAP message.\n @retval OT_ERROR_NO_BUFS Failed to allocate retransmission data.\n @retval OT_ERROR_INVALID_STATE DTLS connection was not initialized.\n"]
pub fn otCoapSecureSendRequestBlockWise(
aInstance: *mut otInstance,
aMessage: *mut otMessage,
aHandler: otCoapResponseHandler,
aContext: *mut ::std::os::raw::c_void,
aTransmitHook: otCoapBlockwiseTransmitHook,
aReceiveHook: otCoapBlockwiseReceiveHook,
) -> otError;
}
extern "C" {
#[doc = " Sends a CoAP request over secure DTLS connection.\n\n If a response for a request is expected, respective function and context information should be provided.\n If no response is expected, these arguments should be NULL pointers.\n If Message Id was not set in the header (equal to 0), this function will assign unique Message Id to the message.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A reference to the message to send.\n @param[in] aHandler A function pointer that shall be called on response reception or time-out.\n @param[in] aContext A pointer to arbitrary context information.\n\n @retval OT_ERROR_NONE Successfully sent CoAP message.\n @retval OT_ERROR_NO_BUFS Failed to allocate retransmission data.\n @retval OT_ERROR_INVALID_STATE DTLS connection was not initialized.\n"]
pub fn otCoapSecureSendRequest(
aInstance: *mut otInstance,
aMessage: *mut otMessage,
aHandler: otCoapResponseHandler,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Adds a resource to the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aResource A pointer to the resource.\n"]
pub fn otCoapSecureAddResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
}
extern "C" {
#[doc = " Removes a resource from the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aResource A pointer to the resource.\n"]
pub fn otCoapSecureRemoveResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
}
extern "C" {
#[doc = " Adds a block-wise resource to the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aResource A pointer to the resource.\n"]
pub fn otCoapSecureAddBlockWiseResource(
aInstance: *mut otInstance,
aResource: *mut otCoapBlockwiseResource,
);
}
extern "C" {
#[doc = " Removes a block-wise resource from the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aResource A pointer to the resource.\n"]
pub fn otCoapSecureRemoveBlockWiseResource(
aInstance: *mut otInstance,
aResource: *mut otCoapBlockwiseResource,
);
}
extern "C" {
#[doc = " Sets the default handler for unhandled CoAP Secure requests.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aHandler A function pointer that shall be called when an unhandled request arrives.\n @param[in] aContext A pointer to arbitrary context information. May be NULL if not used.\n"]
pub fn otCoapSecureSetDefaultHandler(
aInstance: *mut otInstance,
aHandler: otCoapRequestHandler,
aContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Sets the connected callback to indicate, when\n a Client connect to the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aHandler A pointer to a function that will be called once DTLS connection is established.\n @param[in] aContext A pointer to arbitrary context information. May be NULL if not used.\n"]
pub fn otCoapSecureSetClientConnectedCallback(
aInstance: *mut otInstance,
aHandler: otHandleCoapSecureClientConnect,
aContext: *mut ::std::os::raw::c_void,
);
}
extern "C" {
#[doc = " Sends a CoAP response block-wise from the CoAP Secure server.\n\n Is available when OPENTHREAD_CONFIG_COAP_BLOCKWISE_TRANSFER_ENABLE configuration\n is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the CoAP response to send.\n @param[in] aMessageInfo A pointer to the message info associated with @p aMessage.\n @param[in] aContext A pointer to arbitrary context information. May be NULL if not used.\n @param[in] aTransmitHook A function pointer that is called on Block1 request reception.\n\n @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.\n"]
pub fn otCoapSecureSendResponseBlockWise(
aInstance: *mut otInstance,
aMessage: *mut otMessage,
aMessageInfo: *const otMessageInfo,
aContext: *mut ::std::os::raw::c_void,
aTransmitHook: otCoapBlockwiseTransmitHook,
) -> otError;
}
extern "C" {
#[doc = " Sends a CoAP response from the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the CoAP response to send.\n @param[in] aMessageInfo A pointer to the message info associated with @p aMessage.\n\n @retval OT_ERROR_NONE Successfully enqueued the CoAP response message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers available to send the CoAP response.\n"]
pub fn otCoapSecureSendResponse(
aInstance: *mut otInstance,
aMessage: *mut otMessage,
aMessageInfo: *const otMessageInfo,
) -> otError;
}
extern "C" {
#[doc = " For FTD only, creates a new Operational Dataset to use when forming a new network.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aDataset The Operational Dataset.\n\n @retval OT_ERROR_NONE Successfully created a new Operational Dataset.\n @retval OT_ERROR_FAILED Failed to generate random values for new parameters.\n"]
pub fn otDatasetCreateNewNetwork(
aInstance: *mut otInstance,
aDataset: *mut otOperationalDataset,
) -> otError;
}
extern "C" {
#[doc = " For FTD only, gets a minimal delay timer.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval the value of minimal delay timer (in ms).\n"]
pub fn otDatasetGetDelayTimerMinimal(aInstance: *mut otInstance) -> u32;
}
extern "C" {
#[doc = " For FTD only, sets a minimal delay timer.\n\n @note This API is reserved for testing and demo purposes only. Changing settings with\n this API will render a production application non-compliant with the Thread Specification.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDelayTimerMinimal The value of minimal delay timer (in ms).\n\n @retval OT_ERROR_NONE Successfully set minimal delay timer.\n @retval OT_ERROR_INVALID_ARGS If @p aDelayTimerMinimal is not valid.\n"]
pub fn otDatasetSetDelayTimerMinimal(
aInstance: *mut otInstance,
aDelayTimerMinimal: u32,
) -> otError;
}
#[doc = " This callback function pointer is called when a Dataset update request finishes, reporting success or failure status\n of the Dataset update request.\n\n Available when `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is enabled.\n\n @param[in] aError The error status.\n OT_ERROR_NONE indicates successful Dataset update.\n OT_ERROR_INVALID_STATE indicates failure due invalid state (MLE being disabled).\n OT_ERROR_ALREADY indicates failure due to another device within network requesting\n a conflicting Dataset update.\n\n @param[in] aContext A pointer to the arbitrary context (provided by user in `otDatasetUpdaterRequestUpdate()`).\n"]
pub type otDatasetUpdaterCallback = ::std::option::Option<
unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
>;
extern "C" {
#[doc = " Requests an update to Operational Dataset.\n\n Available when `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is enabled.\n\n @p aDataset should contain the fields to be updated and their new value. It must not contain Active or Pending\n Timestamp fields. The Delay field is optional, if not provided a default value (1000 ms) would be used.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDataset A pointer to the Dataset containing the fields to change.\n @param[in] aCallback A callback to indicate when Dataset update request finishes.\n @param[in] aContext An arbitrary context passed to callback.\n\n @retval OT_ERROR_NONE Dataset update started successfully (@p aCallback will be invoked on completion).\n @retval OT_ERROR_INVALID_STATE Device is disabled (MLE is disabled).\n @retval OT_ERROR_INVALID_ARGS The @p aDataset is not valid (contains Active or Pending Timestamp).\n @retval OT_ERROR_BUSY Cannot start update, a previous one is ongoing.\n @retval OT_ERROR_NO_BUFS Could not allocated buffer to save Dataset.\n"]
pub fn otDatasetUpdaterRequestUpdate(
aInstance: *mut otInstance,
aDataset: *const otOperationalDataset,
aCallback: otDatasetUpdaterCallback,
aContext: *mut ::std::os::raw::c_void,
) -> otError;
}
extern "C" {
#[doc = " Cancels an ongoing (if any) Operational Dataset update request.\n\n Available when `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n"]
pub fn otDatasetUpdaterCancelUpdate(aInstance: *mut otInstance);
}
extern "C" {
#[doc = " Indicates whether there is an ongoing Operation Dataset update request.\n\n Available when `OPENTHREAD_CONFIG_DATASET_UPDATER_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE There is an ongoing update.\n @retval FALSE There is no ongoing update.\n"]
pub fn otDatasetUpdaterIsUpdateOngoing(aInstance: *mut otInstance) -> bool;
}
extern "C" {
#[doc = " Processes a factory diagnostics command line.\n\n The output of this function (the content written to @p aOutput) MUST terminate with `\\0` and the `\\0` is within the\n output buffer.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aArgsLength The number of elements in @p aArgs.\n @param[in] aArgs An array of arguments.\n @param[out] aOutput The diagnostics execution result.\n @param[in] aOutputMaxLen The output buffer size.\n\n @retval OT_ERROR_INVALID_ARGS The command is supported but invalid arguments provided.\n @retval OT_ERROR_NONE The command is successfully process.\n @retval OT_ERROR_NOT_IMPLEMENTED The command is not supported.\n"]
pub fn otDiagProcessCmd(
aInstance: *mut otInstance,
aArgsLength: u8,
aArgs: *mut *mut ::std::os::raw::c_char,
aOutput: *mut ::std::os::raw::c_char,
aOutputMaxLen: usize,
) -> otError;
}
extern "C" {
#[doc = " Processes a factory diagnostics command line.\n\n The output of this function (the content written to @p aOutput) MUST terminate with `\\0` and the `\\0` is within the\n output buffer.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aString A NULL-terminated input string.\n @param[out] aOutput The diagnostics execution result.\n @param[in] aOutputMaxLen The output buffer size.\n\n @retval OT_ERROR_NONE The command is successfully process.\n @retval OT_ERROR_INVALID_ARGS The command is supported but invalid arguments provided.\n @retval OT_ERROR_NOT_IMPLEMENTED The command is not supported.\n @retval OT_ERROR_NO_BUFS The command string is too long.\n"]
pub fn otDiagProcessCmdLine(
aInstance: *mut otInstance,
aString: *const ::std::os::raw::c_char,
aOutput: *mut ::std::os::raw::c_char,
aOutputMaxLen: usize,
) -> otError;
}
extern "C" {
#[doc = " Indicates whether or not the factory diagnostics mode is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE if factory diagnostics mode is enabled\n @retval FALSE if factory diagnostics mode is disabled.\n"]
pub fn otDiagIsEnabled(aInstance: *mut otInstance) -> bool;
}
#[doc = " Represents a TXT record entry representing a key/value pair (RFC 6763 - section 6.3).\n\n The string buffers pointed to by `mKey` and `mValue` MUST persist and remain unchanged after an instance of such\n structure is passed to OpenThread (as part of `otSrpClientService` instance).\n\n An array of `otDnsTxtEntry` entries are used in `otSrpClientService` to specify the full TXT record (a list of\n entries).\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otDnsTxtEntry {
#[doc = " The TXT record key string.\n\n If `mKey` is not NULL, then it MUST be a null-terminated C string. The entry is treated as key/value pair with\n `mValue` buffer providing the value.\n - The entry is encoded as follows:\n - A single string length byte followed by \"key=value\" format (without the quotation marks).\n- In this case, the overall encoded length must be 255 bytes or less.\n - If `mValue` is NULL, then key is treated as a boolean attribute and encoded as \"key\" (with no `=`).\n - If `mValue` is not NULL but `mValueLength` is zero, then it is treated as empty value and encoded as \"key=\".\n\n If `mKey` is NULL, then `mValue` buffer is treated as an already encoded TXT-DATA and is appended as is in the\n DNS message.\n"]
pub mKey: *const ::std::os::raw::c_char,
#[doc = "< The TXT record value or already encoded TXT-DATA (depending on `mKey`)."]
pub mValue: *const u8,
#[doc = "< Number of bytes in `mValue` buffer."]
pub mValueLength: u16,
}
impl Default for otDnsTxtEntry {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[doc = " Represents an iterator for TXT record entries (key/value pairs).\n\n The data fields in this structure are intended for use by OpenThread core and caller should not read or change them.\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otDnsTxtEntryIterator {
pub mPtr: *const ::std::os::raw::c_void,
pub mData: [u16; 2usize],
pub mChar: [::std::os::raw::c_char; 65usize],
}
impl Default for otDnsTxtEntryIterator {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
#[doc = " Initializes a TXT record iterator.\n\n The buffer pointer @p aTxtData and its content MUST persist and remain unchanged while @p aIterator object\n is being used.\n\n @param[in] aIterator A pointer to the iterator to initialize (MUST NOT be NULL).\n @param[in] aTxtData A pointer to buffer containing the encoded TXT data.\n @param[in] aTxtDataLength The length (number of bytes) of @p aTxtData.\n"]
pub fn otDnsInitTxtEntryIterator(
aIterator: *mut otDnsTxtEntryIterator,
aTxtData: *const u8,
aTxtDataLength: u16,
);
}
extern "C" {
#[doc = " Parses the TXT data from an iterator and gets the next TXT record entry (key/value pair).\n\n The @p aIterator MUST be initialized using `otDnsInitTxtEntryIterator()` before calling this function and the TXT\n data buffer used to initialize the iterator MUST persist and remain unchanged. Otherwise the behavior of this\n function is undefined.\n\n If the parsed key string length is smaller than or equal to `OT_DNS_TXT_KEY_ITER_MAX_LENGTH` the key string is\n returned in `mKey` in @p aEntry. But if the key is longer, then `mKey` is set to NULL and the entire encoded TXT\n entry string is returned in `mValue` and `mValueLength`.\n\n @param[in] aIterator A pointer to the iterator (MUST NOT be NULL).\n @param[out] aEntry A pointer to a `otDnsTxtEntry` structure to output the parsed/read entry (MUST NOT be NULL).\n\n @retval OT_ERROR_NONE The next entry was parsed successfully. @p aEntry is updated.\n @retval OT_ERROR_NOT_FOUND No more entries in the TXT data.\n @retval OT_ERROR_PARSE The TXT data from @p aIterator is not well-formed.\n"]
pub fn otDnsGetNextTxtEntry(
aIterator: *mut otDnsTxtEntryIterator,
aEntry: *mut otDnsTxtEntry,
) -> otError;
}
extern "C" {
#[doc = " Encodes a given list of TXT record entries (key/value pairs) into TXT data (following format specified by RFC 6763).\n\n @param[in] aTxtEntries Pointer to an array of `otDnsTxtEntry`.\n @param[in] aNumTxtEntries Number of entries in @p aTxtEntries array.\n @param[out] aTxtData A pointer to a buffer to output the encoded TXT data.\n @param[in,out] aTxtDataLength On input, size of buffer @p aTxtData. On output, length of the encoded TXT data.\n\n @retval OT_ERROR_NONE Encoded TXT data successfully, @p aTxtData and @p aTxtDataLength are updated.\n @retval OT_ERROR_INVALID_ARGS The @p aTxtEntries is not valid.\n @retval OT_ERROR_NO_BUS Could not fit the encoded data in @p aTxtData buffer with its @p aTxtDataLength.\n"]
pub fn otDnsEncodeTxtData(
aTxtEntries: *const otDnsTxtEntry,
aNumTxtEntries: u16,
aTxtData: *mut u8,
aTxtDataLength: *mut u16,
) -> otError;
}
extern "C" {
#[doc = " Enables/disables the \"DNS name compression\" mode.\n\n By default DNS name compression is enabled. When disabled, DNS names are appended as full and never compressed. This\n is applicable to OpenThread's DNS and SRP client/server modules.\n\n This is intended for testing only and available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` config is enabled.\n\n Note that in the case `OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE` is used, this mode applies to all OpenThread\n instances (i.e., calling this function enables/disables the compression mode on all OpenThread instances).\n\n @param[in] aEnabled TRUE to enable the \"DNS name compression\" mode, FALSE to disable.\n"]
pub fn otDnsSetNameCompressionEnabled(aEnabled: bool);
}
extern "C" {
#[doc = " Indicates whether the \"DNS name compression\" mode is enabled or not.\n\n This is intended for testing only and available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` config is enabled.\n\n @returns TRUE if the \"DNS name compression\" mode is enabled, FALSE otherwise.\n"]
pub fn otDnsIsNameCompressionEnabled() -> bool;
}
#[doc = "< Indicates the flag is not specified."]
pub const OT_DNS_FLAG_UNSPECIFIED: otDnsRecursionFlag = 0;
#[doc = "< Indicates DNS name server can resolve the query recursively."]
pub const OT_DNS_FLAG_RECURSION_DESIRED: otDnsRecursionFlag = 1;
#[doc = "< Indicates DNS name server can not resolve the query recursively."]
pub const OT_DNS_FLAG_NO_RECURSION: otDnsRecursionFlag = 2;
#[doc = " Type represents the \"Recursion Desired\" (RD) flag in an `otDnsQueryConfig`.\n"]
pub type otDnsRecursionFlag = ::std::os::raw::c_uint;
#[doc = "< NAT64 mode is not specified. Use default NAT64 mode."]
pub const OT_DNS_NAT64_UNSPECIFIED: otDnsNat64Mode = 0;
#[doc = "< Allow NAT64 address translation during DNS client address resolution."]
pub const OT_DNS_NAT64_ALLOW: otDnsNat64Mode = 1;
#[doc = "< Do not allow NAT64 address translation during DNS client address resolution."]
pub const OT_DNS_NAT64_DISALLOW: otDnsNat64Mode = 2;
#[doc = " Type represents the NAT64 mode in an `otDnsQueryConfig`.\n\n The NAT64 mode indicates whether to allow or disallow NAT64 address translation during DNS client address resolution.\n This mode is only used when `OPENTHREAD_CONFIG_DNS_CLIENT_NAT64_ENABLE` is enabled.\n"]
pub type otDnsNat64Mode = ::std::os::raw::c_uint;
#[doc = "< Mode is not specified. Use default service mode."]
pub const OT_DNS_SERVICE_MODE_UNSPECIFIED: otDnsServiceMode = 0;
#[doc = "< Query for SRV record only."]
pub const OT_DNS_SERVICE_MODE_SRV: otDnsServiceMode = 1;
#[doc = "< Query for TXT record only."]
pub const OT_DNS_SERVICE_MODE_TXT: otDnsServiceMode = 2;
#[doc = "< Query for both SRV and TXT records in same message."]
pub const OT_DNS_SERVICE_MODE_SRV_TXT: otDnsServiceMode = 3;
#[doc = "< Query in parallel for SRV and TXT using separate messages."]
pub const OT_DNS_SERVICE_MODE_SRV_TXT_SEPARATE: otDnsServiceMode = 4;
#[doc = "< Query for TXT/SRV together first, if fails then query separately."]
pub const OT_DNS_SERVICE_MODE_SRV_TXT_OPTIMIZE: otDnsServiceMode = 5;
#[doc = " Type represents the service resolution mode in an `otDnsQueryConfig`.\n\n This is only used during DNS client service resolution `otDnsClientResolveService()`. It determines which\n record types to query.\n"]
pub type otDnsServiceMode = ::std::os::raw::c_uint;
pub const OT_DNS_TRANSPORT_UNSPECIFIED: otDnsTransportProto = 0;
#[doc = " DNS transport is unspecified."]
pub const OT_DNS_TRANSPORT_UDP: otDnsTransportProto = 1;
#[doc = " DNS query should be sent via UDP."]
pub const OT_DNS_TRANSPORT_TCP: otDnsTransportProto = 2;
#[doc = " Type represents the DNS transport protocol in an `otDnsQueryConfig`.\n\n This `OT_DNS_TRANSPORT_TCP` is only supported when `OPENTHREAD_CONFIG_DNS_CLIENT_OVER_TCP_ENABLE` is enabled.\n"]
pub type otDnsTransportProto = ::std::os::raw::c_uint;
#[doc = " Represents a DNS query configuration.\n\n Any of the fields in this structure can be set to zero to indicate that it is not specified. How the unspecified\n fields are treated is determined by the function which uses the instance of `otDnsQueryConfig`.\n"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct otDnsQueryConfig {
#[doc = "< Server address (IPv6 addr/port). All zero or zero port for unspecified."]
pub mServerSockAddr: otSockAddr,
#[doc = "< Wait time (in msec) to rx response. Zero indicates unspecified value."]
pub mResponseTimeout: u32,
#[doc = "< Maximum tx attempts before reporting failure. Zero for unspecified value."]
pub mMaxTxAttempts: u8,
#[doc = "< Indicates whether the server can resolve the query recursively or not."]
pub mRecursionFlag: otDnsRecursionFlag,
#[doc = "< Allow/Disallow NAT64 address translation during address resolution."]
pub mNat64Mode: otDnsNat64Mode,
#[doc = "< Determines which records to query during service resolution."]
pub mServiceMode: otDnsServiceMode,
#[doc = "< Select default transport protocol."]
pub mTransportProto: otDnsTransportProto,
}
impl Default for otDnsQueryConfig {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
#[doc = " Gets the current default query config used by DNS client.\n\n When OpenThread stack starts, the default DNS query config is determined from a set of OT config options such as\n `OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_SERVER_IP6_ADDRESS`, `_DEFAULT_SERVER_PORT`, `_DEFAULT_RESPONSE_TIMEOUT`, etc.\n (see `config/dns_client.h` for all related config options).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the current default config being used by DNS client.\n"]
pub fn otDnsClientGetDefaultConfig(aInstance: *mut otInstance) -> *const otDnsQueryConfig;
}
extern "C" {
#[doc = " Sets the default query config on DNS client.\n\n @note Any ongoing query will continue to use the config from when it was started. The new default config will be\n used for any future DNS queries.\n\n The @p aConfig can be NULL. In this case the default config will be set to the defaults from OT config options\n `OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_{}`. This resets the default query config back to to the config when the\n OpenThread stack starts.\n\n In a non-NULL @p aConfig, caller can choose to leave some of the fields in `otDnsQueryConfig` instance unspecified\n (value zero). The unspecified fields are replaced by the corresponding OT config option definitions\n `OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_{}` to form the default query config.\n\n When `OPENTHREAD_CONFIG_DNS_CLIENT_DEFAULT_SERVER_ADDRESS_AUTO_SET_ENABLE` is enabled, the server's IPv6 address in\n the default config is automatically set and updated by DNS client. This is done only when user does not explicitly\n set or specify it. This behavior requires SRP client and its auto-start feature to be enabled. SRP client will then\n monitor the Thread Network Data for DNS/SRP Service entries to select an SRP server. The selected SRP server address\n is also set as the DNS server address in the default config.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aConfig A pointer to the new query config to use as default.\n"]
pub fn otDnsClientSetDefaultConfig(
aInstance: *mut otInstance,
aConfig: *const otDnsQueryConfig,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otDnsAddressResponse {
_unused: [u8; 0],
}
#[doc = " Pointer is called when a DNS response is received for an address resolution query.\n\n Within this callback the user can use `otDnsAddressResponseGet{Item}()` functions along with the @p aResponse\n pointer to get more info about the response.\n\n The @p aResponse pointer can only be used within this callback and after returning from this function it will not\n stay valid, so the user MUST NOT retain the @p aResponse pointer for later use.\n\n @param[in] aError The result of the DNS transaction.\n @param[in] aResponse A pointer to the response (it is always non-NULL).\n @param[in] aContext A pointer to application-specific context.\n\n The @p aError can have the following:\n\n - OT_ERROR_NONE A response was received successfully.\n - OT_ERROR_ABORT A DNS transaction was aborted by stack.\n - OT_ERROR_RESPONSE_TIMEOUT No DNS response has been received within timeout.\n\n If the server rejects the address resolution request the error code from server is mapped as follow:\n\n - (0) NOERROR Success (no error condition) -> OT_ERROR_NONE\n - (1) FORMERR Server unable to interpret due to format error -> OT_ERROR_PARSE\n - (2) SERVFAIL Server encountered an internal failure -> OT_ERROR_FAILED\n - (3) NXDOMAIN Name that ought to exist, does not exist -> OT_ERROR_NOT_FOUND\n - (4) NOTIMP Server does not support the query type (OpCode) -> OT_ERROR_NOT_IMPLEMENTED\n - (5) REFUSED Server refused for policy/security reasons -> OT_ERROR_SECURITY\n - (6) YXDOMAIN Some name that ought not to exist, does exist -> OT_ERROR_DUPLICATED\n - (7) YXRRSET Some RRset that ought not to exist, does exist -> OT_ERROR_DUPLICATED\n - (8) NXRRSET Some RRset that ought to exist, does not exist -> OT_ERROR_NOT_FOUND\n - (9) NOTAUTH Service is not authoritative for zone -> OT_ERROR_SECURITY\n - (10) NOTZONE A name is not in the zone -> OT_ERROR_PARSE\n - (20) BADNAME Bad name -> OT_ERROR_PARSE\n - (21) BADALG Bad algorithm -> OT_ERROR_SECURITY\n - (22) BADTRUN Bad truncation -> OT_ERROR_PARSE\n - Other response codes -> OT_ERROR_FAILED\n"]
pub type otDnsAddressCallback = ::std::option::Option<
unsafe extern "C" fn(
aError: otError,
aResponse: *const otDnsAddressResponse,
aContext: *mut ::std::os::raw::c_void,
),
>;
extern "C" {
#[doc = " Sends an address resolution DNS query for AAAA (IPv6) record(s) for a given host name.\n\n The @p aConfig can be NULL. In this case the default config (from `otDnsClientGetDefaultConfig()`) will be used as\n the config for this query. In a non-NULL @p aConfig, some of the fields can be left unspecified (value zero). The\n unspecified fields are then replaced by the values from the default config.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aHostName The host name for which to query the address (MUST NOT be NULL).\n @param[in] aCallback A function pointer that shall be called on response reception or time-out.\n @param[in] aContext A pointer to arbitrary context information.\n @param[in] aConfig A pointer to the config to use for this query.\n\n @retval OT_ERROR_NONE Query sent successfully. @p aCallback will be invoked to report the status.\n @retval OT_ERROR_NO_BUFS Insufficient buffer to prepare and send query.\n @retval OT_ERROR_INVALID_ARGS The host name is not valid format.\n @retval OT_ERROR_INVALID_STATE Cannot send query since Thread interface is not up.\n"]
pub fn otDnsClientResolveAddress(
aInstance: *mut otInstance,
aHostName: *const ::std::os::raw::c_char,
aCallback: otDnsAddressCallback,
aContext: *mut ::std::os::raw::c_void,
aConfig: *const otDnsQueryConfig,
) -> otError;
}
extern "C" {
#[doc = " Sends an address resolution DNS query for A (IPv4) record(s) for a given host name.\n\n Requires and is available when `OPENTHREAD_CONFIG_DNS_CLIENT_NAT64_ENABLE` is enabled.\n\n When a successful response is received, the addresses are returned from @p aCallback as NAT64 IPv6 translated\n versions of the IPv4 addresses from the query response.\n\n The @p aConfig can be NULL. In this case the default config (from `otDnsClientGetDefaultConfig()`) will be used as\n the config for this query. In a non-NULL @p aConfig, some of the fields can be left unspecified (value zero). The\n unspecified fields are then replaced by the values from the default config.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aHostName The host name for which to query the address (MUST NOT be NULL).\n @param[in] aCallback A function pointer that shall be called on response reception or time-out.\n @param[in] aContext A pointer to arbitrary context information.\n @param[in] aConfig A pointer to the config to use for this query.\n\n @retval OT_ERROR_NONE Query sent successfully. @p aCallback will be invoked to report the status.\n @retval OT_ERROR_NO_BUFS Insufficient buffer to prepare and send query.\n @retval OT_ERROR_INVALID_ARGS The host name is not valid format or NAT64 is not enabled in config.\n @retval OT_ERROR_INVALID_STATE Cannot send query since Thread interface is not up.\n"]
pub fn otDnsClientResolveIp4Address(
aInstance: *mut otInstance,
aHostName: *const ::std::os::raw::c_char,
aCallback: otDnsAddressCallback,
aContext: *mut ::std::os::raw::c_void,
aConfig: *const otDnsQueryConfig,
) -> otError;
}
extern "C" {
#[doc = " Gets the full host name associated with an address resolution DNS response.\n\n MUST only be used from `otDnsAddressCallback`.\n\n @param[in] aResponse A pointer to the response.\n @param[out] aNameBuffer A buffer to char array to output the full host name (MUST NOT be NULL).\n @param[in] aNameBufferSize The size of @p aNameBuffer.\n\n @retval OT_ERROR_NONE The full host name was read successfully.\n @retval OT_ERROR_NO_BUFS The name does not fit in @p aNameBuffer.\n"]
pub fn otDnsAddressResponseGetHostName(
aResponse: *const otDnsAddressResponse,
aNameBuffer: *mut ::std::os::raw::c_char,
aNameBufferSize: u16,
) -> otError;
}
extern "C" {
#[doc = " Gets an IPv6 address associated with an address resolution DNS response.\n\n MUST only be used from `otDnsAddressCallback`.\n\n The response may include multiple IPv6 address records. @p aIndex can be used to iterate through the list of\n addresses. Index zero gets the first address and so on. When we reach end of the list, `OT_ERROR_NOT_FOUND` is\n returned.\n\n @param[in] aResponse A pointer to the response.\n @param[in] aIndex The address record index to retrieve.\n @param[out] aAddress A pointer to a IPv6 address to output the address (MUST NOT be NULL).\n @param[out] aTtl A pointer to an `uint32_t` to output TTL for the address. It can be NULL if caller does not\n want to get the TTL.\n\n @retval OT_ERROR_NONE The address was read successfully.\n @retval OT_ERROR_NOT_FOUND No address record in @p aResponse at @p aIndex.\n @retval OT_ERROR_PARSE Could not parse the records in the @p aResponse.\n @retval OT_ERROR_INVALID_STATE No NAT64 prefix (applicable only when NAT64 is allowed).\n"]
pub fn otDnsAddressResponseGetAddress(
aResponse: *const otDnsAddressResponse,
aIndex: u16,
aAddress: *mut otIp6Address,
aTtl: *mut u32,
) -> otError;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct otDnsBrowseResponse {
_unused: [u8; 0],
}
#[doc = " Pointer is called when a DNS response is received for a browse (service instance enumeration) query.\n\n Within this callback the user can use `otDnsBrowseResponseGet{Item}()` functions along with the @p aResponse\n pointer to get more info about the response.\n\n The @p aResponse pointer can only be used within this callback and after returning from this function it will not\n stay valid, so the user MUST NOT retain the @p aResponse pointer for later use.\n\n @param[in] aError The result of the DNS transaction.\n @param[in] aResponse A pointer to the response (it is always non-NULL).\n @param[in] aContext A pointer to application-specific context.\n\n For the full list of possible values for @p aError, please see `otDnsAddressCallback()`.\n"]
pub type otDnsBrowseCallback = ::std::option::Option<
unsaf