1#![allow(dead_code)]
8#![allow(non_camel_case_types)]
9#![allow(non_snake_case)]
10#![allow(non_upper_case_globals)]
11#![allow(clippy::missing_safety_doc)]
12
13#[repr(C)]
14#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct __BindgenBitfieldUnit<Storage> {
16 storage: Storage,
17}
18impl<Storage> __BindgenBitfieldUnit<Storage> {
19 #[inline]
20 pub const fn new(storage: Storage) -> Self {
21 Self { storage }
22 }
23}
24impl<Storage> __BindgenBitfieldUnit<Storage>
25where
26 Storage: AsRef<[u8]> + AsMut<[u8]>,
27{
28 #[inline]
29 pub fn get_bit(&self, index: usize) -> bool {
30 debug_assert!(index / 8 < self.storage.as_ref().len());
31 let byte_index = index / 8;
32 let byte = self.storage.as_ref()[byte_index];
33 let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 };
34 let mask = 1 << bit_index;
35 byte & mask == mask
36 }
37 #[inline]
38 pub fn set_bit(&mut self, index: usize, val: bool) {
39 debug_assert!(index / 8 < self.storage.as_ref().len());
40 let byte_index = index / 8;
41 let byte = &mut self.storage.as_mut()[byte_index];
42 let bit_index = if cfg!(target_endian = "big") { 7 - (index % 8) } else { index % 8 };
43 let mask = 1 << bit_index;
44 if val {
45 *byte |= mask;
46 } else {
47 *byte &= !mask;
48 }
49 }
50 #[inline]
51 pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
52 debug_assert!(bit_width <= 64);
53 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
54 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
55 let mut val = 0;
56 for i in 0..(bit_width as usize) {
57 if self.get_bit(i + bit_offset) {
58 let index =
59 if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i };
60 val |= 1 << index;
61 }
62 }
63 val
64 }
65 #[inline]
66 pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
67 debug_assert!(bit_width <= 64);
68 debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
69 debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
70 for i in 0..(bit_width as usize) {
71 let mask = 1 << i;
72 let val_bit_is_set = val & mask == mask;
73 let index = if cfg!(target_endian = "big") { bit_width as usize - 1 - i } else { i };
74 self.set_bit(index + bit_offset, val_bit_is_set);
75 }
76 }
77}
78pub const OT_LOG_LEVEL_NONE: u32 = 0;
79pub const OT_LOG_LEVEL_CRIT: u32 = 1;
80pub const OT_LOG_LEVEL_WARN: u32 = 2;
81pub const OT_LOG_LEVEL_NOTE: u32 = 3;
82pub const OT_LOG_LEVEL_INFO: u32 = 4;
83pub const OT_LOG_LEVEL_DEBG: u32 = 5;
84pub const OPENTHREAD_API_VERSION: u32 = 483;
85pub const OT_UPTIME_STRING_SIZE: u32 = 24;
86pub const OT_CHANGED_IP6_ADDRESS_ADDED: u32 = 1;
87pub const OT_CHANGED_IP6_ADDRESS_REMOVED: u32 = 2;
88pub const OT_CHANGED_THREAD_ROLE: u32 = 4;
89pub const OT_CHANGED_THREAD_LL_ADDR: u32 = 8;
90pub const OT_CHANGED_THREAD_ML_ADDR: u32 = 16;
91pub const OT_CHANGED_THREAD_RLOC_ADDED: u32 = 32;
92pub const OT_CHANGED_THREAD_RLOC_REMOVED: u32 = 64;
93pub const OT_CHANGED_THREAD_PARTITION_ID: u32 = 128;
94pub const OT_CHANGED_THREAD_KEY_SEQUENCE_COUNTER: u32 = 256;
95pub const OT_CHANGED_THREAD_NETDATA: u32 = 512;
96pub const OT_CHANGED_THREAD_CHILD_ADDED: u32 = 1024;
97pub const OT_CHANGED_THREAD_CHILD_REMOVED: u32 = 2048;
98pub const OT_CHANGED_IP6_MULTICAST_SUBSCRIBED: u32 = 4096;
99pub const OT_CHANGED_IP6_MULTICAST_UNSUBSCRIBED: u32 = 8192;
100pub const OT_CHANGED_THREAD_CHANNEL: u32 = 16384;
101pub const OT_CHANGED_THREAD_PANID: u32 = 32768;
102pub const OT_CHANGED_THREAD_NETWORK_NAME: u32 = 65536;
103pub const OT_CHANGED_THREAD_EXT_PANID: u32 = 131072;
104pub const OT_CHANGED_NETWORK_KEY: u32 = 262144;
105pub const OT_CHANGED_PSKC: u32 = 524288;
106pub const OT_CHANGED_SECURITY_POLICY: u32 = 1048576;
107pub const OT_CHANGED_CHANNEL_MANAGER_NEW_CHANNEL: u32 = 2097152;
108pub const OT_CHANGED_SUPPORTED_CHANNEL_MASK: u32 = 4194304;
109pub const OT_CHANGED_COMMISSIONER_STATE: u32 = 8388608;
110pub const OT_CHANGED_THREAD_NETIF_STATE: u32 = 16777216;
111pub const OT_CHANGED_THREAD_BACKBONE_ROUTER_STATE: u32 = 33554432;
112pub const OT_CHANGED_THREAD_BACKBONE_ROUTER_LOCAL: u32 = 67108864;
113pub const OT_CHANGED_JOINER_STATE: u32 = 134217728;
114pub const OT_CHANGED_ACTIVE_DATASET: u32 = 268435456;
115pub const OT_CHANGED_PENDING_DATASET: u32 = 536870912;
116pub const OT_CHANGED_NAT64_TRANSLATOR_STATE: u32 = 1073741824;
117pub const OT_CHANGED_PARENT_LINK_QUALITY: u32 = 2147483648;
118pub const OT_CRYPTO_SHA256_HASH_SIZE: u32 = 32;
119pub const OT_CRYPTO_ECDSA_MAX_DER_SIZE: u32 = 125;
120pub const OT_CRYPTO_ECDSA_PUBLIC_KEY_SIZE: u32 = 64;
121pub const OT_CRYPTO_ECDSA_SIGNATURE_SIZE: u32 = 64;
122pub const OT_CRYPTO_PBDKF2_MAX_SALT_SIZE: u32 = 30;
123pub const OT_PANID_BROADCAST: u32 = 65535;
124pub const OT_EXT_ADDRESS_SIZE: u32 = 8;
125pub const OT_MAC_KEY_SIZE: u32 = 16;
126pub const OT_IP6_PREFIX_SIZE: u32 = 8;
127pub const OT_IP6_PREFIX_BITSIZE: u32 = 64;
128pub const OT_IP6_IID_SIZE: u32 = 8;
129pub const OT_IP6_ADDRESS_SIZE: u32 = 16;
130pub const OT_IP6_ADDRESS_BITSIZE: u32 = 128;
131pub const OT_IP6_HEADER_SIZE: u32 = 40;
132pub const OT_IP6_HEADER_PROTO_OFFSET: u32 = 6;
133pub const OT_IP6_ADDRESS_STRING_SIZE: u32 = 40;
134pub const OT_IP6_SOCK_ADDR_STRING_SIZE: u32 = 48;
135pub const OT_IP6_PREFIX_STRING_SIZE: u32 = 45;
136pub const OT_IP6_MAX_MLR_ADDRESSES: u32 = 15;
137pub const OT_NETWORK_KEY_SIZE: u32 = 16;
138pub const OT_NETWORK_NAME_MAX_SIZE: u32 = 16;
139pub const OT_EXT_PAN_ID_SIZE: u32 = 8;
140pub const OT_MESH_LOCAL_PREFIX_SIZE: u32 = 8;
141pub const OT_PSKC_MAX_SIZE: u32 = 16;
142pub const OT_CHANNEL_1_MASK: u32 = 2;
143pub const OT_CHANNEL_2_MASK: u32 = 4;
144pub const OT_CHANNEL_3_MASK: u32 = 8;
145pub const OT_CHANNEL_4_MASK: u32 = 16;
146pub const OT_CHANNEL_5_MASK: u32 = 32;
147pub const OT_CHANNEL_6_MASK: u32 = 64;
148pub const OT_CHANNEL_7_MASK: u32 = 128;
149pub const OT_CHANNEL_8_MASK: u32 = 256;
150pub const OT_CHANNEL_9_MASK: u32 = 512;
151pub const OT_CHANNEL_10_MASK: u32 = 1024;
152pub const OT_CHANNEL_11_MASK: u32 = 2048;
153pub const OT_CHANNEL_12_MASK: u32 = 4096;
154pub const OT_CHANNEL_13_MASK: u32 = 8192;
155pub const OT_CHANNEL_14_MASK: u32 = 16384;
156pub const OT_CHANNEL_15_MASK: u32 = 32768;
157pub const OT_CHANNEL_16_MASK: u32 = 65536;
158pub const OT_CHANNEL_17_MASK: u32 = 131072;
159pub const OT_CHANNEL_18_MASK: u32 = 262144;
160pub const OT_CHANNEL_19_MASK: u32 = 524288;
161pub const OT_CHANNEL_20_MASK: u32 = 1048576;
162pub const OT_CHANNEL_21_MASK: u32 = 2097152;
163pub const OT_CHANNEL_22_MASK: u32 = 4194304;
164pub const OT_CHANNEL_23_MASK: u32 = 8388608;
165pub const OT_CHANNEL_24_MASK: u32 = 16777216;
166pub const OT_CHANNEL_25_MASK: u32 = 33554432;
167pub const OT_CHANNEL_26_MASK: u32 = 67108864;
168pub const OT_OPERATIONAL_DATASET_MAX_LENGTH: u32 = 254;
169pub const OT_JOINER_MAX_DISCERNER_LENGTH: u32 = 64;
170pub const OT_COMMISSIONING_PASSPHRASE_MIN_SIZE: u32 = 6;
171pub const OT_COMMISSIONING_PASSPHRASE_MAX_SIZE: u32 = 255;
172pub const OT_PROVISIONING_URL_MAX_SIZE: u32 = 64;
173pub const OT_STEERING_DATA_MAX_LENGTH: u32 = 16;
174pub const OT_JOINER_MAX_PSKD_LENGTH: u32 = 32;
175pub const OT_NETWORK_DATA_ITERATOR_INIT: u32 = 0;
176pub const OT_SERVICE_DATA_MAX_SIZE: u32 = 252;
177pub const OT_SERVER_DATA_MAX_SIZE: u32 = 248;
178pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ITERATOR_INIT: u32 = 0;
179pub const OT_BORDER_AGENT_ID_LENGTH: u32 = 16;
180pub const OT_BORDER_AGENT_MESHCOP_SERVICE_TXT_DATA_MAX_LENGTH: u32 = 128;
181pub const OT_BORDER_AGENT_MIN_EPHEMERAL_KEY_LENGTH: u32 = 6;
182pub const OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_LENGTH: u32 = 32;
183pub const OT_BORDER_AGENT_DEFAULT_EPHEMERAL_KEY_TIMEOUT: u32 = 120000;
184pub const OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT: u32 = 600000;
185pub const OT_DEFAULT_COAP_PORT: u32 = 5683;
186pub const OT_COAP_DEFAULT_TOKEN_LENGTH: u32 = 2;
187pub const OT_COAP_MAX_TOKEN_LENGTH: u32 = 8;
188pub const OT_COAP_MAX_RETRANSMIT: u32 = 20;
189pub const OT_COAP_MIN_ACK_TIMEOUT: u32 = 1000;
190pub const OT_DEFAULT_COAP_SECURE_PORT: u32 = 5684;
191pub const OPENTHREAD_LIB_SPINEL_RX_FRAME_BUFFER_SIZE: u32 = 65535;
192pub const OPENTHREAD_POSIX_CONFIG_RCP_TIME_SYNC_INTERVAL: u32 = 60000000;
193pub const OPENTHREAD_SPINEL_CONFIG_ABORT_ON_UNEXPECTED_RCP_RESET_ENABLE: u32 = 1;
194pub const OT_DNS_MAX_NAME_SIZE: u32 = 255;
195pub const OT_DNS_MAX_LABEL_SIZE: u32 = 64;
196pub const OT_DNS_TXT_KEY_MIN_LENGTH: u32 = 1;
197pub const OT_DNS_TXT_KEY_MAX_LENGTH: u32 = 9;
198pub const OT_DNS_TXT_KEY_ITER_MAX_LENGTH: u32 = 64;
199pub const OT_ICMP6_HEADER_DATA_SIZE: u32 = 4;
200pub const OT_ICMP6_ROUTER_ADVERT_MIN_SIZE: u32 = 16;
201pub const OT_MAC_FILTER_FIXED_RSS_DISABLED: u32 = 127;
202pub const OT_MAC_FILTER_ITERATOR_INIT: u32 = 0;
203pub const OT_LINK_CSL_PERIOD_TEN_SYMBOLS_UNIT_IN_USEC: u32 = 160;
204pub const OT_LOG_HEX_DUMP_LINE_SIZE: u32 = 73;
205pub const OT_IP4_ADDRESS_SIZE: u32 = 4;
206pub const OT_IP4_ADDRESS_STRING_SIZE: u32 = 17;
207pub const OT_IP4_CIDR_STRING_SIZE: u32 = 20;
208pub const OT_THREAD_VERSION_INVALID: u32 = 0;
209pub const OT_THREAD_VERSION_1_1: u32 = 2;
210pub const OT_THREAD_VERSION_1_2: u32 = 3;
211pub const OT_THREAD_VERSION_1_3: u32 = 4;
212pub const OT_THREAD_VERSION_1_3_1: u32 = 5;
213pub const OT_THREAD_VERSION_1_4: u32 = 5;
214pub const OT_NETWORK_BASE_TLV_MAX_LENGTH: u32 = 254;
215pub const OT_NETWORK_MAX_ROUTER_ID: u32 = 62;
216pub const OT_NEIGHBOR_INFO_ITERATOR_INIT: u32 = 0;
217pub const OT_JOINER_ADVDATA_MAX_LENGTH: u32 = 64;
218pub const OT_DURATION_STRING_SIZE: u32 = 21;
219pub const OT_NETWORK_DIAGNOSTIC_TLV_EXT_ADDRESS: u32 = 0;
220pub const OT_NETWORK_DIAGNOSTIC_TLV_SHORT_ADDRESS: u32 = 1;
221pub const OT_NETWORK_DIAGNOSTIC_TLV_MODE: u32 = 2;
222pub const OT_NETWORK_DIAGNOSTIC_TLV_TIMEOUT: u32 = 3;
223pub const OT_NETWORK_DIAGNOSTIC_TLV_CONNECTIVITY: u32 = 4;
224pub const OT_NETWORK_DIAGNOSTIC_TLV_ROUTE: u32 = 5;
225pub const OT_NETWORK_DIAGNOSTIC_TLV_LEADER_DATA: u32 = 6;
226pub const OT_NETWORK_DIAGNOSTIC_TLV_NETWORK_DATA: u32 = 7;
227pub const OT_NETWORK_DIAGNOSTIC_TLV_IP6_ADDR_LIST: u32 = 8;
228pub const OT_NETWORK_DIAGNOSTIC_TLV_MAC_COUNTERS: u32 = 9;
229pub const OT_NETWORK_DIAGNOSTIC_TLV_BATTERY_LEVEL: u32 = 14;
230pub const OT_NETWORK_DIAGNOSTIC_TLV_SUPPLY_VOLTAGE: u32 = 15;
231pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD_TABLE: u32 = 16;
232pub const OT_NETWORK_DIAGNOSTIC_TLV_CHANNEL_PAGES: u32 = 17;
233pub const OT_NETWORK_DIAGNOSTIC_TLV_TYPE_LIST: u32 = 18;
234pub const OT_NETWORK_DIAGNOSTIC_TLV_MAX_CHILD_TIMEOUT: u32 = 19;
235pub const OT_NETWORK_DIAGNOSTIC_TLV_EUI64: u32 = 23;
236pub const OT_NETWORK_DIAGNOSTIC_TLV_VERSION: u32 = 24;
237pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_NAME: u32 = 25;
238pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_MODEL: u32 = 26;
239pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_SW_VERSION: u32 = 27;
240pub const OT_NETWORK_DIAGNOSTIC_TLV_THREAD_STACK_VERSION: u32 = 28;
241pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD: u32 = 29;
242pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD_IP6_ADDR_LIST: u32 = 30;
243pub const OT_NETWORK_DIAGNOSTIC_TLV_ROUTER_NEIGHBOR: u32 = 31;
244pub const OT_NETWORK_DIAGNOSTIC_TLV_ANSWER: u32 = 32;
245pub const OT_NETWORK_DIAGNOSTIC_TLV_QUERY_ID: u32 = 33;
246pub const OT_NETWORK_DIAGNOSTIC_TLV_MLE_COUNTERS: u32 = 34;
247pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_APP_URL: u32 = 35;
248pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_NAME_TLV_LENGTH: u32 = 32;
249pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_MODEL_TLV_LENGTH: u32 = 32;
250pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_SW_VERSION_TLV_LENGTH: u32 = 16;
251pub const OT_NETWORK_DIAGNOSTIC_MAX_THREAD_STACK_VERSION_TLV_LENGTH: u32 = 64;
252pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_APP_URL_TLV_LENGTH: u32 = 96;
253pub const OT_NETWORK_DIAGNOSTIC_ITERATOR_INIT: u32 = 0;
254pub const OT_TIME_SYNC_INVALID_SEQ: u32 = 0;
255pub const OT_PLAT_INFRA_IF_MAX_LINK_LAYER_ADDR_LENGTH: u32 = 16;
256pub const OT_MS_PER_S: u32 = 1000;
257pub const OT_US_PER_MS: u32 = 1000;
258pub const OT_US_PER_S: u32 = 1000000;
259pub const OT_NS_PER_US: u32 = 1000;
260pub const OT_SNTP_DEFAULT_SERVER_IP: &[u8; 19usize] = b"2001:4860:4806:8::\0";
261pub const OT_SNTP_DEFAULT_SERVER_PORT: u32 = 123;
262pub const OT_TCP_ENDPOINT_TCB_SIZE_BASE: u32 = 392;
263pub const OT_TCP_ENDPOINT_TCB_NUM_PTR: u32 = 36;
264pub const OT_TCP_RECEIVE_BUFFER_SIZE_FEW_HOPS: u32 = 2598;
265pub const OT_TCP_RECEIVE_BUFFER_SIZE_MANY_HOPS: u32 = 4157;
266pub const OT_TCP_LISTENER_TCB_SIZE_BASE: u32 = 16;
267pub const OT_TCP_LISTENER_TCB_NUM_PTR: u32 = 3;
268pub const OT_CHILD_IP6_ADDRESS_ITERATOR_INIT: u32 = 0;
269#[doc = " No error."]
270pub const OT_ERROR_NONE: otError = 0;
271#[doc = " Operational failed."]
272pub const OT_ERROR_FAILED: otError = 1;
273#[doc = " Message was dropped."]
274pub const OT_ERROR_DROP: otError = 2;
275#[doc = " Insufficient buffers."]
276pub const OT_ERROR_NO_BUFS: otError = 3;
277#[doc = " No route available."]
278pub const OT_ERROR_NO_ROUTE: otError = 4;
279#[doc = " Service is busy and could not service the operation."]
280pub const OT_ERROR_BUSY: otError = 5;
281#[doc = " Failed to parse message."]
282pub const OT_ERROR_PARSE: otError = 6;
283#[doc = " Input arguments are invalid."]
284pub const OT_ERROR_INVALID_ARGS: otError = 7;
285#[doc = " Security checks failed."]
286pub const OT_ERROR_SECURITY: otError = 8;
287#[doc = " Address resolution requires an address query operation."]
288pub const OT_ERROR_ADDRESS_QUERY: otError = 9;
289#[doc = " Address is not in the source match table."]
290pub const OT_ERROR_NO_ADDRESS: otError = 10;
291#[doc = " Operation was aborted."]
292pub const OT_ERROR_ABORT: otError = 11;
293#[doc = " Function or method is not implemented."]
294pub const OT_ERROR_NOT_IMPLEMENTED: otError = 12;
295#[doc = " Cannot complete due to invalid state."]
296pub const OT_ERROR_INVALID_STATE: otError = 13;
297#[doc = " No acknowledgment was received after macMaxFrameRetries (IEEE 802.15.4-2006)."]
298pub const OT_ERROR_NO_ACK: otError = 14;
299#[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)."]
300pub const OT_ERROR_CHANNEL_ACCESS_FAILURE: otError = 15;
301#[doc = " Not currently attached to a Thread Partition."]
302pub const OT_ERROR_DETACHED: otError = 16;
303#[doc = " FCS check failure while receiving."]
304pub const OT_ERROR_FCS: otError = 17;
305#[doc = " No frame received."]
306pub const OT_ERROR_NO_FRAME_RECEIVED: otError = 18;
307#[doc = " Received a frame from an unknown neighbor."]
308pub const OT_ERROR_UNKNOWN_NEIGHBOR: otError = 19;
309#[doc = " Received a frame from an invalid source address."]
310pub const OT_ERROR_INVALID_SOURCE_ADDRESS: otError = 20;
311#[doc = " Received a frame filtered by the address filter (allowlisted or denylisted)."]
312pub const OT_ERROR_ADDRESS_FILTERED: otError = 21;
313#[doc = " Received a frame filtered by the destination address check."]
314pub const OT_ERROR_DESTINATION_ADDRESS_FILTERED: otError = 22;
315#[doc = " The requested item could not be found."]
316pub const OT_ERROR_NOT_FOUND: otError = 23;
317#[doc = " The operation is already in progress."]
318pub const OT_ERROR_ALREADY: otError = 24;
319#[doc = " The creation of IPv6 address failed."]
320pub const OT_ERROR_IP6_ADDRESS_CREATION_FAILURE: otError = 26;
321#[doc = " Operation prevented by mode flags"]
322pub const OT_ERROR_NOT_CAPABLE: otError = 27;
323#[doc = " Coap response or acknowledgment or DNS, SNTP response not received."]
324pub const OT_ERROR_RESPONSE_TIMEOUT: otError = 28;
325#[doc = " Received a duplicated frame."]
326pub const OT_ERROR_DUPLICATED: otError = 29;
327#[doc = " Message is being dropped from reassembly list due to timeout."]
328pub const OT_ERROR_REASSEMBLY_TIMEOUT: otError = 30;
329#[doc = " Message is not a TMF Message."]
330pub const OT_ERROR_NOT_TMF: otError = 31;
331#[doc = " Received a non-lowpan data frame."]
332pub const OT_ERROR_NOT_LOWPAN_DATA_FRAME: otError = 32;
333#[doc = " The link margin was too low."]
334pub const OT_ERROR_LINK_MARGIN_LOW: otError = 34;
335#[doc = " Input (CLI) command is invalid."]
336pub const OT_ERROR_INVALID_COMMAND: otError = 35;
337#[doc = " Special error code used to indicate success/error status is pending and not yet known."]
338pub const OT_ERROR_PENDING: otError = 36;
339#[doc = " Request rejected."]
340pub const OT_ERROR_REJECTED: otError = 37;
341#[doc = " The number of defined errors."]
342pub const OT_NUM_ERRORS: otError = 38;
343#[doc = " Generic error (should not use)."]
344pub const OT_ERROR_GENERIC: otError = 255;
345#[doc = " Represents error codes used throughout OpenThread."]
346pub type otError = ::std::os::raw::c_uint;
347extern "C" {
348 #[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."]
349 pub fn otThreadErrorToString(aError: otError) -> *const ::std::os::raw::c_char;
350}
351pub type va_list = __builtin_va_list;
352#[doc = " Represents the log level."]
353pub type otLogLevel = ::std::os::raw::c_int;
354#[doc = "< OpenThread API"]
355pub const OT_LOG_REGION_API: otLogRegion = 1;
356#[doc = "< MLE"]
357pub const OT_LOG_REGION_MLE: otLogRegion = 2;
358#[doc = "< EID-to-RLOC mapping."]
359pub const OT_LOG_REGION_ARP: otLogRegion = 3;
360#[doc = "< Network Data"]
361pub const OT_LOG_REGION_NET_DATA: otLogRegion = 4;
362#[doc = "< ICMPv6"]
363pub const OT_LOG_REGION_ICMP: otLogRegion = 5;
364#[doc = "< IPv6"]
365pub const OT_LOG_REGION_IP6: otLogRegion = 6;
366#[doc = "< TCP"]
367pub const OT_LOG_REGION_TCP: otLogRegion = 7;
368#[doc = "< IEEE 802.15.4 MAC"]
369pub const OT_LOG_REGION_MAC: otLogRegion = 8;
370#[doc = "< Memory"]
371pub const OT_LOG_REGION_MEM: otLogRegion = 9;
372#[doc = "< NCP"]
373pub const OT_LOG_REGION_NCP: otLogRegion = 10;
374#[doc = "< Mesh Commissioning Protocol"]
375pub const OT_LOG_REGION_MESH_COP: otLogRegion = 11;
376#[doc = "< Network Diagnostic"]
377pub const OT_LOG_REGION_NET_DIAG: otLogRegion = 12;
378#[doc = "< Platform"]
379pub const OT_LOG_REGION_PLATFORM: otLogRegion = 13;
380#[doc = "< CoAP"]
381pub const OT_LOG_REGION_COAP: otLogRegion = 14;
382#[doc = "< CLI"]
383pub const OT_LOG_REGION_CLI: otLogRegion = 15;
384#[doc = "< OpenThread Core"]
385pub const OT_LOG_REGION_CORE: otLogRegion = 16;
386#[doc = "< Utility module"]
387pub const OT_LOG_REGION_UTIL: otLogRegion = 17;
388#[doc = "< Backbone Router (available since Thread 1.2)"]
389pub const OT_LOG_REGION_BBR: otLogRegion = 18;
390#[doc = "< Multicast Listener Registration (available since Thread 1.2)"]
391pub const OT_LOG_REGION_MLR: otLogRegion = 19;
392#[doc = "< Domain Unicast Address (available since Thread 1.2)"]
393pub const OT_LOG_REGION_DUA: otLogRegion = 20;
394#[doc = "< Border Router"]
395pub const OT_LOG_REGION_BR: otLogRegion = 21;
396#[doc = "< Service Registration Protocol (SRP)"]
397pub const OT_LOG_REGION_SRP: otLogRegion = 22;
398#[doc = "< DNS"]
399pub const OT_LOG_REGION_DNS: otLogRegion = 23;
400#[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`."]
401pub type otLogRegion = ::std::os::raw::c_uint;
402extern "C" {
403 #[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."]
404 pub fn otPlatLog(
405 aLogLevel: otLogLevel,
406 aLogRegion: otLogRegion,
407 aFormat: *const ::std::os::raw::c_char,
408 ...
409 );
410}
411extern "C" {
412 #[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."]
413 pub fn otPlatLogHandleLevelChanged(aLogLevel: otLogLevel);
414}
415#[repr(C)]
416#[derive(Debug, Default, Copy, Clone)]
417pub struct otInstance {
418 _unused: [u8; 0],
419}
420extern "C" {
421 #[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"]
422 pub fn otInstanceInit(
423 aInstanceBuffer: *mut ::std::os::raw::c_void,
424 aInstanceBufferSize: *mut usize,
425 ) -> *mut otInstance;
426}
427extern "C" {
428 #[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."]
429 pub fn otInstanceInitSingle() -> *mut otInstance;
430}
431extern "C" {
432 #[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."]
433 pub fn otInstanceInitMultiple(aIdx: u8) -> *mut otInstance;
434}
435extern "C" {
436 #[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."]
437 pub fn otInstanceGetId(aInstance: *mut otInstance) -> u32;
438}
439extern "C" {
440 #[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."]
441 pub fn otInstanceIsInitialized(aInstance: *mut otInstance) -> bool;
442}
443extern "C" {
444 #[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."]
445 pub fn otInstanceFinalize(aInstance: *mut otInstance);
446}
447extern "C" {
448 #[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)."]
449 pub fn otInstanceGetUptime(aInstance: *mut otInstance) -> u64;
450}
451extern "C" {
452 #[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`."]
453 pub fn otInstanceGetUptimeAsString(
454 aInstance: *mut otInstance,
455 aBuffer: *mut ::std::os::raw::c_char,
456 aSize: u16,
457 );
458}
459#[doc = " Represents a bit-field indicating specific state/configuration that has changed. See `OT_CHANGED_*`\n definitions."]
460pub type otChangedFlags = u32;
461#[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."]
462pub type otStateChangedCallback = ::std::option::Option<
463 unsafe extern "C" fn(aFlags: otChangedFlags, aContext: *mut ::std::os::raw::c_void),
464>;
465extern "C" {
466 #[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."]
467 pub fn otSetStateChangedCallback(
468 aInstance: *mut otInstance,
469 aCallback: otStateChangedCallback,
470 aContext: *mut ::std::os::raw::c_void,
471 ) -> otError;
472}
473extern "C" {
474 #[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."]
475 pub fn otRemoveStateChangeCallback(
476 aInstance: *mut otInstance,
477 aCallback: otStateChangedCallback,
478 aContext: *mut ::std::os::raw::c_void,
479 );
480}
481extern "C" {
482 #[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."]
483 pub fn otInstanceReset(aInstance: *mut otInstance);
484}
485extern "C" {
486 #[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."]
487 pub fn otInstanceResetToBootloader(aInstance: *mut otInstance) -> otError;
488}
489extern "C" {
490 #[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."]
491 pub fn otInstanceFactoryReset(aInstance: *mut otInstance);
492}
493extern "C" {
494 #[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."]
495 pub fn otInstanceResetRadioStack(aInstance: *mut otInstance);
496}
497extern "C" {
498 #[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."]
499 pub fn otInstanceErasePersistentInfo(aInstance: *mut otInstance) -> otError;
500}
501extern "C" {
502 #[doc = " Gets the OpenThread version string.\n\n @returns A pointer to the OpenThread version."]
503 pub fn otGetVersionString() -> *const ::std::os::raw::c_char;
504}
505extern "C" {
506 #[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."]
507 pub fn otGetRadioVersionString(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
508}
509#[doc = " Represents Backbone Router configuration."]
510#[repr(C)]
511#[derive(Debug, Default, Copy, Clone)]
512pub struct otBackboneRouterConfig {
513 #[doc = "< Only used when get Primary Backbone Router information in the Thread Network"]
514 pub mServer16: u16,
515 #[doc = "< Reregistration Delay (in seconds)"]
516 pub mReregistrationDelay: u16,
517 #[doc = "< Multicast Listener Registration Timeout (in seconds)"]
518 pub mMlrTimeout: u32,
519 #[doc = "< Sequence Number"]
520 pub mSequenceNumber: u8,
521}
522extern "C" {
523 #[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."]
524 pub fn otBackboneRouterGetPrimary(
525 aInstance: *mut otInstance,
526 aConfig: *mut otBackboneRouterConfig,
527 ) -> otError;
528}
529#[repr(C)]
530#[derive(Debug, Default, Copy, Clone)]
531pub struct otMessage {
532 _unused: [u8; 0],
533}
534#[doc = "< Low priority level."]
535pub const OT_MESSAGE_PRIORITY_LOW: otMessagePriority = 0;
536#[doc = "< Normal priority level."]
537pub const OT_MESSAGE_PRIORITY_NORMAL: otMessagePriority = 1;
538#[doc = "< High priority level."]
539pub const OT_MESSAGE_PRIORITY_HIGH: otMessagePriority = 2;
540#[doc = " Defines the OpenThread message priority levels."]
541pub type otMessagePriority = ::std::os::raw::c_uint;
542#[doc = "< Message from Thread Netif."]
543pub const OT_MESSAGE_ORIGIN_THREAD_NETIF: otMessageOrigin = 0;
544#[doc = "< Message from a trusted source on host."]
545pub const OT_MESSAGE_ORIGIN_HOST_TRUSTED: otMessageOrigin = 1;
546#[doc = "< Message from an untrusted source on host."]
547pub const OT_MESSAGE_ORIGIN_HOST_UNTRUSTED: otMessageOrigin = 2;
548#[doc = " Defines the OpenThread message origins."]
549pub type otMessageOrigin = ::std::os::raw::c_uint;
550#[doc = " Represents a message settings."]
551#[repr(C)]
552#[derive(Debug, Default, Copy, Clone)]
553pub struct otMessageSettings {
554 #[doc = "< TRUE if the message should be secured at Layer 2."]
555 pub mLinkSecurityEnabled: bool,
556 #[doc = "< Priority level (MUST be a `OT_MESSAGE_PRIORITY_*` from `otMessagePriority`)."]
557 pub mPriority: u8,
558}
559#[doc = " Represents link-specific information for messages received from the Thread radio."]
560#[repr(C)]
561#[derive(Debug, Default, Copy, Clone)]
562pub struct otThreadLinkInfo {
563 #[doc = "< Source PAN ID"]
564 pub mPanId: u16,
565 #[doc = "< 802.15.4 Channel"]
566 pub mChannel: u8,
567 #[doc = "< Received Signal Strength in dBm (averaged over fragments)"]
568 pub mRss: i8,
569 #[doc = "< Average Link Quality Indicator (averaged over fragments)"]
570 pub mLqi: u8,
571 pub _bitfield_align_1: [u8; 0],
572 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
573 #[doc = "< The time sync sequence."]
574 pub mTimeSyncSeq: u8,
575 #[doc = "< The time offset to the Thread network time, in microseconds."]
576 pub mNetworkTimeOffset: i64,
577 #[doc = "< Radio link type."]
578 pub mRadioType: u8,
579}
580impl otThreadLinkInfo {
581 #[inline]
582 pub fn mLinkSecurity(&self) -> bool {
583 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
584 }
585 #[inline]
586 pub fn set_mLinkSecurity(&mut self, val: bool) {
587 unsafe {
588 let val: u8 = ::std::mem::transmute(val);
589 self._bitfield_1.set(0usize, 1u8, val as u64)
590 }
591 }
592 #[inline]
593 pub fn mIsDstPanIdBroadcast(&self) -> bool {
594 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
595 }
596 #[inline]
597 pub fn set_mIsDstPanIdBroadcast(&mut self, val: bool) {
598 unsafe {
599 let val: u8 = ::std::mem::transmute(val);
600 self._bitfield_1.set(1usize, 1u8, val as u64)
601 }
602 }
603 #[inline]
604 pub fn new_bitfield_1(
605 mLinkSecurity: bool,
606 mIsDstPanIdBroadcast: bool,
607 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
608 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
609 __bindgen_bitfield_unit.set(0usize, 1u8, {
610 let mLinkSecurity: u8 = unsafe { ::std::mem::transmute(mLinkSecurity) };
611 mLinkSecurity as u64
612 });
613 __bindgen_bitfield_unit.set(1usize, 1u8, {
614 let mIsDstPanIdBroadcast: u8 = unsafe { ::std::mem::transmute(mIsDstPanIdBroadcast) };
615 mIsDstPanIdBroadcast as u64
616 });
617 __bindgen_bitfield_unit
618 }
619}
620extern "C" {
621 #[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"]
622 pub fn otMessageFree(aMessage: *mut otMessage);
623}
624extern "C" {
625 #[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"]
626 pub fn otMessageGetLength(aMessage: *const otMessage) -> u16;
627}
628extern "C" {
629 #[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"]
630 pub fn otMessageSetLength(aMessage: *mut otMessage, aLength: u16) -> otError;
631}
632extern "C" {
633 #[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"]
634 pub fn otMessageGetOffset(aMessage: *const otMessage) -> u16;
635}
636extern "C" {
637 #[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"]
638 pub fn otMessageSetOffset(aMessage: *mut otMessage, aOffset: u16);
639}
640extern "C" {
641 #[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."]
642 pub fn otMessageIsLinkSecurityEnabled(aMessage: *const otMessage) -> bool;
643}
644extern "C" {
645 #[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."]
646 pub fn otMessageIsLoopbackToHostAllowed(aMessage: *const otMessage) -> bool;
647}
648extern "C" {
649 #[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."]
650 pub fn otMessageSetLoopbackToHostAllowed(aMessage: *mut otMessage, aAllowLoopbackToHost: bool);
651}
652extern "C" {
653 #[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."]
654 pub fn otMessageIsMulticastLoopEnabled(aMessage: *mut otMessage) -> bool;
655}
656extern "C" {
657 #[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."]
658 pub fn otMessageSetMulticastLoopEnabled(aMessage: *mut otMessage, aEnabled: bool);
659}
660extern "C" {
661 #[doc = " Gets the message origin.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @returns The message origin."]
662 pub fn otMessageGetOrigin(aMessage: *const otMessage) -> otMessageOrigin;
663}
664extern "C" {
665 #[doc = " Sets the message origin.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aOrigin The message origin."]
666 pub fn otMessageSetOrigin(aMessage: *mut otMessage, aOrigin: otMessageOrigin);
667}
668extern "C" {
669 #[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."]
670 pub fn otMessageSetDirectTransmission(aMessage: *mut otMessage, aEnabled: bool);
671}
672extern "C" {
673 #[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."]
674 pub fn otMessageGetRss(aMessage: *const otMessage) -> i8;
675}
676extern "C" {
677 #[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`."]
678 pub fn otMessageGetThreadLinkInfo(
679 aMessage: *const otMessage,
680 aLinkInfo: *mut otThreadLinkInfo,
681 ) -> otError;
682}
683extern "C" {
684 #[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"]
685 pub fn otMessageAppend(
686 aMessage: *mut otMessage,
687 aBuf: *const ::std::os::raw::c_void,
688 aLength: u16,
689 ) -> otError;
690}
691extern "C" {
692 #[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"]
693 pub fn otMessageRead(
694 aMessage: *const otMessage,
695 aOffset: u16,
696 aBuf: *mut ::std::os::raw::c_void,
697 aLength: u16,
698 ) -> u16;
699}
700extern "C" {
701 #[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"]
702 pub fn otMessageWrite(
703 aMessage: *mut otMessage,
704 aOffset: u16,
705 aBuf: *const ::std::os::raw::c_void,
706 aLength: u16,
707 ) -> ::std::os::raw::c_int;
708}
709#[doc = " Represents an OpenThread message queue."]
710#[repr(C)]
711#[derive(Debug, Copy, Clone)]
712pub struct otMessageQueue {
713 #[doc = "< Opaque data used by the implementation."]
714 pub mData: *mut ::std::os::raw::c_void,
715}
716impl Default for otMessageQueue {
717 fn default() -> Self {
718 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
719 unsafe {
720 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
721 s.assume_init()
722 }
723 }
724}
725#[doc = " Represents information about a message queue."]
726#[repr(C)]
727#[derive(Debug, Default, Copy, Clone)]
728pub struct otMessageQueueInfo {
729 #[doc = "< Number of messages in the queue."]
730 pub mNumMessages: u16,
731 #[doc = "< Number of data buffers used by messages in the queue."]
732 pub mNumBuffers: u16,
733 #[doc = "< Total number of bytes used by all messages in the queue."]
734 pub mTotalBytes: u32,
735}
736#[doc = " Represents the message buffer information for different queues used by OpenThread stack."]
737#[repr(C)]
738#[derive(Debug, Default, Copy, Clone)]
739pub struct otBufferInfo {
740 #[doc = "< The total number of buffers in the messages pool (0xffff if unknown)."]
741 pub mTotalBuffers: u16,
742 #[doc = "< The number of free buffers (0xffff if unknown)."]
743 pub mFreeBuffers: u16,
744 #[doc = " The maximum number of used buffers at the same time since OT stack initialization or last call to\n `otMessageResetBufferInfo()`."]
745 pub mMaxUsedBuffers: u16,
746 #[doc = "< Info about 6LoWPAN send queue."]
747 pub m6loSendQueue: otMessageQueueInfo,
748 #[doc = "< Info about 6LoWPAN reassembly queue."]
749 pub m6loReassemblyQueue: otMessageQueueInfo,
750 #[doc = "< Info about IPv6 send queue."]
751 pub mIp6Queue: otMessageQueueInfo,
752 #[doc = "< Info about MPL send queue."]
753 pub mMplQueue: otMessageQueueInfo,
754 #[doc = "< Info about MLE delayed message queue."]
755 pub mMleQueue: otMessageQueueInfo,
756 #[doc = "< Info about CoAP/TMF send queue."]
757 pub mCoapQueue: otMessageQueueInfo,
758 #[doc = "< Info about CoAP secure send queue."]
759 pub mCoapSecureQueue: otMessageQueueInfo,
760 #[doc = "< Info about application CoAP send queue."]
761 pub mApplicationCoapQueue: otMessageQueueInfo,
762}
763extern "C" {
764 #[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."]
765 pub fn otMessageQueueInit(aQueue: *mut otMessageQueue);
766}
767extern "C" {
768 #[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."]
769 pub fn otMessageQueueEnqueue(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
770}
771extern "C" {
772 #[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."]
773 pub fn otMessageQueueEnqueueAtHead(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
774}
775extern "C" {
776 #[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."]
777 pub fn otMessageQueueDequeue(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
778}
779extern "C" {
780 #[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."]
781 pub fn otMessageQueueGetHead(aQueue: *mut otMessageQueue) -> *mut otMessage;
782}
783extern "C" {
784 #[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`."]
785 pub fn otMessageQueueGetNext(
786 aQueue: *mut otMessageQueue,
787 aMessage: *const otMessage,
788 ) -> *mut otMessage;
789}
790extern "C" {
791 #[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."]
792 pub fn otMessageGetBufferInfo(aInstance: *mut otInstance, aBufferInfo: *mut otBufferInfo);
793}
794extern "C" {
795 #[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."]
796 pub fn otMessageResetBufferInfo(aInstance: *mut otInstance);
797}
798#[doc = "< Key Type: Raw Data."]
799pub const OT_CRYPTO_KEY_TYPE_RAW: otCryptoKeyType = 0;
800#[doc = "< Key Type: AES."]
801pub const OT_CRYPTO_KEY_TYPE_AES: otCryptoKeyType = 1;
802#[doc = "< Key Type: HMAC."]
803pub const OT_CRYPTO_KEY_TYPE_HMAC: otCryptoKeyType = 2;
804#[doc = "< Key Type: ECDSA."]
805pub const OT_CRYPTO_KEY_TYPE_ECDSA: otCryptoKeyType = 3;
806#[doc = " Defines the key types."]
807pub type otCryptoKeyType = ::std::os::raw::c_uint;
808#[doc = "< Key Algorithm: Vendor Defined."]
809pub const OT_CRYPTO_KEY_ALG_VENDOR: otCryptoKeyAlgorithm = 0;
810#[doc = "< Key Algorithm: AES ECB."]
811pub const OT_CRYPTO_KEY_ALG_AES_ECB: otCryptoKeyAlgorithm = 1;
812#[doc = "< Key Algorithm: HMAC SHA-256."]
813pub const OT_CRYPTO_KEY_ALG_HMAC_SHA_256: otCryptoKeyAlgorithm = 2;
814#[doc = "< Key Algorithm: ECDSA."]
815pub const OT_CRYPTO_KEY_ALG_ECDSA: otCryptoKeyAlgorithm = 3;
816#[doc = " Defines the key algorithms."]
817pub type otCryptoKeyAlgorithm = ::std::os::raw::c_uint;
818#[doc = "< Key Usage: Key Usage is empty."]
819pub const OT_CRYPTO_KEY_USAGE_NONE: _bindgen_ty_1 = 0;
820#[doc = "< Key Usage: Key can be exported."]
821pub const OT_CRYPTO_KEY_USAGE_EXPORT: _bindgen_ty_1 = 1;
822#[doc = "< Key Usage: Encryption (vendor defined)."]
823pub const OT_CRYPTO_KEY_USAGE_ENCRYPT: _bindgen_ty_1 = 2;
824#[doc = "< Key Usage: AES ECB."]
825pub const OT_CRYPTO_KEY_USAGE_DECRYPT: _bindgen_ty_1 = 4;
826#[doc = "< Key Usage: Sign Hash."]
827pub const OT_CRYPTO_KEY_USAGE_SIGN_HASH: _bindgen_ty_1 = 8;
828#[doc = "< Key Usage: Verify Hash."]
829pub const OT_CRYPTO_KEY_USAGE_VERIFY_HASH: _bindgen_ty_1 = 16;
830#[doc = " Defines the key usage flags."]
831pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
832#[doc = "< Key Persistence: Key is volatile."]
833pub const OT_CRYPTO_KEY_STORAGE_VOLATILE: otCryptoKeyStorage = 0;
834#[doc = "< Key Persistence: Key is persistent."]
835pub const OT_CRYPTO_KEY_STORAGE_PERSISTENT: otCryptoKeyStorage = 1;
836#[doc = " Defines the key storage types."]
837pub type otCryptoKeyStorage = ::std::os::raw::c_uint;
838#[doc = " This datatype represents the key reference."]
839pub type otCryptoKeyRef = u32;
840#[doc = " @struct otCryptoKey\n\n Represents the Key Material required for Crypto operations."]
841#[repr(C)]
842#[derive(Debug, Copy, Clone)]
843pub struct otCryptoKey {
844 #[doc = "< Pointer to the buffer containing key. NULL indicates to use `mKeyRef`."]
845 pub mKey: *const u8,
846 #[doc = "< The key length in bytes (applicable when `mKey` is not NULL)."]
847 pub mKeyLength: u16,
848 #[doc = "< The PSA key ref (requires `mKey` to be NULL)."]
849 pub mKeyRef: u32,
850}
851impl Default for otCryptoKey {
852 fn default() -> Self {
853 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
854 unsafe {
855 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
856 s.assume_init()
857 }
858 }
859}
860#[doc = " @struct otCryptoContext\n\n Stores the context object for platform APIs."]
861#[repr(C)]
862#[derive(Debug, Copy, Clone)]
863pub struct otCryptoContext {
864 #[doc = "< Pointer to the context."]
865 pub mContext: *mut ::std::os::raw::c_void,
866 #[doc = "< The length of the context in bytes."]
867 pub mContextSize: u16,
868}
869impl Default for otCryptoContext {
870 fn default() -> Self {
871 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
872 unsafe {
873 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
874 s.assume_init()
875 }
876 }
877}
878#[doc = " @struct otPlatCryptoSha256Hash\n\n Represents a SHA-256 hash."]
879#[repr(C, packed)]
880#[derive(Debug, Default, Copy, Clone)]
881pub struct otPlatCryptoSha256Hash {
882 #[doc = "< Hash bytes."]
883 pub m8: [u8; 32usize],
884}
885#[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)."]
886#[repr(C)]
887#[derive(Debug, Copy, Clone)]
888pub struct otPlatCryptoEcdsaKeyPair {
889 pub mDerBytes: [u8; 125usize],
890 pub mDerLength: u8,
891}
892impl Default for otPlatCryptoEcdsaKeyPair {
893 fn default() -> Self {
894 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
895 unsafe {
896 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
897 s.assume_init()
898 }
899 }
900}
901#[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)."]
902#[repr(C, packed)]
903#[derive(Debug, Copy, Clone)]
904pub struct otPlatCryptoEcdsaPublicKey {
905 pub m8: [u8; 64usize],
906}
907impl Default for otPlatCryptoEcdsaPublicKey {
908 fn default() -> Self {
909 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
910 unsafe {
911 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
912 s.assume_init()
913 }
914 }
915}
916#[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)."]
917#[repr(C, packed)]
918#[derive(Debug, Copy, Clone)]
919pub struct otPlatCryptoEcdsaSignature {
920 pub m8: [u8; 64usize],
921}
922impl Default for otPlatCryptoEcdsaSignature {
923 fn default() -> Self {
924 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
925 unsafe {
926 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
927 s.assume_init()
928 }
929 }
930}
931extern "C" {
932 #[doc = " Initialize the Crypto module."]
933 pub fn otPlatCryptoInit();
934}
935extern "C" {
936 #[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."]
937 pub fn otPlatCryptoImportKey(
938 aKeyRef: *mut otCryptoKeyRef,
939 aKeyType: otCryptoKeyType,
940 aKeyAlgorithm: otCryptoKeyAlgorithm,
941 aKeyUsage: ::std::os::raw::c_int,
942 aKeyPersistence: otCryptoKeyStorage,
943 aKey: *const u8,
944 aKeyLen: usize,
945 ) -> otError;
946}
947extern "C" {
948 #[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."]
949 pub fn otPlatCryptoExportKey(
950 aKeyRef: otCryptoKeyRef,
951 aBuffer: *mut u8,
952 aBufferLen: usize,
953 aKeyLen: *mut usize,
954 ) -> otError;
955}
956extern "C" {
957 #[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."]
958 pub fn otPlatCryptoDestroyKey(aKeyRef: otCryptoKeyRef) -> otError;
959}
960extern "C" {
961 #[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."]
962 pub fn otPlatCryptoHasKey(aKeyRef: otCryptoKeyRef) -> bool;
963}
964extern "C" {
965 #[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."]
966 pub fn otPlatCryptoHmacSha256Init(aContext: *mut otCryptoContext) -> otError;
967}
968extern "C" {
969 #[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"]
970 pub fn otPlatCryptoHmacSha256Deinit(aContext: *mut otCryptoContext) -> otError;
971}
972extern "C" {
973 #[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"]
974 pub fn otPlatCryptoHmacSha256Start(
975 aContext: *mut otCryptoContext,
976 aKey: *const otCryptoKey,
977 ) -> otError;
978}
979extern "C" {
980 #[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"]
981 pub fn otPlatCryptoHmacSha256Update(
982 aContext: *mut otCryptoContext,
983 aBuf: *const ::std::os::raw::c_void,
984 aBufLength: u16,
985 ) -> otError;
986}
987extern "C" {
988 #[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"]
989 pub fn otPlatCryptoHmacSha256Finish(
990 aContext: *mut otCryptoContext,
991 aBuf: *mut u8,
992 aBufLength: usize,
993 ) -> otError;
994}
995extern "C" {
996 #[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."]
997 pub fn otPlatCryptoAesInit(aContext: *mut otCryptoContext) -> otError;
998}
999extern "C" {
1000 #[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"]
1001 pub fn otPlatCryptoAesSetKey(
1002 aContext: *mut otCryptoContext,
1003 aKey: *const otCryptoKey,
1004 ) -> otError;
1005}
1006extern "C" {
1007 #[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"]
1008 pub fn otPlatCryptoAesEncrypt(
1009 aContext: *mut otCryptoContext,
1010 aInput: *const u8,
1011 aOutput: *mut u8,
1012 ) -> otError;
1013}
1014extern "C" {
1015 #[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"]
1016 pub fn otPlatCryptoAesFree(aContext: *mut otCryptoContext) -> otError;
1017}
1018extern "C" {
1019 #[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"]
1020 pub fn otPlatCryptoHkdfInit(aContext: *mut otCryptoContext) -> otError;
1021}
1022extern "C" {
1023 #[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"]
1024 pub fn otPlatCryptoHkdfExpand(
1025 aContext: *mut otCryptoContext,
1026 aInfo: *const u8,
1027 aInfoLength: u16,
1028 aOutputKey: *mut u8,
1029 aOutputKeyLength: u16,
1030 ) -> otError;
1031}
1032extern "C" {
1033 #[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."]
1034 pub fn otPlatCryptoHkdfExtract(
1035 aContext: *mut otCryptoContext,
1036 aSalt: *const u8,
1037 aSaltLength: u16,
1038 aInputKey: *const otCryptoKey,
1039 ) -> otError;
1040}
1041extern "C" {
1042 #[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"]
1043 pub fn otPlatCryptoHkdfDeinit(aContext: *mut otCryptoContext) -> otError;
1044}
1045extern "C" {
1046 #[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."]
1047 pub fn otPlatCryptoSha256Init(aContext: *mut otCryptoContext) -> otError;
1048}
1049extern "C" {
1050 #[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"]
1051 pub fn otPlatCryptoSha256Deinit(aContext: *mut otCryptoContext) -> otError;
1052}
1053extern "C" {
1054 #[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"]
1055 pub fn otPlatCryptoSha256Start(aContext: *mut otCryptoContext) -> otError;
1056}
1057extern "C" {
1058 #[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"]
1059 pub fn otPlatCryptoSha256Update(
1060 aContext: *mut otCryptoContext,
1061 aBuf: *const ::std::os::raw::c_void,
1062 aBufLength: u16,
1063 ) -> otError;
1064}
1065extern "C" {
1066 #[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"]
1067 pub fn otPlatCryptoSha256Finish(
1068 aContext: *mut otCryptoContext,
1069 aHash: *mut u8,
1070 aHashSize: u16,
1071 ) -> otError;
1072}
1073extern "C" {
1074 #[doc = " Initialize cryptographically-secure pseudorandom number generator (CSPRNG)."]
1075 pub fn otPlatCryptoRandomInit();
1076}
1077extern "C" {
1078 #[doc = " Deinitialize cryptographically-secure pseudorandom number generator (CSPRNG)."]
1079 pub fn otPlatCryptoRandomDeinit();
1080}
1081extern "C" {
1082 #[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."]
1083 pub fn otPlatCryptoRandomGet(aBuffer: *mut u8, aSize: u16) -> otError;
1084}
1085extern "C" {
1086 #[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."]
1087 pub fn otPlatCryptoEcdsaGenerateKey(aKeyPair: *mut otPlatCryptoEcdsaKeyPair) -> otError;
1088}
1089extern "C" {
1090 #[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."]
1091 pub fn otPlatCryptoEcdsaGetPublicKey(
1092 aKeyPair: *const otPlatCryptoEcdsaKeyPair,
1093 aPublicKey: *mut otPlatCryptoEcdsaPublicKey,
1094 ) -> otError;
1095}
1096extern "C" {
1097 #[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."]
1098 pub fn otPlatCryptoEcdsaSign(
1099 aKeyPair: *const otPlatCryptoEcdsaKeyPair,
1100 aHash: *const otPlatCryptoSha256Hash,
1101 aSignature: *mut otPlatCryptoEcdsaSignature,
1102 ) -> otError;
1103}
1104extern "C" {
1105 #[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."]
1106 pub fn otPlatCryptoEcdsaVerify(
1107 aPublicKey: *const otPlatCryptoEcdsaPublicKey,
1108 aHash: *const otPlatCryptoSha256Hash,
1109 aSignature: *const otPlatCryptoEcdsaSignature,
1110 ) -> otError;
1111}
1112extern "C" {
1113 #[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."]
1114 pub fn otPlatCryptoEcdsaSignUsingKeyRef(
1115 aKeyRef: otCryptoKeyRef,
1116 aHash: *const otPlatCryptoSha256Hash,
1117 aSignature: *mut otPlatCryptoEcdsaSignature,
1118 ) -> otError;
1119}
1120extern "C" {
1121 #[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."]
1122 pub fn otPlatCryptoEcdsaExportPublicKey(
1123 aKeyRef: otCryptoKeyRef,
1124 aPublicKey: *mut otPlatCryptoEcdsaPublicKey,
1125 ) -> otError;
1126}
1127extern "C" {
1128 #[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."]
1129 pub fn otPlatCryptoEcdsaGenerateAndImportKey(aKeyRef: otCryptoKeyRef) -> otError;
1130}
1131extern "C" {
1132 #[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."]
1133 pub fn otPlatCryptoEcdsaVerifyUsingKeyRef(
1134 aKeyRef: otCryptoKeyRef,
1135 aHash: *const otPlatCryptoSha256Hash,
1136 aSignature: *const otPlatCryptoEcdsaSignature,
1137 ) -> otError;
1138}
1139extern "C" {
1140 #[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."]
1141 pub fn otPlatCryptoPbkdf2GenerateKey(
1142 aPassword: *const u8,
1143 aPasswordLen: u16,
1144 aSalt: *const u8,
1145 aSaltLen: u16,
1146 aIterationCounter: u32,
1147 aKeyLen: u16,
1148 aKey: *mut u8,
1149 ) -> otError;
1150}
1151#[doc = "< aMaxPHYPacketSize (IEEE 802.15.4-2006)"]
1152pub const OT_RADIO_FRAME_MAX_SIZE: _bindgen_ty_2 = 127;
1153#[doc = "< Minimal size of frame FCS + CONTROL"]
1154pub const OT_RADIO_FRAME_MIN_SIZE: _bindgen_ty_2 = 3;
1155#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1156pub const OT_RADIO_SYMBOLS_PER_OCTET: _bindgen_ty_2 = 2;
1157#[doc = "< 2.4 GHz IEEE 802.15.4 (bits per second)"]
1158pub const OT_RADIO_BIT_RATE: _bindgen_ty_2 = 250000;
1159#[doc = "< Number of bits per octet"]
1160pub const OT_RADIO_BITS_PER_OCTET: _bindgen_ty_2 = 8;
1161#[doc = "< The O-QPSK PHY symbol rate when operating in the 780MHz, 915MHz, 2380MHz, 2450MHz"]
1162pub const OT_RADIO_SYMBOL_RATE: _bindgen_ty_2 = 62500;
1163#[doc = "< Symbol duration time in unit of microseconds"]
1164pub const OT_RADIO_SYMBOL_TIME: _bindgen_ty_2 = 16;
1165#[doc = "< Time for 10 symbols in unit of microseconds"]
1166pub const OT_RADIO_TEN_SYMBOLS_TIME: _bindgen_ty_2 = 160;
1167#[doc = "< LQI measurement not supported"]
1168pub const OT_RADIO_LQI_NONE: _bindgen_ty_2 = 0;
1169#[doc = "< Invalid or unknown RSSI value"]
1170pub const OT_RADIO_RSSI_INVALID: _bindgen_ty_2 = 127;
1171#[doc = "< Invalid or unknown power value"]
1172pub const OT_RADIO_POWER_INVALID: _bindgen_ty_2 = 127;
1173#[doc = "< Invalid short address."]
1174pub const OT_RADIO_INVALID_SHORT_ADDR: _bindgen_ty_2 = 65534;
1175#[doc = "< Broadcast short address."]
1176pub const OT_RADIO_BROADCAST_SHORT_ADDR: _bindgen_ty_2 = 65535;
1177#[doc = " @defgroup radio-types Radio Types\n\n @brief\n This module includes the platform abstraction for a radio frame.\n\n @{"]
1178pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
1179#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1180pub const OT_RADIO_CHANNEL_PAGE_0: _bindgen_ty_3 = 0;
1181#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1182pub const OT_RADIO_CHANNEL_PAGE_0_MASK: _bindgen_ty_3 = 1;
1183#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1184pub const OT_RADIO_CHANNEL_PAGE_2: _bindgen_ty_3 = 2;
1185#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1186pub const OT_RADIO_CHANNEL_PAGE_2_MASK: _bindgen_ty_3 = 4;
1187#[doc = " Defines the channel page."]
1188pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
1189#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1190pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MIN: _bindgen_ty_4 = 1;
1191#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1192pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MAX: _bindgen_ty_4 = 10;
1193#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1194pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MASK: _bindgen_ty_4 = 2046;
1195#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1196pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MIN: _bindgen_ty_4 = 11;
1197#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1198pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MAX: _bindgen_ty_4 = 26;
1199#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1200pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MASK: _bindgen_ty_4 = 134215680;
1201#[doc = " Defines the frequency band channel range."]
1202pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
1203#[doc = " Represents radio capabilities.\n\n The value is a bit-field indicating the capabilities supported by the radio. See `OT_RADIO_CAPS_*` definitions."]
1204pub type otRadioCaps = u16;
1205#[doc = "< Radio supports no capability."]
1206pub const OT_RADIO_CAPS_NONE: _bindgen_ty_5 = 0;
1207#[doc = "< Radio supports AckTime event."]
1208pub const OT_RADIO_CAPS_ACK_TIMEOUT: _bindgen_ty_5 = 1;
1209#[doc = "< Radio supports Energy Scans."]
1210pub const OT_RADIO_CAPS_ENERGY_SCAN: _bindgen_ty_5 = 2;
1211#[doc = "< Radio supports tx retry logic with collision avoidance (CSMA)."]
1212pub const OT_RADIO_CAPS_TRANSMIT_RETRIES: _bindgen_ty_5 = 4;
1213#[doc = "< Radio supports CSMA backoff for frame tx (but no retry)."]
1214pub const OT_RADIO_CAPS_CSMA_BACKOFF: _bindgen_ty_5 = 8;
1215#[doc = "< Radio supports direct transition from sleep to TX with CSMA."]
1216pub const OT_RADIO_CAPS_SLEEP_TO_TX: _bindgen_ty_5 = 16;
1217#[doc = "< Radio supports tx security."]
1218pub const OT_RADIO_CAPS_TRANSMIT_SEC: _bindgen_ty_5 = 32;
1219#[doc = "< Radio supports tx at specific time."]
1220pub const OT_RADIO_CAPS_TRANSMIT_TIMING: _bindgen_ty_5 = 64;
1221#[doc = "< Radio supports rx at specific time."]
1222pub const OT_RADIO_CAPS_RECEIVE_TIMING: _bindgen_ty_5 = 128;
1223#[doc = "< Radio supports RxOnWhenIdle handling."]
1224pub const OT_RADIO_CAPS_RX_ON_WHEN_IDLE: _bindgen_ty_5 = 256;
1225#[doc = "< Radio supports setting per-frame transmit power."]
1226pub const OT_RADIO_CAPS_TRANSMIT_FRAME_POWER: _bindgen_ty_5 = 512;
1227#[doc = "< Radio supports setting alternate short address."]
1228pub const OT_RADIO_CAPS_ALT_SHORT_ADDR: _bindgen_ty_5 = 1024;
1229#[doc = " Defines constants that are used to indicate different radio capabilities. See `otRadioCaps`."]
1230pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
1231#[doc = " Represents the IEEE 802.15.4 PAN ID."]
1232pub type otPanId = u16;
1233#[doc = " Represents the IEEE 802.15.4 Short Address."]
1234pub type otShortAddress = u16;
1235#[doc = "< Size of IE header in bytes."]
1236pub const OT_IE_HEADER_SIZE: _bindgen_ty_6 = 2;
1237#[doc = "< Size of CSL IE content in bytes."]
1238pub const OT_CSL_IE_SIZE: _bindgen_ty_6 = 4;
1239#[doc = "< Max length for header IE in ACK."]
1240pub const OT_ACK_IE_MAX_SIZE: _bindgen_ty_6 = 16;
1241#[doc = "< Max length of Link Metrics data in Vendor-Specific IE."]
1242pub const OT_ENH_PROBING_IE_DATA_MAX_SIZE: _bindgen_ty_6 = 2;
1243#[doc = " Defines constants about size of header IE in ACK."]
1244pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
1245#[doc = " @struct otExtAddress\n\n Represents the IEEE 802.15.4 Extended Address."]
1246#[repr(C, packed)]
1247#[derive(Debug, Default, Copy, Clone)]
1248pub struct otExtAddress {
1249 #[doc = "< IEEE 802.15.4 Extended Address bytes"]
1250 pub m8: [u8; 8usize],
1251}
1252#[doc = " @struct otMacKey\n\n Represents a MAC Key."]
1253#[repr(C, packed)]
1254#[derive(Debug, Default, Copy, Clone)]
1255pub struct otMacKey {
1256 #[doc = "< MAC Key bytes."]
1257 pub m8: [u8; 16usize],
1258}
1259#[doc = " Represents a MAC Key Ref used by PSA."]
1260pub type otMacKeyRef = otCryptoKeyRef;
1261#[doc = " @struct otMacKeyMaterial\n\n Represents a MAC Key."]
1262#[repr(C)]
1263#[derive(Copy, Clone)]
1264pub struct otMacKeyMaterial {
1265 pub mKeyMaterial: otMacKeyMaterial__bindgen_ty_1,
1266}
1267#[repr(C)]
1268#[derive(Copy, Clone)]
1269pub union otMacKeyMaterial__bindgen_ty_1 {
1270 #[doc = "< Reference to the key stored."]
1271 pub mKeyRef: otMacKeyRef,
1272 #[doc = "< Key stored as literal."]
1273 pub mKey: otMacKey,
1274}
1275impl Default for otMacKeyMaterial__bindgen_ty_1 {
1276 fn default() -> Self {
1277 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1278 unsafe {
1279 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1280 s.assume_init()
1281 }
1282 }
1283}
1284impl Default for otMacKeyMaterial {
1285 fn default() -> Self {
1286 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1287 unsafe {
1288 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1289 s.assume_init()
1290 }
1291 }
1292}
1293#[doc = "< Use Literal Keys."]
1294pub const OT_KEY_TYPE_LITERAL_KEY: otRadioKeyType = 0;
1295#[doc = "< Use Reference to Key."]
1296pub const OT_KEY_TYPE_KEY_REF: otRadioKeyType = 1;
1297#[doc = " Defines constants about key types."]
1298pub type otRadioKeyType = ::std::os::raw::c_uint;
1299#[doc = " Represents the IEEE 802.15.4 Header IE (Information Element) related information of a radio frame."]
1300#[repr(C)]
1301#[derive(Debug, Default, Copy, Clone)]
1302pub struct otRadioIeInfo {
1303 #[doc = "< The time offset to the Thread network time."]
1304 pub mNetworkTimeOffset: i64,
1305 #[doc = "< The Time IE offset from the start of PSDU."]
1306 pub mTimeIeOffset: u8,
1307 #[doc = "< The Time sync sequence."]
1308 pub mTimeSyncSeq: u8,
1309}
1310#[doc = " Represents an IEEE 802.15.4 radio frame."]
1311#[repr(C)]
1312#[derive(Copy, Clone)]
1313pub struct otRadioFrame {
1314 #[doc = "< The PSDU."]
1315 pub mPsdu: *mut u8,
1316 #[doc = "< Length of the PSDU."]
1317 pub mLength: u16,
1318 #[doc = "< Channel used to transmit/receive the frame."]
1319 pub mChannel: u8,
1320 #[doc = "< Radio link type - should be ignored by radio driver."]
1321 pub mRadioType: u8,
1322 pub mInfo: otRadioFrame__bindgen_ty_1,
1323}
1324#[doc = " The union of transmit and receive information for a radio frame."]
1325#[repr(C)]
1326#[derive(Copy, Clone)]
1327pub union otRadioFrame__bindgen_ty_1 {
1328 pub mTxInfo: otRadioFrame__bindgen_ty_1__bindgen_ty_1,
1329 pub mRxInfo: otRadioFrame__bindgen_ty_1__bindgen_ty_2,
1330}
1331#[doc = " Structure representing radio frame transmit information."]
1332#[repr(C)]
1333#[derive(Debug, Copy, Clone)]
1334pub struct otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1335 #[doc = "< The key material used for AES-CCM frame security."]
1336 pub mAesKey: *const otMacKeyMaterial,
1337 #[doc = "< The pointer to the Header IE(s) related information."]
1338 pub mIeInfo: *mut otRadioIeInfo,
1339 #[doc = " The base time in microseconds for scheduled transmissions\n relative to the local radio clock, see `otPlatRadioGetNow` and\n `mTxDelay`.\n\n If this field is non-zero, `mMaxCsmaBackoffs` should be ignored.\n\n This field does not affect CCA behavior which is controlled by `mCsmaCaEnabled`."]
1340 pub mTxDelayBaseTime: u32,
1341 #[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.\n\n If this field is non-zero, `mMaxCsmaBackoffs` should be ignored.\n\n This field does not affect CCA behavior which is controlled by `mCsmaCaEnabled`."]
1342 pub mTxDelay: u32,
1343 #[doc = " Maximum number of CSMA backoff attempts before declaring channel access failure.\n\n This is applicable and MUST be used when radio platform provides the `OT_RADIO_CAPS_CSMA_BACKOFF` and/or\n `OT_RADIO_CAPS_TRANSMIT_RETRIES`.\n\n This field MUST be ignored if `mCsmaCaEnabled` is set to `false` (CCA is disabled) or\n either `mTxDelayBaseTime` or `mTxDelay` is non-zero (frame transmission is expected at a specific time).\n\n It can be set to `0` to skip backoff mechanism (note that CCA MUST still be performed assuming\n `mCsmaCaEnabled` is `true`)."]
1344 pub mMaxCsmaBackoffs: u8,
1345 #[doc = "< Maximum number of retries allowed after a transmission failure."]
1346 pub mMaxFrameRetries: u8,
1347 #[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."]
1348 pub mRxChannelAfterTxDone: u8,
1349 #[doc = " The transmit power in dBm.\n\n If the platform layer does not provide `OT_RADIO_CAPS_TRANSMIT_FRAME_POWER` capability, it can ignore\n this value.\n\n If the value is OT_RADIO_POWER_INVALID, then the platform should ignore this value and transmit the frame\n with its default transmit power.\n\n Otherwise, the platform should transmit this frame with the maximum power no larger than minimal of the\n following values:\n 1. mTxPower,\n 2. The power limit set by otPlatRadioSetChannelTargetPower(),\n 3. The power limit set by otPlatRadioSetChannelMaxTransmitPower(),\n 4. The power limit set by otPlatRadioSetRegion()."]
1350 pub mTxPower: i8,
1351 pub _bitfield_align_1: [u8; 0],
1352 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1353 #[doc = " The time of the local radio clock in microseconds when the end of\n the SFD was present at the local antenna.\n\n The platform should update this field before otPlatRadioTxStarted() is fired for each transmit attempt."]
1354 pub mTimestamp: u64,
1355}
1356impl Default for otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1357 fn default() -> Self {
1358 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1359 unsafe {
1360 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1361 s.assume_init()
1362 }
1363 }
1364}
1365impl otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1366 #[inline]
1367 pub fn mIsHeaderUpdated(&self) -> bool {
1368 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1369 }
1370 #[inline]
1371 pub fn set_mIsHeaderUpdated(&mut self, val: bool) {
1372 unsafe {
1373 let val: u8 = ::std::mem::transmute(val);
1374 self._bitfield_1.set(0usize, 1u8, val as u64)
1375 }
1376 }
1377 #[inline]
1378 pub fn mIsARetx(&self) -> bool {
1379 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1380 }
1381 #[inline]
1382 pub fn set_mIsARetx(&mut self, val: bool) {
1383 unsafe {
1384 let val: u8 = ::std::mem::transmute(val);
1385 self._bitfield_1.set(1usize, 1u8, val as u64)
1386 }
1387 }
1388 #[inline]
1389 pub fn mCsmaCaEnabled(&self) -> bool {
1390 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
1391 }
1392 #[inline]
1393 pub fn set_mCsmaCaEnabled(&mut self, val: bool) {
1394 unsafe {
1395 let val: u8 = ::std::mem::transmute(val);
1396 self._bitfield_1.set(2usize, 1u8, val as u64)
1397 }
1398 }
1399 #[inline]
1400 pub fn mCslPresent(&self) -> bool {
1401 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
1402 }
1403 #[inline]
1404 pub fn set_mCslPresent(&mut self, val: bool) {
1405 unsafe {
1406 let val: u8 = ::std::mem::transmute(val);
1407 self._bitfield_1.set(3usize, 1u8, val as u64)
1408 }
1409 }
1410 #[inline]
1411 pub fn mIsSecurityProcessed(&self) -> bool {
1412 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
1413 }
1414 #[inline]
1415 pub fn set_mIsSecurityProcessed(&mut self, val: bool) {
1416 unsafe {
1417 let val: u8 = ::std::mem::transmute(val);
1418 self._bitfield_1.set(4usize, 1u8, val as u64)
1419 }
1420 }
1421 #[inline]
1422 pub fn new_bitfield_1(
1423 mIsHeaderUpdated: bool,
1424 mIsARetx: bool,
1425 mCsmaCaEnabled: bool,
1426 mCslPresent: bool,
1427 mIsSecurityProcessed: bool,
1428 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1429 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1430 __bindgen_bitfield_unit.set(0usize, 1u8, {
1431 let mIsHeaderUpdated: u8 = unsafe { ::std::mem::transmute(mIsHeaderUpdated) };
1432 mIsHeaderUpdated as u64
1433 });
1434 __bindgen_bitfield_unit.set(1usize, 1u8, {
1435 let mIsARetx: u8 = unsafe { ::std::mem::transmute(mIsARetx) };
1436 mIsARetx as u64
1437 });
1438 __bindgen_bitfield_unit.set(2usize, 1u8, {
1439 let mCsmaCaEnabled: u8 = unsafe { ::std::mem::transmute(mCsmaCaEnabled) };
1440 mCsmaCaEnabled as u64
1441 });
1442 __bindgen_bitfield_unit.set(3usize, 1u8, {
1443 let mCslPresent: u8 = unsafe { ::std::mem::transmute(mCslPresent) };
1444 mCslPresent as u64
1445 });
1446 __bindgen_bitfield_unit.set(4usize, 1u8, {
1447 let mIsSecurityProcessed: u8 = unsafe { ::std::mem::transmute(mIsSecurityProcessed) };
1448 mIsSecurityProcessed as u64
1449 });
1450 __bindgen_bitfield_unit
1451 }
1452}
1453#[doc = " Structure representing radio frame receive information."]
1454#[repr(C)]
1455#[derive(Debug, Default, Copy, Clone)]
1456pub struct otRadioFrame__bindgen_ty_1__bindgen_ty_2 {
1457 #[doc = " The time of the local radio clock in microseconds when the end of\n the SFD was present at the local antenna."]
1458 pub mTimestamp: u64,
1459 #[doc = "< ACK security frame counter (applicable when `mAckedWithSecEnhAck` is set)."]
1460 pub mAckFrameCounter: u32,
1461 #[doc = "< ACK security key index (applicable when `mAckedWithSecEnhAck` is set)."]
1462 pub mAckKeyId: u8,
1463 #[doc = "< Received signal strength indicator in dBm for received frames."]
1464 pub mRssi: i8,
1465 #[doc = "< Link Quality Indicator for received frames."]
1466 pub mLqi: u8,
1467 pub _bitfield_align_1: [u8; 0],
1468 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1469}
1470impl otRadioFrame__bindgen_ty_1__bindgen_ty_2 {
1471 #[inline]
1472 pub fn mAckedWithFramePending(&self) -> bool {
1473 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1474 }
1475 #[inline]
1476 pub fn set_mAckedWithFramePending(&mut self, val: bool) {
1477 unsafe {
1478 let val: u8 = ::std::mem::transmute(val);
1479 self._bitfield_1.set(0usize, 1u8, val as u64)
1480 }
1481 }
1482 #[inline]
1483 pub fn mAckedWithSecEnhAck(&self) -> bool {
1484 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1485 }
1486 #[inline]
1487 pub fn set_mAckedWithSecEnhAck(&mut self, val: bool) {
1488 unsafe {
1489 let val: u8 = ::std::mem::transmute(val);
1490 self._bitfield_1.set(1usize, 1u8, val as u64)
1491 }
1492 }
1493 #[inline]
1494 pub fn new_bitfield_1(
1495 mAckedWithFramePending: bool,
1496 mAckedWithSecEnhAck: bool,
1497 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1498 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1499 __bindgen_bitfield_unit.set(0usize, 1u8, {
1500 let mAckedWithFramePending: u8 =
1501 unsafe { ::std::mem::transmute(mAckedWithFramePending) };
1502 mAckedWithFramePending as u64
1503 });
1504 __bindgen_bitfield_unit.set(1usize, 1u8, {
1505 let mAckedWithSecEnhAck: u8 = unsafe { ::std::mem::transmute(mAckedWithSecEnhAck) };
1506 mAckedWithSecEnhAck as u64
1507 });
1508 __bindgen_bitfield_unit
1509 }
1510}
1511impl Default for otRadioFrame__bindgen_ty_1 {
1512 fn default() -> Self {
1513 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1514 unsafe {
1515 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1516 s.assume_init()
1517 }
1518 }
1519}
1520impl Default for otRadioFrame {
1521 fn default() -> Self {
1522 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1523 unsafe {
1524 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1525 s.assume_init()
1526 }
1527 }
1528}
1529pub const OT_RADIO_STATE_DISABLED: otRadioState = 0;
1530pub const OT_RADIO_STATE_SLEEP: otRadioState = 1;
1531pub const OT_RADIO_STATE_RECEIVE: otRadioState = 2;
1532pub const OT_RADIO_STATE_TRANSMIT: otRadioState = 3;
1533pub const OT_RADIO_STATE_INVALID: otRadioState = 255;
1534#[doc = " Represents the state of a radio.\n Initially, a radio is in the Disabled state."]
1535pub type otRadioState = ::std::os::raw::c_uint;
1536#[doc = " Represents radio coexistence metrics."]
1537#[repr(C)]
1538#[derive(Debug, Default, Copy, Clone)]
1539pub struct otRadioCoexMetrics {
1540 #[doc = "< Number of grant glitches."]
1541 pub mNumGrantGlitch: u32,
1542 #[doc = "< Number of tx requests."]
1543 pub mNumTxRequest: u32,
1544 #[doc = "< Number of tx requests while grant was active."]
1545 pub mNumTxGrantImmediate: u32,
1546 #[doc = "< Number of tx requests while grant was inactive."]
1547 pub mNumTxGrantWait: u32,
1548 #[doc = "< Number of tx requests while grant was inactive that were ultimately granted."]
1549 pub mNumTxGrantWaitActivated: u32,
1550 #[doc = "< Number of tx requests while grant was inactive that timed out."]
1551 pub mNumTxGrantWaitTimeout: u32,
1552 #[doc = "< Number of tx that were in progress when grant was deactivated."]
1553 pub mNumTxGrantDeactivatedDuringRequest: u32,
1554 #[doc = "< Number of tx requests that were not granted within 50us."]
1555 pub mNumTxDelayedGrant: u32,
1556 #[doc = "< Average time in usec from tx request to grant."]
1557 pub mAvgTxRequestToGrantTime: u32,
1558 #[doc = "< Number of rx requests."]
1559 pub mNumRxRequest: u32,
1560 #[doc = "< Number of rx requests while grant was active."]
1561 pub mNumRxGrantImmediate: u32,
1562 #[doc = "< Number of rx requests while grant was inactive."]
1563 pub mNumRxGrantWait: u32,
1564 #[doc = "< Number of rx requests while grant was inactive that were ultimately granted."]
1565 pub mNumRxGrantWaitActivated: u32,
1566 #[doc = "< Number of rx requests while grant was inactive that timed out."]
1567 pub mNumRxGrantWaitTimeout: u32,
1568 #[doc = "< Number of rx that were in progress when grant was deactivated."]
1569 pub mNumRxGrantDeactivatedDuringRequest: u32,
1570 #[doc = "< Number of rx requests that were not granted within 50us."]
1571 pub mNumRxDelayedGrant: u32,
1572 #[doc = "< Average time in usec from rx request to grant."]
1573 pub mAvgRxRequestToGrantTime: u32,
1574 #[doc = "< Number of rx requests that completed without receiving grant."]
1575 pub mNumRxGrantNone: u32,
1576 #[doc = "< Stats collection stopped due to saturation."]
1577 pub mStopped: bool,
1578}
1579#[doc = " Represents what metrics are specified to query."]
1580#[repr(C, packed)]
1581#[derive(Debug, Default, Copy, Clone)]
1582pub struct otLinkMetrics {
1583 pub _bitfield_align_1: [u8; 0],
1584 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1585}
1586impl otLinkMetrics {
1587 #[inline]
1588 pub fn mPduCount(&self) -> bool {
1589 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1590 }
1591 #[inline]
1592 pub fn set_mPduCount(&mut self, val: bool) {
1593 unsafe {
1594 let val: u8 = ::std::mem::transmute(val);
1595 self._bitfield_1.set(0usize, 1u8, val as u64)
1596 }
1597 }
1598 #[inline]
1599 pub fn mLqi(&self) -> bool {
1600 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1601 }
1602 #[inline]
1603 pub fn set_mLqi(&mut self, val: bool) {
1604 unsafe {
1605 let val: u8 = ::std::mem::transmute(val);
1606 self._bitfield_1.set(1usize, 1u8, val as u64)
1607 }
1608 }
1609 #[inline]
1610 pub fn mLinkMargin(&self) -> bool {
1611 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
1612 }
1613 #[inline]
1614 pub fn set_mLinkMargin(&mut self, val: bool) {
1615 unsafe {
1616 let val: u8 = ::std::mem::transmute(val);
1617 self._bitfield_1.set(2usize, 1u8, val as u64)
1618 }
1619 }
1620 #[inline]
1621 pub fn mRssi(&self) -> bool {
1622 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
1623 }
1624 #[inline]
1625 pub fn set_mRssi(&mut self, val: bool) {
1626 unsafe {
1627 let val: u8 = ::std::mem::transmute(val);
1628 self._bitfield_1.set(3usize, 1u8, val as u64)
1629 }
1630 }
1631 #[inline]
1632 pub fn mReserved(&self) -> bool {
1633 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
1634 }
1635 #[inline]
1636 pub fn set_mReserved(&mut self, val: bool) {
1637 unsafe {
1638 let val: u8 = ::std::mem::transmute(val);
1639 self._bitfield_1.set(4usize, 1u8, val as u64)
1640 }
1641 }
1642 #[inline]
1643 pub fn new_bitfield_1(
1644 mPduCount: bool,
1645 mLqi: bool,
1646 mLinkMargin: bool,
1647 mRssi: bool,
1648 mReserved: bool,
1649 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1650 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1651 __bindgen_bitfield_unit.set(0usize, 1u8, {
1652 let mPduCount: u8 = unsafe { ::std::mem::transmute(mPduCount) };
1653 mPduCount as u64
1654 });
1655 __bindgen_bitfield_unit.set(1usize, 1u8, {
1656 let mLqi: u8 = unsafe { ::std::mem::transmute(mLqi) };
1657 mLqi as u64
1658 });
1659 __bindgen_bitfield_unit.set(2usize, 1u8, {
1660 let mLinkMargin: u8 = unsafe { ::std::mem::transmute(mLinkMargin) };
1661 mLinkMargin as u64
1662 });
1663 __bindgen_bitfield_unit.set(3usize, 1u8, {
1664 let mRssi: u8 = unsafe { ::std::mem::transmute(mRssi) };
1665 mRssi as u64
1666 });
1667 __bindgen_bitfield_unit.set(4usize, 1u8, {
1668 let mReserved: u8 = unsafe { ::std::mem::transmute(mReserved) };
1669 mReserved as u64
1670 });
1671 __bindgen_bitfield_unit
1672 }
1673}
1674extern "C" {
1675 #[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)."]
1676 pub fn otPlatRadioGetCaps(aInstance: *mut otInstance) -> otRadioCaps;
1677}
1678extern "C" {
1679 #[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."]
1680 pub fn otPlatRadioGetVersionString(aInstance: *mut otInstance)
1681 -> *const ::std::os::raw::c_char;
1682}
1683extern "C" {
1684 #[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."]
1685 pub fn otPlatRadioGetReceiveSensitivity(aInstance: *mut otInstance) -> i8;
1686}
1687extern "C" {
1688 #[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."]
1689 pub fn otPlatRadioGetIeeeEui64(aInstance: *mut otInstance, aIeeeEui64: *mut u8);
1690}
1691extern "C" {
1692 #[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."]
1693 pub fn otPlatRadioSetPanId(aInstance: *mut otInstance, aPanId: otPanId);
1694}
1695extern "C" {
1696 #[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."]
1697 pub fn otPlatRadioSetExtendedAddress(
1698 aInstance: *mut otInstance,
1699 aExtAddress: *const otExtAddress,
1700 );
1701}
1702extern "C" {
1703 #[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."]
1704 pub fn otPlatRadioSetShortAddress(aInstance: *mut otInstance, aShortAddress: otShortAddress);
1705}
1706extern "C" {
1707 #[doc = " Set the alternate short address.\n\n This is an optional radio platform API. The radio platform MUST indicate support for this API by including the\n capability `OT_RADIO_CAPS_ALT_SHORT_ADDR` in `otPlatRadioGetCaps()`.\n\n When supported, the radio should accept received frames destined to the specified alternate short address in\n addition to the short address provided in `otPlatRadioSetShortAddress()`.\n\n The @p aShortAddress can be set to `OT_RADIO_INVALID_SHORT_ADDR` (0xfffe) to clear any previously set alternate\n short address.\n\n This function is used by OpenThread stack during child-to-router role transitions, allowing the device to continue\n receiving frames addressed to its previous short address for a short period.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aShortAddress The alternate IEEE 802.15.4 short address. `OT_RADIO_INVALID_SHORT_ADDR` to clear."]
1708 pub fn otPlatRadioSetAlternateShortAddress(
1709 aInstance: *mut otInstance,
1710 aShortAddress: otShortAddress,
1711 );
1712}
1713extern "C" {
1714 #[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."]
1715 pub fn otPlatRadioGetTransmitPower(aInstance: *mut otInstance, aPower: *mut i8) -> otError;
1716}
1717extern "C" {
1718 #[doc = " Set the radio's transmit power in dBm for all channels.\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 that was configured by `otPlatRadioSetChannelMaxTransmitPower()`.\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."]
1719 pub fn otPlatRadioSetTransmitPower(aInstance: *mut otInstance, aPower: i8) -> otError;
1720}
1721extern "C" {
1722 #[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."]
1723 pub fn otPlatRadioGetCcaEnergyDetectThreshold(
1724 aInstance: *mut otInstance,
1725 aThreshold: *mut i8,
1726 ) -> otError;
1727}
1728extern "C" {
1729 #[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."]
1730 pub fn otPlatRadioSetCcaEnergyDetectThreshold(
1731 aInstance: *mut otInstance,
1732 aThreshold: i8,
1733 ) -> otError;
1734}
1735extern "C" {
1736 #[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."]
1737 pub fn otPlatRadioGetFemLnaGain(aInstance: *mut otInstance, aGain: *mut i8) -> otError;
1738}
1739extern "C" {
1740 #[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."]
1741 pub fn otPlatRadioSetFemLnaGain(aInstance: *mut otInstance, aGain: i8) -> otError;
1742}
1743extern "C" {
1744 #[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."]
1745 pub fn otPlatRadioGetPromiscuous(aInstance: *mut otInstance) -> bool;
1746}
1747extern "C" {
1748 #[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."]
1749 pub fn otPlatRadioSetPromiscuous(aInstance: *mut otInstance, aEnable: bool);
1750}
1751extern "C" {
1752 #[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 Upon the transition of the \"RxOnWhenIdle\" flag from TRUE to FALSE, the radio platform should enter sleep mode.\n If the radio is currently in receive mode, it should enter sleep mode immediately. Otherwise, it should enter sleep\n mode after the current operation is completed.\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."]
1753 pub fn otPlatRadioSetRxOnWhenIdle(aInstance: *mut otInstance, aEnable: bool);
1754}
1755extern "C" {
1756 #[doc = " Update MAC keys and key index\n\n Is used when radio provides OT_RADIO_CAPS_TRANSMIT_SEC capability.\n\n The radio platform should reset the current security MAC frame counter tracked by the radio on this call. While this\n is highly recommended, the OpenThread stack, as a safeguard, will also reset the frame counter using the\n `otPlatRadioSetMacFrameCounter()` before calling this API.\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."]
1757 pub fn otPlatRadioSetMacKey(
1758 aInstance: *mut otInstance,
1759 aKeyIdMode: u8,
1760 aKeyId: u8,
1761 aPrevKey: *const otMacKeyMaterial,
1762 aCurrKey: *const otMacKeyMaterial,
1763 aNextKey: *const otMacKeyMaterial,
1764 aKeyType: otRadioKeyType,
1765 );
1766}
1767extern "C" {
1768 #[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."]
1769 pub fn otPlatRadioSetMacFrameCounter(aInstance: *mut otInstance, aMacFrameCounter: u32);
1770}
1771extern "C" {
1772 #[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."]
1773 pub fn otPlatRadioSetMacFrameCounterIfLarger(aInstance: *mut otInstance, aMacFrameCounter: u32);
1774}
1775extern "C" {
1776 #[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."]
1777 pub fn otPlatRadioGetNow(aInstance: *mut otInstance) -> u64;
1778}
1779extern "C" {
1780 #[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."]
1781 pub fn otPlatRadioGetBusSpeed(aInstance: *mut otInstance) -> u32;
1782}
1783extern "C" {
1784 #[doc = " Get the bus latency in microseconds between the host and the radio chip.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The bus latency in microseconds between the host and the radio chip.\n Return 0 when the MAC and above layer and Radio layer resides on the same chip."]
1785 pub fn otPlatRadioGetBusLatency(aInstance: *mut otInstance) -> u32;
1786}
1787extern "C" {
1788 #[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."]
1789 pub fn otPlatRadioGetState(aInstance: *mut otInstance) -> otRadioState;
1790}
1791extern "C" {
1792 #[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."]
1793 pub fn otPlatRadioEnable(aInstance: *mut otInstance) -> otError;
1794}
1795extern "C" {
1796 #[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."]
1797 pub fn otPlatRadioDisable(aInstance: *mut otInstance) -> otError;
1798}
1799extern "C" {
1800 #[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."]
1801 pub fn otPlatRadioIsEnabled(aInstance: *mut otInstance) -> bool;
1802}
1803extern "C" {
1804 #[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."]
1805 pub fn otPlatRadioSleep(aInstance: *mut otInstance) -> otError;
1806}
1807extern "C" {
1808 #[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."]
1809 pub fn otPlatRadioReceive(aInstance: *mut otInstance, aChannel: u8) -> otError;
1810}
1811extern "C" {
1812 #[doc = " Schedule a radio reception window at a specific time and duration.\n\n After a radio reception is successfully scheduled for a future time and duration, a subsequent call to this\n function MUST be handled as follows:\n\n - If the start time of the previously scheduled reception window has not yet been reached, the new call to\n `otPlatRadioReceiveAt()` MUST cancel the previous schedule, effectively replacing it.\n\n - If the start of the previous window has already passed, the previous receive schedule is already being executed\n by the radio and MUST NOT be replaced or impacted. The new call to `otPlatRadioReceiveAt()` would then schedule\n a new future receive window. In particular, if the new `otPlatRadioReceiveAt()` call occurs after the start\n but while still within the previous reception window, the ongoing reception window MUST NOT be impacted.\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. For example, if @p aStart is in the past."]
1813 pub fn otPlatRadioReceiveAt(
1814 aInstance: *mut otInstance,
1815 aChannel: u8,
1816 aStart: u32,
1817 aDuration: u32,
1818 ) -> otError;
1819}
1820extern "C" {
1821 #[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."]
1822 pub fn otPlatRadioReceiveDone(
1823 aInstance: *mut otInstance,
1824 aFrame: *mut otRadioFrame,
1825 aError: otError,
1826 );
1827}
1828extern "C" {
1829 #[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."]
1830 pub fn otPlatDiagRadioReceiveDone(
1831 aInstance: *mut otInstance,
1832 aFrame: *mut otRadioFrame,
1833 aError: otError,
1834 );
1835}
1836extern "C" {
1837 #[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."]
1838 pub fn otPlatRadioGetTransmitBuffer(aInstance: *mut otInstance) -> *mut otRadioFrame;
1839}
1840extern "C" {
1841 #[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."]
1842 pub fn otPlatRadioTransmit(aInstance: *mut otInstance, aFrame: *mut otRadioFrame) -> otError;
1843}
1844extern "C" {
1845 #[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."]
1846 pub fn otPlatRadioTxStarted(aInstance: *mut otInstance, aFrame: *mut otRadioFrame);
1847}
1848extern "C" {
1849 #[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."]
1850 pub fn otPlatRadioTxDone(
1851 aInstance: *mut otInstance,
1852 aFrame: *mut otRadioFrame,
1853 aAckFrame: *mut otRadioFrame,
1854 aError: otError,
1855 );
1856}
1857extern "C" {
1858 #[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."]
1859 pub fn otPlatDiagRadioTransmitDone(
1860 aInstance: *mut otInstance,
1861 aFrame: *mut otRadioFrame,
1862 aError: otError,
1863 );
1864}
1865extern "C" {
1866 #[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."]
1867 pub fn otPlatRadioGetRssi(aInstance: *mut otInstance) -> i8;
1868}
1869extern "C" {
1870 #[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."]
1871 pub fn otPlatRadioEnergyScan(
1872 aInstance: *mut otInstance,
1873 aScanChannel: u8,
1874 aScanDuration: u16,
1875 ) -> otError;
1876}
1877extern "C" {
1878 #[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."]
1879 pub fn otPlatRadioEnergyScanDone(aInstance: *mut otInstance, aEnergyScanMaxRssi: i8);
1880}
1881extern "C" {
1882 #[doc = " The radio driver calls this method to notify OpenThread that the spinel bus latency has been changed.\n\n @param[in] aInstance The OpenThread instance structure."]
1883 pub fn otPlatRadioBusLatencyChanged(aInstance: *mut otInstance);
1884}
1885extern "C" {
1886 #[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."]
1887 pub fn otPlatRadioEnableSrcMatch(aInstance: *mut otInstance, aEnable: bool);
1888}
1889extern "C" {
1890 #[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."]
1891 pub fn otPlatRadioAddSrcMatchShortEntry(
1892 aInstance: *mut otInstance,
1893 aShortAddress: otShortAddress,
1894 ) -> otError;
1895}
1896extern "C" {
1897 #[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."]
1898 pub fn otPlatRadioAddSrcMatchExtEntry(
1899 aInstance: *mut otInstance,
1900 aExtAddress: *const otExtAddress,
1901 ) -> otError;
1902}
1903extern "C" {
1904 #[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."]
1905 pub fn otPlatRadioClearSrcMatchShortEntry(
1906 aInstance: *mut otInstance,
1907 aShortAddress: otShortAddress,
1908 ) -> otError;
1909}
1910extern "C" {
1911 #[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."]
1912 pub fn otPlatRadioClearSrcMatchExtEntry(
1913 aInstance: *mut otInstance,
1914 aExtAddress: *const otExtAddress,
1915 ) -> otError;
1916}
1917extern "C" {
1918 #[doc = " Clear all short addresses from the source address match table.\n\n @param[in] aInstance The OpenThread instance structure."]
1919 pub fn otPlatRadioClearSrcMatchShortEntries(aInstance: *mut otInstance);
1920}
1921extern "C" {
1922 #[doc = " Clear all the extended/long addresses from source address match table.\n\n @param[in] aInstance The OpenThread instance structure."]
1923 pub fn otPlatRadioClearSrcMatchExtEntries(aInstance: *mut otInstance);
1924}
1925extern "C" {
1926 #[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."]
1927 pub fn otPlatRadioGetSupportedChannelMask(aInstance: *mut otInstance) -> u32;
1928}
1929extern "C" {
1930 #[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."]
1931 pub fn otPlatRadioGetPreferredChannelMask(aInstance: *mut otInstance) -> u32;
1932}
1933extern "C" {
1934 #[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."]
1935 pub fn otPlatRadioSetCoexEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
1936}
1937extern "C" {
1938 #[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."]
1939 pub fn otPlatRadioIsCoexEnabled(aInstance: *mut otInstance) -> bool;
1940}
1941extern "C" {
1942 #[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."]
1943 pub fn otPlatRadioGetCoexMetrics(
1944 aInstance: *mut otInstance,
1945 aCoexMetrics: *mut otRadioCoexMetrics,
1946 ) -> otError;
1947}
1948extern "C" {
1949 #[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."]
1950 pub fn otPlatRadioEnableCsl(
1951 aInstance: *mut otInstance,
1952 aCslPeriod: u32,
1953 aShortAddr: otShortAddress,
1954 aExtAddr: *const otExtAddress,
1955 ) -> otError;
1956}
1957extern "C" {
1958 #[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."]
1959 pub fn otPlatRadioResetCsl(aInstance: *mut otInstance) -> otError;
1960}
1961extern "C" {
1962 #[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."]
1963 pub fn otPlatRadioUpdateCslSampleTime(aInstance: *mut otInstance, aCslSampleTime: u32);
1964}
1965extern "C" {
1966 #[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."]
1967 pub fn otPlatRadioGetCslAccuracy(aInstance: *mut otInstance) -> u8;
1968}
1969extern "C" {
1970 #[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."]
1971 pub fn otPlatRadioGetCslUncertainty(aInstance: *mut otInstance) -> u8;
1972}
1973extern "C" {
1974 #[doc = " Set the max transmit power for a specific channel.\n\n @note This function will be deprecated in October 2027. It is recommended to use the function\n `otPlatRadioSetChannelTargetPower()`.\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."]
1975 pub fn otPlatRadioSetChannelMaxTransmitPower(
1976 aInstance: *mut otInstance,
1977 aChannel: u8,
1978 aMaxPower: i8,
1979 ) -> otError;
1980}
1981extern "C" {
1982 #[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."]
1983 pub fn otPlatRadioSetRegion(aInstance: *mut otInstance, aRegionCode: u16) -> otError;
1984}
1985extern "C" {
1986 #[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."]
1987 pub fn otPlatRadioGetRegion(aInstance: *mut otInstance, aRegionCode: *mut u16) -> otError;
1988}
1989extern "C" {
1990 #[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."]
1991 pub fn otPlatRadioConfigureEnhAckProbing(
1992 aInstance: *mut otInstance,
1993 aLinkMetrics: otLinkMetrics,
1994 aShortAddress: otShortAddress,
1995 aExtAddress: *const otExtAddress,
1996 ) -> otError;
1997}
1998extern "C" {
1999 #[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."]
2000 pub fn otPlatRadioAddCalibratedPower(
2001 aInstance: *mut otInstance,
2002 aChannel: u8,
2003 aActualPower: i16,
2004 aRawPowerSetting: *const u8,
2005 aRawPowerSettingLength: u16,
2006 ) -> otError;
2007}
2008extern "C" {
2009 #[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."]
2010 pub fn otPlatRadioClearCalibratedPowers(aInstance: *mut otInstance) -> otError;
2011}
2012extern "C" {
2013 #[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 function and `otPlatRadioSetTransmitPower()` are implemented at the same time:\n - If neither of these two functions is called, the radio outputs the platform-defined default power.\n - If both functions are called, the last one to be called takes effect.\n\n The radio driver should set the actual output power to be less than or equal to the @p aTargetPower and as close\n as possible to the @p aTargetPower. If the @p aTargetPower is lower than the minimum output power supported\n by the platform, the output power should be set to the minimum output power supported by the platform. If the\n @p aTargetPower is higher than the maximum output power supported by the platform, the output power should be\n set to the maximum output power supported by the platform. If the @p aTargetPower is set to `INT16_MAX`, the\n corresponding channel is disabled.\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.\n\n @retval OT_ERROR_NONE Successfully set the target power.\n @retval OT_ERROR_INVALID_ARGS The @p aChannel is invalid.\n @retval OT_ERROR_NOT_IMPLEMENTED The feature is not implemented."]
2014 pub fn otPlatRadioSetChannelTargetPower(
2015 aInstance: *mut otInstance,
2016 aChannel: u8,
2017 aTargetPower: i16,
2018 ) -> otError;
2019}
2020extern "C" {
2021 #[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."]
2022 pub fn otPlatRadioGetRawPowerSetting(
2023 aInstance: *mut otInstance,
2024 aChannel: u8,
2025 aRawPowerSetting: *mut u8,
2026 aRawPowerSettingLength: *mut u16,
2027 ) -> otError;
2028}
2029#[doc = " @struct otIp6InterfaceIdentifier\n\n Represents the Interface Identifier of an IPv6 address."]
2030#[repr(C, packed)]
2031#[derive(Copy, Clone)]
2032pub struct otIp6InterfaceIdentifier {
2033 #[doc = "< The Interface Identifier accessor fields"]
2034 pub mFields: otIp6InterfaceIdentifier__bindgen_ty_1,
2035}
2036#[repr(C, packed)]
2037#[derive(Copy, Clone)]
2038pub union otIp6InterfaceIdentifier__bindgen_ty_1 {
2039 #[doc = "< 8-bit fields"]
2040 pub m8: [u8; 8usize],
2041 #[doc = "< 16-bit fields"]
2042 pub m16: [u16; 4usize],
2043 #[doc = "< 32-bit fields"]
2044 pub m32: [u32; 2usize],
2045}
2046impl Default for otIp6InterfaceIdentifier__bindgen_ty_1 {
2047 fn default() -> Self {
2048 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2049 unsafe {
2050 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2051 s.assume_init()
2052 }
2053 }
2054}
2055impl Default for otIp6InterfaceIdentifier {
2056 fn default() -> Self {
2057 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2058 unsafe {
2059 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2060 s.assume_init()
2061 }
2062 }
2063}
2064#[doc = " @struct otIp6NetworkPrefix\n\n Represents the Network Prefix of an IPv6 address (most significant 64 bits of the address)."]
2065#[repr(C, packed)]
2066#[derive(Debug, Default, Copy, Clone)]
2067pub struct otIp6NetworkPrefix {
2068 #[doc = "< The Network Prefix."]
2069 pub m8: [u8; 8usize],
2070}
2071#[doc = " @struct otIp6AddressComponents\n\n Represents the components of an IPv6 address."]
2072#[repr(C, packed)]
2073#[derive(Copy, Clone)]
2074pub struct otIp6AddressComponents {
2075 #[doc = "< The Network Prefix (most significant 64 bits of the address)"]
2076 pub mNetworkPrefix: otIp6NetworkPrefix,
2077 #[doc = "< The Interface Identifier (least significant 64 bits of the address)"]
2078 pub mIid: otIp6InterfaceIdentifier,
2079}
2080impl Default for otIp6AddressComponents {
2081 fn default() -> Self {
2082 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2083 unsafe {
2084 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2085 s.assume_init()
2086 }
2087 }
2088}
2089#[doc = " @struct otIp6Address\n\n Represents an IPv6 address."]
2090#[repr(C, packed)]
2091#[derive(Copy, Clone)]
2092pub struct otIp6Address {
2093 #[doc = "< IPv6 accessor fields"]
2094 pub mFields: otIp6Address__bindgen_ty_1,
2095}
2096#[repr(C, packed)]
2097#[derive(Copy, Clone)]
2098pub union otIp6Address__bindgen_ty_1 {
2099 #[doc = "< 8-bit fields"]
2100 pub m8: [u8; 16usize],
2101 #[doc = "< 16-bit fields"]
2102 pub m16: [u16; 8usize],
2103 #[doc = "< 32-bit fields"]
2104 pub m32: [u32; 4usize],
2105 #[doc = "< IPv6 address components"]
2106 pub mComponents: otIp6AddressComponents,
2107}
2108impl Default for otIp6Address__bindgen_ty_1 {
2109 fn default() -> Self {
2110 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2111 unsafe {
2112 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2113 s.assume_init()
2114 }
2115 }
2116}
2117impl Default for otIp6Address {
2118 fn default() -> Self {
2119 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2120 unsafe {
2121 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2122 s.assume_init()
2123 }
2124 }
2125}
2126#[doc = " @struct otIp6Prefix\n\n Represents an IPv6 prefix."]
2127#[repr(C, packed)]
2128#[derive(Copy, Clone)]
2129pub struct otIp6Prefix {
2130 #[doc = "< The IPv6 prefix."]
2131 pub mPrefix: otIp6Address,
2132 #[doc = "< The IPv6 prefix length (in bits)."]
2133 pub mLength: u8,
2134}
2135impl Default for otIp6Prefix {
2136 fn default() -> Self {
2137 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2138 unsafe {
2139 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2140 s.assume_init()
2141 }
2142 }
2143}
2144#[doc = "< Thread assigned address (ALOC, RLOC, MLEID, etc)"]
2145pub const OT_ADDRESS_ORIGIN_THREAD: _bindgen_ty_7 = 0;
2146#[doc = "< SLAAC assigned address"]
2147pub const OT_ADDRESS_ORIGIN_SLAAC: _bindgen_ty_7 = 1;
2148#[doc = "< DHCPv6 assigned address"]
2149pub const OT_ADDRESS_ORIGIN_DHCPV6: _bindgen_ty_7 = 2;
2150#[doc = "< Manually assigned address"]
2151pub const OT_ADDRESS_ORIGIN_MANUAL: _bindgen_ty_7 = 3;
2152#[doc = " IPv6 Address origins"]
2153pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
2154#[doc = " Represents an IPv6 network interface unicast address."]
2155#[repr(C)]
2156#[derive(Copy, Clone)]
2157pub struct otNetifAddress {
2158 #[doc = "< The IPv6 unicast address."]
2159 pub mAddress: otIp6Address,
2160 #[doc = "< The Prefix length (in bits)."]
2161 pub mPrefixLength: u8,
2162 #[doc = "< The IPv6 address origin."]
2163 pub mAddressOrigin: u8,
2164 pub _bitfield_align_1: [u8; 0],
2165 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2166 #[doc = "< A pointer to the next network interface address."]
2167 pub mNext: *const otNetifAddress,
2168}
2169impl Default for otNetifAddress {
2170 fn default() -> Self {
2171 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2172 unsafe {
2173 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2174 s.assume_init()
2175 }
2176 }
2177}
2178impl otNetifAddress {
2179 #[inline]
2180 pub fn mPreferred(&self) -> bool {
2181 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2182 }
2183 #[inline]
2184 pub fn set_mPreferred(&mut self, val: bool) {
2185 unsafe {
2186 let val: u8 = ::std::mem::transmute(val);
2187 self._bitfield_1.set(0usize, 1u8, val as u64)
2188 }
2189 }
2190 #[inline]
2191 pub fn mValid(&self) -> bool {
2192 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
2193 }
2194 #[inline]
2195 pub fn set_mValid(&mut self, val: bool) {
2196 unsafe {
2197 let val: u8 = ::std::mem::transmute(val);
2198 self._bitfield_1.set(1usize, 1u8, val as u64)
2199 }
2200 }
2201 #[inline]
2202 pub fn mScopeOverrideValid(&self) -> bool {
2203 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2204 }
2205 #[inline]
2206 pub fn set_mScopeOverrideValid(&mut self, val: bool) {
2207 unsafe {
2208 let val: u8 = ::std::mem::transmute(val);
2209 self._bitfield_1.set(2usize, 1u8, val as u64)
2210 }
2211 }
2212 #[inline]
2213 pub fn mScopeOverride(&self) -> ::std::os::raw::c_uint {
2214 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 4u8) as u32) }
2215 }
2216 #[inline]
2217 pub fn set_mScopeOverride(&mut self, val: ::std::os::raw::c_uint) {
2218 unsafe {
2219 let val: u32 = ::std::mem::transmute(val);
2220 self._bitfield_1.set(3usize, 4u8, val as u64)
2221 }
2222 }
2223 #[inline]
2224 pub fn mRloc(&self) -> bool {
2225 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
2226 }
2227 #[inline]
2228 pub fn set_mRloc(&mut self, val: bool) {
2229 unsafe {
2230 let val: u8 = ::std::mem::transmute(val);
2231 self._bitfield_1.set(7usize, 1u8, val as u64)
2232 }
2233 }
2234 #[inline]
2235 pub fn mMeshLocal(&self) -> bool {
2236 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
2237 }
2238 #[inline]
2239 pub fn set_mMeshLocal(&mut self, val: bool) {
2240 unsafe {
2241 let val: u8 = ::std::mem::transmute(val);
2242 self._bitfield_1.set(8usize, 1u8, val as u64)
2243 }
2244 }
2245 #[inline]
2246 pub fn mSrpRegistered(&self) -> bool {
2247 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
2248 }
2249 #[inline]
2250 pub fn set_mSrpRegistered(&mut self, val: bool) {
2251 unsafe {
2252 let val: u8 = ::std::mem::transmute(val);
2253 self._bitfield_1.set(9usize, 1u8, val as u64)
2254 }
2255 }
2256 #[inline]
2257 pub fn new_bitfield_1(
2258 mPreferred: bool,
2259 mValid: bool,
2260 mScopeOverrideValid: bool,
2261 mScopeOverride: ::std::os::raw::c_uint,
2262 mRloc: bool,
2263 mMeshLocal: bool,
2264 mSrpRegistered: bool,
2265 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2266 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2267 __bindgen_bitfield_unit.set(0usize, 1u8, {
2268 let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
2269 mPreferred as u64
2270 });
2271 __bindgen_bitfield_unit.set(1usize, 1u8, {
2272 let mValid: u8 = unsafe { ::std::mem::transmute(mValid) };
2273 mValid as u64
2274 });
2275 __bindgen_bitfield_unit.set(2usize, 1u8, {
2276 let mScopeOverrideValid: u8 = unsafe { ::std::mem::transmute(mScopeOverrideValid) };
2277 mScopeOverrideValid as u64
2278 });
2279 __bindgen_bitfield_unit.set(3usize, 4u8, {
2280 let mScopeOverride: u32 = unsafe { ::std::mem::transmute(mScopeOverride) };
2281 mScopeOverride as u64
2282 });
2283 __bindgen_bitfield_unit.set(7usize, 1u8, {
2284 let mRloc: u8 = unsafe { ::std::mem::transmute(mRloc) };
2285 mRloc as u64
2286 });
2287 __bindgen_bitfield_unit.set(8usize, 1u8, {
2288 let mMeshLocal: u8 = unsafe { ::std::mem::transmute(mMeshLocal) };
2289 mMeshLocal as u64
2290 });
2291 __bindgen_bitfield_unit.set(9usize, 1u8, {
2292 let mSrpRegistered: u8 = unsafe { ::std::mem::transmute(mSrpRegistered) };
2293 mSrpRegistered as u64
2294 });
2295 __bindgen_bitfield_unit
2296 }
2297}
2298#[doc = " Represents an IPv6 network interface multicast address."]
2299#[repr(C)]
2300#[derive(Copy, Clone)]
2301pub struct otNetifMulticastAddress {
2302 #[doc = "< The IPv6 multicast address."]
2303 pub mAddress: otIp6Address,
2304 #[doc = "< A pointer to the next network interface multicast address."]
2305 pub mNext: *const otNetifMulticastAddress,
2306}
2307impl Default for otNetifMulticastAddress {
2308 fn default() -> Self {
2309 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2310 unsafe {
2311 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2312 s.assume_init()
2313 }
2314 }
2315}
2316#[doc = " Represents an IPv6 socket address."]
2317#[repr(C)]
2318#[derive(Copy, Clone)]
2319pub struct otSockAddr {
2320 #[doc = "< An IPv6 address."]
2321 pub mAddress: otIp6Address,
2322 #[doc = "< A transport-layer port."]
2323 pub mPort: u16,
2324}
2325impl Default for otSockAddr {
2326 fn default() -> Self {
2327 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2328 unsafe {
2329 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2330 s.assume_init()
2331 }
2332 }
2333}
2334#[doc = "< Non-ECT"]
2335pub const OT_ECN_NOT_CAPABLE: _bindgen_ty_8 = 0;
2336#[doc = "< ECT(0)"]
2337pub const OT_ECN_CAPABLE_0: _bindgen_ty_8 = 2;
2338#[doc = "< ECT(1)"]
2339pub const OT_ECN_CAPABLE_1: _bindgen_ty_8 = 1;
2340#[doc = "< Congestion encountered (CE)"]
2341pub const OT_ECN_MARKED: _bindgen_ty_8 = 3;
2342#[doc = " ECN statuses, represented as in the IP header."]
2343pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
2344#[doc = " Represents the local and peer IPv6 socket addresses."]
2345#[repr(C)]
2346#[derive(Copy, Clone)]
2347pub struct otMessageInfo {
2348 #[doc = "< The local IPv6 address."]
2349 pub mSockAddr: otIp6Address,
2350 #[doc = "< The peer IPv6 address."]
2351 pub mPeerAddr: otIp6Address,
2352 #[doc = "< The local transport-layer port."]
2353 pub mSockPort: u16,
2354 #[doc = "< The peer transport-layer port."]
2355 pub mPeerPort: u16,
2356 #[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."]
2357 pub mHopLimit: u8,
2358 pub _bitfield_align_1: [u8; 0],
2359 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2360}
2361impl Default for otMessageInfo {
2362 fn default() -> Self {
2363 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2364 unsafe {
2365 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2366 s.assume_init()
2367 }
2368 }
2369}
2370impl otMessageInfo {
2371 #[inline]
2372 pub fn mEcn(&self) -> u8 {
2373 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
2374 }
2375 #[inline]
2376 pub fn set_mEcn(&mut self, val: u8) {
2377 unsafe {
2378 let val: u8 = ::std::mem::transmute(val);
2379 self._bitfield_1.set(0usize, 2u8, val as u64)
2380 }
2381 }
2382 #[inline]
2383 pub fn mIsHostInterface(&self) -> bool {
2384 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2385 }
2386 #[inline]
2387 pub fn set_mIsHostInterface(&mut self, val: bool) {
2388 unsafe {
2389 let val: u8 = ::std::mem::transmute(val);
2390 self._bitfield_1.set(2usize, 1u8, val as u64)
2391 }
2392 }
2393 #[inline]
2394 pub fn mAllowZeroHopLimit(&self) -> bool {
2395 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
2396 }
2397 #[inline]
2398 pub fn set_mAllowZeroHopLimit(&mut self, val: bool) {
2399 unsafe {
2400 let val: u8 = ::std::mem::transmute(val);
2401 self._bitfield_1.set(3usize, 1u8, val as u64)
2402 }
2403 }
2404 #[inline]
2405 pub fn mMulticastLoop(&self) -> bool {
2406 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2407 }
2408 #[inline]
2409 pub fn set_mMulticastLoop(&mut self, val: bool) {
2410 unsafe {
2411 let val: u8 = ::std::mem::transmute(val);
2412 self._bitfield_1.set(4usize, 1u8, val as u64)
2413 }
2414 }
2415 #[inline]
2416 pub fn new_bitfield_1(
2417 mEcn: u8,
2418 mIsHostInterface: bool,
2419 mAllowZeroHopLimit: bool,
2420 mMulticastLoop: bool,
2421 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2422 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2423 __bindgen_bitfield_unit.set(0usize, 2u8, {
2424 let mEcn: u8 = unsafe { ::std::mem::transmute(mEcn) };
2425 mEcn as u64
2426 });
2427 __bindgen_bitfield_unit.set(2usize, 1u8, {
2428 let mIsHostInterface: u8 = unsafe { ::std::mem::transmute(mIsHostInterface) };
2429 mIsHostInterface as u64
2430 });
2431 __bindgen_bitfield_unit.set(3usize, 1u8, {
2432 let mAllowZeroHopLimit: u8 = unsafe { ::std::mem::transmute(mAllowZeroHopLimit) };
2433 mAllowZeroHopLimit as u64
2434 });
2435 __bindgen_bitfield_unit.set(4usize, 1u8, {
2436 let mMulticastLoop: u8 = unsafe { ::std::mem::transmute(mMulticastLoop) };
2437 mMulticastLoop as u64
2438 });
2439 __bindgen_bitfield_unit
2440 }
2441}
2442#[doc = "< IPv6 Hop-by-Hop Option"]
2443pub const OT_IP6_PROTO_HOP_OPTS: _bindgen_ty_9 = 0;
2444#[doc = "< Transmission Control Protocol"]
2445pub const OT_IP6_PROTO_TCP: _bindgen_ty_9 = 6;
2446#[doc = "< User Datagram"]
2447pub const OT_IP6_PROTO_UDP: _bindgen_ty_9 = 17;
2448#[doc = "< IPv6 encapsulation"]
2449pub const OT_IP6_PROTO_IP6: _bindgen_ty_9 = 41;
2450#[doc = "< Routing Header for IPv6"]
2451pub const OT_IP6_PROTO_ROUTING: _bindgen_ty_9 = 43;
2452#[doc = "< Fragment Header for IPv6"]
2453pub const OT_IP6_PROTO_FRAGMENT: _bindgen_ty_9 = 44;
2454#[doc = "< ICMP for IPv6"]
2455pub const OT_IP6_PROTO_ICMP6: _bindgen_ty_9 = 58;
2456#[doc = "< No Next Header for IPv6"]
2457pub const OT_IP6_PROTO_NONE: _bindgen_ty_9 = 59;
2458#[doc = "< Destination Options for IPv6"]
2459pub const OT_IP6_PROTO_DST_OPTS: _bindgen_ty_9 = 60;
2460#[doc = " Internet Protocol Numbers."]
2461pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
2462extern "C" {
2463 #[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)."]
2464 pub fn otIp6SetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
2465}
2466extern "C" {
2467 #[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."]
2468 pub fn otIp6IsEnabled(aInstance: *mut otInstance) -> bool;
2469}
2470extern "C" {
2471 #[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."]
2472 pub fn otIp6AddUnicastAddress(
2473 aInstance: *mut otInstance,
2474 aAddress: *const otNetifAddress,
2475 ) -> otError;
2476}
2477extern "C" {
2478 #[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."]
2479 pub fn otIp6RemoveUnicastAddress(
2480 aInstance: *mut otInstance,
2481 aAddress: *const otIp6Address,
2482 ) -> otError;
2483}
2484extern "C" {
2485 #[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."]
2486 pub fn otIp6GetUnicastAddresses(aInstance: *mut otInstance) -> *const otNetifAddress;
2487}
2488extern "C" {
2489 #[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."]
2490 pub fn otIp6HasUnicastAddress(
2491 aInstance: *mut otInstance,
2492 aAddress: *const otIp6Address,
2493 ) -> bool;
2494}
2495extern "C" {
2496 #[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."]
2497 pub fn otIp6SubscribeMulticastAddress(
2498 aInstance: *mut otInstance,
2499 aAddress: *const otIp6Address,
2500 ) -> otError;
2501}
2502extern "C" {
2503 #[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."]
2504 pub fn otIp6UnsubscribeMulticastAddress(
2505 aInstance: *mut otInstance,
2506 aAddress: *const otIp6Address,
2507 ) -> otError;
2508}
2509extern "C" {
2510 #[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."]
2511 pub fn otIp6GetMulticastAddresses(aInstance: *mut otInstance)
2512 -> *const otNetifMulticastAddress;
2513}
2514extern "C" {
2515 #[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"]
2516 pub fn otIp6NewMessage(
2517 aInstance: *mut otInstance,
2518 aSettings: *const otMessageSettings,
2519 ) -> *mut otMessage;
2520}
2521extern "C" {
2522 #[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"]
2523 pub fn otIp6NewMessageFromBuffer(
2524 aInstance: *mut otInstance,
2525 aData: *const u8,
2526 aDataLength: u16,
2527 aSettings: *const otMessageSettings,
2528 ) -> *mut otMessage;
2529}
2530#[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."]
2531pub type otIp6ReceiveCallback = ::std::option::Option<
2532 unsafe extern "C" fn(aMessage: *mut otMessage, aContext: *mut ::std::os::raw::c_void),
2533>;
2534extern "C" {
2535 #[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"]
2536 pub fn otIp6SetReceiveCallback(
2537 aInstance: *mut otInstance,
2538 aCallback: otIp6ReceiveCallback,
2539 aCallbackContext: *mut ::std::os::raw::c_void,
2540 );
2541}
2542#[doc = " Represents IPv6 address information."]
2543#[repr(C)]
2544#[derive(Debug, Copy, Clone)]
2545pub struct otIp6AddressInfo {
2546 #[doc = "< A pointer to the IPv6 address."]
2547 pub mAddress: *const otIp6Address,
2548 #[doc = "< The prefix length of mAddress if it is a unicast address."]
2549 pub mPrefixLength: u8,
2550 pub _bitfield_align_1: [u8; 0],
2551 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2552 pub __bindgen_padding_0: [u16; 3usize],
2553}
2554impl Default for otIp6AddressInfo {
2555 fn default() -> Self {
2556 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2557 unsafe {
2558 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2559 s.assume_init()
2560 }
2561 }
2562}
2563impl otIp6AddressInfo {
2564 #[inline]
2565 pub fn mScope(&self) -> u8 {
2566 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
2567 }
2568 #[inline]
2569 pub fn set_mScope(&mut self, val: u8) {
2570 unsafe {
2571 let val: u8 = ::std::mem::transmute(val);
2572 self._bitfield_1.set(0usize, 4u8, val as u64)
2573 }
2574 }
2575 #[inline]
2576 pub fn mPreferred(&self) -> bool {
2577 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2578 }
2579 #[inline]
2580 pub fn set_mPreferred(&mut self, val: bool) {
2581 unsafe {
2582 let val: u8 = ::std::mem::transmute(val);
2583 self._bitfield_1.set(4usize, 1u8, val as u64)
2584 }
2585 }
2586 #[inline]
2587 pub fn mMeshLocal(&self) -> bool {
2588 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
2589 }
2590 #[inline]
2591 pub fn set_mMeshLocal(&mut self, val: bool) {
2592 unsafe {
2593 let val: u8 = ::std::mem::transmute(val);
2594 self._bitfield_1.set(5usize, 1u8, val as u64)
2595 }
2596 }
2597 #[inline]
2598 pub fn new_bitfield_1(
2599 mScope: u8,
2600 mPreferred: bool,
2601 mMeshLocal: bool,
2602 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2603 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2604 __bindgen_bitfield_unit.set(0usize, 4u8, {
2605 let mScope: u8 = unsafe { ::std::mem::transmute(mScope) };
2606 mScope as u64
2607 });
2608 __bindgen_bitfield_unit.set(4usize, 1u8, {
2609 let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
2610 mPreferred as u64
2611 });
2612 __bindgen_bitfield_unit.set(5usize, 1u8, {
2613 let mMeshLocal: u8 = unsafe { ::std::mem::transmute(mMeshLocal) };
2614 mMeshLocal as u64
2615 });
2616 __bindgen_bitfield_unit
2617 }
2618}
2619#[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."]
2620pub type otIp6AddressCallback = ::std::option::Option<
2621 unsafe extern "C" fn(
2622 aAddressInfo: *const otIp6AddressInfo,
2623 aIsAdded: bool,
2624 aContext: *mut ::std::os::raw::c_void,
2625 ),
2626>;
2627extern "C" {
2628 #[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."]
2629 pub fn otIp6SetAddressCallback(
2630 aInstance: *mut otInstance,
2631 aCallback: otIp6AddressCallback,
2632 aCallbackContext: *mut ::std::os::raw::c_void,
2633 );
2634}
2635extern "C" {
2636 #[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"]
2637 pub fn otIp6IsReceiveFilterEnabled(aInstance: *mut otInstance) -> bool;
2638}
2639extern "C" {
2640 #[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"]
2641 pub fn otIp6SetReceiveFilterEnabled(aInstance: *mut otInstance, aEnabled: bool);
2642}
2643extern "C" {
2644 #[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."]
2645 pub fn otIp6Send(aInstance: *mut otInstance, aMessage: *mut otMessage) -> otError;
2646}
2647extern "C" {
2648 #[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."]
2649 pub fn otIp6AddUnsecurePort(aInstance: *mut otInstance, aPort: u16) -> otError;
2650}
2651extern "C" {
2652 #[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."]
2653 pub fn otIp6RemoveUnsecurePort(aInstance: *mut otInstance, aPort: u16) -> otError;
2654}
2655extern "C" {
2656 #[doc = " Removes all ports from the allowed unsecure port list.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
2657 pub fn otIp6RemoveAllUnsecurePorts(aInstance: *mut otInstance);
2658}
2659extern "C" {
2660 #[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."]
2661 pub fn otIp6GetUnsecurePorts(aInstance: *mut otInstance, aNumEntries: *mut u8) -> *const u16;
2662}
2663extern "C" {
2664 #[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."]
2665 pub fn otIp6IsAddressEqual(aFirst: *const otIp6Address, aSecond: *const otIp6Address) -> bool;
2666}
2667extern "C" {
2668 #[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."]
2669 pub fn otIp6ArePrefixesEqual(aFirst: *const otIp6Prefix, aSecond: *const otIp6Prefix) -> bool;
2670}
2671extern "C" {
2672 #[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."]
2673 pub fn otIp6AddressFromString(
2674 aString: *const ::std::os::raw::c_char,
2675 aAddress: *mut otIp6Address,
2676 ) -> otError;
2677}
2678extern "C" {
2679 #[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."]
2680 pub fn otIp6PrefixFromString(
2681 aString: *const ::std::os::raw::c_char,
2682 aPrefix: *mut otIp6Prefix,
2683 ) -> otError;
2684}
2685extern "C" {
2686 #[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`."]
2687 pub fn otIp6AddressToString(
2688 aAddress: *const otIp6Address,
2689 aBuffer: *mut ::std::os::raw::c_char,
2690 aSize: u16,
2691 );
2692}
2693extern "C" {
2694 #[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`."]
2695 pub fn otIp6SockAddrToString(
2696 aSockAddr: *const otSockAddr,
2697 aBuffer: *mut ::std::os::raw::c_char,
2698 aSize: u16,
2699 );
2700}
2701extern "C" {
2702 #[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`."]
2703 pub fn otIp6PrefixToString(
2704 aPrefix: *const otIp6Prefix,
2705 aBuffer: *mut ::std::os::raw::c_char,
2706 aSize: u16,
2707 );
2708}
2709extern "C" {
2710 #[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."]
2711 pub fn otIp6PrefixMatch(aFirst: *const otIp6Address, aSecond: *const otIp6Address) -> u8;
2712}
2713extern "C" {
2714 #[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."]
2715 pub fn otIp6GetPrefix(aAddress: *const otIp6Address, aLength: u8, aPrefix: *mut otIp6Prefix);
2716}
2717extern "C" {
2718 #[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."]
2719 pub fn otIp6IsAddressUnspecified(aAddress: *const otIp6Address) -> bool;
2720}
2721extern "C" {
2722 #[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."]
2723 pub fn otIp6SelectSourceAddress(
2724 aInstance: *mut otInstance,
2725 aMessageInfo: *mut otMessageInfo,
2726 ) -> otError;
2727}
2728extern "C" {
2729 #[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."]
2730 pub fn otIp6IsSlaacEnabled(aInstance: *mut otInstance) -> bool;
2731}
2732extern "C" {
2733 #[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."]
2734 pub fn otIp6SetSlaacEnabled(aInstance: *mut otInstance, aEnabled: bool);
2735}
2736#[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."]
2737pub type otIp6SlaacPrefixFilter = ::std::option::Option<
2738 unsafe extern "C" fn(aInstance: *mut otInstance, aPrefix: *const otIp6Prefix) -> bool,
2739>;
2740extern "C" {
2741 #[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."]
2742 pub fn otIp6SetSlaacPrefixFilter(aInstance: *mut otInstance, aFilter: otIp6SlaacPrefixFilter);
2743}
2744#[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"]
2745pub type otIp6RegisterMulticastListenersCallback = ::std::option::Option<
2746 unsafe extern "C" fn(
2747 aContext: *mut ::std::os::raw::c_void,
2748 aError: otError,
2749 aMlrStatus: u8,
2750 aFailedAddresses: *const otIp6Address,
2751 aFailedAddressNum: u8,
2752 ),
2753>;
2754extern "C" {
2755 #[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"]
2756 pub fn otIp6RegisterMulticastListeners(
2757 aInstance: *mut otInstance,
2758 aAddresses: *const otIp6Address,
2759 aAddressNum: u8,
2760 aTimeout: *const u32,
2761 aCallback: otIp6RegisterMulticastListenersCallback,
2762 aContext: *mut ::std::os::raw::c_void,
2763 ) -> otError;
2764}
2765extern "C" {
2766 #[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."]
2767 pub fn otIp6SetMeshLocalIid(
2768 aInstance: *mut otInstance,
2769 aIid: *const otIp6InterfaceIdentifier,
2770 ) -> otError;
2771}
2772extern "C" {
2773 #[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."]
2774 pub fn otIp6ProtoToString(aIpProto: u8) -> *const ::std::os::raw::c_char;
2775}
2776#[doc = " Represents the counters for packets and bytes."]
2777#[repr(C)]
2778#[derive(Debug, Default, Copy, Clone)]
2779pub struct otPacketsAndBytes {
2780 #[doc = "< The number of packets."]
2781 pub mPackets: u64,
2782 #[doc = "< The number of bytes."]
2783 pub mBytes: u64,
2784}
2785#[doc = " Represents the counters of packets forwarded via Border Routing."]
2786#[repr(C)]
2787#[derive(Debug, Default, Copy, Clone)]
2788pub struct otBorderRoutingCounters {
2789 #[doc = "< The counters for inbound unicast."]
2790 pub mInboundUnicast: otPacketsAndBytes,
2791 #[doc = "< The counters for inbound multicast."]
2792 pub mInboundMulticast: otPacketsAndBytes,
2793 #[doc = "< The counters for outbound unicast."]
2794 pub mOutboundUnicast: otPacketsAndBytes,
2795 #[doc = "< The counters for outbound multicast."]
2796 pub mOutboundMulticast: otPacketsAndBytes,
2797 #[doc = "< The counters for inbound Internet when DHCPv6 PD enabled."]
2798 pub mInboundInternet: otPacketsAndBytes,
2799 #[doc = "< The counters for outbound Internet when DHCPv6 PD enabled."]
2800 pub mOutboundInternet: otPacketsAndBytes,
2801 #[doc = "< The number of received RA packets."]
2802 pub mRaRx: u32,
2803 #[doc = "< The number of RA packets successfully transmitted."]
2804 pub mRaTxSuccess: u32,
2805 #[doc = "< The number of RA packets failed to transmit."]
2806 pub mRaTxFailure: u32,
2807 #[doc = "< The number of received RS packets."]
2808 pub mRsRx: u32,
2809 #[doc = "< The number of RS packets successfully transmitted."]
2810 pub mRsTxSuccess: u32,
2811 #[doc = "< The number of RS packets failed to transmit."]
2812 pub mRsTxFailure: u32,
2813}
2814extern "C" {
2815 #[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."]
2816 pub fn otIp6GetBorderRoutingCounters(
2817 aInstance: *mut otInstance,
2818 ) -> *const otBorderRoutingCounters;
2819}
2820extern "C" {
2821 #[doc = " Resets the Border Routing counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
2822 pub fn otIp6ResetBorderRoutingCounters(aInstance: *mut otInstance);
2823}
2824#[doc = " @struct otNetworkKey\n\n Represents a Thread Network Key."]
2825#[repr(C, packed)]
2826#[derive(Debug, Default, Copy, Clone)]
2827pub struct otNetworkKey {
2828 #[doc = "< Byte values"]
2829 pub m8: [u8; 16usize],
2830}
2831#[doc = " This datatype represents KeyRef to NetworkKey."]
2832pub type otNetworkKeyRef = otCryptoKeyRef;
2833#[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`)."]
2834#[repr(C)]
2835#[derive(Debug, Default, Copy, Clone)]
2836pub struct otNetworkName {
2837 #[doc = "< Byte values. The `+ 1` is for null char."]
2838 pub m8: [::std::os::raw::c_char; 17usize],
2839}
2840#[doc = " Represents an Extended PAN ID."]
2841#[repr(C, packed)]
2842#[derive(Debug, Default, Copy, Clone)]
2843pub struct otExtendedPanId {
2844 #[doc = "< Byte values"]
2845 pub m8: [u8; 8usize],
2846}
2847#[doc = " @struct otIp6NetworkPrefix\n\n Represents the Network Prefix of an IPv6 address (most significant 64 bits of the address)."]
2848pub type otMeshLocalPrefix = otIp6NetworkPrefix;
2849#[doc = " Represents PSKc."]
2850#[repr(C, packed)]
2851#[derive(Debug, Default, Copy, Clone)]
2852pub struct otPskc {
2853 #[doc = "< Byte values"]
2854 pub m8: [u8; 16usize],
2855}
2856#[doc = " This datatype represents KeyRef to PSKc."]
2857pub type otPskcRef = otCryptoKeyRef;
2858#[doc = " Represent Security Policy."]
2859#[repr(C)]
2860#[derive(Debug, Default, Copy, Clone)]
2861pub struct otSecurityPolicy {
2862 #[doc = "< The value for thrKeyRotation in units of hours."]
2863 pub mRotationTime: u16,
2864 pub _bitfield_align_1: [u8; 0],
2865 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2866}
2867impl otSecurityPolicy {
2868 #[inline]
2869 pub fn mObtainNetworkKeyEnabled(&self) -> bool {
2870 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2871 }
2872 #[inline]
2873 pub fn set_mObtainNetworkKeyEnabled(&mut self, val: bool) {
2874 unsafe {
2875 let val: u8 = ::std::mem::transmute(val);
2876 self._bitfield_1.set(0usize, 1u8, val as u64)
2877 }
2878 }
2879 #[inline]
2880 pub fn mNativeCommissioningEnabled(&self) -> bool {
2881 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
2882 }
2883 #[inline]
2884 pub fn set_mNativeCommissioningEnabled(&mut self, val: bool) {
2885 unsafe {
2886 let val: u8 = ::std::mem::transmute(val);
2887 self._bitfield_1.set(1usize, 1u8, val as u64)
2888 }
2889 }
2890 #[inline]
2891 pub fn mRoutersEnabled(&self) -> bool {
2892 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2893 }
2894 #[inline]
2895 pub fn set_mRoutersEnabled(&mut self, val: bool) {
2896 unsafe {
2897 let val: u8 = ::std::mem::transmute(val);
2898 self._bitfield_1.set(2usize, 1u8, val as u64)
2899 }
2900 }
2901 #[inline]
2902 pub fn mExternalCommissioningEnabled(&self) -> bool {
2903 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
2904 }
2905 #[inline]
2906 pub fn set_mExternalCommissioningEnabled(&mut self, val: bool) {
2907 unsafe {
2908 let val: u8 = ::std::mem::transmute(val);
2909 self._bitfield_1.set(3usize, 1u8, val as u64)
2910 }
2911 }
2912 #[inline]
2913 pub fn mCommercialCommissioningEnabled(&self) -> bool {
2914 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2915 }
2916 #[inline]
2917 pub fn set_mCommercialCommissioningEnabled(&mut self, val: bool) {
2918 unsafe {
2919 let val: u8 = ::std::mem::transmute(val);
2920 self._bitfield_1.set(4usize, 1u8, val as u64)
2921 }
2922 }
2923 #[inline]
2924 pub fn mAutonomousEnrollmentEnabled(&self) -> bool {
2925 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
2926 }
2927 #[inline]
2928 pub fn set_mAutonomousEnrollmentEnabled(&mut self, val: bool) {
2929 unsafe {
2930 let val: u8 = ::std::mem::transmute(val);
2931 self._bitfield_1.set(5usize, 1u8, val as u64)
2932 }
2933 }
2934 #[inline]
2935 pub fn mNetworkKeyProvisioningEnabled(&self) -> bool {
2936 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
2937 }
2938 #[inline]
2939 pub fn set_mNetworkKeyProvisioningEnabled(&mut self, val: bool) {
2940 unsafe {
2941 let val: u8 = ::std::mem::transmute(val);
2942 self._bitfield_1.set(6usize, 1u8, val as u64)
2943 }
2944 }
2945 #[inline]
2946 pub fn mTobleLinkEnabled(&self) -> bool {
2947 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
2948 }
2949 #[inline]
2950 pub fn set_mTobleLinkEnabled(&mut self, val: bool) {
2951 unsafe {
2952 let val: u8 = ::std::mem::transmute(val);
2953 self._bitfield_1.set(7usize, 1u8, val as u64)
2954 }
2955 }
2956 #[inline]
2957 pub fn mNonCcmRoutersEnabled(&self) -> bool {
2958 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
2959 }
2960 #[inline]
2961 pub fn set_mNonCcmRoutersEnabled(&mut self, val: bool) {
2962 unsafe {
2963 let val: u8 = ::std::mem::transmute(val);
2964 self._bitfield_1.set(8usize, 1u8, val as u64)
2965 }
2966 }
2967 #[inline]
2968 pub fn mVersionThresholdForRouting(&self) -> u8 {
2969 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 3u8) as u8) }
2970 }
2971 #[inline]
2972 pub fn set_mVersionThresholdForRouting(&mut self, val: u8) {
2973 unsafe {
2974 let val: u8 = ::std::mem::transmute(val);
2975 self._bitfield_1.set(9usize, 3u8, val as u64)
2976 }
2977 }
2978 #[inline]
2979 pub fn new_bitfield_1(
2980 mObtainNetworkKeyEnabled: bool,
2981 mNativeCommissioningEnabled: bool,
2982 mRoutersEnabled: bool,
2983 mExternalCommissioningEnabled: bool,
2984 mCommercialCommissioningEnabled: bool,
2985 mAutonomousEnrollmentEnabled: bool,
2986 mNetworkKeyProvisioningEnabled: bool,
2987 mTobleLinkEnabled: bool,
2988 mNonCcmRoutersEnabled: bool,
2989 mVersionThresholdForRouting: u8,
2990 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2991 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2992 __bindgen_bitfield_unit.set(0usize, 1u8, {
2993 let mObtainNetworkKeyEnabled: u8 =
2994 unsafe { ::std::mem::transmute(mObtainNetworkKeyEnabled) };
2995 mObtainNetworkKeyEnabled as u64
2996 });
2997 __bindgen_bitfield_unit.set(1usize, 1u8, {
2998 let mNativeCommissioningEnabled: u8 =
2999 unsafe { ::std::mem::transmute(mNativeCommissioningEnabled) };
3000 mNativeCommissioningEnabled as u64
3001 });
3002 __bindgen_bitfield_unit.set(2usize, 1u8, {
3003 let mRoutersEnabled: u8 = unsafe { ::std::mem::transmute(mRoutersEnabled) };
3004 mRoutersEnabled as u64
3005 });
3006 __bindgen_bitfield_unit.set(3usize, 1u8, {
3007 let mExternalCommissioningEnabled: u8 =
3008 unsafe { ::std::mem::transmute(mExternalCommissioningEnabled) };
3009 mExternalCommissioningEnabled as u64
3010 });
3011 __bindgen_bitfield_unit.set(4usize, 1u8, {
3012 let mCommercialCommissioningEnabled: u8 =
3013 unsafe { ::std::mem::transmute(mCommercialCommissioningEnabled) };
3014 mCommercialCommissioningEnabled as u64
3015 });
3016 __bindgen_bitfield_unit.set(5usize, 1u8, {
3017 let mAutonomousEnrollmentEnabled: u8 =
3018 unsafe { ::std::mem::transmute(mAutonomousEnrollmentEnabled) };
3019 mAutonomousEnrollmentEnabled as u64
3020 });
3021 __bindgen_bitfield_unit.set(6usize, 1u8, {
3022 let mNetworkKeyProvisioningEnabled: u8 =
3023 unsafe { ::std::mem::transmute(mNetworkKeyProvisioningEnabled) };
3024 mNetworkKeyProvisioningEnabled as u64
3025 });
3026 __bindgen_bitfield_unit.set(7usize, 1u8, {
3027 let mTobleLinkEnabled: u8 = unsafe { ::std::mem::transmute(mTobleLinkEnabled) };
3028 mTobleLinkEnabled as u64
3029 });
3030 __bindgen_bitfield_unit.set(8usize, 1u8, {
3031 let mNonCcmRoutersEnabled: u8 = unsafe { ::std::mem::transmute(mNonCcmRoutersEnabled) };
3032 mNonCcmRoutersEnabled as u64
3033 });
3034 __bindgen_bitfield_unit.set(9usize, 3u8, {
3035 let mVersionThresholdForRouting: u8 =
3036 unsafe { ::std::mem::transmute(mVersionThresholdForRouting) };
3037 mVersionThresholdForRouting as u64
3038 });
3039 __bindgen_bitfield_unit
3040 }
3041}
3042#[doc = " Represents Channel Mask."]
3043pub type otChannelMask = u32;
3044#[doc = " Represents presence of different components in Active or Pending Operational Dataset."]
3045#[repr(C)]
3046#[derive(Debug, Default, Copy, Clone)]
3047pub struct otOperationalDatasetComponents {
3048 #[doc = "< TRUE if Active Timestamp is present, FALSE otherwise."]
3049 pub mIsActiveTimestampPresent: bool,
3050 #[doc = "< TRUE if Pending Timestamp is present, FALSE otherwise."]
3051 pub mIsPendingTimestampPresent: bool,
3052 #[doc = "< TRUE if Network Key is present, FALSE otherwise."]
3053 pub mIsNetworkKeyPresent: bool,
3054 #[doc = "< TRUE if Network Name is present, FALSE otherwise."]
3055 pub mIsNetworkNamePresent: bool,
3056 #[doc = "< TRUE if Extended PAN ID is present, FALSE otherwise."]
3057 pub mIsExtendedPanIdPresent: bool,
3058 #[doc = "< TRUE if Mesh Local Prefix is present, FALSE otherwise."]
3059 pub mIsMeshLocalPrefixPresent: bool,
3060 #[doc = "< TRUE if Delay Timer is present, FALSE otherwise."]
3061 pub mIsDelayPresent: bool,
3062 #[doc = "< TRUE if PAN ID is present, FALSE otherwise."]
3063 pub mIsPanIdPresent: bool,
3064 #[doc = "< TRUE if Channel is present, FALSE otherwise."]
3065 pub mIsChannelPresent: bool,
3066 #[doc = "< TRUE if PSKc is present, FALSE otherwise."]
3067 pub mIsPskcPresent: bool,
3068 #[doc = "< TRUE if Security Policy is present, FALSE otherwise."]
3069 pub mIsSecurityPolicyPresent: bool,
3070 #[doc = "< TRUE if Channel Mask is present, FALSE otherwise."]
3071 pub mIsChannelMaskPresent: bool,
3072 #[doc = "< TRUE if Wake-up Channel is present, FALSE otherwise."]
3073 pub mIsWakeupChannelPresent: bool,
3074}
3075#[doc = " Represents a Thread Dataset timestamp component."]
3076#[repr(C)]
3077#[derive(Debug, Default, Copy, Clone)]
3078pub struct otTimestamp {
3079 pub mSeconds: u64,
3080 pub mTicks: u16,
3081 pub mAuthoritative: bool,
3082}
3083#[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."]
3084#[repr(C)]
3085#[derive(Debug, Default, Copy, Clone)]
3086pub struct otOperationalDataset {
3087 #[doc = "< Active Timestamp"]
3088 pub mActiveTimestamp: otTimestamp,
3089 #[doc = "< Pending Timestamp"]
3090 pub mPendingTimestamp: otTimestamp,
3091 #[doc = "< Network Key"]
3092 pub mNetworkKey: otNetworkKey,
3093 #[doc = "< Network Name"]
3094 pub mNetworkName: otNetworkName,
3095 #[doc = "< Extended PAN ID"]
3096 pub mExtendedPanId: otExtendedPanId,
3097 #[doc = "< Mesh Local Prefix"]
3098 pub mMeshLocalPrefix: otMeshLocalPrefix,
3099 #[doc = "< Delay Timer"]
3100 pub mDelay: u32,
3101 #[doc = "< PAN ID"]
3102 pub mPanId: otPanId,
3103 #[doc = "< Channel"]
3104 pub mChannel: u16,
3105 #[doc = "< Wake-up Channel"]
3106 pub mWakeupChannel: u16,
3107 #[doc = "< PSKc"]
3108 pub mPskc: otPskc,
3109 #[doc = "< Security Policy"]
3110 pub mSecurityPolicy: otSecurityPolicy,
3111 #[doc = "< Channel Mask"]
3112 pub mChannelMask: otChannelMask,
3113 #[doc = "< Specifies which components are set in the Dataset."]
3114 pub mComponents: otOperationalDatasetComponents,
3115}
3116#[doc = " Represents an Active or Pending Operational Dataset.\n\n The Operational Dataset is TLV encoded as specified by Thread."]
3117#[repr(C)]
3118#[derive(Debug, Copy, Clone)]
3119pub struct otOperationalDatasetTlvs {
3120 #[doc = "< Operational Dataset TLVs."]
3121 pub mTlvs: [u8; 254usize],
3122 #[doc = "< Size of Operational Dataset in bytes."]
3123 pub mLength: u8,
3124}
3125impl Default for otOperationalDatasetTlvs {
3126 fn default() -> Self {
3127 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3128 unsafe {
3129 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3130 s.assume_init()
3131 }
3132 }
3133}
3134#[doc = "< meshcop Channel TLV"]
3135pub const OT_MESHCOP_TLV_CHANNEL: otMeshcopTlvType = 0;
3136#[doc = "< meshcop Pan Id TLV"]
3137pub const OT_MESHCOP_TLV_PANID: otMeshcopTlvType = 1;
3138#[doc = "< meshcop Extended Pan Id TLV"]
3139pub const OT_MESHCOP_TLV_EXTPANID: otMeshcopTlvType = 2;
3140#[doc = "< meshcop Network Name TLV"]
3141pub const OT_MESHCOP_TLV_NETWORKNAME: otMeshcopTlvType = 3;
3142#[doc = "< meshcop PSKc TLV"]
3143pub const OT_MESHCOP_TLV_PSKC: otMeshcopTlvType = 4;
3144#[doc = "< meshcop Network Key TLV"]
3145pub const OT_MESHCOP_TLV_NETWORKKEY: otMeshcopTlvType = 5;
3146#[doc = "< meshcop Network Key Sequence TLV"]
3147pub const OT_MESHCOP_TLV_NETWORK_KEY_SEQUENCE: otMeshcopTlvType = 6;
3148#[doc = "< meshcop Mesh Local Prefix TLV"]
3149pub const OT_MESHCOP_TLV_MESHLOCALPREFIX: otMeshcopTlvType = 7;
3150#[doc = "< meshcop Steering Data TLV"]
3151pub const OT_MESHCOP_TLV_STEERING_DATA: otMeshcopTlvType = 8;
3152#[doc = "< meshcop Border Agent Locator TLV"]
3153pub const OT_MESHCOP_TLV_BORDER_AGENT_RLOC: otMeshcopTlvType = 9;
3154#[doc = "< meshcop Commissioner ID TLV"]
3155pub const OT_MESHCOP_TLV_COMMISSIONER_ID: otMeshcopTlvType = 10;
3156#[doc = "< meshcop Commissioner Session ID TLV"]
3157pub const OT_MESHCOP_TLV_COMM_SESSION_ID: otMeshcopTlvType = 11;
3158#[doc = "< meshcop Security Policy TLV"]
3159pub const OT_MESHCOP_TLV_SECURITYPOLICY: otMeshcopTlvType = 12;
3160#[doc = "< meshcop Get TLV"]
3161pub const OT_MESHCOP_TLV_GET: otMeshcopTlvType = 13;
3162#[doc = "< meshcop Active Timestamp TLV"]
3163pub const OT_MESHCOP_TLV_ACTIVETIMESTAMP: otMeshcopTlvType = 14;
3164#[doc = "< meshcop Commissioner UDP Port TLV"]
3165pub const OT_MESHCOP_TLV_COMMISSIONER_UDP_PORT: otMeshcopTlvType = 15;
3166#[doc = "< meshcop State TLV"]
3167pub const OT_MESHCOP_TLV_STATE: otMeshcopTlvType = 16;
3168#[doc = "< meshcop Joiner DTLS Encapsulation TLV"]
3169pub const OT_MESHCOP_TLV_JOINER_DTLS: otMeshcopTlvType = 17;
3170#[doc = "< meshcop Joiner UDP Port TLV"]
3171pub const OT_MESHCOP_TLV_JOINER_UDP_PORT: otMeshcopTlvType = 18;
3172#[doc = "< meshcop Joiner IID TLV"]
3173pub const OT_MESHCOP_TLV_JOINER_IID: otMeshcopTlvType = 19;
3174#[doc = "< meshcop Joiner Router Locator TLV"]
3175pub const OT_MESHCOP_TLV_JOINER_RLOC: otMeshcopTlvType = 20;
3176#[doc = "< meshcop Joiner Router KEK TLV"]
3177pub const OT_MESHCOP_TLV_JOINER_ROUTER_KEK: otMeshcopTlvType = 21;
3178#[doc = "< meshcop Provisioning URL TLV"]
3179pub const OT_MESHCOP_TLV_PROVISIONING_URL: otMeshcopTlvType = 32;
3180#[doc = "< meshcop Vendor Name TLV"]
3181pub const OT_MESHCOP_TLV_VENDOR_NAME_TLV: otMeshcopTlvType = 33;
3182#[doc = "< meshcop Vendor Model TLV"]
3183pub const OT_MESHCOP_TLV_VENDOR_MODEL_TLV: otMeshcopTlvType = 34;
3184#[doc = "< meshcop Vendor SW Version TLV"]
3185pub const OT_MESHCOP_TLV_VENDOR_SW_VERSION_TLV: otMeshcopTlvType = 35;
3186#[doc = "< meshcop Vendor Data TLV"]
3187pub const OT_MESHCOP_TLV_VENDOR_DATA_TLV: otMeshcopTlvType = 36;
3188#[doc = "< meshcop Vendor Stack Version TLV"]
3189pub const OT_MESHCOP_TLV_VENDOR_STACK_VERSION_TLV: otMeshcopTlvType = 37;
3190#[doc = "< meshcop UDP encapsulation TLV"]
3191pub const OT_MESHCOP_TLV_UDP_ENCAPSULATION_TLV: otMeshcopTlvType = 48;
3192#[doc = "< meshcop IPv6 address TLV"]
3193pub const OT_MESHCOP_TLV_IPV6_ADDRESS_TLV: otMeshcopTlvType = 49;
3194#[doc = "< meshcop Pending Timestamp TLV"]
3195pub const OT_MESHCOP_TLV_PENDINGTIMESTAMP: otMeshcopTlvType = 51;
3196#[doc = "< meshcop Delay Timer TLV"]
3197pub const OT_MESHCOP_TLV_DELAYTIMER: otMeshcopTlvType = 52;
3198#[doc = "< meshcop Channel Mask TLV"]
3199pub const OT_MESHCOP_TLV_CHANNELMASK: otMeshcopTlvType = 53;
3200#[doc = "< meshcop Count TLV"]
3201pub const OT_MESHCOP_TLV_COUNT: otMeshcopTlvType = 54;
3202#[doc = "< meshcop Period TLV"]
3203pub const OT_MESHCOP_TLV_PERIOD: otMeshcopTlvType = 55;
3204#[doc = "< meshcop Scan Duration TLV"]
3205pub const OT_MESHCOP_TLV_SCAN_DURATION: otMeshcopTlvType = 56;
3206#[doc = "< meshcop Energy List TLV"]
3207pub const OT_MESHCOP_TLV_ENERGY_LIST: otMeshcopTlvType = 57;
3208#[doc = "< meshcop Thread Domain Name TLV"]
3209pub const OT_MESHCOP_TLV_THREAD_DOMAIN_NAME: otMeshcopTlvType = 59;
3210#[doc = "< meshcop Wake-up Channel TLV"]
3211pub const OT_MESHCOP_TLV_WAKEUP_CHANNEL: otMeshcopTlvType = 74;
3212#[doc = "< meshcop Discovery Request TLV"]
3213pub const OT_MESHCOP_TLV_DISCOVERYREQUEST: otMeshcopTlvType = 128;
3214#[doc = "< meshcop Discovery Response TLV"]
3215pub const OT_MESHCOP_TLV_DISCOVERYRESPONSE: otMeshcopTlvType = 129;
3216#[doc = "< meshcop Joiner Advertisement TLV"]
3217pub const OT_MESHCOP_TLV_JOINERADVERTISEMENT: otMeshcopTlvType = 241;
3218#[doc = " Represents meshcop TLV types."]
3219pub type otMeshcopTlvType = ::std::os::raw::c_uint;
3220#[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."]
3221pub type otDatasetMgmtSetCallback = ::std::option::Option<
3222 unsafe extern "C" fn(aResult: otError, aContext: *mut ::std::os::raw::c_void),
3223>;
3224extern "C" {
3225 #[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."]
3226 pub fn otDatasetIsCommissioned(aInstance: *mut otInstance) -> bool;
3227}
3228extern "C" {
3229 #[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."]
3230 pub fn otDatasetGetActive(
3231 aInstance: *mut otInstance,
3232 aDataset: *mut otOperationalDataset,
3233 ) -> otError;
3234}
3235extern "C" {
3236 #[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."]
3237 pub fn otDatasetGetActiveTlvs(
3238 aInstance: *mut otInstance,
3239 aDataset: *mut otOperationalDatasetTlvs,
3240 ) -> otError;
3241}
3242extern "C" {
3243 #[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 This function consistently returns `OT_ERROR_NONE` and can effectively be treated as having a `void` return type.\n Previously, other errors (e.g., `OT_ERROR_NOT_IMPLEMENTED`) were allowed for legacy reasons. However, as\n non-volatile storage is now mandatory for Thread operation, any failure to save the dataset will trigger an\n assertion. The `otError` return type is retained for backward compatibility.\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."]
3244 pub fn otDatasetSetActive(
3245 aInstance: *mut otInstance,
3246 aDataset: *const otOperationalDataset,
3247 ) -> otError;
3248}
3249extern "C" {
3250 #[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_INVALID_ARGS The @p aDataset is invalid. It is too long or contains incorrect TLV formatting."]
3251 pub fn otDatasetSetActiveTlvs(
3252 aInstance: *mut otInstance,
3253 aDataset: *const otOperationalDatasetTlvs,
3254 ) -> otError;
3255}
3256extern "C" {
3257 #[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."]
3258 pub fn otDatasetGetPending(
3259 aInstance: *mut otInstance,
3260 aDataset: *mut otOperationalDataset,
3261 ) -> otError;
3262}
3263extern "C" {
3264 #[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."]
3265 pub fn otDatasetGetPendingTlvs(
3266 aInstance: *mut otInstance,
3267 aDataset: *mut otOperationalDatasetTlvs,
3268 ) -> otError;
3269}
3270extern "C" {
3271 #[doc = " Sets the Pending Operational Dataset.\n\n This function consistently returns `OT_ERROR_NONE` and can effectively be treated as having a `void` return type.\n Previously, other errors (e.g., `OT_ERROR_NOT_IMPLEMENTED`) were allowed for legacy reasons. However, as\n non-volatile storage is now mandatory for Thread operation, any failure to save the dataset will trigger an\n assertion. The `otError` return type is retained for backward compatibility.\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."]
3272 pub fn otDatasetSetPending(
3273 aInstance: *mut otInstance,
3274 aDataset: *const otOperationalDataset,
3275 ) -> otError;
3276}
3277extern "C" {
3278 #[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_INVALID_ARGS The @p aDataset is invalid. It is too long or contains incorrect TLV formatting."]
3279 pub fn otDatasetSetPendingTlvs(
3280 aInstance: *mut otInstance,
3281 aDataset: *const otOperationalDatasetTlvs,
3282 ) -> otError;
3283}
3284extern "C" {
3285 #[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."]
3286 pub fn otDatasetSendMgmtActiveGet(
3287 aInstance: *mut otInstance,
3288 aDatasetComponents: *const otOperationalDatasetComponents,
3289 aTlvTypes: *const u8,
3290 aLength: u8,
3291 aAddress: *const otIp6Address,
3292 ) -> otError;
3293}
3294extern "C" {
3295 #[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."]
3296 pub fn otDatasetSendMgmtActiveSet(
3297 aInstance: *mut otInstance,
3298 aDataset: *const otOperationalDataset,
3299 aTlvs: *const u8,
3300 aLength: u8,
3301 aCallback: otDatasetMgmtSetCallback,
3302 aContext: *mut ::std::os::raw::c_void,
3303 ) -> otError;
3304}
3305extern "C" {
3306 #[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."]
3307 pub fn otDatasetSendMgmtPendingGet(
3308 aInstance: *mut otInstance,
3309 aDatasetComponents: *const otOperationalDatasetComponents,
3310 aTlvTypes: *const u8,
3311 aLength: u8,
3312 aAddress: *const otIp6Address,
3313 ) -> otError;
3314}
3315extern "C" {
3316 #[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."]
3317 pub fn otDatasetSendMgmtPendingSet(
3318 aInstance: *mut otInstance,
3319 aDataset: *const otOperationalDataset,
3320 aTlvs: *const u8,
3321 aLength: u8,
3322 aCallback: otDatasetMgmtSetCallback,
3323 aContext: *mut ::std::os::raw::c_void,
3324 ) -> otError;
3325}
3326extern "C" {
3327 #[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."]
3328 pub fn otDatasetGeneratePskc(
3329 aPassPhrase: *const ::std::os::raw::c_char,
3330 aNetworkName: *const otNetworkName,
3331 aExtPanId: *const otExtendedPanId,
3332 aPskc: *mut otPskc,
3333 ) -> otError;
3334}
3335extern "C" {
3336 #[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)."]
3337 pub fn otNetworkNameFromString(
3338 aNetworkName: *mut otNetworkName,
3339 aNameString: *const ::std::os::raw::c_char,
3340 ) -> otError;
3341}
3342extern "C" {
3343 #[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's length is longer than `OT_OPERATIONAL_DATASET_MAX_LENGTH`."]
3344 pub fn otDatasetParseTlvs(
3345 aDatasetTlvs: *const otOperationalDatasetTlvs,
3346 aDataset: *mut otOperationalDataset,
3347 ) -> otError;
3348}
3349extern "C" {
3350 #[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."]
3351 pub fn otDatasetConvertToTlvs(
3352 aDataset: *const otOperationalDataset,
3353 aDatasetTlvs: *mut otOperationalDatasetTlvs,
3354 );
3355}
3356extern "C" {
3357 #[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."]
3358 pub fn otDatasetUpdateTlvs(
3359 aDataset: *const otOperationalDataset,
3360 aDatasetTlvs: *mut otOperationalDatasetTlvs,
3361 ) -> otError;
3362}
3363pub const OT_JOINER_STATE_IDLE: otJoinerState = 0;
3364pub const OT_JOINER_STATE_DISCOVER: otJoinerState = 1;
3365pub const OT_JOINER_STATE_CONNECT: otJoinerState = 2;
3366pub const OT_JOINER_STATE_CONNECTED: otJoinerState = 3;
3367pub const OT_JOINER_STATE_ENTRUST: otJoinerState = 4;
3368pub const OT_JOINER_STATE_JOINED: otJoinerState = 5;
3369#[doc = " Defines the Joiner State."]
3370pub type otJoinerState = ::std::os::raw::c_uint;
3371#[doc = " Represents a Joiner Discerner."]
3372#[repr(C)]
3373#[derive(Debug, Default, Copy, Clone)]
3374pub struct otJoinerDiscerner {
3375 #[doc = "< Discerner value (the lowest `mLength` bits specify the discerner)."]
3376 pub mValue: u64,
3377 #[doc = "< Length (number of bits) - must be non-zero and at most `OT_JOINER_MAX_DISCERNER_LENGTH`."]
3378 pub mLength: u8,
3379}
3380#[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."]
3381pub type otJoinerCallback = ::std::option::Option<
3382 unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
3383>;
3384extern "C" {
3385 #[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."]
3386 pub fn otJoinerStart(
3387 aInstance: *mut otInstance,
3388 aPskd: *const ::std::os::raw::c_char,
3389 aProvisioningUrl: *const ::std::os::raw::c_char,
3390 aVendorName: *const ::std::os::raw::c_char,
3391 aVendorModel: *const ::std::os::raw::c_char,
3392 aVendorSwVersion: *const ::std::os::raw::c_char,
3393 aVendorData: *const ::std::os::raw::c_char,
3394 aCallback: otJoinerCallback,
3395 aContext: *mut ::std::os::raw::c_void,
3396 ) -> otError;
3397}
3398extern "C" {
3399 #[doc = " Disables the Thread Joiner role.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
3400 pub fn otJoinerStop(aInstance: *mut otInstance);
3401}
3402extern "C" {
3403 #[doc = " Gets the Joiner State.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The joiner state."]
3404 pub fn otJoinerGetState(aInstance: *mut otInstance) -> otJoinerState;
3405}
3406extern "C" {
3407 #[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."]
3408 pub fn otJoinerGetId(aInstance: *mut otInstance) -> *const otExtAddress;
3409}
3410extern "C" {
3411 #[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."]
3412 pub fn otJoinerSetDiscerner(
3413 aInstance: *mut otInstance,
3414 aDiscerner: *mut otJoinerDiscerner,
3415 ) -> otError;
3416}
3417extern "C" {
3418 #[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."]
3419 pub fn otJoinerGetDiscerner(aInstance: *mut otInstance) -> *const otJoinerDiscerner;
3420}
3421extern "C" {
3422 #[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."]
3423 pub fn otJoinerStateToString(aState: otJoinerState) -> *const ::std::os::raw::c_char;
3424}
3425#[doc = "< Commissioner role is disabled."]
3426pub const OT_COMMISSIONER_STATE_DISABLED: otCommissionerState = 0;
3427#[doc = "< Currently petitioning to become a Commissioner."]
3428pub const OT_COMMISSIONER_STATE_PETITION: otCommissionerState = 1;
3429#[doc = "< Commissioner role is active."]
3430pub const OT_COMMISSIONER_STATE_ACTIVE: otCommissionerState = 2;
3431#[doc = " Defines the Commissioner State."]
3432pub type otCommissionerState = ::std::os::raw::c_uint;
3433pub const OT_COMMISSIONER_JOINER_START: otCommissionerJoinerEvent = 0;
3434pub const OT_COMMISSIONER_JOINER_CONNECTED: otCommissionerJoinerEvent = 1;
3435pub const OT_COMMISSIONER_JOINER_FINALIZE: otCommissionerJoinerEvent = 2;
3436pub const OT_COMMISSIONER_JOINER_END: otCommissionerJoinerEvent = 3;
3437pub const OT_COMMISSIONER_JOINER_REMOVED: otCommissionerJoinerEvent = 4;
3438#[doc = " Defines a Joiner Event on the Commissioner."]
3439pub type otCommissionerJoinerEvent = ::std::os::raw::c_uint;
3440#[doc = " Represents the steering data."]
3441#[repr(C)]
3442#[derive(Debug, Default, Copy, Clone)]
3443pub struct otSteeringData {
3444 #[doc = "< Length of steering data (bytes)"]
3445 pub mLength: u8,
3446 #[doc = "< Byte values"]
3447 pub m8: [u8; 16usize],
3448}
3449#[doc = " Represents a Commissioning Dataset."]
3450#[repr(C)]
3451#[derive(Debug, Default, Copy, Clone)]
3452pub struct otCommissioningDataset {
3453 #[doc = "< Border Router RLOC16"]
3454 pub mLocator: u16,
3455 #[doc = "< Commissioner Session Id"]
3456 pub mSessionId: u16,
3457 #[doc = "< Steering Data"]
3458 pub mSteeringData: otSteeringData,
3459 #[doc = "< Joiner UDP Port"]
3460 pub mJoinerUdpPort: u16,
3461 pub _bitfield_align_1: [u8; 0],
3462 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3463 pub __bindgen_padding_0: u8,
3464}
3465impl otCommissioningDataset {
3466 #[inline]
3467 pub fn mIsLocatorSet(&self) -> bool {
3468 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
3469 }
3470 #[inline]
3471 pub fn set_mIsLocatorSet(&mut self, val: bool) {
3472 unsafe {
3473 let val: u8 = ::std::mem::transmute(val);
3474 self._bitfield_1.set(0usize, 1u8, val as u64)
3475 }
3476 }
3477 #[inline]
3478 pub fn mIsSessionIdSet(&self) -> bool {
3479 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
3480 }
3481 #[inline]
3482 pub fn set_mIsSessionIdSet(&mut self, val: bool) {
3483 unsafe {
3484 let val: u8 = ::std::mem::transmute(val);
3485 self._bitfield_1.set(1usize, 1u8, val as u64)
3486 }
3487 }
3488 #[inline]
3489 pub fn mIsSteeringDataSet(&self) -> bool {
3490 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
3491 }
3492 #[inline]
3493 pub fn set_mIsSteeringDataSet(&mut self, val: bool) {
3494 unsafe {
3495 let val: u8 = ::std::mem::transmute(val);
3496 self._bitfield_1.set(2usize, 1u8, val as u64)
3497 }
3498 }
3499 #[inline]
3500 pub fn mIsJoinerUdpPortSet(&self) -> bool {
3501 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
3502 }
3503 #[inline]
3504 pub fn set_mIsJoinerUdpPortSet(&mut self, val: bool) {
3505 unsafe {
3506 let val: u8 = ::std::mem::transmute(val);
3507 self._bitfield_1.set(3usize, 1u8, val as u64)
3508 }
3509 }
3510 #[inline]
3511 pub fn mHasExtraTlv(&self) -> bool {
3512 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3513 }
3514 #[inline]
3515 pub fn set_mHasExtraTlv(&mut self, val: bool) {
3516 unsafe {
3517 let val: u8 = ::std::mem::transmute(val);
3518 self._bitfield_1.set(4usize, 1u8, val as u64)
3519 }
3520 }
3521 #[inline]
3522 pub fn new_bitfield_1(
3523 mIsLocatorSet: bool,
3524 mIsSessionIdSet: bool,
3525 mIsSteeringDataSet: bool,
3526 mIsJoinerUdpPortSet: bool,
3527 mHasExtraTlv: bool,
3528 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3529 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3530 __bindgen_bitfield_unit.set(0usize, 1u8, {
3531 let mIsLocatorSet: u8 = unsafe { ::std::mem::transmute(mIsLocatorSet) };
3532 mIsLocatorSet as u64
3533 });
3534 __bindgen_bitfield_unit.set(1usize, 1u8, {
3535 let mIsSessionIdSet: u8 = unsafe { ::std::mem::transmute(mIsSessionIdSet) };
3536 mIsSessionIdSet as u64
3537 });
3538 __bindgen_bitfield_unit.set(2usize, 1u8, {
3539 let mIsSteeringDataSet: u8 = unsafe { ::std::mem::transmute(mIsSteeringDataSet) };
3540 mIsSteeringDataSet as u64
3541 });
3542 __bindgen_bitfield_unit.set(3usize, 1u8, {
3543 let mIsJoinerUdpPortSet: u8 = unsafe { ::std::mem::transmute(mIsJoinerUdpPortSet) };
3544 mIsJoinerUdpPortSet as u64
3545 });
3546 __bindgen_bitfield_unit.set(4usize, 1u8, {
3547 let mHasExtraTlv: u8 = unsafe { ::std::mem::transmute(mHasExtraTlv) };
3548 mHasExtraTlv as u64
3549 });
3550 __bindgen_bitfield_unit
3551 }
3552}
3553#[doc = " Represents a Joiner PSKd."]
3554#[repr(C)]
3555#[derive(Debug, Copy, Clone)]
3556pub struct otJoinerPskd {
3557 #[doc = "< Char string array (must be null terminated - +1 is for null char)."]
3558 pub m8: [::std::os::raw::c_char; 33usize],
3559}
3560impl Default for otJoinerPskd {
3561 fn default() -> Self {
3562 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3563 unsafe {
3564 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3565 s.assume_init()
3566 }
3567 }
3568}
3569#[doc = "< Accept any Joiner (no EUI64 or Discerner is specified)."]
3570pub const OT_JOINER_INFO_TYPE_ANY: otJoinerInfoType = 0;
3571#[doc = "< Joiner EUI-64 is specified (`mSharedId.mEui64` in `otJoinerInfo`)."]
3572pub const OT_JOINER_INFO_TYPE_EUI64: otJoinerInfoType = 1;
3573#[doc = "< Joiner Discerner is specified (`mSharedId.mDiscerner` in `otJoinerInfo`)."]
3574pub const OT_JOINER_INFO_TYPE_DISCERNER: otJoinerInfoType = 2;
3575#[doc = " Defines a Joiner Info Type."]
3576pub type otJoinerInfoType = ::std::os::raw::c_uint;
3577#[doc = " Represents a Joiner Info."]
3578#[repr(C)]
3579#[derive(Copy, Clone)]
3580pub struct otJoinerInfo {
3581 #[doc = "< Joiner type."]
3582 pub mType: otJoinerInfoType,
3583 #[doc = "< Shared fields"]
3584 pub mSharedId: otJoinerInfo__bindgen_ty_1,
3585 #[doc = "< Joiner PSKd"]
3586 pub mPskd: otJoinerPskd,
3587 #[doc = "< Joiner expiration time in msec"]
3588 pub mExpirationTime: u32,
3589}
3590#[repr(C)]
3591#[derive(Copy, Clone)]
3592pub union otJoinerInfo__bindgen_ty_1 {
3593 #[doc = "< Joiner EUI64 (when `mType` is `OT_JOINER_INFO_TYPE_EUI64`)"]
3594 pub mEui64: otExtAddress,
3595 #[doc = "< Joiner Discerner (when `mType` is `OT_JOINER_INFO_TYPE_DISCERNER`)"]
3596 pub mDiscerner: otJoinerDiscerner,
3597}
3598impl Default for otJoinerInfo__bindgen_ty_1 {
3599 fn default() -> Self {
3600 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3601 unsafe {
3602 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3603 s.assume_init()
3604 }
3605 }
3606}
3607impl Default for otJoinerInfo {
3608 fn default() -> Self {
3609 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3610 unsafe {
3611 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3612 s.assume_init()
3613 }
3614 }
3615}
3616#[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."]
3617pub type otCommissionerStateCallback = ::std::option::Option<
3618 unsafe extern "C" fn(aState: otCommissionerState, aContext: *mut ::std::os::raw::c_void),
3619>;
3620#[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."]
3621pub type otCommissionerJoinerCallback = ::std::option::Option<
3622 unsafe extern "C" fn(
3623 aEvent: otCommissionerJoinerEvent,
3624 aJoinerInfo: *const otJoinerInfo,
3625 aJoinerId: *const otExtAddress,
3626 aContext: *mut ::std::os::raw::c_void,
3627 ),
3628>;
3629extern "C" {
3630 #[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."]
3631 pub fn otCommissionerStart(
3632 aInstance: *mut otInstance,
3633 aStateCallback: otCommissionerStateCallback,
3634 aJoinerCallback: otCommissionerJoinerCallback,
3635 aCallbackContext: *mut ::std::os::raw::c_void,
3636 ) -> otError;
3637}
3638extern "C" {
3639 #[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."]
3640 pub fn otCommissionerStop(aInstance: *mut otInstance) -> otError;
3641}
3642extern "C" {
3643 #[doc = " Returns the Commissioner Id.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Commissioner Id."]
3644 pub fn otCommissionerGetId(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
3645}
3646extern "C" {
3647 #[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."]
3648 pub fn otCommissionerSetId(
3649 aInstance: *mut otInstance,
3650 aId: *const ::std::os::raw::c_char,
3651 ) -> otError;
3652}
3653extern "C" {
3654 #[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()."]
3655 pub fn otCommissionerAddJoiner(
3656 aInstance: *mut otInstance,
3657 aEui64: *const otExtAddress,
3658 aPskd: *const ::std::os::raw::c_char,
3659 aTimeout: u32,
3660 ) -> otError;
3661}
3662extern "C" {
3663 #[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()."]
3664 pub fn otCommissionerAddJoinerWithDiscerner(
3665 aInstance: *mut otInstance,
3666 aDiscerner: *const otJoinerDiscerner,
3667 aPskd: *const ::std::os::raw::c_char,
3668 aTimeout: u32,
3669 ) -> otError;
3670}
3671extern "C" {
3672 #[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."]
3673 pub fn otCommissionerGetNextJoinerInfo(
3674 aInstance: *mut otInstance,
3675 aIterator: *mut u16,
3676 aJoiner: *mut otJoinerInfo,
3677 ) -> otError;
3678}
3679extern "C" {
3680 #[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()."]
3681 pub fn otCommissionerRemoveJoiner(
3682 aInstance: *mut otInstance,
3683 aEui64: *const otExtAddress,
3684 ) -> otError;
3685}
3686extern "C" {
3687 #[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()."]
3688 pub fn otCommissionerRemoveJoinerWithDiscerner(
3689 aInstance: *mut otInstance,
3690 aDiscerner: *const otJoinerDiscerner,
3691 ) -> otError;
3692}
3693extern "C" {
3694 #[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."]
3695 pub fn otCommissionerGetProvisioningUrl(
3696 aInstance: *mut otInstance,
3697 ) -> *const ::std::os::raw::c_char;
3698}
3699extern "C" {
3700 #[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)."]
3701 pub fn otCommissionerSetProvisioningUrl(
3702 aInstance: *mut otInstance,
3703 aProvisioningUrl: *const ::std::os::raw::c_char,
3704 ) -> otError;
3705}
3706extern "C" {
3707 #[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()."]
3708 pub fn otCommissionerAnnounceBegin(
3709 aInstance: *mut otInstance,
3710 aChannelMask: u32,
3711 aCount: u8,
3712 aPeriod: u16,
3713 aAddress: *const otIp6Address,
3714 ) -> otError;
3715}
3716#[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."]
3717pub type otCommissionerEnergyReportCallback = ::std::option::Option<
3718 unsafe extern "C" fn(
3719 aChannelMask: u32,
3720 aEnergyList: *const u8,
3721 aEnergyListLength: u8,
3722 aContext: *mut ::std::os::raw::c_void,
3723 ),
3724>;
3725extern "C" {
3726 #[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()."]
3727 pub fn otCommissionerEnergyScan(
3728 aInstance: *mut otInstance,
3729 aChannelMask: u32,
3730 aCount: u8,
3731 aPeriod: u16,
3732 aScanDuration: u16,
3733 aAddress: *const otIp6Address,
3734 aCallback: otCommissionerEnergyReportCallback,
3735 aContext: *mut ::std::os::raw::c_void,
3736 ) -> otError;
3737}
3738#[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."]
3739pub type otCommissionerPanIdConflictCallback = ::std::option::Option<
3740 unsafe extern "C" fn(aPanId: u16, aChannelMask: u32, aContext: *mut ::std::os::raw::c_void),
3741>;
3742extern "C" {
3743 #[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()."]
3744 pub fn otCommissionerPanIdQuery(
3745 aInstance: *mut otInstance,
3746 aPanId: u16,
3747 aChannelMask: u32,
3748 aAddress: *const otIp6Address,
3749 aCallback: otCommissionerPanIdConflictCallback,
3750 aContext: *mut ::std::os::raw::c_void,
3751 ) -> otError;
3752}
3753extern "C" {
3754 #[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."]
3755 pub fn otCommissionerSendMgmtGet(
3756 aInstance: *mut otInstance,
3757 aTlvs: *const u8,
3758 aLength: u8,
3759 ) -> otError;
3760}
3761extern "C" {
3762 #[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."]
3763 pub fn otCommissionerSendMgmtSet(
3764 aInstance: *mut otInstance,
3765 aDataset: *const otCommissioningDataset,
3766 aTlvs: *const u8,
3767 aLength: u8,
3768 ) -> otError;
3769}
3770extern "C" {
3771 #[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."]
3772 pub fn otCommissionerGetSessionId(aInstance: *mut otInstance) -> u16;
3773}
3774extern "C" {
3775 #[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."]
3776 pub fn otCommissionerGetState(aInstance: *mut otInstance) -> otCommissionerState;
3777}
3778pub type otNetworkDataIterator = u32;
3779#[doc = " Represents a Border Router configuration."]
3780#[repr(C)]
3781#[repr(align(4))]
3782#[derive(Copy, Clone)]
3783pub struct otBorderRouterConfig {
3784 #[doc = "< The IPv6 prefix."]
3785 pub mPrefix: otIp6Prefix,
3786 pub _bitfield_align_1: [u8; 0],
3787 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3788 #[doc = "< The border router's RLOC16 (value ignored on config add)."]
3789 pub mRloc16: u16,
3790}
3791impl Default for otBorderRouterConfig {
3792 fn default() -> Self {
3793 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3794 unsafe {
3795 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3796 s.assume_init()
3797 }
3798 }
3799}
3800impl otBorderRouterConfig {
3801 #[inline]
3802 pub fn mPreference(&self) -> ::std::os::raw::c_int {
3803 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
3804 }
3805 #[inline]
3806 pub fn set_mPreference(&mut self, val: ::std::os::raw::c_int) {
3807 unsafe {
3808 let val: u32 = ::std::mem::transmute(val);
3809 self._bitfield_1.set(0usize, 2u8, val as u64)
3810 }
3811 }
3812 #[inline]
3813 pub fn mPreferred(&self) -> bool {
3814 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
3815 }
3816 #[inline]
3817 pub fn set_mPreferred(&mut self, val: bool) {
3818 unsafe {
3819 let val: u8 = ::std::mem::transmute(val);
3820 self._bitfield_1.set(2usize, 1u8, val as u64)
3821 }
3822 }
3823 #[inline]
3824 pub fn mSlaac(&self) -> bool {
3825 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
3826 }
3827 #[inline]
3828 pub fn set_mSlaac(&mut self, val: bool) {
3829 unsafe {
3830 let val: u8 = ::std::mem::transmute(val);
3831 self._bitfield_1.set(3usize, 1u8, val as u64)
3832 }
3833 }
3834 #[inline]
3835 pub fn mDhcp(&self) -> bool {
3836 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3837 }
3838 #[inline]
3839 pub fn set_mDhcp(&mut self, val: bool) {
3840 unsafe {
3841 let val: u8 = ::std::mem::transmute(val);
3842 self._bitfield_1.set(4usize, 1u8, val as u64)
3843 }
3844 }
3845 #[inline]
3846 pub fn mConfigure(&self) -> bool {
3847 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
3848 }
3849 #[inline]
3850 pub fn set_mConfigure(&mut self, val: bool) {
3851 unsafe {
3852 let val: u8 = ::std::mem::transmute(val);
3853 self._bitfield_1.set(5usize, 1u8, val as u64)
3854 }
3855 }
3856 #[inline]
3857 pub fn mDefaultRoute(&self) -> bool {
3858 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
3859 }
3860 #[inline]
3861 pub fn set_mDefaultRoute(&mut self, val: bool) {
3862 unsafe {
3863 let val: u8 = ::std::mem::transmute(val);
3864 self._bitfield_1.set(6usize, 1u8, val as u64)
3865 }
3866 }
3867 #[inline]
3868 pub fn mOnMesh(&self) -> bool {
3869 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
3870 }
3871 #[inline]
3872 pub fn set_mOnMesh(&mut self, val: bool) {
3873 unsafe {
3874 let val: u8 = ::std::mem::transmute(val);
3875 self._bitfield_1.set(7usize, 1u8, val as u64)
3876 }
3877 }
3878 #[inline]
3879 pub fn mStable(&self) -> bool {
3880 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
3881 }
3882 #[inline]
3883 pub fn set_mStable(&mut self, val: bool) {
3884 unsafe {
3885 let val: u8 = ::std::mem::transmute(val);
3886 self._bitfield_1.set(8usize, 1u8, val as u64)
3887 }
3888 }
3889 #[inline]
3890 pub fn mNdDns(&self) -> bool {
3891 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
3892 }
3893 #[inline]
3894 pub fn set_mNdDns(&mut self, val: bool) {
3895 unsafe {
3896 let val: u8 = ::std::mem::transmute(val);
3897 self._bitfield_1.set(9usize, 1u8, val as u64)
3898 }
3899 }
3900 #[inline]
3901 pub fn mDp(&self) -> bool {
3902 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8) }
3903 }
3904 #[inline]
3905 pub fn set_mDp(&mut self, val: bool) {
3906 unsafe {
3907 let val: u8 = ::std::mem::transmute(val);
3908 self._bitfield_1.set(10usize, 1u8, val as u64)
3909 }
3910 }
3911 #[inline]
3912 pub fn new_bitfield_1(
3913 mPreference: ::std::os::raw::c_int,
3914 mPreferred: bool,
3915 mSlaac: bool,
3916 mDhcp: bool,
3917 mConfigure: bool,
3918 mDefaultRoute: bool,
3919 mOnMesh: bool,
3920 mStable: bool,
3921 mNdDns: bool,
3922 mDp: bool,
3923 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3924 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3925 __bindgen_bitfield_unit.set(0usize, 2u8, {
3926 let mPreference: u32 = unsafe { ::std::mem::transmute(mPreference) };
3927 mPreference as u64
3928 });
3929 __bindgen_bitfield_unit.set(2usize, 1u8, {
3930 let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
3931 mPreferred as u64
3932 });
3933 __bindgen_bitfield_unit.set(3usize, 1u8, {
3934 let mSlaac: u8 = unsafe { ::std::mem::transmute(mSlaac) };
3935 mSlaac as u64
3936 });
3937 __bindgen_bitfield_unit.set(4usize, 1u8, {
3938 let mDhcp: u8 = unsafe { ::std::mem::transmute(mDhcp) };
3939 mDhcp as u64
3940 });
3941 __bindgen_bitfield_unit.set(5usize, 1u8, {
3942 let mConfigure: u8 = unsafe { ::std::mem::transmute(mConfigure) };
3943 mConfigure as u64
3944 });
3945 __bindgen_bitfield_unit.set(6usize, 1u8, {
3946 let mDefaultRoute: u8 = unsafe { ::std::mem::transmute(mDefaultRoute) };
3947 mDefaultRoute as u64
3948 });
3949 __bindgen_bitfield_unit.set(7usize, 1u8, {
3950 let mOnMesh: u8 = unsafe { ::std::mem::transmute(mOnMesh) };
3951 mOnMesh as u64
3952 });
3953 __bindgen_bitfield_unit.set(8usize, 1u8, {
3954 let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
3955 mStable as u64
3956 });
3957 __bindgen_bitfield_unit.set(9usize, 1u8, {
3958 let mNdDns: u8 = unsafe { ::std::mem::transmute(mNdDns) };
3959 mNdDns as u64
3960 });
3961 __bindgen_bitfield_unit.set(10usize, 1u8, {
3962 let mDp: u8 = unsafe { ::std::mem::transmute(mDp) };
3963 mDp as u64
3964 });
3965 __bindgen_bitfield_unit
3966 }
3967}
3968#[doc = " Represents 6LoWPAN Context ID information associated with a prefix in Network Data."]
3969#[repr(C)]
3970#[derive(Copy, Clone)]
3971pub struct otLowpanContextInfo {
3972 #[doc = "< The 6LoWPAN Context ID."]
3973 pub mContextId: u8,
3974 #[doc = "< The compress flag."]
3975 pub mCompressFlag: bool,
3976 #[doc = "< The associated IPv6 prefix."]
3977 pub mPrefix: otIp6Prefix,
3978}
3979impl Default for otLowpanContextInfo {
3980 fn default() -> Self {
3981 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3982 unsafe {
3983 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3984 s.assume_init()
3985 }
3986 }
3987}
3988#[doc = " Represents an External Route configuration."]
3989#[repr(C)]
3990#[repr(align(4))]
3991#[derive(Copy, Clone)]
3992pub struct otExternalRouteConfig {
3993 #[doc = "< The IPv6 prefix."]
3994 pub mPrefix: otIp6Prefix,
3995 #[doc = "< The border router's RLOC16 (value ignored on config add)."]
3996 pub mRloc16: u16,
3997 pub _bitfield_align_1: [u8; 0],
3998 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3999 pub __bindgen_padding_0: [u8; 3usize],
4000}
4001impl Default for otExternalRouteConfig {
4002 fn default() -> Self {
4003 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4004 unsafe {
4005 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4006 s.assume_init()
4007 }
4008 }
4009}
4010impl otExternalRouteConfig {
4011 #[inline]
4012 pub fn mPreference(&self) -> ::std::os::raw::c_int {
4013 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
4014 }
4015 #[inline]
4016 pub fn set_mPreference(&mut self, val: ::std::os::raw::c_int) {
4017 unsafe {
4018 let val: u32 = ::std::mem::transmute(val);
4019 self._bitfield_1.set(0usize, 2u8, val as u64)
4020 }
4021 }
4022 #[inline]
4023 pub fn mNat64(&self) -> bool {
4024 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
4025 }
4026 #[inline]
4027 pub fn set_mNat64(&mut self, val: bool) {
4028 unsafe {
4029 let val: u8 = ::std::mem::transmute(val);
4030 self._bitfield_1.set(2usize, 1u8, val as u64)
4031 }
4032 }
4033 #[inline]
4034 pub fn mStable(&self) -> bool {
4035 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
4036 }
4037 #[inline]
4038 pub fn set_mStable(&mut self, val: bool) {
4039 unsafe {
4040 let val: u8 = ::std::mem::transmute(val);
4041 self._bitfield_1.set(3usize, 1u8, val as u64)
4042 }
4043 }
4044 #[inline]
4045 pub fn mNextHopIsThisDevice(&self) -> bool {
4046 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
4047 }
4048 #[inline]
4049 pub fn set_mNextHopIsThisDevice(&mut self, val: bool) {
4050 unsafe {
4051 let val: u8 = ::std::mem::transmute(val);
4052 self._bitfield_1.set(4usize, 1u8, val as u64)
4053 }
4054 }
4055 #[inline]
4056 pub fn mAdvPio(&self) -> bool {
4057 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
4058 }
4059 #[inline]
4060 pub fn set_mAdvPio(&mut self, val: bool) {
4061 unsafe {
4062 let val: u8 = ::std::mem::transmute(val);
4063 self._bitfield_1.set(5usize, 1u8, val as u64)
4064 }
4065 }
4066 #[inline]
4067 pub fn new_bitfield_1(
4068 mPreference: ::std::os::raw::c_int,
4069 mNat64: bool,
4070 mStable: bool,
4071 mNextHopIsThisDevice: bool,
4072 mAdvPio: bool,
4073 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4074 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4075 __bindgen_bitfield_unit.set(0usize, 2u8, {
4076 let mPreference: u32 = unsafe { ::std::mem::transmute(mPreference) };
4077 mPreference as u64
4078 });
4079 __bindgen_bitfield_unit.set(2usize, 1u8, {
4080 let mNat64: u8 = unsafe { ::std::mem::transmute(mNat64) };
4081 mNat64 as u64
4082 });
4083 __bindgen_bitfield_unit.set(3usize, 1u8, {
4084 let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
4085 mStable as u64
4086 });
4087 __bindgen_bitfield_unit.set(4usize, 1u8, {
4088 let mNextHopIsThisDevice: u8 = unsafe { ::std::mem::transmute(mNextHopIsThisDevice) };
4089 mNextHopIsThisDevice as u64
4090 });
4091 __bindgen_bitfield_unit.set(5usize, 1u8, {
4092 let mAdvPio: u8 = unsafe { ::std::mem::transmute(mAdvPio) };
4093 mAdvPio as u64
4094 });
4095 __bindgen_bitfield_unit
4096 }
4097}
4098#[doc = "< Low route preference."]
4099pub const OT_ROUTE_PREFERENCE_LOW: otRoutePreference = -1;
4100#[doc = "< Medium route preference."]
4101pub const OT_ROUTE_PREFERENCE_MED: otRoutePreference = 0;
4102#[doc = "< High route preference."]
4103pub const OT_ROUTE_PREFERENCE_HIGH: otRoutePreference = 1;
4104#[doc = " Defines valid values for `mPreference` in `otExternalRouteConfig` and `otBorderRouterConfig`."]
4105pub type otRoutePreference = ::std::os::raw::c_int;
4106#[doc = " Represents a Server configuration."]
4107#[repr(C)]
4108#[derive(Debug, Copy, Clone)]
4109pub struct otServerConfig {
4110 pub _bitfield_align_1: [u8; 0],
4111 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4112 #[doc = "< Length of server data."]
4113 pub mServerDataLength: u8,
4114 #[doc = "< Server data bytes."]
4115 pub mServerData: [u8; 248usize],
4116 #[doc = "< The Server RLOC16."]
4117 pub mRloc16: u16,
4118}
4119impl Default for otServerConfig {
4120 fn default() -> Self {
4121 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4122 unsafe {
4123 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4124 s.assume_init()
4125 }
4126 }
4127}
4128impl otServerConfig {
4129 #[inline]
4130 pub fn mStable(&self) -> bool {
4131 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
4132 }
4133 #[inline]
4134 pub fn set_mStable(&mut self, val: bool) {
4135 unsafe {
4136 let val: u8 = ::std::mem::transmute(val);
4137 self._bitfield_1.set(0usize, 1u8, val as u64)
4138 }
4139 }
4140 #[inline]
4141 pub fn new_bitfield_1(mStable: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4142 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4143 __bindgen_bitfield_unit.set(0usize, 1u8, {
4144 let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
4145 mStable as u64
4146 });
4147 __bindgen_bitfield_unit
4148 }
4149}
4150#[doc = " Represents a Service configuration."]
4151#[repr(C)]
4152#[derive(Debug, Copy, Clone)]
4153pub struct otServiceConfig {
4154 #[doc = "< Service ID (when iterating over the Network Data)."]
4155 pub mServiceId: u8,
4156 #[doc = "< IANA Enterprise Number."]
4157 pub mEnterpriseNumber: u32,
4158 #[doc = "< Length of service data."]
4159 pub mServiceDataLength: u8,
4160 #[doc = "< Service data bytes."]
4161 pub mServiceData: [u8; 252usize],
4162 #[doc = "< The Server configuration."]
4163 pub mServerConfig: otServerConfig,
4164}
4165impl Default for otServiceConfig {
4166 fn default() -> Self {
4167 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4168 unsafe {
4169 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4170 s.assume_init()
4171 }
4172 }
4173}
4174extern "C" {
4175 #[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."]
4176 pub fn otNetDataGet(
4177 aInstance: *mut otInstance,
4178 aStable: bool,
4179 aData: *mut u8,
4180 aDataLength: *mut u8,
4181 ) -> otError;
4182}
4183extern "C" {
4184 #[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."]
4185 pub fn otNetDataGetLength(aInstance: *mut otInstance) -> u8;
4186}
4187extern "C" {
4188 #[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)."]
4189 pub fn otNetDataGetMaxLength(aInstance: *mut otInstance) -> u8;
4190}
4191extern "C" {
4192 #[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"]
4193 pub fn otNetDataResetMaxLength(aInstance: *mut otInstance);
4194}
4195extern "C" {
4196 #[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."]
4197 pub fn otNetDataGetNextOnMeshPrefix(
4198 aInstance: *mut otInstance,
4199 aIterator: *mut otNetworkDataIterator,
4200 aConfig: *mut otBorderRouterConfig,
4201 ) -> otError;
4202}
4203extern "C" {
4204 #[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."]
4205 pub fn otNetDataGetNextRoute(
4206 aInstance: *mut otInstance,
4207 aIterator: *mut otNetworkDataIterator,
4208 aConfig: *mut otExternalRouteConfig,
4209 ) -> otError;
4210}
4211extern "C" {
4212 #[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."]
4213 pub fn otNetDataGetNextService(
4214 aInstance: *mut otInstance,
4215 aIterator: *mut otNetworkDataIterator,
4216 aConfig: *mut otServiceConfig,
4217 ) -> otError;
4218}
4219extern "C" {
4220 #[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."]
4221 pub fn otNetDataGetNextLowpanContextInfo(
4222 aInstance: *mut otInstance,
4223 aIterator: *mut otNetworkDataIterator,
4224 aContextInfo: *mut otLowpanContextInfo,
4225 ) -> otError;
4226}
4227extern "C" {
4228 #[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."]
4229 pub fn otNetDataGetCommissioningDataset(
4230 aInstance: *mut otInstance,
4231 aDataset: *mut otCommissioningDataset,
4232 );
4233}
4234extern "C" {
4235 #[doc = " Get the Network Data Version.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Network Data Version."]
4236 pub fn otNetDataGetVersion(aInstance: *mut otInstance) -> u8;
4237}
4238extern "C" {
4239 #[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."]
4240 pub fn otNetDataGetStableVersion(aInstance: *mut otInstance) -> u8;
4241}
4242extern "C" {
4243 #[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."]
4244 pub fn otNetDataSteeringDataCheckJoiner(
4245 aInstance: *mut otInstance,
4246 aEui64: *const otExtAddress,
4247 ) -> otError;
4248}
4249extern "C" {
4250 #[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."]
4251 pub fn otNetDataSteeringDataCheckJoinerWithDiscerner(
4252 aInstance: *mut otInstance,
4253 aDiscerner: *const otJoinerDiscerner,
4254 ) -> otError;
4255}
4256extern "C" {
4257 #[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."]
4258 pub fn otNetDataContainsOmrPrefix(
4259 aInstance: *mut otInstance,
4260 aPrefix: *const otIp6Prefix,
4261 ) -> bool;
4262}
4263#[doc = "< Backbone function is disabled."]
4264pub const OT_BACKBONE_ROUTER_STATE_DISABLED: otBackboneRouterState = 0;
4265#[doc = "< Secondary Backbone Router."]
4266pub const OT_BACKBONE_ROUTER_STATE_SECONDARY: otBackboneRouterState = 1;
4267#[doc = "< The Primary Backbone Router."]
4268pub const OT_BACKBONE_ROUTER_STATE_PRIMARY: otBackboneRouterState = 2;
4269#[doc = " Represents the Backbone Router Status."]
4270pub type otBackboneRouterState = ::std::os::raw::c_uint;
4271extern "C" {
4272 #[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"]
4273 pub fn otBackboneRouterSetEnabled(aInstance: *mut otInstance, aEnable: bool);
4274}
4275extern "C" {
4276 #[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"]
4277 pub fn otBackboneRouterGetState(aInstance: *mut otInstance) -> otBackboneRouterState;
4278}
4279extern "C" {
4280 #[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"]
4281 pub fn otBackboneRouterGetConfig(
4282 aInstance: *mut otInstance,
4283 aConfig: *mut otBackboneRouterConfig,
4284 );
4285}
4286extern "C" {
4287 #[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"]
4288 pub fn otBackboneRouterSetConfig(
4289 aInstance: *mut otInstance,
4290 aConfig: *const otBackboneRouterConfig,
4291 ) -> otError;
4292}
4293extern "C" {
4294 #[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"]
4295 pub fn otBackboneRouterRegister(aInstance: *mut otInstance) -> otError;
4296}
4297extern "C" {
4298 #[doc = " Returns the Backbone Router registration jitter value.\n\n @returns The Backbone Router registration jitter value.\n\n @sa otBackboneRouterSetRegistrationJitter"]
4299 pub fn otBackboneRouterGetRegistrationJitter(aInstance: *mut otInstance) -> u8;
4300}
4301extern "C" {
4302 #[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"]
4303 pub fn otBackboneRouterSetRegistrationJitter(aInstance: *mut otInstance, aJitter: u8);
4304}
4305extern "C" {
4306 #[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."]
4307 pub fn otBackboneRouterGetDomainPrefix(
4308 aInstance: *mut otInstance,
4309 aConfig: *mut otBorderRouterConfig,
4310 ) -> otError;
4311}
4312extern "C" {
4313 #[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."]
4314 pub fn otBackboneRouterConfigNextDuaRegistrationResponse(
4315 aInstance: *mut otInstance,
4316 aMlIid: *const otIp6InterfaceIdentifier,
4317 aStatus: u8,
4318 );
4319}
4320extern "C" {
4321 #[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."]
4322 pub fn otBackboneRouterConfigNextMulticastListenerRegistrationResponse(
4323 aInstance: *mut otInstance,
4324 aStatus: u8,
4325 );
4326}
4327#[doc = "< Multicast Listener was added."]
4328pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ADDED: otBackboneRouterMulticastListenerEvent = 0;
4329#[doc = "< Multicast Listener was removed or expired."]
4330pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_REMOVED: otBackboneRouterMulticastListenerEvent = 1;
4331#[doc = " Represents the Multicast Listener events."]
4332pub type otBackboneRouterMulticastListenerEvent = ::std::os::raw::c_uint;
4333#[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."]
4334pub type otBackboneRouterMulticastListenerCallback = ::std::option::Option<
4335 unsafe extern "C" fn(
4336 aContext: *mut ::std::os::raw::c_void,
4337 aEvent: otBackboneRouterMulticastListenerEvent,
4338 aAddress: *const otIp6Address,
4339 ),
4340>;
4341extern "C" {
4342 #[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."]
4343 pub fn otBackboneRouterSetMulticastListenerCallback(
4344 aInstance: *mut otInstance,
4345 aCallback: otBackboneRouterMulticastListenerCallback,
4346 aContext: *mut ::std::os::raw::c_void,
4347 );
4348}
4349extern "C" {
4350 #[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"]
4351 pub fn otBackboneRouterMulticastListenerClear(aInstance: *mut otInstance);
4352}
4353extern "C" {
4354 #[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"]
4355 pub fn otBackboneRouterMulticastListenerAdd(
4356 aInstance: *mut otInstance,
4357 aAddress: *const otIp6Address,
4358 aTimeout: u32,
4359 ) -> otError;
4360}
4361pub type otBackboneRouterMulticastListenerIterator = u16;
4362#[doc = " Represents a Backbone Router Multicast Listener info."]
4363#[repr(C)]
4364#[derive(Copy, Clone)]
4365pub struct otBackboneRouterMulticastListenerInfo {
4366 pub mAddress: otIp6Address,
4367 pub mTimeout: u32,
4368}
4369impl Default for otBackboneRouterMulticastListenerInfo {
4370 fn default() -> Self {
4371 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4372 unsafe {
4373 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4374 s.assume_init()
4375 }
4376 }
4377}
4378extern "C" {
4379 #[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"]
4380 pub fn otBackboneRouterMulticastListenerGetNext(
4381 aInstance: *mut otInstance,
4382 aIterator: *mut otBackboneRouterMulticastListenerIterator,
4383 aListenerInfo: *mut otBackboneRouterMulticastListenerInfo,
4384 ) -> otError;
4385}
4386#[doc = "< ND Proxy was added."]
4387pub const OT_BACKBONE_ROUTER_NDPROXY_ADDED: otBackboneRouterNdProxyEvent = 0;
4388#[doc = "< ND Proxy was removed."]
4389pub const OT_BACKBONE_ROUTER_NDPROXY_REMOVED: otBackboneRouterNdProxyEvent = 1;
4390#[doc = "< ND Proxy was renewed."]
4391pub const OT_BACKBONE_ROUTER_NDPROXY_RENEWED: otBackboneRouterNdProxyEvent = 2;
4392#[doc = "< All ND Proxies were cleared."]
4393pub const OT_BACKBONE_ROUTER_NDPROXY_CLEARED: otBackboneRouterNdProxyEvent = 3;
4394#[doc = " Represents the ND Proxy events."]
4395pub type otBackboneRouterNdProxyEvent = ::std::os::raw::c_uint;
4396#[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`."]
4397pub type otBackboneRouterNdProxyCallback = ::std::option::Option<
4398 unsafe extern "C" fn(
4399 aContext: *mut ::std::os::raw::c_void,
4400 aEvent: otBackboneRouterNdProxyEvent,
4401 aDua: *const otIp6Address,
4402 ),
4403>;
4404extern "C" {
4405 #[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."]
4406 pub fn otBackboneRouterSetNdProxyCallback(
4407 aInstance: *mut otInstance,
4408 aCallback: otBackboneRouterNdProxyCallback,
4409 aContext: *mut ::std::os::raw::c_void,
4410 );
4411}
4412#[doc = " Represents the Backbone Router ND Proxy info."]
4413#[repr(C)]
4414#[derive(Debug, Copy, Clone)]
4415pub struct otBackboneRouterNdProxyInfo {
4416 #[doc = "< Mesh-local IID"]
4417 pub mMeshLocalIid: *mut otIp6InterfaceIdentifier,
4418 #[doc = "< Time since last transaction (Seconds)"]
4419 pub mTimeSinceLastTransaction: u32,
4420 #[doc = "< RLOC16"]
4421 pub mRloc16: u16,
4422}
4423impl Default for otBackboneRouterNdProxyInfo {
4424 fn default() -> Self {
4425 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4426 unsafe {
4427 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4428 s.assume_init()
4429 }
4430 }
4431}
4432extern "C" {
4433 #[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."]
4434 pub fn otBackboneRouterGetNdProxyInfo(
4435 aInstance: *mut otInstance,
4436 aDua: *const otIp6Address,
4437 aNdProxyInfo: *mut otBackboneRouterNdProxyInfo,
4438 ) -> otError;
4439}
4440#[doc = "< Domain Prefix was added."]
4441pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_ADDED: otBackboneRouterDomainPrefixEvent = 0;
4442#[doc = "< Domain Prefix was removed."]
4443pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_REMOVED: otBackboneRouterDomainPrefixEvent = 1;
4444#[doc = "< Domain Prefix was changed."]
4445pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_CHANGED: otBackboneRouterDomainPrefixEvent = 2;
4446#[doc = " Represents the Domain Prefix events."]
4447pub type otBackboneRouterDomainPrefixEvent = ::std::os::raw::c_uint;
4448#[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."]
4449pub type otBackboneRouterDomainPrefixCallback = ::std::option::Option<
4450 unsafe extern "C" fn(
4451 aContext: *mut ::std::os::raw::c_void,
4452 aEvent: otBackboneRouterDomainPrefixEvent,
4453 aDomainPrefix: *const otIp6Prefix,
4454 ),
4455>;
4456extern "C" {
4457 #[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."]
4458 pub fn otBackboneRouterSetDomainPrefixCallback(
4459 aInstance: *mut otInstance,
4460 aCallback: otBackboneRouterDomainPrefixCallback,
4461 aContext: *mut ::std::os::raw::c_void,
4462 );
4463}
4464#[doc = " Represents a Border Agent Identifier."]
4465#[repr(C)]
4466#[derive(Debug, Default, Copy, Clone)]
4467pub struct otBorderAgentId {
4468 #[doc = "< Border Agent ID bytes."]
4469 pub mId: [u8; 16usize],
4470}
4471#[doc = " Defines Border Agent counters.\n\n The `mEpskc` related counters require `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`."]
4472#[repr(C)]
4473#[derive(Debug, Default, Copy, Clone)]
4474pub struct otBorderAgentCounters {
4475 #[doc = "< The number of ePSKc activations"]
4476 pub mEpskcActivations: u32,
4477 #[doc = "< The number of ePSKc deactivations via API"]
4478 pub mEpskcDeactivationClears: u32,
4479 #[doc = "< The number of ePSKc deactivations due to timeout"]
4480 pub mEpskcDeactivationTimeouts: u32,
4481 #[doc = "< The number of ePSKc deactivations due to reached max attempts"]
4482 pub mEpskcDeactivationMaxAttempts: u32,
4483 #[doc = "< The number of ePSKc deactivations due to commissioner disconnected"]
4484 pub mEpskcDeactivationDisconnects: u32,
4485 #[doc = "< The number of invalid border agent state errors at ePSKc activation"]
4486 pub mEpskcInvalidBaStateErrors: u32,
4487 #[doc = "< The number of invalid args errors at ePSKc activation"]
4488 pub mEpskcInvalidArgsErrors: u32,
4489 #[doc = "< The number of start secure session errors at ePSKc activation"]
4490 pub mEpskcStartSecureSessionErrors: u32,
4491 #[doc = "< The number of established secure sessions with ePSKc"]
4492 pub mEpskcSecureSessionSuccesses: u32,
4493 #[doc = "< The number of failed secure sessions with ePSKc"]
4494 pub mEpskcSecureSessionFailures: u32,
4495 #[doc = "< The number of successful commissioner petitions with ePSKc"]
4496 pub mEpskcCommissionerPetitions: u32,
4497 #[doc = "< The number of established secure sessions with PSKc"]
4498 pub mPskcSecureSessionSuccesses: u32,
4499 #[doc = "< The number of failed secure sessions with PSKc"]
4500 pub mPskcSecureSessionFailures: u32,
4501 #[doc = "< The number of successful commissioner petitions with PSKc"]
4502 pub mPskcCommissionerPetitions: u32,
4503 #[doc = "< The number of MGMT_ACTIVE_GET.req sent over secure sessions"]
4504 pub mMgmtActiveGets: u32,
4505 #[doc = "< The number of MGMT_PENDING_GET.req sent over secure sessions"]
4506 pub mMgmtPendingGets: u32,
4507}
4508#[doc = " Represents information about a Border Agent session.\n\n This structure is populated by `otBorderAgentGetNextSessionInfo()` during iteration over the list of sessions using\n an `otBorderAgentSessionIterator`.\n\n To ensure consistent `mLifetime` calculations, the iterator's initialization time is stored within the iterator,\n and each session's `mLifetime` is calculated relative to this time."]
4509#[repr(C)]
4510#[derive(Copy, Clone)]
4511pub struct otBorderAgentSessionInfo {
4512 #[doc = "< Socket address (IPv6 address and port number) of session peer."]
4513 pub mPeerSockAddr: otSockAddr,
4514 #[doc = "< Indicates whether the session is connected."]
4515 pub mIsConnected: bool,
4516 #[doc = "< Indicates whether the session is accepted as full commissioner."]
4517 pub mIsCommissioner: bool,
4518 #[doc = "< Milliseconds since the session was first established."]
4519 pub mLifetime: u64,
4520}
4521impl Default for otBorderAgentSessionInfo {
4522 fn default() -> Self {
4523 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4524 unsafe {
4525 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4526 s.assume_init()
4527 }
4528 }
4529}
4530#[doc = " Represents an iterator for Border Agent sessions.\n\n The caller MUST NOT access or update the fields in this struct. It is intended for OpenThread internal use only."]
4531#[repr(C)]
4532#[derive(Debug, Copy, Clone)]
4533pub struct otBorderAgentSessionIterator {
4534 pub mPtr: *mut ::std::os::raw::c_void,
4535 pub mData: u64,
4536}
4537impl Default for otBorderAgentSessionIterator {
4538 fn default() -> Self {
4539 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4540 unsafe {
4541 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4542 s.assume_init()
4543 }
4544 }
4545}
4546#[doc = " Represents the Border Agent MeshCoP Service TXT data."]
4547#[repr(C)]
4548#[derive(Debug, Copy, Clone)]
4549pub struct otBorderAgentMeshCoPServiceTxtData {
4550 pub mData: [u8; 128usize],
4551 pub mLength: u16,
4552}
4553impl Default for otBorderAgentMeshCoPServiceTxtData {
4554 fn default() -> Self {
4555 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4556 unsafe {
4557 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4558 s.assume_init()
4559 }
4560 }
4561}
4562extern "C" {
4563 #[doc = " Indicates whether or not the Border Agent service is active and running.\n\n While the Border Agent is active, external commissioner candidates can try to connect to and establish secure DTLS\n sessions with the Border Agent using PSKc. A connected commissioner can then petition to become a full commissioner.\n\n If `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE` is enabled, independent and separate DTLS transport and\n sessions are used for the ephemeral key. Therefore, the ephemeral key and Border Agent service can be enabled and\n used in parallel.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE The Border Agent is active.\n @retval FALSE The Border Agent is not active."]
4564 pub fn otBorderAgentIsActive(aInstance: *mut otInstance) -> bool;
4565}
4566extern "C" {
4567 #[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."]
4568 pub fn otBorderAgentGetUdpPort(aInstance: *mut otInstance) -> u16;
4569}
4570#[doc = " This callback informs the application of the changes in the state of the MeshCoP service.\n\n In specific, the 'state' includes the MeshCoP TXT data originated from the Thread network and whether the\n Border Agent is Active (which can be obtained by `otBorderAgentIsActive`).\n\n @param[in] aContext A pointer to application-specific context."]
4571pub type otBorderAgentMeshCoPServiceChangedCallback =
4572 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
4573extern "C" {
4574 #[doc = " Sets the callback function used by the Border Agent to notify of any changes to the state of the MeshCoP service.\n\n The callback is invoked when the 'Is Active' state of the Border Agent or the MeshCoP service TXT data values\n change. For example, it is invoked when the network name or the extended PAN ID changes and passes the updated\n encoded TXT data to the application layer.\n\n This callback is invoked once right after this API is called to provide initial states of the MeshCoP service.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback The callback to be invoked when there are any changes of the MeshCoP service.\n @param[in] aContext A pointer to application-specific context."]
4575 pub fn otBorderAgentSetMeshCoPServiceChangedCallback(
4576 aInstance: *mut otInstance,
4577 aCallback: otBorderAgentMeshCoPServiceChangedCallback,
4578 aContext: *mut ::std::os::raw::c_void,
4579 );
4580}
4581extern "C" {
4582 #[doc = " Gets the MeshCoP service TXT data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aTxtData A pointer to a MeshCoP Service TXT data struct to get the data.\n\n @retval OT_ERROR_NONE If successfully retrieved the Border Agent MeshCoP Service TXT data.\n @retval OT_ERROR_NO_BUFS If the buffer in @p aTxtData doesn't have enough size."]
4583 pub fn otBorderAgentGetMeshCoPServiceTxtData(
4584 aInstance: *mut otInstance,
4585 aTxtData: *mut otBorderAgentMeshCoPServiceTxtData,
4586 ) -> otError;
4587}
4588extern "C" {
4589 #[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"]
4590 pub fn otBorderAgentGetId(aInstance: *mut otInstance, aId: *mut otBorderAgentId) -> otError;
4591}
4592extern "C" {
4593 #[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"]
4594 pub fn otBorderAgentSetId(aInstance: *mut otInstance, aId: *const otBorderAgentId) -> otError;
4595}
4596extern "C" {
4597 #[doc = " Initializes a session iterator.\n\n An iterator MUST be initialized before being used in `otBorderAgentGetNextSessionInfo()`. A previously initialized\n iterator can be re-initialized to start from the beginning of the session list.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aIterator The iterator to initialize."]
4598 pub fn otBorderAgentInitSessionIterator(
4599 aInstance: *mut otInstance,
4600 aIterator: *mut otBorderAgentSessionIterator,
4601 );
4602}
4603extern "C" {
4604 #[doc = " Retrieves the next Border Agent session information.\n\n @param[in] aIterator The iterator to use.\n @param[out] aSessionInfo A pointer to an `otBorderAgentSessionInfo` to populate.\n\n @retval OT_ERROR_NONE Successfully retrieved the next session info.\n @retval OT_ERROR_NOT_FOUND No more sessions are available. The end of the list has been reached."]
4605 pub fn otBorderAgentGetNextSessionInfo(
4606 aIterator: *mut otBorderAgentSessionIterator,
4607 aSessionInfo: *mut otBorderAgentSessionInfo,
4608 ) -> otError;
4609}
4610extern "C" {
4611 #[doc = " Gets the counters of the Thread Border Agent.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Border Agent counters."]
4612 pub fn otBorderAgentGetCounters(aInstance: *mut otInstance) -> *const otBorderAgentCounters;
4613}
4614#[doc = "< Ephemeral Key Manager is disabled."]
4615pub const OT_BORDER_AGENT_STATE_DISABLED: otBorderAgentEphemeralKeyState = 0;
4616#[doc = "< Enabled, but no ephemeral key is in use (not set or started)."]
4617pub const OT_BORDER_AGENT_STATE_STOPPED: otBorderAgentEphemeralKeyState = 1;
4618#[doc = "< Ephemeral key is set. Listening to accept secure connections."]
4619pub const OT_BORDER_AGENT_STATE_STARTED: otBorderAgentEphemeralKeyState = 2;
4620#[doc = "< Session is established with an external commissioner candidate."]
4621pub const OT_BORDER_AGENT_STATE_CONNECTED: otBorderAgentEphemeralKeyState = 3;
4622#[doc = "< Session is established and candidate is accepted as full commissioner."]
4623pub const OT_BORDER_AGENT_STATE_ACCEPTED: otBorderAgentEphemeralKeyState = 4;
4624#[doc = " Represents Border Agent's Ephemeral Key Manager state."]
4625pub type otBorderAgentEphemeralKeyState = ::std::os::raw::c_uint;
4626extern "C" {
4627 #[doc = " Gets the state of Border Agent's Ephemeral Key Manager.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current state of Ephemeral Key Manager."]
4628 pub fn otBorderAgentEphemeralKeyGetState(
4629 aInstance: *mut otInstance,
4630 ) -> otBorderAgentEphemeralKeyState;
4631}
4632extern "C" {
4633 #[doc = " Enables/disables the Border Agent's Ephemeral Key Manager.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n If this function is called to disable, while an an ephemeral key is in use, the ephemeral key use will be stopped\n (as if `otBorderAgentEphemeralKeyStop()` is called).\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aEnabled Whether to enable or disable the Ephemeral Key Manager."]
4634 pub fn otBorderAgentEphemeralKeySetEnabled(aInstance: *mut otInstance, aEnabled: bool);
4635}
4636extern "C" {
4637 #[doc = " Starts using an ephemeral key for a given timeout duration.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n An ephemeral key can only be set when `otBorderAgentEphemeralKeyGetState()` is `OT_BORDER_AGENT_STATE_STOPPED`,\n i.e., enabled but not yet started. Otherwise, `OT_ERROR_INVALID_STATE` is returned. This means that setting the\n ephemeral key again while a previously set key is still in use will fail. Callers can stop the previous key by\n calling `otBorderAgentEphemeralKeyStop()` before starting with a new key.\n\n The Ephemeral Key Manager and the Border Agent service (which uses PSKc) can be enabled and used in parallel, as\n they use independent and separate DTLS transport and sessions.\n\n The given @p aKeyString is used directly as the ephemeral PSK (excluding the trailing null `\\0` character).\n Its length must be between `OT_BORDER_AGENT_MIN_EPHEMERAL_KEY_LENGTH` and `OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_LENGTH`,\n inclusive. Otherwise `OT_ERROR_INVALID_ARGS` is returned.\n\n When successfully set, the ephemeral key can be used only once by an external commissioner candidate to establish a\n secure session. After the commissioner candidate disconnects, the use of the ephemeral key is stopped. If the\n timeout expires, the use of the ephemeral key is stopped, and any connected session using the key is immediately\n disconnected.\n\n The Ephemeral Key Manager limits the number of failed DTLS connections to 10 attempts. After the 10th failed\n attempt, the use of the ephemeral key is automatically stopped (even if the timeout has not yet expired).\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aKeyString The ephemeral key.\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 is used. If the\n timeout value is larger than `OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT`, the maximum value\n is used instead.\n @param[in] aUdpPort The UDP port to use with the ephemeral key. If the UDP port is zero, an ephemeral port will\n be used. `otBorderAgentEphemeralKeyGetUdpPort()` returns the current UDP port being used.\n\n @retval OT_ERROR_NONE Successfully started using the ephemeral key.\n @retval OT_ERROR_INVALID_STATE A previously set ephemeral key is still in use or the feature is disabled.\n @retval OT_ERROR_INVALID_ARGS The given @p aKeyString is not valid.\n @retval OT_ERROR_FAILED Failed to start (e.g., it could not bind to the given UDP port)."]
4638 pub fn otBorderAgentEphemeralKeyStart(
4639 aInstance: *mut otInstance,
4640 aKeyString: *const ::std::os::raw::c_char,
4641 aTimeout: u32,
4642 aUdpPort: u16,
4643 ) -> otError;
4644}
4645extern "C" {
4646 #[doc = " Stops the ephemeral key use and disconnects any session using it.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n If there is no ephemeral key in use, calling this function has no effect.\n\n @param[in] aInstance The OpenThread instance."]
4647 pub fn otBorderAgentEphemeralKeyStop(aInstance: *mut otInstance);
4648}
4649extern "C" {
4650 #[doc = " Gets the UDP port used by Border Agent's Ephemeral Key Manager.\n\n Requires `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`.\n\n The port is applicable if an ephemeral key is in use, i.e., the state is not `OT_BORDER_AGENT_STATE_DISABLED` or\n `OT_BORDER_AGENT_STATE_STOPPED`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The UDP port being used by Border Agent's Ephemeral Key Manager (when active)."]
4651 pub fn otBorderAgentEphemeralKeyGetUdpPort(aInstance: *mut otInstance) -> u16;
4652}
4653#[doc = " Callback function pointer to signal state changes to the Border Agent's Ephemeral Key Manager.\n\n This callback is invoked whenever the `otBorderAgentEphemeralKeyGetState()` gets changed.\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)."]
4654pub type otBorderAgentEphemeralKeyCallback =
4655 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
4656extern "C" {
4657 #[doc = " Sets the callback function to notify state changes of Border Agent's Ephemeral Key Manager.\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."]
4658 pub fn otBorderAgentEphemeralKeySetCallback(
4659 aInstance: *mut otInstance,
4660 aCallback: otBorderAgentEphemeralKeyCallback,
4661 aContext: *mut ::std::os::raw::c_void,
4662 );
4663}
4664extern "C" {
4665 #[doc = " Converts a given `otBorderAgentEphemeralKeyState` to a human-readable string.\n\n @param[in] aState The state to convert.\n\n @returns Human-readable string corresponding to @p aState."]
4666 pub fn otBorderAgentEphemeralKeyStateToString(
4667 aState: otBorderAgentEphemeralKeyState,
4668 ) -> *const ::std::os::raw::c_char;
4669}
4670#[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()`."]
4671#[repr(C)]
4672#[derive(Debug, Copy, Clone)]
4673pub struct otBorderRoutingPrefixTableIterator {
4674 pub mPtr1: *const ::std::os::raw::c_void,
4675 pub mPtr2: *const ::std::os::raw::c_void,
4676 pub mData0: u32,
4677 pub mData1: u32,
4678 pub mData2: u8,
4679 pub mData3: u8,
4680}
4681impl Default for otBorderRoutingPrefixTableIterator {
4682 fn default() -> Self {
4683 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4684 unsafe {
4685 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4686 s.assume_init()
4687 }
4688 }
4689}
4690#[doc = " Represents a discovered router on the infrastructure link.\n\n The `mIsPeerBr` field requires `OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE`. Routing Manager\n determines whether the router is a peer BR (connected to the same Thread mesh network) by comparing its advertised\n PIO/RIO prefixes with the entries in the Thread Network Data. While this method is generally effective, it may not\n be 100% accurate in all scenarios, so the `mIsPeerBr` flag should be used with caution."]
4691#[repr(C)]
4692#[derive(Copy, Clone)]
4693pub struct otBorderRoutingRouterEntry {
4694 #[doc = "< IPv6 address of the router."]
4695 pub mAddress: otIp6Address,
4696 #[doc = "< Milliseconds since last update (any message rx) from this router."]
4697 pub mMsecSinceLastUpdate: u32,
4698 #[doc = "< The router's age in seconds (duration since its first discovery)."]
4699 pub mAge: u32,
4700 pub _bitfield_align_1: [u8; 0],
4701 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4702 pub __bindgen_padding_0: [u8; 3usize],
4703}
4704impl Default for otBorderRoutingRouterEntry {
4705 fn default() -> Self {
4706 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4707 unsafe {
4708 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4709 s.assume_init()
4710 }
4711 }
4712}
4713impl otBorderRoutingRouterEntry {
4714 #[inline]
4715 pub fn mManagedAddressConfigFlag(&self) -> bool {
4716 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
4717 }
4718 #[inline]
4719 pub fn set_mManagedAddressConfigFlag(&mut self, val: bool) {
4720 unsafe {
4721 let val: u8 = ::std::mem::transmute(val);
4722 self._bitfield_1.set(0usize, 1u8, val as u64)
4723 }
4724 }
4725 #[inline]
4726 pub fn mOtherConfigFlag(&self) -> bool {
4727 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
4728 }
4729 #[inline]
4730 pub fn set_mOtherConfigFlag(&mut self, val: bool) {
4731 unsafe {
4732 let val: u8 = ::std::mem::transmute(val);
4733 self._bitfield_1.set(1usize, 1u8, val as u64)
4734 }
4735 }
4736 #[inline]
4737 pub fn mSnacRouterFlag(&self) -> bool {
4738 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
4739 }
4740 #[inline]
4741 pub fn set_mSnacRouterFlag(&mut self, val: bool) {
4742 unsafe {
4743 let val: u8 = ::std::mem::transmute(val);
4744 self._bitfield_1.set(2usize, 1u8, val as u64)
4745 }
4746 }
4747 #[inline]
4748 pub fn mIsLocalDevice(&self) -> bool {
4749 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
4750 }
4751 #[inline]
4752 pub fn set_mIsLocalDevice(&mut self, val: bool) {
4753 unsafe {
4754 let val: u8 = ::std::mem::transmute(val);
4755 self._bitfield_1.set(3usize, 1u8, val as u64)
4756 }
4757 }
4758 #[inline]
4759 pub fn mIsReachable(&self) -> bool {
4760 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
4761 }
4762 #[inline]
4763 pub fn set_mIsReachable(&mut self, val: bool) {
4764 unsafe {
4765 let val: u8 = ::std::mem::transmute(val);
4766 self._bitfield_1.set(4usize, 1u8, val as u64)
4767 }
4768 }
4769 #[inline]
4770 pub fn mIsPeerBr(&self) -> bool {
4771 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
4772 }
4773 #[inline]
4774 pub fn set_mIsPeerBr(&mut self, val: bool) {
4775 unsafe {
4776 let val: u8 = ::std::mem::transmute(val);
4777 self._bitfield_1.set(5usize, 1u8, val as u64)
4778 }
4779 }
4780 #[inline]
4781 pub fn new_bitfield_1(
4782 mManagedAddressConfigFlag: bool,
4783 mOtherConfigFlag: bool,
4784 mSnacRouterFlag: bool,
4785 mIsLocalDevice: bool,
4786 mIsReachable: bool,
4787 mIsPeerBr: bool,
4788 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4789 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4790 __bindgen_bitfield_unit.set(0usize, 1u8, {
4791 let mManagedAddressConfigFlag: u8 =
4792 unsafe { ::std::mem::transmute(mManagedAddressConfigFlag) };
4793 mManagedAddressConfigFlag as u64
4794 });
4795 __bindgen_bitfield_unit.set(1usize, 1u8, {
4796 let mOtherConfigFlag: u8 = unsafe { ::std::mem::transmute(mOtherConfigFlag) };
4797 mOtherConfigFlag as u64
4798 });
4799 __bindgen_bitfield_unit.set(2usize, 1u8, {
4800 let mSnacRouterFlag: u8 = unsafe { ::std::mem::transmute(mSnacRouterFlag) };
4801 mSnacRouterFlag as u64
4802 });
4803 __bindgen_bitfield_unit.set(3usize, 1u8, {
4804 let mIsLocalDevice: u8 = unsafe { ::std::mem::transmute(mIsLocalDevice) };
4805 mIsLocalDevice as u64
4806 });
4807 __bindgen_bitfield_unit.set(4usize, 1u8, {
4808 let mIsReachable: u8 = unsafe { ::std::mem::transmute(mIsReachable) };
4809 mIsReachable as u64
4810 });
4811 __bindgen_bitfield_unit.set(5usize, 1u8, {
4812 let mIsPeerBr: u8 = unsafe { ::std::mem::transmute(mIsPeerBr) };
4813 mIsPeerBr as u64
4814 });
4815 __bindgen_bitfield_unit
4816 }
4817}
4818#[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."]
4819#[repr(C)]
4820#[derive(Copy, Clone)]
4821pub struct otBorderRoutingPrefixTableEntry {
4822 #[doc = "< Information about the router advertising this prefix."]
4823 pub mRouter: otBorderRoutingRouterEntry,
4824 #[doc = "< The discovered IPv6 prefix."]
4825 pub mPrefix: otIp6Prefix,
4826 #[doc = "< Indicates whether the prefix is on-link or route prefix."]
4827 pub mIsOnLink: bool,
4828 #[doc = "< Milliseconds since last update of this prefix."]
4829 pub mMsecSinceLastUpdate: u32,
4830 #[doc = "< Valid lifetime of the prefix (in seconds)."]
4831 pub mValidLifetime: u32,
4832 #[doc = "< Route preference when `mIsOnlink` is false."]
4833 pub mRoutePreference: otRoutePreference,
4834 #[doc = "< Preferred lifetime of the on-link prefix when `mIsOnLink`."]
4835 pub mPreferredLifetime: u32,
4836}
4837impl Default for otBorderRoutingPrefixTableEntry {
4838 fn default() -> Self {
4839 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4840 unsafe {
4841 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4842 s.assume_init()
4843 }
4844 }
4845}
4846#[doc = " Represents information about a peer Border Router found in the Network Data."]
4847#[repr(C)]
4848#[derive(Debug, Default, Copy, Clone)]
4849pub struct otBorderRoutingPeerBorderRouterEntry {
4850 #[doc = "< The RLOC16 of BR."]
4851 pub mRloc16: u16,
4852 #[doc = "< Seconds since the BR appeared in the Network Data."]
4853 pub mAge: u32,
4854}
4855#[doc = " Represents a group of data of platform-generated RA messages processed."]
4856#[repr(C)]
4857#[derive(Debug, Default, Copy, Clone)]
4858pub struct otPdProcessedRaInfo {
4859 #[doc = "< The number of platform generated RA handled by ProcessPlatformGeneratedRa."]
4860 pub mNumPlatformRaReceived: u32,
4861 #[doc = "< The number of PIO processed for adding OMR prefixes."]
4862 pub mNumPlatformPioProcessed: u32,
4863 #[doc = "< The timestamp of last processed RA message."]
4864 pub mLastPlatformRaMsec: u32,
4865}
4866#[doc = "< Routing Manager is uninitialized."]
4867pub const OT_BORDER_ROUTING_STATE_UNINITIALIZED: otBorderRoutingState = 0;
4868#[doc = "< Routing Manager is initialized but disabled."]
4869pub const OT_BORDER_ROUTING_STATE_DISABLED: otBorderRoutingState = 1;
4870#[doc = "< Routing Manager in initialized and enabled but currently stopped."]
4871pub const OT_BORDER_ROUTING_STATE_STOPPED: otBorderRoutingState = 2;
4872#[doc = "< Routing Manager is initialized, enabled, and running."]
4873pub const OT_BORDER_ROUTING_STATE_RUNNING: otBorderRoutingState = 3;
4874#[doc = " Represents the state of Border Routing Manager."]
4875pub type otBorderRoutingState = ::std::os::raw::c_uint;
4876#[doc = "< DHCPv6 PD is disabled on the border router."]
4877pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_DISABLED: otBorderRoutingDhcp6PdState = 0;
4878#[doc = "< DHCPv6 PD in enabled but won't try to request and publish a prefix."]
4879pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_STOPPED: otBorderRoutingDhcp6PdState = 1;
4880#[doc = "< DHCPv6 PD is enabled and will try to request and publish a prefix."]
4881pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_RUNNING: otBorderRoutingDhcp6PdState = 2;
4882#[doc = "< DHCPv6 PD is idle; Higher-prf prefix published by other BRs."]
4883pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_IDLE: otBorderRoutingDhcp6PdState = 3;
4884#[doc = " This enumeration represents the state of DHCPv6 Prefix Delegation State."]
4885pub type otBorderRoutingDhcp6PdState = ::std::os::raw::c_uint;
4886extern "C" {
4887 #[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."]
4888 pub fn otBorderRoutingInit(
4889 aInstance: *mut otInstance,
4890 aInfraIfIndex: u32,
4891 aInfraIfIsRunning: bool,
4892 ) -> otError;
4893}
4894extern "C" {
4895 #[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."]
4896 pub fn otBorderRoutingSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
4897}
4898extern "C" {
4899 #[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."]
4900 pub fn otBorderRoutingGetState(aInstance: *mut otInstance) -> otBorderRoutingState;
4901}
4902extern "C" {
4903 #[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."]
4904 pub fn otBorderRoutingGetRouteInfoOptionPreference(
4905 aInstance: *mut otInstance,
4906 ) -> otRoutePreference;
4907}
4908extern "C" {
4909 #[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."]
4910 pub fn otBorderRoutingSetRouteInfoOptionPreference(
4911 aInstance: *mut otInstance,
4912 aPreference: otRoutePreference,
4913 );
4914}
4915extern "C" {
4916 #[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."]
4917 pub fn otBorderRoutingClearRouteInfoOptionPreference(aInstance: *mut otInstance);
4918}
4919extern "C" {
4920 #[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."]
4921 pub fn otBorderRoutingSetExtraRouterAdvertOptions(
4922 aInstance: *mut otInstance,
4923 aOptions: *const u8,
4924 aLength: u16,
4925 ) -> otError;
4926}
4927extern "C" {
4928 #[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."]
4929 pub fn otBorderRoutingGetRoutePreference(aInstance: *mut otInstance) -> otRoutePreference;
4930}
4931extern "C" {
4932 #[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."]
4933 pub fn otBorderRoutingSetRoutePreference(
4934 aInstance: *mut otInstance,
4935 aPreference: otRoutePreference,
4936 );
4937}
4938extern "C" {
4939 #[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."]
4940 pub fn otBorderRoutingClearRoutePreference(aInstance: *mut otInstance);
4941}
4942extern "C" {
4943 #[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"]
4944 pub fn otBorderRoutingGetOmrPrefix(
4945 aInstance: *mut otInstance,
4946 aPrefix: *mut otIp6Prefix,
4947 ) -> otError;
4948}
4949extern "C" {
4950 #[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"]
4951 pub fn otBorderRoutingGetPdOmrPrefix(
4952 aInstance: *mut otInstance,
4953 aPrefixInfo: *mut otBorderRoutingPrefixTableEntry,
4954 ) -> otError;
4955}
4956extern "C" {
4957 #[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."]
4958 pub fn otBorderRoutingGetPdProcessedRaInfo(
4959 aInstance: *mut otInstance,
4960 aPdProcessedRaInfo: *mut otPdProcessedRaInfo,
4961 ) -> otError;
4962}
4963extern "C" {
4964 #[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."]
4965 pub fn otBorderRoutingGetFavoredOmrPrefix(
4966 aInstance: *mut otInstance,
4967 aPrefix: *mut otIp6Prefix,
4968 aPreference: *mut otRoutePreference,
4969 ) -> otError;
4970}
4971extern "C" {
4972 #[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."]
4973 pub fn otBorderRoutingGetOnLinkPrefix(
4974 aInstance: *mut otInstance,
4975 aPrefix: *mut otIp6Prefix,
4976 ) -> otError;
4977}
4978extern "C" {
4979 #[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."]
4980 pub fn otBorderRoutingGetFavoredOnLinkPrefix(
4981 aInstance: *mut otInstance,
4982 aPrefix: *mut otIp6Prefix,
4983 ) -> otError;
4984}
4985extern "C" {
4986 #[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."]
4987 pub fn otBorderRoutingGetNat64Prefix(
4988 aInstance: *mut otInstance,
4989 aPrefix: *mut otIp6Prefix,
4990 ) -> otError;
4991}
4992extern "C" {
4993 #[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."]
4994 pub fn otBorderRoutingGetFavoredNat64Prefix(
4995 aInstance: *mut otInstance,
4996 aPrefix: *mut otIp6Prefix,
4997 aPreference: *mut otRoutePreference,
4998 ) -> otError;
4999}
5000extern "C" {
5001 #[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."]
5002 pub fn otBorderRoutingPrefixTableInitIterator(
5003 aInstance: *mut otInstance,
5004 aIterator: *mut otBorderRoutingPrefixTableIterator,
5005 );
5006}
5007extern "C" {
5008 #[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."]
5009 pub fn otBorderRoutingGetNextPrefixTableEntry(
5010 aInstance: *mut otInstance,
5011 aIterator: *mut otBorderRoutingPrefixTableIterator,
5012 aEntry: *mut otBorderRoutingPrefixTableEntry,
5013 ) -> otError;
5014}
5015extern "C" {
5016 #[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."]
5017 pub fn otBorderRoutingGetNextRouterEntry(
5018 aInstance: *mut otInstance,
5019 aIterator: *mut otBorderRoutingPrefixTableIterator,
5020 aEntry: *mut otBorderRoutingRouterEntry,
5021 ) -> otError;
5022}
5023extern "C" {
5024 #[doc = " Iterates over the peer BRs found in the Network Data.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE`.\n\n Peer BRs are other devices within the Thread mesh that provide external IP connectivity. A device is considered\n to provide external IP connectivity if at least one of the following conditions is met regarding its Network Data\n entries:\n\n - It has added at least one external route entry.\n - It has added at least one prefix entry with both the default-route and on-mesh flags set.\n - It has added at least one domain prefix (with both the domain and on-mesh flags set).\n\n The list of peer BRs specifically excludes the current device, even if it is itself acting as a BR.\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."]
5025 pub fn otBorderRoutingGetNextPeerBrEntry(
5026 aInstance: *mut otInstance,
5027 aIterator: *mut otBorderRoutingPrefixTableIterator,
5028 aEntry: *mut otBorderRoutingPeerBorderRouterEntry,
5029 ) -> otError;
5030}
5031extern "C" {
5032 #[doc = " Returns the number of peer BRs found in the Network Data.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_TRACK_PEER_BR_INFO_ENABLE`.\n\n Peer BRs are other devices within the Thread mesh that provide external IP connectivity. A device is considered\n to provide external IP connectivity if at least one of the following conditions is met regarding its Network Data\n entries:\n\n - It has added at least one external route entry.\n - It has added at least one prefix entry with both the default-route and on-mesh flags set.\n - It has added at least one domain prefix (with both the domain and on-mesh flags set).\n\n The list of peer BRs specifically excludes the current device, even if it is itself acting as a BR.\n\n @param[in] aInstance The OpenThread instance.\n @param[out] aMinAge Pointer to an `uint32_t` to return the minimum age among all peer BRs.\n Can be NULL if the caller does not need this information.\n Age is represented as seconds since appearance of the BR entry in the Network Data.\n\n @returns The number of peer BRs."]
5033 pub fn otBorderRoutingCountPeerBrs(aInstance: *mut otInstance, aMinAge: *mut u32) -> u16;
5034}
5035extern "C" {
5036 #[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."]
5037 pub fn otBorderRoutingDhcp6PdSetEnabled(aInstance: *mut otInstance, aEnabled: bool);
5038}
5039extern "C" {
5040 #[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."]
5041 pub fn otBorderRoutingDhcp6PdGetState(
5042 aInstance: *mut otInstance,
5043 ) -> otBorderRoutingDhcp6PdState;
5044}
5045#[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."]
5046pub type otBorderRoutingRequestDhcp6PdCallback = ::std::option::Option<
5047 unsafe extern "C" fn(
5048 aState: otBorderRoutingDhcp6PdState,
5049 aContext: *mut ::std::os::raw::c_void,
5050 ),
5051>;
5052extern "C" {
5053 #[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."]
5054 pub fn otBorderRoutingDhcp6PdSetRequestCallback(
5055 aInstance: *mut otInstance,
5056 aCallback: otBorderRoutingRequestDhcp6PdCallback,
5057 aContext: *mut ::std::os::raw::c_void,
5058 );
5059}
5060extern "C" {
5061 #[doc = " Sets the local on-link prefix.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_TESTING_API_ENABLE`.\n\n This is intended for testing only and using it will make the BR non-compliant with the Thread Specification.\n\n @param[in] aPrefix The on-link prefix to use."]
5062 pub fn otBorderRoutingSetOnLinkPrefix(aInstance: *mut otInstance, aPrefix: *const otIp6Prefix);
5063}
5064extern "C" {
5065 #[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."]
5066 pub fn otBorderRouterGetNetData(
5067 aInstance: *mut otInstance,
5068 aStable: bool,
5069 aData: *mut u8,
5070 aDataLength: *mut u8,
5071 ) -> otError;
5072}
5073extern "C" {
5074 #[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"]
5075 pub fn otBorderRouterAddOnMeshPrefix(
5076 aInstance: *mut otInstance,
5077 aConfig: *const otBorderRouterConfig,
5078 ) -> otError;
5079}
5080extern "C" {
5081 #[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"]
5082 pub fn otBorderRouterRemoveOnMeshPrefix(
5083 aInstance: *mut otInstance,
5084 aPrefix: *const otIp6Prefix,
5085 ) -> otError;
5086}
5087extern "C" {
5088 #[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."]
5089 pub fn otBorderRouterGetNextOnMeshPrefix(
5090 aInstance: *mut otInstance,
5091 aIterator: *mut otNetworkDataIterator,
5092 aConfig: *mut otBorderRouterConfig,
5093 ) -> otError;
5094}
5095extern "C" {
5096 #[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"]
5097 pub fn otBorderRouterAddRoute(
5098 aInstance: *mut otInstance,
5099 aConfig: *const otExternalRouteConfig,
5100 ) -> otError;
5101}
5102extern "C" {
5103 #[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"]
5104 pub fn otBorderRouterRemoveRoute(
5105 aInstance: *mut otInstance,
5106 aPrefix: *const otIp6Prefix,
5107 ) -> otError;
5108}
5109extern "C" {
5110 #[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."]
5111 pub fn otBorderRouterGetNextRoute(
5112 aInstance: *mut otInstance,
5113 aIterator: *mut otNetworkDataIterator,
5114 aConfig: *mut otExternalRouteConfig,
5115 ) -> otError;
5116}
5117extern "C" {
5118 #[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"]
5119 pub fn otBorderRouterRegister(aInstance: *mut otInstance) -> otError;
5120}
5121#[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."]
5122pub type otBorderRouterNetDataFullCallback =
5123 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
5124extern "C" {
5125 #[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."]
5126 pub fn otBorderRouterSetNetDataFullCallback(
5127 aInstance: *mut otInstance,
5128 aCallback: otBorderRouterNetDataFullCallback,
5129 aContext: *mut ::std::os::raw::c_void,
5130 );
5131}
5132extern "C" {
5133 #[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."]
5134 pub fn otChannelManagerRequestChannelChange(aInstance: *mut otInstance, aChannel: u8);
5135}
5136extern "C" {
5137 #[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."]
5138 pub fn otChannelManagerGetRequestedChannel(aInstance: *mut otInstance) -> u8;
5139}
5140extern "C" {
5141 #[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."]
5142 pub fn otChannelManagerGetDelay(aInstance: *mut otInstance) -> u16;
5143}
5144extern "C" {
5145 #[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."]
5146 pub fn otChannelManagerSetDelay(aInstance: *mut otInstance, aDelay: u16) -> otError;
5147}
5148extern "C" {
5149 #[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."]
5150 pub fn otChannelManagerRequestChannelSelect(
5151 aInstance: *mut otInstance,
5152 aSkipQualityCheck: bool,
5153 ) -> otError;
5154}
5155extern "C" {
5156 #[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."]
5157 pub fn otChannelManagerRequestCslChannelSelect(
5158 aInstance: *mut otInstance,
5159 aSkipQualityCheck: bool,
5160 ) -> otError;
5161}
5162extern "C" {
5163 #[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."]
5164 pub fn otChannelManagerSetAutoChannelSelectionEnabled(
5165 aInstance: *mut otInstance,
5166 aEnabled: bool,
5167 );
5168}
5169extern "C" {
5170 #[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."]
5171 pub fn otChannelManagerGetAutoChannelSelectionEnabled(aInstance: *mut otInstance) -> bool;
5172}
5173extern "C" {
5174 #[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."]
5175 pub fn otChannelManagerSetAutoCslChannelSelectionEnabled(
5176 aInstance: *mut otInstance,
5177 aEnabled: bool,
5178 );
5179}
5180extern "C" {
5181 #[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."]
5182 pub fn otChannelManagerGetAutoCslChannelSelectionEnabled(aInstance: *mut otInstance) -> bool;
5183}
5184extern "C" {
5185 #[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)."]
5186 pub fn otChannelManagerSetAutoChannelSelectionInterval(
5187 aInstance: *mut otInstance,
5188 aInterval: u32,
5189 ) -> otError;
5190}
5191extern "C" {
5192 #[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."]
5193 pub fn otChannelManagerGetAutoChannelSelectionInterval(aInstance: *mut otInstance) -> u32;
5194}
5195extern "C" {
5196 #[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."]
5197 pub fn otChannelManagerGetSupportedChannels(aInstance: *mut otInstance) -> u32;
5198}
5199extern "C" {
5200 #[doc = " Sets the supported channel mask.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask A channel mask."]
5201 pub fn otChannelManagerSetSupportedChannels(aInstance: *mut otInstance, aChannelMask: u32);
5202}
5203extern "C" {
5204 #[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."]
5205 pub fn otChannelManagerGetFavoredChannels(aInstance: *mut otInstance) -> u32;
5206}
5207extern "C" {
5208 #[doc = " Sets the favored channel mask.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask A channel mask."]
5209 pub fn otChannelManagerSetFavoredChannels(aInstance: *mut otInstance, aChannelMask: u32);
5210}
5211extern "C" {
5212 #[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%."]
5213 pub fn otChannelManagerGetCcaFailureRateThreshold(aInstance: *mut otInstance) -> u16;
5214}
5215extern "C" {
5216 #[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%."]
5217 pub fn otChannelManagerSetCcaFailureRateThreshold(aInstance: *mut otInstance, aThreshold: u16);
5218}
5219extern "C" {
5220 #[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."]
5221 pub fn otChannelMonitorSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
5222}
5223extern "C" {
5224 #[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."]
5225 pub fn otChannelMonitorIsEnabled(aInstance: *mut otInstance) -> bool;
5226}
5227extern "C" {
5228 #[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."]
5229 pub fn otChannelMonitorGetSampleInterval(aInstance: *mut otInstance) -> u32;
5230}
5231extern "C" {
5232 #[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."]
5233 pub fn otChannelMonitorGetRssiThreshold(aInstance: *mut otInstance) -> i8;
5234}
5235extern "C" {
5236 #[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."]
5237 pub fn otChannelMonitorGetSampleWindow(aInstance: *mut otInstance) -> u32;
5238}
5239extern "C" {
5240 #[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."]
5241 pub fn otChannelMonitorGetSampleCount(aInstance: *mut otInstance) -> u32;
5242}
5243extern "C" {
5244 #[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."]
5245 pub fn otChannelMonitorGetChannelOccupancy(aInstance: *mut otInstance, aChannel: u8) -> u16;
5246}
5247extern "C" {
5248 #[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."]
5249 pub fn otChildSupervisionGetInterval(aInstance: *mut otInstance) -> u16;
5250}
5251extern "C" {
5252 #[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."]
5253 pub fn otChildSupervisionSetInterval(aInstance: *mut otInstance, aInterval: u16);
5254}
5255extern "C" {
5256 #[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."]
5257 pub fn otChildSupervisionGetCheckTimeout(aInstance: *mut otInstance) -> u16;
5258}
5259extern "C" {
5260 #[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."]
5261 pub fn otChildSupervisionSetCheckTimeout(aInstance: *mut otInstance, aTimeout: u16);
5262}
5263extern "C" {
5264 #[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."]
5265 pub fn otChildSupervisionGetCheckFailureCounter(aInstance: *mut otInstance) -> u16;
5266}
5267extern "C" {
5268 #[doc = " Reset the supervision check timeout failure counter to zero."]
5269 pub fn otChildSupervisionResetCheckFailureCounter(aInstance: *mut otInstance);
5270}
5271#[doc = " Represents a CLI command."]
5272#[repr(C)]
5273#[derive(Debug, Copy, Clone)]
5274pub struct otCliCommand {
5275 #[doc = "< A pointer to the command string."]
5276 pub mName: *const ::std::os::raw::c_char,
5277 pub mCommand: ::std::option::Option<
5278 unsafe extern "C" fn(
5279 aContext: *mut ::std::os::raw::c_void,
5280 aArgsLength: u8,
5281 aArgs: *mut *mut ::std::os::raw::c_char,
5282 ) -> otError,
5283 >,
5284}
5285impl Default for otCliCommand {
5286 fn default() -> Self {
5287 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5288 unsafe {
5289 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5290 s.assume_init()
5291 }
5292 }
5293}
5294#[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."]
5295pub type otCliOutputCallback = ::std::option::Option<
5296 unsafe extern "C" fn(
5297 aContext: *mut ::std::os::raw::c_void,
5298 aFormat: *const ::std::os::raw::c_char,
5299 aArguments: *mut __va_list_tag,
5300 ) -> ::std::os::raw::c_int,
5301>;
5302extern "C" {
5303 #[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."]
5304 pub fn otCliInit(
5305 aInstance: *mut otInstance,
5306 aCallback: otCliOutputCallback,
5307 aContext: *mut ::std::os::raw::c_void,
5308 );
5309}
5310extern "C" {
5311 #[doc = " Is called to feed in a console input line.\n\n @param[in] aBuf A pointer to a null-terminated string."]
5312 pub fn otCliInputLine(aBuf: *mut ::std::os::raw::c_char);
5313}
5314extern "C" {
5315 #[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."]
5316 pub fn otCliSetUserCommands(
5317 aUserCommands: *const otCliCommand,
5318 aLength: u8,
5319 aContext: *mut ::std::os::raw::c_void,
5320 ) -> otError;
5321}
5322extern "C" {
5323 #[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."]
5324 pub fn otCliOutputBytes(aBytes: *const u8, aLength: u8);
5325}
5326extern "C" {
5327 #[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."]
5328 pub fn otCliOutputFormat(aFmt: *const ::std::os::raw::c_char, ...);
5329}
5330extern "C" {
5331 #[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."]
5332 pub fn otCliAppendResult(aError: otError);
5333}
5334extern "C" {
5335 #[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."]
5336 pub fn otCliPlatLogv(
5337 aLogLevel: otLogLevel,
5338 aLogRegion: otLogRegion,
5339 aFormat: *const ::std::os::raw::c_char,
5340 aArgs: *mut __va_list_tag,
5341 );
5342}
5343extern "C" {
5344 #[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."]
5345 pub fn otCliVendorSetUserCommands();
5346}
5347#[doc = "< Confirmable"]
5348pub const OT_COAP_TYPE_CONFIRMABLE: otCoapType = 0;
5349#[doc = "< Non-confirmable"]
5350pub const OT_COAP_TYPE_NON_CONFIRMABLE: otCoapType = 1;
5351#[doc = "< Acknowledgment"]
5352pub const OT_COAP_TYPE_ACKNOWLEDGMENT: otCoapType = 2;
5353#[doc = "< Reset"]
5354pub const OT_COAP_TYPE_RESET: otCoapType = 3;
5355#[doc = " CoAP Type values (2 bit unsigned integer)."]
5356pub type otCoapType = ::std::os::raw::c_uint;
5357#[doc = "< Empty message code"]
5358pub const OT_COAP_CODE_EMPTY: otCoapCode = 0;
5359#[doc = "< Get"]
5360pub const OT_COAP_CODE_GET: otCoapCode = 1;
5361#[doc = "< Post"]
5362pub const OT_COAP_CODE_POST: otCoapCode = 2;
5363#[doc = "< Put"]
5364pub const OT_COAP_CODE_PUT: otCoapCode = 3;
5365#[doc = "< Delete"]
5366pub const OT_COAP_CODE_DELETE: otCoapCode = 4;
5367#[doc = "< 2.00"]
5368pub const OT_COAP_CODE_RESPONSE_MIN: otCoapCode = 64;
5369#[doc = "< Created"]
5370pub const OT_COAP_CODE_CREATED: otCoapCode = 65;
5371#[doc = "< Deleted"]
5372pub const OT_COAP_CODE_DELETED: otCoapCode = 66;
5373#[doc = "< Valid"]
5374pub const OT_COAP_CODE_VALID: otCoapCode = 67;
5375#[doc = "< Changed"]
5376pub const OT_COAP_CODE_CHANGED: otCoapCode = 68;
5377#[doc = "< Content"]
5378pub const OT_COAP_CODE_CONTENT: otCoapCode = 69;
5379#[doc = "< RFC7959 Continue"]
5380pub const OT_COAP_CODE_CONTINUE: otCoapCode = 95;
5381#[doc = "< Bad Request"]
5382pub const OT_COAP_CODE_BAD_REQUEST: otCoapCode = 128;
5383#[doc = "< Unauthorized"]
5384pub const OT_COAP_CODE_UNAUTHORIZED: otCoapCode = 129;
5385#[doc = "< Bad Option"]
5386pub const OT_COAP_CODE_BAD_OPTION: otCoapCode = 130;
5387#[doc = "< Forbidden"]
5388pub const OT_COAP_CODE_FORBIDDEN: otCoapCode = 131;
5389#[doc = "< Not Found"]
5390pub const OT_COAP_CODE_NOT_FOUND: otCoapCode = 132;
5391#[doc = "< Method Not Allowed"]
5392pub const OT_COAP_CODE_METHOD_NOT_ALLOWED: otCoapCode = 133;
5393#[doc = "< Not Acceptable"]
5394pub const OT_COAP_CODE_NOT_ACCEPTABLE: otCoapCode = 134;
5395#[doc = "< RFC7959 Request Entity Incomplete"]
5396pub const OT_COAP_CODE_REQUEST_INCOMPLETE: otCoapCode = 136;
5397#[doc = "< Precondition Failed"]
5398pub const OT_COAP_CODE_PRECONDITION_FAILED: otCoapCode = 140;
5399#[doc = "< Request Entity Too Large"]
5400pub const OT_COAP_CODE_REQUEST_TOO_LARGE: otCoapCode = 141;
5401#[doc = "< Unsupported Content-Format"]
5402pub const OT_COAP_CODE_UNSUPPORTED_FORMAT: otCoapCode = 143;
5403#[doc = "< Internal Server Error"]
5404pub const OT_COAP_CODE_INTERNAL_ERROR: otCoapCode = 160;
5405#[doc = "< Not Implemented"]
5406pub const OT_COAP_CODE_NOT_IMPLEMENTED: otCoapCode = 161;
5407#[doc = "< Bad Gateway"]
5408pub const OT_COAP_CODE_BAD_GATEWAY: otCoapCode = 162;
5409#[doc = "< Service Unavailable"]
5410pub const OT_COAP_CODE_SERVICE_UNAVAILABLE: otCoapCode = 163;
5411#[doc = "< Gateway Timeout"]
5412pub const OT_COAP_CODE_GATEWAY_TIMEOUT: otCoapCode = 164;
5413#[doc = "< Proxying Not Supported"]
5414pub const OT_COAP_CODE_PROXY_NOT_SUPPORTED: otCoapCode = 165;
5415#[doc = " CoAP Code values."]
5416pub type otCoapCode = ::std::os::raw::c_uint;
5417#[doc = "< If-Match"]
5418pub const OT_COAP_OPTION_IF_MATCH: otCoapOptionType = 1;
5419#[doc = "< Uri-Host"]
5420pub const OT_COAP_OPTION_URI_HOST: otCoapOptionType = 3;
5421#[doc = "< ETag"]
5422pub const OT_COAP_OPTION_E_TAG: otCoapOptionType = 4;
5423#[doc = "< If-None-Match"]
5424pub const OT_COAP_OPTION_IF_NONE_MATCH: otCoapOptionType = 5;
5425#[doc = "< Observe [RFC7641]"]
5426pub const OT_COAP_OPTION_OBSERVE: otCoapOptionType = 6;
5427#[doc = "< Uri-Port"]
5428pub const OT_COAP_OPTION_URI_PORT: otCoapOptionType = 7;
5429#[doc = "< Location-Path"]
5430pub const OT_COAP_OPTION_LOCATION_PATH: otCoapOptionType = 8;
5431#[doc = "< Uri-Path"]
5432pub const OT_COAP_OPTION_URI_PATH: otCoapOptionType = 11;
5433#[doc = "< Content-Format"]
5434pub const OT_COAP_OPTION_CONTENT_FORMAT: otCoapOptionType = 12;
5435#[doc = "< Max-Age"]
5436pub const OT_COAP_OPTION_MAX_AGE: otCoapOptionType = 14;
5437#[doc = "< Uri-Query"]
5438pub const OT_COAP_OPTION_URI_QUERY: otCoapOptionType = 15;
5439#[doc = "< Accept"]
5440pub const OT_COAP_OPTION_ACCEPT: otCoapOptionType = 17;
5441#[doc = "< Location-Query"]
5442pub const OT_COAP_OPTION_LOCATION_QUERY: otCoapOptionType = 20;
5443#[doc = "< Block2 (RFC7959)"]
5444pub const OT_COAP_OPTION_BLOCK2: otCoapOptionType = 23;
5445#[doc = "< Block1 (RFC7959)"]
5446pub const OT_COAP_OPTION_BLOCK1: otCoapOptionType = 27;
5447#[doc = "< Size2 (RFC7959)"]
5448pub const OT_COAP_OPTION_SIZE2: otCoapOptionType = 28;
5449#[doc = "< Proxy-Uri"]
5450pub const OT_COAP_OPTION_PROXY_URI: otCoapOptionType = 35;
5451#[doc = "< Proxy-Scheme"]
5452pub const OT_COAP_OPTION_PROXY_SCHEME: otCoapOptionType = 39;
5453#[doc = "< Size1"]
5454pub const OT_COAP_OPTION_SIZE1: otCoapOptionType = 60;
5455#[doc = " CoAP Option Numbers"]
5456pub type otCoapOptionType = ::std::os::raw::c_uint;
5457#[doc = " Represents a CoAP option."]
5458#[repr(C)]
5459#[derive(Debug, Default, Copy, Clone)]
5460pub struct otCoapOption {
5461 #[doc = "< Option Number"]
5462 pub mNumber: u16,
5463 #[doc = "< Option Length"]
5464 pub mLength: u16,
5465}
5466#[doc = " Acts as an iterator for CoAP options"]
5467#[repr(C)]
5468#[derive(Debug, Copy, Clone)]
5469pub struct otCoapOptionIterator {
5470 #[doc = "< CoAP message"]
5471 pub mMessage: *const otMessage,
5472 #[doc = "< CoAP message option"]
5473 pub mOption: otCoapOption,
5474 #[doc = "< Byte offset of next option"]
5475 pub mNextOptionOffset: u16,
5476}
5477impl Default for otCoapOptionIterator {
5478 fn default() -> Self {
5479 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5480 unsafe {
5481 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5482 s.assume_init()
5483 }
5484 }
5485}
5486#[doc = " text/plain; charset=utf-8: [RFC2046][RFC3676][RFC5147]"]
5487pub const OT_COAP_OPTION_CONTENT_FORMAT_TEXT_PLAIN: otCoapOptionContentFormat = 0;
5488#[doc = " application/cose; cose-type=\"cose-encrypt0\": [RFC8152]"]
5489pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_ENCRYPT0: otCoapOptionContentFormat = 16;
5490#[doc = " application/cose; cose-type=\"cose-mac0\": [RFC8152]"]
5491pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_MAC0: otCoapOptionContentFormat = 17;
5492#[doc = " application/cose; cose-type=\"cose-sign1\": [RFC8152]"]
5493pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_SIGN1: otCoapOptionContentFormat = 18;
5494#[doc = " application/link-format: [RFC6690]"]
5495pub const OT_COAP_OPTION_CONTENT_FORMAT_LINK_FORMAT: otCoapOptionContentFormat = 40;
5496#[doc = " application/xml: [RFC3023]"]
5497pub const OT_COAP_OPTION_CONTENT_FORMAT_XML: otCoapOptionContentFormat = 41;
5498#[doc = " application/octet-stream: [RFC2045][RFC2046]"]
5499pub const OT_COAP_OPTION_CONTENT_FORMAT_OCTET_STREAM: otCoapOptionContentFormat = 42;
5500#[doc = " application/exi:\n [\"Efficient XML Interchange (EXI) Format 1.0 (Second Edition)\", February 2014]"]
5501pub const OT_COAP_OPTION_CONTENT_FORMAT_EXI: otCoapOptionContentFormat = 47;
5502#[doc = " application/json: [RFC7159]"]
5503pub const OT_COAP_OPTION_CONTENT_FORMAT_JSON: otCoapOptionContentFormat = 50;
5504#[doc = " application/json-patch+json: [RFC6902]"]
5505pub const OT_COAP_OPTION_CONTENT_FORMAT_JSON_PATCH_JSON: otCoapOptionContentFormat = 51;
5506#[doc = " application/merge-patch+json: [RFC7396]"]
5507pub const OT_COAP_OPTION_CONTENT_FORMAT_MERGE_PATCH_JSON: otCoapOptionContentFormat = 52;
5508#[doc = " application/cbor: [RFC7049]"]
5509pub const OT_COAP_OPTION_CONTENT_FORMAT_CBOR: otCoapOptionContentFormat = 60;
5510#[doc = " application/cwt: [RFC8392]"]
5511pub const OT_COAP_OPTION_CONTENT_FORMAT_CWT: otCoapOptionContentFormat = 61;
5512#[doc = " application/cose; cose-type=\"cose-encrypt\": [RFC8152]"]
5513pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_ENCRYPT: otCoapOptionContentFormat = 96;
5514#[doc = " application/cose; cose-type=\"cose-mac\": [RFC8152]"]
5515pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_MAC: otCoapOptionContentFormat = 97;
5516#[doc = " application/cose; cose-type=\"cose-sign\": [RFC8152]"]
5517pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_SIGN: otCoapOptionContentFormat = 98;
5518#[doc = " application/cose-key: [RFC8152]"]
5519pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_KEY: otCoapOptionContentFormat = 101;
5520#[doc = " application/cose-key-set: [RFC8152]"]
5521pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_KEY_SET: otCoapOptionContentFormat = 102;
5522#[doc = " application/senml+json: [RFC8428]"]
5523pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_JSON: otCoapOptionContentFormat = 110;
5524#[doc = " application/sensml+json: [RFC8428]"]
5525pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_JSON: otCoapOptionContentFormat = 111;
5526#[doc = " application/senml+cbor: [RFC8428]"]
5527pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_CBOR: otCoapOptionContentFormat = 112;
5528#[doc = " application/sensml+cbor: [RFC8428]"]
5529pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_CBOR: otCoapOptionContentFormat = 113;
5530#[doc = " application/senml-exi: [RFC8428]"]
5531pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_EXI: otCoapOptionContentFormat = 114;
5532#[doc = " application/sensml-exi: [RFC8428]"]
5533pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_EXI: otCoapOptionContentFormat = 115;
5534#[doc = " application/coap-group+json: [RFC7390]"]
5535pub const OT_COAP_OPTION_CONTENT_FORMAT_COAP_GROUP_JSON: otCoapOptionContentFormat = 256;
5536#[doc = " application/senml+xml: [RFC8428]"]
5537pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_XML: otCoapOptionContentFormat = 310;
5538#[doc = " application/sensml+xml: [RFC8428]"]
5539pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_XML: otCoapOptionContentFormat = 311;
5540#[doc = " CoAP Content Format codes. The full list is documented at\n https://www.iana.org/assignments/core-parameters/core-parameters.xhtml#content-formats"]
5541pub type otCoapOptionContentFormat = ::std::os::raw::c_uint;
5542pub const OT_COAP_OPTION_BLOCK_SZX_16: otCoapBlockSzx = 0;
5543pub const OT_COAP_OPTION_BLOCK_SZX_32: otCoapBlockSzx = 1;
5544pub const OT_COAP_OPTION_BLOCK_SZX_64: otCoapBlockSzx = 2;
5545pub const OT_COAP_OPTION_BLOCK_SZX_128: otCoapBlockSzx = 3;
5546pub const OT_COAP_OPTION_BLOCK_SZX_256: otCoapBlockSzx = 4;
5547pub const OT_COAP_OPTION_BLOCK_SZX_512: otCoapBlockSzx = 5;
5548pub const OT_COAP_OPTION_BLOCK_SZX_1024: otCoapBlockSzx = 6;
5549#[doc = " CoAP Block Size Exponents"]
5550pub type otCoapBlockSzx = ::std::os::raw::c_uint;
5551#[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."]
5552pub type otCoapResponseHandler = ::std::option::Option<
5553 unsafe extern "C" fn(
5554 aContext: *mut ::std::os::raw::c_void,
5555 aMessage: *mut otMessage,
5556 aMessageInfo: *const otMessageInfo,
5557 aResult: otError,
5558 ),
5559>;
5560#[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."]
5561pub type otCoapRequestHandler = ::std::option::Option<
5562 unsafe extern "C" fn(
5563 aContext: *mut ::std::os::raw::c_void,
5564 aMessage: *mut otMessage,
5565 aMessageInfo: *const otMessageInfo,
5566 ),
5567>;
5568#[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."]
5569pub type otCoapBlockwiseReceiveHook = ::std::option::Option<
5570 unsafe extern "C" fn(
5571 aContext: *mut ::std::os::raw::c_void,
5572 aBlock: *const u8,
5573 aPosition: u32,
5574 aBlockLength: u16,
5575 aMore: bool,
5576 aTotalLength: u32,
5577 ) -> otError,
5578>;
5579#[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."]
5580pub type otCoapBlockwiseTransmitHook = ::std::option::Option<
5581 unsafe extern "C" fn(
5582 aContext: *mut ::std::os::raw::c_void,
5583 aBlock: *mut u8,
5584 aPosition: u32,
5585 aBlockLength: *mut u16,
5586 aMore: *mut bool,
5587 ) -> otError,
5588>;
5589#[doc = " Represents a CoAP resource."]
5590#[repr(C)]
5591#[derive(Debug, Copy, Clone)]
5592pub struct otCoapResource {
5593 #[doc = "< The URI Path string"]
5594 pub mUriPath: *const ::std::os::raw::c_char,
5595 #[doc = "< The callback for handling a received request"]
5596 pub mHandler: otCoapRequestHandler,
5597 #[doc = "< Application-specific context"]
5598 pub mContext: *mut ::std::os::raw::c_void,
5599 #[doc = "< The next CoAP resource in the list"]
5600 pub mNext: *mut otCoapResource,
5601}
5602impl Default for otCoapResource {
5603 fn default() -> Self {
5604 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5605 unsafe {
5606 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5607 s.assume_init()
5608 }
5609 }
5610}
5611#[doc = " Represents a CoAP resource with block-wise transfer."]
5612#[repr(C)]
5613#[derive(Debug, Copy, Clone)]
5614pub struct otCoapBlockwiseResource {
5615 #[doc = "< The URI Path string"]
5616 pub mUriPath: *const ::std::os::raw::c_char,
5617 #[doc = "< The callback for handling a received request"]
5618 pub mHandler: otCoapRequestHandler,
5619 #[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."]
5620 pub mReceiveHook: otCoapBlockwiseReceiveHook,
5621 #[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."]
5622 pub mTransmitHook: otCoapBlockwiseTransmitHook,
5623 #[doc = "< Application-specific context"]
5624 pub mContext: *mut ::std::os::raw::c_void,
5625 #[doc = "< The next CoAP resource in the list"]
5626 pub mNext: *mut otCoapBlockwiseResource,
5627}
5628impl Default for otCoapBlockwiseResource {
5629 fn default() -> Self {
5630 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5631 unsafe {
5632 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5633 s.assume_init()
5634 }
5635 }
5636}
5637#[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."]
5638#[repr(C)]
5639#[derive(Debug, Default, Copy, Clone)]
5640pub struct otCoapTxParameters {
5641 #[doc = " Minimum spacing before first retransmission when ACK is not received, in milliseconds (RFC7252 default value is\n 2000ms)."]
5642 pub mAckTimeout: u32,
5643 #[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)."]
5644 pub mAckRandomFactorNumerator: u8,
5645 #[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)."]
5646 pub mAckRandomFactorDenominator: u8,
5647 #[doc = " Maximum number of retransmissions for CoAP Confirmable messages (RFC7252 default value is 4)."]
5648 pub mMaxRetransmit: u8,
5649}
5650extern "C" {
5651 #[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."]
5652 pub fn otCoapMessageInit(aMessage: *mut otMessage, aType: otCoapType, aCode: otCoapCode);
5653}
5654extern "C" {
5655 #[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."]
5656 pub fn otCoapMessageInitResponse(
5657 aResponse: *mut otMessage,
5658 aRequest: *const otMessage,
5659 aType: otCoapType,
5660 aCode: otCoapCode,
5661 ) -> otError;
5662}
5663extern "C" {
5664 #[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."]
5665 pub fn otCoapMessageSetToken(
5666 aMessage: *mut otMessage,
5667 aToken: *const u8,
5668 aTokenLength: u8,
5669 ) -> otError;
5670}
5671extern "C" {
5672 #[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."]
5673 pub fn otCoapMessageGenerateToken(aMessage: *mut otMessage, aTokenLength: u8);
5674}
5675extern "C" {
5676 #[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."]
5677 pub fn otCoapMessageAppendContentFormatOption(
5678 aMessage: *mut otMessage,
5679 aContentFormat: otCoapOptionContentFormat,
5680 ) -> otError;
5681}
5682extern "C" {
5683 #[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."]
5684 pub fn otCoapMessageAppendOption(
5685 aMessage: *mut otMessage,
5686 aNumber: u16,
5687 aLength: u16,
5688 aValue: *const ::std::os::raw::c_void,
5689 ) -> otError;
5690}
5691extern "C" {
5692 #[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"]
5693 pub fn otCoapMessageAppendUintOption(
5694 aMessage: *mut otMessage,
5695 aNumber: u16,
5696 aValue: u32,
5697 ) -> otError;
5698}
5699extern "C" {
5700 #[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."]
5701 pub fn otCoapMessageAppendObserveOption(aMessage: *mut otMessage, aObserve: u32) -> otError;
5702}
5703extern "C" {
5704 #[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."]
5705 pub fn otCoapMessageAppendUriPathOptions(
5706 aMessage: *mut otMessage,
5707 aUriPath: *const ::std::os::raw::c_char,
5708 ) -> otError;
5709}
5710extern "C" {
5711 #[doc = " Appends a Uri-Query option.\n\n @param[in,out] aMessage A pointer to the CoAP message.\n @param[in] aUriQuery 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."]
5712 pub fn otCoapMessageAppendUriQueryOptions(
5713 aMessage: *mut otMessage,
5714 aUriQuery: *const ::std::os::raw::c_char,
5715 ) -> otError;
5716}
5717extern "C" {
5718 #[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."]
5719 pub fn otCoapBlockSizeFromExponent(aSize: otCoapBlockSzx) -> u16;
5720}
5721extern "C" {
5722 #[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."]
5723 pub fn otCoapMessageAppendBlock2Option(
5724 aMessage: *mut otMessage,
5725 aNum: u32,
5726 aMore: bool,
5727 aSize: otCoapBlockSzx,
5728 ) -> otError;
5729}
5730extern "C" {
5731 #[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."]
5732 pub fn otCoapMessageAppendBlock1Option(
5733 aMessage: *mut otMessage,
5734 aNum: u32,
5735 aMore: bool,
5736 aSize: otCoapBlockSzx,
5737 ) -> otError;
5738}
5739extern "C" {
5740 #[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."]
5741 pub fn otCoapMessageAppendProxyUriOption(
5742 aMessage: *mut otMessage,
5743 aUriPath: *const ::std::os::raw::c_char,
5744 ) -> otError;
5745}
5746extern "C" {
5747 #[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."]
5748 pub fn otCoapMessageAppendMaxAgeOption(aMessage: *mut otMessage, aMaxAge: u32) -> otError;
5749}
5750extern "C" {
5751 #[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."]
5752 pub fn otCoapMessageAppendUriQueryOption(
5753 aMessage: *mut otMessage,
5754 aUriQuery: *const ::std::os::raw::c_char,
5755 ) -> otError;
5756}
5757extern "C" {
5758 #[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."]
5759 pub fn otCoapMessageSetPayloadMarker(aMessage: *mut otMessage) -> otError;
5760}
5761extern "C" {
5762 #[doc = " Returns the Type value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Type value."]
5763 pub fn otCoapMessageGetType(aMessage: *const otMessage) -> otCoapType;
5764}
5765extern "C" {
5766 #[doc = " Returns the Code value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Code value."]
5767 pub fn otCoapMessageGetCode(aMessage: *const otMessage) -> otCoapCode;
5768}
5769extern "C" {
5770 #[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."]
5771 pub fn otCoapMessageSetCode(aMessage: *mut otMessage, aCode: otCoapCode);
5772}
5773extern "C" {
5774 #[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."]
5775 pub fn otCoapMessageCodeToString(aMessage: *const otMessage) -> *const ::std::os::raw::c_char;
5776}
5777extern "C" {
5778 #[doc = " Returns the Message ID value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Message ID value."]
5779 pub fn otCoapMessageGetMessageId(aMessage: *const otMessage) -> u16;
5780}
5781extern "C" {
5782 #[doc = " Returns the Token length.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Token length."]
5783 pub fn otCoapMessageGetTokenLength(aMessage: *const otMessage) -> u8;
5784}
5785extern "C" {
5786 #[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."]
5787 pub fn otCoapMessageGetToken(aMessage: *const otMessage) -> *const u8;
5788}
5789extern "C" {
5790 #[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."]
5791 pub fn otCoapOptionIteratorInit(
5792 aIterator: *mut otCoapOptionIterator,
5793 aMessage: *const otMessage,
5794 ) -> otError;
5795}
5796extern "C" {
5797 #[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."]
5798 pub fn otCoapOptionIteratorGetFirstOptionMatching(
5799 aIterator: *mut otCoapOptionIterator,
5800 aOption: u16,
5801 ) -> *const otCoapOption;
5802}
5803extern "C" {
5804 #[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."]
5805 pub fn otCoapOptionIteratorGetFirstOption(
5806 aIterator: *mut otCoapOptionIterator,
5807 ) -> *const otCoapOption;
5808}
5809extern "C" {
5810 #[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."]
5811 pub fn otCoapOptionIteratorGetNextOptionMatching(
5812 aIterator: *mut otCoapOptionIterator,
5813 aOption: u16,
5814 ) -> *const otCoapOption;
5815}
5816extern "C" {
5817 #[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."]
5818 pub fn otCoapOptionIteratorGetNextOption(
5819 aIterator: *mut otCoapOptionIterator,
5820 ) -> *const otCoapOption;
5821}
5822extern "C" {
5823 #[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"]
5824 pub fn otCoapOptionIteratorGetOptionUintValue(
5825 aIterator: *mut otCoapOptionIterator,
5826 aValue: *mut u64,
5827 ) -> otError;
5828}
5829extern "C" {
5830 #[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."]
5831 pub fn otCoapOptionIteratorGetOptionValue(
5832 aIterator: *mut otCoapOptionIterator,
5833 aValue: *mut ::std::os::raw::c_void,
5834 ) -> otError;
5835}
5836extern "C" {
5837 #[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."]
5838 pub fn otCoapNewMessage(
5839 aInstance: *mut otInstance,
5840 aSettings: *const otMessageSettings,
5841 ) -> *mut otMessage;
5842}
5843extern "C" {
5844 #[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."]
5845 pub fn otCoapSendRequestWithParameters(
5846 aInstance: *mut otInstance,
5847 aMessage: *mut otMessage,
5848 aMessageInfo: *const otMessageInfo,
5849 aHandler: otCoapResponseHandler,
5850 aContext: *mut ::std::os::raw::c_void,
5851 aTxParameters: *const otCoapTxParameters,
5852 ) -> otError;
5853}
5854extern "C" {
5855 #[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."]
5856 pub fn otCoapSendRequestBlockWiseWithParameters(
5857 aInstance: *mut otInstance,
5858 aMessage: *mut otMessage,
5859 aMessageInfo: *const otMessageInfo,
5860 aHandler: otCoapResponseHandler,
5861 aContext: *mut ::std::os::raw::c_void,
5862 aTxParameters: *const otCoapTxParameters,
5863 aTransmitHook: otCoapBlockwiseTransmitHook,
5864 aReceiveHook: otCoapBlockwiseReceiveHook,
5865 ) -> otError;
5866}
5867extern "C" {
5868 #[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."]
5869 pub fn otCoapStart(aInstance: *mut otInstance, aPort: u16) -> otError;
5870}
5871extern "C" {
5872 #[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."]
5873 pub fn otCoapStop(aInstance: *mut otInstance) -> otError;
5874}
5875extern "C" {
5876 #[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."]
5877 pub fn otCoapAddResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
5878}
5879extern "C" {
5880 #[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."]
5881 pub fn otCoapRemoveResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
5882}
5883extern "C" {
5884 #[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."]
5885 pub fn otCoapAddBlockWiseResource(
5886 aInstance: *mut otInstance,
5887 aResource: *mut otCoapBlockwiseResource,
5888 );
5889}
5890extern "C" {
5891 #[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."]
5892 pub fn otCoapRemoveBlockWiseResource(
5893 aInstance: *mut otInstance,
5894 aResource: *mut otCoapBlockwiseResource,
5895 );
5896}
5897extern "C" {
5898 #[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."]
5899 pub fn otCoapSetDefaultHandler(
5900 aInstance: *mut otInstance,
5901 aHandler: otCoapRequestHandler,
5902 aContext: *mut ::std::os::raw::c_void,
5903 );
5904}
5905extern "C" {
5906 #[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."]
5907 pub fn otCoapSendResponseWithParameters(
5908 aInstance: *mut otInstance,
5909 aMessage: *mut otMessage,
5910 aMessageInfo: *const otMessageInfo,
5911 aTxParameters: *const otCoapTxParameters,
5912 ) -> otError;
5913}
5914extern "C" {
5915 #[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."]
5916 pub fn otCoapSendResponseBlockWiseWithParameters(
5917 aInstance: *mut otInstance,
5918 aMessage: *mut otMessage,
5919 aMessageInfo: *const otMessageInfo,
5920 aTxParameters: *const otCoapTxParameters,
5921 aContext: *mut ::std::os::raw::c_void,
5922 aTransmitHook: otCoapBlockwiseTransmitHook,
5923 ) -> otError;
5924}
5925#[doc = "< Connection established"]
5926pub const OT_COAP_SECURE_CONNECTED: otCoapSecureConnectEvent = 0;
5927#[doc = "< Disconnected by peer"]
5928pub const OT_COAP_SECURE_DISCONNECTED_PEER_CLOSED: otCoapSecureConnectEvent = 1;
5929#[doc = "< Disconnected locally"]
5930pub const OT_COAP_SECURE_DISCONNECTED_LOCAL_CLOSED: otCoapSecureConnectEvent = 2;
5931#[doc = "< Disconnected due to reaching the max connection attempts"]
5932pub const OT_COAP_SECURE_DISCONNECTED_MAX_ATTEMPTS: otCoapSecureConnectEvent = 3;
5933#[doc = "< Disconnected due to an error"]
5934pub const OT_COAP_SECURE_DISCONNECTED_ERROR: otCoapSecureConnectEvent = 4;
5935#[doc = " CoAP secure connection event types."]
5936pub type otCoapSecureConnectEvent = ::std::os::raw::c_uint;
5937#[doc = " Pointer is called when the DTLS connection state changes.\n\n @param[in] aEvent The connection event.\n @param[in] aContext A pointer to arbitrary context information."]
5938pub type otHandleCoapSecureClientConnect = ::std::option::Option<
5939 unsafe extern "C" fn(aEvent: otCoapSecureConnectEvent, aContext: *mut ::std::os::raw::c_void),
5940>;
5941#[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."]
5942pub type otCoapSecureAutoStopCallback =
5943 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
5944extern "C" {
5945 #[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."]
5946 pub fn otCoapSecureStart(aInstance: *mut otInstance, aPort: u16) -> otError;
5947}
5948extern "C" {
5949 #[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."]
5950 pub fn otCoapSecureStartWithMaxConnAttempts(
5951 aInstance: *mut otInstance,
5952 aPort: u16,
5953 aMaxAttempts: u16,
5954 aCallback: otCoapSecureAutoStopCallback,
5955 aContext: *mut ::std::os::raw::c_void,
5956 ) -> otError;
5957}
5958extern "C" {
5959 #[doc = " Stops the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
5960 pub fn otCoapSecureStop(aInstance: *mut otInstance);
5961}
5962extern "C" {
5963 #[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."]
5964 pub fn otCoapSecureSetPsk(
5965 aInstance: *mut otInstance,
5966 aPsk: *const u8,
5967 aPskLength: u16,
5968 aPskIdentity: *const u8,
5969 aPskIdLength: u16,
5970 );
5971}
5972extern "C" {
5973 #[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."]
5974 pub fn otCoapSecureGetPeerCertificateBase64(
5975 aInstance: *mut otInstance,
5976 aPeerCert: *mut ::std::os::raw::c_uchar,
5977 aCertLength: *mut usize,
5978 aCertBufferSize: usize,
5979 ) -> otError;
5980}
5981extern "C" {
5982 #[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."]
5983 pub fn otCoapSecureSetSslAuthMode(aInstance: *mut otInstance, aVerifyPeerCertificate: bool);
5984}
5985extern "C" {
5986 #[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."]
5987 pub fn otCoapSecureSetCertificate(
5988 aInstance: *mut otInstance,
5989 aX509Cert: *const u8,
5990 aX509Length: u32,
5991 aPrivateKey: *const u8,
5992 aPrivateKeyLength: u32,
5993 );
5994}
5995extern "C" {
5996 #[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."]
5997 pub fn otCoapSecureSetCaCertificateChain(
5998 aInstance: *mut otInstance,
5999 aX509CaCertificateChain: *const u8,
6000 aX509CaCertChainLength: u32,
6001 );
6002}
6003extern "C" {
6004 #[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."]
6005 pub fn otCoapSecureConnect(
6006 aInstance: *mut otInstance,
6007 aSockAddr: *const otSockAddr,
6008 aHandler: otHandleCoapSecureClientConnect,
6009 aContext: *mut ::std::os::raw::c_void,
6010 ) -> otError;
6011}
6012extern "C" {
6013 #[doc = " Stops the DTLS connection.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
6014 pub fn otCoapSecureDisconnect(aInstance: *mut otInstance);
6015}
6016extern "C" {
6017 #[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."]
6018 pub fn otCoapSecureIsConnected(aInstance: *mut otInstance) -> bool;
6019}
6020extern "C" {
6021 #[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."]
6022 pub fn otCoapSecureIsConnectionActive(aInstance: *mut otInstance) -> bool;
6023}
6024extern "C" {
6025 #[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."]
6026 pub fn otCoapSecureIsClosed(aInstance: *mut otInstance) -> bool;
6027}
6028extern "C" {
6029 #[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."]
6030 pub fn otCoapSecureSendRequestBlockWise(
6031 aInstance: *mut otInstance,
6032 aMessage: *mut otMessage,
6033 aHandler: otCoapResponseHandler,
6034 aContext: *mut ::std::os::raw::c_void,
6035 aTransmitHook: otCoapBlockwiseTransmitHook,
6036 aReceiveHook: otCoapBlockwiseReceiveHook,
6037 ) -> otError;
6038}
6039extern "C" {
6040 #[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."]
6041 pub fn otCoapSecureSendRequest(
6042 aInstance: *mut otInstance,
6043 aMessage: *mut otMessage,
6044 aHandler: otCoapResponseHandler,
6045 aContext: *mut ::std::os::raw::c_void,
6046 ) -> otError;
6047}
6048extern "C" {
6049 #[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."]
6050 pub fn otCoapSecureAddResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
6051}
6052extern "C" {
6053 #[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."]
6054 pub fn otCoapSecureRemoveResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
6055}
6056extern "C" {
6057 #[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."]
6058 pub fn otCoapSecureAddBlockWiseResource(
6059 aInstance: *mut otInstance,
6060 aResource: *mut otCoapBlockwiseResource,
6061 );
6062}
6063extern "C" {
6064 #[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."]
6065 pub fn otCoapSecureRemoveBlockWiseResource(
6066 aInstance: *mut otInstance,
6067 aResource: *mut otCoapBlockwiseResource,
6068 );
6069}
6070extern "C" {
6071 #[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."]
6072 pub fn otCoapSecureSetDefaultHandler(
6073 aInstance: *mut otInstance,
6074 aHandler: otCoapRequestHandler,
6075 aContext: *mut ::std::os::raw::c_void,
6076 );
6077}
6078extern "C" {
6079 #[doc = " Sets the connect event callback to indicate when\n a Client connection to the CoAP Secure server has changed.\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 has changed.\n @param[in] aContext A pointer to arbitrary context information. May be NULL if not used."]
6080 pub fn otCoapSecureSetClientConnectEventCallback(
6081 aInstance: *mut otInstance,
6082 aHandler: otHandleCoapSecureClientConnect,
6083 aContext: *mut ::std::os::raw::c_void,
6084 );
6085}
6086extern "C" {
6087 #[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."]
6088 pub fn otCoapSecureSendResponseBlockWise(
6089 aInstance: *mut otInstance,
6090 aMessage: *mut otMessage,
6091 aMessageInfo: *const otMessageInfo,
6092 aContext: *mut ::std::os::raw::c_void,
6093 aTransmitHook: otCoapBlockwiseTransmitHook,
6094 ) -> otError;
6095}
6096extern "C" {
6097 #[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."]
6098 pub fn otCoapSecureSendResponse(
6099 aInstance: *mut otInstance,
6100 aMessage: *mut otMessage,
6101 aMessageInfo: *const otMessageInfo,
6102 ) -> otError;
6103}
6104extern "C" {
6105 #[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."]
6106 pub fn otDatasetCreateNewNetwork(
6107 aInstance: *mut otInstance,
6108 aDataset: *mut otOperationalDataset,
6109 ) -> otError;
6110}
6111extern "C" {
6112 #[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)."]
6113 pub fn otDatasetGetDelayTimerMinimal(aInstance: *mut otInstance) -> u32;
6114}
6115extern "C" {
6116 #[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."]
6117 pub fn otDatasetSetDelayTimerMinimal(
6118 aInstance: *mut otInstance,
6119 aDelayTimerMinimal: u32,
6120 ) -> otError;
6121}
6122#[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()`)."]
6123pub type otDatasetUpdaterCallback = ::std::option::Option<
6124 unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
6125>;
6126extern "C" {
6127 #[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 or not fully configured (missing or incomplete Active Dataset).\n @retval OT_ERROR_ALREADY The @p aDataset fields already match the existing Active Dataset.\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."]
6128 pub fn otDatasetUpdaterRequestUpdate(
6129 aInstance: *mut otInstance,
6130 aDataset: *const otOperationalDataset,
6131 aCallback: otDatasetUpdaterCallback,
6132 aContext: *mut ::std::os::raw::c_void,
6133 ) -> otError;
6134}
6135extern "C" {
6136 #[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."]
6137 pub fn otDatasetUpdaterCancelUpdate(aInstance: *mut otInstance);
6138}
6139extern "C" {
6140 #[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."]
6141 pub fn otDatasetUpdaterIsUpdateOngoing(aInstance: *mut otInstance) -> bool;
6142}
6143#[doc = "< Input mode without pull resistor."]
6144pub const OT_GPIO_MODE_INPUT: otGpioMode = 0;
6145#[doc = "< Output mode."]
6146pub const OT_GPIO_MODE_OUTPUT: otGpioMode = 1;
6147#[doc = " Defines the gpio modes."]
6148pub type otGpioMode = ::std::os::raw::c_uint;
6149#[doc = " Pointer to callback to output platform diag messages.\n\n @param[in] aFormat The format string.\n @param[in] aArguments The format string arguments.\n @param[out] aContext A pointer to the user context."]
6150pub type otPlatDiagOutputCallback = ::std::option::Option<
6151 unsafe extern "C" fn(
6152 aFormat: *const ::std::os::raw::c_char,
6153 aArguments: *mut __va_list_tag,
6154 aContext: *mut ::std::os::raw::c_void,
6155 ),
6156>;
6157extern "C" {
6158 #[doc = " Sets the platform diag output callback.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aCallback A pointer to a function that is called on outputting diag messages.\n @param[in] aContext A pointer to the user context."]
6159 pub fn otPlatDiagSetOutputCallback(
6160 aInstance: *mut otInstance,
6161 aCallback: otPlatDiagOutputCallback,
6162 aContext: *mut ::std::os::raw::c_void,
6163 );
6164}
6165extern "C" {
6166 #[doc = " Processes a factory diagnostics command line.\n\n @param[in] aInstance The OpenThread instance for current request.\n @param[in] aArgsLength The number of arguments in @p aArgs.\n @param[in] aArgs The arguments of diagnostics command line.\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_INVALID_COMMAND The command is not valid or not supported."]
6167 pub fn otPlatDiagProcess(
6168 aInstance: *mut otInstance,
6169 aArgsLength: u8,
6170 aArgs: *mut *mut ::std::os::raw::c_char,
6171 ) -> otError;
6172}
6173extern "C" {
6174 #[doc = " Enables/disables the factory diagnostics mode.\n\n @param[in] aMode TRUE to enable diagnostics mode, FALSE otherwise."]
6175 pub fn otPlatDiagModeSet(aMode: bool);
6176}
6177extern "C" {
6178 #[doc = " Indicates whether or not factory diagnostics mode is enabled.\n\n @returns TRUE if factory diagnostics mode is enabled, FALSE otherwise."]
6179 pub fn otPlatDiagModeGet() -> bool;
6180}
6181extern "C" {
6182 #[doc = " Sets the channel to use for factory diagnostics.\n\n @param[in] aChannel The channel value."]
6183 pub fn otPlatDiagChannelSet(aChannel: u8);
6184}
6185extern "C" {
6186 #[doc = " Sets the transmit power to use for factory diagnostics.\n\n @param[in] aTxPower The transmit power value."]
6187 pub fn otPlatDiagTxPowerSet(aTxPower: i8);
6188}
6189extern "C" {
6190 #[doc = " Processes the received radio frame.\n\n @param[in] aInstance The OpenThread instance for current request.\n @param[in] aFrame The received radio frame.\n @param[in] aError The received radio frame status."]
6191 pub fn otPlatDiagRadioReceived(
6192 aInstance: *mut otInstance,
6193 aFrame: *mut otRadioFrame,
6194 aError: otError,
6195 );
6196}
6197extern "C" {
6198 #[doc = " Processes the alarm event.\n\n @param[in] aInstance The OpenThread instance for current request."]
6199 pub fn otPlatDiagAlarmCallback(aInstance: *mut otInstance);
6200}
6201extern "C" {
6202 #[doc = " Sets the gpio value.\n\n @param[in] aGpio The gpio number.\n @param[in] aValue true to set the gpio to high level, or false otherwise.\n\n @retval OT_ERROR_NONE Successfully set the gpio.\n @retval OT_ERROR_FAILED A platform error occurred while setting the gpio.\n @retval OT_ERROR_INVALID_ARGS @p aGpio is not supported.\n @retval OT_ERROR_INVALID_STATE Diagnostic mode was not enabled or @p aGpio is not configured as output.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented or configured on the platform."]
6203 pub fn otPlatDiagGpioSet(aGpio: u32, aValue: bool) -> otError;
6204}
6205extern "C" {
6206 #[doc = " Gets the gpio value.\n\n @param[in] aGpio The gpio number.\n @param[out] aValue A pointer where to put gpio value.\n\n @retval OT_ERROR_NONE Successfully got the gpio value.\n @retval OT_ERROR_FAILED A platform error occurred while getting the gpio value.\n @retval OT_ERROR_INVALID_ARGS @p aGpio is not supported or @p aValue is NULL.\n @retval OT_ERROR_INVALID_STATE Diagnostic mode was not enabled or @p aGpio is not configured as input.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented or configured on the platform."]
6207 pub fn otPlatDiagGpioGet(aGpio: u32, aValue: *mut bool) -> otError;
6208}
6209extern "C" {
6210 #[doc = " Sets the gpio mode.\n\n @param[in] aGpio The gpio number.\n @param[out] aMode The gpio mode.\n\n @retval OT_ERROR_NONE Successfully set the gpio mode.\n @retval OT_ERROR_FAILED A platform error occurred while setting the gpio mode.\n @retval OT_ERROR_INVALID_ARGS @p aGpio or @p aMode is not supported.\n @retval OT_ERROR_INVALID_STATE Diagnostic mode was not enabled.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented or configured on the platform."]
6211 pub fn otPlatDiagGpioSetMode(aGpio: u32, aMode: otGpioMode) -> otError;
6212}
6213extern "C" {
6214 #[doc = " Gets the gpio mode.\n\n @param[in] aGpio The gpio number.\n @param[out] aMode A pointer where to put gpio mode.\n\n @retval OT_ERROR_NONE Successfully got the gpio mode.\n @retval OT_ERROR_FAILED Mode returned by the platform is not implemented in OpenThread or a platform error\n occurred while getting the gpio mode.\n @retval OT_ERROR_INVALID_ARGS @p aGpio is not supported or @p aMode is NULL.\n @retval OT_ERROR_INVALID_STATE Diagnostic mode was not enabled.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented or configured on the platform."]
6215 pub fn otPlatDiagGpioGetMode(aGpio: u32, aMode: *mut otGpioMode) -> otError;
6216}
6217extern "C" {
6218 #[doc = " Set the radio raw power setting for diagnostics module.\n\n @param[in] aInstance The OpenThread instance structure.\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 set the raw power setting.\n @retval OT_ERROR_INVALID_ARGS The @p aRawPowerSetting is NULL or the @p aRawPowerSettingLength is too long.\n @retval OT_ERROR_NOT_IMPLEMENTED This method is not implemented."]
6219 pub fn otPlatDiagRadioSetRawPowerSetting(
6220 aInstance: *mut otInstance,
6221 aRawPowerSetting: *const u8,
6222 aRawPowerSettingLength: u16,
6223 ) -> otError;
6224}
6225extern "C" {
6226 #[doc = " Get the radio raw power setting for diagnostics module.\n\n @param[in] aInstance The OpenThread instance structure.\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 set the raw power setting.\n @retval OT_ERROR_INVALID_ARGS The @p aRawPowerSetting or @p aRawPowerSettingLength is NULL or\n @aRawPowerSettingLength is too short.\n @retval OT_ERROR_NOT_FOUND The raw power setting is not set.\n @retval OT_ERROR_NOT_IMPLEMENTED This method is not implemented."]
6227 pub fn otPlatDiagRadioGetRawPowerSetting(
6228 aInstance: *mut otInstance,
6229 aRawPowerSetting: *mut u8,
6230 aRawPowerSettingLength: *mut u16,
6231 ) -> otError;
6232}
6233extern "C" {
6234 #[doc = " Enable/disable the platform layer to use the raw power setting set by `otPlatDiagRadioSetRawPowerSetting()`.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aEnable TRUE to enable or FALSE to disable the raw power setting.\n\n @retval OT_ERROR_NONE Successfully enabled/disabled the raw power setting.\n @retval OT_ERROR_NOT_IMPLEMENTED This method is not implemented."]
6235 pub fn otPlatDiagRadioRawPowerSettingEnable(
6236 aInstance: *mut otInstance,
6237 aEnable: bool,
6238 ) -> otError;
6239}
6240extern "C" {
6241 #[doc = " Start/stop the platform layer to transmit continuous carrier wave.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aEnable TRUE to enable or FALSE to disable the platform layer to transmit continuous carrier wave.\n\n @retval OT_ERROR_NONE Successfully enabled/disabled .\n @retval OT_ERROR_INVALID_STATE The radio was not in the Receive state.\n @retval OT_ERROR_NOT_IMPLEMENTED This method is not implemented."]
6242 pub fn otPlatDiagRadioTransmitCarrier(aInstance: *mut otInstance, aEnable: bool) -> otError;
6243}
6244extern "C" {
6245 #[doc = " Start/stop the platform layer to transmit stream of characters.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aEnable TRUE to enable or FALSE to disable the platform layer to transmit stream.\n\n @retval OT_ERROR_NONE Successfully enabled/disabled.\n @retval OT_ERROR_INVALID_STATE The radio was not in the Receive state.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented."]
6246 pub fn otPlatDiagRadioTransmitStream(aInstance: *mut otInstance, aEnable: bool) -> otError;
6247}
6248extern "C" {
6249 #[doc = " Get the power settings for the given channel.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aChannel The radio channel.\n @param[out] aTargetPower The target power in 0.01 dBm.\n @param[out] aActualPower The actual power in 0.01 dBm.\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, @aTargetPower, @p aActualPower, @p aRawPowerSetting or\n @p aRawPowerSettingLength is NULL or @aRawPowerSettingLength is too short.\n @retval OT_ERROR_NOT_FOUND The power settings for the @p aChannel was not found.\n @retval OT_ERROR_NOT_IMPLEMENTED This method is not implemented."]
6250 pub fn otPlatDiagRadioGetPowerSettings(
6251 aInstance: *mut otInstance,
6252 aChannel: u8,
6253 aTargetPower: *mut i16,
6254 aActualPower: *mut i16,
6255 aRawPowerSetting: *mut u8,
6256 aRawPowerSettingLength: *mut u16,
6257 ) -> otError;
6258}
6259#[doc = " @addtogroup api-factory-diagnostics\n\n @brief\n This module includes functions that control the Thread stack's execution.\n\n @{"]
6260pub type otDiagOutputCallback = otPlatDiagOutputCallback;
6261extern "C" {
6262 #[doc = " Sets the diag output callback.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aCallback A pointer to a function that is called on outputting diag messages.\n @param[in] aContext A pointer to the user context."]
6263 pub fn otDiagSetOutputCallback(
6264 aInstance: *mut otInstance,
6265 aCallback: otDiagOutputCallback,
6266 aContext: *mut ::std::os::raw::c_void,
6267 );
6268}
6269extern "C" {
6270 #[doc = " Processes a factory diagnostics command line.\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\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."]
6271 pub fn otDiagProcessCmd(
6272 aInstance: *mut otInstance,
6273 aArgsLength: u8,
6274 aArgs: *mut *mut ::std::os::raw::c_char,
6275 ) -> otError;
6276}
6277extern "C" {
6278 #[doc = " Processes a factory diagnostics command line.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aString A NULL-terminated input string.\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."]
6279 pub fn otDiagProcessCmdLine(
6280 aInstance: *mut otInstance,
6281 aString: *const ::std::os::raw::c_char,
6282 ) -> otError;
6283}
6284extern "C" {
6285 #[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."]
6286 pub fn otDiagIsEnabled(aInstance: *mut otInstance) -> bool;
6287}
6288#[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)."]
6289#[repr(C)]
6290#[derive(Debug, Copy, Clone)]
6291pub struct otDnsTxtEntry {
6292 #[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."]
6293 pub mKey: *const ::std::os::raw::c_char,
6294 #[doc = "< The TXT record value or already encoded TXT-DATA (depending on `mKey`)."]
6295 pub mValue: *const u8,
6296 #[doc = "< Number of bytes in `mValue` buffer."]
6297 pub mValueLength: u16,
6298}
6299impl Default for otDnsTxtEntry {
6300 fn default() -> Self {
6301 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6302 unsafe {
6303 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6304 s.assume_init()
6305 }
6306 }
6307}
6308#[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."]
6309#[repr(C)]
6310#[derive(Debug, Copy, Clone)]
6311pub struct otDnsTxtEntryIterator {
6312 pub mPtr: *const ::std::os::raw::c_void,
6313 pub mData: [u16; 2usize],
6314 pub mChar: [::std::os::raw::c_char; 65usize],
6315}
6316impl Default for otDnsTxtEntryIterator {
6317 fn default() -> Self {
6318 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6319 unsafe {
6320 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6321 s.assume_init()
6322 }
6323 }
6324}
6325extern "C" {
6326 #[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."]
6327 pub fn otDnsInitTxtEntryIterator(
6328 aIterator: *mut otDnsTxtEntryIterator,
6329 aTxtData: *const u8,
6330 aTxtDataLength: u16,
6331 );
6332}
6333extern "C" {
6334 #[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."]
6335 pub fn otDnsGetNextTxtEntry(
6336 aIterator: *mut otDnsTxtEntryIterator,
6337 aEntry: *mut otDnsTxtEntry,
6338 ) -> otError;
6339}
6340extern "C" {
6341 #[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."]
6342 pub fn otDnsEncodeTxtData(
6343 aTxtEntries: *const otDnsTxtEntry,
6344 aNumTxtEntries: u16,
6345 aTxtData: *mut u8,
6346 aTxtDataLength: *mut u16,
6347 ) -> otError;
6348}
6349extern "C" {
6350 #[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."]
6351 pub fn otDnsSetNameCompressionEnabled(aEnabled: bool);
6352}
6353extern "C" {
6354 #[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."]
6355 pub fn otDnsIsNameCompressionEnabled() -> bool;
6356}
6357#[doc = "< Indicates the flag is not specified."]
6358pub const OT_DNS_FLAG_UNSPECIFIED: otDnsRecursionFlag = 0;
6359#[doc = "< Indicates DNS name server can resolve the query recursively."]
6360pub const OT_DNS_FLAG_RECURSION_DESIRED: otDnsRecursionFlag = 1;
6361#[doc = "< Indicates DNS name server can not resolve the query recursively."]
6362pub const OT_DNS_FLAG_NO_RECURSION: otDnsRecursionFlag = 2;
6363#[doc = " Type represents the \"Recursion Desired\" (RD) flag in an `otDnsQueryConfig`."]
6364pub type otDnsRecursionFlag = ::std::os::raw::c_uint;
6365#[doc = "< NAT64 mode is not specified. Use default NAT64 mode."]
6366pub const OT_DNS_NAT64_UNSPECIFIED: otDnsNat64Mode = 0;
6367#[doc = "< Allow NAT64 address translation during DNS client address resolution."]
6368pub const OT_DNS_NAT64_ALLOW: otDnsNat64Mode = 1;
6369#[doc = "< Do not allow NAT64 address translation during DNS client address resolution."]
6370pub const OT_DNS_NAT64_DISALLOW: otDnsNat64Mode = 2;
6371#[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."]
6372pub type otDnsNat64Mode = ::std::os::raw::c_uint;
6373#[doc = "< Mode is not specified. Use default service mode."]
6374pub const OT_DNS_SERVICE_MODE_UNSPECIFIED: otDnsServiceMode = 0;
6375#[doc = "< Query for SRV record only."]
6376pub const OT_DNS_SERVICE_MODE_SRV: otDnsServiceMode = 1;
6377#[doc = "< Query for TXT record only."]
6378pub const OT_DNS_SERVICE_MODE_TXT: otDnsServiceMode = 2;
6379#[doc = "< Query for both SRV and TXT records in same message."]
6380pub const OT_DNS_SERVICE_MODE_SRV_TXT: otDnsServiceMode = 3;
6381#[doc = "< Query in parallel for SRV and TXT using separate messages."]
6382pub const OT_DNS_SERVICE_MODE_SRV_TXT_SEPARATE: otDnsServiceMode = 4;
6383#[doc = "< Query for TXT/SRV together first, if fails then query separately."]
6384pub const OT_DNS_SERVICE_MODE_SRV_TXT_OPTIMIZE: otDnsServiceMode = 5;
6385#[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."]
6386pub type otDnsServiceMode = ::std::os::raw::c_uint;
6387pub const OT_DNS_TRANSPORT_UNSPECIFIED: otDnsTransportProto = 0;
6388#[doc = " DNS transport is unspecified."]
6389pub const OT_DNS_TRANSPORT_UDP: otDnsTransportProto = 1;
6390#[doc = " DNS query should be sent via UDP."]
6391pub const OT_DNS_TRANSPORT_TCP: otDnsTransportProto = 2;
6392#[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."]
6393pub type otDnsTransportProto = ::std::os::raw::c_uint;
6394#[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`."]
6395#[repr(C)]
6396#[derive(Copy, Clone)]
6397pub struct otDnsQueryConfig {
6398 #[doc = "< Server address (IPv6 addr/port). All zero or zero port for unspecified."]
6399 pub mServerSockAddr: otSockAddr,
6400 #[doc = "< Wait time (in msec) to rx response. Zero indicates unspecified value."]
6401 pub mResponseTimeout: u32,
6402 #[doc = "< Maximum tx attempts before reporting failure. Zero for unspecified value."]
6403 pub mMaxTxAttempts: u8,
6404 #[doc = "< Indicates whether the server can resolve the query recursively or not."]
6405 pub mRecursionFlag: otDnsRecursionFlag,
6406 #[doc = "< Allow/Disallow NAT64 address translation during address resolution."]
6407 pub mNat64Mode: otDnsNat64Mode,
6408 #[doc = "< Determines which records to query during service resolution."]
6409 pub mServiceMode: otDnsServiceMode,
6410 #[doc = "< Select default transport protocol."]
6411 pub mTransportProto: otDnsTransportProto,
6412}
6413impl Default for otDnsQueryConfig {
6414 fn default() -> Self {
6415 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6416 unsafe {
6417 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6418 s.assume_init()
6419 }
6420 }
6421}
6422extern "C" {
6423 #[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."]
6424 pub fn otDnsClientGetDefaultConfig(aInstance: *mut otInstance) -> *const otDnsQueryConfig;
6425}
6426extern "C" {
6427 #[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."]
6428 pub fn otDnsClientSetDefaultConfig(
6429 aInstance: *mut otInstance,
6430 aConfig: *const otDnsQueryConfig,
6431 );
6432}
6433#[repr(C)]
6434#[derive(Debug, Copy, Clone)]
6435pub struct otDnsAddressResponse {
6436 _unused: [u8; 0],
6437}
6438#[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"]
6439pub type otDnsAddressCallback = ::std::option::Option<
6440 unsafe extern "C" fn(
6441 aError: otError,
6442 aResponse: *const otDnsAddressResponse,
6443 aContext: *mut ::std::os::raw::c_void,
6444 ),
6445>;
6446extern "C" {
6447 #[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."]
6448 pub fn otDnsClientResolveAddress(
6449 aInstance: *mut otInstance,
6450 aHostName: *const ::std::os::raw::c_char,
6451 aCallback: otDnsAddressCallback,
6452 aContext: *mut ::std::os::raw::c_void,
6453 aConfig: *const otDnsQueryConfig,
6454 ) -> otError;
6455}
6456extern "C" {
6457 #[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."]
6458 pub fn otDnsClientResolveIp4Address(
6459 aInstance: *mut otInstance,
6460 aHostName: *const ::std::os::raw::c_char,
6461 aCallback: otDnsAddressCallback,
6462 aContext: *mut ::std::os::raw::c_void,
6463 aConfig: *const otDnsQueryConfig,
6464 ) -> otError;
6465}
6466extern "C" {
6467 #[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."]
6468 pub fn otDnsAddressResponseGetHostName(
6469 aResponse: *const otDnsAddressResponse,
6470 aNameBuffer: *mut ::std::os::raw::c_char,
6471 aNameBufferSize: u16,
6472 ) -> otError;
6473}
6474extern "C" {
6475 #[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)."]
6476 pub fn otDnsAddressResponseGetAddress(
6477 aResponse: *const otDnsAddressResponse,
6478 aIndex: u16,
6479 aAddress: *mut otIp6Address,
6480 aTtl: *mut u32,
6481 ) -> otError;
6482}
6483#[repr(C)]
6484#[derive(Debug, Copy, Clone)]
6485pub struct otDnsBrowseResponse {
6486 _unused: [u8; 0],
6487}
6488#[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()`."]
6489pub type otDnsBrowseCallback = ::std::option::Option<
6490 unsafe extern "C" fn(
6491 aError: otError,
6492 aResponse: *const otDnsBrowseResponse,
6493 aContext: *mut ::std::os::raw::c_void,
6494 ),
6495>;
6496#[doc = " Provides info for a DNS service instance."]
6497#[repr(C)]
6498#[derive(Copy, Clone)]
6499pub struct otDnsServiceInfo {
6500 #[doc = "< Service record TTL (in seconds)."]
6501 pub mTtl: u32,
6502 #[doc = "< Service port number."]
6503 pub mPort: u16,
6504 #[doc = "< Service priority."]
6505 pub mPriority: u16,
6506 #[doc = "< Service weight."]
6507 pub mWeight: u16,
6508 #[doc = "< Buffer to output the service host name (can be NULL if not needed)."]
6509 pub mHostNameBuffer: *mut ::std::os::raw::c_char,
6510 #[doc = "< Size of `mHostNameBuffer`."]
6511 pub mHostNameBufferSize: u16,
6512 #[doc = "< The host IPv6 address. Set to all zero if not available."]
6513 pub mHostAddress: otIp6Address,
6514 #[doc = "< The host address TTL."]
6515 pub mHostAddressTtl: u32,
6516 #[doc = "< Buffer to output TXT data (can be NULL if not needed)."]
6517 pub mTxtData: *mut u8,
6518 #[doc = "< On input, size of `mTxtData` buffer. On output number bytes written."]
6519 pub mTxtDataSize: u16,
6520 #[doc = "< Indicates if TXT data could not fit in `mTxtDataSize` and was truncated."]
6521 pub mTxtDataTruncated: bool,
6522 #[doc = "< The TXT data TTL."]
6523 pub mTxtDataTtl: u32,
6524}
6525impl Default for otDnsServiceInfo {
6526 fn default() -> Self {
6527 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6528 unsafe {
6529 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6530 s.assume_init()
6531 }
6532 }
6533}
6534extern "C" {
6535 #[doc = " Sends a DNS browse (service instance enumeration) query for a given service name.\n\n Is available when `OPENTHREAD_CONFIG_DNS_CLIENT_SERVICE_DISCOVERY_ENABLE` is enabled.\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] aServiceName The service name to query for (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."]
6536 pub fn otDnsClientBrowse(
6537 aInstance: *mut otInstance,
6538 aServiceName: *const ::std::os::raw::c_char,
6539 aCallback: otDnsBrowseCallback,
6540 aContext: *mut ::std::os::raw::c_void,
6541 aConfig: *const otDnsQueryConfig,
6542 ) -> otError;
6543}
6544extern "C" {
6545 #[doc = " Gets the service name associated with a DNS browse (service instance enumeration) response.\n\n MUST only be used from `otDnsBrowseCallback`.\n\n @param[in] aResponse A pointer to the response.\n @param[out] aNameBuffer A buffer to char array to output the service name (MUST NOT be NULL).\n @param[in] aNameBufferSize The size of @p aNameBuffer.\n\n @retval OT_ERROR_NONE The service name was read successfully.\n @retval OT_ERROR_NO_BUFS The name does not fit in @p aNameBuffer."]
6546 pub fn otDnsBrowseResponseGetServiceName(
6547 aResponse: *const otDnsBrowseResponse,
6548 aNameBuffer: *mut ::std::os::raw::c_char,
6549 aNameBufferSize: u16,
6550 ) -> otError;
6551}
6552extern "C" {
6553 #[doc = " Gets a service instance associated with a DNS browse (service instance enumeration) response.\n\n MUST only be used from `otDnsBrowseCallback`.\n\n The response may include multiple service instance records. @p aIndex can be used to iterate through the list. Index\n zero gives the first record. When we reach end of the list, `OT_ERROR_NOT_FOUND` is returned.\n\n Note that this function gets the service instance label and not the full service instance name which is of the form\n `<Instance>.<Service>.<Domain>`.\n\n @param[in] aResponse A pointer to the response.\n @param[in] aIndex The service instance record index to retrieve.\n @param[out] aLabelBuffer A buffer to char array to output the service instance label (MUST NOT be NULL).\n @param[in] aLabelBufferSize The size of @p aLabelBuffer.\n\n @retval OT_ERROR_NONE The service instance was read successfully.\n @retval OT_ERROR_NO_BUFS The name does not fit in @p aNameBuffer.\n @retval OT_ERROR_NOT_FOUND No service instance record in @p aResponse at @p aIndex.\n @retval OT_ERROR_PARSE Could not parse the records in the @p aResponse."]
6554 pub fn otDnsBrowseResponseGetServiceInstance(
6555 aResponse: *const otDnsBrowseResponse,
6556 aIndex: u16,
6557 aLabelBuffer: *mut ::std::os::raw::c_char,
6558 aLabelBufferSize: u8,
6559 ) -> otError;
6560}
6561extern "C" {
6562 #[doc = " Gets info for a service instance from a DNS browse (service instance enumeration) response.\n\n MUST only be used from `otDnsBrowseCallback`.\n\n A browse DNS response can include SRV, TXT, and AAAA records for the service instances that are enumerated. This is\n a SHOULD and not a MUST requirement, and servers/resolvers are not required to provide this. This function attempts\n to retrieve this info for a given service instance when available.\n\n - If no matching SRV record is found in @p aResponse, `OT_ERROR_NOT_FOUND` is returned. In this case, no additional\n records (no TXT and/or AAAA) are read.\n - If a matching SRV record is found in @p aResponse, @p aServiceInfo is updated and `OT_ERROR_NONE` is returned.\n - If no matching TXT record is found in @p aResponse, `mTxtDataSize` in @p aServiceInfo is set to zero.\n - If TXT data length is greater than `mTxtDataSize`, it is read partially and `mTxtDataTruncated` is set to true.\n - If no matching AAAA record is found in @p aResponse, `mHostAddress is set to all zero or unspecified address.\n - If there are multiple AAAA records for the host name in @p aResponse, `mHostAddress` is set to the first one. The\n other addresses can be retrieved using `otDnsBrowseResponseGetHostAddress()`.\n\n @param[in] aResponse A pointer to the response.\n @param[in] aInstanceLabel The service instance label (MUST NOT be NULL).\n @param[out] aServiceInfo A `ServiceInfo` to output the service instance information (MUST NOT be NULL).\n\n @retval OT_ERROR_NONE The service instance info was read. @p aServiceInfo is updated.\n @retval OT_ERROR_NOT_FOUND Could not find a matching SRV record for @p aInstanceLabel.\n @retval OT_ERROR_NO_BUFS The host name and/or TXT data could not fit in the given buffers.\n @retval OT_ERROR_PARSE Could not parse the records in the @p aResponse."]
6563 pub fn otDnsBrowseResponseGetServiceInfo(
6564 aResponse: *const otDnsBrowseResponse,
6565 aInstanceLabel: *const ::std::os::raw::c_char,
6566 aServiceInfo: *mut otDnsServiceInfo,
6567 ) -> otError;
6568}
6569extern "C" {
6570 #[doc = " Gets the host IPv6 address from a DNS browse (service instance enumeration) response.\n\n MUST only be used from `otDnsBrowseCallback`.\n\n The response can include zero or more 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] aHostName The host name to get the address (MUST NOT be NULL).\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\n not 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 for @p aHostname in @p aResponse at @p aIndex.\n @retval OT_ERROR_PARSE Could not parse the records in the @p aResponse."]
6571 pub fn otDnsBrowseResponseGetHostAddress(
6572 aResponse: *const otDnsBrowseResponse,
6573 aHostName: *const ::std::os::raw::c_char,
6574 aIndex: u16,
6575 aAddress: *mut otIp6Address,
6576 aTtl: *mut u32,
6577 ) -> otError;
6578}
6579#[repr(C)]
6580#[derive(Debug, Copy, Clone)]
6581pub struct otDnsServiceResponse {
6582 _unused: [u8; 0],
6583}
6584#[doc = " Pointer is called when a DNS response is received for a service instance resolution query.\n\n Within this callback the user can use `otDnsServiceResponseGet{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()`."]
6585pub type otDnsServiceCallback = ::std::option::Option<
6586 unsafe extern "C" fn(
6587 aError: otError,
6588 aResponse: *const otDnsServiceResponse,
6589 aContext: *mut ::std::os::raw::c_void,
6590 ),
6591>;
6592extern "C" {
6593 #[doc = " Starts a DNS service instance resolution for a given service instance.\n\n Is available when `OPENTHREAD_CONFIG_DNS_CLIENT_SERVICE_DISCOVERY_ENABLE` is enabled.\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 The function sends queries for SRV and/or TXT records for the given service instance. The `mServiceMode` field in\n `otDnsQueryConfig` determines which records to query (SRV only, TXT only, or both SRV and TXT) and how to perform\n the query (together in the same message, separately in parallel, or in optimized mode where client will try in the\n same message first and then separately if it fails to get a response).\n\n The SRV record provides information about service port, priority, and weight along with the host name associated\n with the service instance. This function DOES NOT perform address resolution for the host name discovered from SRV\n record. The server/resolver may provide AAAA/A record(s) for the host name in the Additional Data section of the\n response to SRV/TXT query and this information can be retrieved using `otDnsServiceResponseGetServiceInfo()` in\n `otDnsServiceCallback`. Users of this API MUST NOT assume that host address will always be available from\n `otDnsServiceResponseGetServiceInfo()`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aInstanceLabel The service instance label.\n @param[in] aServiceName The service name (together with @p aInstanceLabel form full instance name).\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 @p aInstanceLabel is NULL."]
6594 pub fn otDnsClientResolveService(
6595 aInstance: *mut otInstance,
6596 aInstanceLabel: *const ::std::os::raw::c_char,
6597 aServiceName: *const ::std::os::raw::c_char,
6598 aCallback: otDnsServiceCallback,
6599 aContext: *mut ::std::os::raw::c_void,
6600 aConfig: *const otDnsQueryConfig,
6601 ) -> otError;
6602}
6603extern "C" {
6604 #[doc = " Starts a DNS service instance resolution for a given service instance, with a potential follow-up\n address resolution for the host name discovered for the service instance.\n\n Is available when `OPENTHREAD_CONFIG_DNS_CLIENT_SERVICE_DISCOVERY_ENABLE` is enabled.\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. This function cannot be used with\n `mServiceMode` in DNS config set to `OT_DNS_SERVICE_MODE_TXT` (i.e., querying for TXT record only) and will return\n `OT_ERROR_INVALID_ARGS`.\n\n Behaves similarly to `otDnsClientResolveService()` sending queries for SRV and TXT records. However,\n if the server/resolver does not provide AAAA/A records for the host name in the response to SRV query (in the\n Additional Data section), it will perform host name resolution (sending an AAAA query) for the discovered host name\n from the SRV record. The callback @p aCallback is invoked when responses for all queries are received (i.e., both\n service and host address resolutions are finished).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aInstanceLabel The service instance label.\n @param[in] aServiceName The service name (together with @p aInstanceLabel form full instance name).\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 @p aInstanceLabel is NULL, or @p aConfig is invalid."]
6605 pub fn otDnsClientResolveServiceAndHostAddress(
6606 aInstance: *mut otInstance,
6607 aInstanceLabel: *const ::std::os::raw::c_char,
6608 aServiceName: *const ::std::os::raw::c_char,
6609 aCallback: otDnsServiceCallback,
6610 aContext: *mut ::std::os::raw::c_void,
6611 aConfig: *const otDnsQueryConfig,
6612 ) -> otError;
6613}
6614extern "C" {
6615 #[doc = " Gets the service instance name associated with a DNS service instance resolution response.\n\n MUST only be used from `otDnsServiceCallback`.\n\n @param[in] aResponse A pointer to the response.\n @param[out] aLabelBuffer A buffer to char array to output the service instance label (MUST NOT be NULL).\n @param[in] aLabelBufferSize The size of @p aLabelBuffer.\n @param[out] aNameBuffer A buffer to char array to output the rest of service name (can be NULL if user is\n not interested in getting the name.\n @param[in] aNameBufferSize The size of @p aNameBuffer.\n\n @retval OT_ERROR_NONE The service name was read successfully.\n @retval OT_ERROR_NO_BUFS Either the label or name does not fit in the given buffers."]
6616 pub fn otDnsServiceResponseGetServiceName(
6617 aResponse: *const otDnsServiceResponse,
6618 aLabelBuffer: *mut ::std::os::raw::c_char,
6619 aLabelBufferSize: u8,
6620 aNameBuffer: *mut ::std::os::raw::c_char,
6621 aNameBufferSize: u16,
6622 ) -> otError;
6623}
6624extern "C" {
6625 #[doc = " Gets info for a service instance from a DNS service instance resolution response.\n\n MUST only be used from a `otDnsServiceCallback` triggered from `otDnsClientResolveService()` or\n `otDnsClientResolveServiceAndHostAddress()`.\n\n When this is is used from a `otDnsClientResolveService()` callback, the DNS response from server/resolver may\n include AAAA records in its Additional Data section for the host name associated with the service instance that is\n resolved. This is a SHOULD and not a MUST requirement so servers/resolvers are not required to provide this. This\n function attempts to parse AAAA record(s) if included in the response. If it is not included `mHostAddress` is set\n to all zeros (unspecified address). To also resolve the host address, user can use the DNS client API function\n `otDnsClientResolveServiceAndHostAddress()` which will perform service resolution followed up by a host name\n address resolution query (when AAAA records are not provided by server/resolver in the SRV query response).\n\n - If a matching SRV record is found in @p aResponse, @p aServiceInfo is updated.\n - If no matching SRV record is found, `OT_ERROR_NOT_FOUND` is returned unless the query config for this query\n used `OT_DNS_SERVICE_MODE_TXT` for `mServiceMode` (meaning the request was only for TXT record). In this case, we\n still try to parse the SRV record from Additional Data Section of response (in case server provided the info).\n - If no matching TXT record is found in @p aResponse, `mTxtDataSize` in @p aServiceInfo is set to zero.\n - If TXT data length is greater than `mTxtDataSize`, it is read partially and `mTxtDataTruncated` is set to true.\n - If no matching AAAA record is found in @p aResponse, `mHostAddress is set to all zero or unspecified address.\n - If there are multiple AAAA records for the host name in @p aResponse, `mHostAddress` is set to the first one. The\n other addresses can be retrieved using `otDnsServiceResponseGetHostAddress()`.\n\n @param[in] aResponse A pointer to the response.\n @param[out] aServiceInfo A `ServiceInfo` to output the service instance information (MUST NOT be NULL).\n\n @retval OT_ERROR_NONE The service instance info was read. @p aServiceInfo is updated.\n @retval OT_ERROR_NOT_FOUND Could not find a required record in @p aResponse.\n @retval OT_ERROR_NO_BUFS The host name and/or TXT data could not fit in the given buffers.\n @retval OT_ERROR_PARSE Could not parse the records in the @p aResponse."]
6626 pub fn otDnsServiceResponseGetServiceInfo(
6627 aResponse: *const otDnsServiceResponse,
6628 aServiceInfo: *mut otDnsServiceInfo,
6629 ) -> otError;
6630}
6631extern "C" {
6632 #[doc = " Gets the host IPv6 address from a DNS service instance resolution response.\n\n MUST only be used from `otDnsServiceCallback`.\n\n The response can include zero or more 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] aHostName The host name to get the address (MUST NOT be NULL).\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\n not 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 for @p aHostname in @p aResponse at @p aIndex.\n @retval OT_ERROR_PARSE Could not parse the records in the @p aResponse."]
6633 pub fn otDnsServiceResponseGetHostAddress(
6634 aResponse: *const otDnsServiceResponse,
6635 aHostName: *const ::std::os::raw::c_char,
6636 aIndex: u16,
6637 aAddress: *mut otIp6Address,
6638 aTtl: *mut u32,
6639 ) -> otError;
6640}
6641#[doc = " Is called when a DNS-SD query subscribes one of:\n 1. a service name.\n 2. a service instance name.\n 3. a host name.\n\n The DNS-SD query implementation is responsible for identifying what @p aFullName is.\n If @p aFullName is a service name or service instance name, the DNS-SD query implementation should discover\n corresponding service instance information and notify the DNS-SD server using\n `otDnssdQueryHandleDiscoveredServiceInstance`.\n If @p aFullName is a host name, the DNS-SD query implementation should\n discover the host information and notify the DNS-SD server using `otDnssdQueryHandleDiscoveredHost`.\n\n @note There can be multiple subscription to the same name. DNS-SD query implementation should record the number of\n active subscriptions and stop notifying when there is no active subscription for @p aFullName.\n\n @param[in] aContext A pointer to the application-specific context.\n @param[in] aFullName The null-terminated full service name (e.g. \"_ipps._tcp.default.service.arpa.\"),\n or full service instance name (e.g. \"OpenThread._ipps._tcp.default.service.arpa.\"),\n or full host name (e.g. \"ot-host.default.service.arpa.\").\n\n @sa otDnssdQueryHandleDiscoveredServiceInstance\n @sa otDnssdQueryHandleDiscoveredHost"]
6642pub type otDnssdQuerySubscribeCallback = ::std::option::Option<
6643 unsafe extern "C" fn(
6644 aContext: *mut ::std::os::raw::c_void,
6645 aFullName: *const ::std::os::raw::c_char,
6646 ),
6647>;
6648#[doc = " Is called when a DNS-SD query unsubscribes one of:\n 1. a service name.\n 2. a service instance name.\n 3. a host name.\n\n The DNS-SD query implementation is responsible for identifying what @p aFullName is.\n\n @note There can be multiple subscription to the same name. DNS-SD query implementation should record the number of\n active subscriptions and stop notifying when there is no active subscription for @p aFullName.\n\n @param[in] aContext A pointer to the application-specific context.\n @param[in] aFullName The null-terminated full service name (e.g. \"_ipps._tcp.default.service.arpa.\"), or\n full service instance name (e.g. \"OpenThread._ipps._tcp.default.service.arpa.\")."]
6649pub type otDnssdQueryUnsubscribeCallback = ::std::option::Option<
6650 unsafe extern "C" fn(
6651 aContext: *mut ::std::os::raw::c_void,
6652 aFullName: *const ::std::os::raw::c_char,
6653 ),
6654>;
6655#[doc = " This opaque type represents a DNS-SD query."]
6656pub type otDnssdQuery = ::std::os::raw::c_void;
6657#[doc = " Represents information of a discovered service instance for a DNS-SD query."]
6658#[repr(C)]
6659#[derive(Debug, Copy, Clone)]
6660pub struct otDnssdServiceInstanceInfo {
6661 #[doc = "< Full instance name (e.g. \"OpenThread._ipps._tcp.default.service.arpa.\")."]
6662 pub mFullName: *const ::std::os::raw::c_char,
6663 #[doc = "< Host name (e.g. \"ot-host.default.service.arpa.\")."]
6664 pub mHostName: *const ::std::os::raw::c_char,
6665 #[doc = "< Number of host IPv6 addresses."]
6666 pub mAddressNum: u8,
6667 #[doc = "< Host IPv6 addresses."]
6668 pub mAddresses: *const otIp6Address,
6669 #[doc = "< Service port."]
6670 pub mPort: u16,
6671 #[doc = "< Service priority."]
6672 pub mPriority: u16,
6673 #[doc = "< Service weight."]
6674 pub mWeight: u16,
6675 #[doc = "< Service TXT RDATA length."]
6676 pub mTxtLength: u16,
6677 #[doc = "< Service TXT RDATA."]
6678 pub mTxtData: *const u8,
6679 #[doc = "< Service TTL (in seconds)."]
6680 pub mTtl: u32,
6681}
6682impl Default for otDnssdServiceInstanceInfo {
6683 fn default() -> Self {
6684 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6685 unsafe {
6686 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6687 s.assume_init()
6688 }
6689 }
6690}
6691#[doc = " Represents information of a discovered host for a DNS-SD query."]
6692#[repr(C)]
6693#[derive(Debug, Copy, Clone)]
6694pub struct otDnssdHostInfo {
6695 #[doc = "< Number of host IPv6 addresses."]
6696 pub mAddressNum: u8,
6697 #[doc = "< Host IPv6 addresses."]
6698 pub mAddresses: *const otIp6Address,
6699 #[doc = "< Service TTL (in seconds)."]
6700 pub mTtl: u32,
6701}
6702impl Default for otDnssdHostInfo {
6703 fn default() -> Self {
6704 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6705 unsafe {
6706 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6707 s.assume_init()
6708 }
6709 }
6710}
6711#[doc = "< Service type unspecified."]
6712pub const OT_DNSSD_QUERY_TYPE_NONE: otDnssdQueryType = 0;
6713#[doc = "< Service type browse service."]
6714pub const OT_DNSSD_QUERY_TYPE_BROWSE: otDnssdQueryType = 1;
6715#[doc = "< Service type resolve service instance."]
6716pub const OT_DNSSD_QUERY_TYPE_RESOLVE: otDnssdQueryType = 2;
6717#[doc = "< Service type resolve hostname."]
6718pub const OT_DNSSD_QUERY_TYPE_RESOLVE_HOST: otDnssdQueryType = 3;
6719#[doc = " Specifies a DNS-SD query type."]
6720pub type otDnssdQueryType = ::std::os::raw::c_uint;
6721#[doc = " Represents the count of queries, responses, failures handled by upstream DNS server.\n\n Requires `OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE`."]
6722#[repr(C)]
6723#[derive(Debug, Default, Copy, Clone)]
6724pub struct otUpstreamDnsCounters {
6725 #[doc = "< The number of queries forwarded."]
6726 pub mQueries: u32,
6727 #[doc = "< The number of responses forwarded."]
6728 pub mResponses: u32,
6729 #[doc = "< The number of upstream DNS failures."]
6730 pub mFailures: u32,
6731}
6732#[doc = " Contains the counters of DNS-SD server."]
6733#[repr(C)]
6734#[derive(Debug, Default, Copy, Clone)]
6735pub struct otDnssdCounters {
6736 #[doc = "< The number of successful responses."]
6737 pub mSuccessResponse: u32,
6738 #[doc = "< The number of server failure responses."]
6739 pub mServerFailureResponse: u32,
6740 #[doc = "< The number of format error responses."]
6741 pub mFormatErrorResponse: u32,
6742 #[doc = "< The number of name error responses."]
6743 pub mNameErrorResponse: u32,
6744 #[doc = "< The number of 'not implemented' responses."]
6745 pub mNotImplementedResponse: u32,
6746 #[doc = "< The number of other responses."]
6747 pub mOtherResponse: u32,
6748 #[doc = "< The number of queries resolved by the local SRP server."]
6749 pub mResolvedBySrp: u32,
6750 #[doc = "< The number of queries, responses,\n< failures handled by upstream DNS server."]
6751 pub mUpstreamDnsCounters: otUpstreamDnsCounters,
6752}
6753extern "C" {
6754 #[doc = " Sets DNS-SD server query callbacks.\n\n The DNS-SD server calls @p aSubscribe to subscribe to a service or service instance to resolve a DNS-SD query and @p\n aUnsubscribe to unsubscribe when the query is resolved or timeout.\n\n @note @p aSubscribe and @p aUnsubscribe must be both set or unset.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aSubscribe A pointer to the callback function to subscribe a service or service instance.\n @param[in] aUnsubscribe A pointer to the callback function to unsubscribe a service or service instance.\n @param[in] aContext A pointer to the application-specific context."]
6755 pub fn otDnssdQuerySetCallbacks(
6756 aInstance: *mut otInstance,
6757 aSubscribe: otDnssdQuerySubscribeCallback,
6758 aUnsubscribe: otDnssdQueryUnsubscribeCallback,
6759 aContext: *mut ::std::os::raw::c_void,
6760 );
6761}
6762extern "C" {
6763 #[doc = " Notifies a discovered service instance.\n\n The external query resolver (e.g. Discovery Proxy) should call this function to notify OpenThread core of the\n subscribed services or service instances.\n\n @note @p aInstanceInfo must not contain unspecified or link-local or loop-back or multicast IP addresses.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aServiceFullName The null-terminated full service name.\n @param[in] aInstanceInfo A pointer to the discovered service instance information."]
6764 pub fn otDnssdQueryHandleDiscoveredServiceInstance(
6765 aInstance: *mut otInstance,
6766 aServiceFullName: *const ::std::os::raw::c_char,
6767 aInstanceInfo: *mut otDnssdServiceInstanceInfo,
6768 );
6769}
6770extern "C" {
6771 #[doc = " Notifies a discovered host.\n\n The external query resolver (e.g. Discovery Proxy) should call this function to notify OpenThread core of the\n subscribed hosts.\n\n @note @p aHostInfo must not contain unspecified or link-local or loop-back or multicast IP addresses.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aHostFullName The null-terminated full host name.\n @param[in] aHostInfo A pointer to the discovered service instance information."]
6772 pub fn otDnssdQueryHandleDiscoveredHost(
6773 aInstance: *mut otInstance,
6774 aHostFullName: *const ::std::os::raw::c_char,
6775 aHostInfo: *mut otDnssdHostInfo,
6776 );
6777}
6778extern "C" {
6779 #[doc = " Acquires the next query in the DNS-SD server.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aQuery The query pointer. Pass NULL to get the first query.\n\n @returns A pointer to the query or NULL if no more queries."]
6780 pub fn otDnssdGetNextQuery(
6781 aInstance: *mut otInstance,
6782 aQuery: *const otDnssdQuery,
6783 ) -> *const otDnssdQuery;
6784}
6785extern "C" {
6786 #[doc = " Acquires the DNS-SD query type and name for a specific query.\n\n @param[in] aQuery The query pointer acquired from `otDnssdGetNextQuery`.\n @param[out] aNameOutput The name output buffer, which should be `OT_DNS_MAX_NAME_SIZE` bytes long.\n\n @returns The DNS-SD query type."]
6787 pub fn otDnssdGetQueryTypeAndName(
6788 aQuery: *const otDnssdQuery,
6789 aNameOutput: *mut [::std::os::raw::c_char; 255usize],
6790 ) -> otDnssdQueryType;
6791}
6792extern "C" {
6793 #[doc = " Returns the counters of the DNS-SD server.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns A pointer to the counters of the DNS-SD server."]
6794 pub fn otDnssdGetCounters(aInstance: *mut otInstance) -> *const otDnssdCounters;
6795}
6796extern "C" {
6797 #[doc = " Enable or disable forwarding DNS queries to platform DNS upstream API.\n\n Available when `OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled A boolean to enable/disable forwarding DNS queries to upstream.\n\n @sa otPlatDnsStartUpstreamQuery\n @sa otPlatDnsCancelUpstreamQuery\n @sa otPlatDnsUpstreamQueryDone"]
6798 pub fn otDnssdUpstreamQuerySetEnabled(aInstance: *mut otInstance, aEnabled: bool);
6799}
6800extern "C" {
6801 #[doc = " Returns whether the DNSSD server will forward DNS queries to the platform DNS upstream API.\n\n Available when `OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @retval TRUE If the DNSSD server will forward DNS queries.\n @retval FALSE If the DNSSD server will not forward DNS queries.\n\n @sa otDnssdUpstreamQuerySetEnabled"]
6802 pub fn otDnssdUpstreamQueryIsEnabled(aInstance: *mut otInstance) -> bool;
6803}
6804extern "C" {
6805 #[doc = " @note This API is deprecated and use of it is discouraged."]
6806 pub fn otHeapCAlloc(aCount: usize, aSize: usize) -> *mut ::std::os::raw::c_void;
6807}
6808extern "C" {
6809 #[doc = " @note This API is deprecated and use of it is discouraged."]
6810 pub fn otHeapFree(aPointer: *mut ::std::os::raw::c_void);
6811}
6812#[doc = "< Destination Unreachable"]
6813pub const OT_ICMP6_TYPE_DST_UNREACH: otIcmp6Type = 1;
6814#[doc = "< Packet To Big"]
6815pub const OT_ICMP6_TYPE_PACKET_TO_BIG: otIcmp6Type = 2;
6816#[doc = "< Time Exceeded"]
6817pub const OT_ICMP6_TYPE_TIME_EXCEEDED: otIcmp6Type = 3;
6818#[doc = "< Parameter Problem"]
6819pub const OT_ICMP6_TYPE_PARAMETER_PROBLEM: otIcmp6Type = 4;
6820#[doc = "< Echo Request"]
6821pub const OT_ICMP6_TYPE_ECHO_REQUEST: otIcmp6Type = 128;
6822#[doc = "< Echo Reply"]
6823pub const OT_ICMP6_TYPE_ECHO_REPLY: otIcmp6Type = 129;
6824#[doc = "< Router Solicitation"]
6825pub const OT_ICMP6_TYPE_ROUTER_SOLICIT: otIcmp6Type = 133;
6826#[doc = "< Router Advertisement"]
6827pub const OT_ICMP6_TYPE_ROUTER_ADVERT: otIcmp6Type = 134;
6828#[doc = "< Neighbor Solicitation"]
6829pub const OT_ICMP6_TYPE_NEIGHBOR_SOLICIT: otIcmp6Type = 135;
6830#[doc = "< Neighbor Advertisement"]
6831pub const OT_ICMP6_TYPE_NEIGHBOR_ADVERT: otIcmp6Type = 136;
6832#[doc = " ICMPv6 Message Types"]
6833pub type otIcmp6Type = ::std::os::raw::c_uint;
6834#[doc = "< Destination Unreachable (Type 1) - No Route"]
6835pub const OT_ICMP6_CODE_DST_UNREACH_NO_ROUTE: otIcmp6Code = 0;
6836#[doc = "< Destination Unreachable (Type 1) - Administratively Prohibited"]
6837pub const OT_ICMP6_CODE_DST_UNREACH_PROHIBITED: otIcmp6Code = 1;
6838#[doc = "< Time Exceeded (Type 3) - Fragment Reassembly"]
6839pub const OT_ICMP6_CODE_FRAGM_REAS_TIME_EX: otIcmp6Code = 1;
6840#[doc = " ICMPv6 Message Codes"]
6841pub type otIcmp6Code = ::std::os::raw::c_uint;
6842#[doc = " @struct otIcmp6Header\n\n Represents an ICMPv6 header."]
6843#[repr(C, packed)]
6844#[derive(Copy, Clone)]
6845pub struct otIcmp6Header {
6846 #[doc = "< Type"]
6847 pub mType: u8,
6848 #[doc = "< Code"]
6849 pub mCode: u8,
6850 #[doc = "< Checksum"]
6851 pub mChecksum: u16,
6852 #[doc = "< Message-specific data"]
6853 pub mData: otIcmp6Header__bindgen_ty_1,
6854}
6855#[repr(C, packed)]
6856#[derive(Copy, Clone)]
6857pub union otIcmp6Header__bindgen_ty_1 {
6858 pub m8: [u8; 4usize],
6859 pub m16: [u16; 2usize],
6860 pub m32: [u32; 1usize],
6861}
6862impl Default for otIcmp6Header__bindgen_ty_1 {
6863 fn default() -> Self {
6864 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6865 unsafe {
6866 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6867 s.assume_init()
6868 }
6869 }
6870}
6871impl Default for otIcmp6Header {
6872 fn default() -> Self {
6873 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6874 unsafe {
6875 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6876 s.assume_init()
6877 }
6878 }
6879}
6880#[doc = " This callback allows OpenThread to inform the application of a received ICMPv6 message.\n\n @param[in] aContext A pointer to arbitrary context information.\n @param[in] aMessage A pointer to the received message.\n @param[in] aMessageInfo A pointer to message information associated with @p aMessage.\n @param[in] aIcmpHeader A pointer to the received ICMPv6 header."]
6881pub type otIcmp6ReceiveCallback = ::std::option::Option<
6882 unsafe extern "C" fn(
6883 aContext: *mut ::std::os::raw::c_void,
6884 aMessage: *mut otMessage,
6885 aMessageInfo: *const otMessageInfo,
6886 aIcmpHeader: *const otIcmp6Header,
6887 ),
6888>;
6889#[doc = " Implements ICMPv6 message handler."]
6890#[repr(C)]
6891#[derive(Debug, Copy, Clone)]
6892pub struct otIcmp6Handler {
6893 #[doc = "< The ICMPv6 received callback"]
6894 pub mReceiveCallback: otIcmp6ReceiveCallback,
6895 #[doc = "< A pointer to arbitrary context information."]
6896 pub mContext: *mut ::std::os::raw::c_void,
6897 #[doc = "< A pointer to the next handler in the list."]
6898 pub mNext: *mut otIcmp6Handler,
6899}
6900impl Default for otIcmp6Handler {
6901 fn default() -> Self {
6902 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6903 unsafe {
6904 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6905 s.assume_init()
6906 }
6907 }
6908}
6909#[doc = "< ICMPv6 Echo processing disabled"]
6910pub const OT_ICMP6_ECHO_HANDLER_DISABLED: otIcmp6EchoMode = 0;
6911#[doc = "< ICMPv6 Echo processing enabled only for unicast requests only"]
6912pub const OT_ICMP6_ECHO_HANDLER_UNICAST_ONLY: otIcmp6EchoMode = 1;
6913#[doc = "< ICMPv6 Echo processing enabled only for multicast requests only"]
6914pub const OT_ICMP6_ECHO_HANDLER_MULTICAST_ONLY: otIcmp6EchoMode = 2;
6915#[doc = "< ICMPv6 Echo processing enabled for unicast and multicast requests"]
6916pub const OT_ICMP6_ECHO_HANDLER_ALL: otIcmp6EchoMode = 3;
6917#[doc = "< ICMPv6 Echo processing enabled for RLOC/ALOC destinations only"]
6918pub const OT_ICMP6_ECHO_HANDLER_RLOC_ALOC_ONLY: otIcmp6EchoMode = 4;
6919#[doc = " ICMPv6 Echo Reply Modes"]
6920pub type otIcmp6EchoMode = ::std::os::raw::c_uint;
6921extern "C" {
6922 #[doc = " Indicates whether or not ICMPv6 Echo processing is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ICMP6_ECHO_HANDLER_DISABLED ICMPv6 Echo processing is disabled.\n @retval OT_ICMP6_ECHO_HANDLER_UNICAST_ONLY ICMPv6 Echo processing enabled for unicast requests only\n @retval OT_ICMP6_ECHO_HANDLER_MULTICAST_ONLY ICMPv6 Echo processing enabled for multicast requests only\n @retval OT_ICMP6_ECHO_HANDLER_ALL ICMPv6 Echo processing enabled for unicast and multicast requests"]
6923 pub fn otIcmp6GetEchoMode(aInstance: *mut otInstance) -> otIcmp6EchoMode;
6924}
6925extern "C" {
6926 #[doc = " Sets whether or not ICMPv6 Echo processing is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMode The ICMPv6 Echo processing mode."]
6927 pub fn otIcmp6SetEchoMode(aInstance: *mut otInstance, aMode: otIcmp6EchoMode);
6928}
6929extern "C" {
6930 #[doc = " Registers a handler to provide received ICMPv6 messages.\n\n @note A handler structure @p aHandler has to be stored in persistent (static) memory.\n OpenThread does not make a copy of handler structure.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aHandler A pointer to a handler containing callback that is called when\n an ICMPv6 message is received."]
6931 pub fn otIcmp6RegisterHandler(
6932 aInstance: *mut otInstance,
6933 aHandler: *mut otIcmp6Handler,
6934 ) -> otError;
6935}
6936extern "C" {
6937 #[doc = " Sends an ICMPv6 Echo Request via the Thread interface.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the message buffer containing the ICMPv6 payload.\n @param[in] aMessageInfo A reference to message information associated with @p aMessage.\n @param[in] aIdentifier An identifier to aid in matching Echo Replies to this Echo Request.\n May be zero."]
6938 pub fn otIcmp6SendEchoRequest(
6939 aInstance: *mut otInstance,
6940 aMessage: *mut otMessage,
6941 aMessageInfo: *const otMessageInfo,
6942 aIdentifier: u16,
6943 ) -> otError;
6944}
6945#[doc = " Pointer is called if signal jam detection is enabled and a jam is detected.\n\n @param[in] aJamState Current jam state (`true` if jam is detected, `false` otherwise).\n @param[in] aContext A pointer to application-specific context."]
6946pub type otJamDetectionCallback = ::std::option::Option<
6947 unsafe extern "C" fn(aJamState: bool, aContext: *mut ::std::os::raw::c_void),
6948>;
6949extern "C" {
6950 #[doc = " Set the Jam Detection RSSI Threshold (in dBm).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aRssiThreshold The RSSI threshold.\n\n @retval OT_ERROR_NONE Successfully set the threshold."]
6951 pub fn otJamDetectionSetRssiThreshold(
6952 aInstance: *mut otInstance,
6953 aRssiThreshold: i8,
6954 ) -> otError;
6955}
6956extern "C" {
6957 #[doc = " Get the Jam Detection RSSI Threshold (in dBm).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Jam Detection RSSI Threshold."]
6958 pub fn otJamDetectionGetRssiThreshold(aInstance: *mut otInstance) -> i8;
6959}
6960extern "C" {
6961 #[doc = " Set the Jam Detection Detection Window (in seconds).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aWindow The Jam Detection window (valid range is 1 to 63)\n\n @retval OT_ERROR_NONE Successfully set the window.\n @retval OT_ERROR_INVALID_ARGS The given input parameter not within valid range (1-63)"]
6962 pub fn otJamDetectionSetWindow(aInstance: *mut otInstance, aWindow: u8) -> otError;
6963}
6964extern "C" {
6965 #[doc = " Get the Jam Detection Detection Window (in seconds).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Jam Detection Window."]
6966 pub fn otJamDetectionGetWindow(aInstance: *mut otInstance) -> u8;
6967}
6968extern "C" {
6969 #[doc = " Set the Jam Detection Busy Period (in seconds).\n\n The number of aggregate seconds within the detection window where the RSSI must be above\n threshold to trigger detection.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aBusyPeriod The Jam Detection busy period (should be non-zero and\nless than or equal to Jam Detection Window)\n\n @retval OT_ERROR_NONE Successfully set the window.\n @retval OT_ERROR_INVALID_ARGS The given input is not within the valid range."]
6970 pub fn otJamDetectionSetBusyPeriod(aInstance: *mut otInstance, aBusyPeriod: u8) -> otError;
6971}
6972extern "C" {
6973 #[doc = " Get the Jam Detection Busy Period (in seconds)\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Jam Detection Busy Period."]
6974 pub fn otJamDetectionGetBusyPeriod(aInstance: *mut otInstance) -> u8;
6975}
6976extern "C" {
6977 #[doc = " Start the jamming detection.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function called to notify of jamming state change.\n @param[in] aContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully started the jamming detection.\n @retval OT_ERROR_ALREADY Jam detection has been started before."]
6978 pub fn otJamDetectionStart(
6979 aInstance: *mut otInstance,
6980 aCallback: otJamDetectionCallback,
6981 aContext: *mut ::std::os::raw::c_void,
6982 ) -> otError;
6983}
6984extern "C" {
6985 #[doc = " Stop the jamming detection.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully stopped the jamming detection.\n @retval OT_ERROR_ALREADY Jam detection is already stopped."]
6986 pub fn otJamDetectionStop(aInstance: *mut otInstance) -> otError;
6987}
6988extern "C" {
6989 #[doc = " Get the Jam Detection Status (enabled/disabled)\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Jam Detection status (true if enabled, false otherwise)."]
6990 pub fn otJamDetectionIsEnabled(aInstance: *mut otInstance) -> bool;
6991}
6992extern "C" {
6993 #[doc = " Get the Jam Detection State\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Jam Detection state (`true` jam is detected, `false' otherwise)."]
6994 pub fn otJamDetectionGetState(aInstance: *mut otInstance) -> bool;
6995}
6996extern "C" {
6997 #[doc = " Get the current history bitmap.\n\n This value provides information about current state of jamming detection\n module for monitoring/debugging purpose. It returns a 64-bit value where\n each bit corresponds to one second interval starting with bit 0 for the\n most recent interval and bit 63 for the oldest intervals (63 sec earlier).\n The bit is set to 1 if the jamming detection module observed/detected\n high signal level during the corresponding one second interval.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current history bitmap."]
6998 pub fn otJamDetectionGetHistoryBitmap(aInstance: *mut otInstance) -> u64;
6999}
7000pub type otMacFilterIterator = u8;
7001#[doc = "< Address filter is disabled."]
7002pub const OT_MAC_FILTER_ADDRESS_MODE_DISABLED: otMacFilterAddressMode = 0;
7003#[doc = "< Allowlist address filter mode is enabled."]
7004pub const OT_MAC_FILTER_ADDRESS_MODE_ALLOWLIST: otMacFilterAddressMode = 1;
7005#[doc = "< Denylist address filter mode is enabled."]
7006pub const OT_MAC_FILTER_ADDRESS_MODE_DENYLIST: otMacFilterAddressMode = 2;
7007#[doc = " Defines address mode of the mac filter."]
7008pub type otMacFilterAddressMode = ::std::os::raw::c_uint;
7009#[doc = " Represents a Mac Filter entry."]
7010#[repr(C)]
7011#[derive(Debug, Default, Copy, Clone)]
7012pub struct otMacFilterEntry {
7013 #[doc = "< IEEE 802.15.4 Extended Address"]
7014 pub mExtAddress: otExtAddress,
7015 #[doc = "< Received signal strength"]
7016 pub mRssIn: i8,
7017}
7018#[doc = " Represents the MAC layer counters."]
7019#[repr(C)]
7020#[derive(Debug, Default, Copy, Clone)]
7021pub struct otMacCounters {
7022 #[doc = " The total number of unique MAC frame transmission requests.\n\n Note that this counter is incremented for each MAC transmission request only by one,\n regardless of the amount of CCA failures, CSMA-CA attempts, or retransmissions.\n\n This increment rule applies to the following counters:\n - @p mTxUnicast\n - @p mTxBroadcast\n - @p mTxAckRequested\n - @p mTxNoAckRequested\n - @p mTxData\n - @p mTxDataPoll\n - @p mTxBeacon\n - @p mTxBeaconRequest\n - @p mTxOther\n - @p mTxErrAbort\n - @p mTxErrBusyChannel\n\n The following equations are valid:\n - @p mTxTotal = @p mTxUnicast + @p mTxBroadcast\n - @p mTxTotal = @p mTxAckRequested + @p mTxNoAckRequested\n - @p mTxTotal = @p mTxData + @p mTxDataPoll + @p mTxBeacon + @p mTxBeaconRequest + @p mTxOther"]
7023 pub mTxTotal: u32,
7024 #[doc = " The total number of unique unicast MAC frame transmission requests."]
7025 pub mTxUnicast: u32,
7026 #[doc = " The total number of unique broadcast MAC frame transmission requests."]
7027 pub mTxBroadcast: u32,
7028 #[doc = " The total number of unique MAC frame transmission requests with requested acknowledgment."]
7029 pub mTxAckRequested: u32,
7030 #[doc = " The total number of unique MAC frame transmission requests that were acked."]
7031 pub mTxAcked: u32,
7032 #[doc = " The total number of unique MAC frame transmission requests without requested acknowledgment."]
7033 pub mTxNoAckRequested: u32,
7034 #[doc = " The total number of unique MAC Data frame transmission requests."]
7035 pub mTxData: u32,
7036 #[doc = " The total number of unique MAC Data Poll frame transmission requests."]
7037 pub mTxDataPoll: u32,
7038 #[doc = " The total number of unique MAC Beacon frame transmission requests."]
7039 pub mTxBeacon: u32,
7040 #[doc = " The total number of unique MAC Beacon Request frame transmission requests."]
7041 pub mTxBeaconRequest: u32,
7042 #[doc = " The total number of unique other MAC frame transmission requests.\n\n This counter is currently used for counting out-of-band frames."]
7043 pub mTxOther: u32,
7044 #[doc = " The total number of MAC retransmission attempts.\n\n Note that this counter is incremented by one for each retransmission attempt that may be\n triggered by lack of acknowledgement, CSMA/CA failure, or other type of transmission error.\n The @p mTxRetry counter is incremented both for unicast and broadcast MAC frames.\n\n Modify the following configuration parameters to control the amount of retransmissions in the system:\n\n - OPENTHREAD_CONFIG_MAC_DEFAULT_MAX_FRAME_RETRIES_DIRECT\n - OPENTHREAD_CONFIG_MAC_DEFAULT_MAX_FRAME_RETRIES_INDIRECT\n - OPENTHREAD_CONFIG_MAC_TX_NUM_BCAST\n - OPENTHREAD_CONFIG_MAC_MAX_CSMA_BACKOFFS_DIRECT\n - OPENTHREAD_CONFIG_MAC_MAX_CSMA_BACKOFFS_INDIRECT\n\n Currently, this counter is invalid if the platform's radio driver capability includes\n @ref OT_RADIO_CAPS_TRANSMIT_RETRIES."]
7045 pub mTxRetry: u32,
7046 #[doc = " The total number of unique MAC transmission packets that meet maximal retry limit for direct packets."]
7047 pub mTxDirectMaxRetryExpiry: u32,
7048 #[doc = " The total number of unique MAC transmission packets that meet maximal retry limit for indirect packets."]
7049 pub mTxIndirectMaxRetryExpiry: u32,
7050 #[doc = " The total number of CCA failures.\n\n The meaning of this counter can be different and it depends on the platform's radio driver capabilities.\n\n If @ref OT_RADIO_CAPS_CSMA_BACKOFF is enabled, this counter represents the total number of full CSMA/CA\n failed attempts and it is incremented by one also for each retransmission (in case of a CSMA/CA fail).\n\n If @ref OT_RADIO_CAPS_TRANSMIT_RETRIES is enabled, this counter represents the total number of full CSMA/CA\n failed attempts and it is incremented by one for each individual data frame request (regardless of the\n amount of retransmissions)."]
7051 pub mTxErrCca: u32,
7052 #[doc = " The total number of unique MAC transmission request failures cause by an abort error."]
7053 pub mTxErrAbort: u32,
7054 #[doc = " The total number of unique MAC transmission requests failures caused by a busy channel (a CSMA/CA fail)."]
7055 pub mTxErrBusyChannel: u32,
7056 #[doc = " The total number of received frames.\n\n This counter counts all frames reported by the platform's radio driver, including frames\n that were dropped, for example because of an FCS error."]
7057 pub mRxTotal: u32,
7058 #[doc = " The total number of unicast frames received."]
7059 pub mRxUnicast: u32,
7060 #[doc = " The total number of broadcast frames received."]
7061 pub mRxBroadcast: u32,
7062 #[doc = " The total number of MAC Data frames received."]
7063 pub mRxData: u32,
7064 #[doc = " The total number of MAC Data Poll frames received."]
7065 pub mRxDataPoll: u32,
7066 #[doc = " The total number of MAC Beacon frames received."]
7067 pub mRxBeacon: u32,
7068 #[doc = " The total number of MAC Beacon Request frames received."]
7069 pub mRxBeaconRequest: u32,
7070 #[doc = " The total number of other types of frames received."]
7071 pub mRxOther: u32,
7072 #[doc = " The total number of frames dropped by MAC Filter module, for example received from denylisted node."]
7073 pub mRxAddressFiltered: u32,
7074 #[doc = " The total number of frames dropped by destination address check, for example received frame for other node."]
7075 pub mRxDestAddrFiltered: u32,
7076 #[doc = " The total number of frames dropped due to duplication, that is when the frame has been already received.\n\n This counter may be incremented, for example when ACK frame generated by the receiver hasn't reached\n transmitter node which performed retransmission."]
7077 pub mRxDuplicated: u32,
7078 #[doc = " The total number of frames dropped because of missing or malformed content."]
7079 pub mRxErrNoFrame: u32,
7080 #[doc = " The total number of frames dropped due to unknown neighbor."]
7081 pub mRxErrUnknownNeighbor: u32,
7082 #[doc = " The total number of frames dropped due to invalid source address."]
7083 pub mRxErrInvalidSrcAddr: u32,
7084 #[doc = " The total number of frames dropped due to security error.\n\n This counter may be incremented, for example when lower than expected Frame Counter is used\n to encrypt the frame."]
7085 pub mRxErrSec: u32,
7086 #[doc = " The total number of frames dropped due to invalid FCS."]
7087 pub mRxErrFcs: u32,
7088 #[doc = " The total number of frames dropped due to other error."]
7089 pub mRxErrOther: u32,
7090}
7091#[doc = " Represents a received IEEE 802.15.4 Beacon."]
7092#[repr(C)]
7093#[repr(align(4))]
7094#[derive(Debug, Default, Copy, Clone)]
7095pub struct otActiveScanResult {
7096 #[doc = "< IEEE 802.15.4 Extended Address"]
7097 pub mExtAddress: otExtAddress,
7098 #[doc = "< Thread Network Name"]
7099 pub mNetworkName: otNetworkName,
7100 #[doc = "< Thread Extended PAN ID"]
7101 pub mExtendedPanId: otExtendedPanId,
7102 #[doc = "< Steering Data"]
7103 pub mSteeringData: otSteeringData,
7104 #[doc = "< IEEE 802.15.4 PAN ID"]
7105 pub mPanId: u16,
7106 #[doc = "< Joiner UDP Port"]
7107 pub mJoinerUdpPort: u16,
7108 #[doc = "< IEEE 802.15.4 Channel"]
7109 pub mChannel: u8,
7110 #[doc = "< RSSI (dBm)"]
7111 pub mRssi: i8,
7112 #[doc = "< LQI"]
7113 pub mLqi: u8,
7114 pub _bitfield_align_1: [u8; 0],
7115 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7116 pub __bindgen_padding_0: u16,
7117}
7118impl otActiveScanResult {
7119 #[inline]
7120 pub fn mVersion(&self) -> ::std::os::raw::c_uint {
7121 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
7122 }
7123 #[inline]
7124 pub fn set_mVersion(&mut self, val: ::std::os::raw::c_uint) {
7125 unsafe {
7126 let val: u32 = ::std::mem::transmute(val);
7127 self._bitfield_1.set(0usize, 4u8, val as u64)
7128 }
7129 }
7130 #[inline]
7131 pub fn mIsNative(&self) -> bool {
7132 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
7133 }
7134 #[inline]
7135 pub fn set_mIsNative(&mut self, val: bool) {
7136 unsafe {
7137 let val: u8 = ::std::mem::transmute(val);
7138 self._bitfield_1.set(4usize, 1u8, val as u64)
7139 }
7140 }
7141 #[inline]
7142 pub fn mDiscover(&self) -> bool {
7143 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
7144 }
7145 #[inline]
7146 pub fn set_mDiscover(&mut self, val: bool) {
7147 unsafe {
7148 let val: u8 = ::std::mem::transmute(val);
7149 self._bitfield_1.set(5usize, 1u8, val as u64)
7150 }
7151 }
7152 #[inline]
7153 pub fn mIsJoinable(&self) -> bool {
7154 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
7155 }
7156 #[inline]
7157 pub fn set_mIsJoinable(&mut self, val: bool) {
7158 unsafe {
7159 let val: u8 = ::std::mem::transmute(val);
7160 self._bitfield_1.set(6usize, 1u8, val as u64)
7161 }
7162 }
7163 #[inline]
7164 pub fn new_bitfield_1(
7165 mVersion: ::std::os::raw::c_uint,
7166 mIsNative: bool,
7167 mDiscover: bool,
7168 mIsJoinable: bool,
7169 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7170 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7171 __bindgen_bitfield_unit.set(0usize, 4u8, {
7172 let mVersion: u32 = unsafe { ::std::mem::transmute(mVersion) };
7173 mVersion as u64
7174 });
7175 __bindgen_bitfield_unit.set(4usize, 1u8, {
7176 let mIsNative: u8 = unsafe { ::std::mem::transmute(mIsNative) };
7177 mIsNative as u64
7178 });
7179 __bindgen_bitfield_unit.set(5usize, 1u8, {
7180 let mDiscover: u8 = unsafe { ::std::mem::transmute(mDiscover) };
7181 mDiscover as u64
7182 });
7183 __bindgen_bitfield_unit.set(6usize, 1u8, {
7184 let mIsJoinable: u8 = unsafe { ::std::mem::transmute(mIsJoinable) };
7185 mIsJoinable as u64
7186 });
7187 __bindgen_bitfield_unit
7188 }
7189}
7190#[doc = " Represents an energy scan result."]
7191#[repr(C)]
7192#[derive(Debug, Default, Copy, Clone)]
7193pub struct otEnergyScanResult {
7194 #[doc = "< IEEE 802.15.4 Channel"]
7195 pub mChannel: u8,
7196 #[doc = "< The max RSSI (dBm)"]
7197 pub mMaxRssi: i8,
7198}
7199#[doc = " Pointer is called during an IEEE 802.15.4 Active Scan when an IEEE 802.15.4 Beacon is received or\n the scan completes.\n\n @param[in] aResult A valid pointer to the beacon information or NULL when the active scan completes.\n @param[in] aContext A pointer to application-specific context."]
7200pub type otHandleActiveScanResult = ::std::option::Option<
7201 unsafe extern "C" fn(aResult: *mut otActiveScanResult, aContext: *mut ::std::os::raw::c_void),
7202>;
7203extern "C" {
7204 #[doc = " Starts an IEEE 802.15.4 Active Scan\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aScanChannels A bit vector indicating which channels to scan (e.g. OT_CHANNEL_11_MASK).\n @param[in] aScanDuration The time in milliseconds to spend scanning each channel.\n @param[in] aCallback A pointer to a function called on receiving a beacon or scan completes.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Accepted the Active Scan request.\n @retval OT_ERROR_BUSY Already performing an Active Scan."]
7205 pub fn otLinkActiveScan(
7206 aInstance: *mut otInstance,
7207 aScanChannels: u32,
7208 aScanDuration: u16,
7209 aCallback: otHandleActiveScanResult,
7210 aCallbackContext: *mut ::std::os::raw::c_void,
7211 ) -> otError;
7212}
7213extern "C" {
7214 #[doc = " Indicates whether or not an IEEE 802.15.4 Active Scan is currently in progress.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns true if an IEEE 802.15.4 Active Scan is in progress, false otherwise."]
7215 pub fn otLinkIsActiveScanInProgress(aInstance: *mut otInstance) -> bool;
7216}
7217#[doc = " Pointer is called during an IEEE 802.15.4 Energy Scan when the result for a channel is ready or the\n scan completes.\n\n @param[in] aResult A valid pointer to the energy scan result information or NULL when the energy scan completes.\n @param[in] aContext A pointer to application-specific context."]
7218pub type otHandleEnergyScanResult = ::std::option::Option<
7219 unsafe extern "C" fn(aResult: *mut otEnergyScanResult, aContext: *mut ::std::os::raw::c_void),
7220>;
7221extern "C" {
7222 #[doc = " Starts an IEEE 802.15.4 Energy Scan\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aScanChannels A bit vector indicating on which channels to perform energy scan.\n @param[in] aScanDuration The time in milliseconds to spend scanning each channel.\n @param[in] aCallback A pointer to a function called to pass on scan result on indicate scan completion.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Accepted the Energy Scan request.\n @retval OT_ERROR_BUSY Could not start the energy scan."]
7223 pub fn otLinkEnergyScan(
7224 aInstance: *mut otInstance,
7225 aScanChannels: u32,
7226 aScanDuration: u16,
7227 aCallback: otHandleEnergyScanResult,
7228 aCallbackContext: *mut ::std::os::raw::c_void,
7229 ) -> otError;
7230}
7231extern "C" {
7232 #[doc = " Indicates whether or not an IEEE 802.15.4 Energy Scan is currently in progress.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns true if an IEEE 802.15.4 Energy Scan is in progress, false otherwise."]
7233 pub fn otLinkIsEnergyScanInProgress(aInstance: *mut otInstance) -> bool;
7234}
7235extern "C" {
7236 #[doc = " Enqueues an IEEE 802.15.4 Data Request message for transmission.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully enqueued an IEEE 802.15.4 Data Request message.\n @retval OT_ERROR_INVALID_STATE Device is not in rx-off-when-idle mode.\n @retval OT_ERROR_NO_BUFS Insufficient message buffers available."]
7237 pub fn otLinkSendDataRequest(aInstance: *mut otInstance) -> otError;
7238}
7239extern "C" {
7240 #[doc = " Indicates whether or not an IEEE 802.15.4 MAC is in the transmit state.\n\n MAC module is in the transmit state during CSMA/CA procedure, CCA, Data, Beacon or Data Request frame transmission\n and receiving an ACK of a transmitted frame. MAC module is not in the transmit state during transmission of an ACK\n frame or a Beacon Request frame.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns true if an IEEE 802.15.4 MAC is in the transmit state, false otherwise."]
7241 pub fn otLinkIsInTransmitState(aInstance: *mut otInstance) -> bool;
7242}
7243extern "C" {
7244 #[doc = " Get the IEEE 802.15.4 channel.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The IEEE 802.15.4 channel.\n\n @sa otLinkSetChannel"]
7245 pub fn otLinkGetChannel(aInstance: *mut otInstance) -> u8;
7246}
7247extern "C" {
7248 #[doc = " Set the IEEE 802.15.4 channel\n\n Succeeds only when Thread protocols are disabled. A successful call to this function invalidates the\n Active and Pending Operational Datasets in non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannel The IEEE 802.15.4 channel.\n\n @retval OT_ERROR_NONE Successfully set the channel.\n @retval OT_ERROR_INVALID_ARGS If @p aChannel is not in the range [11, 26] or is not in the supported channel mask.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otLinkGetChannel"]
7249 pub fn otLinkSetChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7250}
7251extern "C" {
7252 #[doc = " Get the supported channel mask of MAC layer.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The supported channel mask as `uint32_t` with bit 0 (lsb) mapping to channel 0, bit 1 to channel 1, so on."]
7253 pub fn otLinkGetSupportedChannelMask(aInstance: *mut otInstance) -> u32;
7254}
7255extern "C" {
7256 #[doc = " Set the supported channel mask of MAC layer.\n\n Succeeds only when Thread protocols are disabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask The supported channel mask (bit 0 or lsb mapping to channel 0, and so on).\n\n @retval OT_ERROR_NONE Successfully set the supported channel mask.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled."]
7257 pub fn otLinkSetSupportedChannelMask(aInstance: *mut otInstance, aChannelMask: u32) -> otError;
7258}
7259extern "C" {
7260 #[doc = " Gets the IEEE 802.15.4 Extended Address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the IEEE 802.15.4 Extended Address."]
7261 pub fn otLinkGetExtendedAddress(aInstance: *mut otInstance) -> *const otExtAddress;
7262}
7263extern "C" {
7264 #[doc = " Sets the IEEE 802.15.4 Extended Address.\n\n @note Only succeeds when Thread protocols are disabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress A pointer to the IEEE 802.15.4 Extended Address.\n\n @retval OT_ERROR_NONE Successfully set the IEEE 802.15.4 Extended Address.\n @retval OT_ERROR_INVALID_ARGS @p aExtAddress was NULL.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled."]
7265 pub fn otLinkSetExtendedAddress(
7266 aInstance: *mut otInstance,
7267 aExtAddress: *const otExtAddress,
7268 ) -> otError;
7269}
7270extern "C" {
7271 #[doc = " Get the factory-assigned IEEE EUI-64.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[out] aEui64 A pointer to where the factory-assigned IEEE EUI-64 is placed."]
7272 pub fn otLinkGetFactoryAssignedIeeeEui64(aInstance: *mut otInstance, aEui64: *mut otExtAddress);
7273}
7274extern "C" {
7275 #[doc = " Get the IEEE 802.15.4 PAN ID.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The IEEE 802.15.4 PAN ID.\n\n @sa otLinkSetPanId"]
7276 pub fn otLinkGetPanId(aInstance: *mut otInstance) -> otPanId;
7277}
7278extern "C" {
7279 #[doc = " Set the IEEE 802.15.4 PAN ID.\n\n Succeeds only when Thread protocols are disabled. A successful call to this function also invalidates\n the Active and Pending Operational Datasets in non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPanId The IEEE 802.15.4 PAN ID.\n\n @retval OT_ERROR_NONE Successfully set the PAN ID.\n @retval OT_ERROR_INVALID_ARGS If aPanId is not in the range [0, 65534].\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otLinkGetPanId"]
7280 pub fn otLinkSetPanId(aInstance: *mut otInstance, aPanId: otPanId) -> otError;
7281}
7282extern "C" {
7283 #[doc = " Get the data poll period of sleepy end device.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The data poll period of sleepy end device in milliseconds.\n\n @sa otLinkSetPollPeriod"]
7284 pub fn otLinkGetPollPeriod(aInstance: *mut otInstance) -> u32;
7285}
7286extern "C" {
7287 #[doc = " Set/clear user-specified/external data poll period for sleepy end device.\n\n @note This function updates only poll period of sleepy end device. To update child timeout the function\n `otThreadSetChildTimeout()` shall be called.\n\n @note Minimal non-zero value should be `OPENTHREAD_CONFIG_MAC_MINIMUM_POLL_PERIOD` (10ms).\n Or zero to clear user-specified poll period.\n\n @note User-specified value should be no more than the maximal value 0x3FFFFFF ((1 << 26) - 1) allowed,\n otherwise it would be clipped by the maximal value.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPollPeriod data poll period in milliseconds.\n\n @retval OT_ERROR_NONE Successfully set/cleared user-specified poll period.\n @retval OT_ERROR_INVALID_ARGS If aPollPeriod is invalid.\n\n @sa otLinkGetPollPeriod"]
7288 pub fn otLinkSetPollPeriod(aInstance: *mut otInstance, aPollPeriod: u32) -> otError;
7289}
7290extern "C" {
7291 #[doc = " Get the IEEE 802.15.4 Short Address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The IEEE 802.15.4 Short Address."]
7292 pub fn otLinkGetShortAddress(aInstance: *mut otInstance) -> otShortAddress;
7293}
7294extern "C" {
7295 #[doc = " Get the IEEE 802.15.4 alternate short address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The alternate short address, or `OT_RADIO_INVALID_SHORT_ADDR` (0xfffe) if there is no alternate address."]
7296 pub fn otLinkGetAlternateShortAddress(aInstance: *mut otInstance) -> otShortAddress;
7297}
7298extern "C" {
7299 #[doc = " Returns the maximum number of frame retries during direct transmission.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The maximum number of retries during direct transmission."]
7300 pub fn otLinkGetMaxFrameRetriesDirect(aInstance: *mut otInstance) -> u8;
7301}
7302extern "C" {
7303 #[doc = " Sets the maximum number of frame retries during direct transmission.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMaxFrameRetriesDirect The maximum number of retries during direct transmission."]
7304 pub fn otLinkSetMaxFrameRetriesDirect(aInstance: *mut otInstance, aMaxFrameRetriesDirect: u8);
7305}
7306extern "C" {
7307 #[doc = " Returns the maximum number of frame retries during indirect transmission.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The maximum number of retries during indirect transmission."]
7308 pub fn otLinkGetMaxFrameRetriesIndirect(aInstance: *mut otInstance) -> u8;
7309}
7310extern "C" {
7311 #[doc = " Sets the maximum number of frame retries during indirect transmission.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMaxFrameRetriesIndirect The maximum number of retries during indirect transmission."]
7312 pub fn otLinkSetMaxFrameRetriesIndirect(
7313 aInstance: *mut otInstance,
7314 aMaxFrameRetriesIndirect: u8,
7315 );
7316}
7317extern "C" {
7318 #[doc = " Gets the current MAC frame counter value.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns The current MAC frame counter value."]
7319 pub fn otLinkGetFrameCounter(aInstance: *mut otInstance) -> u32;
7320}
7321extern "C" {
7322 #[doc = " Gets the address mode of MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns the address mode."]
7323 pub fn otLinkFilterGetAddressMode(aInstance: *mut otInstance) -> otMacFilterAddressMode;
7324}
7325extern "C" {
7326 #[doc = " Sets the address mode of MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMode The address mode to set."]
7327 pub fn otLinkFilterSetAddressMode(aInstance: *mut otInstance, aMode: otMacFilterAddressMode);
7328}
7329extern "C" {
7330 #[doc = " Adds an Extended Address to MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress A pointer to the Extended Address (MUST NOT be NULL).\n\n @retval OT_ERROR_NONE Successfully added @p aExtAddress to MAC filter.\n @retval OT_ERROR_NO_BUFS No available entry exists."]
7331 pub fn otLinkFilterAddAddress(
7332 aInstance: *mut otInstance,
7333 aExtAddress: *const otExtAddress,
7334 ) -> otError;
7335}
7336extern "C" {
7337 #[doc = " Removes an Extended Address from MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n No action is performed if there is no existing entry in Filter matching the given Extended Address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress A pointer to the Extended Address (MUST NOT be NULL)."]
7338 pub fn otLinkFilterRemoveAddress(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
7339}
7340extern "C" {
7341 #[doc = " Clears all the Extended Addresses from MAC filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
7342 pub fn otLinkFilterClearAddresses(aInstance: *mut otInstance);
7343}
7344extern "C" {
7345 #[doc = " Gets an in-use address filter entry.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the MAC filter iterator context. To get the first in-use address filter\n entry, it should be set to OT_MAC_FILTER_ITERATOR_INIT. MUST NOT be NULL.\n @param[out] aEntry A pointer to where the information is placed. MUST NOT be NULL.\n\n @retval OT_ERROR_NONE Successfully retrieved an in-use address filter entry.\n @retval OT_ERROR_NOT_FOUND No subsequent entry exists."]
7346 pub fn otLinkFilterGetNextAddress(
7347 aInstance: *mut otInstance,
7348 aIterator: *mut otMacFilterIterator,
7349 aEntry: *mut otMacFilterEntry,
7350 ) -> otError;
7351}
7352extern "C" {
7353 #[doc = " Adds the specified Extended Address to the `RssIn` list (or modifies an existing\n address in the `RssIn` list) and sets the received signal strength (in dBm) entry\n for messages from that address. The Extended Address does not necessarily have\n to be in the `address allowlist/denylist` filter to set the `rss`.\n @note The `RssIn` list contains Extended Addresses whose `rss` or link quality indicator (`lqi`)\n values have been set to be different from the defaults.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress A pointer to the IEEE 802.15.4 Extended Address. MUST NOT be NULL.\n @param[in] aRss A received signal strength (in dBm).\n\n @retval OT_ERROR_NONE Successfully added an entry for @p aExtAddress and @p aRss.\n @retval OT_ERROR_NO_BUFS No available entry exists."]
7354 pub fn otLinkFilterAddRssIn(
7355 aInstance: *mut otInstance,
7356 aExtAddress: *const otExtAddress,
7357 aRss: i8,
7358 ) -> otError;
7359}
7360extern "C" {
7361 #[doc = " Removes the specified Extended Address from the `RssIn` list. Once removed\n from the `RssIn` list, this MAC address will instead use the default `rss`\n and `lqi` settings, assuming defaults have been set.\n (If no defaults have been set, the over-air signal is used.)\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n No action is performed if there is no existing entry in the `RssIn` list matching the specified Extended Address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress A pointer to the IEEE 802.15.4 Extended Address. MUST NOT be NULL."]
7362 pub fn otLinkFilterRemoveRssIn(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
7363}
7364extern "C" {
7365 #[doc = " Sets the default received signal strength (in dBm) on MAC Filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n The default RSS value is used for all received frames from addresses for which there is no explicit RSS-IN entry\n in the Filter list (added using `otLinkFilterAddRssIn()`).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aRss The default received signal strength (in dBm) to set."]
7366 pub fn otLinkFilterSetDefaultRssIn(aInstance: *mut otInstance, aRss: i8);
7367}
7368extern "C" {
7369 #[doc = " Clears any previously set default received signal strength (in dBm) on MAC Filter.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
7370 pub fn otLinkFilterClearDefaultRssIn(aInstance: *mut otInstance);
7371}
7372extern "C" {
7373 #[doc = " Clears all the received signal strength (`rss`) and link quality\n indicator (`lqi`) entries (including defaults) from the `RssIn` list.\n Performing this action means that all Extended Addresses will use the on-air signal.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
7374 pub fn otLinkFilterClearAllRssIn(aInstance: *mut otInstance);
7375}
7376extern "C" {
7377 #[doc = " Gets an in-use RssIn filter entry.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the MAC filter iterator context. MUST NOT be NULL.\n To get the first entry, it should be set to OT_MAC_FILTER_ITERATOR_INIT.\n @param[out] aEntry A pointer to where the information is placed. The last entry would have the extended\n address as all 0xff to indicate the default received signal strength if it was set.\n@p aEntry MUST NOT be NULL.\n\n @retval OT_ERROR_NONE Successfully retrieved the next entry.\n @retval OT_ERROR_NOT_FOUND No subsequent entry exists."]
7378 pub fn otLinkFilterGetNextRssIn(
7379 aInstance: *mut otInstance,
7380 aIterator: *mut otMacFilterIterator,
7381 aEntry: *mut otMacFilterEntry,
7382 ) -> otError;
7383}
7384extern "C" {
7385 #[doc = " Enables/disables IEEE 802.15.4 radio filter mode.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n The radio filter is mainly intended for testing. It can be used to temporarily block all tx/rx on the 802.15.4 radio.\n When radio filter is enabled, radio is put to sleep instead of receive (to ensure device does not receive any frame\n and/or potentially send ack). Also the frame transmission requests return immediately without sending the frame over\n the air (return \"no ack\" error if ack is requested, otherwise return success).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aFilterEnabled TRUE to enable radio filter, FALSE to disable"]
7386 pub fn otLinkSetRadioFilterEnabled(aInstance: *mut otInstance, aFilterEnabled: bool);
7387}
7388extern "C" {
7389 #[doc = " Indicates whether the IEEE 802.15.4 radio filter is enabled or not.\n\n Is available when `OPENTHREAD_CONFIG_MAC_FILTER_ENABLE` configuration is enabled.\n\n @retval TRUE If the radio filter is enabled.\n @retval FALSE If the radio filter is disabled."]
7390 pub fn otLinkIsRadioFilterEnabled(aInstance: *mut otInstance) -> bool;
7391}
7392extern "C" {
7393 #[doc = " Converts received signal strength to link quality.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aRss The received signal strength value to be converted.\n\n @return Link quality value mapping to @p aRss."]
7394 pub fn otLinkConvertRssToLinkQuality(aInstance: *mut otInstance, aRss: i8) -> u8;
7395}
7396extern "C" {
7397 #[doc = " Converts link quality to typical received signal strength.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aLinkQuality LinkQuality value, should be in range [0,3].\n\n @return Typical platform received signal strength mapping to @p aLinkQuality."]
7398 pub fn otLinkConvertLinkQualityToRss(aInstance: *mut otInstance, aLinkQuality: u8) -> i8;
7399}
7400extern "C" {
7401 #[doc = " Gets histogram of retries for a single direct packet until success.\n\n Is valid when OPENTHREAD_CONFIG_MAC_RETRY_SUCCESS_HISTOGRAM_ENABLE configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aNumberOfEntries A pointer to where the size of returned histogram array is placed.\n\n @returns A pointer to the histogram of retries (in a form of an array).\n The n-th element indicates that the packet has been sent with n-th retry."]
7402 pub fn otLinkGetTxDirectRetrySuccessHistogram(
7403 aInstance: *mut otInstance,
7404 aNumberOfEntries: *mut u8,
7405 ) -> *const u32;
7406}
7407extern "C" {
7408 #[doc = " Gets histogram of retries for a single indirect packet until success.\n\n Is valid when OPENTHREAD_CONFIG_MAC_RETRY_SUCCESS_HISTOGRAM_ENABLE configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aNumberOfEntries A pointer to where the size of returned histogram array is placed.\n\n @returns A pointer to the histogram of retries (in a form of an array).\n The n-th element indicates that the packet has been sent with n-th retry."]
7409 pub fn otLinkGetTxIndirectRetrySuccessHistogram(
7410 aInstance: *mut otInstance,
7411 aNumberOfEntries: *mut u8,
7412 ) -> *const u32;
7413}
7414extern "C" {
7415 #[doc = " Clears histogram statistics for direct and indirect transmissions.\n\n Is valid when OPENTHREAD_CONFIG_MAC_RETRY_SUCCESS_HISTOGRAM_ENABLE configuration is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
7416 pub fn otLinkResetTxRetrySuccessHistogram(aInstance: *mut otInstance);
7417}
7418extern "C" {
7419 #[doc = " Get the MAC layer counters.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the MAC layer counters."]
7420 pub fn otLinkGetCounters(aInstance: *mut otInstance) -> *const otMacCounters;
7421}
7422extern "C" {
7423 #[doc = " Resets the MAC layer counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
7424 pub fn otLinkResetCounters(aInstance: *mut otInstance);
7425}
7426#[doc = " Pointer is called when an IEEE 802.15.4 frame is received.\n\n @note This callback is called after FCS processing and @p aFrame may not contain the actual FCS that was received.\n\n @note This callback is called before IEEE 802.15.4 security processing.\n\n @param[in] aFrame A pointer to the received IEEE 802.15.4 frame.\n @param[in] aIsTx Whether this frame is transmitted, not received.\n @param[in] aContext A pointer to application-specific context."]
7427pub type otLinkPcapCallback = ::std::option::Option<
7428 unsafe extern "C" fn(
7429 aFrame: *const otRadioFrame,
7430 aIsTx: bool,
7431 aContext: *mut ::std::os::raw::c_void,
7432 ),
7433>;
7434extern "C" {
7435 #[doc = " Registers a callback to provide received raw IEEE 802.15.4 frames.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPcapCallback A pointer to a function that is called when receiving an IEEE 802.15.4 link frame or\n NULL to disable the callback.\n @param[in] aCallbackContext A pointer to application-specific context."]
7436 pub fn otLinkSetPcapCallback(
7437 aInstance: *mut otInstance,
7438 aPcapCallback: otLinkPcapCallback,
7439 aCallbackContext: *mut ::std::os::raw::c_void,
7440 );
7441}
7442extern "C" {
7443 #[doc = " Indicates whether or not promiscuous mode is enabled at the link layer.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE Promiscuous mode is enabled.\n @retval FALSE Promiscuous mode is not enabled."]
7444 pub fn otLinkIsPromiscuous(aInstance: *mut otInstance) -> bool;
7445}
7446extern "C" {
7447 #[doc = " Enables or disables the link layer promiscuous mode.\n\n @note Promiscuous mode may only be enabled when the Thread interface is disabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPromiscuous true to enable promiscuous mode, or false otherwise.\n\n @retval OT_ERROR_NONE Successfully enabled promiscuous mode.\n @retval OT_ERROR_INVALID_STATE Could not enable promiscuous mode because\n the Thread interface is enabled."]
7448 pub fn otLinkSetPromiscuous(aInstance: *mut otInstance, aPromiscuous: bool) -> otError;
7449}
7450extern "C" {
7451 #[doc = " Gets the CSL channel.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The CSL channel."]
7452 pub fn otLinkGetCslChannel(aInstance: *mut otInstance) -> u8;
7453}
7454extern "C" {
7455 #[doc = " Sets the CSL channel.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannel The CSL sample channel. Channel value should be `0` (Set CSL Channel unspecified) or\n within the range [1, 10] (if 915-MHz supported) and [11, 26] (if 2.4 GHz supported).\n\n @retval OT_ERROR_NONE Successfully set the CSL parameters.\n @retval OT_ERROR_INVALID_ARGS Invalid @p aChannel."]
7456 pub fn otLinkSetCslChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7457}
7458extern "C" {
7459 #[doc = " Gets the CSL period in microseconds\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The CSL period in microseconds."]
7460 pub fn otLinkGetCslPeriod(aInstance: *mut otInstance) -> u32;
7461}
7462extern "C" {
7463 #[doc = " Sets the CSL period in microseconds. Disable CSL by setting this parameter to `0`.\n\n The CSL period MUST be a multiple of `OT_LINK_CSL_PERIOD_TEN_SYMBOLS_UNIT_IN_USEC`, otherwise `OT_ERROR_INVALID_ARGS`\n is returned.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPeriod The CSL period in microseconds.\n\n @retval OT_ERROR_NONE Successfully set the CSL period.\n @retval OT_ERROR_INVALID_ARGS Invalid CSL period"]
7464 pub fn otLinkSetCslPeriod(aInstance: *mut otInstance, aPeriod: u32) -> otError;
7465}
7466extern "C" {
7467 #[doc = " Gets the CSL timeout.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The CSL timeout in seconds."]
7468 pub fn otLinkGetCslTimeout(aInstance: *mut otInstance) -> u32;
7469}
7470extern "C" {
7471 #[doc = " Sets the CSL timeout in seconds.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aTimeout The CSL timeout in seconds.\n\n @retval OT_ERROR_NONE Successfully set the CSL timeout.\n @retval OT_ERROR_INVALID_ARGS Invalid CSL timeout."]
7472 pub fn otLinkSetCslTimeout(aInstance: *mut otInstance, aTimeout: u32) -> otError;
7473}
7474extern "C" {
7475 #[doc = " Returns the current CCA (Clear Channel Assessment) failure rate.\n\n The rate is maintained over a window of (roughly) last `OPENTHREAD_CONFIG_CCA_FAILURE_RATE_AVERAGING_WINDOW`\n frame transmissions.\n\n @returns The CCA failure rate with maximum value `0xffff` corresponding to 100% failure rate."]
7476 pub fn otLinkGetCcaFailureRate(aInstance: *mut otInstance) -> u16;
7477}
7478extern "C" {
7479 #[doc = " Enables or disables the link layer.\n\n @note The link layer may only be enabled / disabled when the Thread Interface is disabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnable true to enable the link layer, or false otherwise.\n\n @retval OT_ERROR_NONE Successfully enabled / disabled the link layer.\n @retval OT_ERROR_INVALID_STATE Could not disable the link layer because\n the Thread interface is enabled."]
7480 pub fn otLinkSetEnabled(aInstance: *mut otInstance, aEnable: bool) -> otError;
7481}
7482extern "C" {
7483 #[doc = " Indicates whether or not the link layer is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE Link layer is enabled.\n @retval FALSE Link layer is not enabled."]
7484 pub fn otLinkIsEnabled(aInstance: *mut otInstance) -> bool;
7485}
7486extern "C" {
7487 #[doc = " Indicates whether or not CSL is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE Link layer is CSL enabled.\n @retval FALSE Link layer is not CSL enabled."]
7488 pub fn otLinkIsCslEnabled(aInstance: *mut otInstance) -> bool;
7489}
7490extern "C" {
7491 #[doc = " Indicates whether the device is connected to a parent which supports CSL.\n\n @retval TRUE If parent supports CSL.\n @retval FALSE If parent does not support CSL."]
7492 pub fn otLinkIsCslSupported(aInstance: *mut otInstance) -> bool;
7493}
7494extern "C" {
7495 #[doc = " Instructs the device to send an empty IEEE 802.15.4 data frame.\n\n Is only supported on an Rx-Off-When-Idle device to send an empty data frame to its parent.\n Note: available only when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully enqueued an empty message.\n @retval OT_ERROR_INVALID_STATE Device is not in Rx-Off-When-Idle mode.\n @retval OT_ERROR_NO_BUFS Insufficient message buffers available."]
7496 pub fn otLinkSendEmptyData(aInstance: *mut otInstance) -> otError;
7497}
7498extern "C" {
7499 #[doc = " Sets the region code.\n\n The radio region format is the 2-bytes ascii representation of the 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."]
7500 pub fn otLinkSetRegion(aInstance: *mut otInstance, aRegionCode: u16) -> otError;
7501}
7502extern "C" {
7503 #[doc = " Get the region code.\n\n The radio region format is the 2-bytes ascii representation of the ISO 3166 alpha-2 code.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[out] 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_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."]
7504 pub fn otLinkGetRegion(aInstance: *mut otInstance, aRegionCode: *mut u16) -> otError;
7505}
7506extern "C" {
7507 #[doc = " Gets the Wake-up channel.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_COORDINATOR_ENABLE` or `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Wake-up channel."]
7508 pub fn otLinkGetWakeupChannel(aInstance: *mut otInstance) -> u8;
7509}
7510extern "C" {
7511 #[doc = " Sets the Wake-up channel.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_COORDINATOR_ENABLE` or `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannel The Wake-up sample channel. Channel value should be `0` (Set Wake-up Channel unspecified,\n which means the device will use the PAN channel) or within the range [1, 10] (if 915-MHz\n supported) and [11, 26] (if 2.4 GHz supported).\n\n @retval OT_ERROR_NONE Successfully set the Wake-up channel.\n @retval OT_ERROR_INVALID_ARGS Invalid @p aChannel."]
7512 pub fn otLinkSetWakeupChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7513}
7514extern "C" {
7515 #[doc = " Enables or disables listening for wake-up frames.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnable true to enable listening for wake-up frames, or false otherwise.\n\n @retval OT_ERROR_NONE Successfully enabled / disabled the listening for wake-up frames.\n @retval OT_ERROR_INVALID_ARGS The listen duration is greater than the listen interval.\n @retval OT_ERROR_INVALID_STATE Could not enable listening for wake-up frames due to bad configuration."]
7516 pub fn otLinkSetWakeUpListenEnabled(aInstance: *mut otInstance, aEnable: bool) -> otError;
7517}
7518extern "C" {
7519 #[doc = " Returns whether listening for wake-up frames is enabled.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE If listening for wake-up frames is enabled.\n @retval FALSE If listening for wake-up frames is not enabled."]
7520 pub fn otLinkIsWakeupListenEnabled(aInstance: *mut otInstance) -> bool;
7521}
7522extern "C" {
7523 #[doc = " Get the wake-up listen parameters.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aInterval A pointer to return the wake-up listen interval in microseconds.\n @param[out] aDuration A pointer to return the wake-up listen duration in microseconds."]
7524 pub fn otLinkGetWakeupListenParameters(
7525 aInstance: *mut otInstance,
7526 aInterval: *mut u32,
7527 aDuration: *mut u32,
7528 );
7529}
7530extern "C" {
7531 #[doc = " Set the wake-up listen parameters.\n\n The listen interval must be greater than the listen duration.\n The listen duration must be greater or equal than the minimum supported.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_END_DEVICE_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aInterval The wake-up listen interval in microseconds.\n @param[in] aDuration The wake-up listen duration in microseconds.\n\n @retval OT_ERROR_NONE Successfully set the wake-up listen parameters.\n @retval OT_ERROR_INVALID_ARGS Invalid wake-up listen parameters."]
7532 pub fn otLinkSetWakeupListenParameters(
7533 aInstance: *mut otInstance,
7534 aInterval: u32,
7535 aDuration: u32,
7536 ) -> otError;
7537}
7538extern "C" {
7539 #[doc = " Sets the rx-on-when-idle state.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aRxOnWhenIdle TRUE to keep radio in Receive state, FALSE to put to Sleep state during idle periods.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7540 pub fn otLinkSetRxOnWhenIdle(aInstance: *mut otInstance, aRxOnWhenIdle: bool) -> otError;
7541}
7542#[doc = " Represents the result (value) for a Link Metrics query."]
7543#[repr(C)]
7544#[derive(Debug, Default, Copy, Clone)]
7545pub struct otLinkMetricsValues {
7546 #[doc = "< Specifies which metrics values are present/included."]
7547 pub mMetrics: otLinkMetrics,
7548 #[doc = "< The value of Pdu Count."]
7549 pub mPduCountValue: u32,
7550 #[doc = "< The value LQI."]
7551 pub mLqiValue: u8,
7552 #[doc = "< The value of Link Margin."]
7553 pub mLinkMarginValue: u8,
7554 #[doc = "< The value of Rssi."]
7555 pub mRssiValue: i8,
7556}
7557#[doc = " Represents which frames are accounted in a Forward Tracking Series."]
7558#[repr(C, packed)]
7559#[derive(Debug, Default, Copy, Clone)]
7560pub struct otLinkMetricsSeriesFlags {
7561 pub _bitfield_align_1: [u8; 0],
7562 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7563}
7564impl otLinkMetricsSeriesFlags {
7565 #[inline]
7566 pub fn mLinkProbe(&self) -> bool {
7567 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
7568 }
7569 #[inline]
7570 pub fn set_mLinkProbe(&mut self, val: bool) {
7571 unsafe {
7572 let val: u8 = ::std::mem::transmute(val);
7573 self._bitfield_1.set(0usize, 1u8, val as u64)
7574 }
7575 }
7576 #[inline]
7577 pub fn mMacData(&self) -> bool {
7578 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
7579 }
7580 #[inline]
7581 pub fn set_mMacData(&mut self, val: bool) {
7582 unsafe {
7583 let val: u8 = ::std::mem::transmute(val);
7584 self._bitfield_1.set(1usize, 1u8, val as u64)
7585 }
7586 }
7587 #[inline]
7588 pub fn mMacDataRequest(&self) -> bool {
7589 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
7590 }
7591 #[inline]
7592 pub fn set_mMacDataRequest(&mut self, val: bool) {
7593 unsafe {
7594 let val: u8 = ::std::mem::transmute(val);
7595 self._bitfield_1.set(2usize, 1u8, val as u64)
7596 }
7597 }
7598 #[inline]
7599 pub fn mMacAck(&self) -> bool {
7600 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
7601 }
7602 #[inline]
7603 pub fn set_mMacAck(&mut self, val: bool) {
7604 unsafe {
7605 let val: u8 = ::std::mem::transmute(val);
7606 self._bitfield_1.set(3usize, 1u8, val as u64)
7607 }
7608 }
7609 #[inline]
7610 pub fn new_bitfield_1(
7611 mLinkProbe: bool,
7612 mMacData: bool,
7613 mMacDataRequest: bool,
7614 mMacAck: bool,
7615 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7616 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7617 __bindgen_bitfield_unit.set(0usize, 1u8, {
7618 let mLinkProbe: u8 = unsafe { ::std::mem::transmute(mLinkProbe) };
7619 mLinkProbe as u64
7620 });
7621 __bindgen_bitfield_unit.set(1usize, 1u8, {
7622 let mMacData: u8 = unsafe { ::std::mem::transmute(mMacData) };
7623 mMacData as u64
7624 });
7625 __bindgen_bitfield_unit.set(2usize, 1u8, {
7626 let mMacDataRequest: u8 = unsafe { ::std::mem::transmute(mMacDataRequest) };
7627 mMacDataRequest as u64
7628 });
7629 __bindgen_bitfield_unit.set(3usize, 1u8, {
7630 let mMacAck: u8 = unsafe { ::std::mem::transmute(mMacAck) };
7631 mMacAck as u64
7632 });
7633 __bindgen_bitfield_unit
7634 }
7635}
7636#[doc = "< Clear."]
7637pub const OT_LINK_METRICS_ENH_ACK_CLEAR: otLinkMetricsEnhAckFlags = 0;
7638#[doc = "< Register."]
7639pub const OT_LINK_METRICS_ENH_ACK_REGISTER: otLinkMetricsEnhAckFlags = 1;
7640#[doc = " Enhanced-ACK Flags.\n\n These are used in Enhanced-ACK Based Probing to indicate whether to register or clear the probing."]
7641pub type otLinkMetricsEnhAckFlags = ::std::os::raw::c_uint;
7642pub const OT_LINK_METRICS_STATUS_SUCCESS: otLinkMetricsStatus = 0;
7643pub const OT_LINK_METRICS_STATUS_CANNOT_SUPPORT_NEW_SERIES: otLinkMetricsStatus = 1;
7644pub const OT_LINK_METRICS_STATUS_SERIESID_ALREADY_REGISTERED: otLinkMetricsStatus = 2;
7645pub const OT_LINK_METRICS_STATUS_SERIESID_NOT_RECOGNIZED: otLinkMetricsStatus = 3;
7646pub const OT_LINK_METRICS_STATUS_NO_MATCHING_FRAMES_RECEIVED: otLinkMetricsStatus = 4;
7647pub const OT_LINK_METRICS_STATUS_OTHER_ERROR: otLinkMetricsStatus = 254;
7648#[doc = " Link Metrics Status values."]
7649pub type otLinkMetricsStatus = ::std::os::raw::c_uint;
7650#[doc = " Pointer is called when a Link Metrics report is received.\n\n @param[in] aSource A pointer to the source address.\n @param[in] aMetricsValues A pointer to the Link Metrics values (the query result).\n @param[in] aStatus The status code in the report (only useful when @p aMetricsValues is NULL).\n @param[in] aContext A pointer to application-specific context."]
7651pub type otLinkMetricsReportCallback = ::std::option::Option<
7652 unsafe extern "C" fn(
7653 aSource: *const otIp6Address,
7654 aMetricsValues: *const otLinkMetricsValues,
7655 aStatus: otLinkMetricsStatus,
7656 aContext: *mut ::std::os::raw::c_void,
7657 ),
7658>;
7659#[doc = " Pointer is called when a Link Metrics Management Response is received.\n\n @param[in] aSource A pointer to the source address.\n @param[in] aStatus The status code in the response.\n @param[in] aContext A pointer to application-specific context."]
7660pub type otLinkMetricsMgmtResponseCallback = ::std::option::Option<
7661 unsafe extern "C" fn(
7662 aSource: *const otIp6Address,
7663 aStatus: otLinkMetricsStatus,
7664 aContext: *mut ::std::os::raw::c_void,
7665 ),
7666>;
7667#[doc = " Pointer is called when Enh-ACK Probing IE is received.\n\n @param[in] aShortAddress The Mac short address of the Probing Subject.\n @param[in] aExtAddress A pointer to the Mac extended address of the Probing Subject.\n @param[in] aMetricsValues A pointer to the Link Metrics values obtained from the IE.\n @param[in] aContext A pointer to application-specific context."]
7668pub type otLinkMetricsEnhAckProbingIeReportCallback = ::std::option::Option<
7669 unsafe extern "C" fn(
7670 aShortAddress: otShortAddress,
7671 aExtAddress: *const otExtAddress,
7672 aMetricsValues: *const otLinkMetricsValues,
7673 aContext: *mut ::std::os::raw::c_void,
7674 ),
7675>;
7676extern "C" {
7677 #[doc = " Sends an MLE Data Request to query Link Metrics.\n\n It could be either Single Probe or Forward Tracking Series.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDestination A pointer to the destination address.\n @param[in] aSeriesId The Series ID to query about, 0 for Single Probe.\n @param[in] aLinkMetricsFlags A pointer to flags specifying what metrics to query.\n @param[in] aCallback A pointer to a function that is called when Link Metrics report is received.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully sent a Link Metrics query message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers to generate the MLE Data Request message.\n @retval OT_ERROR_UNKNOWN_NEIGHBOR @p aDestination is not link-local or the neighbor is not found.\n @retval OT_ERROR_NOT_CAPABLE The neighbor is not a Thread 1.2 device and does not support Link Metrics."]
7678 pub fn otLinkMetricsQuery(
7679 aInstance: *mut otInstance,
7680 aDestination: *const otIp6Address,
7681 aSeriesId: u8,
7682 aLinkMetricsFlags: *const otLinkMetrics,
7683 aCallback: otLinkMetricsReportCallback,
7684 aCallbackContext: *mut ::std::os::raw::c_void,
7685 ) -> otError;
7686}
7687extern "C" {
7688 #[doc = " Sends an MLE Link Metrics Management Request to configure or clear a Forward Tracking Series.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDestination A pointer to the destination address.\n @param[in] aSeriesId The Series ID to operate with.\n @param[in] aSeriesFlags The Series Flags that specifies which frames are to be accounted.\n @param[in] aLinkMetricsFlags A pointer to flags specifying what metrics to query. Should be `NULL` when\n `aSeriesFlags` is `0`.\n @param[in] aCallback A pointer to a function that is called when Link Metrics Management Response is\n received.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully sent a Link Metrics Management Request message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers to generate the MLE Link Metrics Management Request message.\n @retval OT_ERROR_INVALID_ARGS @p aSeriesId is not within the valid range.\n @retval OT_ERROR_UNKNOWN_NEIGHBOR @p aDestination is not link-local or the neighbor is not found.\n @retval OT_ERROR_NOT_CAPABLE The neighbor is not a Thread 1.2 device and does not support Link Metrics."]
7689 pub fn otLinkMetricsConfigForwardTrackingSeries(
7690 aInstance: *mut otInstance,
7691 aDestination: *const otIp6Address,
7692 aSeriesId: u8,
7693 aSeriesFlags: otLinkMetricsSeriesFlags,
7694 aLinkMetricsFlags: *const otLinkMetrics,
7695 aCallback: otLinkMetricsMgmtResponseCallback,
7696 aCallbackContext: *mut ::std::os::raw::c_void,
7697 ) -> otError;
7698}
7699extern "C" {
7700 #[doc = " Sends an MLE Link Metrics Management Request to configure/clear an Enhanced-ACK Based Probing.\n This functionality requires OT_LINK_METRICS_INITIATOR feature enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDestination A pointer to the destination address.\n @param[in] aEnhAckFlags Enh-ACK Flags to indicate whether to register or clear the probing. `0` to clear and\n `1` to register. Other values are reserved.\n @param[in] aLinkMetricsFlags A pointer to flags specifying what metrics to query. Should be `NULL` when\n `aEnhAckFlags` is `0`.\n @param[in] aCallback A pointer to a function that is called when an Enhanced Ack with Link Metrics is\n received.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully sent a Link Metrics Management Request message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers to generate the MLE Link Metrics Management Request message.\n @retval OT_ERROR_INVALID_ARGS @p aEnhAckFlags is not a valid value or @p aLinkMetricsFlags isn't correct.\n @retval OT_ERROR_UNKNOWN_NEIGHBOR @p aDestination is not link-local or the neighbor is not found.\n @retval OT_ERROR_NOT_CAPABLE The neighbor is not a Thread 1.2 device and does not support Link Metrics."]
7701 pub fn otLinkMetricsConfigEnhAckProbing(
7702 aInstance: *mut otInstance,
7703 aDestination: *const otIp6Address,
7704 aEnhAckFlags: otLinkMetricsEnhAckFlags,
7705 aLinkMetricsFlags: *const otLinkMetrics,
7706 aCallback: otLinkMetricsMgmtResponseCallback,
7707 aCallbackContext: *mut ::std::os::raw::c_void,
7708 aEnhAckCallback: otLinkMetricsEnhAckProbingIeReportCallback,
7709 aEnhAckCallbackContext: *mut ::std::os::raw::c_void,
7710 ) -> otError;
7711}
7712extern "C" {
7713 #[doc = " Sends an MLE Link Probe message.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDestination A pointer to the destination address.\n @param[in] aSeriesId The Series ID [1, 254] which the Probe message aims at.\n @param[in] aLength The length of the data payload in Link Probe TLV, [0, 64] (per Thread 1.2 spec, 4.4.37).\n\n @retval OT_ERROR_NONE Successfully sent a Link Probe message.\n @retval OT_ERROR_NO_BUFS Insufficient buffers to generate the MLE Link Probe message.\n @retval OT_ERROR_INVALID_ARGS @p aSeriesId or @p aLength is not within the valid range.\n @retval OT_ERROR_UNKNOWN_NEIGHBOR @p aDestination is not link-local or the neighbor is not found.\n @retval OT_ERROR_NOT_CAPABLE The neighbor is not a Thread 1.2 device and does not support Link Metrics."]
7714 pub fn otLinkMetricsSendLinkProbe(
7715 aInstance: *mut otInstance,
7716 aDestination: *const otIp6Address,
7717 aSeriesId: u8,
7718 aLength: u8,
7719 ) -> otError;
7720}
7721extern "C" {
7722 #[doc = " If Link Metrics Manager is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE Link Metrics Manager is enabled.\n @retval FALSE Link Metrics Manager is not enabled."]
7723 pub fn otLinkMetricsManagerIsEnabled(aInstance: *mut otInstance) -> bool;
7724}
7725extern "C" {
7726 #[doc = " Enable or disable Link Metrics Manager.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnable A boolean indicating to enable or disable."]
7727 pub fn otLinkMetricsManagerSetEnabled(aInstance: *mut otInstance, aEnable: bool);
7728}
7729extern "C" {
7730 #[doc = " Get Link Metrics data of a neighbor by its extended address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress A pointer to the Mac extended address of the Probing Subject.\n @param[out] aLinkMetricsValues A pointer to the Link Metrics values of the subject.\n\n @retval OT_ERROR_NONE Successfully got the Link Metrics data.\n @retval OT_ERROR_INVALID_ARGS The arguments are invalid.\n @retval OT_ERROR_NOT_FOUND No neighbor with the given extended address is found."]
7731 pub fn otLinkMetricsManagerGetMetricsValueByExtAddr(
7732 aInstance: *mut otInstance,
7733 aExtAddress: *const otExtAddress,
7734 aLinkMetricsValues: *mut otLinkMetricsValues,
7735 ) -> otError;
7736}
7737#[doc = " Pointer on receipt of a IEEE 802.15.4 frame.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aFrame A pointer to the received frame or NULL if the receive operation was aborted.\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."]
7738pub type otLinkRawReceiveDone = ::std::option::Option<
7739 unsafe extern "C" fn(aInstance: *mut otInstance, aFrame: *mut otRadioFrame, aError: otError),
7740>;
7741extern "C" {
7742 #[doc = " Enables/disables the raw link-layer.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function called on receipt of a IEEE 802.15.4 frame. NULL to disable the\n raw-link layer.\n\n @retval OT_ERROR_FAILED The radio could not be enabled/disabled.\n @retval OT_ERROR_INVALID_STATE If the OpenThread IPv6 interface is already enabled.\n @retval OT_ERROR_NONE If the enable state was successfully set."]
7743 pub fn otLinkRawSetReceiveDone(
7744 aInstance: *mut otInstance,
7745 aCallback: otLinkRawReceiveDone,
7746 ) -> otError;
7747}
7748extern "C" {
7749 #[doc = " Indicates whether or not the raw link-layer is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval true The raw link-layer is enabled.\n @retval false The raw link-layer is disabled."]
7750 pub fn otLinkRawIsEnabled(aInstance: *mut otInstance) -> bool;
7751}
7752extern "C" {
7753 #[doc = " Gets the status of promiscuous mode.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval true Promiscuous mode is enabled.\n @retval false Promiscuous mode is disabled."]
7754 pub fn otLinkRawGetPromiscuous(aInstance: *mut otInstance) -> bool;
7755}
7756extern "C" {
7757 #[doc = " Enables or disables promiscuous mode.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnable A value to enable or disable promiscuous mode.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7758 pub fn otLinkRawSetPromiscuous(aInstance: *mut otInstance, aEnable: bool) -> otError;
7759}
7760extern "C" {
7761 #[doc = " Set the Short Address for address filtering.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aShortAddress The IEEE 802.15.4 Short Address.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7762 pub fn otLinkRawSetShortAddress(aInstance: *mut otInstance, aShortAddress: u16) -> otError;
7763}
7764extern "C" {
7765 #[doc = " Set the alternate short address.\n\n This is an optional API. Support for this is indicated by including the capability `OT_RADIO_CAPS_ALT_SHORT_ADDR` in\n `otLinkRawGetCaps()`.\n\n When supported, the radio will accept received frames destined to the specified alternate short address in addition\n to the short address provided in `otLinkRawSetShortAddress()`.\n\n The @p aShortAddress can be set to `OT_RADIO_INVALID_SHORT_ADDR` (0xfffe) to clear any previously set alternate\n short address.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aShortAddress The alternate short address. `OT_RADIO_INVALID_SHORT_ADDR` to clear.\n\n @retval OT_ERROR_NONE Successfully set the alternate short address.\n @retval OT_ERROR_INVALID_STATE The raw link-layer is not enabled."]
7766 pub fn otLinkRawSetAlternateShortAddress(
7767 aInstance: *mut otInstance,
7768 aShortAddress: otShortAddress,
7769 ) -> otError;
7770}
7771extern "C" {
7772 #[doc = " Transition the radio from Receive to Sleep.\n Turn off the radio.\n\n @param[in] aInstance A pointer to an OpenThread instance.\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"]
7773 pub fn otLinkRawSleep(aInstance: *mut otInstance) -> otError;
7774}
7775extern "C" {
7776 #[doc = " Transitioning the radio from Sleep to Receive.\n Turn on the radio.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully transitioned to Receive.\n @retval OT_ERROR_INVALID_STATE The radio was disabled or transmitting."]
7777 pub fn otLinkRawReceive(aInstance: *mut otInstance) -> otError;
7778}
7779extern "C" {
7780 #[doc = " The radio transitions from Transmit to Receive.\n Returns a pointer to the transmit buffer.\n\n The caller forms the IEEE 802.15.4 frame in this buffer then calls otLinkRawTransmit()\n to request transmission.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the transmit buffer or NULL if the raw link-layer isn't enabled."]
7781 pub fn otLinkRawGetTransmitBuffer(aInstance: *mut otInstance) -> *mut otRadioFrame;
7782}
7783#[doc = " Pointer on receipt of a IEEE 802.15.4 frame.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aFrame A pointer to the frame that was transmitted.\n @param[in] aAckFrame A pointer to the ACK frame.\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 when the transmission could not take place\ndue to activity on the channel.\n OT_ERROR_ABORT when transmission was aborted for other reasons."]
7784pub type otLinkRawTransmitDone = ::std::option::Option<
7785 unsafe extern "C" fn(
7786 aInstance: *mut otInstance,
7787 aFrame: *mut otRadioFrame,
7788 aAckFrame: *mut otRadioFrame,
7789 aError: otError,
7790 ),
7791>;
7792extern "C" {
7793 #[doc = " Begins the transmit sequence on the radio.\n\n The caller must form the IEEE 802.15.4 frame in the buffer provided by otLinkRawGetTransmitBuffer() 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 Receive.\n 2. Transmits the PSDU on the given channel and at the given transmit power.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function called on completion of the transmission.\n\n @retval OT_ERROR_NONE Successfully transitioned to Transmit.\n @retval OT_ERROR_INVALID_STATE The radio was not in the Receive state."]
7794 pub fn otLinkRawTransmit(
7795 aInstance: *mut otInstance,
7796 aCallback: otLinkRawTransmitDone,
7797 ) -> otError;
7798}
7799extern "C" {
7800 #[doc = " Get the most recent RSSI measurement.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The RSSI in dBm when it is valid. 127 when RSSI is invalid."]
7801 pub fn otLinkRawGetRssi(aInstance: *mut otInstance) -> i8;
7802}
7803extern "C" {
7804 #[doc = " Get the radio capabilities.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The radio capability bit vector. The stack enables or disables some functions based on this value."]
7805 pub fn otLinkRawGetCaps(aInstance: *mut otInstance) -> otRadioCaps;
7806}
7807#[doc = " Pointer on receipt of a IEEE 802.15.4 frame.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnergyScanMaxRssi The maximum RSSI encountered on the scanned channel."]
7808pub type otLinkRawEnergyScanDone =
7809 ::std::option::Option<unsafe extern "C" fn(aInstance: *mut otInstance, aEnergyScanMaxRssi: i8)>;
7810extern "C" {
7811 #[doc = " Begins the energy scan sequence on the radio.\n\n @param[in] aInstance A pointer to an OpenThread instance.\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 @param[in] aCallback A pointer to a function called on completion of a scanned channel.\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 @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7812 pub fn otLinkRawEnergyScan(
7813 aInstance: *mut otInstance,
7814 aScanChannel: u8,
7815 aScanDuration: u16,
7816 aCallback: otLinkRawEnergyScanDone,
7817 ) -> otError;
7818}
7819extern "C" {
7820 #[doc = " Enable/Disable source match for frame pending.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnable Enable/disable source match for frame pending.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7821 pub fn otLinkRawSrcMatchEnable(aInstance: *mut otInstance, aEnable: bool) -> otError;
7822}
7823extern "C" {
7824 #[doc = " Adding short address to the source match table.\n\n @param[in] aInstance A pointer to an OpenThread instance.\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 @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7825 pub fn otLinkRawSrcMatchAddShortEntry(
7826 aInstance: *mut otInstance,
7827 aShortAddress: u16,
7828 ) -> otError;
7829}
7830extern "C" {
7831 #[doc = " Adding extended address to the source match table.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress The extended address to be added.\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 @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7832 pub fn otLinkRawSrcMatchAddExtEntry(
7833 aInstance: *mut otInstance,
7834 aExtAddress: *const otExtAddress,
7835 ) -> otError;
7836}
7837extern "C" {
7838 #[doc = " Removing short address to the source match table.\n\n @param[in] aInstance A pointer to an OpenThread instance.\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 match table.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7839 pub fn otLinkRawSrcMatchClearShortEntry(
7840 aInstance: *mut otInstance,
7841 aShortAddress: u16,
7842 ) -> otError;
7843}
7844extern "C" {
7845 #[doc = " Removing extended address to the source match table of the radio.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress The extended address to be removed.\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 match table.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7846 pub fn otLinkRawSrcMatchClearExtEntry(
7847 aInstance: *mut otInstance,
7848 aExtAddress: *const otExtAddress,
7849 ) -> otError;
7850}
7851extern "C" {
7852 #[doc = " Removing all the short addresses from the source match table.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7853 pub fn otLinkRawSrcMatchClearShortEntries(aInstance: *mut otInstance) -> otError;
7854}
7855extern "C" {
7856 #[doc = " Removing all the extended addresses from the source match table.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7857 pub fn otLinkRawSrcMatchClearExtEntries(aInstance: *mut otInstance) -> otError;
7858}
7859extern "C" {
7860 #[doc = " Update MAC keys and key index.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aKeyIdMode The key ID mode.\n @param[in] aKeyId The key index.\n @param[in] aPrevKey The previous MAC key.\n @param[in] aCurrKey The current MAC key.\n @param[in] aNextKey The next MAC key.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7861 pub fn otLinkRawSetMacKey(
7862 aInstance: *mut otInstance,
7863 aKeyIdMode: u8,
7864 aKeyId: u8,
7865 aPrevKey: *const otMacKey,
7866 aCurrKey: *const otMacKey,
7867 aNextKey: *const otMacKey,
7868 ) -> otError;
7869}
7870extern "C" {
7871 #[doc = " Sets the current MAC frame counter value.\n\n Always sets the MAC counter to the new given value @p aMacFrameCounter independent of the current\n value.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMacFrameCounter The MAC frame counter value.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7872 pub fn otLinkRawSetMacFrameCounter(
7873 aInstance: *mut otInstance,
7874 aMacFrameCounter: u32,
7875 ) -> otError;
7876}
7877extern "C" {
7878 #[doc = " Sets the current MAC frame counter value only if the new value is larger than the current one.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMacFrameCounter The MAC frame counter value.\n\n @retval OT_ERROR_NONE If successful.\n @retval OT_ERROR_INVALID_STATE If the raw link-layer isn't enabled."]
7879 pub fn otLinkRawSetMacFrameCounterIfLarger(
7880 aInstance: *mut otInstance,
7881 aMacFrameCounter: u32,
7882 ) -> otError;
7883}
7884extern "C" {
7885 #[doc = " Get current platform time (64bits width) of the radio chip.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current radio time in microseconds."]
7886 pub fn otLinkRawGetRadioTime(aInstance: *mut otInstance) -> u64;
7887}
7888extern "C" {
7889 #[doc = " Returns the current log level.\n\n If dynamic log level feature `OPENTHREAD_CONFIG_LOG_LEVEL_DYNAMIC_ENABLE` is enabled, this function returns the\n currently set dynamic log level. Otherwise, this function returns the build-time configured log level.\n\n @returns The log level."]
7890 pub fn otLoggingGetLevel() -> otLogLevel;
7891}
7892extern "C" {
7893 #[doc = " Sets the log level.\n\n @note This function requires `OPENTHREAD_CONFIG_LOG_LEVEL_DYNAMIC_ENABLE=1`.\n\n @param[in] aLogLevel The log level.\n\n @retval OT_ERROR_NONE Successfully updated log level.\n @retval OT_ERROR_INVALID_ARGS Log level value is invalid."]
7894 pub fn otLoggingSetLevel(aLogLevel: otLogLevel) -> otError;
7895}
7896extern "C" {
7897 #[doc = " Emits a log message at critical log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below critical, this function does not emit any log message.\n\n @param[in] aFormat The format string.\n @param[in] ... Arguments for the format specification."]
7898 pub fn otLogCritPlat(aFormat: *const ::std::os::raw::c_char, ...);
7899}
7900extern "C" {
7901 #[doc = " Emits a log message at warning log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below warning, this function does not emit any log message.\n\n @param[in] aFormat The format string.\n @param[in] ... Arguments for the format specification."]
7902 pub fn otLogWarnPlat(aFormat: *const ::std::os::raw::c_char, ...);
7903}
7904extern "C" {
7905 #[doc = " Emits a log message at note log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below note, this function does not emit any log message.\n\n @param[in] aFormat The format string.\n @param[in] ... Arguments for the format specification."]
7906 pub fn otLogNotePlat(aFormat: *const ::std::os::raw::c_char, ...);
7907}
7908extern "C" {
7909 #[doc = " Emits a log message at info log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below info, this function does not emit any log message.\n\n @param[in] aFormat The format string.\n @param[in] ... Arguments for the format specification."]
7910 pub fn otLogInfoPlat(aFormat: *const ::std::os::raw::c_char, ...);
7911}
7912extern "C" {
7913 #[doc = " Emits a log message at debug log level.\n\n Is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below debug, this function does not emit any log message.\n\n @param[in] aFormat The format string.\n @param[in] ... Arguments for the format specification."]
7914 pub fn otLogDebgPlat(aFormat: *const ::std::os::raw::c_char, ...);
7915}
7916extern "C" {
7917 #[doc = " Generates a memory dump at critical log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n critical this function does not emit any log message.\n\n @param[in] aText A string that is printed before the bytes.\n @param[in] aData A pointer to the data buffer.\n @param[in] aDataLength Number of bytes in @p aData."]
7918 pub fn otDumpCritPlat(
7919 aText: *const ::std::os::raw::c_char,
7920 aData: *const ::std::os::raw::c_void,
7921 aDataLength: u16,
7922 );
7923}
7924extern "C" {
7925 #[doc = " Generates a memory dump at warning log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n warning this function does not emit any log message.\n\n @param[in] aText A string that is printed before the bytes.\n @param[in] aData A pointer to the data buffer.\n @param[in] aDataLength Number of bytes in @p aData."]
7926 pub fn otDumpWarnPlat(
7927 aText: *const ::std::os::raw::c_char,
7928 aData: *const ::std::os::raw::c_void,
7929 aDataLength: u16,
7930 );
7931}
7932extern "C" {
7933 #[doc = " Generates a memory dump at note log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n note this function does not emit any log message.\n\n @param[in] aText A string that is printed before the bytes.\n @param[in] aData A pointer to the data buffer.\n @param[in] aDataLength Number of bytes in @p aData."]
7934 pub fn otDumpNotePlat(
7935 aText: *const ::std::os::raw::c_char,
7936 aData: *const ::std::os::raw::c_void,
7937 aDataLength: u16,
7938 );
7939}
7940extern "C" {
7941 #[doc = " Generates a memory dump at info log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n info this function does not emit any log message.\n\n @param[in] aText A string that is printed before the bytes.\n @param[in] aData A pointer to the data buffer.\n @param[in] aDataLength Number of bytes in @p aData."]
7942 pub fn otDumpInfoPlat(
7943 aText: *const ::std::os::raw::c_char,
7944 aData: *const ::std::os::raw::c_void,
7945 aDataLength: u16,
7946 );
7947}
7948extern "C" {
7949 #[doc = " Generates a memory dump at debug log level.\n\n If `OPENTHREAD_CONFIG_LOG_PLATFORM` or `OPENTHREAD_CONFIG_LOG_PKT_DUMP` is not set or the current log level is below\n debug this function does not emit any log message.\n\n @param[in] aText A string that is printed before the bytes.\n @param[in] aData A pointer to the data buffer.\n @param[in] aDataLength Number of bytes in @p aData."]
7950 pub fn otDumpDebgPlat(
7951 aText: *const ::std::os::raw::c_char,
7952 aData: *const ::std::os::raw::c_void,
7953 aDataLength: u16,
7954 );
7955}
7956extern "C" {
7957 #[doc = " Emits a log message at given log level using a platform module name.\n\n This is is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below @p aLogLevel , this function does not emit any log message.\n\n The @p aPlatModuleName name is used to determine the log module name in the emitted log message, following the\n `P-{PlatModuleName}---` format. This means that the prefix string \"P-\" is added to indicate that this is a platform\n sub-module, followed by the next 12 characters of the @p PlatModuleName string, with padded hyphens `-` at the end\n to ensure that the region name is 14 characters long.\n\n @param[in] aLogLevel The log level.\n @param[in] aPlatModuleName The platform sub-module name.\n @param[in] aFormat The format string.\n @param[in] ... Arguments for the format specification."]
7958 pub fn otLogPlat(
7959 aLogLevel: otLogLevel,
7960 aPlatModuleName: *const ::std::os::raw::c_char,
7961 aFormat: *const ::std::os::raw::c_char,
7962 ...
7963 );
7964}
7965extern "C" {
7966 #[doc = " Emits a log message at given log level using a platform module name.\n\n This is is intended for use by platform. If `OPENTHREAD_CONFIG_LOG_PLATFORM` is not set or the current log\n level is below @p aLogLevel , this function does not emit any log message.\n\n The @p aPlatModuleName name is used to determine the log module name in the emitted log message, following the\n `P-{PlatModuleName}---` format. This means that the prefix string \"P-\" is added to indicate that this is a platform\n sub-module, followed by the next 12 characters of the @p PlatModuleName string, with padded hyphens `-` at the end\n to ensure that the region name is 14 characters long.\n\n @param[in] aLogLevel The log level.\n @param[in] aPlatModuleName The platform sub-module name.\n @param[in] aFormat The format string.\n @param[in] aArgs Arguments for the format specification."]
7967 pub fn otLogPlatArgs(
7968 aLogLevel: otLogLevel,
7969 aPlatModuleName: *const ::std::os::raw::c_char,
7970 aFormat: *const ::std::os::raw::c_char,
7971 aArgs: *mut __va_list_tag,
7972 );
7973}
7974extern "C" {
7975 #[doc = " Emits a log message at a given log level.\n\n Is intended for use by CLI only. If `OPENTHREAD_CONFIG_LOG_CLI` is not set or the current log\n level is below the given log level, this function does not emit any log message.\n\n @param[in] aLogLevel The log level.\n @param[in] aFormat The format string.\n @param[in] ... Arguments for the format specification."]
7976 pub fn otLogCli(aLogLevel: otLogLevel, aFormat: *const ::std::os::raw::c_char, ...);
7977}
7978#[doc = " Represents information used for generating hex dump output."]
7979#[repr(C)]
7980#[derive(Debug, Copy, Clone)]
7981pub struct otLogHexDumpInfo {
7982 #[doc = "< The data byes."]
7983 pub mDataBytes: *const u8,
7984 #[doc = "< The data length (number of bytes in @p mDataBytes)"]
7985 pub mDataLength: u16,
7986 #[doc = "< Title string to add table header (MUST NOT be `NULL`)."]
7987 pub mTitle: *const ::std::os::raw::c_char,
7988 #[doc = "< Buffer to output one line of generated hex dump."]
7989 pub mLine: [::std::os::raw::c_char; 73usize],
7990 #[doc = "< Iterator used by OT stack. MUST be initialized to zero."]
7991 pub mIterator: u16,
7992}
7993impl Default for otLogHexDumpInfo {
7994 fn default() -> Self {
7995 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7996 unsafe {
7997 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7998 s.assume_init()
7999 }
8000 }
8001}
8002extern "C" {
8003 #[doc = " Generates the next hex dump line.\n\n Can call this method back-to-back to generate the hex dump output line by line. On the first call the `mIterator`\n field in @p aInfo MUST be set to zero.\n\n Here is an example of the generated hex dump output:\n\n \"==========================[{mTitle} len=070]============================\"\n \"| 41 D8 87 34 12 FF FF 25 | 4C 57 DA F2 FB 2F 62 7F | A..4...%LW.../b. |\"\n \"| 3B 01 F0 4D 4C 4D 4C 54 | 4F 00 15 15 00 00 00 00 | ;..MLMLTO....... |\"\n \"| 00 00 00 01 80 DB 60 82 | 7E 33 72 3B CC B3 A1 84 | ......`.~3r;.... |\"\n \"| 3B E6 AD B2 0B 45 E7 45 | C5 B9 00 1A CB 2D 6D 1C | ;....E.E.....-m. |\"\n \"| 10 3E 3C F5 D3 70 | | .><..p |\"\n \"------------------------------------------------------------------------\"\n\n @param[in,out] aInfo A pointer to `otLogHexDumpInfo` to use to generate hex dump.\n\n @retval OT_ERROR_NONE Successfully generated the next line, `mLine` field in @p aInfo is updated.\n @retval OT_ERROR_NOT_FOUND Reached the end and no more line to generate."]
8004 pub fn otLogGenerateNextHexDumpLine(aInfo: *mut otLogHexDumpInfo) -> otError;
8005}
8006#[doc = " Represents information associated with a radio link."]
8007#[repr(C)]
8008#[derive(Debug, Default, Copy, Clone)]
8009pub struct otRadioLinkInfo {
8010 #[doc = "< Preference level of radio link"]
8011 pub mPreference: u8,
8012}
8013#[doc = " Represents multi radio link information associated with a neighbor."]
8014#[repr(C)]
8015#[derive(Debug, Default, Copy, Clone)]
8016pub struct otMultiRadioNeighborInfo {
8017 pub _bitfield_align_1: [u8; 0],
8018 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8019 #[doc = "< Additional info for 15.4 radio link (applicable when supported)."]
8020 pub mIeee802154Info: otRadioLinkInfo,
8021 #[doc = "< Additional info for TREL radio link (applicable when supported)."]
8022 pub mTrelUdp6Info: otRadioLinkInfo,
8023}
8024impl otMultiRadioNeighborInfo {
8025 #[inline]
8026 pub fn mSupportsIeee802154(&self) -> bool {
8027 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8028 }
8029 #[inline]
8030 pub fn set_mSupportsIeee802154(&mut self, val: bool) {
8031 unsafe {
8032 let val: u8 = ::std::mem::transmute(val);
8033 self._bitfield_1.set(0usize, 1u8, val as u64)
8034 }
8035 }
8036 #[inline]
8037 pub fn mSupportsTrelUdp6(&self) -> bool {
8038 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8039 }
8040 #[inline]
8041 pub fn set_mSupportsTrelUdp6(&mut self, val: bool) {
8042 unsafe {
8043 let val: u8 = ::std::mem::transmute(val);
8044 self._bitfield_1.set(1usize, 1u8, val as u64)
8045 }
8046 }
8047 #[inline]
8048 pub fn new_bitfield_1(
8049 mSupportsIeee802154: bool,
8050 mSupportsTrelUdp6: bool,
8051 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8052 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8053 __bindgen_bitfield_unit.set(0usize, 1u8, {
8054 let mSupportsIeee802154: u8 = unsafe { ::std::mem::transmute(mSupportsIeee802154) };
8055 mSupportsIeee802154 as u64
8056 });
8057 __bindgen_bitfield_unit.set(1usize, 1u8, {
8058 let mSupportsTrelUdp6: u8 = unsafe { ::std::mem::transmute(mSupportsTrelUdp6) };
8059 mSupportsTrelUdp6 as u64
8060 });
8061 __bindgen_bitfield_unit
8062 }
8063}
8064extern "C" {
8065 #[doc = " Gets the multi radio link information associated with a neighbor with a given Extended Address.\n\n `OPENTHREAD_CONFIG_MULTI_RADIO` must be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress The Extended Address of neighbor.\n @param[out] aNeighborInfo A pointer to `otMultiRadioNeighborInfo` to output the neighbor info (on success).\n\n @retval OT_ERROR_NONE Neighbor was found and @p aNeighborInfo was updated successfully.\n @retval OT_ERROR_NOT_FOUND Could not find a neighbor with @p aExtAddress."]
8066 pub fn otMultiRadioGetNeighborInfo(
8067 aInstance: *mut otInstance,
8068 aExtAddress: *const otExtAddress,
8069 aNeighborInfo: *mut otMultiRadioNeighborInfo,
8070 ) -> otError;
8071}
8072#[doc = " @struct otIp4Address\n\n Represents an IPv4 address."]
8073#[repr(C, packed)]
8074#[derive(Copy, Clone)]
8075pub struct otIp4Address {
8076 pub mFields: otIp4Address__bindgen_ty_1,
8077}
8078#[repr(C, packed)]
8079#[derive(Copy, Clone)]
8080pub union otIp4Address__bindgen_ty_1 {
8081 #[doc = "< 8-bit fields"]
8082 pub m8: [u8; 4usize],
8083 #[doc = "< 32-bit representation"]
8084 pub m32: u32,
8085}
8086impl Default for otIp4Address__bindgen_ty_1 {
8087 fn default() -> Self {
8088 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8089 unsafe {
8090 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8091 s.assume_init()
8092 }
8093 }
8094}
8095impl Default for otIp4Address {
8096 fn default() -> Self {
8097 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8098 unsafe {
8099 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8100 s.assume_init()
8101 }
8102 }
8103}
8104#[doc = " @struct otIp4Cidr\n\n Represents an IPv4 CIDR block."]
8105#[repr(C)]
8106#[derive(Copy, Clone)]
8107pub struct otIp4Cidr {
8108 pub mAddress: otIp4Address,
8109 pub mLength: u8,
8110}
8111impl Default for otIp4Cidr {
8112 fn default() -> Self {
8113 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8114 unsafe {
8115 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8116 s.assume_init()
8117 }
8118 }
8119}
8120#[doc = " Represents the counters for NAT64."]
8121#[repr(C)]
8122#[derive(Debug, Default, Copy, Clone)]
8123pub struct otNat64Counters {
8124 #[doc = "< Number of packets translated from IPv4 to IPv6."]
8125 pub m4To6Packets: u64,
8126 #[doc = "< Sum of size of packets translated from IPv4 to IPv6."]
8127 pub m4To6Bytes: u64,
8128 #[doc = "< Number of packets translated from IPv6 to IPv4."]
8129 pub m6To4Packets: u64,
8130 #[doc = "< Sum of size of packets translated from IPv6 to IPv4."]
8131 pub m6To4Bytes: u64,
8132}
8133#[doc = " Represents the counters for the protocols supported by NAT64."]
8134#[repr(C)]
8135#[derive(Debug, Default, Copy, Clone)]
8136pub struct otNat64ProtocolCounters {
8137 #[doc = "< Counters for sum of all protocols."]
8138 pub mTotal: otNat64Counters,
8139 #[doc = "< Counters for ICMP and ICMPv6."]
8140 pub mIcmp: otNat64Counters,
8141 #[doc = "< Counters for UDP."]
8142 pub mUdp: otNat64Counters,
8143 #[doc = "< Counters for TCP."]
8144 pub mTcp: otNat64Counters,
8145}
8146#[doc = "< Packet drop for unknown reasons."]
8147pub const OT_NAT64_DROP_REASON_UNKNOWN: otNat64DropReason = 0;
8148#[doc = "< Packet drop due to failed to parse the datagram."]
8149pub const OT_NAT64_DROP_REASON_ILLEGAL_PACKET: otNat64DropReason = 1;
8150#[doc = "< Packet drop due to unsupported IP protocol."]
8151pub const OT_NAT64_DROP_REASON_UNSUPPORTED_PROTO: otNat64DropReason = 2;
8152#[doc = "< Packet drop due to no mappings found or mapping pool exhausted."]
8153pub const OT_NAT64_DROP_REASON_NO_MAPPING: otNat64DropReason = 3;
8154pub const OT_NAT64_DROP_REASON_COUNT: otNat64DropReason = 4;
8155#[doc = " Packet drop reasons."]
8156pub type otNat64DropReason = ::std::os::raw::c_uint;
8157#[doc = " Represents the counters of dropped packets due to errors when handling NAT64 packets."]
8158#[repr(C)]
8159#[derive(Debug, Default, Copy, Clone)]
8160pub struct otNat64ErrorCounters {
8161 #[doc = "< Errors translating IPv4 packets."]
8162 pub mCount4To6: [u64; 4usize],
8163 #[doc = "< Errors translating IPv6 packets."]
8164 pub mCount6To4: [u64; 4usize],
8165}
8166extern "C" {
8167 #[doc = " Gets NAT64 translator counters.\n\n The counter is counted since the instance initialized.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aCounters A pointer to an `otNat64Counters` where the counters of NAT64 translator will be placed."]
8168 pub fn otNat64GetCounters(aInstance: *mut otInstance, aCounters: *mut otNat64ProtocolCounters);
8169}
8170extern "C" {
8171 #[doc = " Gets the NAT64 translator error counters.\n\n The counters are initialized to zero when the OpenThread instance is initialized.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aCounters A pointer to an `otNat64Counters` where the counters of NAT64 translator will be placed."]
8172 pub fn otNat64GetErrorCounters(
8173 aInstance: *mut otInstance,
8174 aCounters: *mut otNat64ErrorCounters,
8175 );
8176}
8177#[doc = " Represents an address mapping record for NAT64.\n\n @note The counters will be reset for each mapping session even for the same address pair. Applications can use `mId`\n to identify different sessions to calculate the packets correctly."]
8178#[repr(C)]
8179#[derive(Copy, Clone)]
8180pub struct otNat64AddressMapping {
8181 #[doc = "< The unique id for a mapping session."]
8182 pub mId: u64,
8183 #[doc = "< The IPv4 address of the mapping."]
8184 pub mIp4: otIp4Address,
8185 #[doc = "< The IPv6 address of the mapping."]
8186 pub mIp6: otIp6Address,
8187 #[doc = " The source port or ICMP ID of the mapping. Used when\n OPENTHREAD_CONFIG_NAT64_PORT_TRANSLATION_ENABLE is true."]
8188 pub mSrcPortOrId: u16,
8189 #[doc = " The translated port or ICMP ID of the mapping. Used when\n OPENTHREAD_CONFIG_NAT64_PORT_TRANSLATION_ENABLE is true."]
8190 pub mTranslatedPortOrId: u16,
8191 #[doc = "< Remaining time before expiry in milliseconds."]
8192 pub mRemainingTimeMs: u32,
8193 pub mCounters: otNat64ProtocolCounters,
8194}
8195impl Default for otNat64AddressMapping {
8196 fn default() -> Self {
8197 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8198 unsafe {
8199 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8200 s.assume_init()
8201 }
8202 }
8203}
8204#[doc = " Used to iterate through NAT64 address mappings.\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 `otNat64AddressMappingIteratorInit()`."]
8205#[repr(C)]
8206#[derive(Debug, Copy, Clone)]
8207pub struct otNat64AddressMappingIterator {
8208 pub mPtr: *mut ::std::os::raw::c_void,
8209}
8210impl Default for otNat64AddressMappingIterator {
8211 fn default() -> Self {
8212 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8213 unsafe {
8214 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8215 s.assume_init()
8216 }
8217 }
8218}
8219extern "C" {
8220 #[doc = " Initializes an `otNat64AddressMappingIterator`.\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 mapping info.\n\n @param[in] aInstance The OpenThread instance.\n @param[out] aIterator A pointer to the iterator to initialize."]
8221 pub fn otNat64InitAddressMappingIterator(
8222 aInstance: *mut otInstance,
8223 aIterator: *mut otNat64AddressMappingIterator,
8224 );
8225}
8226extern "C" {
8227 #[doc = " Gets the next AddressMapping info (using an iterator).\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\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 NAT64 address mapping record. To get the first entry the iterator should be set to\n OT_NAT64_ADDRESS_MAPPING_ITERATOR_INIT.\n @param[out] aMapping A pointer to an `otNat64AddressMapping` where information of next NAT64 address\n mapping record is placed (on success).\n\n @retval OT_ERROR_NONE Successfully found the next NAT64 address mapping info (@p aMapping was successfully\n updated).\n @retval OT_ERROR_NOT_FOUND No subsequent NAT64 address mapping info was found."]
8228 pub fn otNat64GetNextAddressMapping(
8229 aInstance: *mut otInstance,
8230 aIterator: *mut otNat64AddressMappingIterator,
8231 aMapping: *mut otNat64AddressMapping,
8232 ) -> otError;
8233}
8234#[doc = "< NAT64 is disabled."]
8235pub const OT_NAT64_STATE_DISABLED: otNat64State = 0;
8236#[doc = "< NAT64 is enabled, but one or more dependencies of NAT64 are not running."]
8237pub const OT_NAT64_STATE_NOT_RUNNING: otNat64State = 1;
8238#[doc = "< NAT64 is enabled, but this BR is not an active NAT64 BR."]
8239pub const OT_NAT64_STATE_IDLE: otNat64State = 2;
8240#[doc = "< The BR is publishing a NAT64 prefix and/or translating packets."]
8241pub const OT_NAT64_STATE_ACTIVE: otNat64State = 3;
8242#[doc = " States of NAT64."]
8243pub type otNat64State = ::std::os::raw::c_uint;
8244extern "C" {
8245 #[doc = " Gets the state of NAT64 translator.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_NAT64_STATE_DISABLED NAT64 translator is disabled.\n @retval OT_NAT64_STATE_NOT_RUNNING NAT64 translator is enabled, but the translator is not configured with a valid\n NAT64 prefix and a CIDR.\n @retval OT_NAT64_STATE_ACTIVE NAT64 translator is enabled, and is translating packets."]
8246 pub fn otNat64GetTranslatorState(aInstance: *mut otInstance) -> otNat64State;
8247}
8248extern "C" {
8249 #[doc = " Gets the state of NAT64 prefix manager.\n\n Available when `OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_NAT64_STATE_DISABLED NAT64 prefix manager is disabled.\n @retval OT_NAT64_STATE_NOT_RUNNING NAT64 prefix manager is enabled, but is not running (because the routing manager\n is not running).\n @retval OT_NAT64_STATE_IDLE NAT64 prefix manager is enabled, but is not publishing a NAT64 prefix. Usually\n when there is another border router publishing a NAT64 prefix with higher\n priority.\n @retval OT_NAT64_STATE_ACTIVE NAT64 prefix manager is enabled, and is publishing NAT64 prefix to the Thread\n network."]
8250 pub fn otNat64GetPrefixManagerState(aInstance: *mut otInstance) -> otNat64State;
8251}
8252extern "C" {
8253 #[doc = " Enable or disable NAT64 functions.\n\n Note: This includes the NAT64 Translator (when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled) and the NAT64\n Prefix Manager (when `OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE` is enabled).\n\n When `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled, setting disabled to true resets the\n mapping table in the translator.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` or `OPENTHREAD_CONFIG_NAT64_BORDER_ROUTING_ENABLE` is\n enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled A boolean to enable/disable the NAT64 functions\n\n @sa otNat64GetTranslatorState\n @sa otNat64GetPrefixManagerState"]
8254 pub fn otNat64SetEnabled(aInstance: *mut otInstance, aEnabled: bool);
8255}
8256extern "C" {
8257 #[doc = " Allocate a new message buffer for sending an IPv4 message to the NAT64 translator.\n\n Message buffers allocated by this function will have 20 bytes (difference between the size of IPv6 headers\n and IPv4 header sizes) reserved.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\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 otNat64Send"]
8258 pub fn otIp4NewMessage(
8259 aInstance: *mut otInstance,
8260 aSettings: *const otMessageSettings,
8261 ) -> *mut otMessage;
8262}
8263extern "C" {
8264 #[doc = " Sets the CIDR used when setting the source address of the outgoing translated IPv4 packets.\n\n Is available only when OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE is enabled.\n\n @note A valid CIDR must have a non-zero prefix length. The actual addresses pool is limited by the size of the\n mapping pool and the number of addresses available in the CIDR block.\n\n @note This function can be called at any time, but the NAT64 translator will be reset and all existing sessions will\n be expired when updating the configured CIDR.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCidr A pointer to an otIp4Cidr for the IPv4 CIDR block for NAT64.\n\n @retval OT_ERROR_INVALID_ARGS The given CIDR is not a valid IPv4 CIDR for NAT64.\n @retval OT_ERROR_NONE Successfully set the CIDR for NAT64.\n\n @sa otNat64Send\n @sa otNat64SetReceiveIp4Callback"]
8265 pub fn otNat64SetIp4Cidr(aInstance: *mut otInstance, aCidr: *const otIp4Cidr) -> otError;
8266}
8267extern "C" {
8268 #[doc = " Clears the CIDR used when setting the source address of the outgoing translated IPv4 packets.\n\n Is available only when OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE is enabled.\n\n @note This function can be called at any time, but the NAT64 translator will be reset and all existing sessions\n will be expired when clearing the configured CIDR.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @sa otNat64SetIp4Cidr"]
8269 pub fn otNat64ClearIp4Cidr(aInstance: *mut otInstance);
8270}
8271extern "C" {
8272 #[doc = " Translates an IPv4 datagram to an IPv6 datagram and sends 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 IPv4 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."]
8273 pub fn otNat64Send(aInstance: *mut otInstance, aMessage: *mut otMessage) -> otError;
8274}
8275#[doc = " Pointer is called when an IPv4 datagram (translated by NAT64 translator) 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.\n @param[in] aContext A pointer to application-specific context."]
8276pub type otNat64ReceiveIp4Callback = ::std::option::Option<
8277 unsafe extern "C" fn(aMessage: *mut otMessage, aContext: *mut ::std::os::raw::c_void),
8278>;
8279extern "C" {
8280 #[doc = " Registers a callback to provide received IPv4 datagrams.\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 IPv4 datagram is received or\n NULL to disable the callback.\n @param[in] aContext A pointer to application-specific context."]
8281 pub fn otNat64SetReceiveIp4Callback(
8282 aInstance: *mut otInstance,
8283 aCallback: otNat64ReceiveIp4Callback,
8284 aContext: *mut ::std::os::raw::c_void,
8285 );
8286}
8287extern "C" {
8288 #[doc = " Gets the IPv4 CIDR configured in the NAT64 translator.\n\n Available when `OPENTHREAD_CONFIG_NAT64_TRANSLATOR_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aCidr A pointer to an otIp4Cidr. Where the CIDR will be filled."]
8289 pub fn otNat64GetCidr(aInstance: *mut otInstance, aCidr: *mut otIp4Cidr) -> otError;
8290}
8291extern "C" {
8292 #[doc = " Test if two IPv4 addresses are the same.\n\n @param[in] aFirst A pointer to the first IPv4 address to compare.\n @param[in] aSecond A pointer to the second IPv4 address to compare.\n\n @retval TRUE The two IPv4 addresses are the same.\n @retval FALSE The two IPv4 addresses are not the same."]
8293 pub fn otIp4IsAddressEqual(aFirst: *const otIp4Address, aSecond: *const otIp4Address) -> bool;
8294}
8295extern "C" {
8296 #[doc = " Set @p aIp4Address by performing NAT64 address translation from @p aIp6Address as specified\n in RFC 6052.\n\n The NAT64 @p aPrefixLength MUST be one of the following values: 32, 40, 48, 56, 64, or 96, otherwise the behavior\n of this method is undefined.\n\n @param[in] aPrefixLength The prefix length to use for IPv4/IPv6 translation.\n @param[in] aIp6Address A pointer to an IPv6 address.\n @param[out] aIp4Address A pointer to output the IPv4 address."]
8297 pub fn otIp4ExtractFromIp6Address(
8298 aPrefixLength: u8,
8299 aIp6Address: *const otIp6Address,
8300 aIp4Address: *mut otIp4Address,
8301 );
8302}
8303extern "C" {
8304 #[doc = " Extracts the IPv4 address from a given IPv4-mapped IPv6 address.\n\n An IPv4-mapped IPv6 address consists of an 80-bit prefix of zeros, the next 16 bits set to ones, and the remaining,\n least-significant 32 bits contain the IPv4 address, e.g., `::ffff:192.0.2.128` representing `192.0.2.128`.\n\n @param[in] aIp6Address An IPv6 address to extract IPv4 from.\n @param[out] aIp4Address An IPv4 address to output the extracted address.\n\n @retval OT_ERROR_NONE Extracted the IPv4 address successfully. @p aIp4Address is updated.\n @retval OT_ERROR_PARSE The @p aIp6Address does not follow the IPv4-mapped IPv6 address format."]
8305 pub fn otIp4FromIp4MappedIp6Address(
8306 aIp6Address: *const otIp6Address,
8307 aIp4Address: *mut otIp4Address,
8308 ) -> otError;
8309}
8310extern "C" {
8311 #[doc = " Converts a given IP4 address to an IPv6 address following the IPv4-mapped IPv6 address format.\n\n @param[in] aIp4Address An IPv4 address to convert.\n @param[out] aIp6Address An IPv6 address to set."]
8312 pub fn otIp4ToIp4MappedIp6Address(
8313 aIp4Address: *const otIp4Address,
8314 aIp6Address: *mut otIp6Address,
8315 );
8316}
8317extern "C" {
8318 #[doc = " Converts the address to a string.\n\n The string format uses quad-dotted notation of four bytes in the address (e.g., \"127.0.0.1\").\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be\n truncated but the outputted string is always null-terminated.\n\n @param[in] aAddress A pointer to an IPv4 address (MUST NOT be NULL).\n @param[out] aBuffer A pointer to a char array to output the string (MUST NOT be `nullptr`).\n @param[in] aSize The size of @p aBuffer (in bytes)."]
8319 pub fn otIp4AddressToString(
8320 aAddress: *const otIp4Address,
8321 aBuffer: *mut ::std::os::raw::c_char,
8322 aSize: u16,
8323 );
8324}
8325extern "C" {
8326 #[doc = " Converts a human-readable IPv4 CIDR string into a binary representation.\n\n @param[in] aString A pointer to a NULL-terminated string.\n @param[out] aCidr A pointer to an IPv4 CIDR.\n\n @retval OT_ERROR_NONE Successfully parsed the string.\n @retval OT_ERROR_INVALID_ARGS Failed to parse the string."]
8327 pub fn otIp4CidrFromString(
8328 aString: *const ::std::os::raw::c_char,
8329 aCidr: *mut otIp4Cidr,
8330 ) -> otError;
8331}
8332extern "C" {
8333 #[doc = " Converts the IPv4 CIDR to a string.\n\n The string format uses quad-dotted notation of four bytes in the address with the length of prefix (e.g.,\n \"127.0.0.1/32\").\n\n If the resulting string does not fit in @p aBuffer (within its @p aSize characters), the string will be\n truncated but the outputted string is always null-terminated.\n\n @param[in] aCidr A pointer to an IPv4 CIDR (MUST NOT be NULL).\n @param[out] aBuffer A pointer to a char array to output the string (MUST NOT be `nullptr`).\n @param[in] aSize The size of @p aBuffer (in bytes)."]
8334 pub fn otIp4CidrToString(
8335 aCidr: *const otIp4Cidr,
8336 aBuffer: *mut ::std::os::raw::c_char,
8337 aSize: u16,
8338 );
8339}
8340extern "C" {
8341 #[doc = " Converts a human-readable IPv4 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 IPv4 address.\n\n @retval OT_ERROR_NONE Successfully parsed the string.\n @retval OT_ERROR_INVALID_ARGS Failed to parse the string."]
8342 pub fn otIp4AddressFromString(
8343 aString: *const ::std::os::raw::c_char,
8344 aAddress: *mut otIp4Address,
8345 ) -> otError;
8346}
8347extern "C" {
8348 #[doc = " Sets the IPv6 address by performing NAT64 address translation from the preferred NAT64 prefix and the given IPv4\n address as specified in RFC 6052.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aIp4Address A pointer to the IPv4 address to translate to IPv6.\n @param[out] aIp6Address A pointer to the synthesized IPv6 address.\n\n @returns OT_ERROR_NONE Successfully synthesized the IPv6 address from NAT64 prefix and IPv4 address.\n @returns OT_ERROR_INVALID_STATE No valid NAT64 prefix in the network data."]
8349 pub fn otNat64SynthesizeIp6Address(
8350 aInstance: *mut otInstance,
8351 aIp4Address: *const otIp4Address,
8352 aIp6Address: *mut otIp6Address,
8353 ) -> otError;
8354}
8355#[doc = " Pointer is called to send HDLC encoded NCP data.\n\n @param[in] aBuf A pointer to a buffer with an output.\n @param[in] aBufLength A length of the output data stored in the buffer.\n\n @returns Number of bytes processed by the callback."]
8356pub type otNcpHdlcSendCallback = ::std::option::Option<
8357 unsafe extern "C" fn(aBuf: *const u8, aBufLength: u16) -> ::std::os::raw::c_int,
8358>;
8359extern "C" {
8360 #[doc = " Is called after NCP send finished."]
8361 pub fn otNcpHdlcSendDone();
8362}
8363extern "C" {
8364 #[doc = " Is called after HDLC encoded NCP data received.\n\n @param[in] aBuf A pointer to a buffer.\n @param[in] aBufLength The length of the data stored in the buffer."]
8365 pub fn otNcpHdlcReceive(aBuf: *const u8, aBufLength: u16);
8366}
8367extern "C" {
8368 #[doc = " Initialize the NCP based on HDLC framing.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aSendCallback The function pointer used to send NCP data."]
8369 pub fn otNcpHdlcInit(aInstance: *mut otInstance, aSendCallback: otNcpHdlcSendCallback);
8370}
8371extern "C" {
8372 #[doc = " Initialize the NCP based on HDLC framing.\n\n @param[in] aInstances The OpenThread instance pointers array.\n @param[in] aCount Number of elements in the array.\n @param[in] aSendCallback The function pointer used to send NCP data."]
8373 pub fn otNcpHdlcInitMulti(
8374 aInstance: *mut *mut otInstance,
8375 aCount: u8,
8376 aSendCallback: otNcpHdlcSendCallback,
8377 );
8378}
8379extern "C" {
8380 #[doc = " Initialize the NCP based on SPI framing.\n\n @param[in] aInstance The OpenThread instance structure."]
8381 pub fn otNcpSpiInit(aInstance: *mut otInstance);
8382}
8383extern "C" {
8384 #[doc = " @brief Send data to the host via a specific stream.\n\n Attempts to send the given data to the host\n using the given aStreamId. This is useful for reporting\n error messages, implementing debug/diagnostic consoles,\n and potentially other types of datastreams.\n\n The write either is accepted in its entirety or rejected.\n Partial writes are not attempted.\n\n @param[in] aStreamId A numeric identifier for the stream to write to.\n If set to '0', will default to the debug stream.\n @param[in] aDataPtr A pointer to the data to send on the stream.\n If aDataLen is non-zero, this param MUST NOT be NULL.\n @param[in] aDataLen The number of bytes of data from aDataPtr to send.\n\n @retval OT_ERROR_NONE The data was queued for delivery to the host.\n @retval OT_ERROR_BUSY There are not enough resources to complete this\n request. This is usually a temporary condition.\n @retval OT_ERROR_INVALID_ARGS The given aStreamId was invalid."]
8385 pub fn otNcpStreamWrite(
8386 aStreamId: ::std::os::raw::c_int,
8387 aDataPtr: *const u8,
8388 aDataLen: ::std::os::raw::c_int,
8389 ) -> otError;
8390}
8391extern "C" {
8392 #[doc = " Writes OpenThread Log using `otNcpStreamWrite`.\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."]
8393 pub fn otNcpPlatLogv(
8394 aLogLevel: otLogLevel,
8395 aLogRegion: otLogRegion,
8396 aFormat: *const ::std::os::raw::c_char,
8397 aArgs: *mut __va_list_tag,
8398 );
8399}
8400#[doc = " Defines delegate (function pointer) type to control behavior of peek/poke operation.\n\n This delegate function is called to decide whether to allow peek or poke of a specific memory region. It is used\n if NCP support for peek/poke commands is enabled.\n\n @param[in] aAddress Start address of memory region.\n @param[in] aCount Number of bytes to peek or poke.\n\n @returns TRUE to allow peek/poke of the given memory region, FALSE otherwise."]
8401pub type otNcpDelegateAllowPeekPoke =
8402 ::std::option::Option<unsafe extern "C" fn(aAddress: u32, aCount: u16) -> bool>;
8403extern "C" {
8404 #[doc = " Registers peek/poke delegate functions with NCP module.\n\n The delegate functions are called by NCP module to decide whether to allow peek or poke of a specific memory region.\n If the delegate pointer is set to NULL, it allows peek/poke operation for any address.\n\n @param[in] aAllowPeekDelegate Delegate function pointer for peek operation.\n @param[in] aAllowPokeDelegate Delegate function pointer for poke operation."]
8405 pub fn otNcpRegisterPeekPokeDelegates(
8406 aAllowPeekDelegate: otNcpDelegateAllowPeekPoke,
8407 aAllowPokeDelegate: otNcpDelegateAllowPeekPoke,
8408 );
8409}
8410#[doc = "< The Thread stack is disabled."]
8411pub const OT_DEVICE_ROLE_DISABLED: otDeviceRole = 0;
8412#[doc = "< Not currently participating in a Thread network/partition."]
8413pub const OT_DEVICE_ROLE_DETACHED: otDeviceRole = 1;
8414#[doc = "< The Thread Child role."]
8415pub const OT_DEVICE_ROLE_CHILD: otDeviceRole = 2;
8416#[doc = "< The Thread Router role."]
8417pub const OT_DEVICE_ROLE_ROUTER: otDeviceRole = 3;
8418#[doc = "< The Thread Leader role."]
8419pub const OT_DEVICE_ROLE_LEADER: otDeviceRole = 4;
8420#[doc = " Represents a Thread device role."]
8421pub type otDeviceRole = ::std::os::raw::c_uint;
8422#[doc = " Represents an MLE Link Mode configuration."]
8423#[repr(C, packed)]
8424#[derive(Debug, Default, Copy, Clone)]
8425pub struct otLinkModeConfig {
8426 pub _bitfield_align_1: [u8; 0],
8427 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8428}
8429impl otLinkModeConfig {
8430 #[inline]
8431 pub fn mRxOnWhenIdle(&self) -> bool {
8432 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8433 }
8434 #[inline]
8435 pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
8436 unsafe {
8437 let val: u8 = ::std::mem::transmute(val);
8438 self._bitfield_1.set(0usize, 1u8, val as u64)
8439 }
8440 }
8441 #[inline]
8442 pub fn mDeviceType(&self) -> bool {
8443 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8444 }
8445 #[inline]
8446 pub fn set_mDeviceType(&mut self, val: bool) {
8447 unsafe {
8448 let val: u8 = ::std::mem::transmute(val);
8449 self._bitfield_1.set(1usize, 1u8, val as u64)
8450 }
8451 }
8452 #[inline]
8453 pub fn mNetworkData(&self) -> bool {
8454 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
8455 }
8456 #[inline]
8457 pub fn set_mNetworkData(&mut self, val: bool) {
8458 unsafe {
8459 let val: u8 = ::std::mem::transmute(val);
8460 self._bitfield_1.set(2usize, 1u8, val as u64)
8461 }
8462 }
8463 #[inline]
8464 pub fn new_bitfield_1(
8465 mRxOnWhenIdle: bool,
8466 mDeviceType: bool,
8467 mNetworkData: bool,
8468 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8469 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8470 __bindgen_bitfield_unit.set(0usize, 1u8, {
8471 let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
8472 mRxOnWhenIdle as u64
8473 });
8474 __bindgen_bitfield_unit.set(1usize, 1u8, {
8475 let mDeviceType: u8 = unsafe { ::std::mem::transmute(mDeviceType) };
8476 mDeviceType as u64
8477 });
8478 __bindgen_bitfield_unit.set(2usize, 1u8, {
8479 let mNetworkData: u8 = unsafe { ::std::mem::transmute(mNetworkData) };
8480 mNetworkData as u64
8481 });
8482 __bindgen_bitfield_unit
8483 }
8484}
8485#[doc = " Holds diagnostic information for a neighboring Thread node"]
8486#[repr(C)]
8487#[derive(Debug, Default, Copy, Clone)]
8488pub struct otNeighborInfo {
8489 #[doc = "< IEEE 802.15.4 Extended Address"]
8490 pub mExtAddress: otExtAddress,
8491 #[doc = "< Seconds since last heard"]
8492 pub mAge: u32,
8493 #[doc = "< Seconds since link establishment (requires `CONFIG_UPTIME_ENABLE`)"]
8494 pub mConnectionTime: u32,
8495 #[doc = "< RLOC16"]
8496 pub mRloc16: u16,
8497 #[doc = "< Link Frame Counter"]
8498 pub mLinkFrameCounter: u32,
8499 #[doc = "< MLE Frame Counter"]
8500 pub mMleFrameCounter: u32,
8501 #[doc = "< Link Quality In"]
8502 pub mLinkQualityIn: u8,
8503 #[doc = "< Average RSSI"]
8504 pub mAverageRssi: i8,
8505 #[doc = "< Last observed RSSI"]
8506 pub mLastRssi: i8,
8507 #[doc = "< Link Margin"]
8508 pub mLinkMargin: u8,
8509 #[doc = "< Frame error rate (0xffff->100%). Requires error tracking feature."]
8510 pub mFrameErrorRate: u16,
8511 #[doc = "< (IPv6) msg error rate (0xffff->100%). Requires error tracking feature."]
8512 pub mMessageErrorRate: u16,
8513 #[doc = "< Thread version of the neighbor"]
8514 pub mVersion: u16,
8515 pub _bitfield_align_1: [u8; 0],
8516 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8517 pub __bindgen_padding_0: u8,
8518}
8519impl otNeighborInfo {
8520 #[inline]
8521 pub fn mRxOnWhenIdle(&self) -> bool {
8522 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8523 }
8524 #[inline]
8525 pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
8526 unsafe {
8527 let val: u8 = ::std::mem::transmute(val);
8528 self._bitfield_1.set(0usize, 1u8, val as u64)
8529 }
8530 }
8531 #[inline]
8532 pub fn mFullThreadDevice(&self) -> bool {
8533 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8534 }
8535 #[inline]
8536 pub fn set_mFullThreadDevice(&mut self, val: bool) {
8537 unsafe {
8538 let val: u8 = ::std::mem::transmute(val);
8539 self._bitfield_1.set(1usize, 1u8, val as u64)
8540 }
8541 }
8542 #[inline]
8543 pub fn mFullNetworkData(&self) -> bool {
8544 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
8545 }
8546 #[inline]
8547 pub fn set_mFullNetworkData(&mut self, val: bool) {
8548 unsafe {
8549 let val: u8 = ::std::mem::transmute(val);
8550 self._bitfield_1.set(2usize, 1u8, val as u64)
8551 }
8552 }
8553 #[inline]
8554 pub fn mIsChild(&self) -> bool {
8555 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
8556 }
8557 #[inline]
8558 pub fn set_mIsChild(&mut self, val: bool) {
8559 unsafe {
8560 let val: u8 = ::std::mem::transmute(val);
8561 self._bitfield_1.set(3usize, 1u8, val as u64)
8562 }
8563 }
8564 #[inline]
8565 pub fn new_bitfield_1(
8566 mRxOnWhenIdle: bool,
8567 mFullThreadDevice: bool,
8568 mFullNetworkData: bool,
8569 mIsChild: bool,
8570 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8571 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8572 __bindgen_bitfield_unit.set(0usize, 1u8, {
8573 let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
8574 mRxOnWhenIdle as u64
8575 });
8576 __bindgen_bitfield_unit.set(1usize, 1u8, {
8577 let mFullThreadDevice: u8 = unsafe { ::std::mem::transmute(mFullThreadDevice) };
8578 mFullThreadDevice as u64
8579 });
8580 __bindgen_bitfield_unit.set(2usize, 1u8, {
8581 let mFullNetworkData: u8 = unsafe { ::std::mem::transmute(mFullNetworkData) };
8582 mFullNetworkData as u64
8583 });
8584 __bindgen_bitfield_unit.set(3usize, 1u8, {
8585 let mIsChild: u8 = unsafe { ::std::mem::transmute(mIsChild) };
8586 mIsChild as u64
8587 });
8588 __bindgen_bitfield_unit
8589 }
8590}
8591pub type otNeighborInfoIterator = i16;
8592#[doc = " Represents the Thread Leader Data."]
8593#[repr(C)]
8594#[derive(Debug, Default, Copy, Clone)]
8595pub struct otLeaderData {
8596 #[doc = "< Partition ID"]
8597 pub mPartitionId: u32,
8598 #[doc = "< Leader Weight"]
8599 pub mWeighting: u8,
8600 #[doc = "< Full Network Data Version"]
8601 pub mDataVersion: u8,
8602 #[doc = "< Stable Network Data Version"]
8603 pub mStableDataVersion: u8,
8604 #[doc = "< Leader Router ID"]
8605 pub mLeaderRouterId: u8,
8606}
8607#[doc = " Holds diagnostic information for a Thread Router"]
8608#[repr(C)]
8609#[derive(Debug, Default, Copy, Clone)]
8610pub struct otRouterInfo {
8611 #[doc = "< IEEE 802.15.4 Extended Address"]
8612 pub mExtAddress: otExtAddress,
8613 #[doc = "< RLOC16"]
8614 pub mRloc16: u16,
8615 #[doc = "< Router ID"]
8616 pub mRouterId: u8,
8617 #[doc = "< Next hop to router"]
8618 pub mNextHop: u8,
8619 #[doc = "< Path cost to router"]
8620 pub mPathCost: u8,
8621 #[doc = "< Link Quality In"]
8622 pub mLinkQualityIn: u8,
8623 #[doc = "< Link Quality Out"]
8624 pub mLinkQualityOut: u8,
8625 #[doc = "< Time last heard"]
8626 pub mAge: u8,
8627 pub _bitfield_align_1: [u8; 0],
8628 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8629 #[doc = "< Thread version"]
8630 pub mVersion: u8,
8631 #[doc = "< CSL clock accuracy, in ± ppm"]
8632 pub mCslClockAccuracy: u8,
8633 #[doc = "< CSL uncertainty, in ±10 us"]
8634 pub mCslUncertainty: u8,
8635}
8636impl otRouterInfo {
8637 #[inline]
8638 pub fn mAllocated(&self) -> bool {
8639 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8640 }
8641 #[inline]
8642 pub fn set_mAllocated(&mut self, val: bool) {
8643 unsafe {
8644 let val: u8 = ::std::mem::transmute(val);
8645 self._bitfield_1.set(0usize, 1u8, val as u64)
8646 }
8647 }
8648 #[inline]
8649 pub fn mLinkEstablished(&self) -> bool {
8650 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8651 }
8652 #[inline]
8653 pub fn set_mLinkEstablished(&mut self, val: bool) {
8654 unsafe {
8655 let val: u8 = ::std::mem::transmute(val);
8656 self._bitfield_1.set(1usize, 1u8, val as u64)
8657 }
8658 }
8659 #[inline]
8660 pub fn new_bitfield_1(
8661 mAllocated: bool,
8662 mLinkEstablished: bool,
8663 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8664 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8665 __bindgen_bitfield_unit.set(0usize, 1u8, {
8666 let mAllocated: u8 = unsafe { ::std::mem::transmute(mAllocated) };
8667 mAllocated as u64
8668 });
8669 __bindgen_bitfield_unit.set(1usize, 1u8, {
8670 let mLinkEstablished: u8 = unsafe { ::std::mem::transmute(mLinkEstablished) };
8671 mLinkEstablished as u64
8672 });
8673 __bindgen_bitfield_unit
8674 }
8675}
8676#[doc = " Represents the IP level counters."]
8677#[repr(C)]
8678#[derive(Debug, Default, Copy, Clone)]
8679pub struct otIpCounters {
8680 #[doc = "< The number of IPv6 packets successfully transmitted."]
8681 pub mTxSuccess: u32,
8682 #[doc = "< The number of IPv6 packets successfully received."]
8683 pub mRxSuccess: u32,
8684 #[doc = "< The number of IPv6 packets failed to transmit."]
8685 pub mTxFailure: u32,
8686 #[doc = "< The number of IPv6 packets failed to receive."]
8687 pub mRxFailure: u32,
8688}
8689#[doc = " Represents the Thread MLE counters."]
8690#[repr(C)]
8691#[derive(Debug, Default, Copy, Clone)]
8692pub struct otMleCounters {
8693 #[doc = "< Number of times device entered OT_DEVICE_ROLE_DISABLED role."]
8694 pub mDisabledRole: u16,
8695 #[doc = "< Number of times device entered OT_DEVICE_ROLE_DETACHED role."]
8696 pub mDetachedRole: u16,
8697 #[doc = "< Number of times device entered OT_DEVICE_ROLE_CHILD role."]
8698 pub mChildRole: u16,
8699 #[doc = "< Number of times device entered OT_DEVICE_ROLE_ROUTER role."]
8700 pub mRouterRole: u16,
8701 #[doc = "< Number of times device entered OT_DEVICE_ROLE_LEADER role."]
8702 pub mLeaderRole: u16,
8703 #[doc = "< Number of attach attempts while device was detached."]
8704 pub mAttachAttempts: u16,
8705 #[doc = "< Number of changes to partition ID."]
8706 pub mPartitionIdChanges: u16,
8707 #[doc = "< Number of attempts to attach to a better partition."]
8708 pub mBetterPartitionAttachAttempts: u16,
8709 #[doc = "< Number of attempts to attach to find a better parent (parent search)."]
8710 pub mBetterParentAttachAttempts: u16,
8711 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_DISABLED role."]
8712 pub mDisabledTime: u64,
8713 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_DETACHED role."]
8714 pub mDetachedTime: u64,
8715 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_CHILD role."]
8716 pub mChildTime: u64,
8717 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_ROUTER role."]
8718 pub mRouterTime: u64,
8719 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_LEADER role."]
8720 pub mLeaderTime: u64,
8721 #[doc = "< Number of milliseconds tracked by previous counters."]
8722 pub mTrackedTime: u64,
8723 #[doc = " Number of times device changed its parent.\n\n A parent change can happen if device detaches from its current parent and attaches to a different one, or even\n while device is attached when the periodic parent search feature is enabled (please see option\n OPENTHREAD_CONFIG_PARENT_SEARCH_ENABLE)."]
8724 pub mParentChanges: u16,
8725}
8726#[doc = " Represents the MLE Parent Response data."]
8727#[repr(C)]
8728#[derive(Debug, Default, Copy, Clone)]
8729pub struct otThreadParentResponseInfo {
8730 #[doc = "< IEEE 802.15.4 Extended Address of the Parent"]
8731 pub mExtAddr: otExtAddress,
8732 #[doc = "< Short address of the Parent"]
8733 pub mRloc16: u16,
8734 #[doc = "< Rssi of the Parent"]
8735 pub mRssi: i8,
8736 #[doc = "< Parent priority"]
8737 pub mPriority: i8,
8738 #[doc = "< Parent Link Quality 3"]
8739 pub mLinkQuality3: u8,
8740 #[doc = "< Parent Link Quality 2"]
8741 pub mLinkQuality2: u8,
8742 #[doc = "< Parent Link Quality 1"]
8743 pub mLinkQuality1: u8,
8744 #[doc = "< Is the node receiving parent response attached"]
8745 pub mIsAttached: bool,
8746}
8747#[doc = " This callback informs the application that the detaching process has finished.\n\n @param[in] aContext A pointer to application-specific context."]
8748pub type otDetachGracefullyCallback =
8749 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
8750#[doc = " Informs the application about the result of waking a Wake-up End Device.\n\n @param[in] aError OT_ERROR_NONE Indicates that the Wake-up End Device has been added as a neighbor.\n OT_ERROR_FAILED Indicates that the Wake-up End Device has not received a wake-up frame, or it\n has failed the MLE procedure.\n @param[in] aContext A pointer to application-specific context."]
8751pub type otWakeupCallback = ::std::option::Option<
8752 unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
8753>;
8754extern "C" {
8755 #[doc = " Starts Thread protocol operation.\n\n The interface must be up when calling this function.\n\n Calling this function with @p aEnabled set to FALSE stops any ongoing processes of detaching started by\n otThreadDetachGracefully(). Its callback will be called.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE if Thread is enabled, FALSE otherwise.\n\n @retval OT_ERROR_NONE Successfully started Thread protocol operation.\n @retval OT_ERROR_INVALID_STATE The network interface was not up."]
8756 pub fn otThreadSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
8757}
8758extern "C" {
8759 #[doc = " Gets the Thread protocol version.\n\n The constants `OT_THREAD_VERSION_*` define the numerical version values.\n\n @returns the Thread protocol version."]
8760 pub fn otThreadGetVersion() -> u16;
8761}
8762extern "C" {
8763 #[doc = " Indicates whether a node is the only router on the network.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE It is the only router in the network.\n @retval FALSE It is a child or is not a single router in the network."]
8764 pub fn otThreadIsSingleton(aInstance: *mut otInstance) -> bool;
8765}
8766extern "C" {
8767 #[doc = " Starts a Thread Discovery scan.\n\n @note A successful call to this function enables the rx-on-when-idle mode for the entire scan procedure.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aScanChannels A bit vector indicating which channels to scan (e.g. OT_CHANNEL_11_MASK).\n @param[in] aPanId The PAN ID filter (set to Broadcast PAN to disable filter).\n @param[in] aJoiner Value of the Joiner Flag in the Discovery Request TLV.\n @param[in] aEnableEui64Filtering TRUE to filter responses on EUI-64, FALSE otherwise.\n @param[in] aCallback A pointer to a function called on receiving an MLE Discovery Response or\n scan completes.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully started a Thread Discovery Scan.\n @retval OT_ERROR_INVALID_STATE The IPv6 interface is not enabled (netif is not up).\n @retval OT_ERROR_NO_BUFS Could not allocate message for Discovery Request.\n @retval OT_ERROR_BUSY Thread Discovery Scan is already in progress."]
8768 pub fn otThreadDiscover(
8769 aInstance: *mut otInstance,
8770 aScanChannels: u32,
8771 aPanId: u16,
8772 aJoiner: bool,
8773 aEnableEui64Filtering: bool,
8774 aCallback: otHandleActiveScanResult,
8775 aCallbackContext: *mut ::std::os::raw::c_void,
8776 ) -> otError;
8777}
8778extern "C" {
8779 #[doc = " Determines if an MLE Thread Discovery is currently in progress.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
8780 pub fn otThreadIsDiscoverInProgress(aInstance: *mut otInstance) -> bool;
8781}
8782extern "C" {
8783 #[doc = " Sets the Thread Joiner Advertisement when discovering Thread network.\n\n Thread Joiner Advertisement is used to allow a Joiner to advertise its own application-specific information\n (such as Vendor ID, Product ID, Discriminator, etc.) via a newly-proposed Joiner Advertisement TLV,\n and to make this information available to Commissioners or Commissioner Candidates without human interaction.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aOui The Vendor IEEE OUI value that will be included in the Joiner Advertisement. Only the\n least significant 3 bytes will be used, and the most significant byte will be ignored.\n @param[in] aAdvData A pointer to the AdvData that will be included in the Joiner Advertisement.\n @param[in] aAdvDataLength The length of AdvData in bytes.\n\n @retval OT_ERROR_NONE Successfully set Joiner Advertisement.\n @retval OT_ERROR_INVALID_ARGS Invalid AdvData."]
8784 pub fn otThreadSetJoinerAdvertisement(
8785 aInstance: *mut otInstance,
8786 aOui: u32,
8787 aAdvData: *const u8,
8788 aAdvDataLength: u8,
8789 ) -> otError;
8790}
8791extern "C" {
8792 #[doc = " Gets the Thread Child Timeout (in seconds) used when operating in the Child role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Thread Child Timeout value in seconds.\n\n @sa otThreadSetChildTimeout"]
8793 pub fn otThreadGetChildTimeout(aInstance: *mut otInstance) -> u32;
8794}
8795extern "C" {
8796 #[doc = " Sets the Thread Child Timeout (in seconds) used when operating in the Child role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aTimeout The timeout value in seconds.\n\n @sa otThreadGetChildTimeout"]
8797 pub fn otThreadSetChildTimeout(aInstance: *mut otInstance, aTimeout: u32);
8798}
8799extern "C" {
8800 #[doc = " Gets the IEEE 802.15.4 Extended PAN ID.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the IEEE 802.15.4 Extended PAN ID.\n\n @sa otThreadSetExtendedPanId"]
8801 pub fn otThreadGetExtendedPanId(aInstance: *mut otInstance) -> *const otExtendedPanId;
8802}
8803extern "C" {
8804 #[doc = " Sets the IEEE 802.15.4 Extended PAN ID.\n\n @note Can only be called while Thread protocols are disabled. A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtendedPanId A pointer to the IEEE 802.15.4 Extended PAN ID.\n\n @retval OT_ERROR_NONE Successfully set the Extended PAN ID.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otThreadGetExtendedPanId"]
8805 pub fn otThreadSetExtendedPanId(
8806 aInstance: *mut otInstance,
8807 aExtendedPanId: *const otExtendedPanId,
8808 ) -> otError;
8809}
8810extern "C" {
8811 #[doc = " Returns a pointer to the Leader's RLOC.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aLeaderRloc A pointer to the Leader's RLOC.\n\n @retval OT_ERROR_NONE The Leader's RLOC was successfully written to @p aLeaderRloc.\n @retval OT_ERROR_INVALID_ARGS @p aLeaderRloc was NULL.\n @retval OT_ERROR_DETACHED Not currently attached to a Thread Partition."]
8812 pub fn otThreadGetLeaderRloc(
8813 aInstance: *mut otInstance,
8814 aLeaderRloc: *mut otIp6Address,
8815 ) -> otError;
8816}
8817extern "C" {
8818 #[doc = " Get the MLE Link Mode configuration.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The MLE Link Mode configuration.\n\n @sa otThreadSetLinkMode"]
8819 pub fn otThreadGetLinkMode(aInstance: *mut otInstance) -> otLinkModeConfig;
8820}
8821extern "C" {
8822 #[doc = " Set the MLE Link Mode configuration.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aConfig A pointer to the Link Mode configuration.\n\n @retval OT_ERROR_NONE Successfully set the MLE Link Mode configuration.\n\n @sa otThreadGetLinkMode"]
8823 pub fn otThreadSetLinkMode(aInstance: *mut otInstance, aConfig: otLinkModeConfig) -> otError;
8824}
8825extern "C" {
8826 #[doc = " Get the Thread Network Key.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aNetworkKey A pointer to an `otNetworkKey` to return the Thread Network Key.\n\n @sa otThreadSetNetworkKey"]
8827 pub fn otThreadGetNetworkKey(aInstance: *mut otInstance, aNetworkKey: *mut otNetworkKey);
8828}
8829extern "C" {
8830 #[doc = " Get the `otNetworkKeyRef` for Thread Network Key.\n\n Requires the build-time feature `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns Reference to the Thread Network Key stored in memory.\n\n @sa otThreadSetNetworkKeyRef"]
8831 pub fn otThreadGetNetworkKeyRef(aInstance: *mut otInstance) -> otNetworkKeyRef;
8832}
8833extern "C" {
8834 #[doc = " Set the Thread Network Key.\n\n Succeeds only when Thread protocols are disabled. A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aKey A pointer to a buffer containing the Thread Network Key.\n\n @retval OT_ERROR_NONE Successfully set the Thread Network Key.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otThreadGetNetworkKey"]
8835 pub fn otThreadSetNetworkKey(aInstance: *mut otInstance, aKey: *const otNetworkKey) -> otError;
8836}
8837extern "C" {
8838 #[doc = " Set the Thread Network Key as a `otNetworkKeyRef`.\n\n Succeeds only when Thread protocols are disabled. A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n Requires the build-time feature `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aKeyRef Reference to the Thread Network Key.\n\n @retval OT_ERROR_NONE Successfully set the Thread Network Key.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otThreadGetNetworkKeyRef"]
8839 pub fn otThreadSetNetworkKeyRef(
8840 aInstance: *mut otInstance,
8841 aKeyRef: otNetworkKeyRef,
8842 ) -> otError;
8843}
8844extern "C" {
8845 #[doc = " Gets the Thread Routing Locator (RLOC) address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Thread Routing Locator (RLOC) address."]
8846 pub fn otThreadGetRloc(aInstance: *mut otInstance) -> *const otIp6Address;
8847}
8848extern "C" {
8849 #[doc = " Gets the Mesh Local EID address.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Mesh Local EID address."]
8850 pub fn otThreadGetMeshLocalEid(aInstance: *mut otInstance) -> *const otIp6Address;
8851}
8852extern "C" {
8853 #[doc = " Returns a pointer to the Mesh Local Prefix.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Mesh Local Prefix."]
8854 pub fn otThreadGetMeshLocalPrefix(aInstance: *mut otInstance) -> *const otMeshLocalPrefix;
8855}
8856extern "C" {
8857 #[doc = " Sets the Mesh Local Prefix.\n\n Succeeds only when Thread protocols are disabled. A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMeshLocalPrefix A pointer to the Mesh Local Prefix.\n\n @retval OT_ERROR_NONE Successfully set the Mesh Local Prefix.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled."]
8858 pub fn otThreadSetMeshLocalPrefix(
8859 aInstance: *mut otInstance,
8860 aMeshLocalPrefix: *const otMeshLocalPrefix,
8861 ) -> otError;
8862}
8863extern "C" {
8864 #[doc = " Gets the Thread link-local IPv6 address.\n\n The Thread link local address is derived using IEEE802.15.4 Extended Address as Interface Identifier.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to Thread link-local IPv6 address."]
8865 pub fn otThreadGetLinkLocalIp6Address(aInstance: *mut otInstance) -> *const otIp6Address;
8866}
8867extern "C" {
8868 #[doc = " Gets the Thread Link-Local All Thread Nodes multicast address.\n\n The address is a link-local Unicast Prefix-Based Multicast Address [RFC 3306], with:\n - flgs set to 3 (P = 1 and T = 1)\n - scop set to 2\n - plen set to 64\n - network prefix set to the Mesh Local Prefix\n - group ID set to 1\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to Thread Link-Local All Thread Nodes multicast address."]
8869 pub fn otThreadGetLinkLocalAllThreadNodesMulticastAddress(
8870 aInstance: *mut otInstance,
8871 ) -> *const otIp6Address;
8872}
8873extern "C" {
8874 #[doc = " Gets the Thread Realm-Local All Thread Nodes multicast address.\n\n The address is a realm-local Unicast Prefix-Based Multicast Address [RFC 3306], with:\n - flgs set to 3 (P = 1 and T = 1)\n - scop set to 3\n - plen set to 64\n - network prefix set to the Mesh Local Prefix\n - group ID set to 1\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to Thread Realm-Local All Thread Nodes multicast address."]
8875 pub fn otThreadGetRealmLocalAllThreadNodesMulticastAddress(
8876 aInstance: *mut otInstance,
8877 ) -> *const otIp6Address;
8878}
8879extern "C" {
8880 #[doc = " Retrieves the Service ALOC for given Service ID.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aServiceId Service ID to get ALOC for.\n @param[out] aServiceAloc A pointer to output the Service ALOC. MUST NOT BE NULL.\n\n @retval OT_ERROR_NONE Successfully retrieved the Service ALOC.\n @retval OT_ERROR_DETACHED The Thread interface is not currently attached to a Thread Partition."]
8881 pub fn otThreadGetServiceAloc(
8882 aInstance: *mut otInstance,
8883 aServiceId: u8,
8884 aServiceAloc: *mut otIp6Address,
8885 ) -> otError;
8886}
8887extern "C" {
8888 #[doc = " Get the Thread Network Name.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Thread Network Name.\n\n @sa otThreadSetNetworkName"]
8889 pub fn otThreadGetNetworkName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
8890}
8891extern "C" {
8892 #[doc = " Set the Thread Network Name.\n\n Succeeds only when Thread protocols are disabled. A successful\n call to this function invalidates the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aNetworkName A pointer to the Thread Network Name.\n\n @retval OT_ERROR_NONE Successfully set the Thread Network Name.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otThreadGetNetworkName"]
8893 pub fn otThreadSetNetworkName(
8894 aInstance: *mut otInstance,
8895 aNetworkName: *const ::std::os::raw::c_char,
8896 ) -> otError;
8897}
8898extern "C" {
8899 #[doc = " Gets the Thread Domain Name.\n\n @note Available since Thread 1.2.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Thread Domain Name.\n\n @sa otThreadSetDomainName"]
8900 pub fn otThreadGetDomainName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
8901}
8902extern "C" {
8903 #[doc = " Sets the Thread Domain Name. Only succeeds when Thread protocols are disabled.\n\n @note Available since Thread 1.2.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDomainName A pointer to the Thread Domain Name.\n\n @retval OT_ERROR_NONE Successfully set the Thread Domain Name.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otThreadGetDomainName"]
8904 pub fn otThreadSetDomainName(
8905 aInstance: *mut otInstance,
8906 aDomainName: *const ::std::os::raw::c_char,
8907 ) -> otError;
8908}
8909extern "C" {
8910 #[doc = " Sets or clears the Interface Identifier manually specified for the Thread Domain Unicast Address.\n\n Available when `OPENTHREAD_CONFIG_DUA_ENABLE` is enabled.\n\n @note Only available since Thread 1.2.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aIid A pointer to the Interface Identifier to set or NULL to clear.\n\n @retval OT_ERROR_NONE Successfully set/cleared the Interface Identifier.\n @retval OT_ERROR_INVALID_ARGS The specified Interface Identifier is reserved.\n\n @sa otThreadGetFixedDuaInterfaceIdentifier"]
8911 pub fn otThreadSetFixedDuaInterfaceIdentifier(
8912 aInstance: *mut otInstance,
8913 aIid: *const otIp6InterfaceIdentifier,
8914 ) -> otError;
8915}
8916extern "C" {
8917 #[doc = " Gets the Interface Identifier manually specified for the Thread Domain Unicast Address.\n\n Available when `OPENTHREAD_CONFIG_DUA_ENABLE` is enabled.\n\n @note Only available since Thread 1.2.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Interface Identifier which was set manually, or NULL if none was set.\n\n @sa otThreadSetFixedDuaInterfaceIdentifier"]
8918 pub fn otThreadGetFixedDuaInterfaceIdentifier(
8919 aInstance: *mut otInstance,
8920 ) -> *const otIp6InterfaceIdentifier;
8921}
8922extern "C" {
8923 #[doc = " Gets the thrKeySequenceCounter.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The thrKeySequenceCounter value.\n\n @sa otThreadSetKeySequenceCounter"]
8924 pub fn otThreadGetKeySequenceCounter(aInstance: *mut otInstance) -> u32;
8925}
8926extern "C" {
8927 #[doc = " Sets the thrKeySequenceCounter.\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] aKeySequenceCounter The thrKeySequenceCounter value.\n\n @sa otThreadGetKeySequenceCounter"]
8928 pub fn otThreadSetKeySequenceCounter(aInstance: *mut otInstance, aKeySequenceCounter: u32);
8929}
8930extern "C" {
8931 #[doc = " Gets the thrKeySwitchGuardTime (in hours).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The thrKeySwitchGuardTime value (in hours).\n\n @sa otThreadSetKeySwitchGuardTime"]
8932 pub fn otThreadGetKeySwitchGuardTime(aInstance: *mut otInstance) -> u16;
8933}
8934extern "C" {
8935 #[doc = " Sets the thrKeySwitchGuardTime (in hours).\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] aKeySwitchGuardTime The thrKeySwitchGuardTime value (in hours).\n\n @sa otThreadGetKeySwitchGuardTime"]
8936 pub fn otThreadSetKeySwitchGuardTime(aInstance: *mut otInstance, aKeySwitchGuardTime: u16);
8937}
8938extern "C" {
8939 #[doc = " Detach from the Thread network.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully detached from the Thread network.\n @retval OT_ERROR_INVALID_STATE Thread is disabled."]
8940 pub fn otThreadBecomeDetached(aInstance: *mut otInstance) -> otError;
8941}
8942extern "C" {
8943 #[doc = " Attempt to reattach as a child.\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\n @retval OT_ERROR_NONE Successfully begin attempt to become a child.\n @retval OT_ERROR_INVALID_STATE Thread is disabled."]
8944 pub fn otThreadBecomeChild(aInstance: *mut otInstance) -> otError;
8945}
8946extern "C" {
8947 #[doc = " Gets the next neighbor information. It is used to go through the entries of\n the neighbor table.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in,out] aIterator A pointer to the iterator context. To get the first neighbor entry\nit should be set to OT_NEIGHBOR_INFO_ITERATOR_INIT.\n @param[out] aInfo A pointer to the neighbor information.\n\n @retval OT_ERROR_NONE Successfully found the next neighbor entry in table.\n @retval OT_ERROR_NOT_FOUND No subsequent neighbor entry exists in the table.\n @retval OT_ERROR_INVALID_ARGS @p aIterator or @p aInfo was NULL."]
8948 pub fn otThreadGetNextNeighborInfo(
8949 aInstance: *mut otInstance,
8950 aIterator: *mut otNeighborInfoIterator,
8951 aInfo: *mut otNeighborInfo,
8952 ) -> otError;
8953}
8954extern "C" {
8955 #[doc = " Get the device role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_DEVICE_ROLE_DISABLED The Thread stack is disabled.\n @retval OT_DEVICE_ROLE_DETACHED The device is not currently participating in a Thread network/partition.\n @retval OT_DEVICE_ROLE_CHILD The device is currently operating as a Thread Child.\n @retval OT_DEVICE_ROLE_ROUTER The device is currently operating as a Thread Router.\n @retval OT_DEVICE_ROLE_LEADER The device is currently operating as a Thread Leader."]
8956 pub fn otThreadGetDeviceRole(aInstance: *mut otInstance) -> otDeviceRole;
8957}
8958extern "C" {
8959 #[doc = " Convert the device role to human-readable string.\n\n @param[in] aRole The device role to convert.\n\n @returns A string representing @p aRole."]
8960 pub fn otThreadDeviceRoleToString(aRole: otDeviceRole) -> *const ::std::os::raw::c_char;
8961}
8962extern "C" {
8963 #[doc = " Get the Thread Leader Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aLeaderData A pointer to where the leader data is placed.\n\n @retval OT_ERROR_NONE Successfully retrieved the leader data.\n @retval OT_ERROR_DETACHED Not currently attached."]
8964 pub fn otThreadGetLeaderData(
8965 aInstance: *mut otInstance,
8966 aLeaderData: *mut otLeaderData,
8967 ) -> otError;
8968}
8969extern "C" {
8970 #[doc = " Get the Leader's Router ID.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Leader's Router ID."]
8971 pub fn otThreadGetLeaderRouterId(aInstance: *mut otInstance) -> u8;
8972}
8973extern "C" {
8974 #[doc = " Get the Leader's Weight.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Leader's Weight."]
8975 pub fn otThreadGetLeaderWeight(aInstance: *mut otInstance) -> u8;
8976}
8977extern "C" {
8978 #[doc = " Get the Partition ID.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Partition ID."]
8979 pub fn otThreadGetPartitionId(aInstance: *mut otInstance) -> u32;
8980}
8981extern "C" {
8982 #[doc = " Get the RLOC16.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The RLOC16."]
8983 pub fn otThreadGetRloc16(aInstance: *mut otInstance) -> u16;
8984}
8985extern "C" {
8986 #[doc = " The function retrieves diagnostic information for a Thread Router as parent.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aParentInfo A pointer to where the parent router information is placed."]
8987 pub fn otThreadGetParentInfo(
8988 aInstance: *mut otInstance,
8989 aParentInfo: *mut otRouterInfo,
8990 ) -> otError;
8991}
8992extern "C" {
8993 #[doc = " The function retrieves the average RSSI for the Thread Parent.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aParentRssi A pointer to where the parent RSSI should be placed."]
8994 pub fn otThreadGetParentAverageRssi(
8995 aInstance: *mut otInstance,
8996 aParentRssi: *mut i8,
8997 ) -> otError;
8998}
8999extern "C" {
9000 #[doc = " The function retrieves the RSSI of the last packet from the Thread Parent.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aLastRssi A pointer to where the last RSSI should be placed.\n\n @retval OT_ERROR_NONE Successfully retrieved the RSSI data.\n @retval OT_ERROR_FAILED Unable to get RSSI data.\n @retval OT_ERROR_INVALID_ARGS @p aLastRssi is NULL."]
9001 pub fn otThreadGetParentLastRssi(aInstance: *mut otInstance, aLastRssi: *mut i8) -> otError;
9002}
9003extern "C" {
9004 #[doc = " Starts the process for child to search for a better parent while staying attached to its current parent.\n\n Must be used when device is attached as a child.\n\n @retval OT_ERROR_NONE Successfully started the process to search for a better parent.\n @retval OT_ERROR_INVALID_STATE Device role is not child."]
9005 pub fn otThreadSearchForBetterParent(aInstance: *mut otInstance) -> otError;
9006}
9007extern "C" {
9008 #[doc = " Gets the IPv6 counters.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the IPv6 counters."]
9009 pub fn otThreadGetIp6Counters(aInstance: *mut otInstance) -> *const otIpCounters;
9010}
9011extern "C" {
9012 #[doc = " Resets the IPv6 counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
9013 pub fn otThreadResetIp6Counters(aInstance: *mut otInstance);
9014}
9015extern "C" {
9016 #[doc = " Gets the time-in-queue histogram for messages in the TX queue.\n\n Requires `OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE`.\n\n Histogram of the time-in-queue of messages in the transmit queue is collected. The time-in-queue is tracked for\n direct transmissions only and is measured as the duration from when a message is added to the transmit queue until\n it is passed to the MAC layer for transmission or dropped.\n\n The histogram is returned as an array of `uint32_t` values with `aNumBins` entries. The first entry in the array\n (at index 0) represents the number of messages with a time-in-queue less than `aBinInterval`. The second entry\n represents the number of messages with a time-in-queue greater than or equal to `aBinInterval`, but less than\n `2 * aBinInterval`. And so on. The last entry represents the number of messages with time-in-queue greater than or\n equal to `(aNumBins - 1) * aBinInterval`.\n\n The collected statistics can be reset by calling `otThreadResetTimeInQueueStat()`. The histogram information is\n collected since the OpenThread instance was initialized or since the last time statistics collection was reset by\n calling the `otThreadResetTimeInQueueStat()`.\n\n Pointers @p aNumBins and @p aBinInterval MUST NOT be NULL.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aNumBins Pointer to return the number of bins in histogram (array length).\n @param[out] aBinInterval Pointer to return the histogram bin interval length in milliseconds.\n\n @returns A pointer to an array of @p aNumBins entries representing the collected histogram info."]
9017 pub fn otThreadGetTimeInQueueHistogram(
9018 aInstance: *mut otInstance,
9019 aNumBins: *mut u16,
9020 aBinInterval: *mut u32,
9021 ) -> *const u32;
9022}
9023extern "C" {
9024 #[doc = " Gets the maximum time-in-queue for messages in the TX queue.\n\n Requires `OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE`.\n\n The time-in-queue is tracked for direct transmissions only and is measured as the duration from when a message is\n added to the transmit queue until it is passed to the MAC layer for transmission or dropped.\n\n The collected statistics can be reset by calling `otThreadResetTimeInQueueStat()`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The maximum time-in-queue in milliseconds for all messages in the TX queue (so far)."]
9025 pub fn otThreadGetMaxTimeInQueue(aInstance: *mut otInstance) -> u32;
9026}
9027extern "C" {
9028 #[doc = " Resets the TX queue time-in-queue statistics.\n\n Requires `OPENTHREAD_CONFIG_TX_QUEUE_STATISTICS_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
9029 pub fn otThreadResetTimeInQueueStat(aInstance: *mut otInstance);
9030}
9031extern "C" {
9032 #[doc = " Gets the Thread MLE counters.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the Thread MLE counters."]
9033 pub fn otThreadGetMleCounters(aInstance: *mut otInstance) -> *const otMleCounters;
9034}
9035extern "C" {
9036 #[doc = " Resets the Thread MLE counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
9037 pub fn otThreadResetMleCounters(aInstance: *mut otInstance);
9038}
9039extern "C" {
9040 #[doc = " Gets the current attach duration (number of seconds since the device last attached).\n\n Requires the `OPENTHREAD_CONFIG_UPTIME_ENABLE` feature.\n\n If the device is not currently attached, zero will be returned.\n\n Unlike the role-tracking variables in `otMleCounters`, which track the cumulative time the device is in each role,\n this function tracks the time since the last successful attachment, indicating how long the device has been\n connected to the Thread mesh (regardless of its role, whether acting as a child, router, or leader).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The number of seconds since last attached."]
9041 pub fn otThreadGetCurrentAttachDuration(aInstance: *mut otInstance) -> u32;
9042}
9043#[doc = " Pointer is called every time an MLE Parent Response message is received.\n\n This is used in `otThreadRegisterParentResponseCallback()`.\n\n @param[in] aInfo A pointer to a location on stack holding the stats data.\n @param[in] aContext A pointer to callback client-specific context."]
9044pub type otThreadParentResponseCallback = ::std::option::Option<
9045 unsafe extern "C" fn(
9046 aInfo: *mut otThreadParentResponseInfo,
9047 aContext: *mut ::std::os::raw::c_void,
9048 ),
9049>;
9050extern "C" {
9051 #[doc = " Registers a callback to receive MLE Parent Response data.\n\n Requires `OPENTHREAD_CONFIG_MLE_PARENT_RESPONSE_CALLBACK_API_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called upon receiving an MLE Parent Response message.\n @param[in] aContext A pointer to callback client-specific context."]
9052 pub fn otThreadRegisterParentResponseCallback(
9053 aInstance: *mut otInstance,
9054 aCallback: otThreadParentResponseCallback,
9055 aContext: *mut ::std::os::raw::c_void,
9056 );
9057}
9058#[doc = " Represents the Thread Discovery Request data."]
9059#[repr(C)]
9060#[derive(Debug, Default, Copy, Clone)]
9061pub struct otThreadDiscoveryRequestInfo {
9062 #[doc = "< IEEE 802.15.4 Extended Address of the requester"]
9063 pub mExtAddress: otExtAddress,
9064 pub _bitfield_align_1: [u8; 0],
9065 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
9066}
9067impl otThreadDiscoveryRequestInfo {
9068 #[inline]
9069 pub fn mVersion(&self) -> u8 {
9070 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
9071 }
9072 #[inline]
9073 pub fn set_mVersion(&mut self, val: u8) {
9074 unsafe {
9075 let val: u8 = ::std::mem::transmute(val);
9076 self._bitfield_1.set(0usize, 4u8, val as u64)
9077 }
9078 }
9079 #[inline]
9080 pub fn mIsJoiner(&self) -> bool {
9081 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
9082 }
9083 #[inline]
9084 pub fn set_mIsJoiner(&mut self, val: bool) {
9085 unsafe {
9086 let val: u8 = ::std::mem::transmute(val);
9087 self._bitfield_1.set(4usize, 1u8, val as u64)
9088 }
9089 }
9090 #[inline]
9091 pub fn new_bitfield_1(mVersion: u8, mIsJoiner: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
9092 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
9093 __bindgen_bitfield_unit.set(0usize, 4u8, {
9094 let mVersion: u8 = unsafe { ::std::mem::transmute(mVersion) };
9095 mVersion as u64
9096 });
9097 __bindgen_bitfield_unit.set(4usize, 1u8, {
9098 let mIsJoiner: u8 = unsafe { ::std::mem::transmute(mIsJoiner) };
9099 mIsJoiner as u64
9100 });
9101 __bindgen_bitfield_unit
9102 }
9103}
9104#[doc = " Pointer is called every time an MLE Discovery Request message is received.\n\n @param[in] aInfo A pointer to the Discovery Request info data.\n @param[in] aContext A pointer to callback application-specific context."]
9105pub type otThreadDiscoveryRequestCallback = ::std::option::Option<
9106 unsafe extern "C" fn(
9107 aInfo: *const otThreadDiscoveryRequestInfo,
9108 aContext: *mut ::std::os::raw::c_void,
9109 ),
9110>;
9111extern "C" {
9112 #[doc = " Sets a callback to receive MLE Discovery Request data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called upon receiving an MLE Discovery Request message.\n @param[in] aContext A pointer to callback application-specific context."]
9113 pub fn otThreadSetDiscoveryRequestCallback(
9114 aInstance: *mut otInstance,
9115 aCallback: otThreadDiscoveryRequestCallback,
9116 aContext: *mut ::std::os::raw::c_void,
9117 );
9118}
9119#[doc = " Pointer type defines the callback to notify the outcome of a `otThreadLocateAnycastDestination()`\n request.\n\n @param[in] aContext A pointer to an arbitrary context (provided when callback is registered).\n @param[in] aError The error when handling the request. OT_ERROR_NONE indicates success.\n OT_ERROR_RESPONSE_TIMEOUT indicates a destination could not be found.\n OT_ERROR_ABORT indicates the request was aborted.\n @param[in] aMeshLocalAddress A pointer to the mesh-local EID of the closest destination of the anycast address\n when @p aError is OT_ERROR_NONE, NULL otherwise.\n @param[in] aRloc16 The RLOC16 of the destination if found, otherwise invalid RLOC16 (0xfffe)."]
9120pub type otThreadAnycastLocatorCallback = ::std::option::Option<
9121 unsafe extern "C" fn(
9122 aContext: *mut ::std::os::raw::c_void,
9123 aError: otError,
9124 aMeshLocalAddress: *const otIp6Address,
9125 aRloc16: u16,
9126 ),
9127>;
9128extern "C" {
9129 #[doc = " Requests the closest destination of a given anycast address to be located.\n\n Is only available when `OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_ENABLE` is enabled.\n\n If a previous request is ongoing, a subsequent call to this function will cancel and replace the earlier request.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aAnycastAddress The anycast address to locate. MUST NOT be NULL.\n @param[in] aCallback The callback function to report the result.\n @param[in] aContext An arbitrary context used with @p aCallback.\n\n @retval OT_ERROR_NONE The request started successfully. @p aCallback will be invoked to report the result.\n @retval OT_ERROR_INVALID_ARGS The @p aAnycastAddress is not a valid anycast address or @p aCallback is NULL.\n @retval OT_ERROR_NO_BUFS Out of buffer to prepare and send the request message."]
9130 pub fn otThreadLocateAnycastDestination(
9131 aInstance: *mut otInstance,
9132 aAnycastAddress: *const otIp6Address,
9133 aCallback: otThreadAnycastLocatorCallback,
9134 aContext: *mut ::std::os::raw::c_void,
9135 ) -> otError;
9136}
9137extern "C" {
9138 #[doc = " Indicates whether an anycast locate request is currently in progress.\n\n Is only available when `OPENTHREAD_CONFIG_TMF_ANYCAST_LOCATOR_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns TRUE if an anycast locate request is currently in progress, FALSE otherwise."]
9139 pub fn otThreadIsAnycastLocateInProgress(aInstance: *mut otInstance) -> bool;
9140}
9141extern "C" {
9142 #[doc = " Sends a Proactive Address Notification (ADDR_NTF.ntf) message.\n\n Is only available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDestination The destination to send the ADDR_NTF.ntf message.\n @param[in] aTarget The target address of the ADDR_NTF.ntf message.\n @param[in] aMlIid The ML-IID of the ADDR_NTF.ntf message."]
9143 pub fn otThreadSendAddressNotification(
9144 aInstance: *mut otInstance,
9145 aDestination: *mut otIp6Address,
9146 aTarget: *mut otIp6Address,
9147 aMlIid: *mut otIp6InterfaceIdentifier,
9148 );
9149}
9150extern "C" {
9151 #[doc = " Sends a Proactive Backbone Notification (PRO_BB.ntf) message on the Backbone link.\n\n Is only available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aTarget The target address of the PRO_BB.ntf message.\n @param[in] aMlIid The ML-IID of the PRO_BB.ntf message.\n @param[in] aTimeSinceLastTransaction Time since last transaction (in seconds).\n\n @retval OT_ERROR_NONE Successfully sent PRO_BB.ntf on backbone link.\n @retval OT_ERROR_NO_BUFS If insufficient message buffers available."]
9152 pub fn otThreadSendProactiveBackboneNotification(
9153 aInstance: *mut otInstance,
9154 aTarget: *mut otIp6Address,
9155 aMlIid: *mut otIp6InterfaceIdentifier,
9156 aTimeSinceLastTransaction: u32,
9157 ) -> otError;
9158}
9159extern "C" {
9160 #[doc = " Notifies other nodes in the network (if any) and then stops Thread protocol operation.\n\n It sends an Address Release if it's a router, or sets its child timeout to 0 if it's a child.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to a function that is called upon finishing detaching.\n @param[in] aContext A pointer to callback application-specific context.\n\n @retval OT_ERROR_NONE Successfully started detaching.\n @retval OT_ERROR_BUSY Detaching is already in progress."]
9161 pub fn otThreadDetachGracefully(
9162 aInstance: *mut otInstance,
9163 aCallback: otDetachGracefullyCallback,
9164 aContext: *mut ::std::os::raw::c_void,
9165 ) -> otError;
9166}
9167extern "C" {
9168 #[doc = " Converts an `uint32_t` duration (in seconds) to a human-readable string.\n\n Requires `OPENTHREAD_CONFIG_UPTIME_ENABLE` to be enabled.\n\n The string follows the format \"<hh>:<mm>:<ss>\" for hours, minutes, seconds (if duration is shorter than one day) or\n \"<dd>d.<hh>:<mm>:<ss>\" (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 Is intended for use with `mAge` or `mConnectionTime` in `otNeighborInfo` or `otChildInfo` structures.\n\n @param[in] aDuration A duration interval in seconds.\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_DURATION_STRING_SIZE`."]
9169 pub fn otConvertDurationInSecondsToString(
9170 aDuration: u32,
9171 aBuffer: *mut ::std::os::raw::c_char,
9172 aSize: u16,
9173 );
9174}
9175extern "C" {
9176 #[doc = " Sets the store frame counter ahead.\n\n Requires `OPENTHREAD_CONFIG_DYNAMIC_STORE_FRAME_AHEAD_COUNTER_ENABLE` to be enabled.\n\n The OpenThread stack stores the MLE and MAC security frame counter values in non-volatile storage,\n ensuring they persist across device resets. These saved values are set to be ahead of their current\n values by the \"frame counter ahead\" value.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aStoreFrameCounterAhead The store frame counter ahead to set."]
9177 pub fn otThreadSetStoreFrameCounterAhead(
9178 aInstance: *mut otInstance,
9179 aStoreFrameCounterAhead: u32,
9180 );
9181}
9182extern "C" {
9183 #[doc = " Gets the store frame counter ahead.\n\n Requires `OPENTHREAD_CONFIG_DYNAMIC_STORE_FRAME_AHEAD_COUNTER_ENABLE` to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current store frame counter ahead."]
9184 pub fn otThreadGetStoreFrameCounterAhead(aInstance: *mut otInstance) -> u32;
9185}
9186extern "C" {
9187 #[doc = " Attempts to wake a Wake-up End Device.\n\n Requires `OPENTHREAD_CONFIG_WAKEUP_COORDINATOR_ENABLE` to be enabled.\n\n The wake-up starts with transmitting a wake-up frame sequence to the Wake-up End Device.\n During the wake-up sequence, and for a short time after the last wake-up frame is sent, the Wake-up Coordinator keeps\n its receiver on to be able to receive an initial mesh link establishment message from the WED.\n\n @warning The functionality implemented by this function is still in the design phase.\n Consequently, the prototype and semantics of this function are subject to change.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aWedAddress The extended address of the Wake-up End Device.\n @param[in] aWakeupIntervalUs An interval between consecutive wake-up frames (in microseconds).\n @param[in] aWakeupDurationMs Duration of the wake-up sequence (in milliseconds).\n @param[in] aCallback A pointer to function that is called when the wake-up succeeds or fails.\n @param[in] aCallbackContext A pointer to callback application-specific context.\n\n @retval OT_ERROR_NONE Successfully started the wake-up.\n @retval OT_ERROR_INVALID_STATE Another attachment request is still in progress.\n @retval OT_ERROR_INVALID_ARGS The wake-up interval or duration are invalid."]
9188 pub fn otThreadWakeup(
9189 aInstance: *mut otInstance,
9190 aWedAddress: *const otExtAddress,
9191 aWakeupIntervalUs: u16,
9192 aWakeupDurationMs: u16,
9193 aCallback: otWakeupCallback,
9194 aCallbackContext: *mut ::std::os::raw::c_void,
9195 ) -> otError;
9196}
9197pub type otNetworkDiagIterator = u16;
9198#[doc = " Represents a Network Diagnostic Connectivity value."]
9199#[repr(C)]
9200#[derive(Debug, Default, Copy, Clone)]
9201pub struct otNetworkDiagConnectivity {
9202 #[doc = "< The priority of the sender as a parent."]
9203 pub mParentPriority: i8,
9204 #[doc = "< Number of neighbors with link of quality 3."]
9205 pub mLinkQuality3: u8,
9206 #[doc = "< Number of neighbors with link of quality 2."]
9207 pub mLinkQuality2: u8,
9208 #[doc = "< Number of neighbors with link of quality 1."]
9209 pub mLinkQuality1: u8,
9210 #[doc = "< Cost to the Leader."]
9211 pub mLeaderCost: u8,
9212 #[doc = "< Most recent received ID seq number."]
9213 pub mIdSequence: u8,
9214 #[doc = "< Number of active routers."]
9215 pub mActiveRouters: u8,
9216 #[doc = "< Buffer capacity in bytes for SEDs. Optional."]
9217 pub mSedBufferSize: u16,
9218 #[doc = "< Queue capacity (number of IPv6 datagrams) per SED. Optional."]
9219 pub mSedDatagramCount: u8,
9220}
9221#[doc = " Represents a Network Diagnostic Route data."]
9222#[repr(C)]
9223#[derive(Debug, Default, Copy, Clone)]
9224pub struct otNetworkDiagRouteData {
9225 #[doc = "< The Assigned Router ID."]
9226 pub mRouterId: u8,
9227 pub _bitfield_align_1: [u8; 0],
9228 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
9229}
9230impl otNetworkDiagRouteData {
9231 #[inline]
9232 pub fn mLinkQualityOut(&self) -> u8 {
9233 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
9234 }
9235 #[inline]
9236 pub fn set_mLinkQualityOut(&mut self, val: u8) {
9237 unsafe {
9238 let val: u8 = ::std::mem::transmute(val);
9239 self._bitfield_1.set(0usize, 2u8, val as u64)
9240 }
9241 }
9242 #[inline]
9243 pub fn mLinkQualityIn(&self) -> u8 {
9244 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) }
9245 }
9246 #[inline]
9247 pub fn set_mLinkQualityIn(&mut self, val: u8) {
9248 unsafe {
9249 let val: u8 = ::std::mem::transmute(val);
9250 self._bitfield_1.set(2usize, 2u8, val as u64)
9251 }
9252 }
9253 #[inline]
9254 pub fn mRouteCost(&self) -> u8 {
9255 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
9256 }
9257 #[inline]
9258 pub fn set_mRouteCost(&mut self, val: u8) {
9259 unsafe {
9260 let val: u8 = ::std::mem::transmute(val);
9261 self._bitfield_1.set(4usize, 4u8, val as u64)
9262 }
9263 }
9264 #[inline]
9265 pub fn new_bitfield_1(
9266 mLinkQualityOut: u8,
9267 mLinkQualityIn: u8,
9268 mRouteCost: u8,
9269 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
9270 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
9271 __bindgen_bitfield_unit.set(0usize, 2u8, {
9272 let mLinkQualityOut: u8 = unsafe { ::std::mem::transmute(mLinkQualityOut) };
9273 mLinkQualityOut as u64
9274 });
9275 __bindgen_bitfield_unit.set(2usize, 2u8, {
9276 let mLinkQualityIn: u8 = unsafe { ::std::mem::transmute(mLinkQualityIn) };
9277 mLinkQualityIn as u64
9278 });
9279 __bindgen_bitfield_unit.set(4usize, 4u8, {
9280 let mRouteCost: u8 = unsafe { ::std::mem::transmute(mRouteCost) };
9281 mRouteCost as u64
9282 });
9283 __bindgen_bitfield_unit
9284 }
9285}
9286#[doc = " Represents a Network Diagnostic Route64 TLV value."]
9287#[repr(C)]
9288#[derive(Debug, Copy, Clone)]
9289pub struct otNetworkDiagRoute {
9290 #[doc = "< Sequence number for Router ID assignments."]
9291 pub mIdSequence: u8,
9292 #[doc = "< Number of routes."]
9293 pub mRouteCount: u8,
9294 #[doc = "< Link Quality and Routing Cost data."]
9295 pub mRouteData: [otNetworkDiagRouteData; 63usize],
9296}
9297impl Default for otNetworkDiagRoute {
9298 fn default() -> Self {
9299 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9300 unsafe {
9301 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9302 s.assume_init()
9303 }
9304 }
9305}
9306#[doc = " Represents a Network Diagnostic Mac Counters value.\n\n See <a href=\"https://www.ietf.org/rfc/rfc2863\">RFC 2863</a> for definitions of member fields."]
9307#[repr(C)]
9308#[derive(Debug, Default, Copy, Clone)]
9309pub struct otNetworkDiagMacCounters {
9310 pub mIfInUnknownProtos: u32,
9311 pub mIfInErrors: u32,
9312 pub mIfOutErrors: u32,
9313 pub mIfInUcastPkts: u32,
9314 pub mIfInBroadcastPkts: u32,
9315 pub mIfInDiscards: u32,
9316 pub mIfOutUcastPkts: u32,
9317 pub mIfOutBroadcastPkts: u32,
9318 pub mIfOutDiscards: u32,
9319}
9320#[doc = " Represents a Network Diagnostics MLE Counters value."]
9321#[repr(C)]
9322#[derive(Debug, Default, Copy, Clone)]
9323pub struct otNetworkDiagMleCounters {
9324 #[doc = "< Number of times device entered disabled role."]
9325 pub mDisabledRole: u16,
9326 #[doc = "< Number of times device entered detached role."]
9327 pub mDetachedRole: u16,
9328 #[doc = "< Number of times device entered child role."]
9329 pub mChildRole: u16,
9330 #[doc = "< Number of times device entered router role."]
9331 pub mRouterRole: u16,
9332 #[doc = "< Number of times device entered leader role."]
9333 pub mLeaderRole: u16,
9334 #[doc = "< Number of attach attempts while device was detached."]
9335 pub mAttachAttempts: u16,
9336 #[doc = "< Number of changes to partition ID."]
9337 pub mPartitionIdChanges: u16,
9338 #[doc = "< Number of attempts to attach to a better partition."]
9339 pub mBetterPartitionAttachAttempts: u16,
9340 #[doc = "< Number of time device changed its parent."]
9341 pub mParentChanges: u16,
9342 #[doc = "< Milliseconds tracked by next counters (zero if not supported)."]
9343 pub mTrackedTime: u64,
9344 #[doc = "< Milliseconds device has been in disabled role."]
9345 pub mDisabledTime: u64,
9346 #[doc = "< Milliseconds device has been in detached role."]
9347 pub mDetachedTime: u64,
9348 #[doc = "< Milliseconds device has been in child role."]
9349 pub mChildTime: u64,
9350 #[doc = "< Milliseconds device has been in router role."]
9351 pub mRouterTime: u64,
9352 #[doc = "< Milliseconds device has been in leader role."]
9353 pub mLeaderTime: u64,
9354}
9355#[doc = " Represents a Network Diagnostic Child Table Entry."]
9356#[repr(C)]
9357#[repr(align(2))]
9358#[derive(Debug, Default, Copy, Clone)]
9359pub struct otNetworkDiagChildEntry {
9360 pub _bitfield_align_1: [u16; 0],
9361 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
9362 #[doc = "< Link mode."]
9363 pub mMode: otLinkModeConfig,
9364}
9365impl otNetworkDiagChildEntry {
9366 #[inline]
9367 pub fn mTimeout(&self) -> u16 {
9368 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u16) }
9369 }
9370 #[inline]
9371 pub fn set_mTimeout(&mut self, val: u16) {
9372 unsafe {
9373 let val: u16 = ::std::mem::transmute(val);
9374 self._bitfield_1.set(0usize, 5u8, val as u64)
9375 }
9376 }
9377 #[inline]
9378 pub fn mLinkQuality(&self) -> u8 {
9379 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u8) }
9380 }
9381 #[inline]
9382 pub fn set_mLinkQuality(&mut self, val: u8) {
9383 unsafe {
9384 let val: u8 = ::std::mem::transmute(val);
9385 self._bitfield_1.set(5usize, 2u8, val as u64)
9386 }
9387 }
9388 #[inline]
9389 pub fn mChildId(&self) -> u16 {
9390 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 9u8) as u16) }
9391 }
9392 #[inline]
9393 pub fn set_mChildId(&mut self, val: u16) {
9394 unsafe {
9395 let val: u16 = ::std::mem::transmute(val);
9396 self._bitfield_1.set(7usize, 9u8, val as u64)
9397 }
9398 }
9399 #[inline]
9400 pub fn new_bitfield_1(
9401 mTimeout: u16,
9402 mLinkQuality: u8,
9403 mChildId: u16,
9404 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
9405 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
9406 __bindgen_bitfield_unit.set(0usize, 5u8, {
9407 let mTimeout: u16 = unsafe { ::std::mem::transmute(mTimeout) };
9408 mTimeout as u64
9409 });
9410 __bindgen_bitfield_unit.set(5usize, 2u8, {
9411 let mLinkQuality: u8 = unsafe { ::std::mem::transmute(mLinkQuality) };
9412 mLinkQuality as u64
9413 });
9414 __bindgen_bitfield_unit.set(7usize, 9u8, {
9415 let mChildId: u16 = unsafe { ::std::mem::transmute(mChildId) };
9416 mChildId as u64
9417 });
9418 __bindgen_bitfield_unit
9419 }
9420}
9421#[doc = " Represents a Network Diagnostic TLV."]
9422#[repr(C)]
9423#[derive(Copy, Clone)]
9424pub struct otNetworkDiagTlv {
9425 #[doc = "< The Network Diagnostic TLV type."]
9426 pub mType: u8,
9427 pub mData: otNetworkDiagTlv__bindgen_ty_1,
9428}
9429#[repr(C)]
9430#[derive(Copy, Clone)]
9431pub union otNetworkDiagTlv__bindgen_ty_1 {
9432 pub mExtAddress: otExtAddress,
9433 pub mEui64: otExtAddress,
9434 pub mAddr16: u16,
9435 pub mMode: otLinkModeConfig,
9436 pub mTimeout: u32,
9437 pub mConnectivity: otNetworkDiagConnectivity,
9438 pub mRoute: otNetworkDiagRoute,
9439 pub mLeaderData: otLeaderData,
9440 pub mMacCounters: otNetworkDiagMacCounters,
9441 pub mMleCounters: otNetworkDiagMleCounters,
9442 pub mBatteryLevel: u8,
9443 pub mSupplyVoltage: u16,
9444 pub mMaxChildTimeout: u32,
9445 pub mVersion: u16,
9446 pub mVendorName: [::std::os::raw::c_char; 33usize],
9447 pub mVendorModel: [::std::os::raw::c_char; 33usize],
9448 pub mVendorSwVersion: [::std::os::raw::c_char; 17usize],
9449 pub mThreadStackVersion: [::std::os::raw::c_char; 65usize],
9450 pub mVendorAppUrl: [::std::os::raw::c_char; 97usize],
9451 pub mNetworkData: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1,
9452 pub mIp6AddrList: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2,
9453 pub mChildTable: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3,
9454 pub mChannelPages: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4,
9455}
9456#[repr(C)]
9457#[derive(Debug, Copy, Clone)]
9458pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1 {
9459 pub mCount: u8,
9460 pub m8: [u8; 254usize],
9461}
9462impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1 {
9463 fn default() -> Self {
9464 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9465 unsafe {
9466 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9467 s.assume_init()
9468 }
9469 }
9470}
9471#[repr(C)]
9472#[derive(Copy, Clone)]
9473pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2 {
9474 pub mCount: u8,
9475 pub mList: [otIp6Address; 15usize],
9476}
9477impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2 {
9478 fn default() -> Self {
9479 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9480 unsafe {
9481 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9482 s.assume_init()
9483 }
9484 }
9485}
9486#[repr(C)]
9487#[derive(Debug, Copy, Clone)]
9488pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3 {
9489 pub mCount: u8,
9490 pub mTable: [otNetworkDiagChildEntry; 63usize],
9491}
9492impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3 {
9493 fn default() -> Self {
9494 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9495 unsafe {
9496 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9497 s.assume_init()
9498 }
9499 }
9500}
9501#[repr(C)]
9502#[derive(Debug, Copy, Clone)]
9503pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4 {
9504 pub mCount: u8,
9505 pub m8: [u8; 254usize],
9506}
9507impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4 {
9508 fn default() -> Self {
9509 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9510 unsafe {
9511 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9512 s.assume_init()
9513 }
9514 }
9515}
9516impl Default for otNetworkDiagTlv__bindgen_ty_1 {
9517 fn default() -> Self {
9518 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9519 unsafe {
9520 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9521 s.assume_init()
9522 }
9523 }
9524}
9525impl Default for otNetworkDiagTlv {
9526 fn default() -> Self {
9527 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9528 unsafe {
9529 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9530 s.assume_init()
9531 }
9532 }
9533}
9534extern "C" {
9535 #[doc = " Gets the next Network Diagnostic TLV in the message.\n\n Requires `OPENTHREAD_CONFIG_TMF_NETDIAG_CLIENT_ENABLE`.\n\n @param[in] aMessage A pointer to a message.\n @param[in,out] aIterator A pointer to the Network Diagnostic iterator context. To get the first\n Network Diagnostic TLV it should be set to OT_NETWORK_DIAGNOSTIC_ITERATOR_INIT.\n @param[out] aNetworkDiagTlv A pointer to where the Network Diagnostic TLV information will be placed.\n\n @retval OT_ERROR_NONE Successfully found the next Network Diagnostic TLV.\n @retval OT_ERROR_NOT_FOUND No subsequent Network Diagnostic TLV exists in the message.\n @retval OT_ERROR_PARSE Parsing the next Network Diagnostic failed.\n\n @Note A subsequent call to this function is allowed only when current return value is OT_ERROR_NONE."]
9536 pub fn otThreadGetNextDiagnosticTlv(
9537 aMessage: *const otMessage,
9538 aIterator: *mut otNetworkDiagIterator,
9539 aNetworkDiagTlv: *mut otNetworkDiagTlv,
9540 ) -> otError;
9541}
9542#[doc = " Pointer is called when Network Diagnostic Get response is received.\n\n @param[in] aError The error when failed to get the response.\n @param[in] aMessage A pointer to the message buffer containing the received Network Diagnostic\n Get response payload. Available only when @p aError is `OT_ERROR_NONE`.\n @param[in] aMessageInfo A pointer to the message info for @p aMessage. Available only when\n @p aError is `OT_ERROR_NONE`.\n @param[in] aContext A pointer to application-specific context."]
9543pub type otReceiveDiagnosticGetCallback = ::std::option::Option<
9544 unsafe extern "C" fn(
9545 aError: otError,
9546 aMessage: *mut otMessage,
9547 aMessageInfo: *const otMessageInfo,
9548 aContext: *mut ::std::os::raw::c_void,
9549 ),
9550>;
9551extern "C" {
9552 #[doc = " Send a Network Diagnostic Get request.\n\n Requires `OPENTHREAD_CONFIG_TMF_NETDIAG_CLIENT_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDestination A pointer to destination address.\n @param[in] aTlvTypes An array of Network Diagnostic TLV types.\n @param[in] aCount Number of types in aTlvTypes.\n @param[in] aCallback A pointer to a function that is called when Network Diagnostic Get response\n is received or NULL to disable the callback.\n @param[in] aCallbackContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully queued the DIAG_GET.req.\n @retval OT_ERROR_NO_BUFS Insufficient message buffers available to send DIAG_GET.req."]
9553 pub fn otThreadSendDiagnosticGet(
9554 aInstance: *mut otInstance,
9555 aDestination: *const otIp6Address,
9556 aTlvTypes: *const u8,
9557 aCount: u8,
9558 aCallback: otReceiveDiagnosticGetCallback,
9559 aCallbackContext: *mut ::std::os::raw::c_void,
9560 ) -> otError;
9561}
9562extern "C" {
9563 #[doc = " Send a Network Diagnostic Reset request.\n\n Requires `OPENTHREAD_CONFIG_TMF_NETDIAG_CLIENT_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDestination A pointer to destination address.\n @param[in] aTlvTypes An array of Network Diagnostic TLV types. Currently only Type 9 is allowed.\n @param[in] aCount Number of types in aTlvTypes\n\n @retval OT_ERROR_NONE Successfully queued the DIAG_RST.ntf.\n @retval OT_ERROR_NO_BUFS Insufficient message buffers available to send DIAG_RST.ntf."]
9564 pub fn otThreadSendDiagnosticReset(
9565 aInstance: *mut otInstance,
9566 aDestination: *const otIp6Address,
9567 aTlvTypes: *const u8,
9568 aCount: u8,
9569 ) -> otError;
9570}
9571extern "C" {
9572 #[doc = " Get the vendor name string.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The vendor name string."]
9573 pub fn otThreadGetVendorName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9574}
9575extern "C" {
9576 #[doc = " Get the vendor model string.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The vendor model string."]
9577 pub fn otThreadGetVendorModel(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9578}
9579extern "C" {
9580 #[doc = " Get the vendor software version string.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The vendor software version string."]
9581 pub fn otThreadGetVendorSwVersion(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9582}
9583extern "C" {
9584 #[doc = " Get the vendor app URL string.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The vendor app URL string."]
9585 pub fn otThreadGetVendorAppUrl(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9586}
9587extern "C" {
9588 #[doc = " Set the vendor name string.\n\n Requires `OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE`.\n\n @p aVendorName should be UTF8 with max length of 32 chars (`MAX_VENDOR_NAME_TLV_LENGTH`). Maximum length does not\n include the null `\\0` character.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aVendorName The vendor name string.\n\n @retval OT_ERROR_NONE Successfully set the vendor name.\n @retval OT_ERROR_INVALID_ARGS @p aVendorName is not valid (too long or not UTF8)."]
9589 pub fn otThreadSetVendorName(
9590 aInstance: *mut otInstance,
9591 aVendorName: *const ::std::os::raw::c_char,
9592 ) -> otError;
9593}
9594extern "C" {
9595 #[doc = " Set the vendor model string.\n\n Requires `OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE`.\n\n @p aVendorModel should be UTF8 with max length of 32 chars (`MAX_VENDOR_MODEL_TLV_LENGTH`). Maximum length does not\n include the null `\\0` character.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aVendorModel The vendor model string.\n\n @retval OT_ERROR_NONE Successfully set the vendor model.\n @retval OT_ERROR_INVALID_ARGS @p aVendorModel is not valid (too long or not UTF8)."]
9596 pub fn otThreadSetVendorModel(
9597 aInstance: *mut otInstance,
9598 aVendorModel: *const ::std::os::raw::c_char,
9599 ) -> otError;
9600}
9601extern "C" {
9602 #[doc = " Set the vendor software version string.\n\n Requires `OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE`.\n\n @p aVendorSwVersion should be UTF8 with max length of 16 chars(`MAX_VENDOR_SW_VERSION_TLV_LENGTH`). Maximum length\n does not include the null `\\0` character.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aVendorSwVersion The vendor software version string.\n\n @retval OT_ERROR_NONE Successfully set the vendor software version.\n @retval OT_ERROR_INVALID_ARGS @p aVendorSwVersion is not valid (too long or not UTF8)."]
9603 pub fn otThreadSetVendorSwVersion(
9604 aInstance: *mut otInstance,
9605 aVendorSwVersion: *const ::std::os::raw::c_char,
9606 ) -> otError;
9607}
9608extern "C" {
9609 #[doc = " Set the vendor app URL string.\n\n Requires `OPENTHREAD_CONFIG_NET_DIAG_VENDOR_INFO_SET_API_ENABLE`.\n\n @p aVendorAppUrl should be UTF8 with max length of 64 chars (`MAX_VENDOR_APPL_URL_TLV_LENGTH`). Maximum length\n does not include the null `\\0` character.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aVendorAppUrl The vendor app URL string.\n\n @retval OT_ERROR_NONE Successfully set the vendor app URL string.\n @retval OT_ERROR_INVALID_ARGS @p aVendorAppUrl is not valid (too long or not UTF8)."]
9610 pub fn otThreadSetVendorAppUrl(
9611 aInstance: *mut otInstance,
9612 aVendorAppUrl: *const ::std::os::raw::c_char,
9613 ) -> otError;
9614}
9615#[doc = "< The device hasn't attached to a network."]
9616pub const OT_NETWORK_TIME_UNSYNCHRONIZED: otNetworkTimeStatus = -1;
9617#[doc = "< The device hasn’t received time sync for more than two periods time."]
9618pub const OT_NETWORK_TIME_RESYNC_NEEDED: otNetworkTimeStatus = 0;
9619#[doc = "< The device network time is synchronized."]
9620pub const OT_NETWORK_TIME_SYNCHRONIZED: otNetworkTimeStatus = 1;
9621#[doc = " Represents OpenThread time synchronization status."]
9622pub type otNetworkTimeStatus = ::std::os::raw::c_int;
9623#[doc = " Pointer is called when a network time sync or status change occurs."]
9624pub type otNetworkTimeSyncCallbackFn =
9625 ::std::option::Option<unsafe extern "C" fn(aCallbackContext: *mut ::std::os::raw::c_void)>;
9626extern "C" {
9627 #[doc = " Get the Thread network time.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in,out] aNetworkTime The Thread network time in microseconds.\n\n @returns The time synchronization status."]
9628 pub fn otNetworkTimeGet(
9629 aInstance: *mut otInstance,
9630 aNetworkTime: *mut u64,
9631 ) -> otNetworkTimeStatus;
9632}
9633extern "C" {
9634 #[doc = " Set the time synchronization period.\n\n Can only be called while Thread protocols are disabled.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aTimeSyncPeriod The time synchronization period, in seconds.\n\n @retval OT_ERROR_NONE Successfully set the time sync period.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled."]
9635 pub fn otNetworkTimeSetSyncPeriod(aInstance: *mut otInstance, aTimeSyncPeriod: u16) -> otError;
9636}
9637extern "C" {
9638 #[doc = " Get the time synchronization period.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The time synchronization period."]
9639 pub fn otNetworkTimeGetSyncPeriod(aInstance: *mut otInstance) -> u16;
9640}
9641extern "C" {
9642 #[doc = " Set the time synchronization XTAL accuracy threshold for Router-Capable device.\n\n Can only be called while Thread protocols are disabled.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aXTALThreshold The XTAL accuracy threshold for Router, in PPM.\n\n @retval OT_ERROR_NONE Successfully set the time sync period.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled."]
9643 pub fn otNetworkTimeSetXtalThreshold(
9644 aInstance: *mut otInstance,
9645 aXTALThreshold: u16,
9646 ) -> otError;
9647}
9648extern "C" {
9649 #[doc = " Get the time synchronization XTAL accuracy threshold for Router.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The XTAL accuracy threshold for Router, in PPM."]
9650 pub fn otNetworkTimeGetXtalThreshold(aInstance: *mut otInstance) -> u16;
9651}
9652extern "C" {
9653 #[doc = " Set a callback to be called when a network time sync or status change occurs\n\n This callback shall be called only when the network time offset jumps by\n OPENTHREAD_CONFIG_TIME_SYNC_JUMP_NOTIF_MIN_US or when the status changes.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aCallbackFn The callback function to be called\n @param[in] aCallbackContext The context to be passed to the callback function upon invocation"]
9654 pub fn otNetworkTimeSyncSetCallback(
9655 aInstance: *mut otInstance,
9656 aCallbackFn: otNetworkTimeSyncCallbackFn,
9657 aCallbackContext: *mut ::std::os::raw::c_void,
9658 );
9659}
9660#[doc = " Represents a ping reply."]
9661#[repr(C)]
9662#[derive(Copy, Clone)]
9663pub struct otPingSenderReply {
9664 #[doc = "< Sender IPv6 address (address from which ping reply was received)."]
9665 pub mSenderAddress: otIp6Address,
9666 #[doc = "< Round trip time in msec."]
9667 pub mRoundTripTime: u16,
9668 #[doc = "< Data size (number of bytes) in reply (excluding IPv6 and ICMP6 headers)."]
9669 pub mSize: u16,
9670 #[doc = "< Sequence number."]
9671 pub mSequenceNumber: u16,
9672 #[doc = "< Hop limit."]
9673 pub mHopLimit: u8,
9674}
9675impl Default for otPingSenderReply {
9676 fn default() -> Self {
9677 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9678 unsafe {
9679 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9680 s.assume_init()
9681 }
9682 }
9683}
9684#[doc = " Represents statistics of a ping request."]
9685#[repr(C)]
9686#[derive(Debug, Default, Copy, Clone)]
9687pub struct otPingSenderStatistics {
9688 #[doc = "< The number of ping requests already sent."]
9689 pub mSentCount: u16,
9690 #[doc = "< The number of ping replies received."]
9691 pub mReceivedCount: u16,
9692 #[doc = "< The total round trip time of ping requests."]
9693 pub mTotalRoundTripTime: u32,
9694 #[doc = "< The min round trip time among ping requests."]
9695 pub mMinRoundTripTime: u16,
9696 #[doc = "< The max round trip time among ping requests."]
9697 pub mMaxRoundTripTime: u16,
9698 #[doc = "< Whether this is a multicast ping request."]
9699 pub mIsMulticast: bool,
9700}
9701#[doc = " Pointer type specifies the callback to notify receipt of a ping reply.\n\n @param[in] aReply A pointer to a `otPingSenderReply` containing info about the received ping reply.\n @param[in] aContext A pointer to application-specific context."]
9702pub type otPingSenderReplyCallback = ::std::option::Option<
9703 unsafe extern "C" fn(aReply: *const otPingSenderReply, aContext: *mut ::std::os::raw::c_void),
9704>;
9705#[doc = " Pointer type specifies the callback to report the ping statistics.\n\n @param[in] aStatistics A pointer to a `otPingSenderStatistics` containing info about the received ping\n statistics.\n @param[in] aContext A pointer to application-specific context."]
9706pub type otPingSenderStatisticsCallback = ::std::option::Option<
9707 unsafe extern "C" fn(
9708 aStatistics: *const otPingSenderStatistics,
9709 aContext: *mut ::std::os::raw::c_void,
9710 ),
9711>;
9712#[doc = " Represents a ping request configuration."]
9713#[repr(C)]
9714#[derive(Copy, Clone)]
9715pub struct otPingSenderConfig {
9716 #[doc = "< Source address of the ping."]
9717 pub mSource: otIp6Address,
9718 #[doc = "< Destination address to ping."]
9719 pub mDestination: otIp6Address,
9720 #[doc = "< Callback function to report replies (can be NULL if not needed)."]
9721 pub mReplyCallback: otPingSenderReplyCallback,
9722 #[doc = "< Callback function to report statistics (can be NULL if not needed)."]
9723 pub mStatisticsCallback: otPingSenderStatisticsCallback,
9724 #[doc = "< A pointer to the callback application-specific context."]
9725 pub mCallbackContext: *mut ::std::os::raw::c_void,
9726 #[doc = "< Data size (# of bytes) excludes IPv6/ICMPv6 header. Zero for default."]
9727 pub mSize: u16,
9728 #[doc = "< Number of ping messages to send. Zero to use default."]
9729 pub mCount: u16,
9730 #[doc = "< Ping tx interval in milliseconds. Zero to use default."]
9731 pub mInterval: u32,
9732 #[doc = "< Time in milliseconds to wait for final reply after sending final request.\n< Zero to use default."]
9733 pub mTimeout: u16,
9734 #[doc = "< Hop limit (used if `mAllowZeroHopLimit` is false). Zero for default."]
9735 pub mHopLimit: u8,
9736 #[doc = "< Indicates whether hop limit is zero."]
9737 pub mAllowZeroHopLimit: bool,
9738 #[doc = "< Allow looping back pings to multicast address that device is subscribed to."]
9739 pub mMulticastLoop: bool,
9740}
9741impl Default for otPingSenderConfig {
9742 fn default() -> Self {
9743 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9744 unsafe {
9745 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9746 s.assume_init()
9747 }
9748 }
9749}
9750extern "C" {
9751 #[doc = " Starts a ping.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aConfig The ping config to use.\n\n @retval OT_ERROR_NONE The ping started successfully.\n @retval OT_ERROR_BUSY Could not start since busy with a previous ongoing ping request.\n @retval OT_ERROR_INVALID_ARGS The @p aConfig contains invalid parameters (e.g., ping interval is too long).\n"]
9752 pub fn otPingSenderPing(
9753 aInstance: *mut otInstance,
9754 aConfig: *const otPingSenderConfig,
9755 ) -> otError;
9756}
9757extern "C" {
9758 #[doc = " Stops an ongoing ping.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
9759 pub fn otPingSenderStop(aInstance: *mut otInstance);
9760}
9761extern "C" {
9762 #[doc = " Set the alarm to fire at @p aDt microseconds after @p aT0.\n\n For @p aT0, the platform MUST support all values in [0, 2^32-1].\n For @p aDt, the platform MUST support all values in [0, 2^31-1].\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aT0 The reference time.\n @param[in] aDt The time delay in microseconds from @p aT0."]
9763 pub fn otPlatAlarmMicroStartAt(aInstance: *mut otInstance, aT0: u32, aDt: u32);
9764}
9765extern "C" {
9766 #[doc = " Stop the alarm.\n\n @param[in] aInstance The OpenThread instance structure."]
9767 pub fn otPlatAlarmMicroStop(aInstance: *mut otInstance);
9768}
9769extern "C" {
9770 #[doc = " Get the current time.\n\n The current time MUST represent a free-running timer. When maintaining current time, the time value MUST utilize the\n entire range [0, 2^32-1] and MUST NOT wrap before 2^32.\n\n @returns The current time in microseconds."]
9771 pub fn otPlatAlarmMicroGetNow() -> u32;
9772}
9773extern "C" {
9774 #[doc = " Signal that the alarm has fired.\n\n @param[in] aInstance The OpenThread instance structure."]
9775 pub fn otPlatAlarmMicroFired(aInstance: *mut otInstance);
9776}
9777extern "C" {
9778 #[doc = " Set the alarm to fire at @p aDt milliseconds after @p aT0.\n\n For @p aT0 the platform MUST support all values in [0, 2^32-1].\n For @p aDt, the platform MUST support all values in [0, 2^31-1].\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aT0 The reference time.\n @param[in] aDt The time delay in milliseconds from @p aT0."]
9779 pub fn otPlatAlarmMilliStartAt(aInstance: *mut otInstance, aT0: u32, aDt: u32);
9780}
9781extern "C" {
9782 #[doc = " Stop the alarm.\n\n @param[in] aInstance The OpenThread instance structure."]
9783 pub fn otPlatAlarmMilliStop(aInstance: *mut otInstance);
9784}
9785extern "C" {
9786 #[doc = " Get the current time.\n\n The current time MUST represent a free-running timer. When maintaining current time, the time value MUST utilize the\n entire range [0, 2^32-1] and MUST NOT wrap before 2^32.\n\n @returns The current time in milliseconds."]
9787 pub fn otPlatAlarmMilliGetNow() -> u32;
9788}
9789extern "C" {
9790 #[doc = " Signal that the alarm has fired.\n\n @param[in] aInstance The OpenThread instance structure."]
9791 pub fn otPlatAlarmMilliFired(aInstance: *mut otInstance);
9792}
9793extern "C" {
9794 #[doc = " Signal diagnostics module that the alarm has fired.\n\n @param[in] aInstance The OpenThread instance structure."]
9795 pub fn otPlatDiagAlarmFired(aInstance: *mut otInstance);
9796}
9797extern "C" {
9798 #[doc = " Handles ICMP6 RA messages received on the Thread interface on the platform.\n\n The `aMessage` should point to a buffer of a valid ICMPv6 message (without IP headers) with router advertisement as\n the value of type field of the message.\n\n When DHCPv6 PD is disabled, the message will be dropped silently.\n\n Note: RA messages will not be forwarded into Thread networks, while for many platforms, RA messages is the way of\n distributing a prefix and other infomations to the downstream network. The typical usecase of this function is to\n handle the router advertisement messages sent by the platform as a result of DHCPv6 Prefix Delegation.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to an ICMPv6 RouterAdvertisement message.\n @param[in] aLength The length of ICMPv6 RouterAdvertisement message."]
9799 pub fn otPlatBorderRoutingProcessIcmp6Ra(
9800 aInstance: *mut otInstance,
9801 aMessage: *const u8,
9802 aLength: u16,
9803 );
9804}
9805extern "C" {
9806 #[doc = " Process a prefix received from the DHCPv6 PD Server. The prefix is received on\n the DHCPv6 PD client callback and provided to the Routing Manager via this\n API.\n\n The prefix lifetime can be updated by calling the function again with updated time values.\n If the preferred lifetime of the prefix is set to 0, the prefix becomes deprecated.\n When this function is called multiple times, the smallest prefix is preferred as this rule allows\n choosing a GUA instead of a ULA.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_DHCP6_PD_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPrefixInfo A pointer to the prefix information structure"]
9807 pub fn otPlatBorderRoutingProcessDhcp6PdPrefix(
9808 aInstance: *mut otInstance,
9809 aPrefixInfo: *const otBorderRoutingPrefixTableEntry,
9810 );
9811}
9812extern "C" {
9813 #[doc = " Standard printf() to the debug uart with no log decoration.\n\n @param[in] fmt printf formatter text\n\n This is a debug convenience function that is not intended to be\n used in anything other then \"debug scenarios\" by a developer.\n\n lf -> cr/lf mapping is automatically handled via otPlatDebugUart_putchar()\n\n @sa otPlatDebugUart_vprintf() for limitations\n\n This is a WEAK symbol that can easily be overridden as needed."]
9814 pub fn otPlatDebugUart_printf(fmt: *const ::std::os::raw::c_char, ...);
9815}
9816extern "C" {
9817 #[doc = " Standard vprintf() to the debug uart, with no log decoration.\n\n @param[in] fmt printf formatter text\n @param[in] ap va_list value for print parameters.\n\n Implementation limitation: this formats the text into\n a purposely small text buffer on the stack, thus long\n messages may be truncated.\n\n This is a WEAK symbol that can easily be overridden as needed.\n\n For example, some platforms might override this via a non-WEAK\n symbol because the platform provides a UART_vprintf() like\n function that can handle an arbitrary length output."]
9818 pub fn otPlatDebugUart_vprintf(fmt: *const ::std::os::raw::c_char, ap: *mut __va_list_tag);
9819}
9820extern "C" {
9821 #[doc = " Platform specific write single byte to Debug Uart\n This should not perform CR/LF mapping.\n\n MUST be implemented by the platform\n\n @param[in] c what to transmit"]
9822 pub fn otPlatDebugUart_putchar_raw(c: ::std::os::raw::c_int);
9823}
9824extern "C" {
9825 #[doc = " Poll/test debug uart if a key has been pressed.\n It would be common to a stub function that returns 0.\n\n MUST be implemented by the platform\n\n @retval zero - nothing ready\n @retval nonzero - otPlatDebugUart_getc() will succeed."]
9826 pub fn otPlatDebugUart_kbhit() -> ::std::os::raw::c_int;
9827}
9828extern "C" {
9829 #[doc = " Poll/Read a byte from the debug uart\n\n MUST be implemented by the platform\n\n @retval (negative) no data available, see otPlatDebugUart_kbhit()\n @retval (0x00..0x0ff) data byte value"]
9830 pub fn otPlatDebugUart_getc() -> ::std::os::raw::c_int;
9831}
9832extern "C" {
9833 #[doc = " Write byte to the uart, expand cr/lf as need.\n\n A WEAK default implementation is provided\n that can be overridden as needed.\n\n @param[in] c the byte to transmit"]
9834 pub fn otPlatDebugUart_putchar(c: ::std::os::raw::c_int);
9835}
9836extern "C" {
9837 #[doc = " identical to \"man 3 puts\" - terminates with lf\n Which is then mapped to cr/lf as required\n\n A WEAK default implementation is provided\n that can be overridden as needed.\n\n @param[in] s the string to print with a lf at the end"]
9838 pub fn otPlatDebugUart_puts(s: *const ::std::os::raw::c_char);
9839}
9840extern "C" {
9841 #[doc = " Write N bytes to the UART, mapping cr/lf\n\n @param[in] pBytes pointer to bytes to transmit.\n @param[in] nBytes how many bytes to transmit."]
9842 pub fn otPlatDebugUart_write_bytes(pBytes: *const u8, nBytes: ::std::os::raw::c_int);
9843}
9844extern "C" {
9845 #[doc = " puts() without a terminal newline.\n see: \"man 3 puts\", without a adding a terminal lf\n\n @param[in] s the string to print without a lf at the end\n\n Note, the terminal \"lf\" mapped to cr/lf via\n the function otPlatDebugUart_putchar()"]
9846 pub fn otPlatDebugUart_puts_no_nl(s: *const ::std::os::raw::c_char);
9847}
9848extern "C" {
9849 #[doc = " Some platforms (simulation) can log to a file.\n\n @returns OT_ERROR_NONE\n @returns OT_ERROR_FAILED\n\n Platforms that desire this MUST provide an implementation."]
9850 pub fn otPlatDebugUart_logfile(filename: *const ::std::os::raw::c_char) -> otError;
9851}
9852#[repr(C)]
9853#[derive(Debug, Copy, Clone)]
9854pub struct otPlatDnsUpstreamQuery {
9855 _unused: [u8; 0],
9856}
9857extern "C" {
9858 #[doc = " Starts an upstream query transaction.\n\n - In success case (and errors represented by DNS protocol messages), the platform is expected to call\n `otPlatDnsUpstreamQueryDone`.\n - The OpenThread core may cancel a (possibly timeout) query transaction by calling\n `otPlatDnsCancelUpstreamQuery`, the platform must not call `otPlatDnsUpstreamQueryDone` on a\n cancelled transaction.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aTxn A pointer to the opaque DNS query transaction object.\n @param[in] aQuery A message buffer of the DNS payload that should be sent to upstream DNS server."]
9859 pub fn otPlatDnsStartUpstreamQuery(
9860 aInstance: *mut otInstance,
9861 aTxn: *mut otPlatDnsUpstreamQuery,
9862 aQuery: *const otMessage,
9863 );
9864}
9865extern "C" {
9866 #[doc = " Cancels a transaction of upstream query.\n\n The platform must call `otPlatDnsUpstreamQueryDone` to release the resources.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aTxn A pointer to the opaque DNS query transaction object."]
9867 pub fn otPlatDnsCancelUpstreamQuery(
9868 aInstance: *mut otInstance,
9869 aTxn: *mut otPlatDnsUpstreamQuery,
9870 );
9871}
9872extern "C" {
9873 #[doc = " The platform calls this function to finish DNS query.\n\n The transaction will be released, so the platform must not call on the same transaction twice. This function passes\n the ownership of `aResponse` to OpenThread stack.\n\n Platform can pass a nullptr to close a transaction without a response.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aTxn A pointer to the opaque DNS query transaction object.\n @param[in] aResponse A message buffer of the DNS response payload or `nullptr` to close a transaction without a\n response."]
9874 pub fn otPlatDnsUpstreamQueryDone(
9875 aInstance: *mut otInstance,
9876 aTxn: *mut otPlatDnsUpstreamQuery,
9877 aResponse: *mut otMessage,
9878 );
9879}
9880extern "C" {
9881 #[doc = " Fill buffer with entropy.\n\n MUST be implemented using a true random number generator (TRNG).\n\n @param[out] aOutput A pointer to where the true random values are placed. Must not be NULL.\n @param[in] aOutputLength Size of @p aBuffer.\n\n @retval OT_ERROR_NONE Successfully filled @p aBuffer with true random values.\n @retval OT_ERROR_FAILED Failed to fill @p aBuffer with true random values.\n @retval OT_ERROR_INVALID_ARGS @p aBuffer was set to NULL."]
9882 pub fn otPlatEntropyGet(aOutput: *mut u8, aOutputLength: u16) -> otError;
9883}
9884extern "C" {
9885 #[doc = " Initializes the flash driver.\n\n @param[in] aInstance The OpenThread instance structure."]
9886 pub fn otPlatFlashInit(aInstance: *mut otInstance);
9887}
9888extern "C" {
9889 #[doc = " Gets the size of the swap space.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The size of the swap space in bytes."]
9890 pub fn otPlatFlashGetSwapSize(aInstance: *mut otInstance) -> u32;
9891}
9892extern "C" {
9893 #[doc = " Erases the swap space indicated by @p aSwapIndex.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aSwapIndex A value in [0, 1] that indicates the swap space."]
9894 pub fn otPlatFlashErase(aInstance: *mut otInstance, aSwapIndex: u8);
9895}
9896extern "C" {
9897 #[doc = " Reads @p aSize bytes into @p aData.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aSwapIndex A value in [0, 1] that indicates the swap space.\n @param[in] aOffset A byte offset within the swap space.\n @param[out] aData A pointer to the data buffer for reading.\n @param[in] aSize Number of bytes to read."]
9898 pub fn otPlatFlashRead(
9899 aInstance: *mut otInstance,
9900 aSwapIndex: u8,
9901 aOffset: u32,
9902 aData: *mut ::std::os::raw::c_void,
9903 aSize: u32,
9904 );
9905}
9906extern "C" {
9907 #[doc = " Writes @p aSize bytes from @p aData.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aSwapIndex A value in [0, 1] that indicates the swap space.\n @param[in] aOffset A byte offset within the swap space.\n @param[out] aData A pointer to the data to write.\n @param[in] aSize Number of bytes to write."]
9908 pub fn otPlatFlashWrite(
9909 aInstance: *mut otInstance,
9910 aSwapIndex: u8,
9911 aOffset: u32,
9912 aData: *const ::std::os::raw::c_void,
9913 aSize: u32,
9914 );
9915}
9916#[doc = " Represents an InfraIf Link-Layer Address."]
9917#[repr(C)]
9918#[derive(Debug, Default, Copy, Clone)]
9919pub struct otPlatInfraIfLinkLayerAddress {
9920 #[doc = "< The link-layer address bytes."]
9921 pub mAddress: [u8; 16usize],
9922 #[doc = "< The address length (number of bytes)."]
9923 pub mLength: u8,
9924}
9925extern "C" {
9926 #[doc = " Tells whether an infra interface has the given IPv6 address assigned.\n\n @param[in] aInfraIfIndex The index of the infra interface.\n @param[in] aAddress The IPv6 address.\n\n @returns TRUE if the infra interface has given IPv6 address assigned, FALSE otherwise."]
9927 pub fn otPlatInfraIfHasAddress(aInfraIfIndex: u32, aAddress: *const otIp6Address) -> bool;
9928}
9929extern "C" {
9930 #[doc = " Sends an ICMPv6 Neighbor Discovery message on given infrastructure interface.\n\n See RFC 4861: https://tools.ietf.org/html/rfc4861.\n\n @param[in] aInfraIfIndex The index of the infrastructure interface this message is sent to.\n @param[in] aDestAddress The destination address this message is sent to.\n @param[in] aBuffer The ICMPv6 message buffer. The ICMPv6 checksum is left zero and the\n platform should do the checksum calculate.\n @param[in] aBufferLength The length of the message buffer.\n\n @note Per RFC 4861, the implementation should send the message with IPv6 link-local source address\n of interface @p aInfraIfIndex and IP Hop Limit 255.\n\n @retval OT_ERROR_NONE Successfully sent the ICMPv6 message.\n @retval OT_ERROR_FAILED Failed to send the ICMPv6 message."]
9931 pub fn otPlatInfraIfSendIcmp6Nd(
9932 aInfraIfIndex: u32,
9933 aDestAddress: *const otIp6Address,
9934 aBuffer: *const u8,
9935 aBufferLength: u16,
9936 ) -> otError;
9937}
9938extern "C" {
9939 #[doc = " The infra interface driver calls this method to notify OpenThread\n that an ICMPv6 Neighbor Discovery message is received.\n\n See RFC 4861: https://tools.ietf.org/html/rfc4861.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aInfraIfIndex The index of the infrastructure interface on which the ICMPv6 message is received.\n @param[in] aSrcAddress The source address this message is received from.\n @param[in] aBuffer The ICMPv6 message buffer.\n @param[in] aBufferLength The length of the ICMPv6 message buffer.\n\n @note Per RFC 4861, the caller should enforce that the source address MUST be a IPv6 link-local\n address and the IP Hop Limit MUST be 255."]
9940 pub fn otPlatInfraIfRecvIcmp6Nd(
9941 aInstance: *mut otInstance,
9942 aInfraIfIndex: u32,
9943 aSrcAddress: *const otIp6Address,
9944 aBuffer: *const u8,
9945 aBufferLength: u16,
9946 );
9947}
9948extern "C" {
9949 #[doc = " The infra interface driver calls this method to notify OpenThread\n of the interface state changes.\n\n It is fine for the platform to call to method even when the running state\n of the interface hasn't changed. In this case, the Routing Manager state is\n not affected.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aInfraIfIndex The index of the infrastructure interface.\n @param[in] aIsRunning A boolean that indicates whether the infrastructure\n interface is running.\n\n @retval OT_ERROR_NONE Successfully updated the infra interface status.\n @retval OT_ERROR_INVALID_STATE The Routing Manager is not initialized.\n @retval OT_ERROR_INVALID_ARGS The @p aInfraIfIndex doesn't match the infra interface the\n Routing Manager are initialized with."]
9950 pub fn otPlatInfraIfStateChanged(
9951 aInstance: *mut otInstance,
9952 aInfraIfIndex: u32,
9953 aIsRunning: bool,
9954 ) -> otError;
9955}
9956extern "C" {
9957 #[doc = " Send a request to discover the NAT64 prefix on the infrastructure interface with @p aInfraIfIndex.\n\n OpenThread will call this method periodically to monitor the presence or change of NAT64 prefix.\n\n @param[in] aInfraIfIndex The index of the infrastructure interface to discover the NAT64 prefix.\n\n @retval OT_ERROR_NONE Successfully request NAT64 prefix discovery.\n @retval OT_ERROR_FAILED Failed to request NAT64 prefix discovery."]
9958 pub fn otPlatInfraIfDiscoverNat64Prefix(aInfraIfIndex: u32) -> otError;
9959}
9960extern "C" {
9961 #[doc = " The infra interface driver calls this method to notify OpenThread that\n the discovery of NAT64 prefix is done.\n\n Is expected to be invoked after calling otPlatInfraIfDiscoverNat64Prefix.\n If no NAT64 prefix is discovered, @p aIp6Prefix shall point to an empty prefix with zero length.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aInfraIfIndex The index of the infrastructure interface on which the NAT64 prefix is discovered.\n @param[in] aIp6Prefix A pointer to NAT64 prefix."]
9962 pub fn otPlatInfraIfDiscoverNat64PrefixDone(
9963 aInstance: *mut otInstance,
9964 aInfraIfIndex: u32,
9965 aIp6Prefix: *const otIp6Prefix,
9966 );
9967}
9968extern "C" {
9969 #[doc = " Get the link-layer address of the infrastructure interface.\n\n OpenThread invokes this method when the address is required, for example: when generating an ND6 message\n which includes a source link-layer address option.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aInfraIfIndex The index of the infrastructure interface.\n @param[out] aInfraIfLinkLayerAddress A pointer to infrastructure interface link-layer address.\n\n @retval OT_ERROR_NONE Successfully get the infrastructure interface link-layer address.\n @retval OT_ERROR_FAILED Failed to get the infrastructure interface link-layer address."]
9970 pub fn otPlatGetInfraIfLinkLayerAddress(
9971 aInstance: *mut otInstance,
9972 aIfIndex: u32,
9973 aInfraIfLinkLayerAddress: *mut otPlatInfraIfLinkLayerAddress,
9974 ) -> otError;
9975}
9976extern "C" {
9977 #[doc = " Dynamically allocates new memory. On platforms that support it, should just redirect to calloc. For\n those that don't support calloc, should support the same functionality:\n\n \"The calloc() function contiguously allocates enough space for count objects that are size bytes of\n memory each and returns a pointer to the allocated memory. The allocated memory is filled with bytes\n of value zero.\"\n\n Is required for OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE.\n\n @param[in] aNum The number of blocks to allocate\n @param[in] aSize The size of each block to allocate\n\n @retval void* The pointer to the front of the memory allocated\n @retval NULL Failed to allocate the memory requested."]
9978 pub fn otPlatCAlloc(aNum: usize, aSize: usize) -> *mut ::std::os::raw::c_void;
9979}
9980extern "C" {
9981 #[doc = " Frees memory that was dynamically allocated.\n\n Is required for OPENTHREAD_CONFIG_HEAP_EXTERNAL_ENABLE.\n\n @param[in] aPtr A pointer the memory blocks to free. The pointer may be NULL."]
9982 pub fn otPlatFree(aPtr: *mut ::std::os::raw::c_void);
9983}
9984#[doc = " Represents an OpenThread message buffer."]
9985#[repr(C)]
9986#[derive(Debug, Copy, Clone)]
9987pub struct otMessageBuffer {
9988 #[doc = "< Pointer to the next buffer."]
9989 pub mNext: *mut otMessageBuffer,
9990}
9991impl Default for otMessageBuffer {
9992 fn default() -> Self {
9993 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9994 unsafe {
9995 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9996 s.assume_init()
9997 }
9998 }
9999}
10000extern "C" {
10001 #[doc = " Initialize the platform implemented message pool.\n\n Is used when `OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT` is enabled.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aMinNumFreeBuffers An uint16 containing the minimum number of free buffers desired by OpenThread.\n @param[in] aBufferSize The size in bytes of a buffer object."]
10002 pub fn otPlatMessagePoolInit(
10003 aInstance: *mut otInstance,
10004 aMinNumFreeBuffers: u16,
10005 aBufferSize: usize,
10006 );
10007}
10008extern "C" {
10009 #[doc = " Allocate a buffer from the platform managed buffer pool.\n\n Is used when `OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT` is enabled.\n\n The returned buffer instance MUST have at least `aBufferSize` bytes (as specified in `otPlatMessagePoolInit()`).\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns A pointer to the buffer or NULL if no buffers are available."]
10010 pub fn otPlatMessagePoolNew(aInstance: *mut otInstance) -> *mut otMessageBuffer;
10011}
10012extern "C" {
10013 #[doc = " Is used to free a buffer back to the platform managed buffer pool.\n\n Is used when `OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT` is enabled.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aBuffer The buffer to free."]
10014 pub fn otPlatMessagePoolFree(aInstance: *mut otInstance, aBuffer: *mut otMessageBuffer);
10015}
10016extern "C" {
10017 #[doc = " Get the number of free buffers.\n\n Is used when `OPENTHREAD_CONFIG_PLATFORM_MESSAGE_MANAGEMENT` is enabled.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns The number of buffers currently free and available to OpenThread."]
10018 pub fn otPlatMessagePoolNumFreeBuffers(aInstance: *mut otInstance) -> u16;
10019}
10020extern "C" {
10021 #[doc = " Performs a software reset on the platform, if supported.\n\n @param[in] aInstance The OpenThread instance structure."]
10022 pub fn otPlatReset(aInstance: *mut otInstance);
10023}
10024extern "C" {
10025 #[doc = " Performs a hardware reset on the platform to launch bootloader mode, if supported.\n\n Used when `OPENTHREAD_CONFIG_PLATFORM_BOOTLOADER_MODE_ENABLE` is enabled.\n\n @param[in] aInstance The OpenThread instance structure.\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."]
10026 pub fn otPlatResetToBootloader(aInstance: *mut otInstance) -> otError;
10027}
10028pub const OT_PLAT_RESET_REASON_POWER_ON: otPlatResetReason = 0;
10029pub const OT_PLAT_RESET_REASON_EXTERNAL: otPlatResetReason = 1;
10030pub const OT_PLAT_RESET_REASON_SOFTWARE: otPlatResetReason = 2;
10031pub const OT_PLAT_RESET_REASON_FAULT: otPlatResetReason = 3;
10032pub const OT_PLAT_RESET_REASON_CRASH: otPlatResetReason = 4;
10033pub const OT_PLAT_RESET_REASON_ASSERT: otPlatResetReason = 5;
10034pub const OT_PLAT_RESET_REASON_OTHER: otPlatResetReason = 6;
10035pub const OT_PLAT_RESET_REASON_UNKNOWN: otPlatResetReason = 7;
10036pub const OT_PLAT_RESET_REASON_WATCHDOG: otPlatResetReason = 8;
10037pub const OT_PLAT_RESET_REASON_COUNT: otPlatResetReason = 9;
10038#[doc = " Enumeration of possible reset reason codes.\n\n These are in the same order as the Spinel reset reason codes."]
10039pub type otPlatResetReason = ::std::os::raw::c_uint;
10040extern "C" {
10041 #[doc = " Returns the reason for the last platform reset.\n\n @param[in] aInstance The OpenThread instance structure."]
10042 pub fn otPlatGetResetReason(aInstance: *mut otInstance) -> otPlatResetReason;
10043}
10044extern "C" {
10045 #[doc = " Provides a platform specific implementation for assert.\n\n @param[in] aFilename The name of the file where the assert occurred.\n @param[in] aLineNumber The line number in the file where the assert occurred."]
10046 pub fn otPlatAssertFail(
10047 aFilename: *const ::std::os::raw::c_char,
10048 aLineNumber: ::std::os::raw::c_int,
10049 );
10050}
10051extern "C" {
10052 #[doc = " Performs a platform specific operation to wake the host MCU.\n This is used only for NCP configurations."]
10053 pub fn otPlatWakeHost();
10054}
10055#[doc = " NCP's MCU stays on and active all the time.\n\n When the NCP's desired power state is set to `ON`, host can send messages to NCP without requiring any \"poke\" or\n external triggers.\n\n @note The `ON` power state only determines the MCU's power mode and is not related to radio's state."]
10056pub const OT_PLAT_MCU_POWER_STATE_ON: otPlatMcuPowerState = 0;
10057#[doc = " NCP's MCU can enter low-power (energy-saving) state.\n\n When the NCP's desired power state is set to `LOW_POWER`, host is expected to \"poke\" the NCP (e.g., an external\n trigger like an interrupt) before it can communicate with the NCP (send a message to the NCP). The \"poke\"\n mechanism is determined by the platform code (based on NCP's interface to the host).\n\n While power state is set to `LOW_POWER`, NCP can still (at any time) send messages to host. Note that receiving\n a message from the NCP does NOT indicate that the NCP's power state has changed, i.e., host is expected to\n continue to \"poke\" when it wants to talk to the NCP until the power state is explicitly changed (by a successful\n call to `otPlatSetMcuPowerState()` changing the state to `ON`).\n\n @note The `LOW_POWER` power state only determines the MCU's power mode and is not related to radio's state\n (radio is managed by OpenThread core and device role, e.g., device being sleepy or not."]
10058pub const OT_PLAT_MCU_POWER_STATE_LOW_POWER: otPlatMcuPowerState = 1;
10059#[doc = " NCP is fully off.\n\n An NCP hardware reset (via a RESET pin) is required to bring the NCP back to `SPINEL_MCU_POWER_STATE_ON`.\n RAM is not retained after reset."]
10060pub const OT_PLAT_MCU_POWER_STATE_OFF: otPlatMcuPowerState = 2;
10061#[doc = " Enumeration of micro-controller's power states.\n\n These values are used for NCP configuration when `OPENTHREAD_CONFIG_NCP_ENABLE_MCU_POWER_STATE_CONTROL` is enabled.\n\n The power state specifies the desired power state of NCP's micro-controller (MCU) when the underlying platform's\n operating system enters idle mode (i.e., all active tasks/events are processed and the MCU can potentially enter a\n energy-saving power state).\n\n The power state primarily determines how the host should interact with the NCP and whether the host needs an\n external trigger (a \"poke\") to NCP before it can communicate with the NCP or not.\n\n After a reset, the MCU power state MUST be `OT_PLAT_POWER_STATE_ON`."]
10062pub type otPlatMcuPowerState = ::std::os::raw::c_uint;
10063extern "C" {
10064 #[doc = " Sets the desired MCU power state.\n\n This is only applicable and used for NCP configuration when `OPENTHREAD_CONFIG_NCP_ENABLE_MCU_POWER_STATE_CONTROL`\n is enabled.\n\n @param[in] aInstance A pointer to OpenThread instance.\n @param[in] aState The new MCU power state.\n\n @retval OT_ERROR_NONE The power state updated successfully.\n @retval OT_ERROR_FAILED The given MCU power state is not supported by the platform."]
10065 pub fn otPlatSetMcuPowerState(
10066 aInstance: *mut otInstance,
10067 aState: otPlatMcuPowerState,
10068 ) -> otError;
10069}
10070extern "C" {
10071 #[doc = " Gets the current desired MCU power state.\n\n This is only applicable and used for NCP configuration when `OPENTHREAD_CONFIG_NCP_ENABLE_MCU_POWER_STATE_CONTROL`\n is enabled.\n\n After a reset, the power state MUST return `OT_PLAT_POWER_STATE_ON`. During operation, power state SHOULD only\n change through an explicit successful call to `otPlatSetMcuPowerState()`.\n\n @param[in] aInstance A pointer to OpenThread instance.\n\n @returns The current power state."]
10072 pub fn otPlatGetMcuPowerState(aInstance: *mut otInstance) -> otPlatMcuPowerState;
10073}
10074extern "C" {
10075 #[doc = " Logs a crash dump using OpenThread logging APIs\n\n @note This API is an optional logging platform API. It's up to the platform layer to implement it.\n\n @retval OT_ERROR_NONE Crash dump was logged successfully\n @retval OT_ERROR_NOT_CAPABLE Platform is not capable of logging a crash dump"]
10076 pub fn otPlatLogCrashDump() -> otError;
10077}
10078extern "C" {
10079 #[doc = " Exports status information to OTNS.\n\n The status information is represented by a null-terminated string with format recognizable by OTNS.\n Each call to `otPlatOtnsStatus` can send multiple statuses, separated by ';', e.x. \"parid=577fbc37;lrid=5\".\n Each status contains key and value separated by '='.\n Status value can be further separated into multiple fields using ',',\n e.x. \"ping_request=fdde:ad00:beef:0:459e:d7b4:b65e:5480,4,112000\".\n\n New statuses should follow these conventions.\n\n Currently, OTNS only supports virtual time simulation.\n\n @param[in] aStatus The status string."]
10080 pub fn otPlatOtnsStatus(aStatus: *const ::std::os::raw::c_char);
10081}
10082#[doc = "< Active Operational Dataset."]
10083pub const OT_SETTINGS_KEY_ACTIVE_DATASET: _bindgen_ty_10 = 1;
10084#[doc = "< Pending Operational Dataset."]
10085pub const OT_SETTINGS_KEY_PENDING_DATASET: _bindgen_ty_10 = 2;
10086#[doc = "< Thread network information."]
10087pub const OT_SETTINGS_KEY_NETWORK_INFO: _bindgen_ty_10 = 3;
10088#[doc = "< Parent information."]
10089pub const OT_SETTINGS_KEY_PARENT_INFO: _bindgen_ty_10 = 4;
10090#[doc = "< Child information."]
10091pub const OT_SETTINGS_KEY_CHILD_INFO: _bindgen_ty_10 = 5;
10092#[doc = "< SLAAC key to generate semantically opaque IID."]
10093pub const OT_SETTINGS_KEY_SLAAC_IID_SECRET_KEY: _bindgen_ty_10 = 7;
10094#[doc = "< Duplicate Address Detection (DAD) information."]
10095pub const OT_SETTINGS_KEY_DAD_INFO: _bindgen_ty_10 = 8;
10096#[doc = "< SRP client ECDSA public/private key pair."]
10097pub const OT_SETTINGS_KEY_SRP_ECDSA_KEY: _bindgen_ty_10 = 11;
10098#[doc = "< The SRP client info (selected SRP server address)."]
10099pub const OT_SETTINGS_KEY_SRP_CLIENT_INFO: _bindgen_ty_10 = 12;
10100#[doc = "< The SRP server info (UDP port)."]
10101pub const OT_SETTINGS_KEY_SRP_SERVER_INFO: _bindgen_ty_10 = 13;
10102#[doc = "< BR ULA prefix."]
10103pub const OT_SETTINGS_KEY_BR_ULA_PREFIX: _bindgen_ty_10 = 15;
10104#[doc = "< BR local on-link prefixes."]
10105pub const OT_SETTINGS_KEY_BR_ON_LINK_PREFIXES: _bindgen_ty_10 = 16;
10106#[doc = "< Unique Border Agent/Router ID."]
10107pub const OT_SETTINGS_KEY_BORDER_AGENT_ID: _bindgen_ty_10 = 17;
10108#[doc = "< TCAT Commissioner certificate"]
10109pub const OT_SETTINGS_KEY_TCAT_COMMR_CERT: _bindgen_ty_10 = 18;
10110pub const OT_SETTINGS_KEY_VENDOR_RESERVED_MIN: _bindgen_ty_10 = 32768;
10111pub const OT_SETTINGS_KEY_VENDOR_RESERVED_MAX: _bindgen_ty_10 = 65535;
10112#[doc = " Defines the keys of settings.\n\n Note: When adding a new settings key, if the settings corresponding to the key contains security sensitive\n information, the developer MUST add the key to the array `aSensitiveKeys` which is passed in\n `otPlatSettingsInit()`."]
10113pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
10114extern "C" {
10115 #[doc = " Performs any initialization for the settings subsystem, if necessary.\n\n Also sets the sensitive keys that should be stored in the secure area.\n\n Note that the memory pointed by @p aSensitiveKeys MUST not be released before @p aInstance is destroyed.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aSensitiveKeys A pointer to an array containing the list of sensitive keys. May be NULL only if\n @p aSensitiveKeysLength is 0, which means that there is no sensitive keys.\n @param[in] aSensitiveKeysLength The number of entries in the @p aSensitiveKeys array."]
10116 pub fn otPlatSettingsInit(
10117 aInstance: *mut otInstance,
10118 aSensitiveKeys: *const u16,
10119 aSensitiveKeysLength: u16,
10120 );
10121}
10122extern "C" {
10123 #[doc = " Performs any de-initialization for the settings subsystem, if necessary.\n\n @param[in] aInstance The OpenThread instance structure."]
10124 pub fn otPlatSettingsDeinit(aInstance: *mut otInstance);
10125}
10126extern "C" {
10127 #[doc = " Fetches the value of a setting.\n\n Fetches the value of the setting identified\n by @p aKey and write it to the memory pointed to by aValue.\n It then writes the length to the integer pointed to by\n @p aValueLength. The initial value of @p aValueLength is the\n maximum number of bytes to be written to @p aValue.\n\n Can be used to check for the existence of\n a key without fetching the value by setting @p aValue and\n @p aValueLength to NULL. You can also check the length of\n the setting without fetching it by setting only aValue\n to NULL.\n\n Note that the underlying storage implementation is not\n required to maintain the order of settings with multiple\n values. The order of such values MAY change after ANY\n write operation to the store.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aKey The key associated with the requested setting.\n @param[in] aIndex The index of the specific item to get.\n @param[out] aValue A pointer to where the value of the setting should be written. May be set to NULL if\n just testing for the presence or length of a setting.\n @param[in,out] aValueLength A pointer to the length of the value. When called, this pointer should point to an\n integer containing the maximum value size that can be written to @p aValue. At return,\n the actual length of the setting is written. This may be set to NULL if performing\n a presence check.\n\n @retval OT_ERROR_NONE The given setting was found and fetched successfully.\n @retval OT_ERROR_NOT_FOUND The given setting was not found in the setting store.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented on this platform."]
10128 pub fn otPlatSettingsGet(
10129 aInstance: *mut otInstance,
10130 aKey: u16,
10131 aIndex: ::std::os::raw::c_int,
10132 aValue: *mut u8,
10133 aValueLength: *mut u16,
10134 ) -> otError;
10135}
10136extern "C" {
10137 #[doc = " Sets or replaces the value of a setting.\n\n Sets or replaces the value of a setting\n identified by @p aKey.\n\n Calling this function successfully may cause unrelated\n settings with multiple values to be reordered.\n\n OpenThread stack guarantees to use `otPlatSettingsSet()`\n method for a @p aKey that was either previously set using\n `otPlatSettingsSet()` (i.e., contains a single value) or\n is empty and/or fully deleted (contains no value).\n\n Platform layer can rely and use this fact for optimizing\n its implementation.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aKey The key associated with the setting to change.\n @param[in] aValue A pointer to where the new value of the setting should be read from. MUST NOT be NULL if\n @p aValueLength is non-zero.\n @param[in] aValueLength The length of the data pointed to by aValue. May be zero.\n\n @retval OT_ERROR_NONE The given setting was changed or staged.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented on this platform.\n @retval OT_ERROR_NO_BUFS No space remaining to store the given setting."]
10138 pub fn otPlatSettingsSet(
10139 aInstance: *mut otInstance,
10140 aKey: u16,
10141 aValue: *const u8,
10142 aValueLength: u16,
10143 ) -> otError;
10144}
10145extern "C" {
10146 #[doc = " Adds a value to a setting.\n\n Adds the value to a setting\n identified by @p aKey, without replacing any existing\n values.\n\n Note that the underlying implementation is not required\n to maintain the order of the items associated with a\n specific key. The added value may be added to the end,\n the beginning, or even somewhere in the middle. The order\n of any pre-existing values may also change.\n\n Calling this function successfully may cause unrelated\n settings with multiple values to be reordered.\n\n OpenThread stack guarantees to use `otPlatSettingsAdd()`\n method for a @p aKey that was either previously managed by\n `otPlatSettingsAdd()` (i.e., contains one or more items) or\n is empty and/or fully deleted (contains no value).\n\n Platform layer can rely and use this fact for optimizing\n its implementation.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aKey The key associated with the setting to change.\n @param[in] aValue A pointer to where the new value of the setting should be read from. MUST NOT be NULL\n if @p aValueLength is non-zero.\n @param[in] aValueLength The length of the data pointed to by @p aValue. May be zero.\n\n @retval OT_ERROR_NONE The given setting was added or staged to be added.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented on this platform.\n @retval OT_ERROR_NO_BUFS No space remaining to store the given setting."]
10147 pub fn otPlatSettingsAdd(
10148 aInstance: *mut otInstance,
10149 aKey: u16,
10150 aValue: *const u8,
10151 aValueLength: u16,
10152 ) -> otError;
10153}
10154extern "C" {
10155 #[doc = " Removes a setting from the setting store.\n\n Deletes a specific value from the\n setting identified by aKey from the settings store.\n\n Note that the underlying implementation is not required\n to maintain the order of the items associated with a\n specific key.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aKey The key associated with the requested setting.\n @param[in] aIndex The index of the value to be removed. If set to -1, all values for this @p aKey will be\n removed.\n\n @retval OT_ERROR_NONE The given key and index was found and removed successfully.\n @retval OT_ERROR_NOT_FOUND The given key or index was not found in the setting store.\n @retval OT_ERROR_NOT_IMPLEMENTED This function is not implemented on this platform."]
10156 pub fn otPlatSettingsDelete(
10157 aInstance: *mut otInstance,
10158 aKey: u16,
10159 aIndex: ::std::os::raw::c_int,
10160 ) -> otError;
10161}
10162extern "C" {
10163 #[doc = " Removes all settings from the setting store.\n\n Deletes all settings from the settings\n store, resetting it to its initial factory state.\n\n @param[in] aInstance The OpenThread instance structure."]
10164 pub fn otPlatSettingsWipe(aInstance: *mut otInstance);
10165}
10166#[doc = " Indicates that a SPI transaction has completed with the given length. The data written to the slave has been written\n to the pointer indicated by the `aInputBuf` argument to the previous call to `otPlatSpiSlavePrepareTransaction()`.\n\n Once this function is called, `otPlatSpiSlavePrepareTransaction()` is invalid and must be called again for the next\n transaction to be valid.\n\n Note that this function is always called at the end of a transaction, even if `otPlatSpiSlavePrepareTransaction()`\n has not yet been called. In such cases, `aOutputBufLen` and `aInputBufLen` will be zero.\n\n This callback can be called from ISR context. The return value from this function indicates if any further\n processing is required. If `TRUE` is returned the platform spi-slave driver implementation must invoke the\n transaction process callback (`aProcessCallback` set in `otPlatSpiSlaveEnable()`) which unlike this callback must be\n called from the same OS context that any other OpenThread API/callback is called.\n\n @param[in] aContext Context pointer passed into `otPlatSpiSlaveEnable()`.\n @param[in] aOutputBuf Value of `aOutputBuf` from last call to `otPlatSpiSlavePrepareTransaction()`.\n @param[in] aOutputBufLen Value of `aOutputBufLen` from last call to `otPlatSpiSlavePrepareTransaction()`.\n @param[in] aInputBuf Value of aInputBuf from last call to `otPlatSpiSlavePrepareTransaction()`.\n @param[in] aInputBufLen Value of aInputBufLen from last call to `otPlatSpiSlavePrepareTransaction()`\n @param[in] aTransactionLength Length of the completed transaction, in bytes.\n\n @returns TRUE if after this call returns the platform should invoke the process callback `aProcessCallback`,\n FALSE if there is nothing to process and no need to invoke the process callback."]
10167pub type otPlatSpiSlaveTransactionCompleteCallback = ::std::option::Option<
10168 unsafe extern "C" fn(
10169 aContext: *mut ::std::os::raw::c_void,
10170 aOutputBuf: *mut u8,
10171 aOutputBufLen: u16,
10172 aInputBuf: *mut u8,
10173 aInputBufLen: u16,
10174 aTransactionLength: u16,
10175 ) -> bool,
10176>;
10177#[doc = " Invoked after a transaction complete callback is called and returns `TRUE` to do any further processing required.\n Unlike `otPlatSpiSlaveTransactionCompleteCallback` which can be called from any OS context (e.g., ISR), this\n callback MUST be called from the same OS context as any other OpenThread API/callback.\n\n @param[in] aContext Context pointer passed into `otPlatSpiSlaveEnable()`."]
10178pub type otPlatSpiSlaveTransactionProcessCallback =
10179 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
10180extern "C" {
10181 #[doc = " Initialize the SPI slave interface.\n\n Note that SPI slave is not fully ready until a transaction is prepared using `otPlatSPISlavePrepareTransaction()`.\n\n If `otPlatSPISlavePrepareTransaction() is not called before the master begins a transaction, the resulting SPI\n transaction will send all `0xFF` bytes and discard all received bytes.\n\n @param[in] aCompleteCallback Pointer to transaction complete callback.\n @param[in] aProcessCallback Pointer to process callback.\n @param[in] aContext Context pointer to be passed to callbacks.\n\n @retval OT_ERROR_NONE Successfully enabled the SPI Slave interface.\n @retval OT_ERROR_ALREADY SPI Slave interface is already enabled.\n @retval OT_ERROR_FAILED Failed to enable the SPI Slave interface."]
10182 pub fn otPlatSpiSlaveEnable(
10183 aCompleteCallback: otPlatSpiSlaveTransactionCompleteCallback,
10184 aProcessCallback: otPlatSpiSlaveTransactionProcessCallback,
10185 aContext: *mut ::std::os::raw::c_void,
10186 ) -> otError;
10187}
10188extern "C" {
10189 #[doc = " Shutdown and disable the SPI slave interface."]
10190 pub fn otPlatSpiSlaveDisable();
10191}
10192extern "C" {
10193 #[doc = " Prepare data for the next SPI transaction. Data pointers MUST remain valid until the transaction complete callback\n is called by the SPI slave driver, or until after the next call to `otPlatSpiSlavePrepareTransaction()`.\n\n May be called more than once before the SPI master initiates the transaction. Each *successful* call\n to this function will cause the previous values from earlier calls to be discarded.\n\n Not calling this function after a completed transaction is the same as if this function was previously called with\n both buffer lengths set to zero and `aRequestTransactionFlag` set to `false`.\n\n Once `aOutputBufLen` bytes of `aOutputBuf` has been clocked out, the MISO pin shall be set high until the master\n finishes the SPI transaction. This is the functional equivalent of padding the end of `aOutputBuf` with `0xFF` bytes\n out to the length of the transaction.\n\n Once `aInputBufLen` bytes of aInputBuf have been clocked in from MOSI, all subsequent values from the MOSI pin are\n ignored until the SPI master finishes the transaction.\n\n Note that even if `aInputBufLen` or `aOutputBufLen` (or both) are exhausted before the SPI master finishes a\n transaction, the ongoing size of the transaction must still be kept track of to be passed to the transaction\n complete callback. For example, if `aInputBufLen` is equal to 10 and `aOutputBufLen` equal to 20 and the SPI master\n clocks out 30 bytes, the value 30 is passed to the transaction complete callback.\n\n If a `NULL` pointer is passed in as `aOutputBuf` or `aInputBuf` it means that that buffer pointer should not change\n from its previous/current value. In this case, the corresponding length argument should be ignored. For example,\n `otPlatSpiSlavePrepareTransaction(NULL, 0, aInputBuf, aInputLen, false)` changes the input buffer pointer and its\n length but keeps the output buffer pointer same as before.\n\n Any call to this function while a transaction is in progress will cause all of the arguments to be ignored and the\n return value to be `OT_ERROR_BUSY`.\n\n @param[in] aOutputBuf Data to be written to MISO pin\n @param[in] aOutputBufLen Size of the output buffer, in bytes\n @param[in] aInputBuf Data to be read from MOSI pin\n @param[in] aInputBufLen Size of the input buffer, in bytes\n @param[in] aRequestTransactionFlag Set to true if host interrupt should be set\n\n @retval OT_ERROR_NONE Transaction was successfully prepared.\n @retval OT_ERROR_BUSY A transaction is currently in progress.\n @retval OT_ERROR_INVALID_STATE otPlatSpiSlaveEnable() hasn't been called."]
10194 pub fn otPlatSpiSlavePrepareTransaction(
10195 aOutputBuf: *mut u8,
10196 aOutputBufLen: u16,
10197 aInputBuf: *mut u8,
10198 aInputBufLen: u16,
10199 aRequestTransactionFlag: bool,
10200 ) -> otError;
10201}
10202extern "C" {
10203 #[doc = " Get the current platform time in microseconds referenced to a continuous\n monotonic local clock (64 bits width).\n\n The clock SHALL NOT wrap during the device's uptime. Implementations SHALL\n therefore identify and compensate for internal counter overflows. The clock\n does not have a defined epoch and it SHALL NOT introduce any continuous or\n 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 platform clock and compensate\n for sleep times by any means (e.g. by combining a high precision/low power\n RTC 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 otPlatTimeGetXtalAccuracy.\n\n @returns The current time in microseconds."]
10204 pub fn otPlatTimeGet() -> u64;
10205}
10206extern "C" {
10207 #[doc = " Get the current estimated worst case accuracy (maximum ± deviation from the\n nominal frequency) of the local platform clock in units of PPM.\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 @returns The current platform clock accuracy, in PPM."]
10208 pub fn otPlatTimeGetXtalAccuracy() -> u16;
10209}
10210extern "C" {
10211 #[doc = " Initializes and enables TREL platform layer.\n\n Upon this call, the platform layer MUST perform the following:\n\n 1) TREL platform layer MUST open a UDP socket to listen for and receive TREL messages from peers. The socket is\n bound to an ephemeral port number chosen by the platform layer. The port number MUST be returned in @p aUdpPort.\n The socket is also bound to network interface(s) on which TREL is to be supported. The socket and the chosen port\n should stay valid while TREL is enabled.\n\n 2) Platform layer MUST initiate an ongoing DNS-SD browse on the service name \"_trel._udp\" within the local browsing\n domain to discover other devices supporting TREL. The ongoing browse will produce two different types of events:\n \"add\" events and \"remove\" events. When the browse is started, it should produce an \"add\" event for every TREL peer\n currently present on the network. Whenever a TREL peer goes offline, a \"remove\" event should be produced. \"remove\"\n events are not guaranteed, however. When a TREL service instance is discovered, a new ongoing DNS-SD query for an\n AAAA record should be started on the hostname indicated in the SRV record of the discovered instance. If multiple\n host IPv6 addressees are discovered for a peer, one with highest scope among all addresses MUST be reported (if\n there are multiple address at same scope, one must be selected randomly).\n\n TREL platform MUST signal back the discovered peer info using `otPlatTrelHandleDiscoveredPeerInfo()` callback. This\n callback MUST be invoked when a new peer is discovered, when there is a change in an existing entry (e.g., new\n TXT record or new port number or new IPv6 address), or when the peer is removed.\n\n @param[in] aInstance The OpenThread instance.\n @param[out] aUdpPort A pointer to return the selected port number by platform layer."]
10212 pub fn otPlatTrelEnable(aInstance: *mut otInstance, aUdpPort: *mut u16);
10213}
10214extern "C" {
10215 #[doc = " Disables TREL platform layer.\n\n After this call, the platform layer MUST stop DNS-SD browse on the service name \"_trel._udp\", stop advertising the\n TREL DNS-SD service (from `otPlatTrelRegisterService()`) and MUST close the UDP socket used to receive TREL messages.\n\n @pram[in] aInstance The OpenThread instance."]
10216 pub fn otPlatTrelDisable(aInstance: *mut otInstance);
10217}
10218#[doc = " Represents a TREL peer info discovered using DNS-SD browse on the service name \"_trel._udp\"."]
10219#[repr(C)]
10220#[derive(Copy, Clone)]
10221pub struct otPlatTrelPeerInfo {
10222 #[doc = " This boolean flag indicates whether the entry is being removed or added.\n\n - TRUE indicates that peer is removed.\n - FALSE indicates that it is a new entry or an update to an existing entry."]
10223 pub mRemoved: bool,
10224 #[doc = " The TXT record data (encoded as specified by DNS-SD) from the SRV record of the discovered TREL peer service\n instance."]
10225 pub mTxtData: *const u8,
10226 #[doc = "< Number of bytes in @p mTxtData buffer."]
10227 pub mTxtLength: u16,
10228 #[doc = " The TREL peer socket address (IPv6 address and port number).\n\n The port number is determined from the SRV record of the discovered TREL peer service instance. The IPv6 address\n is determined from the DNS-SD query for AAAA records on the hostname indicated in the SRV record of the\n discovered service instance. If multiple host IPv6 addressees are discovered, one with highest scope is used."]
10229 pub mSockAddr: otSockAddr,
10230}
10231impl Default for otPlatTrelPeerInfo {
10232 fn default() -> Self {
10233 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10234 unsafe {
10235 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10236 s.assume_init()
10237 }
10238 }
10239}
10240extern "C" {
10241 #[doc = " This is a callback function from platform layer to report a discovered TREL peer info.\n\n @note The @p aInfo structure and its content (e.g., the `mTxtData` buffer) does not need to persist after returning\n from this call. OpenThread code will make a copy of all the info it needs.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aInfo A pointer to the TREL peer info."]
10242 pub fn otPlatTrelHandleDiscoveredPeerInfo(
10243 aInstance: *mut otInstance,
10244 aInfo: *const otPlatTrelPeerInfo,
10245 );
10246}
10247extern "C" {
10248 #[doc = " Notifies platform that a TREL packet is received from a peer using a different socket address than the one reported\n earlier from `otPlatTrelHandleDiscoveredPeerInfo()`.\n\n Ideally the platform underlying DNS-SD should detect changes to advertised port and addresses by peers, however,\n there are situations where this is not detected reliably. This function signals to the platform layer than we\n received a packet from a peer with it using a different port or address. This can be used by the playroom layer to\n restart/confirm the DNS-SD service/address resolution for the peer service and/or take any other relevant actions.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aPeerSockAddr The address of the peer, reported from `otPlatTrelHandleDiscoveredPeerInfo()` call.\n @param[in] aRxSockAddr The address of received packet from the same peer (differs from @p aPeerSockAddr)."]
10249 pub fn otPlatTrelNotifyPeerSocketAddressDifference(
10250 aInstance: *mut otInstance,
10251 aPeerSockAddr: *const otSockAddr,
10252 aRxSockAddr: *const otSockAddr,
10253 );
10254}
10255extern "C" {
10256 #[doc = " Registers a new service to be advertised using DNS-SD [RFC6763].\n\n The service name is \"_trel._udp\". The platform should use its own hostname, which when combined with the service\n name and the local DNS-SD domain name will produce the full service instance name, for example\n \"example-host._trel._udp.local.\".\n\n The domain under which the service instance name appears will be 'local' for mDNS, and will be whatever domain is\n used for service registration in the case of a non-mDNS local DNS-SD service.\n\n A subsequent call to this function updates the previous service. It is used to update the TXT record data and/or the\n port number.\n\n The @p aTxtData buffer is not persisted after the return from this function. The platform layer MUST NOT keep the\n pointer and instead copy the content if needed.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aPort The port number to include in the SRV record of the advertised service.\n @param[in] aTxtData A pointer to the TXT record data (encoded) to be include in the advertised service.\n @param[in] aTxtLength The length of @p aTxtData (number of bytes)."]
10257 pub fn otPlatTrelRegisterService(
10258 aInstance: *mut otInstance,
10259 aPort: u16,
10260 aTxtData: *const u8,
10261 aTxtLength: u8,
10262 );
10263}
10264extern "C" {
10265 #[doc = " Requests a TREL UDP packet to be sent to a given destination.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aUdpPayload A pointer to UDP payload.\n @param[in] aUdpPayloadLen The payload length (number of bytes).\n @param[in] aDestSockAddr The destination socket address."]
10266 pub fn otPlatTrelSend(
10267 aInstance: *mut otInstance,
10268 aUdpPayload: *const u8,
10269 aUdpPayloadLen: u16,
10270 aDestSockAddr: *const otSockAddr,
10271 );
10272}
10273extern "C" {
10274 #[doc = " Is a callback from platform to notify of a received TREL UDP packet.\n\n @note The buffer content (up to its specified length) may get changed during processing by OpenThread core (e.g.,\n decrypted in place), so the platform implementation should expect that after returning from this function the\n @p aBuffer content may have been altered.\n\n @param[in] aInstance The OpenThread instance structure.\n @param[in] aBuffer A buffer containing the received UDP payload.\n @param[in] aLength UDP payload length (number of bytes).\n @param[in] aSockAddr The sender address."]
10275 pub fn otPlatTrelHandleReceived(
10276 aInstance: *mut otInstance,
10277 aBuffer: *mut u8,
10278 aLength: u16,
10279 aSenderAddr: *const otSockAddr,
10280 );
10281}
10282#[doc = " Represents a group of TREL related counters in the platform layer."]
10283#[repr(C)]
10284#[derive(Debug, Default, Copy, Clone)]
10285pub struct otPlatTrelCounters {
10286 #[doc = "< Number of packets successfully transmitted through TREL."]
10287 pub mTxPackets: u64,
10288 #[doc = "< Sum of size of packets successfully transmitted through TREL."]
10289 pub mTxBytes: u64,
10290 #[doc = "< Number of packet transmission failures through TREL."]
10291 pub mTxFailure: u64,
10292 #[doc = "< Number of packets received through TREL."]
10293 pub mRxPackets: u64,
10294 #[doc = "< Sum of size of packets received through TREL."]
10295 pub mRxBytes: u64,
10296}
10297extern "C" {
10298 #[doc = " Gets the pointer to the TREL counters in the platform layer.\n\n @param[in] aInstance The OpenThread instance structure."]
10299 pub fn otPlatTrelGetCounters(aInstance: *mut otInstance) -> *const otPlatTrelCounters;
10300}
10301extern "C" {
10302 #[doc = " Resets the TREL counters in the platform layer.\n\n @param[in] aInstance The OpenThread instance structure."]
10303 pub fn otPlatTrelResetCounters(aInstance: *mut otInstance);
10304}
10305#[doc = " This callback allows OpenThread to provide specific handlers for certain UDP messages.\n\n @retval true The message is handled by this receiver and should not be further processed.\n @retval false The message is not handled by this receiver."]
10306pub type otUdpHandler = ::std::option::Option<
10307 unsafe extern "C" fn(
10308 aContext: *mut ::std::os::raw::c_void,
10309 aMessage: *const otMessage,
10310 aMessageInfo: *const otMessageInfo,
10311 ) -> bool,
10312>;
10313#[doc = " Represents a UDP receiver."]
10314#[repr(C)]
10315#[derive(Debug, Copy, Clone)]
10316pub struct otUdpReceiver {
10317 #[doc = "< A pointer to the next UDP receiver (internal use only)."]
10318 pub mNext: *mut otUdpReceiver,
10319 #[doc = "< A function pointer to the receiver callback."]
10320 pub mHandler: otUdpHandler,
10321 #[doc = "< A pointer to application-specific context."]
10322 pub mContext: *mut ::std::os::raw::c_void,
10323}
10324impl Default for otUdpReceiver {
10325 fn default() -> Self {
10326 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10327 unsafe {
10328 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10329 s.assume_init()
10330 }
10331 }
10332}
10333extern "C" {
10334 #[doc = " Adds a UDP receiver.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aUdpReceiver A pointer to the UDP receiver.\n\n @retval OT_ERROR_NONE The receiver is successfully added.\n @retval OT_ERROR_ALREADY The UDP receiver was already added."]
10335 pub fn otUdpAddReceiver(
10336 aInstance: *mut otInstance,
10337 aUdpReceiver: *mut otUdpReceiver,
10338 ) -> otError;
10339}
10340extern "C" {
10341 #[doc = " Removes a UDP receiver.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aUdpReceiver A pointer to the UDP receiver.\n\n @retval OT_ERROR_NONE The receiver is successfully removed.\n @retval OT_ERROR_NOT_FOUND The UDP receiver was not added."]
10342 pub fn otUdpRemoveReceiver(
10343 aInstance: *mut otInstance,
10344 aUdpReceiver: *mut otUdpReceiver,
10345 ) -> otError;
10346}
10347extern "C" {
10348 #[doc = " Sends a UDP message without socket.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to a message without UDP header.\n @param[in] aMessageInfo A pointer to a message info associated with @p aMessage.\n\n @retval OT_ERROR_NONE Successfully enqueued the message into an output interface.\n @retval OT_ERROR_NO_BUFS Insufficient available buffer to add the IPv6 headers.\n @retval OT_ERROR_INVALID_ARGS Invalid arguments are given."]
10349 pub fn otUdpSendDatagram(
10350 aInstance: *mut otInstance,
10351 aMessage: *mut otMessage,
10352 aMessageInfo: *mut otMessageInfo,
10353 ) -> otError;
10354}
10355#[doc = " This callback allows OpenThread to inform the application of a received UDP message."]
10356pub type otUdpReceive = ::std::option::Option<
10357 unsafe extern "C" fn(
10358 aContext: *mut ::std::os::raw::c_void,
10359 aMessage: *mut otMessage,
10360 aMessageInfo: *const otMessageInfo,
10361 ),
10362>;
10363#[doc = "< Unspecified network interface."]
10364pub const OT_NETIF_UNSPECIFIED: otNetifIdentifier = 0;
10365#[doc = "< The host Thread interface - allow use of platform UDP."]
10366pub const OT_NETIF_THREAD_HOST: otNetifIdentifier = 1;
10367#[doc = "< The internal Thread interface (within OpenThread) - do not use platform UDP."]
10368pub const OT_NETIF_THREAD_INTERNAL: otNetifIdentifier = 2;
10369#[doc = "< The Backbone interface."]
10370pub const OT_NETIF_BACKBONE: otNetifIdentifier = 3;
10371#[doc = " Defines the OpenThread network interface identifiers."]
10372pub type otNetifIdentifier = ::std::os::raw::c_uint;
10373#[doc = " Represents a UDP socket."]
10374#[repr(C)]
10375#[derive(Copy, Clone)]
10376pub struct otUdpSocket {
10377 #[doc = "< The local IPv6 socket address."]
10378 pub mSockName: otSockAddr,
10379 #[doc = "< The peer IPv6 socket address."]
10380 pub mPeerName: otSockAddr,
10381 #[doc = "< A function pointer to the application callback."]
10382 pub mHandler: otUdpReceive,
10383 #[doc = "< A pointer to application-specific context."]
10384 pub mContext: *mut ::std::os::raw::c_void,
10385 #[doc = "< A handle to platform's UDP."]
10386 pub mHandle: *mut ::std::os::raw::c_void,
10387 #[doc = "< A pointer to the next UDP socket (internal use only)."]
10388 pub mNext: *mut otUdpSocket,
10389 #[doc = "< The network interface identifier."]
10390 pub mNetifId: otNetifIdentifier,
10391}
10392impl Default for otUdpSocket {
10393 fn default() -> Self {
10394 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10395 unsafe {
10396 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10397 s.assume_init()
10398 }
10399 }
10400}
10401extern "C" {
10402 #[doc = " Allocate a new message buffer for sending a UDP 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 use 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"]
10403 pub fn otUdpNewMessage(
10404 aInstance: *mut otInstance,
10405 aSettings: *const otMessageSettings,
10406 ) -> *mut otMessage;
10407}
10408extern "C" {
10409 #[doc = " Open a UDP/IPv6 socket.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSocket A pointer to a UDP socket structure.\n @param[in] aCallback A pointer to the application callback function.\n @param[in] aContext A pointer to application-specific context.\n\n @retval OT_ERROR_NONE Successfully opened the socket.\n @retval OT_ERROR_FAILED Failed to open the socket."]
10410 pub fn otUdpOpen(
10411 aInstance: *mut otInstance,
10412 aSocket: *mut otUdpSocket,
10413 aCallback: otUdpReceive,
10414 aContext: *mut ::std::os::raw::c_void,
10415 ) -> otError;
10416}
10417extern "C" {
10418 #[doc = " Check if a UDP socket is open.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSocket A pointer to a UDP socket structure.\n\n @returns Whether the UDP socket is open."]
10419 pub fn otUdpIsOpen(aInstance: *mut otInstance, aSocket: *const otUdpSocket) -> bool;
10420}
10421extern "C" {
10422 #[doc = " Close a UDP/IPv6 socket.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSocket A pointer to a UDP socket structure.\n\n @retval OT_ERROR_NONE Successfully closed the socket.\n @retval OT_ERROR_FAILED Failed to close UDP Socket."]
10423 pub fn otUdpClose(aInstance: *mut otInstance, aSocket: *mut otUdpSocket) -> otError;
10424}
10425extern "C" {
10426 #[doc = " Bind a UDP/IPv6 socket.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSocket A pointer to a UDP socket structure.\n @param[in] aSockName A pointer to an IPv6 socket address structure.\n @param[in] aNetif The network interface to bind.\n\n @retval OT_ERROR_NONE Bind operation was successful.\n @retval OT_ERROR_FAILED Failed to bind UDP socket."]
10427 pub fn otUdpBind(
10428 aInstance: *mut otInstance,
10429 aSocket: *mut otUdpSocket,
10430 aSockName: *const otSockAddr,
10431 aNetif: otNetifIdentifier,
10432 ) -> otError;
10433}
10434extern "C" {
10435 #[doc = " Connect a UDP/IPv6 socket.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSocket A pointer to a UDP socket structure.\n @param[in] aSockName A pointer to an IPv6 socket address structure.\n\n @retval OT_ERROR_NONE Connect operation was successful.\n @retval OT_ERROR_FAILED Failed to connect UDP socket."]
10436 pub fn otUdpConnect(
10437 aInstance: *mut otInstance,
10438 aSocket: *mut otUdpSocket,
10439 aSockName: *const otSockAddr,
10440 ) -> otError;
10441}
10442extern "C" {
10443 #[doc = " Send a UDP/IPv6 message.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSocket A pointer to a UDP socket structure.\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aMessageInfo A pointer to a message info structure.\n\n If the return value is OT_ERROR_NONE, OpenThread takes ownership of @p aMessage, and the caller should no longer\n reference @p aMessage. If the return value is not OT_ERROR_NONE, the caller retains ownership of @p aMessage,\n including freeing @p aMessage if the message buffer is no longer needed.\n\n @retval OT_ERROR_NONE The message is successfully scheduled for sending.\n @retval OT_ERROR_INVALID_ARGS Invalid arguments are given.\n @retval OT_ERROR_NO_BUFS Insufficient available buffer to add the UDP and IPv6 headers."]
10444 pub fn otUdpSend(
10445 aInstance: *mut otInstance,
10446 aSocket: *mut otUdpSocket,
10447 aMessage: *mut otMessage,
10448 aMessageInfo: *const otMessageInfo,
10449 ) -> otError;
10450}
10451extern "C" {
10452 #[doc = " Gets the head of linked list of UDP Sockets.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the head of UDP Socket linked list."]
10453 pub fn otUdpGetSockets(aInstance: *mut otInstance) -> *mut otUdpSocket;
10454}
10455#[doc = " Pointer delivers the UDP packet to host and host should send the packet through its own network stack.\n\n @param[in] aMessage A pointer to the UDP Message.\n @param[in] aPeerPort The destination UDP port.\n @param[in] aPeerAddr A pointer to the destination IPv6 address.\n @param[in] aSockPort The source UDP port.\n @param[in] aContext A pointer to application-specific context."]
10456pub type otUdpForwarder = ::std::option::Option<
10457 unsafe extern "C" fn(
10458 aMessage: *mut otMessage,
10459 aPeerPort: u16,
10460 aPeerAddr: *mut otIp6Address,
10461 aSockPort: u16,
10462 aContext: *mut ::std::os::raw::c_void,
10463 ),
10464>;
10465extern "C" {
10466 #[doc = " Set UDP forward callback to deliver UDP packets to host.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aForwarder A pointer to a function called to forward UDP packet to host.\n @param[in] aContext A pointer to application-specific context."]
10467 pub fn otUdpForwardSetForwarder(
10468 aInstance: *mut otInstance,
10469 aForwarder: otUdpForwarder,
10470 aContext: *mut ::std::os::raw::c_void,
10471 );
10472}
10473extern "C" {
10474 #[doc = " Handle a UDP packet received from host.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMessage A pointer to the UDP Message.\n @param[in] aPeerPort The source UDP port.\n @param[in] aPeerAddr A pointer to the source address.\n @param[in] aSockPort The destination UDP port.\n\n @warning No matter the call success or fail, the message is freed."]
10475 pub fn otUdpForwardReceive(
10476 aInstance: *mut otInstance,
10477 aMessage: *mut otMessage,
10478 aPeerPort: u16,
10479 aPeerAddr: *const otIp6Address,
10480 aSockPort: u16,
10481 );
10482}
10483extern "C" {
10484 #[doc = " Determines if the given UDP port is exclusively opened by OpenThread API.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] port UDP port number to verify.\n\n @retval true The port is being used exclusively by OpenThread.\n @retval false The port is not used by any of the OpenThread API or is shared (e.g. is Backbone socket)."]
10485 pub fn otUdpIsPortInUse(aInstance: *mut otInstance, port: u16) -> bool;
10486}
10487extern "C" {
10488 #[doc = " Initializes the UDP socket by platform.\n\n @param[in] aUdpSocket A pointer to the UDP socket.\n\n @retval OT_ERROR_NONE Successfully initialized UDP socket by platform.\n @retval OT_ERROR_FAILED Failed to initialize UDP Socket."]
10489 pub fn otPlatUdpSocket(aUdpSocket: *mut otUdpSocket) -> otError;
10490}
10491extern "C" {
10492 #[doc = " Closes the UDP socket by platform.\n\n @param[in] aUdpSocket A pointer to the UDP socket.\n\n @retval OT_ERROR_NONE Successfully closed UDP socket by platform.\n @retval OT_ERROR_FAILED Failed to close UDP Socket."]
10493 pub fn otPlatUdpClose(aUdpSocket: *mut otUdpSocket) -> otError;
10494}
10495extern "C" {
10496 #[doc = " Binds the UDP socket by platform.\n\n @param[in] aUdpSocket A pointer to the UDP socket.\n\n @retval OT_ERROR_NONE Successfully bound UDP socket by platform.\n @retval OT_ERROR_FAILED Failed to bind UDP socket."]
10497 pub fn otPlatUdpBind(aUdpSocket: *mut otUdpSocket) -> otError;
10498}
10499extern "C" {
10500 #[doc = " Binds the UDP socket to a platform network interface.\n\n Note: only available when `OPENTHREAD_CONFIG_PLATFORM_UDP_ENABLE` is used.\n\n @param[in] aUdpSocket A pointer to the UDP socket.\n @param[in] aNetifIdentifier The network interface identifier.\n\n @retval OT_ERROR_NONE Successfully bound UDP socket.\n @retval OT_ERROR_FAILED Failed to bind UDP."]
10501 pub fn otPlatUdpBindToNetif(
10502 aUdpSocket: *mut otUdpSocket,
10503 aNetifIdentifier: otNetifIdentifier,
10504 ) -> otError;
10505}
10506extern "C" {
10507 #[doc = " Connects UDP socket by platform.\n\n @param[in] aUdpSocket A pointer to the UDP socket.\n\n @retval OT_ERROR_NONE Successfully connected by platform.\n @retval OT_ERROR_FAILED Failed to connect UDP socket."]
10508 pub fn otPlatUdpConnect(aUdpSocket: *mut otUdpSocket) -> otError;
10509}
10510extern "C" {
10511 #[doc = " Sends UDP payload by platform.\n\n @param[in] aUdpSocket A pointer to the UDP socket.\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\n @retval OT_ERROR_NONE Successfully sent by platform, and @p aMessage is freed.\n @retval OT_ERROR_FAILED Failed to bind UDP socket."]
10512 pub fn otPlatUdpSend(
10513 aUdpSocket: *mut otUdpSocket,
10514 aMessage: *mut otMessage,
10515 aMessageInfo: *const otMessageInfo,
10516 ) -> otError;
10517}
10518extern "C" {
10519 #[doc = " Configures the UDP socket to join a UDP multicast group.\n\n Note: only available when `OPENTHREAD_CONFIG_PLATFORM_UDP_ENABLE` is used.\n\n @param[in] aUdpSocket A pointer to the UDP socket.\n @param[in] aNetifIdentifier The network interface identifier.\n @param[in] aAddress The UDP multicast group address.\n\n @retval OT_ERROR_NONE Successfully joined the multicast group.\n @retval OT_ERROR_FAILED Failed to join the multicast group."]
10520 pub fn otPlatUdpJoinMulticastGroup(
10521 aUdpSocket: *mut otUdpSocket,
10522 aNetifIdentifier: otNetifIdentifier,
10523 aAddress: *const otIp6Address,
10524 ) -> otError;
10525}
10526extern "C" {
10527 #[doc = " Configures the UDP socket to leave a UDP multicast group.\n\n Note: only available when `OPENTHREAD_CONFIG_PLATFORM_UDP_ENABLE` is used.\n\n @param[in] aUdpSocket A pointer to the UDP socket.\n @param[in] aNetifIdentifier The network interface identifier.\n @param[in] aAddress The UDP multicast group address.\n\n @retval OT_ERROR_NONE Successfully left the multicast group.\n @retval OT_ERROR_FAILED Failed to leave the multicast group."]
10528 pub fn otPlatUdpLeaveMulticastGroup(
10529 aUdpSocket: *mut otUdpSocket,
10530 aNetifIdentifier: otNetifIdentifier,
10531 aAddress: *const otIp6Address,
10532 ) -> otError;
10533}
10534extern "C" {
10535 #[doc = " Generates and returns a random `uint32_t` value.\n\n @returns A random `uint32_t` value."]
10536 pub fn otRandomNonCryptoGetUint32() -> u32;
10537}
10538extern "C" {
10539 #[doc = " Generates and returns a random byte.\n\n @returns A random `uint8_t` value."]
10540 pub fn otRandomNonCryptoGetUint8() -> u8;
10541}
10542extern "C" {
10543 #[doc = " Generates and returns a random `uint16_t` value.\n\n @returns A random `uint16_t` value."]
10544 pub fn otRandomNonCryptoGetUint16() -> u16;
10545}
10546extern "C" {
10547 #[doc = " Generates and returns a random `uint8_t` value within a given range `[aMin, aMax)`.\n\n @param[in] aMin A minimum value (this value can be included in returned random result).\n @param[in] aMax A maximum value (this value is excluded from returned random result).\n\n @returns A random `uint8_t` value in the given range (i.e., aMin <= random value < aMax)."]
10548 pub fn otRandomNonCryptoGetUint8InRange(aMin: u8, aMax: u8) -> u8;
10549}
10550extern "C" {
10551 #[doc = " Generates and returns a random `uint16_t` value within a given range `[aMin, aMax)`.\n\n @note The returned random value can include the @p aMin value but excludes the @p aMax.\n\n @param[in] aMin A minimum value (this value can be included in returned random result).\n @param[in] aMax A maximum value (this value is excluded from returned random result).\n\n @returns A random `uint16_t` value in the given range (i.e., aMin <= random value < aMax)."]
10552 pub fn otRandomNonCryptoGetUint16InRange(aMin: u16, aMax: u16) -> u16;
10553}
10554extern "C" {
10555 #[doc = " Generates and returns a random `uint32_t` value within a given range `[aMin, aMax)`.\n\n @note The returned random value can include the @p aMin value but excludes the @p aMax.\n\n @param[in] aMin A minimum value (this value can be included in returned random result).\n @param[in] aMax A maximum value (this value is excluded from returned random result).\n\n @returns A random `uint32_t` value in the given range (i.e., aMin <= random value < aMax)."]
10556 pub fn otRandomNonCryptoGetUint32InRange(aMin: u32, aMax: u32) -> u32;
10557}
10558extern "C" {
10559 #[doc = " Fills a given buffer with 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)."]
10560 pub fn otRandomNonCryptoFillBuffer(aBuffer: *mut u8, aSize: u16);
10561}
10562extern "C" {
10563 #[doc = " Adds a random jitter within a given range to a given value.\n\n @param[in] aValue A value to which the random jitter is added.\n @param[in] aJitter Maximum jitter. Random jitter is selected from the range `[-aJitter, aJitter]`.\n\n @returns The given value with an added random jitter."]
10564 pub fn otRandomNonCryptoAddJitter(aValue: u32, aJitter: u16) -> u32;
10565}
10566extern "C" {
10567 #[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."]
10568 pub fn otServerGetNetDataLocal(
10569 aInstance: *mut otInstance,
10570 aStable: bool,
10571 aData: *mut u8,
10572 aDataLength: *mut u8,
10573 ) -> otError;
10574}
10575extern "C" {
10576 #[doc = " Add a service 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 service 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 otServerRemoveService\n @sa otServerRegister"]
10577 pub fn otServerAddService(
10578 aInstance: *mut otInstance,
10579 aConfig: *const otServiceConfig,
10580 ) -> otError;
10581}
10582extern "C" {
10583 #[doc = " Remove a service configuration from the local network data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnterpriseNumber Enterprise Number of the service entry to be deleted.\n @param[in] aServiceData A pointer to an Service Data to look for during deletion.\n @param[in] aServiceDataLength The length of @p aServiceData in bytes.\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 otServerAddService\n @sa otServerRegister"]
10584 pub fn otServerRemoveService(
10585 aInstance: *mut otInstance,
10586 aEnterpriseNumber: u32,
10587 aServiceData: *const u8,
10588 aServiceDataLength: u8,
10589 ) -> otError;
10590}
10591extern "C" {
10592 #[doc = " Gets the next service 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 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 Thread Network Data."]
10593 pub fn otServerGetNextService(
10594 aInstance: *mut otInstance,
10595 aIterator: *mut otNetworkDataIterator,
10596 aConfig: *mut otServiceConfig,
10597 ) -> otError;
10598}
10599extern "C" {
10600 #[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 otServerAddService\n @sa otServerRemoveService"]
10601 pub fn otServerRegister(aInstance: *mut otInstance) -> otError;
10602}
10603#[doc = " Implements SNTP Query parameters."]
10604#[repr(C)]
10605#[derive(Debug, Copy, Clone)]
10606pub struct otSntpQuery {
10607 #[doc = "< A reference to the message info related with SNTP Server."]
10608 pub mMessageInfo: *const otMessageInfo,
10609}
10610impl Default for otSntpQuery {
10611 fn default() -> Self {
10612 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10613 unsafe {
10614 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10615 s.assume_init()
10616 }
10617 }
10618}
10619#[doc = " Pointer is called when a SNTP response is received.\n\n @param[in] aContext A pointer to application-specific context.\n @param[in] aTime Specifies the time at the server when the response left for the client, in UNIX time.\n @param[in] aResult A result of the SNTP transaction.\n\n @retval OT_ERROR_NONE A response was received successfully and time is provided\n in @p aTime.\n @retval OT_ERROR_ABORT A SNTP transaction was aborted by stack.\n @retval OT_ERROR_BUSY The Kiss-o'-death packet has been received.\n @retval OT_ERROR_RESPONSE_TIMEOUT No SNTP response has been received within timeout.\n @retval OT_ERROR_FAILED A response was received but contains incorrect data."]
10620pub type otSntpResponseHandler = ::std::option::Option<
10621 unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void, aTime: u64, aResult: otError),
10622>;
10623extern "C" {
10624 #[doc = " Sends a SNTP query.\n\n Is available only if feature `OPENTHREAD_CONFIG_SNTP_CLIENT_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aQuery A pointer to specify SNTP query parameters.\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."]
10625 pub fn otSntpClientQuery(
10626 aInstance: *mut otInstance,
10627 aQuery: *const otSntpQuery,
10628 aHandler: otSntpResponseHandler,
10629 aContext: *mut ::std::os::raw::c_void,
10630 ) -> otError;
10631}
10632extern "C" {
10633 #[doc = " Sets the unix era number.\n\n The default value of unix era is set to 0. The subsequent eras start after year 2106.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aUnixEra Unix era number."]
10634 pub fn otSntpClientSetUnixEra(aInstance: *mut otInstance, aUnixEra: u32);
10635}
10636#[doc = "< Item to be added/registered."]
10637pub const OT_SRP_CLIENT_ITEM_STATE_TO_ADD: otSrpClientItemState = 0;
10638#[doc = "< Item is being added/registered."]
10639pub const OT_SRP_CLIENT_ITEM_STATE_ADDING: otSrpClientItemState = 1;
10640#[doc = "< Item to be refreshed (re-register to renew lease)."]
10641pub const OT_SRP_CLIENT_ITEM_STATE_TO_REFRESH: otSrpClientItemState = 2;
10642#[doc = "< Item is being refreshed."]
10643pub const OT_SRP_CLIENT_ITEM_STATE_REFRESHING: otSrpClientItemState = 3;
10644#[doc = "< Item to be removed."]
10645pub const OT_SRP_CLIENT_ITEM_STATE_TO_REMOVE: otSrpClientItemState = 4;
10646#[doc = "< Item is being removed."]
10647pub const OT_SRP_CLIENT_ITEM_STATE_REMOVING: otSrpClientItemState = 5;
10648#[doc = "< Item is registered with server."]
10649pub const OT_SRP_CLIENT_ITEM_STATE_REGISTERED: otSrpClientItemState = 6;
10650#[doc = "< Item is removed."]
10651pub const OT_SRP_CLIENT_ITEM_STATE_REMOVED: otSrpClientItemState = 7;
10652#[doc = " Specifies an SRP client item (service or host info) state."]
10653pub type otSrpClientItemState = ::std::os::raw::c_uint;
10654#[doc = " Represents an SRP client host info."]
10655#[repr(C)]
10656#[derive(Debug, Copy, Clone)]
10657pub struct otSrpClientHostInfo {
10658 #[doc = "< Host name (label) string (NULL if not yet set)."]
10659 pub mName: *const ::std::os::raw::c_char,
10660 #[doc = "< Array of host IPv6 addresses (NULL if not set or auto address is enabled)."]
10661 pub mAddresses: *const otIp6Address,
10662 #[doc = "< Number of IPv6 addresses in `mAddresses` array."]
10663 pub mNumAddresses: u8,
10664 #[doc = "< Indicates whether auto address mode is enabled or not."]
10665 pub mAutoAddress: bool,
10666 #[doc = "< Host info state."]
10667 pub mState: otSrpClientItemState,
10668}
10669impl Default for otSrpClientHostInfo {
10670 fn default() -> Self {
10671 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10672 unsafe {
10673 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10674 s.assume_init()
10675 }
10676 }
10677}
10678#[doc = " Represents an SRP client service.\n\n The values in this structure, including the string buffers for the names and the TXT record entries, MUST persist\n and stay constant after an instance of this structure is passed to OpenThread from `otSrpClientAddService()` or\n `otSrpClientRemoveService()`.\n\n The `mState`, `mData`, `mNext` fields are used/managed by OT core only. Their value is ignored when an instance of\n `otSrpClientService` is passed in `otSrpClientAddService()` or `otSrpClientRemoveService()` or other functions. The\n caller does not need to set these fields.\n\n The `mLease` and `mKeyLease` fields specify the desired lease and key lease intervals for this service. Zero value\n indicates that the interval is unspecified and then the default lease or key lease intervals from\n `otSrpClientGetLeaseInterval()` and `otSrpClientGetKeyLeaseInterval()` are used for this service. If the key lease\n interval (whether set explicitly or determined from the default) is shorter than the lease interval for a service,\n SRP client will re-use the lease interval value for key lease interval as well. For example, if in service `mLease`\n is explicitly set to 2 days and `mKeyLease` is set to zero and default key lease is set to 1 day, then when\n registering this service, the requested key lease for this service is also set to 2 days."]
10679#[repr(C)]
10680#[derive(Debug, Copy, Clone)]
10681pub struct otSrpClientService {
10682 #[doc = "< The service labels (e.g., \"_mt._udp\", not the full domain name)."]
10683 pub mName: *const ::std::os::raw::c_char,
10684 #[doc = "< The service instance name label (not the full name)."]
10685 pub mInstanceName: *const ::std::os::raw::c_char,
10686 #[doc = "< Array of sub-type labels (must end with `NULL` or can be `NULL`)."]
10687 pub mSubTypeLabels: *const *const ::std::os::raw::c_char,
10688 #[doc = "< Array of TXT entries (`mNumTxtEntries` gives num of entries)."]
10689 pub mTxtEntries: *const otDnsTxtEntry,
10690 #[doc = "< The service port number."]
10691 pub mPort: u16,
10692 #[doc = "< The service priority."]
10693 pub mPriority: u16,
10694 #[doc = "< The service weight."]
10695 pub mWeight: u16,
10696 #[doc = "< Number of entries in the `mTxtEntries` array."]
10697 pub mNumTxtEntries: u8,
10698 #[doc = "< Service state (managed by OT core)."]
10699 pub mState: otSrpClientItemState,
10700 #[doc = "< Internal data (used by OT core)."]
10701 pub mData: u32,
10702 #[doc = "< Pointer to next entry in a linked-list (managed by OT core)."]
10703 pub mNext: *mut otSrpClientService,
10704 #[doc = "< Desired lease interval in sec - zero to use default."]
10705 pub mLease: u32,
10706 #[doc = "< Desired key lease interval in sec - zero to use default."]
10707 pub mKeyLease: u32,
10708}
10709impl Default for otSrpClientService {
10710 fn default() -> Self {
10711 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10712 unsafe {
10713 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10714 s.assume_init()
10715 }
10716 }
10717}
10718#[doc = " Pointer type defines the callback used by SRP client to notify user of changes/events/errors.\n\n This callback is invoked on a successful registration of an update (i.e., add/remove of host-info and/or some\n service(s)) with the SRP server, or if there is a failure or error (e.g., server rejects a update request or client\n times out waiting for response, etc).\n\n In case of a successful reregistration of an update, `aError` parameter would be `OT_ERROR_NONE` and the host info\n and the full list of services is provided as input parameters to the callback. Note that host info and services each\n track its own state in the corresponding `mState` member variable of the related data structure (the state\n indicating whether the host-info/service is registered or removed or still being added/removed, etc).\n\n The list of removed services is passed as its own linked-list `aRemovedServices` in the callback. Note that when the\n callback is invoked, the SRP client (OpenThread implementation) is done with the removed service instances listed in\n `aRemovedServices` and no longer tracks/stores them (i.e., if from the callback we call `otSrpClientGetServices()`\n the removed services will not be present in the returned list). Providing a separate list of removed services in\n the callback helps indicate to user which items are now removed and allow user to re-claim/reuse the instances.\n\n If the server rejects an SRP update request, the DNS response code (RFC 2136) is mapped to the following errors:\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\n The following errors are also possible:\n\n - OT_ERROR_RESPONSE_TIMEOUT : Timed out waiting for response from server (client would continue to retry).\n - OT_ERROR_INVALID_ARGS : The provided service structure is invalid (e.g., bad service name or `otDnsTxtEntry`).\n - OT_ERROR_NO_BUFS : Insufficient buffer to prepare or send the update message.\n\n Note that in case of any failure, the client continues the operation, i.e. it prepares and (re)transmits the SRP\n update message to the server, after some wait interval. The retry wait interval starts from the minimum value and\n is increased by the growth factor every failure up to the max value (please see configuration parameter\n `OPENTHREAD_CONFIG_SRP_CLIENT_MIN_RETRY_WAIT_INTERVAL` and the related ones for more details).\n\n @param[in] aError The error (see above).\n @param[in] aHostInfo A pointer to host info.\n @param[in] aServices The head of linked-list containing all services (excluding the ones removed). NULL if\n the list is empty.\n @param[in] aRemovedServices The head of linked-list containing all removed services. NULL if the list is empty.\n @param[in] aContext A pointer to an arbitrary context (provided when callback was registered)."]
10719pub type otSrpClientCallback = ::std::option::Option<
10720 unsafe extern "C" fn(
10721 aError: otError,
10722 aHostInfo: *const otSrpClientHostInfo,
10723 aServices: *const otSrpClientService,
10724 aRemovedServices: *const otSrpClientService,
10725 aContext: *mut ::std::os::raw::c_void,
10726 ),
10727>;
10728#[doc = " Pointer type defines the callback used by SRP client to notify user when it is auto-started or stopped.\n\n This is only used when auto-start feature `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled.\n\n This callback is invoked when auto-start mode is enabled and the SRP client is either automatically started or\n stopped.\n\n @param[in] aServerSockAddr A non-NULL pointer indicates SRP server was started and pointer will give the\n selected server socket address. A NULL pointer indicates SRP server was stopped.\n @param[in] aContext A pointer to an arbitrary context (provided when callback was registered)."]
10729pub type otSrpClientAutoStartCallback = ::std::option::Option<
10730 unsafe extern "C" fn(aServerSockAddr: *const otSockAddr, aContext: *mut ::std::os::raw::c_void),
10731>;
10732extern "C" {
10733 #[doc = " Starts the SRP client operation.\n\n SRP client will prepare and send \"SRP Update\" message to the SRP server once all the following conditions are met:\n\n - The SRP client is started - `otSrpClientStart()` is called.\n - Host name is set - `otSrpClientSetHostName()` is called.\n - At least one host IPv6 address is set - `otSrpClientSetHostAddresses()` is called.\n - At least one service is added - `otSrpClientAddService()` is called.\n\n It does not matter in which order these functions are called. When all conditions are met, the SRP client will\n wait for a short delay before preparing an \"SRP Update\" message and sending it to server. This delay allows for user\n to add multiple services and/or IPv6 addresses before the first SRP Update message is sent (ensuring a single SRP\n Update is sent containing all the info). The config `OPENTHREAD_CONFIG_SRP_CLIENT_UPDATE_TX_DELAY` specifies the\n delay interval.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aServerSockAddr The socket address (IPv6 address and port number) of the SRP server.\n\n @retval OT_ERROR_NONE SRP client operation started successfully or it is already running with same server\n socket address and callback.\n @retval OT_ERROR_BUSY SRP client is busy running with a different socket address.\n @retval OT_ERROR_FAILED Failed to open/connect the client's UDP socket."]
10734 pub fn otSrpClientStart(
10735 aInstance: *mut otInstance,
10736 aServerSockAddr: *const otSockAddr,
10737 ) -> otError;
10738}
10739extern "C" {
10740 #[doc = " Stops the SRP client operation.\n\n Stops any further interactions with the SRP server. Note that it does not remove or clear host info\n and/or list of services. It marks all services to be added/removed again once the client is (re)started.\n\n @param[in] aInstance A pointer to the OpenThread instance."]
10741 pub fn otSrpClientStop(aInstance: *mut otInstance);
10742}
10743extern "C" {
10744 #[doc = " Indicates whether the SRP client is running or not.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns TRUE if the SRP client is running, FALSE otherwise."]
10745 pub fn otSrpClientIsRunning(aInstance: *mut otInstance) -> bool;
10746}
10747extern "C" {
10748 #[doc = " Gets the socket address (IPv6 address and port number) of the SRP server which is being used by SRP\n client.\n\n If the client is not running, the address is unspecified (all zero) with zero port number.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns A pointer to the SRP server's socket address (is always non-NULL)."]
10749 pub fn otSrpClientGetServerAddress(aInstance: *mut otInstance) -> *const otSockAddr;
10750}
10751extern "C" {
10752 #[doc = " Sets the callback to notify caller of events/changes from SRP client.\n\n The SRP client allows a single callback to be registered. So consecutive calls to this function will overwrite any\n previously set callback functions.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aCallback The callback to notify of events and changes. Can be NULL if not needed.\n @param[in] aContext An arbitrary context used with @p aCallback."]
10753 pub fn otSrpClientSetCallback(
10754 aInstance: *mut otInstance,
10755 aCallback: otSrpClientCallback,
10756 aContext: *mut ::std::os::raw::c_void,
10757 );
10758}
10759extern "C" {
10760 #[doc = " Enables the auto-start mode.\n\n This is only available when auto-start feature `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled.\n\n Config option `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_DEFAULT_MODE` specifies the default auto-start mode (whether\n it is enabled or disabled at the start of OT stack).\n\n When auto-start is enabled, the SRP client will monitor the Thread Network Data to discover SRP servers and select\n the preferred server and automatically start and stop the client when an SRP server is detected.\n\n There are three categories of Network Data entries indicating presence of SRP sever. They are preferred in the\n following order:\n\n 1) Preferred unicast entries where server address is included in the service data. If there are multiple options,\n the one with numerically lowest IPv6 address is preferred.\n\n 2) Anycast entries each having a seq number. A larger sequence number in the sense specified by Serial Number\n Arithmetic logic in RFC-1982 is considered more recent and therefore preferred. The largest seq number using\n serial number arithmetic is preferred if it is well-defined (i.e., the seq number is larger than all other\n seq numbers). If it is not well-defined, then the numerically largest seq number is preferred.\n\n 3) Unicast entries where the server address info is included in server data. If there are multiple options, the\n one with numerically lowest IPv6 address is preferred.\n\n When there is a change in the Network Data entries, client will check that the currently selected server is still\n present in the Network Data and is still the preferred one. Otherwise the client will switch to the new preferred\n server or stop if there is none.\n\n When the SRP client is explicitly started through a successful call to `otSrpClientStart()`, the given SRP server\n address in `otSrpClientStart()` will continue to be used regardless of the state of auto-start mode and whether the\n same SRP server address is discovered or not in the Thread Network Data. In this case, only an explicit\n `otSrpClientStop()` call will stop the client.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aCallback A callback to notify when client is auto-started/stopped. Can be NULL if not needed.\n @param[in] aContext A context to be passed when invoking @p aCallback."]
10761 pub fn otSrpClientEnableAutoStartMode(
10762 aInstance: *mut otInstance,
10763 aCallback: otSrpClientAutoStartCallback,
10764 aContext: *mut ::std::os::raw::c_void,
10765 );
10766}
10767extern "C" {
10768 #[doc = " Disables the auto-start mode.\n\n This is only available when auto-start feature `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled.\n\n Disabling the auto-start mode will not stop the client if it is already running but the client stops monitoring\n the Thread Network Data to verify that the selected SRP server is still present in it.\n\n Note that a call to `otSrpClientStop()` will also disable the auto-start mode.\n\n @param[in] aInstance A pointer to the OpenThread instance."]
10769 pub fn otSrpClientDisableAutoStartMode(aInstance: *mut otInstance);
10770}
10771extern "C" {
10772 #[doc = " Indicates the current state of auto-start mode (enabled or disabled).\n\n This is only available when auto-start feature `OPENTHREAD_CONFIG_SRP_CLIENT_AUTO_START_API_ENABLE` is enabled.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns TRUE if the auto-start mode is enabled, FALSE otherwise."]
10773 pub fn otSrpClientIsAutoStartModeEnabled(aInstance: *mut otInstance) -> bool;
10774}
10775extern "C" {
10776 #[doc = " Gets the TTL value in every record included in SRP update requests.\n\n Note that this is the TTL requested by the SRP client. The server may choose to accept a different TTL.\n\n By default, the TTL will equal the lease interval. Passing 0 or a value larger than the lease interval via\n `otSrpClientSetTtl()` will also cause the TTL to equal the lease interval.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns The TTL (in seconds)."]
10777 pub fn otSrpClientGetTtl(aInstance: *mut otInstance) -> u32;
10778}
10779extern "C" {
10780 #[doc = " Sets the TTL value in every record included in SRP update requests.\n\n Changing the TTL does not impact the TTL of already registered services/host-info.\n It only affects future SRP update messages (i.e., adding new services and/or refreshes of the existing services).\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aTtl The TTL (in seconds). If value is zero or greater than lease interval, the TTL is set to the\n lease interval."]
10781 pub fn otSrpClientSetTtl(aInstance: *mut otInstance, aTtl: u32);
10782}
10783extern "C" {
10784 #[doc = " Gets the default lease interval used in SRP update requests.\n\n The default interval is used only for `otSrpClientService` instances with `mLease` set to zero.\n\n Note that this is the lease duration requested by the SRP client. The server may choose to accept a different lease\n interval.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns The lease interval (in seconds)."]
10785 pub fn otSrpClientGetLeaseInterval(aInstance: *mut otInstance) -> u32;
10786}
10787extern "C" {
10788 #[doc = " Sets the default lease interval used in SRP update requests.\n\n The default interval is used only for `otSrpClientService` instances with `mLease` set to zero.\n\n Changing the lease interval does not impact the accepted lease interval of already registered services/host-info.\n It only affects any future SRP update messages (i.e., adding new services and/or refreshes of the existing services).\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aInterval The lease interval (in seconds). If zero, the default value specified by\n `OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_LEASE` would be used."]
10789 pub fn otSrpClientSetLeaseInterval(aInstance: *mut otInstance, aInterval: u32);
10790}
10791extern "C" {
10792 #[doc = " Gets the default key lease interval used in SRP update requests.\n\n The default interval is used only for `otSrpClientService` instances with `mKeyLease` set to zero.\n\n Note that this is the lease duration requested by the SRP client. The server may choose to accept a different lease\n interval.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns The key lease interval (in seconds)."]
10793 pub fn otSrpClientGetKeyLeaseInterval(aInstance: *mut otInstance) -> u32;
10794}
10795extern "C" {
10796 #[doc = " Sets the default key lease interval used in SRP update requests.\n\n The default interval is used only for `otSrpClientService` instances with `mKeyLease` set to zero.\n\n Changing the lease interval does not impact the accepted lease interval of already registered services/host-info.\n It only affects any future SRP update messages (i.e., adding new services and/or refreshes of existing services).\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aInterval The key lease interval (in seconds). If zero, the default value specified by\n `OPENTHREAD_CONFIG_SRP_CLIENT_DEFAULT_KEY_LEASE` would be used."]
10797 pub fn otSrpClientSetKeyLeaseInterval(aInstance: *mut otInstance, aInterval: u32);
10798}
10799extern "C" {
10800 #[doc = " Gets the host info.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns A pointer to host info structure."]
10801 pub fn otSrpClientGetHostInfo(aInstance: *mut otInstance) -> *const otSrpClientHostInfo;
10802}
10803extern "C" {
10804 #[doc = " Sets the host name label.\n\n After a successful call to this function, `otSrpClientCallback` will be called to report the status of host info\n registration with SRP server.\n\n The name string buffer pointed to by @p aName MUST persist and stay unchanged after returning from this function.\n OpenThread will keep the pointer to the string.\n\n The host name can be set before client is started or after start but before host info is registered with server\n (host info should be in either `STATE_TO_ADD` or `STATE_REMOVED`).\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aName A pointer to host name label string (MUST NOT be NULL). Pointer to the string buffer MUST\n persist and remain valid and constant after return from this function.\n\n @retval OT_ERROR_NONE The host name label was set successfully.\n @retval OT_ERROR_INVALID_ARGS The @p aName is NULL.\n @retval OT_ERROR_INVALID_STATE The host name is already set and registered with the server."]
10805 pub fn otSrpClientSetHostName(
10806 aInstance: *mut otInstance,
10807 aName: *const ::std::os::raw::c_char,
10808 ) -> otError;
10809}
10810extern "C" {
10811 #[doc = " Enables auto host address mode.\n\n When enabled host IPv6 addresses are automatically set by SRP client using all the preferred unicast addresses on\n Thread netif excluding all link-local and mesh-local addresses. If there is no preferred address, then Mesh Local\n EID address is added. The SRP client will automatically re-register when/if addresses on Thread netif are updated\n (new addresses are added or existing addresses are removed or marked as non-preferred).\n\n The auto host address mode can be enabled before start or during operation of SRP client except when the host info\n is being removed (client is busy handling a remove request from an call to `otSrpClientRemoveHostAndServices()` and\n host info still being in either `STATE_TO_REMOVE` or `STATE_REMOVING` states).\n\n After auto host address mode is enabled, it can be disabled by a call to `otSrpClientSetHostAddresses()` which\n then explicitly sets the host addresses.\n\n @retval OT_ERROR_NONE Successfully enabled auto host address mode.\n @retval OT_ERROR_INVALID_STATE Host is being removed and therefore cannot enable auto host address mode."]
10812 pub fn otSrpClientEnableAutoHostAddress(aInstance: *mut otInstance) -> otError;
10813}
10814extern "C" {
10815 #[doc = " Sets/updates the list of host IPv6 address.\n\n Host IPv6 addresses can be set/changed before start or during operation of SRP client (e.g. to add/remove or change\n a previously registered host address), except when the host info is being removed (client is busy handling a remove\n request from an earlier call to `otSrpClientRemoveHostAndServices()` and host info still being in either\n `STATE_TO_REMOVE` or `STATE_REMOVING` states).\n\n The host IPv6 address array pointed to by @p aIp6Addresses MUST persist and remain unchanged after returning from\n this function (with `OT_ERROR_NONE`). OpenThread will save the pointer to the array.\n\n After a successful call to this function, `otSrpClientCallback` will be called to report the status of the address\n registration with SRP server.\n\n Calling this function disables auto host address mode if it was previously enabled from a successful call to\n `otSrpClientEnableAutoHostAddress()`.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aIp6Addresses A pointer to the an array containing the host IPv6 addresses.\n @param[in] aNumAddresses The number of addresses in the @p aIp6Addresses array.\n\n @retval OT_ERROR_NONE The host IPv6 address list change started successfully. The `otSrpClientCallback`\n will be called to report the status of registering addresses with server.\n @retval OT_ERROR_INVALID_ARGS The address list is invalid (e.g., must contain at least one address).\n @retval OT_ERROR_INVALID_STATE Host is being removed and therefore cannot change host address."]
10816 pub fn otSrpClientSetHostAddresses(
10817 aInstance: *mut otInstance,
10818 aIp6Addresses: *const otIp6Address,
10819 aNumAddresses: u8,
10820 ) -> otError;
10821}
10822extern "C" {
10823 #[doc = " Adds a service to be registered with server.\n\n After a successful call to this function, `otSrpClientCallback` will be called to report the status of the service\n addition/registration with SRP server.\n\n The `otSrpClientService` instance being pointed to by @p aService MUST persist and remain unchanged after returning\n from this function (with `OT_ERROR_NONE`). OpenThread will save the pointer to the service instance.\n\n The `otSrpClientService` instance is not longer tracked by OpenThread and can be reclaimed only when\n\n - It is removed explicitly by a call to `otSrpClientRemoveService()` or removed along with other services by a\n call to `otSrpClientRemoveHostAndServices() and only after the `otSrpClientCallback` is called indicating the\n service was removed. Or,\n - A call to `otSrpClientClearHostAndServices()` which removes the host and all related services immediately.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aService A pointer to a `otSrpClientService` instance to add.\n\n @retval OT_ERROR_NONE The addition of service started successfully. The `otSrpClientCallback` will be\n called to report the status.\n @retval OT_ERROR_ALREADY A service with the same service and instance names is already in the list.\n @retval OT_ERROR_INVALID_ARGS The service structure is invalid (e.g., bad service name or `otDnsTxtEntry`)."]
10824 pub fn otSrpClientAddService(
10825 aInstance: *mut otInstance,
10826 aService: *mut otSrpClientService,
10827 ) -> otError;
10828}
10829extern "C" {
10830 #[doc = " Requests a service to be unregistered with server.\n\n After a successful call to this function, `otSrpClientCallback` will be called to report the status of remove\n request with SRP server.\n\n The `otSrpClientService` instance being pointed to by @p aService MUST persist and remain unchanged after returning\n from this function (with `OT_ERROR_NONE`). OpenThread will keep the service instance during the remove process.\n Only after the `otSrpClientCallback` is called indicating the service instance is removed from SRP client\n service list and can be be freed/reused.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aService A pointer to a `otSrpClientService` instance to remove.\n\n @retval OT_ERROR_NONE The removal of service started successfully. The `otSrpClientCallback` will be called to\n report the status.\n @retval OT_ERROR_NOT_FOUND The service could not be found in the list."]
10831 pub fn otSrpClientRemoveService(
10832 aInstance: *mut otInstance,
10833 aService: *mut otSrpClientService,
10834 ) -> otError;
10835}
10836extern "C" {
10837 #[doc = " Clears a service, immediately removing it from the client service list.\n\n Unlike `otSrpClientRemoveService()` which sends an update message to the server to remove the service, this function\n clears the service from the client's service list without any interaction with the server. On a successful call to\n this function, the `otSrpClientCallback` will NOT be called and the @p aService entry can be reclaimed and re-used\n by the caller immediately.\n\n Can be used along with a subsequent call to `otSrpClientAddService()` (potentially reusing the same @p\n aService entry with the same service and instance names) to update some of the parameters in an existing service.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aService A pointer to a `otSrpClientService` instance to delete.\n\n @retval OT_ERROR_NONE The @p aService is deleted successfully. It can be reclaimed and re-used immediately.\n @retval OT_ERROR_NOT_FOUND The service could not be found in the list."]
10838 pub fn otSrpClientClearService(
10839 aInstance: *mut otInstance,
10840 aService: *mut otSrpClientService,
10841 ) -> otError;
10842}
10843extern "C" {
10844 #[doc = " Gets the list of services being managed by client.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns A pointer to the head of linked-list of all services or NULL if the list is empty."]
10845 pub fn otSrpClientGetServices(aInstance: *mut otInstance) -> *const otSrpClientService;
10846}
10847extern "C" {
10848 #[doc = " Starts the remove process of the host info and all services.\n\n After returning from this function, `otSrpClientCallback` will be called to report the status of remove request with\n SRP server.\n\n If the host info is to be permanently removed from server, @p aRemoveKeyLease should be set to `true` which removes\n the key lease associated with host on server. Otherwise, the key lease record is kept as before, which ensures\n that the server holds the host name in reserve for when the client is once again able to provide and register its\n service(s).\n\n The @p aSendUnregToServer determines the behavior when the host info is not yet registered with the server. If\n @p aSendUnregToServer is set to `false` (which is the default/expected value) then the SRP client will immediately\n remove the host info and services without sending an update message to server (no need to update the server if\n nothing is yet registered with it). If @p aSendUnregToServer is set to `true` then the SRP client will send an\n update message to the server. Note that if the host info is registered then the value of @p aSendUnregToServer does\n not matter and the SRP client will always send an update message to server requesting removal of all info.\n\n One situation where @p aSendUnregToServer can be useful is on a device reset/reboot, caller may want to remove any\n previously registered services with the server. In this case, caller can `otSrpClientSetHostName()` and then request\n `otSrpClientRemoveHostAndServices()` with `aSendUnregToServer` as `true`.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aRemoveKeyLease A boolean indicating whether or not the host key lease should also be removed.\n @param[in] aSendUnregToServer A boolean indicating whether to send update to server when host info is not registered.\n\n @retval OT_ERROR_NONE The removal of host info and services started successfully. The `otSrpClientCallback`\n will be called to report the status.\n @retval OT_ERROR_ALREADY The host info is already removed."]
10849 pub fn otSrpClientRemoveHostAndServices(
10850 aInstance: *mut otInstance,
10851 aRemoveKeyLease: bool,
10852 aSendUnregToServer: bool,
10853 ) -> otError;
10854}
10855extern "C" {
10856 #[doc = " Clears all host info and all the services.\n\n Unlike `otSrpClientRemoveHostAndServices()` which sends an update message to the server to remove all the info, this\n function clears all the info immediately without any interaction with the server.\n\n @param[in] aInstance A pointer to the OpenThread instance."]
10857 pub fn otSrpClientClearHostAndServices(aInstance: *mut otInstance);
10858}
10859extern "C" {
10860 #[doc = " Gets the domain name being used by SRP client.\n\n Requires `OPENTHREAD_CONFIG_SRP_CLIENT_DOMAIN_NAME_API_ENABLE` to be enabled.\n\n If domain name is not set, \"default.service.arpa\" will be used.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns The domain name string."]
10861 pub fn otSrpClientGetDomainName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
10862}
10863extern "C" {
10864 #[doc = " Sets the domain name to be used by SRP client.\n\n Requires `OPENTHREAD_CONFIG_SRP_CLIENT_DOMAIN_NAME_API_ENABLE` to be enabled.\n\n If not set \"default.service.arpa\" will be used.\n\n The name string buffer pointed to by @p aName MUST persist and stay unchanged after returning from this function.\n OpenThread will keep the pointer to the string.\n\n The domain name can be set before client is started or after start but before host info is registered with server\n (host info should be in either `STATE_TO_ADD` or `STATE_TO_REMOVE`).\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aName A pointer to the domain name string. If NULL sets it to default \"default.service.arpa\".\n\n @retval OT_ERROR_NONE The domain name label was set successfully.\n @retval OT_ERROR_INVALID_STATE The host info is already registered with server."]
10865 pub fn otSrpClientSetDomainName(
10866 aInstance: *mut otInstance,
10867 aName: *const ::std::os::raw::c_char,
10868 ) -> otError;
10869}
10870extern "C" {
10871 #[doc = " Converts a `otSrpClientItemState` to a string.\n\n @param[in] aItemState An item state.\n\n @returns A string representation of @p aItemState."]
10872 pub fn otSrpClientItemStateToString(
10873 aItemState: otSrpClientItemState,
10874 ) -> *const ::std::os::raw::c_char;
10875}
10876extern "C" {
10877 #[doc = " Enables/disables \"service key record inclusion\" mode.\n\n When enabled, SRP client will include KEY record in Service Description Instructions in the SRP update messages\n that it sends.\n\n Is available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` configuration is enabled.\n\n @note KEY record is optional in Service Description Instruction (it is required and always included in the Host\n Description Instruction). The default behavior of SRP client is to not include it. This function is intended to\n override the default behavior for testing only.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aEnabled TRUE to enable, FALSE to disable the \"service key record inclusion\" mode."]
10878 pub fn otSrpClientSetServiceKeyRecordEnabled(aInstance: *mut otInstance, aEnabled: bool);
10879}
10880extern "C" {
10881 #[doc = " Indicates whether the \"service key record inclusion\" mode is enabled or disabled.\n\n Is available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` configuration is enabled.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns TRUE if \"service key record inclusion\" mode is enabled, FALSE otherwise."]
10882 pub fn otSrpClientIsServiceKeyRecordEnabled(aInstance: *mut otInstance) -> bool;
10883}
10884#[doc = " Represents a SRP client service pool entry."]
10885#[repr(C)]
10886#[derive(Debug, Copy, Clone)]
10887pub struct otSrpClientBuffersServiceEntry {
10888 #[doc = "< The SRP client service structure."]
10889 pub mService: otSrpClientService,
10890 #[doc = "< The SRP client TXT entry."]
10891 pub mTxtEntry: otDnsTxtEntry,
10892}
10893impl Default for otSrpClientBuffersServiceEntry {
10894 fn default() -> Self {
10895 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10896 unsafe {
10897 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10898 s.assume_init()
10899 }
10900 }
10901}
10902extern "C" {
10903 #[doc = " Gets the string buffer to use for SRP client host name.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[out] aSize Pointer to a variable to return the size (number of bytes) of the string buffer (MUST NOT be\n NULL).\n\n @returns A pointer to char buffer to use for SRP client host name."]
10904 pub fn otSrpClientBuffersGetHostNameString(
10905 aInstance: *mut otInstance,
10906 aSize: *mut u16,
10907 ) -> *mut ::std::os::raw::c_char;
10908}
10909extern "C" {
10910 #[doc = " Gets the array of IPv6 address entries to use as SRP client host address list.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[out] aArrayLength Pointer to a variable to return the array length i.e., number of IPv6 address entries in\n the array (MUST NOT be NULL).\n\n @returns A pointer to an array of `otIp6Address` entries (number of entries is returned in @p aArrayLength)."]
10911 pub fn otSrpClientBuffersGetHostAddressesArray(
10912 aInstance: *mut otInstance,
10913 aArrayLength: *mut u8,
10914 ) -> *mut otIp6Address;
10915}
10916extern "C" {
10917 #[doc = " Allocates a new service entry from the pool.\n\n The returned service entry instance will be initialized as follows:\n\n - `mService.mName` will point to an allocated string buffer which can be retrieved using the function\n `otSrpClientBuffersGetServiceEntryServiceNameString()`.\n - `mService.mInstanceName` will point to an allocated string buffer which can be retrieved using the function\n `otSrpClientBuffersGetServiceEntryInstanceNameString()`.\n - `mService.mSubTypeLabels` points to an array that is returned from `otSrpClientBuffersGetSubTypeLabelsArray()`.\n - `mService.mTxtEntries` will point to `mTxtEntry`.\n - `mService.mNumTxtEntries` will be set to one.\n - Other `mService` fields (port, priority, weight) are set to zero.\n - `mTxtEntry.mKey` is set to NULL (value is treated as already encoded).\n - `mTxtEntry.mValue` will point to an allocated buffer which can be retrieved using the function\n `otSrpClientBuffersGetServiceEntryTxtBuffer()`.\n - `mTxtEntry.mValueLength` is set to zero.\n - All related data/string buffers and arrays are cleared to all zero.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @returns A pointer to the newly allocated service entry or NULL if not more entry available in the pool."]
10918 pub fn otSrpClientBuffersAllocateService(
10919 aInstance: *mut otInstance,
10920 ) -> *mut otSrpClientBuffersServiceEntry;
10921}
10922extern "C" {
10923 #[doc = " Frees a previously allocated service entry.\n\n The @p aService MUST be previously allocated using `otSrpClientBuffersAllocateService()` and not yet freed. Otherwise\n the behavior of this function is undefined.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aService A pointer to the service entry to free (MUST NOT be NULL)."]
10924 pub fn otSrpClientBuffersFreeService(
10925 aInstance: *mut otInstance,
10926 aService: *mut otSrpClientBuffersServiceEntry,
10927 );
10928}
10929extern "C" {
10930 #[doc = " Frees all previously allocated service entries.\n\n @param[in] aInstance A pointer to the OpenThread instance."]
10931 pub fn otSrpClientBuffersFreeAllServices(aInstance: *mut otInstance);
10932}
10933extern "C" {
10934 #[doc = " Gets the string buffer for service name from a service entry.\n\n @param[in] aEntry A pointer to a previously allocated service entry (MUST NOT be NULL).\n @param[out] aSize A pointer to a variable to return the size (number of bytes) of the string buffer (MUST NOT be\n NULL).\n\n @returns A pointer to the string buffer."]
10935 pub fn otSrpClientBuffersGetServiceEntryServiceNameString(
10936 aEntry: *mut otSrpClientBuffersServiceEntry,
10937 aSize: *mut u16,
10938 ) -> *mut ::std::os::raw::c_char;
10939}
10940extern "C" {
10941 #[doc = " Gets the string buffer for service instance name from a service entry.\n\n @param[in] aEntry A pointer to a previously allocated service entry (MUST NOT be NULL).\n @param[out] aSize A pointer to a variable to return the size (number of bytes) of the string buffer (MUST NOT be\n NULL).\n\n @returns A pointer to the string buffer."]
10942 pub fn otSrpClientBuffersGetServiceEntryInstanceNameString(
10943 aEntry: *mut otSrpClientBuffersServiceEntry,
10944 aSize: *mut u16,
10945 ) -> *mut ::std::os::raw::c_char;
10946}
10947extern "C" {
10948 #[doc = " Gets the buffer for TXT record from a service entry.\n\n @param[in] aEntry A pointer to a previously allocated service entry (MUST NOT be NULL).\n @param[out] aSize A pointer to a variable to return the size (number of bytes) of the buffer (MUST NOT be NULL).\n\n @returns A pointer to the buffer."]
10949 pub fn otSrpClientBuffersGetServiceEntryTxtBuffer(
10950 aEntry: *mut otSrpClientBuffersServiceEntry,
10951 aSize: *mut u16,
10952 ) -> *mut u8;
10953}
10954extern "C" {
10955 #[doc = " Gets the array for service subtype labels from the service entry.\n\n @param[in] aEntry A pointer to a previously allocated service entry (MUST NOT be NULL).\n @param[out] aArrayLength A pointer to a variable to return the array length (MUST NOT be NULL).\n\n @returns A pointer to the array."]
10956 pub fn otSrpClientBuffersGetSubTypeLabelsArray(
10957 aEntry: *mut otSrpClientBuffersServiceEntry,
10958 aArrayLength: *mut u16,
10959 ) -> *mut *const ::std::os::raw::c_char;
10960}
10961#[repr(C)]
10962#[derive(Debug, Copy, Clone)]
10963pub struct otSrpServerHost {
10964 _unused: [u8; 0],
10965}
10966#[repr(C)]
10967#[derive(Debug, Copy, Clone)]
10968pub struct otSrpServerService {
10969 _unused: [u8; 0],
10970}
10971#[doc = " The ID of a SRP service update transaction on the SRP Server."]
10972pub type otSrpServerServiceUpdateId = u32;
10973#[doc = "< The SRP server is disabled."]
10974pub const OT_SRP_SERVER_STATE_DISABLED: otSrpServerState = 0;
10975#[doc = "< The SRP server is enabled and running."]
10976pub const OT_SRP_SERVER_STATE_RUNNING: otSrpServerState = 1;
10977#[doc = "< The SRP server is enabled but stopped."]
10978pub const OT_SRP_SERVER_STATE_STOPPED: otSrpServerState = 2;
10979#[doc = " Represents the state of the SRP server."]
10980pub type otSrpServerState = ::std::os::raw::c_uint;
10981#[doc = "< Unicast address mode. Use Network Data publisher."]
10982pub const OT_SRP_SERVER_ADDRESS_MODE_UNICAST: otSrpServerAddressMode = 0;
10983#[doc = "< Anycast address mode. Use Network Data publisher"]
10984pub const OT_SRP_SERVER_ADDRESS_MODE_ANYCAST: otSrpServerAddressMode = 1;
10985#[doc = "< Unicast address mode. Immediately force add to Network Data."]
10986pub const OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD: otSrpServerAddressMode = 2;
10987#[doc = " Represents the address mode used by the SRP server.\n\n Address mode specifies how the address and port number are determined by the SRP server and how this info is\n published in the Thread Network Data.\n\n @warning Using the `OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD` option will make the implementation\n non-compliant with the Thread specification. This option is intended for testing and specific use-cases.\n When selected, the SRP server, upon being enabled, will bypass the Network Data publisher and always add the\n \"SRP/DNS unicast\" entry directly to the Network Data, regardless of how many other similar entries are present."]
10988pub type otSrpServerAddressMode = ::std::os::raw::c_uint;
10989#[doc = " Includes SRP server TTL configurations."]
10990#[repr(C)]
10991#[derive(Debug, Default, Copy, Clone)]
10992pub struct otSrpServerTtlConfig {
10993 #[doc = "< The minimum TTL in seconds."]
10994 pub mMinTtl: u32,
10995 #[doc = "< The maximum TTL in seconds."]
10996 pub mMaxTtl: u32,
10997}
10998#[doc = " Includes SRP server LEASE and KEY-LEASE configurations."]
10999#[repr(C)]
11000#[derive(Debug, Default, Copy, Clone)]
11001pub struct otSrpServerLeaseConfig {
11002 #[doc = "< The minimum LEASE interval in seconds."]
11003 pub mMinLease: u32,
11004 #[doc = "< The maximum LEASE interval in seconds."]
11005 pub mMaxLease: u32,
11006 #[doc = "< The minimum KEY-LEASE interval in seconds."]
11007 pub mMinKeyLease: u32,
11008 #[doc = "< The maximum KEY-LEASE interval in seconds."]
11009 pub mMaxKeyLease: u32,
11010}
11011#[doc = " Includes SRP server lease information of a host/service."]
11012#[repr(C)]
11013#[derive(Debug, Default, Copy, Clone)]
11014pub struct otSrpServerLeaseInfo {
11015 #[doc = "< The lease time of a host/service in milliseconds."]
11016 pub mLease: u32,
11017 #[doc = "< The key lease time of a host/service in milliseconds."]
11018 pub mKeyLease: u32,
11019 #[doc = "< The remaining lease time of the host/service in milliseconds."]
11020 pub mRemainingLease: u32,
11021 #[doc = "< The remaining key lease time of a host/service in milliseconds."]
11022 pub mRemainingKeyLease: u32,
11023}
11024#[doc = " Includes the statistics of SRP server responses."]
11025#[repr(C)]
11026#[derive(Debug, Default, Copy, Clone)]
11027pub struct otSrpServerResponseCounters {
11028 #[doc = "< The number of successful responses."]
11029 pub mSuccess: u32,
11030 #[doc = "< The number of server failure responses."]
11031 pub mServerFailure: u32,
11032 #[doc = "< The number of format error responses."]
11033 pub mFormatError: u32,
11034 #[doc = "< The number of 'name exists' responses."]
11035 pub mNameExists: u32,
11036 #[doc = "< The number of refused responses."]
11037 pub mRefused: u32,
11038 #[doc = "< The number of other responses."]
11039 pub mOther: u32,
11040}
11041extern "C" {
11042 #[doc = " Returns the domain authorized to the SRP server.\n\n If the domain if not set by SetDomain, \"default.service.arpa.\" will be returned.\n A trailing dot is always appended even if the domain is set without it.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the dot-joined domain string."]
11043 pub fn otSrpServerGetDomain(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
11044}
11045extern "C" {
11046 #[doc = " Sets the domain on the SRP server.\n\n A trailing dot will be appended to @p aDomain if it is not already there.\n Should only be called before the SRP server is enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDomain The domain to be set. MUST NOT be NULL.\n\n @retval OT_ERROR_NONE Successfully set the domain to @p aDomain.\n @retval OT_ERROR_INVALID_STATE The SRP server is already enabled and the Domain cannot be changed.\n @retval OT_ERROR_INVALID_ARGS The argument @p aDomain is not a valid DNS domain name.\n @retval OT_ERROR_NO_BUFS There is no memory to store content of @p aDomain."]
11047 pub fn otSrpServerSetDomain(
11048 aInstance: *mut otInstance,
11049 aDomain: *const ::std::os::raw::c_char,
11050 ) -> otError;
11051}
11052extern "C" {
11053 #[doc = " Returns the state of the SRP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The current state of the SRP server."]
11054 pub fn otSrpServerGetState(aInstance: *mut otInstance) -> otSrpServerState;
11055}
11056extern "C" {
11057 #[doc = " Returns the port the SRP server is listening to.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The port of the SRP server. It returns 0 if the server is not running."]
11058 pub fn otSrpServerGetPort(aInstance: *mut otInstance) -> u16;
11059}
11060extern "C" {
11061 #[doc = " Returns the address mode being used by the SRP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The SRP server's address mode."]
11062 pub fn otSrpServerGetAddressMode(aInstance: *mut otInstance) -> otSrpServerAddressMode;
11063}
11064extern "C" {
11065 #[doc = " Sets the address mode to be used by the SRP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMode The address mode to use.\n\n @retval OT_ERROR_NONE Successfully set the address mode.\n @retval OT_ERROR_INVALID_STATE The SRP server is enabled and the address mode cannot be changed."]
11066 pub fn otSrpServerSetAddressMode(
11067 aInstance: *mut otInstance,
11068 aMode: otSrpServerAddressMode,
11069 ) -> otError;
11070}
11071extern "C" {
11072 #[doc = " Returns the sequence number used with anycast address mode.\n\n The sequence number is included in \"DNS/SRP Service Anycast Address\" entry published in the Network Data.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The anycast sequence number."]
11073 pub fn otSrpServerGetAnycastModeSequenceNumber(aInstance: *mut otInstance) -> u8;
11074}
11075extern "C" {
11076 #[doc = " Sets the sequence number used with anycast address mode.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aSequenceNumber The sequence number to use.\n\n @retval OT_ERROR_NONE Successfully set the address mode.\n @retval OT_ERROR_INVALID_STATE The SRP server is enabled and the sequence number cannot be changed."]
11077 pub fn otSrpServerSetAnycastModeSequenceNumber(
11078 aInstance: *mut otInstance,
11079 aSequenceNumber: u8,
11080 ) -> otError;
11081}
11082extern "C" {
11083 #[doc = " Enables/disables the SRP server.\n\n On a Border Router, it is recommended to use `otSrpServerSetAutoEnableMode()` instead.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled A boolean to enable/disable the SRP server."]
11084 pub fn otSrpServerSetEnabled(aInstance: *mut otInstance, aEnabled: bool);
11085}
11086extern "C" {
11087 #[doc = " Enables/disables the auto-enable mode on SRP server.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE` feature.\n\n When this mode is enabled, the Border Routing Manager controls if/when to enable or disable the SRP server.\n SRP sever is auto-enabled if/when Border Routing is started and it is done with the initial prefix and route\n configurations (when the OMR and on-link prefixes are determined, advertised in emitted Router Advertisement message\n on infrastructure side and published in the Thread Network Data). The SRP server is auto-disabled if/when BR is\n stopped (e.g., if the infrastructure network interface is brought down or if BR gets detached).\n\n This mode can be disabled by a `otSrpServerSetAutoEnableMode()` call with @p aEnabled set to `false` or if the SRP\n server is explicitly enabled or disabled by a call to `otSrpServerSetEnabled()` function. Disabling auto-enable mode\n using `otSrpServerSetAutoEnableMode(false)` will not change the current state of SRP sever (e.g., if it is enabled\n it stays enabled).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled A boolean to enable/disable the auto-enable mode."]
11088 pub fn otSrpServerSetAutoEnableMode(aInstance: *mut otInstance, aEnabled: bool);
11089}
11090extern "C" {
11091 #[doc = " Indicates whether the auto-enable mode is enabled or disabled.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE` feature.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE The auto-enable mode is enabled.\n @retval FALSE The auto-enable mode is disabled."]
11092 pub fn otSrpServerIsAutoEnableMode(aInstance: *mut otInstance) -> bool;
11093}
11094extern "C" {
11095 #[doc = " Enables the \"Fast Start Mode\" on the SRP server.\n\n Requires the `OPENTHREAD_CONFIG_SRP_SERVER_FAST_START_MODE_ENABLE` feature to be enabled.\n\n The Fast Start Mode is designed for scenarios where a device, often a mobile device, needs to act as a provisional\n SRP server (e.g., functioning as a temporary Border Router). The SRP server function is enabled only if no other\n Border Routers (BRs) are already providing the SRP service within the Thread network. A common use case is a mobile\n device joining a Thread network where it may be the first, or only, BR. Importantly, Fast Start Mode allows the\n device to quickly start its SRP server functionality upon joining the network, allowing other Thread devices to\n quickly connect and register their services without the typical delays associated with standard Border Router\n initialization (and SRP server startup).\n\n When Fast Start Mode is enabled, the SRP server manages when to start or stop based on the presence of other BRs,\n following this process:\n - Upon initial attachment to the Thread network, the device immediately inspects the received Network Data for any\n existing \"SRP/DNS\" entries. These entries indicate the presence of other active BRs providing SRP server service:\n - If no \"SRP/DNS\" entries from other BRs are found, the device immediately enables its own SRP server. This\n activation uses `OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD`, which bypasses the usual delay associated with\n the standard Network Data publisher, directly adding its own \"SRP/DNS unicast\" entry to the Network Data.\n - If \"SRP/DNS\" entries from other BRs are detected, the device will not enable its SRP server, deferring to the\n existing ones.\n - After starting its SRP server in Fast Start Mode, the device continuously monitors the Network Data. If, at any\n point, new \"SRP/DNS\" entries appear (indicating that another BR has become active), the device automatically\n disables its own SRP server functionality, relinquishing the role to the newly available BR.\n\n The Fast Start Mode can be enabled when the device is in the detached or disabled state, the SRP server is currently\n disabled, and \"auto-enable mode\" is not in use (i.e., `otSrpServerIsAutoEnableMode()` returns `false`).\n\n After successfully enabling Fast Start Mode, it can be disabled either by a call to `otSrpServerSetEnabled()`,\n explicitly enabling or disabling the SRP server, or by a call to `otSrpServerSetAutoEnableMode()`, enabling or\n disabling the auto-enable mode. If the Fast Start Mode (while active) enables the SRP server, upon disabling\n Fast Start Mode (regardless of how it is done), the SRP server will also be stopped, and the use of the\n `OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD` address mode will be stopped, and the address mode will be\n automatically reverted back to its previous setting before Fast Start Mode was enabled.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @retval OT_ERROR_NONE Fast Start Mode was successfully enabled.\n @retval OT_ERROR_INVALID_STATE Cannot enable Fast Start Mode (e.g., already attached or server already enabled)."]
11096 pub fn otSrpServerEnableFastStartMode(aInstance: *mut otInstance) -> otError;
11097}
11098extern "C" {
11099 #[doc = " Indicates whether the Fast Start Mode is enabled or disabled.\n\n Requires `OPENTHREAD_CONFIG_SRP_SERVER_FAST_START_MODE_ENABLE` feature to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE The fast-start mode is enabled.\n @retval FALSE The fast-start mode is disabled."]
11100 pub fn otSrpServerIsFastStartModeEnabled(aInstance: *mut otInstance) -> bool;
11101}
11102extern "C" {
11103 #[doc = " Returns SRP server TTL configuration.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aTtlConfig A pointer to an `otSrpServerTtlConfig` instance."]
11104 pub fn otSrpServerGetTtlConfig(
11105 aInstance: *mut otInstance,
11106 aTtlConfig: *mut otSrpServerTtlConfig,
11107 );
11108}
11109extern "C" {
11110 #[doc = " Sets SRP server TTL configuration.\n\n The granted TTL will always be no greater than the max lease interval configured via `otSrpServerSetLeaseConfig()`,\n regardless of the minimum and maximum TTL configuration.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aTtlConfig A pointer to an `otSrpServerTtlConfig` instance.\n\n @retval OT_ERROR_NONE Successfully set the TTL configuration.\n @retval OT_ERROR_INVALID_ARGS The TTL configuration is not valid."]
11111 pub fn otSrpServerSetTtlConfig(
11112 aInstance: *mut otInstance,
11113 aTtlConfig: *const otSrpServerTtlConfig,
11114 ) -> otError;
11115}
11116extern "C" {
11117 #[doc = " Returns SRP server LEASE and KEY-LEASE configurations.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aLeaseConfig A pointer to an `otSrpServerLeaseConfig` instance."]
11118 pub fn otSrpServerGetLeaseConfig(
11119 aInstance: *mut otInstance,
11120 aLeaseConfig: *mut otSrpServerLeaseConfig,
11121 );
11122}
11123extern "C" {
11124 #[doc = " Sets SRP server LEASE and KEY-LEASE configurations.\n\n When a non-zero LEASE time is requested from a client, the granted value will be\n limited in range [aMinLease, aMaxLease]; and a non-zero KEY-LEASE will be granted\n in range [aMinKeyLease, aMaxKeyLease]. For zero LEASE or KEY-LEASE time, zero will\n be granted.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aLeaseConfig A pointer to an `otSrpServerLeaseConfig` instance.\n\n @retval OT_ERROR_NONE Successfully set the LEASE and KEY-LEASE ranges.\n @retval OT_ERROR_INVALID_ARGS The LEASE or KEY-LEASE range is not valid."]
11125 pub fn otSrpServerSetLeaseConfig(
11126 aInstance: *mut otInstance,
11127 aLeaseConfig: *const otSrpServerLeaseConfig,
11128 ) -> otError;
11129}
11130#[doc = " Handles SRP service updates.\n\n Is called by the SRP server to notify that a SRP host and possibly SRP services\n are being updated. It is important that the SRP updates are not committed until the handler\n returns the result by calling otSrpServerHandleServiceUpdateResult or times out after @p aTimeout.\n\n A SRP service observer should always call otSrpServerHandleServiceUpdateResult with error code\n OT_ERROR_NONE immediately after receiving the update events.\n\n A more generic handler may perform validations on the SRP host/services and rejects the SRP updates\n if any validation fails. For example, an Advertising Proxy should advertise (or remove) the host and\n services on a multicast-capable link and returns specific error code if any failure occurs.\n\n @param[in] aId The service update transaction ID. This ID must be passed back with\n `otSrpServerHandleServiceUpdateResult`.\n @param[in] aHost A pointer to the otSrpServerHost object which contains the SRP updates. The\n handler should publish/un-publish the host and each service points to this\n host with below rules:\n 1. If the host is not deleted (indicated by `otSrpServerHostIsDeleted`),\n then it should be published or updated with mDNS. Otherwise, the host\n should be un-published (remove AAAA RRs).\n 2. For each service points to this host, it must be un-published if the host\n is to be un-published. Otherwise, the handler should publish or update the\n service when it is not deleted (indicated by `otSrpServerServiceIsDeleted`)\n and un-publish it when deleted.\n @param[in] aTimeout The maximum time in milliseconds for the handler to process the service event.\n @param[in] aContext A pointer to application-specific context.\n\n @sa otSrpServerSetServiceUpdateHandler\n @sa otSrpServerHandleServiceUpdateResult"]
11131pub type otSrpServerServiceUpdateHandler = ::std::option::Option<
11132 unsafe extern "C" fn(
11133 aId: otSrpServerServiceUpdateId,
11134 aHost: *const otSrpServerHost,
11135 aTimeout: u32,
11136 aContext: *mut ::std::os::raw::c_void,
11137 ),
11138>;
11139extern "C" {
11140 #[doc = " Sets the SRP service updates handler on SRP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aServiceHandler A pointer to a service handler. Use NULL to remove the handler.\n @param[in] aContext A pointer to arbitrary context information.\n May be NULL if not used."]
11141 pub fn otSrpServerSetServiceUpdateHandler(
11142 aInstance: *mut otInstance,
11143 aServiceHandler: otSrpServerServiceUpdateHandler,
11144 aContext: *mut ::std::os::raw::c_void,
11145 );
11146}
11147extern "C" {
11148 #[doc = " Reports the result of processing a SRP update to the SRP server.\n\n The Service Update Handler should call this function to return the result of its\n processing of a SRP update.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aId The service update transaction ID. This should be the same ID\n provided via `otSrpServerServiceUpdateHandler`.\n @param[in] aError An error to be returned to the SRP server. Use OT_ERROR_DUPLICATED\n to represent DNS name conflicts."]
11149 pub fn otSrpServerHandleServiceUpdateResult(
11150 aInstance: *mut otInstance,
11151 aId: otSrpServerServiceUpdateId,
11152 aError: otError,
11153 );
11154}
11155extern "C" {
11156 #[doc = " Returns the next registered host on the SRP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aHost A pointer to current host; use NULL to get the first host.\n\n @returns A pointer to the registered host. NULL, if no more hosts can be found."]
11157 pub fn otSrpServerGetNextHost(
11158 aInstance: *mut otInstance,
11159 aHost: *const otSrpServerHost,
11160 ) -> *const otSrpServerHost;
11161}
11162extern "C" {
11163 #[doc = " Returns the response counters of the SRP server.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the response counters of the SRP server."]
11164 pub fn otSrpServerGetResponseCounters(
11165 aInstance: *mut otInstance,
11166 ) -> *const otSrpServerResponseCounters;
11167}
11168extern "C" {
11169 #[doc = " Tells if the SRP service host has been deleted.\n\n A SRP service host can be deleted but retains its name for future uses.\n In this case, the host instance is not removed from the SRP server/registry.\n\n @param[in] aHost A pointer to the SRP service host.\n\n @returns TRUE if the host has been deleted, FALSE if not."]
11170 pub fn otSrpServerHostIsDeleted(aHost: *const otSrpServerHost) -> bool;
11171}
11172extern "C" {
11173 #[doc = " Returns the full name of the host.\n\n @param[in] aHost A pointer to the SRP service host.\n\n @returns A pointer to the null-terminated host name string."]
11174 pub fn otSrpServerHostGetFullName(
11175 aHost: *const otSrpServerHost,
11176 ) -> *const ::std::os::raw::c_char;
11177}
11178extern "C" {
11179 #[doc = " Indicates whether the host matches a given host name.\n\n DNS name matches are performed using a case-insensitive string comparison (i.e., \"Abc\" and \"aBc\" are considered to\n be the same).\n\n @param[in] aHost A pointer to the SRP service host.\n @param[in] aFullName A full host name.\n\n @retval TRUE If host matches the host name.\n @retval FALSE If host does not match the host name."]
11180 pub fn otSrpServerHostMatchesFullName(
11181 aHost: *const otSrpServerHost,
11182 aFullName: *const ::std::os::raw::c_char,
11183 ) -> bool;
11184}
11185extern "C" {
11186 #[doc = " Returns the addresses of given host.\n\n @param[in] aHost A pointer to the SRP service host.\n @param[out] aAddressesNum A pointer to where we should output the number of the addresses to.\n\n @returns A pointer to the array of IPv6 Address."]
11187 pub fn otSrpServerHostGetAddresses(
11188 aHost: *const otSrpServerHost,
11189 aAddressesNum: *mut u8,
11190 ) -> *const otIp6Address;
11191}
11192extern "C" {
11193 #[doc = " Returns the LEASE and KEY-LEASE information of a given host.\n\n @param[in] aHost A pointer to the SRP server host.\n @param[out] aLeaseInfo A pointer to where to output the LEASE and KEY-LEASE information."]
11194 pub fn otSrpServerHostGetLeaseInfo(
11195 aHost: *const otSrpServerHost,
11196 aLeaseInfo: *mut otSrpServerLeaseInfo,
11197 );
11198}
11199extern "C" {
11200 #[doc = " Returns the next service of given host.\n\n @param[in] aHost A pointer to the SRP service host.\n @param[in] aService A pointer to current SRP service instance; use NULL to get the first service.\n\n @returns A pointer to the next service or NULL if there is no more services."]
11201 pub fn otSrpServerHostGetNextService(
11202 aHost: *const otSrpServerHost,
11203 aService: *const otSrpServerService,
11204 ) -> *const otSrpServerService;
11205}
11206extern "C" {
11207 #[doc = " Indicates whether or not the SRP service has been deleted.\n\n A SRP service can be deleted but retains its name for future uses.\n In this case, the service instance is not removed from the SRP server/registry.\n It is guaranteed that all services are deleted if the host is deleted.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns TRUE if the service has been deleted, FALSE if not."]
11208 pub fn otSrpServerServiceIsDeleted(aService: *const otSrpServerService) -> bool;
11209}
11210extern "C" {
11211 #[doc = " Returns the full service instance name of the service.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns A pointer to the null-terminated service instance name string."]
11212 pub fn otSrpServerServiceGetInstanceName(
11213 aService: *const otSrpServerService,
11214 ) -> *const ::std::os::raw::c_char;
11215}
11216extern "C" {
11217 #[doc = " Indicates whether this service matches a given service instance name.\n\n DNS name matches are performed using a case-insensitive string comparison (i.e., \"Abc\" and \"aBc\" are considered to\n be the same).\n\n @param[in] aService A pointer to the SRP service.\n @param[in] aInstanceName The service instance name.\n\n @retval TRUE If service matches the service instance name.\n @retval FALSE If service does not match the service instance name."]
11218 pub fn otSrpServerServiceMatchesInstanceName(
11219 aService: *const otSrpServerService,
11220 aInstanceName: *const ::std::os::raw::c_char,
11221 ) -> bool;
11222}
11223extern "C" {
11224 #[doc = " Returns the service instance label (first label in instance name) of the service.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns A pointer to the null-terminated service instance label string.."]
11225 pub fn otSrpServerServiceGetInstanceLabel(
11226 aService: *const otSrpServerService,
11227 ) -> *const ::std::os::raw::c_char;
11228}
11229extern "C" {
11230 #[doc = " Returns the full service name of the service.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns A pointer to the null-terminated service name string."]
11231 pub fn otSrpServerServiceGetServiceName(
11232 aService: *const otSrpServerService,
11233 ) -> *const ::std::os::raw::c_char;
11234}
11235extern "C" {
11236 #[doc = " Indicates whether this service matches a given service name.\n\n DNS name matches are performed using a case-insensitive string comparison (i.e., \"Abc\" and \"aBc\" are considered to\n be the same).\n\n @param[in] aService A pointer to the SRP service.\n @param[in] aServiceName The service name.\n\n @retval TRUE If service matches the service name.\n @retval FALSE If service does not match the service name."]
11237 pub fn otSrpServerServiceMatchesServiceName(
11238 aService: *const otSrpServerService,
11239 aServiceName: *const ::std::os::raw::c_char,
11240 ) -> bool;
11241}
11242extern "C" {
11243 #[doc = " Gets the number of sub-types of the service.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns The number of sub-types of @p aService."]
11244 pub fn otSrpServerServiceGetNumberOfSubTypes(aService: *const otSrpServerService) -> u16;
11245}
11246extern "C" {
11247 #[doc = " Gets the sub-type service name (full name) of the service at a given index\n\n The full service name for a sub-type service follows \"<sub-label>._sub.<service-labels>.<domain>.\".\n\n @param[in] aService A pointer to the SRP service.\n @param[in] aIndex The index to get.\n\n @returns A pointer to sub-type service name at @p aIndex, or `NULL` if no sub-type at this index."]
11248 pub fn otSrpServerServiceGetSubTypeServiceNameAt(
11249 aService: *const otSrpServerService,
11250 aIndex: u16,
11251 ) -> *const ::std::os::raw::c_char;
11252}
11253extern "C" {
11254 #[doc = " Indicates whether or not the service has a given sub-type.\n\n DNS name matches are performed using a case-insensitive string comparison (i.e., \"Abc\" and \"aBc\" are considered to\n be the same).\n\n @param[in] aService A pointer to the SRP service.\n @param[in] aSubTypeServiceName The sub-type service name (full name) to check.\n\n @retval TRUE Service contains the sub-type @p aSubTypeServiceName.\n @retval FALSE Service does not contain the sub-type @p aSubTypeServiceName."]
11255 pub fn otSrpServerServiceHasSubTypeServiceName(
11256 aService: *const otSrpServerService,
11257 aSubTypeServiceName: *const ::std::os::raw::c_char,
11258 ) -> bool;
11259}
11260extern "C" {
11261 #[doc = " Parses a sub-type service name (full name) and extracts the sub-type label.\n\n The full service name for a sub-type service follows \"<sub-label>._sub.<service-labels>.<domain>.\".\n\n @param[in] aSubTypeServiceName A sub-type service name (full name).\n @param[out] aLabel A pointer to a buffer to copy the extracted sub-type label.\n @param[in] aLabelSize Maximum size of @p aLabel buffer.\n\n @retval OT_ERROR_NONE Name was successfully parsed and @p aLabel was updated.\n @retval OT_ERROR_NO_BUFS The sub-type label could not fit in @p aLabel buffer (number of chars from label\n that could fit are copied in @p aLabel ensuring it is null-terminated).\n @retval OT_ERROR_INVALID_ARGS @p aSubTypeServiceName is not a valid sub-type format."]
11262 pub fn otSrpServerParseSubTypeServiceName(
11263 aSubTypeServiceName: *const ::std::os::raw::c_char,
11264 aLabel: *mut ::std::os::raw::c_char,
11265 aLabelSize: u8,
11266 ) -> otError;
11267}
11268extern "C" {
11269 #[doc = " Returns the port of the service instance.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns The port of the service."]
11270 pub fn otSrpServerServiceGetPort(aService: *const otSrpServerService) -> u16;
11271}
11272extern "C" {
11273 #[doc = " Returns the weight of the service instance.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns The weight of the service."]
11274 pub fn otSrpServerServiceGetWeight(aService: *const otSrpServerService) -> u16;
11275}
11276extern "C" {
11277 #[doc = " Returns the priority of the service instance.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns The priority of the service."]
11278 pub fn otSrpServerServiceGetPriority(aService: *const otSrpServerService) -> u16;
11279}
11280extern "C" {
11281 #[doc = " Returns the TTL of the service instance.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns The TTL of the service instance.."]
11282 pub fn otSrpServerServiceGetTtl(aService: *const otSrpServerService) -> u32;
11283}
11284extern "C" {
11285 #[doc = " Returns the TXT record data of the service instance.\n\n @param[in] aService A pointer to the SRP service.\n @param[out] aDataLength A pointer to return the TXT record data length. MUST NOT be NULL.\n\n @returns A pointer to the buffer containing the TXT record data (the TXT data length is returned in @p aDataLength)."]
11286 pub fn otSrpServerServiceGetTxtData(
11287 aService: *const otSrpServerService,
11288 aDataLength: *mut u16,
11289 ) -> *const u8;
11290}
11291extern "C" {
11292 #[doc = " Returns the host which the service instance reside on.\n\n @param[in] aService A pointer to the SRP service.\n\n @returns A pointer to the host instance."]
11293 pub fn otSrpServerServiceGetHost(aService: *const otSrpServerService)
11294 -> *const otSrpServerHost;
11295}
11296extern "C" {
11297 #[doc = " Returns the LEASE and KEY-LEASE information of a given service.\n\n @param[in] aService A pointer to the SRP server service.\n @param[out] aLeaseInfo A pointer to where to output the LEASE and KEY-LEASE information."]
11298 pub fn otSrpServerServiceGetLeaseInfo(
11299 aService: *const otSrpServerService,
11300 aLeaseInfo: *mut otSrpServerLeaseInfo,
11301 );
11302}
11303extern "C" {
11304 #[doc = " Run all queued OpenThread tasklets at the time this is called.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
11305 pub fn otTaskletsProcess(aInstance: *mut otInstance);
11306}
11307extern "C" {
11308 #[doc = " Indicates whether or not OpenThread has tasklets pending.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE If there are tasklets pending.\n @retval FALSE If there are no tasklets pending."]
11309 pub fn otTaskletsArePending(aInstance: *mut otInstance) -> bool;
11310}
11311extern "C" {
11312 #[doc = " OpenThread calls this function when the tasklet queue transitions from empty to non-empty.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
11313 pub fn otTaskletsSignalPending(aInstance: *mut otInstance);
11314}
11315#[doc = " A linked buffer structure for use with TCP.\n\n A single otLinkedBuffer structure references an array of bytes in memory,\n via mData and mLength. The mNext field is used to form a chain of\n otLinkedBuffer structures."]
11316#[repr(C)]
11317#[derive(Debug, Copy, Clone)]
11318pub struct otLinkedBuffer {
11319 #[doc = "< Pointer to the next linked buffer in the chain, or NULL if it is the end."]
11320 pub mNext: *mut otLinkedBuffer,
11321 #[doc = "< Pointer to data referenced by this linked buffer."]
11322 pub mData: *const u8,
11323 #[doc = "< Length of this linked buffer (number of bytes)."]
11324 pub mLength: usize,
11325}
11326impl Default for otLinkedBuffer {
11327 fn default() -> Self {
11328 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11329 unsafe {
11330 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11331 s.assume_init()
11332 }
11333 }
11334}
11335#[doc = " This callback informs the application that the TCP 3-way handshake is\n complete and that the connection is now established.\n\n @param[in] aEndpoint The TCP endpoint whose connection is now established."]
11336pub type otTcpEstablished =
11337 ::std::option::Option<unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint)>;
11338#[doc = " This callback informs the application that data in the provided\n @p aData have been acknowledged by the connection peer and that @p aData and\n the data it contains can be reclaimed by the application.\n\n The @p aData are guaranteed to be identical to those passed in to TCP via\n otTcpSendByReference(), including any extensions effected via\n otTcpSendByExtension().\n\n @param[in] aEndpoint The TCP endpoint for the connection.\n @param[in] aData A pointer to the otLinkedBuffer that can be reclaimed."]
11339pub type otTcpSendDone = ::std::option::Option<
11340 unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aData: *mut otLinkedBuffer),
11341>;
11342#[doc = " This callback informs the application if forward progress has been made in\n transferring data from the send buffer to the recipient. This callback is\n not necessary for correct TCP operation. Most applications can just rely on\n the otTcpSendDone() callback to reclaim linked buffers once the TCP stack is\n done using them. The purpose of this callback is to support advanced\n applications that benefit from finer-grained information about how the\n the connection is making forward progress in transferring data to the\n connection peer.\n\n This callback's operation is closely tied to TCP's send buffer. The send\n buffer can be understood as having two regions. First, there is the\n \"in-flight\" region at the head (front) of the send buffer. It corresponds\n to data which has been sent to the recipient, but is not yet acknowledged.\n Second, there is the \"backlog\" region, which consists of all data in the\n send buffer that is not in the \"in-flight\" region. The \"backlog\" region\n corresponds to data that is queued for sending, but has not yet been sent.\n\n The callback is invoked in response to two types of events. First, the\n \"in-flight\" region of the send buffer may shrink (e.g., when the recipient\n acknowledges data that we sent earlier). Second, the \"backlog\" region of the\n send buffer may shrink (e.g., new data was sent out). These two conditions\n often occur at the same time, in response to an ACK segment from the\n connection peer, which is why they are combined in a single callback.\n\n The TCP stack only uses the @p aInSendBuffer bytes at the tail of the send\n buffer; when @p aInSendBuffer decreases by an amount x, it means that x\n additional bytes that were formerly at the head of the send buffer are no\n longer part of the send buffer and can now be reclaimed (i.e., overwritten)\n by the application. Note that the otLinkedBuffer structure itself can only\n be reclaimed once all bytes that it references are no longer part of the\n send buffer.\n\n This callback subsumes otTcpSendDone(), in the following sense: applications\n can determine when linked buffers can be reclaimed by comparing\n @p aInSendBuffer with how many bytes are in each linked buffer. However, we\n expect otTcpSendDone(), which directly conveys which otLinkedBuffers can be\n reclaimed, to be much simpler to use. If both callbacks are registered and\n are triggered by the same event (e.g., the same ACK segment received), then\n the otTcpSendDone() callback will be triggered first, followed by this\n callback.\n\n Additionally, this callback provides @p aBacklog, which indicates how many\n bytes of data in the send buffer are not yet in flight. For applications\n that only want to add data to the send buffer when there is an assurance\n that it will be sent out soon, it may be desirable to only send out data\n when @p aBacklog is suitably small (0 or close to 0). For example, an\n application may use @p aBacklog so that it can react to queue buildup by\n dropping or aggregating data to avoid creating a backlog of data.\n\n After a call to otTcpSendByReference() or otTcpSendByExtension() with a\n positive number of bytes, the otTcpForwardProgress() callback is guaranteed\n to be called, to indicate when the bytes that were added to the send buffer\n are sent out. The call to otTcpForwardProgress() may be made immediately\n after the bytes are added to the send buffer (if some of those bytes are\n immediately sent out, reducing the backlog), or sometime in the future (once\n the connection sends out some or all of the data, reducing the backlog). By\n \"immediately,\" we mean that the callback is immediately scheduled for\n execution in a tasklet; to avoid reentrancy-related complexity, the\n otTcpForwardProgress() callback is never directly called from the\n otTcpSendByReference() or otTcpSendByExtension() functions.\n\n @param[in] aEndpoint The TCP endpoint for the connection.\n @param[in] aInSendBuffer The number of bytes in the send buffer (sum of \"in-flight\" and \"backlog\" regions).\n @param[in] aBacklog The number of bytes that are queued for sending but have not yet been sent (the \"backlog\"\n region)."]
11343pub type otTcpForwardProgress = ::std::option::Option<
11344 unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aInSendBuffer: usize, aBacklog: usize),
11345>;
11346#[doc = " This callback indicates the number of bytes available for consumption from\n the receive buffer.\n\n It is called whenever bytes are added to the receive buffer and when the\n end of stream is reached. If the end of the stream has been reached (i.e.,\n if no more data will become available to read because the connection peer\n has closed their end of the connection for writing), then @p aEndOfStream is\n true. Finally, @p aBytesRemaining indicates how much capacity is left in the\n receive buffer to hold additional data that arrives.\n\n @param[in] aEndpoint The TCP endpoint for the connection.\n @param[in] aBytesAvailable The number of bytes in the connection's receive buffer.\n @param[in] aEndOfStream Indicates if additional data, beyond what is already in the connection's receive buffer,\n can be received.\n @param[in] aBytesRemaining The number of additional bytes that can be received before the receive buffer becomes\n full."]
11347pub type otTcpReceiveAvailable = ::std::option::Option<
11348 unsafe extern "C" fn(
11349 aEndpoint: *mut otTcpEndpoint,
11350 aBytesAvailable: usize,
11351 aEndOfStream: bool,
11352 aBytesRemaining: usize,
11353 ),
11354>;
11355pub const OT_TCP_DISCONNECTED_REASON_NORMAL: otTcpDisconnectedReason = 0;
11356pub const OT_TCP_DISCONNECTED_REASON_REFUSED: otTcpDisconnectedReason = 1;
11357pub const OT_TCP_DISCONNECTED_REASON_RESET: otTcpDisconnectedReason = 2;
11358pub const OT_TCP_DISCONNECTED_REASON_TIME_WAIT: otTcpDisconnectedReason = 3;
11359pub const OT_TCP_DISCONNECTED_REASON_TIMED_OUT: otTcpDisconnectedReason = 4;
11360pub type otTcpDisconnectedReason = ::std::os::raw::c_uint;
11361#[doc = " This callback indicates that the connection was broken and should no longer\n be used, or that a connection has entered the TIME-WAIT state.\n\n It can occur if a connection establishment attempt (initiated by calling\n otTcpConnect()) fails, or any point thereafter (e.g., if the connection\n times out or an RST segment is received from the connection peer). Once this\n callback fires, all resources that the application provided for this\n connection (i.e., any `otLinkedBuffers` and memory they reference, but not\n the TCP endpoint itself or space for the receive buffers) can be reclaimed.\n In the case of a connection entering the TIME-WAIT state, this callback is\n called twice, once upon entry into the TIME-WAIT state (with\n OT_TCP_DISCONNECTED_REASON_TIME_WAIT, and again when the TIME-WAIT state\n expires (with OT_TCP_DISCONNECTED_REASON_NORMAL).\n\n @param[in] aEndpoint The TCP endpoint whose connection has been lost.\n @param[in] aReason The reason why the connection was lost."]
11362pub type otTcpDisconnected = ::std::option::Option<
11363 unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aReason: otTcpDisconnectedReason),
11364>;
11365#[doc = " Represents a TCP endpoint.\n\n A TCP endpoint acts an endpoint of TCP connection. It can be used to\n initiate TCP connections, and, once a TCP connection is established, send\n data to and receive data from the connection peer.\n\n The application should not inspect the fields of this structure directly; it\n should only interact with it via the TCP API functions whose signatures are\n provided in this file."]
11366#[repr(C)]
11367#[derive(Copy, Clone)]
11368pub struct otTcpEndpoint {
11369 pub mTcb: otTcpEndpoint__bindgen_ty_1,
11370 #[doc = "< A pointer to the next TCP endpoint (internal use only)"]
11371 pub mNext: *mut otTcpEndpoint,
11372 #[doc = "< A pointer to application-specific context"]
11373 pub mContext: *mut ::std::os::raw::c_void,
11374 #[doc = "< \"Established\" callback function"]
11375 pub mEstablishedCallback: otTcpEstablished,
11376 #[doc = "< \"Send done\" callback function"]
11377 pub mSendDoneCallback: otTcpSendDone,
11378 #[doc = "< \"Forward progress\" callback function"]
11379 pub mForwardProgressCallback: otTcpForwardProgress,
11380 #[doc = "< \"Receive available\" callback function"]
11381 pub mReceiveAvailableCallback: otTcpReceiveAvailable,
11382 #[doc = "< \"Disconnected\" callback function"]
11383 pub mDisconnectedCallback: otTcpDisconnected,
11384 pub mTimers: [u32; 4usize],
11385 pub mReceiveLinks: [otLinkedBuffer; 2usize],
11386 pub mSockAddr: otSockAddr,
11387 pub mPendingCallbacks: u8,
11388}
11389#[repr(C)]
11390#[derive(Copy, Clone)]
11391pub union otTcpEndpoint__bindgen_ty_1 {
11392 pub mSize: [u8; 680usize],
11393 pub mAlign: u64,
11394}
11395impl Default for otTcpEndpoint__bindgen_ty_1 {
11396 fn default() -> Self {
11397 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11398 unsafe {
11399 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11400 s.assume_init()
11401 }
11402 }
11403}
11404impl Default for otTcpEndpoint {
11405 fn default() -> Self {
11406 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11407 unsafe {
11408 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11409 s.assume_init()
11410 }
11411 }
11412}
11413#[doc = " Contains arguments to the otTcpEndpointInitialize() function."]
11414#[repr(C)]
11415#[derive(Debug, Copy, Clone)]
11416pub struct otTcpEndpointInitializeArgs {
11417 #[doc = "< Pointer to application-specific context"]
11418 pub mContext: *mut ::std::os::raw::c_void,
11419 #[doc = "< \"Established\" callback function"]
11420 pub mEstablishedCallback: otTcpEstablished,
11421 #[doc = "< \"Send done\" callback function"]
11422 pub mSendDoneCallback: otTcpSendDone,
11423 #[doc = "< \"Forward progress\" callback function"]
11424 pub mForwardProgressCallback: otTcpForwardProgress,
11425 #[doc = "< \"Receive available\" callback function"]
11426 pub mReceiveAvailableCallback: otTcpReceiveAvailable,
11427 #[doc = "< \"Disconnected\" callback function"]
11428 pub mDisconnectedCallback: otTcpDisconnected,
11429 #[doc = "< Pointer to memory provided to the system for the TCP receive buffer"]
11430 pub mReceiveBuffer: *mut ::std::os::raw::c_void,
11431 #[doc = "< Size of memory provided to the system for the TCP receive buffer"]
11432 pub mReceiveBufferSize: usize,
11433}
11434impl Default for otTcpEndpointInitializeArgs {
11435 fn default() -> Self {
11436 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11437 unsafe {
11438 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11439 s.assume_init()
11440 }
11441 }
11442}
11443extern "C" {
11444 #[doc = " Initializes a TCP endpoint.\n\n Calling this function causes OpenThread to keep track of the TCP endpoint\n and store and retrieve TCP data inside the @p aEndpoint. The application\n should refrain from directly accessing or modifying the fields in\n @p aEndpoint. If the application needs to reclaim the memory backing\n @p aEndpoint, it should call otTcpEndpointDeinitialize().\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEndpoint A pointer to a TCP endpoint structure.\n @param[in] aArgs A pointer to a structure of arguments.\n\n @retval OT_ERROR_NONE Successfully opened the TCP endpoint.\n @retval OT_ERROR_FAILED Failed to open the TCP endpoint."]
11445 pub fn otTcpEndpointInitialize(
11446 aInstance: *mut otInstance,
11447 aEndpoint: *mut otTcpEndpoint,
11448 aArgs: *const otTcpEndpointInitializeArgs,
11449 ) -> otError;
11450}
11451extern "C" {
11452 #[doc = " Obtains the otInstance that was associated with @p aEndpoint upon\n initialization.\n\n @param[in] aEndpoint The TCP endpoint whose instance to obtain.\n\n @returns The otInstance pointer associated with @p aEndpoint."]
11453 pub fn otTcpEndpointGetInstance(aEndpoint: *mut otTcpEndpoint) -> *mut otInstance;
11454}
11455extern "C" {
11456 #[doc = " Obtains the context pointer that was associated with @p aEndpoint upon\n initialization.\n\n @param[in] aEndpoint The TCP endpoint whose context to obtain.\n\n @returns The context pointer associated with @p aEndpoint."]
11457 pub fn otTcpEndpointGetContext(aEndpoint: *mut otTcpEndpoint) -> *mut ::std::os::raw::c_void;
11458}
11459extern "C" {
11460 #[doc = " Obtains a pointer to a TCP endpoint's local host and port.\n\n The contents of the host and port may be stale if this socket is not in a\n connected state and has not been bound after it was last disconnected.\n\n @param[in] aEndpoint The TCP endpoint whose local host and port to obtain.\n\n @returns The local host and port of @p aEndpoint."]
11461 pub fn otTcpGetLocalAddress(aEndpoint: *const otTcpEndpoint) -> *const otSockAddr;
11462}
11463extern "C" {
11464 #[doc = " Obtains a pointer to a TCP endpoint's peer's host and port.\n\n The contents of the host and port may be stale if this socket is not in a\n connected state.\n\n @param[in] aEndpoint The TCP endpoint whose peer's host and port to obtain.\n\n @returns The host and port of the connection peer of @p aEndpoint."]
11465 pub fn otTcpGetPeerAddress(aEndpoint: *const otTcpEndpoint) -> *const otSockAddr;
11466}
11467extern "C" {
11468 #[doc = " Binds the TCP endpoint to an IP address and port.\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure to bind.\n @param[in] aSockName The address and port to which to bind this TCP endpoint.\n\n @retval OT_ERROR_NONE Successfully bound the TCP endpoint.\n @retval OT_ERROR_FAILED Failed to bind the TCP endpoint."]
11469 pub fn otTcpBind(aEndpoint: *mut otTcpEndpoint, aSockName: *const otSockAddr) -> otError;
11470}
11471pub const OT_TCP_CONNECT_NO_FAST_OPEN: _bindgen_ty_11 = 1;
11472#[doc = " Defines flags passed to otTcpConnect()."]
11473pub type _bindgen_ty_11 = ::std::os::raw::c_uint;
11474extern "C" {
11475 #[doc = " Records the remote host and port for this connection.\n\n TCP Fast Open must be enabled or disabled using @p aFlags. If it is\n disabled, then the TCP connection establishment handshake is initiated\n immediately. If it is enabled, then this function merely records the\n the remote host and port, and the TCP connection establishment handshake\n only happens on the first call to `otTcpSendByReference()`.\n\n If TCP Fast Open is disabled, then the caller must wait for the\n `otTcpEstablished` callback indicating that TCP connection establishment\n handshake is done before it can start sending data e.g., by calling\n `otTcpSendByReference()`.\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure to connect.\n @param[in] aSockName The IP address and port of the host to which to connect.\n @param[in] aFlags Flags specifying options for this operation (see enumeration above).\n\n @retval OT_ERROR_NONE Successfully completed the operation.\n @retval OT_ERROR_FAILED Failed to complete the operation."]
11476 pub fn otTcpConnect(
11477 aEndpoint: *mut otTcpEndpoint,
11478 aSockName: *const otSockAddr,
11479 aFlags: u32,
11480 ) -> otError;
11481}
11482pub const OT_TCP_SEND_MORE_TO_COME: _bindgen_ty_12 = 1;
11483#[doc = " Defines flags passed to @p otTcpSendByReference."]
11484pub type _bindgen_ty_12 = ::std::os::raw::c_uint;
11485extern "C" {
11486 #[doc = " Adds data referenced by the linked buffer pointed to by @p aBuffer to the\n send buffer.\n\n Upon a successful call to this function, the linked buffer and data it\n references are owned by the TCP stack; they should not be modified by the\n application until a \"send done\" callback returns ownership of those objects\n to the application. It is acceptable to call this function to add another\n linked buffer to the send queue, even if the \"send done\" callback for a\n previous invocation of this function has not yet fired.\n\n Note that @p aBuffer should not be chained; its mNext field should be\n NULL. If additional data will be added right after this call, then the\n OT_TCP_SEND_MORE_TO_COME flag should be used as a hint to the TCP\n implementation.\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure representing the TCP endpoint on which to send data.\n @param[in] aBuffer A pointer to the linked buffer chain referencing data to add to the send buffer.\n @param[in] aFlags Flags specifying options for this operation (see enumeration above).\n\n @retval OT_ERROR_NONE Successfully added data to the send buffer.\n @retval OT_ERROR_FAILED Failed to add data to the send buffer."]
11487 pub fn otTcpSendByReference(
11488 aEndpoint: *mut otTcpEndpoint,
11489 aBuffer: *mut otLinkedBuffer,
11490 aFlags: u32,
11491 ) -> otError;
11492}
11493extern "C" {
11494 #[doc = " Adds data to the send buffer by extending the length of the final\n otLinkedBuffer in the send buffer by the specified amount.\n\n If the send buffer is empty, then the operation fails.\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure representing the TCP endpoint on which to send data.\n @param[in] aNumBytes The number of bytes by which to extend the length of the final linked buffer.\n @param[in] aFlags Flags specifying options for this operation (see enumeration above).\n\n @retval OT_ERROR_NONE Successfully added data to the send buffer.\n @retval OT_ERROR_FAILED Failed to add data to the send buffer."]
11495 pub fn otTcpSendByExtension(
11496 aEndpoint: *mut otTcpEndpoint,
11497 aNumBytes: usize,
11498 aFlags: u32,
11499 ) -> otError;
11500}
11501extern "C" {
11502 #[doc = " Provides the application with a linked buffer chain referencing data\n currently in the TCP receive buffer.\n\n The linked buffer chain is valid until the \"receive ready\" callback is next\n invoked, or until the next call to otTcpReceiveContiguify() or\n otTcpCommitReceive().\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure representing the TCP endpoint on which to receive\n data.\n @param[out] aBuffer A pointer to the linked buffer chain referencing data currently in the receive buffer.\n\n @retval OT_ERROR_NONE Successfully completed the operation.\n @retval OT_ERROR_FAILED Failed to complete the operation."]
11503 pub fn otTcpReceiveByReference(
11504 aEndpoint: *mut otTcpEndpoint,
11505 aBuffer: *mut *const otLinkedBuffer,
11506 ) -> otError;
11507}
11508extern "C" {
11509 #[doc = " Reorganizes the receive buffer to be entirely contiguous in memory.\n\n This is optional; an application can simply traverse the linked buffer\n chain obtained by calling @p otTcpReceiveByReference. Some\n applications may wish to call this function to make the receive buffer\n contiguous to simplify their data processing, but this comes at the expense\n of CPU time to reorganize the data in the receive buffer.\n\n @param[in] aEndpoint A pointer to the TCP endpoint whose receive buffer to reorganize.\n\n @retval OT_ERROR_NONE Successfully completed the operation.\n @retval OT_ERROR_FAILED Failed to complete the operation."]
11510 pub fn otTcpReceiveContiguify(aEndpoint: *mut otTcpEndpoint) -> otError;
11511}
11512extern "C" {
11513 #[doc = " Informs the TCP stack that the application has finished processing\n @p aNumBytes bytes of data at the start of the receive buffer and that the\n TCP stack need not continue maintaining those bytes in the receive buffer.\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure representing the TCP endpoint on which to receive\n data.\n @param[in] aNumBytes The number of bytes consumed.\n @param[in] aFlags Flags specifying options for this operation (none yet).\n\n @retval OT_ERROR_NONE Successfully completed the receive operation.\n @retval OT_ERROR_FAILED Failed to complete the receive operation."]
11514 pub fn otTcpCommitReceive(
11515 aEndpoint: *mut otTcpEndpoint,
11516 aNumBytes: usize,
11517 aFlags: u32,
11518 ) -> otError;
11519}
11520extern "C" {
11521 #[doc = " Informs the connection peer that this TCP endpoint will not send more data.\n\n This should be used when the application has no more data to send to the\n connection peer. For this connection, future reads on the connection peer\n will result in the \"end of stream\" condition, and future writes on this\n connection endpoint will fail.\n\n The \"end of stream\" condition only applies after any data previously\n provided to the TCP stack to send out has been received by the connection\n peer.\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure representing the TCP endpoint to shut down.\n\n @retval OT_ERROR_NONE Successfully queued the \"end of stream\" condition for transmission.\n @retval OT_ERROR_FAILED Failed to queue the \"end of stream\" condition for transmission."]
11522 pub fn otTcpSendEndOfStream(aEndpoint: *mut otTcpEndpoint) -> otError;
11523}
11524extern "C" {
11525 #[doc = " Forcibly ends the TCP connection associated with this TCP endpoint.\n\n This immediately makes the TCP endpoint free for use for another connection\n and empties the send and receive buffers, transferring ownership of any data\n provided by the application in otTcpSendByReference() and\n otTcpSendByExtension() calls back to the application. The TCP endpoint's\n callbacks and memory for the receive buffer remain associated with the\n TCP endpoint.\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure representing the TCP endpoint to abort.\n\n @retval OT_ERROR_NONE Successfully aborted the TCP endpoint's connection.\n @retval OT_ERROR_FAILED Failed to abort the TCP endpoint's connection."]
11526 pub fn otTcpAbort(aEndpoint: *mut otTcpEndpoint) -> otError;
11527}
11528extern "C" {
11529 #[doc = " Deinitializes this TCP endpoint.\n\n This means that OpenThread no longer keeps track of this TCP endpoint and\n deallocates all resources it has internally allocated for this TCP endpoint.\n The application can reuse the memory backing the TCP endpoint as it sees fit.\n\n If it corresponds to a live TCP connection, the connection is terminated\n unceremoniously (as in otTcpAbort()). All resources the application has\n provided for this TCP endpoint (linked buffers for the send buffer, memory\n for the receive buffer, the @p aEndpoint structure itself, etc.) are\n immediately returned to the application.\n\n @param[in] aEndpoint A pointer to the TCP endpoint structure to deinitialize.\n\n @retval OT_ERROR_NONE Successfully deinitialized the TCP endpoint.\n @retval OT_ERROR_FAILED Failed to deinitialize the TCP endpoint."]
11530 pub fn otTcpEndpointDeinitialize(aEndpoint: *mut otTcpEndpoint) -> otError;
11531}
11532#[doc = "< Accept the incoming connection."]
11533pub const OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT: otTcpIncomingConnectionAction = 0;
11534#[doc = "< Defer (silently ignore) the incoming connection."]
11535pub const OT_TCP_INCOMING_CONNECTION_ACTION_DEFER: otTcpIncomingConnectionAction = 1;
11536#[doc = "< Refuse the incoming connection."]
11537pub const OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE: otTcpIncomingConnectionAction = 2;
11538#[doc = " Defines incoming connection actions.\n\n This is used in otTcpAcceptReady() callback."]
11539pub type otTcpIncomingConnectionAction = ::std::os::raw::c_uint;
11540#[doc = " This callback indicates that an incoming connection that matches this TCP\n listener has arrived.\n\n The typical response is for the application to accept the incoming\n connection. It does so by populating @p aAcceptInto with a pointer to the\n otTcpEndpoint into which to accept the incoming connection. This\n otTcpEndpoint must already be initialized using otTcpEndpointInitialize().\n Then, the application returns OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT.\n\n Alternatively, the application can decline to accept the incoming\n connection. There are two ways for the application to do this. First, if the\n application returns OT_TCP_INCOMING_CONNECTION_ACTION_DEFER, then OpenThread\n silently ignores the connection establishment request; the connection peer\n will likely retransmit the request, at which point the callback will be\n called again. This is valuable if resources are not presently available to\n accept the connection, but they may be available when the connection peer\n retransmits its connection establishment attempt. Second, if the application\n returns OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE, then OpenThread sends a\n \"connection refused\" message to the host that attempted to establish a\n connection. If the application declines the incoming connection, it is not\n required to populate @p aAcceptInto.\n\n @param[in] aListener The TCP listener that matches the incoming connection.\n @param[in] aPeer The host and port from which the incoming connection originates.\n @param[out] aAcceptInto The TCP endpoint into which to accept the incoming connection.\n\n @returns Description of how to handle the incoming connection."]
11541pub type otTcpAcceptReady = ::std::option::Option<
11542 unsafe extern "C" fn(
11543 aListener: *mut otTcpListener,
11544 aPeer: *const otSockAddr,
11545 aAcceptInto: *mut *mut otTcpEndpoint,
11546 ) -> otTcpIncomingConnectionAction,
11547>;
11548#[doc = " This callback indicates that the TCP connection is now ready for two-way\n communication.\n\n In the case of TCP Fast Open, this may be before the TCP\n connection handshake has actually completed. The application is provided\n with the context pointers both for the TCP listener that accepted the\n connection and the TCP endpoint into which it was accepted. The provided\n context is the one associated with the TCP listener.\n\n @param[in] aListener The TCP listener that matches the incoming connection.\n @param[in] aEndpoint The TCP endpoint into which the incoming connection was accepted.\n @param[in] aPeer the host and port from which the incoming connection originated."]
11549pub type otTcpAcceptDone = ::std::option::Option<
11550 unsafe extern "C" fn(
11551 aListener: *mut otTcpListener,
11552 aEndpoint: *mut otTcpEndpoint,
11553 aPeer: *const otSockAddr,
11554 ),
11555>;
11556#[doc = " Represents a TCP listener.\n\n A TCP listener is used to listen for and accept incoming TCP connections.\n\n The application should not inspect the fields of this structure directly; it\n should only interact with it via the TCP API functions whose signatures are\n provided in this file."]
11557#[repr(C)]
11558#[derive(Copy, Clone)]
11559pub struct otTcpListener {
11560 pub mTcbListen: otTcpListener__bindgen_ty_1,
11561 #[doc = "< A pointer to the next TCP listener (internal use only)"]
11562 pub mNext: *mut otTcpListener,
11563 #[doc = "< A pointer to application-specific context"]
11564 pub mContext: *mut ::std::os::raw::c_void,
11565 #[doc = "< \"Accept ready\" callback function"]
11566 pub mAcceptReadyCallback: otTcpAcceptReady,
11567 #[doc = "< \"Accept done\" callback function"]
11568 pub mAcceptDoneCallback: otTcpAcceptDone,
11569}
11570#[repr(C)]
11571#[derive(Copy, Clone)]
11572pub union otTcpListener__bindgen_ty_1 {
11573 pub mSize: [u8; 40usize],
11574 pub mAlign: *mut ::std::os::raw::c_void,
11575}
11576impl Default for otTcpListener__bindgen_ty_1 {
11577 fn default() -> Self {
11578 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11579 unsafe {
11580 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11581 s.assume_init()
11582 }
11583 }
11584}
11585impl Default for otTcpListener {
11586 fn default() -> Self {
11587 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11588 unsafe {
11589 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11590 s.assume_init()
11591 }
11592 }
11593}
11594#[doc = " Contains arguments to the otTcpListenerInitialize() function."]
11595#[repr(C)]
11596#[derive(Debug, Copy, Clone)]
11597pub struct otTcpListenerInitializeArgs {
11598 #[doc = "< Pointer to application-specific context"]
11599 pub mContext: *mut ::std::os::raw::c_void,
11600 #[doc = "< \"Accept ready\" callback function"]
11601 pub mAcceptReadyCallback: otTcpAcceptReady,
11602 #[doc = "< \"Accept done\" callback function"]
11603 pub mAcceptDoneCallback: otTcpAcceptDone,
11604}
11605impl Default for otTcpListenerInitializeArgs {
11606 fn default() -> Self {
11607 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11608 unsafe {
11609 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11610 s.assume_init()
11611 }
11612 }
11613}
11614extern "C" {
11615 #[doc = " Initializes a TCP listener.\n\n Calling this function causes OpenThread to keep track of the TCP listener\n and store and retrieve TCP data inside @p aListener. The application should\n refrain from directly accessing or modifying the fields in @p aListener. If\n the application needs to reclaim the memory backing @p aListener, it should\n call otTcpListenerDeinitialize().\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aListener A pointer to a TCP listener structure.\n @param[in] aArgs A pointer to a structure of arguments.\n\n @retval OT_ERROR_NONE Successfully opened the TCP listener.\n @retval OT_ERROR_FAILED Failed to open the TCP listener."]
11616 pub fn otTcpListenerInitialize(
11617 aInstance: *mut otInstance,
11618 aListener: *mut otTcpListener,
11619 aArgs: *const otTcpListenerInitializeArgs,
11620 ) -> otError;
11621}
11622extern "C" {
11623 #[doc = " Obtains the otInstance that was associated with @p aListener upon\n initialization.\n\n @param[in] aListener The TCP listener whose instance to obtain.\n\n @returns The otInstance pointer associated with @p aListener."]
11624 pub fn otTcpListenerGetInstance(aListener: *mut otTcpListener) -> *mut otInstance;
11625}
11626extern "C" {
11627 #[doc = " Obtains the context pointer that was associated with @p aListener upon\n initialization.\n\n @param[in] aListener The TCP listener whose context to obtain.\n\n @returns The context pointer associated with @p aListener."]
11628 pub fn otTcpListenerGetContext(aListener: *mut otTcpListener) -> *mut ::std::os::raw::c_void;
11629}
11630extern "C" {
11631 #[doc = " Causes incoming TCP connections that match the specified IP address and port\n to trigger this TCP listener's callbacks.\n\n @param[in] aListener A pointer to the TCP listener structure that should begin listening.\n @param[in] aSockName The address and port on which to listen for incoming connections.\n\n @retval OT_ERROR_NONE Successfully initiated listening on the TCP listener.\n @retval OT_ERROR_FAILED Failed to initiate listening on the TCP listener."]
11632 pub fn otTcpListen(aListener: *mut otTcpListener, aSockName: *const otSockAddr) -> otError;
11633}
11634extern "C" {
11635 #[doc = " Causes this TCP listener to stop listening for incoming connections.\n\n @param[in] aListener A pointer to the TCP listener structure that should stop listening.\n\n @retval OT_ERROR_NONE Successfully stopped listening on the TCP listener.\n @retval OT_ERROR_FAILED Failed to stop listening on the TCP listener."]
11636 pub fn otTcpStopListening(aListener: *mut otTcpListener) -> otError;
11637}
11638extern "C" {
11639 #[doc = " Deinitializes this TCP listener.\n\n This means that OpenThread no longer keeps track of this TCP listener and\n deallocates all resources it has internally allocated for this TCP listener.\n The application can reuse the memory backing the TCP listener as it sees\n fit.\n\n If the TCP listener is currently listening, it stops listening.\n\n @param[in] aListener A pointer to the TCP listener structure to deinitialize.\n\n @retval OT_ERROR_NONE Successfully deinitialized the TCP listener.\n @retval OT_ERROR_FAILED Failed to deinitialize the TCP listener."]
11640 pub fn otTcpListenerDeinitialize(aListener: *mut otTcpListener) -> otError;
11641}
11642#[doc = " Holds diagnostic information for a Thread Child"]
11643#[repr(C)]
11644#[derive(Debug, Default, Copy, Clone)]
11645pub struct otChildInfo {
11646 #[doc = "< IEEE 802.15.4 Extended Address"]
11647 pub mExtAddress: otExtAddress,
11648 #[doc = "< Timeout"]
11649 pub mTimeout: u32,
11650 #[doc = "< Seconds since last heard"]
11651 pub mAge: u32,
11652 #[doc = "< Seconds since attach (requires `OPENTHREAD_CONFIG_UPTIME_ENABLE`)"]
11653 pub mConnectionTime: u64,
11654 #[doc = "< RLOC16"]
11655 pub mRloc16: u16,
11656 #[doc = "< Child ID"]
11657 pub mChildId: u16,
11658 #[doc = "< Network Data Version"]
11659 pub mNetworkDataVersion: u8,
11660 #[doc = "< Link Quality In"]
11661 pub mLinkQualityIn: u8,
11662 #[doc = "< Average RSSI"]
11663 pub mAverageRssi: i8,
11664 #[doc = "< Last observed RSSI"]
11665 pub mLastRssi: i8,
11666 #[doc = "< Frame error rate (0xffff->100%). Requires error tracking feature."]
11667 pub mFrameErrorRate: u16,
11668 #[doc = "< (IPv6) msg error rate (0xffff->100%). Requires error tracking feature."]
11669 pub mMessageErrorRate: u16,
11670 #[doc = "< Number of queued messages for the child."]
11671 pub mQueuedMessageCnt: u16,
11672 #[doc = "< Supervision interval (in seconds)."]
11673 pub mSupervisionInterval: u16,
11674 #[doc = "< MLE version"]
11675 pub mVersion: u8,
11676 pub _bitfield_align_1: [u8; 0],
11677 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11678 pub __bindgen_padding_0: [u16; 3usize],
11679}
11680impl otChildInfo {
11681 #[inline]
11682 pub fn mRxOnWhenIdle(&self) -> bool {
11683 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11684 }
11685 #[inline]
11686 pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
11687 unsafe {
11688 let val: u8 = ::std::mem::transmute(val);
11689 self._bitfield_1.set(0usize, 1u8, val as u64)
11690 }
11691 }
11692 #[inline]
11693 pub fn mFullThreadDevice(&self) -> bool {
11694 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
11695 }
11696 #[inline]
11697 pub fn set_mFullThreadDevice(&mut self, val: bool) {
11698 unsafe {
11699 let val: u8 = ::std::mem::transmute(val);
11700 self._bitfield_1.set(1usize, 1u8, val as u64)
11701 }
11702 }
11703 #[inline]
11704 pub fn mFullNetworkData(&self) -> bool {
11705 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
11706 }
11707 #[inline]
11708 pub fn set_mFullNetworkData(&mut self, val: bool) {
11709 unsafe {
11710 let val: u8 = ::std::mem::transmute(val);
11711 self._bitfield_1.set(2usize, 1u8, val as u64)
11712 }
11713 }
11714 #[inline]
11715 pub fn mIsStateRestoring(&self) -> bool {
11716 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
11717 }
11718 #[inline]
11719 pub fn set_mIsStateRestoring(&mut self, val: bool) {
11720 unsafe {
11721 let val: u8 = ::std::mem::transmute(val);
11722 self._bitfield_1.set(3usize, 1u8, val as u64)
11723 }
11724 }
11725 #[inline]
11726 pub fn mIsCslSynced(&self) -> bool {
11727 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
11728 }
11729 #[inline]
11730 pub fn set_mIsCslSynced(&mut self, val: bool) {
11731 unsafe {
11732 let val: u8 = ::std::mem::transmute(val);
11733 self._bitfield_1.set(4usize, 1u8, val as u64)
11734 }
11735 }
11736 #[inline]
11737 pub fn new_bitfield_1(
11738 mRxOnWhenIdle: bool,
11739 mFullThreadDevice: bool,
11740 mFullNetworkData: bool,
11741 mIsStateRestoring: bool,
11742 mIsCslSynced: bool,
11743 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11744 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11745 __bindgen_bitfield_unit.set(0usize, 1u8, {
11746 let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
11747 mRxOnWhenIdle as u64
11748 });
11749 __bindgen_bitfield_unit.set(1usize, 1u8, {
11750 let mFullThreadDevice: u8 = unsafe { ::std::mem::transmute(mFullThreadDevice) };
11751 mFullThreadDevice as u64
11752 });
11753 __bindgen_bitfield_unit.set(2usize, 1u8, {
11754 let mFullNetworkData: u8 = unsafe { ::std::mem::transmute(mFullNetworkData) };
11755 mFullNetworkData as u64
11756 });
11757 __bindgen_bitfield_unit.set(3usize, 1u8, {
11758 let mIsStateRestoring: u8 = unsafe { ::std::mem::transmute(mIsStateRestoring) };
11759 mIsStateRestoring as u64
11760 });
11761 __bindgen_bitfield_unit.set(4usize, 1u8, {
11762 let mIsCslSynced: u8 = unsafe { ::std::mem::transmute(mIsCslSynced) };
11763 mIsCslSynced as u64
11764 });
11765 __bindgen_bitfield_unit
11766 }
11767}
11768pub type otChildIp6AddressIterator = u16;
11769pub const OT_CACHE_ENTRY_STATE_CACHED: otCacheEntryState = 0;
11770pub const OT_CACHE_ENTRY_STATE_SNOOPED: otCacheEntryState = 1;
11771pub const OT_CACHE_ENTRY_STATE_QUERY: otCacheEntryState = 2;
11772pub const OT_CACHE_ENTRY_STATE_RETRY_QUERY: otCacheEntryState = 3;
11773#[doc = " Defines the EID cache entry state."]
11774pub type otCacheEntryState = ::std::os::raw::c_uint;
11775#[doc = " Represents an EID cache entry."]
11776#[repr(C)]
11777#[derive(Copy, Clone)]
11778pub struct otCacheEntryInfo {
11779 #[doc = "< Target EID"]
11780 pub mTarget: otIp6Address,
11781 #[doc = "< RLOC16"]
11782 pub mRloc16: otShortAddress,
11783 #[doc = "< Entry state"]
11784 pub mState: otCacheEntryState,
11785 pub _bitfield_align_1: [u8; 0],
11786 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11787 #[doc = "< Last transaction time (applicable in cached state)."]
11788 pub mLastTransTime: u32,
11789 #[doc = "< Mesh Local EID (applicable if entry in cached state)."]
11790 pub mMeshLocalEid: otIp6Address,
11791 #[doc = "< Timeout in seconds (applicable if in snooped/query/retry-query states)."]
11792 pub mTimeout: u16,
11793 #[doc = "< Retry delay in seconds (applicable if in query-retry state)."]
11794 pub mRetryDelay: u16,
11795}
11796impl Default for otCacheEntryInfo {
11797 fn default() -> Self {
11798 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11799 unsafe {
11800 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11801 s.assume_init()
11802 }
11803 }
11804}
11805impl otCacheEntryInfo {
11806 #[inline]
11807 pub fn mCanEvict(&self) -> bool {
11808 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11809 }
11810 #[inline]
11811 pub fn set_mCanEvict(&mut self, val: bool) {
11812 unsafe {
11813 let val: u8 = ::std::mem::transmute(val);
11814 self._bitfield_1.set(0usize, 1u8, val as u64)
11815 }
11816 }
11817 #[inline]
11818 pub fn mRampDown(&self) -> bool {
11819 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
11820 }
11821 #[inline]
11822 pub fn set_mRampDown(&mut self, val: bool) {
11823 unsafe {
11824 let val: u8 = ::std::mem::transmute(val);
11825 self._bitfield_1.set(1usize, 1u8, val as u64)
11826 }
11827 }
11828 #[inline]
11829 pub fn mValidLastTrans(&self) -> bool {
11830 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
11831 }
11832 #[inline]
11833 pub fn set_mValidLastTrans(&mut self, val: bool) {
11834 unsafe {
11835 let val: u8 = ::std::mem::transmute(val);
11836 self._bitfield_1.set(2usize, 1u8, val as u64)
11837 }
11838 }
11839 #[inline]
11840 pub fn new_bitfield_1(
11841 mCanEvict: bool,
11842 mRampDown: bool,
11843 mValidLastTrans: bool,
11844 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11845 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11846 __bindgen_bitfield_unit.set(0usize, 1u8, {
11847 let mCanEvict: u8 = unsafe { ::std::mem::transmute(mCanEvict) };
11848 mCanEvict as u64
11849 });
11850 __bindgen_bitfield_unit.set(1usize, 1u8, {
11851 let mRampDown: u8 = unsafe { ::std::mem::transmute(mRampDown) };
11852 mRampDown as u64
11853 });
11854 __bindgen_bitfield_unit.set(2usize, 1u8, {
11855 let mValidLastTrans: u8 = unsafe { ::std::mem::transmute(mValidLastTrans) };
11856 mValidLastTrans as u64
11857 });
11858 __bindgen_bitfield_unit
11859 }
11860}
11861#[doc = " Represents an iterator used for iterating through the EID cache table entries.\n\n To initialize the iterator and start from the first entry in the cache table, set all its fields in the structure to\n zero (e.g., `memset` the iterator to zero)."]
11862#[repr(C)]
11863#[derive(Debug, Copy, Clone)]
11864pub struct otCacheEntryIterator {
11865 #[doc = "< Opaque data used by the core implementation. Should not be changed by user."]
11866 pub mData: [*const ::std::os::raw::c_void; 2usize],
11867}
11868impl Default for otCacheEntryIterator {
11869 fn default() -> Self {
11870 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11871 unsafe {
11872 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11873 s.assume_init()
11874 }
11875 }
11876}
11877extern "C" {
11878 #[doc = " Gets the maximum number of children currently allowed.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The maximum number of children currently allowed.\n\n @sa otThreadSetMaxAllowedChildren"]
11879 pub fn otThreadGetMaxAllowedChildren(aInstance: *mut otInstance) -> u16;
11880}
11881extern "C" {
11882 #[doc = " Sets the maximum number of children currently allowed.\n\n This parameter can only be set when Thread protocol operation has been stopped.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMaxChildren The maximum allowed children.\n\n @retval OT_ERROR_NONE Successfully set the max.\n @retval OT_ERROR_INVALID_ARGS If @p aMaxChildren is not in the range [1, OPENTHREAD_CONFIG_MLE_MAX_CHILDREN].\n @retval OT_ERROR_INVALID_STATE If Thread isn't stopped.\n\n @sa otThreadGetMaxAllowedChildren"]
11883 pub fn otThreadSetMaxAllowedChildren(aInstance: *mut otInstance, aMaxChildren: u16) -> otError;
11884}
11885extern "C" {
11886 #[doc = " Indicates whether or not the device is router-eligible.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval TRUE If device is router-eligible.\n @retval FALSE If device is not router-eligible."]
11887 pub fn otThreadIsRouterEligible(aInstance: *mut otInstance) -> bool;
11888}
11889extern "C" {
11890 #[doc = " Sets whether or not the device is router-eligible.\n\n If @p aEligible is false and the device is currently operating as a router, this call will cause the device to\n detach and attempt to reattach as a child.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEligible TRUE to configure the device as router-eligible, FALSE otherwise.\n\n @retval OT_ERROR_NONE Successfully set the router-eligible configuration.\n @retval OT_ERROR_NOT_CAPABLE The device is not capable of becoming a router."]
11891 pub fn otThreadSetRouterEligible(aInstance: *mut otInstance, aEligible: bool) -> otError;
11892}
11893extern "C" {
11894 #[doc = " Set the preferred Router Id.\n\n Upon becoming a router/leader the node attempts to use this Router Id. If the preferred Router Id is not set or if\n it can not be used, a randomly generated router id is picked. This property can be set only when the device role is\n either detached or disabled.\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] aRouterId The preferred Router Id.\n\n @retval OT_ERROR_NONE Successfully set the preferred Router Id.\n @retval OT_ERROR_INVALID_STATE Could not set (role is not detached or disabled)"]
11895 pub fn otThreadSetPreferredRouterId(aInstance: *mut otInstance, aRouterId: u8) -> otError;
11896}
11897#[doc = "< Battery powered."]
11898pub const OT_POWER_SUPPLY_BATTERY: otPowerSupply = 0;
11899#[doc = "< Externally powered (mains-powered)."]
11900pub const OT_POWER_SUPPLY_EXTERNAL: otPowerSupply = 1;
11901#[doc = "< Stable external power with a battery backup or UPS."]
11902pub const OT_POWER_SUPPLY_EXTERNAL_STABLE: otPowerSupply = 2;
11903#[doc = "< Potentially unstable ext power (e.g. light bulb powered via a switch)."]
11904pub const OT_POWER_SUPPLY_EXTERNAL_UNSTABLE: otPowerSupply = 3;
11905#[doc = " Represents the power supply property on a device.\n\n This is used as a property in `otDeviceProperties` to calculate the leader weight."]
11906pub type otPowerSupply = ::std::os::raw::c_uint;
11907#[doc = " Represents the device properties which are used for calculating the local leader weight on a\n device.\n\n The parameters are set based on device's capability, whether acting as border router, its power supply config, etc.\n\n `mIsUnstable` indicates operational stability of device and is determined via a vendor specific mechanism. It can\n include the following cases:\n - Device internally detects that it loses external power supply more often than usual. What is usual is\n determined by the vendor.\n - Device internally detects that it reboots more often than usual. What is usual is determined by the vendor."]
11908#[repr(C)]
11909#[derive(Debug, Copy, Clone)]
11910pub struct otDeviceProperties {
11911 #[doc = "< Power supply config."]
11912 pub mPowerSupply: otPowerSupply,
11913 pub _bitfield_align_1: [u8; 0],
11914 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
11915 #[doc = "< Weight adjustment. Should be -16 to +16 (clamped otherwise)."]
11916 pub mLeaderWeightAdjustment: i8,
11917}
11918impl Default for otDeviceProperties {
11919 fn default() -> Self {
11920 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11921 unsafe {
11922 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11923 s.assume_init()
11924 }
11925 }
11926}
11927impl otDeviceProperties {
11928 #[inline]
11929 pub fn mIsBorderRouter(&self) -> bool {
11930 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
11931 }
11932 #[inline]
11933 pub fn set_mIsBorderRouter(&mut self, val: bool) {
11934 unsafe {
11935 let val: u8 = ::std::mem::transmute(val);
11936 self._bitfield_1.set(0usize, 1u8, val as u64)
11937 }
11938 }
11939 #[inline]
11940 pub fn mSupportsCcm(&self) -> bool {
11941 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
11942 }
11943 #[inline]
11944 pub fn set_mSupportsCcm(&mut self, val: bool) {
11945 unsafe {
11946 let val: u8 = ::std::mem::transmute(val);
11947 self._bitfield_1.set(1usize, 1u8, val as u64)
11948 }
11949 }
11950 #[inline]
11951 pub fn mIsUnstable(&self) -> bool {
11952 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
11953 }
11954 #[inline]
11955 pub fn set_mIsUnstable(&mut self, val: bool) {
11956 unsafe {
11957 let val: u8 = ::std::mem::transmute(val);
11958 self._bitfield_1.set(2usize, 1u8, val as u64)
11959 }
11960 }
11961 #[inline]
11962 pub fn new_bitfield_1(
11963 mIsBorderRouter: bool,
11964 mSupportsCcm: bool,
11965 mIsUnstable: bool,
11966 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
11967 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
11968 __bindgen_bitfield_unit.set(0usize, 1u8, {
11969 let mIsBorderRouter: u8 = unsafe { ::std::mem::transmute(mIsBorderRouter) };
11970 mIsBorderRouter as u64
11971 });
11972 __bindgen_bitfield_unit.set(1usize, 1u8, {
11973 let mSupportsCcm: u8 = unsafe { ::std::mem::transmute(mSupportsCcm) };
11974 mSupportsCcm as u64
11975 });
11976 __bindgen_bitfield_unit.set(2usize, 1u8, {
11977 let mIsUnstable: u8 = unsafe { ::std::mem::transmute(mIsUnstable) };
11978 mIsUnstable as u64
11979 });
11980 __bindgen_bitfield_unit
11981 }
11982}
11983extern "C" {
11984 #[doc = " Get the current device properties.\n\n Requires `OPENTHREAD_CONFIG_MLE_DEVICE_PROPERTY_LEADER_WEIGHT_ENABLE`.\n\n @returns The device properties `otDeviceProperties`."]
11985 pub fn otThreadGetDeviceProperties(aInstance: *mut otInstance) -> *const otDeviceProperties;
11986}
11987extern "C" {
11988 #[doc = " Set the device properties which are then used to determine and set the Leader Weight.\n\n Requires `OPENTHREAD_CONFIG_MLE_DEVICE_PROPERTY_LEADER_WEIGHT_ENABLE`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDeviceProperties The device properties."]
11989 pub fn otThreadSetDeviceProperties(
11990 aInstance: *mut otInstance,
11991 aDeviceProperties: *const otDeviceProperties,
11992 );
11993}
11994extern "C" {
11995 #[doc = " Gets the Thread Leader Weight used when operating in the Leader role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Thread Leader Weight value.\n\n @sa otThreadSetLeaderWeight\n @sa otThreadSetDeviceProperties"]
11996 pub fn otThreadGetLocalLeaderWeight(aInstance: *mut otInstance) -> u8;
11997}
11998extern "C" {
11999 #[doc = " Sets the Thread Leader Weight used when operating in the Leader role.\n\n Directly sets the Leader Weight to the new value, replacing its previous value (which may have been\n determined from the current `otDeviceProperties`).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aWeight The Thread Leader Weight value.\n\n @sa otThreadGetLeaderWeight"]
12000 pub fn otThreadSetLocalLeaderWeight(aInstance: *mut otInstance, aWeight: u8);
12001}
12002extern "C" {
12003 #[doc = " Get the preferred Thread Leader Partition Id used when operating in the Leader role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Thread Leader Partition Id value."]
12004 pub fn otThreadGetPreferredLeaderPartitionId(aInstance: *mut otInstance) -> u32;
12005}
12006extern "C" {
12007 #[doc = " Set the preferred Thread Leader Partition Id used when operating in the Leader role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPartitionId The Thread Leader Partition Id value."]
12008 pub fn otThreadSetPreferredLeaderPartitionId(aInstance: *mut otInstance, aPartitionId: u32);
12009}
12010extern "C" {
12011 #[doc = " Gets the Joiner UDP Port.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Joiner UDP Port number.\n\n @sa otThreadSetJoinerUdpPort"]
12012 pub fn otThreadGetJoinerUdpPort(aInstance: *mut otInstance) -> u16;
12013}
12014extern "C" {
12015 #[doc = " Sets the Joiner UDP Port.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aJoinerUdpPort The Joiner UDP Port number.\n\n @retval OT_ERROR_NONE Successfully set the Joiner UDP Port.\n\n @sa otThreadGetJoinerUdpPort"]
12016 pub fn otThreadSetJoinerUdpPort(aInstance: *mut otInstance, aJoinerUdpPort: u16) -> otError;
12017}
12018extern "C" {
12019 #[doc = " Set Steering data out of band.\n\n Configuration option `OPENTHREAD_CONFIG_MLE_STEERING_DATA_SET_OOB_ENABLE` should be set to enable setting of steering\n data out of band.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aExtAddress Address used to update the steering data.\n All zeros to clear the steering data (no steering data).\n All 0xFFs to set steering data/bloom filter to accept/allow all.\n A specific EUI64 which is then added to current steering data/bloom filter."]
12020 pub fn otThreadSetSteeringData(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
12021}
12022extern "C" {
12023 #[doc = " Get the CONTEXT_ID_REUSE_DELAY parameter used in the Leader role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The CONTEXT_ID_REUSE_DELAY value.\n\n @sa otThreadSetContextIdReuseDelay"]
12024 pub fn otThreadGetContextIdReuseDelay(aInstance: *mut otInstance) -> u32;
12025}
12026extern "C" {
12027 #[doc = " Set the CONTEXT_ID_REUSE_DELAY parameter used in the Leader role.\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] aDelay The CONTEXT_ID_REUSE_DELAY value.\n\n @sa otThreadGetContextIdReuseDelay"]
12028 pub fn otThreadSetContextIdReuseDelay(aInstance: *mut otInstance, aDelay: u32);
12029}
12030extern "C" {
12031 #[doc = " Get the `NETWORK_ID_TIMEOUT` parameter.\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\n @returns The `NETWORK_ID_TIMEOUT` value.\n\n @sa otThreadSetNetworkIdTimeout"]
12032 pub fn otThreadGetNetworkIdTimeout(aInstance: *mut otInstance) -> u8;
12033}
12034extern "C" {
12035 #[doc = " Set the `NETWORK_ID_TIMEOUT` parameter.\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] aTimeout The `NETWORK_ID_TIMEOUT` value.\n\n @sa otThreadGetNetworkIdTimeout"]
12036 pub fn otThreadSetNetworkIdTimeout(aInstance: *mut otInstance, aTimeout: u8);
12037}
12038extern "C" {
12039 #[doc = " Get the ROUTER_UPGRADE_THRESHOLD parameter used in the REED role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The ROUTER_UPGRADE_THRESHOLD value.\n\n @sa otThreadSetRouterUpgradeThreshold"]
12040 pub fn otThreadGetRouterUpgradeThreshold(aInstance: *mut otInstance) -> u8;
12041}
12042extern "C" {
12043 #[doc = " Set the ROUTER_UPGRADE_THRESHOLD parameter used in the Leader role.\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] aThreshold The ROUTER_UPGRADE_THRESHOLD value.\n\n @sa otThreadGetRouterUpgradeThreshold"]
12044 pub fn otThreadSetRouterUpgradeThreshold(aInstance: *mut otInstance, aThreshold: u8);
12045}
12046extern "C" {
12047 #[doc = " Get the MLE_CHILD_ROUTER_LINKS parameter used in the REED role.\n\n This parameter specifies the max number of neighboring routers with which the device (as an FED)\n will try to establish link.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The MLE_CHILD_ROUTER_LINKS value.\n\n @sa otThreadSetChildRouterLinks"]
12048 pub fn otThreadGetChildRouterLinks(aInstance: *mut otInstance) -> u8;
12049}
12050extern "C" {
12051 #[doc = " Set the MLE_CHILD_ROUTER_LINKS parameter used in the REED role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChildRouterLinks The MLE_CHILD_ROUTER_LINKS value.\n\n @retval OT_ERROR_NONE Successfully set the value.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otThreadGetChildRouterLinks"]
12052 pub fn otThreadSetChildRouterLinks(
12053 aInstance: *mut otInstance,
12054 aChildRouterLinks: u8,
12055 ) -> otError;
12056}
12057extern "C" {
12058 #[doc = " Release a Router ID that has been allocated by the device in the Leader role.\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] aRouterId The Router ID to release. Valid range is [0, 62].\n\n @retval OT_ERROR_NONE Successfully released the router id.\n @retval OT_ERROR_INVALID_ARGS @p aRouterId is not in the range [0, 62].\n @retval OT_ERROR_INVALID_STATE The device is not currently operating as a leader.\n @retval OT_ERROR_NOT_FOUND The router id is not currently allocated."]
12059 pub fn otThreadReleaseRouterId(aInstance: *mut otInstance, aRouterId: u8) -> otError;
12060}
12061extern "C" {
12062 #[doc = " Attempt to become a router.\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\n @retval OT_ERROR_NONE Successfully begin attempt to become a router.\n @retval OT_ERROR_INVALID_STATE Thread is disabled."]
12063 pub fn otThreadBecomeRouter(aInstance: *mut otInstance) -> otError;
12064}
12065extern "C" {
12066 #[doc = " Become a leader and start a new partition.\n\n If the device is not attached, this API will force the device to start as the leader of the network. This use case\n is only intended for testing and demo purposes, and using the API while the device is detached can make a production\n application non-compliant with the Thread Specification.\n\n If the device is already attached, this API can be used to try to take over as the leader, creating a new partition.\n For this to work, the local leader weight (`otThreadGetLocalLeaderWeight()`) must be larger than the weight of the\n current leader (`otThreadGetLeaderWeight()`). If it is not, `OT_ERROR_NOT_CAPABLE` is returned to indicate to the\n caller that they need to adjust the weight.\n\n Taking over the leader role in this way is only allowed when triggered by an explicit user action. Using this API\n without such user action can make a production application non-compliant with the Thread Specification.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @retval OT_ERROR_NONE Successfully became a leader and started a new partition, or was leader already.\n @retval OT_ERROR_INVALID_STATE Thread is disabled.\n @retval OT_ERROR_NOT_CAPABLE Device cannot override the current leader due to its local leader weight being same\n or smaller than current leader's weight, or device is not router eligible."]
12067 pub fn otThreadBecomeLeader(aInstance: *mut otInstance) -> otError;
12068}
12069extern "C" {
12070 #[doc = " Get the ROUTER_DOWNGRADE_THRESHOLD parameter used in the Router role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The ROUTER_DOWNGRADE_THRESHOLD value.\n\n @sa otThreadSetRouterDowngradeThreshold"]
12071 pub fn otThreadGetRouterDowngradeThreshold(aInstance: *mut otInstance) -> u8;
12072}
12073extern "C" {
12074 #[doc = " Set the ROUTER_DOWNGRADE_THRESHOLD parameter used in the Leader role.\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] aThreshold The ROUTER_DOWNGRADE_THRESHOLD value.\n\n @sa otThreadGetRouterDowngradeThreshold"]
12075 pub fn otThreadSetRouterDowngradeThreshold(aInstance: *mut otInstance, aThreshold: u8);
12076}
12077extern "C" {
12078 #[doc = " Get the ROUTER_SELECTION_JITTER parameter used in the REED/Router role.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The ROUTER_SELECTION_JITTER value.\n\n @sa otThreadSetRouterSelectionJitter"]
12079 pub fn otThreadGetRouterSelectionJitter(aInstance: *mut otInstance) -> u8;
12080}
12081extern "C" {
12082 #[doc = " Set the ROUTER_SELECTION_JITTER parameter used in the REED/Router role.\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] aRouterJitter The ROUTER_SELECTION_JITTER value.\n\n @sa otThreadGetRouterSelectionJitter"]
12083 pub fn otThreadSetRouterSelectionJitter(aInstance: *mut otInstance, aRouterJitter: u8);
12084}
12085extern "C" {
12086 #[doc = " Gets diagnostic information for an attached Child by its Child ID or RLOC16.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChildId The Child ID or RLOC16 for the attached child.\n @param[out] aChildInfo A pointer to where the child information is placed.\n\n @retval OT_ERROR_NONE @p aChildInfo was successfully updated with the info for the given ID.\n @retval OT_ERROR_NOT_FOUND No valid child with this Child ID.\n @retval OT_ERROR_INVALID_ARGS If @p aChildInfo is NULL."]
12087 pub fn otThreadGetChildInfoById(
12088 aInstance: *mut otInstance,
12089 aChildId: u16,
12090 aChildInfo: *mut otChildInfo,
12091 ) -> otError;
12092}
12093extern "C" {
12094 #[doc = " The function retains diagnostic information for an attached Child by the internal table index.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChildIndex The table index.\n @param[out] aChildInfo A pointer to where the child information is placed.\n\n @retval OT_ERROR_NONE @p aChildInfo was successfully updated with the info for the given index.\n @retval OT_ERROR_NOT_FOUND No valid child at this index.\n @retval OT_ERROR_INVALID_ARGS Either @p aChildInfo is NULL, or @p aChildIndex is out of range (higher\n than max table index).\n\n @sa otGetMaxAllowedChildren"]
12095 pub fn otThreadGetChildInfoByIndex(
12096 aInstance: *mut otInstance,
12097 aChildIndex: u16,
12098 aChildInfo: *mut otChildInfo,
12099 ) -> otError;
12100}
12101extern "C" {
12102 #[doc = " Gets the next IPv6 address (using an iterator) for a given child.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChildIndex The child index.\n @param[in,out] aIterator A pointer to the iterator. On success the iterator will be updated to point to next\n entry in the list. To get the first IPv6 address the iterator should be set to\n OT_CHILD_IP6_ADDRESS_ITERATOR_INIT.\n @param[out] aAddress A pointer to an IPv6 address where the child's next address is placed (on success).\n\n @retval OT_ERROR_NONE Successfully found the next IPv6 address (@p aAddress was successfully updated).\n @retval OT_ERROR_NOT_FOUND The child has no subsequent IPv6 address entry.\n @retval OT_ERROR_INVALID_ARGS @p aIterator or @p aAddress are NULL, or child at @p aChildIndex is not valid.\n\n @sa otThreadGetChildInfoByIndex"]
12103 pub fn otThreadGetChildNextIp6Address(
12104 aInstance: *mut otInstance,
12105 aChildIndex: u16,
12106 aIterator: *mut otChildIp6AddressIterator,
12107 aAddress: *mut otIp6Address,
12108 ) -> otError;
12109}
12110extern "C" {
12111 #[doc = " Get the current Router ID Sequence.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Router ID Sequence."]
12112 pub fn otThreadGetRouterIdSequence(aInstance: *mut otInstance) -> u8;
12113}
12114extern "C" {
12115 #[doc = " The function returns the maximum allowed router ID\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The maximum allowed router ID."]
12116 pub fn otThreadGetMaxRouterId(aInstance: *mut otInstance) -> u8;
12117}
12118extern "C" {
12119 #[doc = " The function retains diagnostic information for a given Thread Router.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aRouterId The router ID or RLOC16 for a given router.\n @param[out] aRouterInfo A pointer to where the router information is placed.\n\n @retval OT_ERROR_NONE Successfully retrieved the router info for given id.\n @retval OT_ERROR_NOT_FOUND No router entry with the given id.\n @retval OT_ERROR_INVALID_ARGS @p aRouterInfo is NULL."]
12120 pub fn otThreadGetRouterInfo(
12121 aInstance: *mut otInstance,
12122 aRouterId: u16,
12123 aRouterInfo: *mut otRouterInfo,
12124 ) -> otError;
12125}
12126extern "C" {
12127 #[doc = " Gets the next EID cache entry (using an iterator).\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aEntryInfo A pointer to where the EID cache entry information is placed.\n @param[in,out] aIterator A pointer to an iterator. It will be updated to point to next entry on success. To get\n the first entry, initialize the iterator by setting all its fields to zero\n (e.g., `memset` the iterator structure to zero).\n\n @retval OT_ERROR_NONE Successfully populated @p aEntryInfo for next EID cache entry.\n @retval OT_ERROR_NOT_FOUND No more entries in the address cache table."]
12128 pub fn otThreadGetNextCacheEntry(
12129 aInstance: *mut otInstance,
12130 aEntryInfo: *mut otCacheEntryInfo,
12131 aIterator: *mut otCacheEntryIterator,
12132 ) -> otError;
12133}
12134extern "C" {
12135 #[doc = " Get the Thread PSKc\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aPskc A pointer to an `otPskc` to return the retrieved Thread PSKc.\n\n @sa otThreadSetPskc"]
12136 pub fn otThreadGetPskc(aInstance: *mut otInstance, aPskc: *mut otPskc);
12137}
12138extern "C" {
12139 #[doc = " Get Key Reference to Thread PSKc stored\n\n Requires the build-time feature `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` to be enabled.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns Key Reference to PSKc\n\n @sa otThreadSetPskcRef"]
12140 pub fn otThreadGetPskcRef(aInstance: *mut otInstance) -> otPskcRef;
12141}
12142extern "C" {
12143 #[doc = " Set the Thread PSKc\n\n Will only succeed when Thread protocols are disabled. A successful\n call to this function will also invalidate the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aPskc A pointer to the new Thread PSKc.\n\n @retval OT_ERROR_NONE Successfully set the Thread PSKc.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otThreadGetPskc"]
12144 pub fn otThreadSetPskc(aInstance: *mut otInstance, aPskc: *const otPskc) -> otError;
12145}
12146extern "C" {
12147 #[doc = " Set the Key Reference to the Thread PSKc\n\n Requires the build-time feature `OPENTHREAD_CONFIG_PLATFORM_KEY_REFERENCES_ENABLE` to be enabled.\n\n Will only succeed when Thread protocols are disabled. Upon success,\n this will also invalidate the Active and Pending Operational Datasets in\n non-volatile memory.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aKeyRef Key Reference to the new Thread PSKc.\n\n @retval OT_ERROR_NONE Successfully set the Thread PSKc.\n @retval OT_ERROR_INVALID_STATE Thread protocols are enabled.\n\n @sa otThreadGetPskcRef"]
12148 pub fn otThreadSetPskcRef(aInstance: *mut otInstance, aKeyRef: otPskcRef) -> otError;
12149}
12150extern "C" {
12151 #[doc = " Get the assigned parent priority.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The assigned parent priority value, -2 means not assigned.\n\n @sa otThreadSetParentPriority"]
12152 pub fn otThreadGetParentPriority(aInstance: *mut otInstance) -> i8;
12153}
12154extern "C" {
12155 #[doc = " Set the parent priority.\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] aParentPriority The parent priority value.\n\n @retval OT_ERROR_NONE Successfully set the parent priority.\n @retval OT_ERROR_INVALID_ARGS If the parent priority value is not among 1, 0, -1 and -2.\n\n @sa otThreadGetParentPriority"]
12156 pub fn otThreadSetParentPriority(aInstance: *mut otInstance, aParentPriority: i8) -> otError;
12157}
12158extern "C" {
12159 #[doc = " Gets the maximum number of IP addresses that each MTD child may register with this device as parent.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The maximum number of IP addresses that each MTD child may register with this device as parent.\n\n @sa otThreadSetMaxChildIpAddresses"]
12160 pub fn otThreadGetMaxChildIpAddresses(aInstance: *mut otInstance) -> u8;
12161}
12162extern "C" {
12163 #[doc = " Sets or restores the maximum number of IP addresses that each MTD child may register with this\n device as parent.\n\n Pass `0` to clear the setting and restore the default.\n\n Available when `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` is enabled.\n\n @note Only used by Thread Test Harness to limit the address registrations of the reference\n parent in order to test the MTD DUT reaction.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMaxIpAddresses The maximum number of IP addresses that each MTD child may register with this\n device as parent. 0 to clear the setting and restore the default.\n\n @retval OT_ERROR_NONE Successfully set/cleared the number.\n @retval OT_ERROR_INVALID_ARGS If exceeds the allowed maximum number.\n\n @sa otThreadGetMaxChildIpAddresses"]
12164 pub fn otThreadSetMaxChildIpAddresses(
12165 aInstance: *mut otInstance,
12166 aMaxIpAddresses: u8,
12167 ) -> otError;
12168}
12169#[doc = "< A child is being added."]
12170pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_ADDED: otNeighborTableEvent = 0;
12171#[doc = "< A child is being removed."]
12172pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_REMOVED: otNeighborTableEvent = 1;
12173#[doc = "< An existing child's mode is changed."]
12174pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_MODE_CHANGED: otNeighborTableEvent = 2;
12175#[doc = "< A router is being added."]
12176pub const OT_NEIGHBOR_TABLE_EVENT_ROUTER_ADDED: otNeighborTableEvent = 3;
12177#[doc = "< A router is being removed."]
12178pub const OT_NEIGHBOR_TABLE_EVENT_ROUTER_REMOVED: otNeighborTableEvent = 4;
12179#[doc = " Defines the constants used in `otNeighborTableCallback` to indicate changes in neighbor table."]
12180pub type otNeighborTableEvent = ::std::os::raw::c_uint;
12181#[doc = " Represent a neighbor table entry info (child or router) and is used as a parameter in the neighbor table\n callback `otNeighborTableCallback`."]
12182#[repr(C)]
12183#[derive(Copy, Clone)]
12184pub struct otNeighborTableEntryInfo {
12185 #[doc = "< The OpenThread instance."]
12186 pub mInstance: *mut otInstance,
12187 pub mInfo: otNeighborTableEntryInfo__bindgen_ty_1,
12188}
12189#[repr(C)]
12190#[derive(Copy, Clone)]
12191pub union otNeighborTableEntryInfo__bindgen_ty_1 {
12192 #[doc = "< The child neighbor info."]
12193 pub mChild: otChildInfo,
12194 #[doc = "< The router neighbor info."]
12195 pub mRouter: otNeighborInfo,
12196}
12197impl Default for otNeighborTableEntryInfo__bindgen_ty_1 {
12198 fn default() -> Self {
12199 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12200 unsafe {
12201 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12202 s.assume_init()
12203 }
12204 }
12205}
12206impl Default for otNeighborTableEntryInfo {
12207 fn default() -> Self {
12208 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12209 unsafe {
12210 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12211 s.assume_init()
12212 }
12213 }
12214}
12215#[doc = " Pointer is called to notify that there is a change in the neighbor table.\n\n @param[in] aEvent A event flag.\n @param[in] aEntryInfo A pointer to table entry info."]
12216pub type otNeighborTableCallback = ::std::option::Option<
12217 unsafe extern "C" fn(aEvent: otNeighborTableEvent, aEntryInfo: *const otNeighborTableEntryInfo),
12218>;
12219extern "C" {
12220 #[doc = " Registers a neighbor table callback function.\n\n The provided callback (if non-NULL) will be invoked when there is a change in the neighbor table (e.g., a child or a\n router neighbor entry is being added/removed or an existing child's mode is changed).\n\n Subsequent calls to this method will overwrite the previous callback. Note that this callback in invoked while the\n neighbor/child table is being updated and always before the `otStateChangedCallback`.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback A pointer to callback handler function."]
12221 pub fn otThreadRegisterNeighborTableCallback(
12222 aInstance: *mut otInstance,
12223 aCallback: otNeighborTableCallback,
12224 );
12225}
12226extern "C" {
12227 #[doc = " Sets whether the device was commissioned using CCM.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is only used by Thread Test Harness\n to indicate whether this device was commissioned using CCM.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE if the device was commissioned using CCM, FALSE otherwise."]
12228 pub fn otThreadSetCcmEnabled(aInstance: *mut otInstance, aEnabled: bool);
12229}
12230extern "C" {
12231 #[doc = " Sets whether the Security Policy TLV version-threshold for routing (VR field) is enabled.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is only used by Thread Test Harness\n to indicate that thread protocol version check VR should be skipped.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE to enable Security Policy TLV version-threshold for routing, FALSE otherwise."]
12232 pub fn otThreadSetThreadVersionCheckEnabled(aInstance: *mut otInstance, aEnabled: bool);
12233}
12234extern "C" {
12235 #[doc = " Enables or disables the filter to drop TMF UDP messages from untrusted origin.\n\n TMF messages are only trusted when they originate from a trusted source, such as the Thread interface. In\n special cases, such as when a device uses platform UDP socket to send TMF messages, they will be dropped due\n to untrusted origin. This filter is enabled by default.\n\n When this filter is disabled, UDP messages sent to the TMF port that originate from untrusted origin (such as\n host, CLI or an external IPv6 node) will be allowed.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE` and is only used by Thread Test Harness\n to test network behavior by sending special TMF messages from the CLI on a POSIX host.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnabled TRUE to enable filter, FALSE otherwise."]
12236 pub fn otThreadSetTmfOriginFilterEnabled(aInstance: *mut otInstance, aEnabled: bool);
12237}
12238extern "C" {
12239 #[doc = " Indicates whether the filter that drops TMF UDP messages from untrusted origin 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 @retval TRUE The filter is enabled.\n @retval FALSE The filter is not enabled."]
12240 pub fn otThreadIsTmfOriginFilterEnabled(aInstance: *mut otInstance) -> bool;
12241}
12242extern "C" {
12243 #[doc = " Gets the range of router IDs that are allowed to assign to nodes within the thread network.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is only used for test purpose. All the\n router IDs in the range [aMinRouterId, aMaxRouterId] are allowed.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[out] aMinRouterId The minimum router ID.\n @param[out] aMaxRouterId The maximum router ID.\n\n @sa otThreadSetRouterIdRange"]
12244 pub fn otThreadGetRouterIdRange(
12245 aInstance: *mut otInstance,
12246 aMinRouterId: *mut u8,
12247 aMaxRouterId: *mut u8,
12248 );
12249}
12250extern "C" {
12251 #[doc = " Sets the range of router IDs that are allowed to assign to nodes within the thread network.\n\n @note This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is only used for test purpose. All the\n router IDs in the range [aMinRouterId, aMaxRouterId] are allowed.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aMinRouterId The minimum router ID.\n @param[in] aMaxRouterId The maximum router ID.\n\n @retval OT_ERROR_NONE Successfully set the range.\n @retval OT_ERROR_INVALID_ARGS aMinRouterId > aMaxRouterId, or the range is not covered by [0, 62].\n\n @sa otThreadGetRouterIdRange"]
12252 pub fn otThreadSetRouterIdRange(
12253 aInstance: *mut otInstance,
12254 aMinRouterId: u8,
12255 aMaxRouterId: u8,
12256 ) -> otError;
12257}
12258extern "C" {
12259 #[doc = " Gets the current Interval Max value used by Advertisement trickle timer.\n\n This API requires `OPENTHREAD_CONFIG_REFERENCE_DEVICE_ENABLE`, and is intended for testing only.\n\n @returns The Interval Max of Advertisement trickle timer in milliseconds."]
12260 pub fn otThreadGetAdvertisementTrickleIntervalMax(aInstance: *mut otInstance) -> u32;
12261}
12262extern "C" {
12263 #[doc = " Indicates whether or not a Router ID is currently allocated.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aRouterId The router ID to check.\n\n @retval TRUE The @p aRouterId is allocated.\n @retval FALSE The @p aRouterId is not allocated."]
12264 pub fn otThreadIsRouterIdAllocated(aInstance: *mut otInstance, aRouterId: u8) -> bool;
12265}
12266extern "C" {
12267 #[doc = " Gets the next hop and path cost towards a given RLOC16 destination.\n\n Can be used with either @p aNextHopRloc16 or @p aPathCost being NULL indicating caller does not want\n to get the value.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aDestRloc16 The RLOC16 of destination.\n @param[out] aNextHopRloc16 A pointer to return RLOC16 of next hop, 0xfffe if no next hop.\n @param[out] aPathCost A pointer to return path cost towards destination."]
12268 pub fn otThreadGetNextHopAndPathCost(
12269 aInstance: *mut otInstance,
12270 aDestRloc16: u16,
12271 aNextHopRloc16: *mut u16,
12272 aPathCost: *mut u8,
12273 );
12274}
12275#[doc = " Represents a TREL peer."]
12276#[repr(C)]
12277#[derive(Copy, Clone)]
12278pub struct otTrelPeer {
12279 #[doc = "< The Extended MAC Address of TREL peer."]
12280 pub mExtAddress: otExtAddress,
12281 #[doc = "< The Extended PAN Identifier of TREL peer."]
12282 pub mExtPanId: otExtendedPanId,
12283 #[doc = "< The IPv6 socket address of TREL peer."]
12284 pub mSockAddr: otSockAddr,
12285}
12286impl Default for otTrelPeer {
12287 fn default() -> Self {
12288 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12289 unsafe {
12290 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12291 s.assume_init()
12292 }
12293 }
12294}
12295#[doc = " Represents an iterator for iterating over TREL peer table entries."]
12296pub type otTrelPeerIterator = u16;
12297extern "C" {
12298 #[doc = " Enables or disables TREL operation.\n\n When @p aEnable is true, this function initiates an ongoing DNS-SD browse on the service name \"_trel._udp\" within the\n local browsing domain to discover other devices supporting TREL. Device also registers a new service to be advertised\n using DNS-SD, with the service name is \"_trel._udp\" indicating its support for TREL. Device is then ready to receive\n TREL messages from peers.\n\n When @p aEnable is false, this function stops the DNS-SD browse on the service name \"_trel._udp\", stops advertising\n TREL DNS-SD service, and clears the TREL peer table.\n\n @note By default the OpenThread stack enables the TREL operation on start.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aEnable A boolean to enable/disable the TREL operation."]
12299 pub fn otTrelSetEnabled(aInstance: *mut otInstance, aEnable: bool);
12300}
12301extern "C" {
12302 #[doc = " Indicates whether the TREL operation is enabled.\n\n @param[in] aInstance The OpenThread instance.\n\n @retval TRUE if the TREL operation is enabled.\n @retval FALSE if the TREL operation is disabled."]
12303 pub fn otTrelIsEnabled(aInstance: *mut otInstance) -> bool;
12304}
12305extern "C" {
12306 #[doc = " Initializes a peer table iterator.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aIterator The iterator to initialize."]
12307 pub fn otTrelInitPeerIterator(aInstance: *mut otInstance, aIterator: *mut otTrelPeerIterator);
12308}
12309extern "C" {
12310 #[doc = " Iterates over the peer table entries and get the next entry from the table\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aIterator The iterator. MUST be initialized.\n\n @returns A pointer to the next `otTrelPeer` entry or `NULL` if no more entries in the table."]
12311 pub fn otTrelGetNextPeer(
12312 aInstance: *mut otInstance,
12313 aIterator: *mut otTrelPeerIterator,
12314 ) -> *const otTrelPeer;
12315}
12316extern "C" {
12317 #[doc = " Returns the number of TREL peers.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The number of TREL peers."]
12318 pub fn otTrelGetNumberOfPeers(aInstance: *mut otInstance) -> u16;
12319}
12320extern "C" {
12321 #[doc = " Sets the filter mode (enables/disables filtering).\n\n When filter mode is enabled, any rx and tx traffic through TREL interface is silently dropped. This is mainly\n intended for use during testing.\n\n Unlike `otTrel{Enable/Disable}()` which fully starts/stops the TREL operation, when filter mode is enabled the\n TREL interface continues to be enabled.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aFiltered TRUE to enable filter mode, FALSE to disable filter mode."]
12322 pub fn otTrelSetFilterEnabled(aInstance: *mut otInstance, aEnable: bool);
12323}
12324extern "C" {
12325 #[doc = " Indicates whether or not the filter mode is enabled.\n\n @param[in] aInstance The OpenThread instance.\n\n @retval TRUE if the TREL filter mode is enabled.\n @retval FALSE if the TREL filter mode is disabled."]
12326 pub fn otTrelIsFilterEnabled(aInstance: *mut otInstance) -> bool;
12327}
12328#[doc = " Represents a group of TREL related counters in the platform layer."]
12329pub type otTrelCounters = otPlatTrelCounters;
12330extern "C" {
12331 #[doc = " Gets the TREL counters.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns A pointer to the TREL counters."]
12332 pub fn otTrelGetCounters(aInstance: *mut otInstance) -> *const otTrelCounters;
12333}
12334extern "C" {
12335 #[doc = " Resets the TREL counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
12336 pub fn otTrelResetCounters(aInstance: *mut otInstance);
12337}
12338extern "C" {
12339 #[doc = " Gets the UDP port of the TREL interface.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns UDP port of the TREL interface."]
12340 pub fn otTrelGetUdpPort(aInstance: *mut otInstance) -> u16;
12341}
12342pub type __builtin_va_list = [__va_list_tag; 1usize];
12343#[repr(C)]
12344#[derive(Debug, Copy, Clone)]
12345pub struct __va_list_tag {
12346 pub gp_offset: ::std::os::raw::c_uint,
12347 pub fp_offset: ::std::os::raw::c_uint,
12348 pub overflow_arg_area: *mut ::std::os::raw::c_void,
12349 pub reg_save_area: *mut ::std::os::raw::c_void,
12350}
12351impl Default for __va_list_tag {
12352 fn default() -> Self {
12353 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12354 unsafe {
12355 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12356 s.assume_init()
12357 }
12358 }
12359}