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 = 507;
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_DNS_MAX_NAME_SIZE: u32 = 255;
180pub const OT_DNS_MAX_LABEL_SIZE: u32 = 64;
181pub const OT_DNS_TXT_KEY_MIN_LENGTH: u32 = 1;
182pub const OT_DNS_TXT_KEY_MAX_LENGTH: u32 = 9;
183pub const OT_DNS_TXT_KEY_ITER_MAX_LENGTH: u32 = 64;
184pub const OT_BORDER_AGENT_ID_LENGTH: u32 = 16;
185pub const OT_BORDER_AGENT_MESHCOP_SERVICE_TXT_DATA_MAX_LENGTH: u32 = 256;
186pub const OT_BORDER_AGENT_MESHCOP_SERVICE_BASE_NAME_MAX_LENGTH: u32 = 47;
187pub const OT_BORDER_AGENT_MIN_EPHEMERAL_KEY_LENGTH: u32 = 6;
188pub const OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_LENGTH: u32 = 32;
189pub const OT_BORDER_AGENT_DEFAULT_EPHEMERAL_KEY_TIMEOUT: u32 = 120000;
190pub const OT_BORDER_AGENT_MAX_EPHEMERAL_KEY_TIMEOUT: u32 = 600000;
191pub const OT_DEFAULT_COAP_PORT: u32 = 5683;
192pub const OT_COAP_DEFAULT_TOKEN_LENGTH: u32 = 2;
193pub const OT_COAP_MAX_TOKEN_LENGTH: u32 = 8;
194pub const OT_COAP_MAX_RETRANSMIT: u32 = 20;
195pub const OT_COAP_MIN_ACK_TIMEOUT: u32 = 1000;
196pub const OT_DEFAULT_COAP_SECURE_PORT: u32 = 5684;
197pub const OPENTHREAD_LIB_SPINEL_RX_FRAME_BUFFER_SIZE: u32 = 65535;
198pub const OPENTHREAD_POSIX_CONFIG_RCP_TIME_SYNC_INTERVAL: u32 = 60000000;
199pub const OPENTHREAD_SPINEL_CONFIG_ABORT_ON_UNEXPECTED_RCP_RESET_ENABLE: u32 = 0;
200pub const OT_ICMP6_HEADER_DATA_SIZE: u32 = 4;
201pub const OT_ICMP6_ROUTER_ADVERT_MIN_SIZE: u32 = 16;
202pub const OT_MAC_FILTER_FIXED_RSS_DISABLED: u32 = 127;
203pub const OT_MAC_FILTER_ITERATOR_INIT: u32 = 0;
204pub const OT_LINK_CSL_PERIOD_TEN_SYMBOLS_UNIT_IN_USEC: u32 = 160;
205pub const OT_LOG_HEX_DUMP_LINE_SIZE: u32 = 73;
206pub const OT_IP4_ADDRESS_SIZE: u32 = 4;
207pub const OT_IP4_ADDRESS_STRING_SIZE: u32 = 17;
208pub const OT_IP4_CIDR_STRING_SIZE: u32 = 20;
209pub const OT_THREAD_VERSION_INVALID: u32 = 0;
210pub const OT_THREAD_VERSION_1_1: u32 = 2;
211pub const OT_THREAD_VERSION_1_2: u32 = 3;
212pub const OT_THREAD_VERSION_1_3: u32 = 4;
213pub const OT_THREAD_VERSION_1_3_1: u32 = 5;
214pub const OT_THREAD_VERSION_1_4: u32 = 5;
215pub const OT_NETWORK_BASE_TLV_MAX_LENGTH: u32 = 254;
216pub const OT_NETWORK_MAX_ROUTER_ID: u32 = 62;
217pub const OT_NEIGHBOR_INFO_ITERATOR_INIT: u32 = 0;
218pub const OT_JOINER_ADVDATA_MAX_LENGTH: u32 = 64;
219pub const OT_DURATION_STRING_SIZE: u32 = 21;
220pub const OT_NETWORK_DIAGNOSTIC_TLV_EXT_ADDRESS: u32 = 0;
221pub const OT_NETWORK_DIAGNOSTIC_TLV_SHORT_ADDRESS: u32 = 1;
222pub const OT_NETWORK_DIAGNOSTIC_TLV_MODE: u32 = 2;
223pub const OT_NETWORK_DIAGNOSTIC_TLV_TIMEOUT: u32 = 3;
224pub const OT_NETWORK_DIAGNOSTIC_TLV_CONNECTIVITY: u32 = 4;
225pub const OT_NETWORK_DIAGNOSTIC_TLV_ROUTE: u32 = 5;
226pub const OT_NETWORK_DIAGNOSTIC_TLV_LEADER_DATA: u32 = 6;
227pub const OT_NETWORK_DIAGNOSTIC_TLV_NETWORK_DATA: u32 = 7;
228pub const OT_NETWORK_DIAGNOSTIC_TLV_IP6_ADDR_LIST: u32 = 8;
229pub const OT_NETWORK_DIAGNOSTIC_TLV_MAC_COUNTERS: u32 = 9;
230pub const OT_NETWORK_DIAGNOSTIC_TLV_BATTERY_LEVEL: u32 = 14;
231pub const OT_NETWORK_DIAGNOSTIC_TLV_SUPPLY_VOLTAGE: u32 = 15;
232pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD_TABLE: u32 = 16;
233pub const OT_NETWORK_DIAGNOSTIC_TLV_CHANNEL_PAGES: u32 = 17;
234pub const OT_NETWORK_DIAGNOSTIC_TLV_TYPE_LIST: u32 = 18;
235pub const OT_NETWORK_DIAGNOSTIC_TLV_MAX_CHILD_TIMEOUT: u32 = 19;
236pub const OT_NETWORK_DIAGNOSTIC_TLV_EUI64: u32 = 23;
237pub const OT_NETWORK_DIAGNOSTIC_TLV_VERSION: u32 = 24;
238pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_NAME: u32 = 25;
239pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_MODEL: u32 = 26;
240pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_SW_VERSION: u32 = 27;
241pub const OT_NETWORK_DIAGNOSTIC_TLV_THREAD_STACK_VERSION: u32 = 28;
242pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD: u32 = 29;
243pub const OT_NETWORK_DIAGNOSTIC_TLV_CHILD_IP6_ADDR_LIST: u32 = 30;
244pub const OT_NETWORK_DIAGNOSTIC_TLV_ROUTER_NEIGHBOR: u32 = 31;
245pub const OT_NETWORK_DIAGNOSTIC_TLV_ANSWER: u32 = 32;
246pub const OT_NETWORK_DIAGNOSTIC_TLV_QUERY_ID: u32 = 33;
247pub const OT_NETWORK_DIAGNOSTIC_TLV_MLE_COUNTERS: u32 = 34;
248pub const OT_NETWORK_DIAGNOSTIC_TLV_VENDOR_APP_URL: u32 = 35;
249pub const OT_NETWORK_DIAGNOSTIC_TLV_NON_PREFERRED_CHANNELS: u32 = 36;
250pub const OT_NETWORK_DIAGNOSTIC_TLV_ENHANCED_ROUTE: u32 = 37;
251pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_NAME_TLV_LENGTH: u32 = 32;
252pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_MODEL_TLV_LENGTH: u32 = 32;
253pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_SW_VERSION_TLV_LENGTH: u32 = 16;
254pub const OT_NETWORK_DIAGNOSTIC_MAX_THREAD_STACK_VERSION_TLV_LENGTH: u32 = 64;
255pub const OT_NETWORK_DIAGNOSTIC_MAX_VENDOR_APP_URL_TLV_LENGTH: u32 = 96;
256pub const OT_NETWORK_DIAGNOSTIC_ITERATOR_INIT: u32 = 0;
257pub const OT_TIME_SYNC_INVALID_SEQ: u32 = 0;
258pub const OT_PLAT_INFRA_IF_MAX_LINK_LAYER_ADDR_LENGTH: u32 = 16;
259pub const OT_MS_PER_S: u32 = 1000;
260pub const OT_US_PER_MS: u32 = 1000;
261pub const OT_US_PER_S: u32 = 1000000;
262pub const OT_NS_PER_US: u32 = 1000;
263pub const OT_SNTP_DEFAULT_SERVER_IP: &[u8; 19usize] = b"2001:4860:4806:8::\0";
264pub const OT_SNTP_DEFAULT_SERVER_PORT: u32 = 123;
265pub const OT_TCP_ENDPOINT_TCB_SIZE_BASE: u32 = 392;
266pub const OT_TCP_ENDPOINT_TCB_NUM_PTR: u32 = 36;
267pub const OT_TCP_RECEIVE_BUFFER_SIZE_FEW_HOPS: u32 = 2598;
268pub const OT_TCP_RECEIVE_BUFFER_SIZE_MANY_HOPS: u32 = 4157;
269pub const OT_TCP_LISTENER_TCB_SIZE_BASE: u32 = 16;
270pub const OT_TCP_LISTENER_TCB_NUM_PTR: u32 = 3;
271pub const OT_CHILD_IP6_ADDRESS_ITERATOR_INIT: u32 = 0;
272pub const OT_VERHOEFF_CHECKSUM_MAX_STRING_LENGTH: u32 = 128;
273#[doc = " No error."]
274pub const OT_ERROR_NONE: otError = 0;
275#[doc = " Operational failed."]
276pub const OT_ERROR_FAILED: otError = 1;
277#[doc = " Message was dropped."]
278pub const OT_ERROR_DROP: otError = 2;
279#[doc = " Insufficient buffers."]
280pub const OT_ERROR_NO_BUFS: otError = 3;
281#[doc = " No route available."]
282pub const OT_ERROR_NO_ROUTE: otError = 4;
283#[doc = " Service is busy and could not service the operation."]
284pub const OT_ERROR_BUSY: otError = 5;
285#[doc = " Failed to parse message."]
286pub const OT_ERROR_PARSE: otError = 6;
287#[doc = " Input arguments are invalid."]
288pub const OT_ERROR_INVALID_ARGS: otError = 7;
289#[doc = " Security checks failed."]
290pub const OT_ERROR_SECURITY: otError = 8;
291#[doc = " Address resolution requires an address query operation."]
292pub const OT_ERROR_ADDRESS_QUERY: otError = 9;
293#[doc = " Address is not in the source match table."]
294pub const OT_ERROR_NO_ADDRESS: otError = 10;
295#[doc = " Operation was aborted."]
296pub const OT_ERROR_ABORT: otError = 11;
297#[doc = " Function or method is not implemented."]
298pub const OT_ERROR_NOT_IMPLEMENTED: otError = 12;
299#[doc = " Cannot complete due to invalid state."]
300pub const OT_ERROR_INVALID_STATE: otError = 13;
301#[doc = " No acknowledgment was received after macMaxFrameRetries (IEEE 802.15.4-2006)."]
302pub const OT_ERROR_NO_ACK: otError = 14;
303#[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)."]
304pub const OT_ERROR_CHANNEL_ACCESS_FAILURE: otError = 15;
305#[doc = " Not currently attached to a Thread Partition."]
306pub const OT_ERROR_DETACHED: otError = 16;
307#[doc = " FCS check failure while receiving."]
308pub const OT_ERROR_FCS: otError = 17;
309#[doc = " No frame received."]
310pub const OT_ERROR_NO_FRAME_RECEIVED: otError = 18;
311#[doc = " Received a frame from an unknown neighbor."]
312pub const OT_ERROR_UNKNOWN_NEIGHBOR: otError = 19;
313#[doc = " Received a frame from an invalid source address."]
314pub const OT_ERROR_INVALID_SOURCE_ADDRESS: otError = 20;
315#[doc = " Received a frame filtered by the address filter (allowlisted or denylisted)."]
316pub const OT_ERROR_ADDRESS_FILTERED: otError = 21;
317#[doc = " Received a frame filtered by the destination address check."]
318pub const OT_ERROR_DESTINATION_ADDRESS_FILTERED: otError = 22;
319#[doc = " The requested item could not be found."]
320pub const OT_ERROR_NOT_FOUND: otError = 23;
321#[doc = " The operation is already in progress."]
322pub const OT_ERROR_ALREADY: otError = 24;
323#[doc = " The creation of IPv6 address failed."]
324pub const OT_ERROR_IP6_ADDRESS_CREATION_FAILURE: otError = 26;
325#[doc = " Operation prevented by mode flags"]
326pub const OT_ERROR_NOT_CAPABLE: otError = 27;
327#[doc = " Coap response or acknowledgment or DNS, SNTP response not received."]
328pub const OT_ERROR_RESPONSE_TIMEOUT: otError = 28;
329#[doc = " Received a duplicated frame."]
330pub const OT_ERROR_DUPLICATED: otError = 29;
331#[doc = " Message is being dropped from reassembly list due to timeout."]
332pub const OT_ERROR_REASSEMBLY_TIMEOUT: otError = 30;
333#[doc = " Message is not a TMF Message."]
334pub const OT_ERROR_NOT_TMF: otError = 31;
335#[doc = " Received a non-lowpan data frame."]
336pub const OT_ERROR_NOT_LOWPAN_DATA_FRAME: otError = 32;
337#[doc = " The link margin was too low."]
338pub const OT_ERROR_LINK_MARGIN_LOW: otError = 34;
339#[doc = " Input (CLI) command is invalid."]
340pub const OT_ERROR_INVALID_COMMAND: otError = 35;
341#[doc = " Special error code used to indicate success/error status is pending and not yet known."]
342pub const OT_ERROR_PENDING: otError = 36;
343#[doc = " Request rejected."]
344pub const OT_ERROR_REJECTED: otError = 37;
345#[doc = " The number of defined errors."]
346pub const OT_NUM_ERRORS: otError = 38;
347#[doc = " Generic error (should not use)."]
348pub const OT_ERROR_GENERIC: otError = 255;
349#[doc = " Represents error codes used throughout OpenThread."]
350pub type otError = ::std::os::raw::c_uint;
351extern "C" {
352 #[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."]
353 pub fn otThreadErrorToString(aError: otError) -> *const ::std::os::raw::c_char;
354}
355pub type va_list = __builtin_va_list;
356#[doc = " Represents the log level."]
357pub type otLogLevel = ::std::os::raw::c_int;
358#[doc = "< OpenThread API"]
359pub const OT_LOG_REGION_API: otLogRegion = 1;
360#[doc = "< MLE"]
361pub const OT_LOG_REGION_MLE: otLogRegion = 2;
362#[doc = "< EID-to-RLOC mapping."]
363pub const OT_LOG_REGION_ARP: otLogRegion = 3;
364#[doc = "< Network Data"]
365pub const OT_LOG_REGION_NET_DATA: otLogRegion = 4;
366#[doc = "< ICMPv6"]
367pub const OT_LOG_REGION_ICMP: otLogRegion = 5;
368#[doc = "< IPv6"]
369pub const OT_LOG_REGION_IP6: otLogRegion = 6;
370#[doc = "< TCP"]
371pub const OT_LOG_REGION_TCP: otLogRegion = 7;
372#[doc = "< IEEE 802.15.4 MAC"]
373pub const OT_LOG_REGION_MAC: otLogRegion = 8;
374#[doc = "< Memory"]
375pub const OT_LOG_REGION_MEM: otLogRegion = 9;
376#[doc = "< NCP"]
377pub const OT_LOG_REGION_NCP: otLogRegion = 10;
378#[doc = "< Mesh Commissioning Protocol"]
379pub const OT_LOG_REGION_MESH_COP: otLogRegion = 11;
380#[doc = "< Network Diagnostic"]
381pub const OT_LOG_REGION_NET_DIAG: otLogRegion = 12;
382#[doc = "< Platform"]
383pub const OT_LOG_REGION_PLATFORM: otLogRegion = 13;
384#[doc = "< CoAP"]
385pub const OT_LOG_REGION_COAP: otLogRegion = 14;
386#[doc = "< CLI"]
387pub const OT_LOG_REGION_CLI: otLogRegion = 15;
388#[doc = "< OpenThread Core"]
389pub const OT_LOG_REGION_CORE: otLogRegion = 16;
390#[doc = "< Utility module"]
391pub const OT_LOG_REGION_UTIL: otLogRegion = 17;
392#[doc = "< Backbone Router (available since Thread 1.2)"]
393pub const OT_LOG_REGION_BBR: otLogRegion = 18;
394#[doc = "< Multicast Listener Registration (available since Thread 1.2)"]
395pub const OT_LOG_REGION_MLR: otLogRegion = 19;
396#[doc = "< Domain Unicast Address (available since Thread 1.2)"]
397pub const OT_LOG_REGION_DUA: otLogRegion = 20;
398#[doc = "< Border Router"]
399pub const OT_LOG_REGION_BR: otLogRegion = 21;
400#[doc = "< Service Registration Protocol (SRP)"]
401pub const OT_LOG_REGION_SRP: otLogRegion = 22;
402#[doc = "< DNS"]
403pub const OT_LOG_REGION_DNS: otLogRegion = 23;
404#[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`."]
405pub type otLogRegion = ::std::os::raw::c_uint;
406extern "C" {
407 #[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."]
408 pub fn otPlatLog(
409 aLogLevel: otLogLevel,
410 aLogRegion: otLogRegion,
411 aFormat: *const ::std::os::raw::c_char,
412 ...
413 );
414}
415extern "C" {
416 #[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."]
417 pub fn otPlatLogHandleLevelChanged(aLogLevel: otLogLevel);
418}
419#[repr(C)]
420#[derive(Debug, Default, Copy, Clone)]
421pub struct otInstance {
422 _unused: [u8; 0],
423}
424extern "C" {
425 #[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"]
426 pub fn otInstanceInit(
427 aInstanceBuffer: *mut ::std::os::raw::c_void,
428 aInstanceBufferSize: *mut usize,
429 ) -> *mut otInstance;
430}
431extern "C" {
432 #[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."]
433 pub fn otInstanceInitSingle() -> *mut otInstance;
434}
435extern "C" {
436 #[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."]
437 pub fn otInstanceInitMultiple(aIdx: u8) -> *mut otInstance;
438}
439extern "C" {
440 #[doc = " Gets the index of the OpenThread instance when multiple instance is in use.\n\n This function is available when both `OPENTHREAD_CONFIG_MULTIPLE_INSTANCE_ENABLE` and\n `OPENTHREAD_CONFIG_MULTIPLE_STATIC_INSTANCE_ENABLE` are enabled.\n\n @param[in] aInstance The reference of the OpenThread instance to get index.\n\n @returns The index of the OpenThread instance."]
441 pub fn otInstanceGetIndex(aInstance: *mut otInstance) -> u8;
442}
443extern "C" {
444 #[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."]
445 pub fn otInstanceGetId(aInstance: *mut otInstance) -> u32;
446}
447extern "C" {
448 #[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."]
449 pub fn otInstanceIsInitialized(aInstance: *mut otInstance) -> bool;
450}
451extern "C" {
452 #[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."]
453 pub fn otInstanceFinalize(aInstance: *mut otInstance);
454}
455extern "C" {
456 #[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)."]
457 pub fn otInstanceGetUptime(aInstance: *mut otInstance) -> u64;
458}
459extern "C" {
460 #[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`."]
461 pub fn otInstanceGetUptimeAsString(
462 aInstance: *mut otInstance,
463 aBuffer: *mut ::std::os::raw::c_char,
464 aSize: u16,
465 );
466}
467#[doc = " Represents a bit-field indicating specific state/configuration that has changed. See `OT_CHANGED_*`\n definitions."]
468pub type otChangedFlags = u32;
469#[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."]
470pub type otStateChangedCallback = ::std::option::Option<
471 unsafe extern "C" fn(aFlags: otChangedFlags, aContext: *mut ::std::os::raw::c_void),
472>;
473extern "C" {
474 #[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."]
475 pub fn otSetStateChangedCallback(
476 aInstance: *mut otInstance,
477 aCallback: otStateChangedCallback,
478 aContext: *mut ::std::os::raw::c_void,
479 ) -> otError;
480}
481extern "C" {
482 #[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."]
483 pub fn otRemoveStateChangeCallback(
484 aInstance: *mut otInstance,
485 aCallback: otStateChangedCallback,
486 aContext: *mut ::std::os::raw::c_void,
487 );
488}
489extern "C" {
490 #[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."]
491 pub fn otInstanceReset(aInstance: *mut otInstance);
492}
493extern "C" {
494 #[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."]
495 pub fn otInstanceResetToBootloader(aInstance: *mut otInstance) -> otError;
496}
497extern "C" {
498 #[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."]
499 pub fn otInstanceFactoryReset(aInstance: *mut otInstance);
500}
501extern "C" {
502 #[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."]
503 pub fn otInstanceResetRadioStack(aInstance: *mut otInstance);
504}
505extern "C" {
506 #[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."]
507 pub fn otInstanceErasePersistentInfo(aInstance: *mut otInstance) -> otError;
508}
509extern "C" {
510 #[doc = " Gets the OpenThread version string.\n\n @returns A pointer to the OpenThread version."]
511 pub fn otGetVersionString() -> *const ::std::os::raw::c_char;
512}
513extern "C" {
514 #[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."]
515 pub fn otGetRadioVersionString(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
516}
517#[doc = " Represents Backbone Router configuration."]
518#[repr(C)]
519#[derive(Debug, Default, Copy, Clone)]
520pub struct otBackboneRouterConfig {
521 #[doc = "< Only used when get Primary Backbone Router information in the Thread Network"]
522 pub mServer16: u16,
523 #[doc = "< Reregistration Delay (in seconds)"]
524 pub mReregistrationDelay: u16,
525 #[doc = "< Multicast Listener Registration Timeout (in seconds)"]
526 pub mMlrTimeout: u32,
527 #[doc = "< Sequence Number"]
528 pub mSequenceNumber: u8,
529}
530extern "C" {
531 #[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."]
532 pub fn otBackboneRouterGetPrimary(
533 aInstance: *mut otInstance,
534 aConfig: *mut otBackboneRouterConfig,
535 ) -> otError;
536}
537#[repr(C)]
538#[derive(Debug, Default, Copy, Clone)]
539pub struct otMessage {
540 _unused: [u8; 0],
541}
542#[doc = "< Low priority level."]
543pub const OT_MESSAGE_PRIORITY_LOW: otMessagePriority = 0;
544#[doc = "< Normal priority level."]
545pub const OT_MESSAGE_PRIORITY_NORMAL: otMessagePriority = 1;
546#[doc = "< High priority level."]
547pub const OT_MESSAGE_PRIORITY_HIGH: otMessagePriority = 2;
548#[doc = " Defines the OpenThread message priority levels."]
549pub type otMessagePriority = ::std::os::raw::c_uint;
550#[doc = "< Message from Thread Netif."]
551pub const OT_MESSAGE_ORIGIN_THREAD_NETIF: otMessageOrigin = 0;
552#[doc = "< Message from a trusted source on host."]
553pub const OT_MESSAGE_ORIGIN_HOST_TRUSTED: otMessageOrigin = 1;
554#[doc = "< Message from an untrusted source on host."]
555pub const OT_MESSAGE_ORIGIN_HOST_UNTRUSTED: otMessageOrigin = 2;
556#[doc = " Defines the OpenThread message origins."]
557pub type otMessageOrigin = ::std::os::raw::c_uint;
558#[doc = " Represents a message settings."]
559#[repr(C)]
560#[derive(Debug, Default, Copy, Clone)]
561pub struct otMessageSettings {
562 #[doc = "< TRUE if the message should be secured at Layer 2."]
563 pub mLinkSecurityEnabled: bool,
564 #[doc = "< Priority level (MUST be a `OT_MESSAGE_PRIORITY_*` from `otMessagePriority`)."]
565 pub mPriority: u8,
566}
567#[doc = " Represents link-specific information for messages received from the Thread radio."]
568#[repr(C)]
569#[derive(Debug, Default, Copy, Clone)]
570pub struct otThreadLinkInfo {
571 #[doc = "< Source PAN ID"]
572 pub mPanId: u16,
573 #[doc = "< 802.15.4 Channel"]
574 pub mChannel: u8,
575 #[doc = "< Received Signal Strength in dBm (averaged over fragments)"]
576 pub mRss: i8,
577 #[doc = "< Average Link Quality Indicator (averaged over fragments)"]
578 pub mLqi: u8,
579 pub _bitfield_align_1: [u8; 0],
580 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
581 #[doc = "< The time sync sequence."]
582 pub mTimeSyncSeq: u8,
583 #[doc = "< The time offset to the Thread network time, in microseconds."]
584 pub mNetworkTimeOffset: i64,
585 #[doc = "< Radio link type."]
586 pub mRadioType: u8,
587}
588impl otThreadLinkInfo {
589 #[inline]
590 pub fn mLinkSecurity(&self) -> bool {
591 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
592 }
593 #[inline]
594 pub fn set_mLinkSecurity(&mut self, val: bool) {
595 unsafe {
596 let val: u8 = ::std::mem::transmute(val);
597 self._bitfield_1.set(0usize, 1u8, val as u64)
598 }
599 }
600 #[inline]
601 pub fn mIsDstPanIdBroadcast(&self) -> bool {
602 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
603 }
604 #[inline]
605 pub fn set_mIsDstPanIdBroadcast(&mut self, val: bool) {
606 unsafe {
607 let val: u8 = ::std::mem::transmute(val);
608 self._bitfield_1.set(1usize, 1u8, val as u64)
609 }
610 }
611 #[inline]
612 pub fn new_bitfield_1(
613 mLinkSecurity: bool,
614 mIsDstPanIdBroadcast: bool,
615 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
616 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
617 __bindgen_bitfield_unit.set(0usize, 1u8, {
618 let mLinkSecurity: u8 = unsafe { ::std::mem::transmute(mLinkSecurity) };
619 mLinkSecurity as u64
620 });
621 __bindgen_bitfield_unit.set(1usize, 1u8, {
622 let mIsDstPanIdBroadcast: u8 = unsafe { ::std::mem::transmute(mIsDstPanIdBroadcast) };
623 mIsDstPanIdBroadcast as u64
624 });
625 __bindgen_bitfield_unit
626 }
627}
628extern "C" {
629 #[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"]
630 pub fn otMessageFree(aMessage: *mut otMessage);
631}
632extern "C" {
633 #[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"]
634 pub fn otMessageGetLength(aMessage: *const otMessage) -> u16;
635}
636extern "C" {
637 #[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"]
638 pub fn otMessageSetLength(aMessage: *mut otMessage, aLength: u16) -> otError;
639}
640extern "C" {
641 #[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"]
642 pub fn otMessageGetOffset(aMessage: *const otMessage) -> u16;
643}
644extern "C" {
645 #[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"]
646 pub fn otMessageSetOffset(aMessage: *mut otMessage, aOffset: u16);
647}
648extern "C" {
649 #[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."]
650 pub fn otMessageIsLinkSecurityEnabled(aMessage: *const otMessage) -> bool;
651}
652extern "C" {
653 #[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."]
654 pub fn otMessageIsLoopbackToHostAllowed(aMessage: *const otMessage) -> bool;
655}
656extern "C" {
657 #[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."]
658 pub fn otMessageSetLoopbackToHostAllowed(aMessage: *mut otMessage, aAllowLoopbackToHost: bool);
659}
660extern "C" {
661 #[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."]
662 pub fn otMessageIsMulticastLoopEnabled(aMessage: *mut otMessage) -> bool;
663}
664extern "C" {
665 #[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."]
666 pub fn otMessageSetMulticastLoopEnabled(aMessage: *mut otMessage, aEnabled: bool);
667}
668extern "C" {
669 #[doc = " Gets the message origin.\n\n @param[in] aMessage A pointer to a message buffer.\n\n @returns The message origin."]
670 pub fn otMessageGetOrigin(aMessage: *const otMessage) -> otMessageOrigin;
671}
672extern "C" {
673 #[doc = " Sets the message origin.\n\n @param[in] aMessage A pointer to a message buffer.\n @param[in] aOrigin The message origin."]
674 pub fn otMessageSetOrigin(aMessage: *mut otMessage, aOrigin: otMessageOrigin);
675}
676extern "C" {
677 #[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."]
678 pub fn otMessageSetDirectTransmission(aMessage: *mut otMessage, aEnabled: bool);
679}
680extern "C" {
681 #[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."]
682 pub fn otMessageGetRss(aMessage: *const otMessage) -> i8;
683}
684extern "C" {
685 #[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`."]
686 pub fn otMessageGetThreadLinkInfo(
687 aMessage: *const otMessage,
688 aLinkInfo: *mut otThreadLinkInfo,
689 ) -> otError;
690}
691extern "C" {
692 #[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"]
693 pub fn otMessageAppend(
694 aMessage: *mut otMessage,
695 aBuf: *const ::std::os::raw::c_void,
696 aLength: u16,
697 ) -> otError;
698}
699extern "C" {
700 #[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"]
701 pub fn otMessageRead(
702 aMessage: *const otMessage,
703 aOffset: u16,
704 aBuf: *mut ::std::os::raw::c_void,
705 aLength: u16,
706 ) -> u16;
707}
708extern "C" {
709 #[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"]
710 pub fn otMessageWrite(
711 aMessage: *mut otMessage,
712 aOffset: u16,
713 aBuf: *const ::std::os::raw::c_void,
714 aLength: u16,
715 ) -> ::std::os::raw::c_int;
716}
717#[doc = " Represents an OpenThread message queue."]
718#[repr(C)]
719#[derive(Debug, Copy, Clone)]
720pub struct otMessageQueue {
721 #[doc = "< Opaque data used by the implementation."]
722 pub mData: *mut ::std::os::raw::c_void,
723}
724impl Default for otMessageQueue {
725 fn default() -> Self {
726 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
727 unsafe {
728 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
729 s.assume_init()
730 }
731 }
732}
733#[doc = " Represents information about a message queue."]
734#[repr(C)]
735#[derive(Debug, Default, Copy, Clone)]
736pub struct otMessageQueueInfo {
737 #[doc = "< Number of messages in the queue."]
738 pub mNumMessages: u16,
739 #[doc = "< Number of data buffers used by messages in the queue."]
740 pub mNumBuffers: u16,
741 #[doc = "< Total number of bytes used by all messages in the queue."]
742 pub mTotalBytes: u32,
743}
744#[doc = " Represents the message buffer information for different queues used by OpenThread stack."]
745#[repr(C)]
746#[derive(Debug, Default, Copy, Clone)]
747pub struct otBufferInfo {
748 #[doc = "< The total number of buffers in the messages pool (0xffff if unknown)."]
749 pub mTotalBuffers: u16,
750 #[doc = "< The number of free buffers (0xffff if unknown)."]
751 pub mFreeBuffers: u16,
752 #[doc = " The maximum number of used buffers at the same time since OT stack initialization or last call to\n `otMessageResetBufferInfo()`."]
753 pub mMaxUsedBuffers: u16,
754 #[doc = "< Info about 6LoWPAN send queue."]
755 pub m6loSendQueue: otMessageQueueInfo,
756 #[doc = "< Info about 6LoWPAN reassembly queue."]
757 pub m6loReassemblyQueue: otMessageQueueInfo,
758 #[doc = "< Info about IPv6 send queue."]
759 pub mIp6Queue: otMessageQueueInfo,
760 #[doc = "< Info about MPL send queue."]
761 pub mMplQueue: otMessageQueueInfo,
762 #[doc = "< Info about MLE delayed message queue."]
763 pub mMleQueue: otMessageQueueInfo,
764 #[doc = "< Info about CoAP/TMF send queue."]
765 pub mCoapQueue: otMessageQueueInfo,
766 #[doc = "< Info about CoAP secure send queue."]
767 pub mCoapSecureQueue: otMessageQueueInfo,
768 #[doc = "< Info about application CoAP send queue."]
769 pub mApplicationCoapQueue: otMessageQueueInfo,
770}
771extern "C" {
772 #[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."]
773 pub fn otMessageQueueInit(aQueue: *mut otMessageQueue);
774}
775extern "C" {
776 #[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."]
777 pub fn otMessageQueueEnqueue(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
778}
779extern "C" {
780 #[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."]
781 pub fn otMessageQueueEnqueueAtHead(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
782}
783extern "C" {
784 #[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."]
785 pub fn otMessageQueueDequeue(aQueue: *mut otMessageQueue, aMessage: *mut otMessage);
786}
787extern "C" {
788 #[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."]
789 pub fn otMessageQueueGetHead(aQueue: *mut otMessageQueue) -> *mut otMessage;
790}
791extern "C" {
792 #[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`."]
793 pub fn otMessageQueueGetNext(
794 aQueue: *mut otMessageQueue,
795 aMessage: *const otMessage,
796 ) -> *mut otMessage;
797}
798extern "C" {
799 #[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."]
800 pub fn otMessageGetBufferInfo(aInstance: *mut otInstance, aBufferInfo: *mut otBufferInfo);
801}
802extern "C" {
803 #[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."]
804 pub fn otMessageResetBufferInfo(aInstance: *mut otInstance);
805}
806#[doc = "< Key Type: Raw Data."]
807pub const OT_CRYPTO_KEY_TYPE_RAW: otCryptoKeyType = 0;
808#[doc = "< Key Type: AES."]
809pub const OT_CRYPTO_KEY_TYPE_AES: otCryptoKeyType = 1;
810#[doc = "< Key Type: HMAC."]
811pub const OT_CRYPTO_KEY_TYPE_HMAC: otCryptoKeyType = 2;
812#[doc = "< Key Type: ECDSA."]
813pub const OT_CRYPTO_KEY_TYPE_ECDSA: otCryptoKeyType = 3;
814#[doc = " Defines the key types."]
815pub type otCryptoKeyType = ::std::os::raw::c_uint;
816#[doc = "< Key Algorithm: Vendor Defined."]
817pub const OT_CRYPTO_KEY_ALG_VENDOR: otCryptoKeyAlgorithm = 0;
818#[doc = "< Key Algorithm: AES ECB."]
819pub const OT_CRYPTO_KEY_ALG_AES_ECB: otCryptoKeyAlgorithm = 1;
820#[doc = "< Key Algorithm: HMAC SHA-256."]
821pub const OT_CRYPTO_KEY_ALG_HMAC_SHA_256: otCryptoKeyAlgorithm = 2;
822#[doc = "< Key Algorithm: ECDSA."]
823pub const OT_CRYPTO_KEY_ALG_ECDSA: otCryptoKeyAlgorithm = 3;
824#[doc = " Defines the key algorithms."]
825pub type otCryptoKeyAlgorithm = ::std::os::raw::c_uint;
826#[doc = "< Key Usage: Key Usage is empty."]
827pub const OT_CRYPTO_KEY_USAGE_NONE: _bindgen_ty_1 = 0;
828#[doc = "< Key Usage: Key can be exported."]
829pub const OT_CRYPTO_KEY_USAGE_EXPORT: _bindgen_ty_1 = 1;
830#[doc = "< Key Usage: Encryption (vendor defined)."]
831pub const OT_CRYPTO_KEY_USAGE_ENCRYPT: _bindgen_ty_1 = 2;
832#[doc = "< Key Usage: AES ECB."]
833pub const OT_CRYPTO_KEY_USAGE_DECRYPT: _bindgen_ty_1 = 4;
834#[doc = "< Key Usage: Sign Hash."]
835pub const OT_CRYPTO_KEY_USAGE_SIGN_HASH: _bindgen_ty_1 = 8;
836#[doc = "< Key Usage: Verify Hash."]
837pub const OT_CRYPTO_KEY_USAGE_VERIFY_HASH: _bindgen_ty_1 = 16;
838#[doc = " Defines the key usage flags."]
839pub type _bindgen_ty_1 = ::std::os::raw::c_uint;
840#[doc = "< Key Persistence: Key is volatile."]
841pub const OT_CRYPTO_KEY_STORAGE_VOLATILE: otCryptoKeyStorage = 0;
842#[doc = "< Key Persistence: Key is persistent."]
843pub const OT_CRYPTO_KEY_STORAGE_PERSISTENT: otCryptoKeyStorage = 1;
844#[doc = " Defines the key storage types."]
845pub type otCryptoKeyStorage = ::std::os::raw::c_uint;
846#[doc = " This datatype represents the key reference."]
847pub type otCryptoKeyRef = u32;
848#[doc = " @struct otCryptoKey\n\n Represents the Key Material required for Crypto operations."]
849#[repr(C)]
850#[derive(Debug, Copy, Clone)]
851pub struct otCryptoKey {
852 #[doc = "< Pointer to the buffer containing key. NULL indicates to use `mKeyRef`."]
853 pub mKey: *const u8,
854 #[doc = "< The key length in bytes (applicable when `mKey` is not NULL)."]
855 pub mKeyLength: u16,
856 #[doc = "< The PSA key ref (requires `mKey` to be NULL)."]
857 pub mKeyRef: u32,
858}
859impl Default for otCryptoKey {
860 fn default() -> Self {
861 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
862 unsafe {
863 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
864 s.assume_init()
865 }
866 }
867}
868#[doc = " @struct otCryptoContext\n\n Stores the context object for platform APIs."]
869#[repr(C)]
870#[derive(Debug, Copy, Clone)]
871pub struct otCryptoContext {
872 #[doc = "< Pointer to the context."]
873 pub mContext: *mut ::std::os::raw::c_void,
874 #[doc = "< The length of the context in bytes."]
875 pub mContextSize: u16,
876}
877impl Default for otCryptoContext {
878 fn default() -> Self {
879 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
880 unsafe {
881 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
882 s.assume_init()
883 }
884 }
885}
886#[doc = " @struct otPlatCryptoSha256Hash\n\n Represents a SHA-256 hash."]
887#[repr(C, packed)]
888#[derive(Debug, Default, Copy, Clone)]
889pub struct otPlatCryptoSha256Hash {
890 #[doc = "< Hash bytes."]
891 pub m8: [u8; 32usize],
892}
893#[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)."]
894#[repr(C)]
895#[derive(Debug, Copy, Clone)]
896pub struct otPlatCryptoEcdsaKeyPair {
897 pub mDerBytes: [u8; 125usize],
898 pub mDerLength: u8,
899}
900impl Default for otPlatCryptoEcdsaKeyPair {
901 fn default() -> Self {
902 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
903 unsafe {
904 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
905 s.assume_init()
906 }
907 }
908}
909#[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)."]
910#[repr(C, packed)]
911#[derive(Debug, Copy, Clone)]
912pub struct otPlatCryptoEcdsaPublicKey {
913 pub m8: [u8; 64usize],
914}
915impl Default for otPlatCryptoEcdsaPublicKey {
916 fn default() -> Self {
917 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
918 unsafe {
919 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
920 s.assume_init()
921 }
922 }
923}
924#[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)."]
925#[repr(C, packed)]
926#[derive(Debug, Copy, Clone)]
927pub struct otPlatCryptoEcdsaSignature {
928 pub m8: [u8; 64usize],
929}
930impl Default for otPlatCryptoEcdsaSignature {
931 fn default() -> Self {
932 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
933 unsafe {
934 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
935 s.assume_init()
936 }
937 }
938}
939extern "C" {
940 #[doc = " Initialize the Crypto module."]
941 pub fn otPlatCryptoInit();
942}
943extern "C" {
944 #[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."]
945 pub fn otPlatCryptoImportKey(
946 aKeyRef: *mut otCryptoKeyRef,
947 aKeyType: otCryptoKeyType,
948 aKeyAlgorithm: otCryptoKeyAlgorithm,
949 aKeyUsage: ::std::os::raw::c_int,
950 aKeyPersistence: otCryptoKeyStorage,
951 aKey: *const u8,
952 aKeyLen: usize,
953 ) -> otError;
954}
955extern "C" {
956 #[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."]
957 pub fn otPlatCryptoExportKey(
958 aKeyRef: otCryptoKeyRef,
959 aBuffer: *mut u8,
960 aBufferLen: usize,
961 aKeyLen: *mut usize,
962 ) -> otError;
963}
964extern "C" {
965 #[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."]
966 pub fn otPlatCryptoDestroyKey(aKeyRef: otCryptoKeyRef) -> otError;
967}
968extern "C" {
969 #[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."]
970 pub fn otPlatCryptoHasKey(aKeyRef: otCryptoKeyRef) -> bool;
971}
972extern "C" {
973 #[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."]
974 pub fn otPlatCryptoHmacSha256Init(aContext: *mut otCryptoContext) -> otError;
975}
976extern "C" {
977 #[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"]
978 pub fn otPlatCryptoHmacSha256Deinit(aContext: *mut otCryptoContext) -> otError;
979}
980extern "C" {
981 #[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"]
982 pub fn otPlatCryptoHmacSha256Start(
983 aContext: *mut otCryptoContext,
984 aKey: *const otCryptoKey,
985 ) -> otError;
986}
987extern "C" {
988 #[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"]
989 pub fn otPlatCryptoHmacSha256Update(
990 aContext: *mut otCryptoContext,
991 aBuf: *const ::std::os::raw::c_void,
992 aBufLength: u16,
993 ) -> otError;
994}
995extern "C" {
996 #[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"]
997 pub fn otPlatCryptoHmacSha256Finish(
998 aContext: *mut otCryptoContext,
999 aBuf: *mut u8,
1000 aBufLength: usize,
1001 ) -> otError;
1002}
1003extern "C" {
1004 #[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."]
1005 pub fn otPlatCryptoAesInit(aContext: *mut otCryptoContext) -> otError;
1006}
1007extern "C" {
1008 #[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"]
1009 pub fn otPlatCryptoAesSetKey(
1010 aContext: *mut otCryptoContext,
1011 aKey: *const otCryptoKey,
1012 ) -> otError;
1013}
1014extern "C" {
1015 #[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"]
1016 pub fn otPlatCryptoAesEncrypt(
1017 aContext: *mut otCryptoContext,
1018 aInput: *const u8,
1019 aOutput: *mut u8,
1020 ) -> otError;
1021}
1022extern "C" {
1023 #[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"]
1024 pub fn otPlatCryptoAesFree(aContext: *mut otCryptoContext) -> otError;
1025}
1026extern "C" {
1027 #[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"]
1028 pub fn otPlatCryptoHkdfInit(aContext: *mut otCryptoContext) -> otError;
1029}
1030extern "C" {
1031 #[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"]
1032 pub fn otPlatCryptoHkdfExpand(
1033 aContext: *mut otCryptoContext,
1034 aInfo: *const u8,
1035 aInfoLength: u16,
1036 aOutputKey: *mut u8,
1037 aOutputKeyLength: u16,
1038 ) -> otError;
1039}
1040extern "C" {
1041 #[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."]
1042 pub fn otPlatCryptoHkdfExtract(
1043 aContext: *mut otCryptoContext,
1044 aSalt: *const u8,
1045 aSaltLength: u16,
1046 aInputKey: *const otCryptoKey,
1047 ) -> otError;
1048}
1049extern "C" {
1050 #[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"]
1051 pub fn otPlatCryptoHkdfDeinit(aContext: *mut otCryptoContext) -> otError;
1052}
1053extern "C" {
1054 #[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."]
1055 pub fn otPlatCryptoSha256Init(aContext: *mut otCryptoContext) -> otError;
1056}
1057extern "C" {
1058 #[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"]
1059 pub fn otPlatCryptoSha256Deinit(aContext: *mut otCryptoContext) -> otError;
1060}
1061extern "C" {
1062 #[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"]
1063 pub fn otPlatCryptoSha256Start(aContext: *mut otCryptoContext) -> otError;
1064}
1065extern "C" {
1066 #[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"]
1067 pub fn otPlatCryptoSha256Update(
1068 aContext: *mut otCryptoContext,
1069 aBuf: *const ::std::os::raw::c_void,
1070 aBufLength: u16,
1071 ) -> otError;
1072}
1073extern "C" {
1074 #[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"]
1075 pub fn otPlatCryptoSha256Finish(
1076 aContext: *mut otCryptoContext,
1077 aHash: *mut u8,
1078 aHashSize: u16,
1079 ) -> otError;
1080}
1081extern "C" {
1082 #[doc = " Initialize cryptographically-secure pseudorandom number generator (CSPRNG)."]
1083 pub fn otPlatCryptoRandomInit();
1084}
1085extern "C" {
1086 #[doc = " Deinitialize cryptographically-secure pseudorandom number generator (CSPRNG)."]
1087 pub fn otPlatCryptoRandomDeinit();
1088}
1089extern "C" {
1090 #[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."]
1091 pub fn otPlatCryptoRandomGet(aBuffer: *mut u8, aSize: u16) -> otError;
1092}
1093extern "C" {
1094 #[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."]
1095 pub fn otPlatCryptoEcdsaGenerateKey(aKeyPair: *mut otPlatCryptoEcdsaKeyPair) -> otError;
1096}
1097extern "C" {
1098 #[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."]
1099 pub fn otPlatCryptoEcdsaGetPublicKey(
1100 aKeyPair: *const otPlatCryptoEcdsaKeyPair,
1101 aPublicKey: *mut otPlatCryptoEcdsaPublicKey,
1102 ) -> otError;
1103}
1104extern "C" {
1105 #[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."]
1106 pub fn otPlatCryptoEcdsaSign(
1107 aKeyPair: *const otPlatCryptoEcdsaKeyPair,
1108 aHash: *const otPlatCryptoSha256Hash,
1109 aSignature: *mut otPlatCryptoEcdsaSignature,
1110 ) -> otError;
1111}
1112extern "C" {
1113 #[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."]
1114 pub fn otPlatCryptoEcdsaVerify(
1115 aPublicKey: *const otPlatCryptoEcdsaPublicKey,
1116 aHash: *const otPlatCryptoSha256Hash,
1117 aSignature: *const otPlatCryptoEcdsaSignature,
1118 ) -> otError;
1119}
1120extern "C" {
1121 #[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."]
1122 pub fn otPlatCryptoEcdsaSignUsingKeyRef(
1123 aKeyRef: otCryptoKeyRef,
1124 aHash: *const otPlatCryptoSha256Hash,
1125 aSignature: *mut otPlatCryptoEcdsaSignature,
1126 ) -> otError;
1127}
1128extern "C" {
1129 #[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."]
1130 pub fn otPlatCryptoEcdsaExportPublicKey(
1131 aKeyRef: otCryptoKeyRef,
1132 aPublicKey: *mut otPlatCryptoEcdsaPublicKey,
1133 ) -> otError;
1134}
1135extern "C" {
1136 #[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."]
1137 pub fn otPlatCryptoEcdsaGenerateAndImportKey(aKeyRef: otCryptoKeyRef) -> otError;
1138}
1139extern "C" {
1140 #[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."]
1141 pub fn otPlatCryptoEcdsaVerifyUsingKeyRef(
1142 aKeyRef: otCryptoKeyRef,
1143 aHash: *const otPlatCryptoSha256Hash,
1144 aSignature: *const otPlatCryptoEcdsaSignature,
1145 ) -> otError;
1146}
1147extern "C" {
1148 #[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."]
1149 pub fn otPlatCryptoPbkdf2GenerateKey(
1150 aPassword: *const u8,
1151 aPasswordLen: u16,
1152 aSalt: *const u8,
1153 aSaltLen: u16,
1154 aIterationCounter: u32,
1155 aKeyLen: u16,
1156 aKey: *mut u8,
1157 ) -> otError;
1158}
1159#[doc = "< aMaxPHYPacketSize (IEEE 802.15.4-2006)"]
1160pub const OT_RADIO_FRAME_MAX_SIZE: _bindgen_ty_2 = 127;
1161#[doc = "< Minimal size of frame FCS + CONTROL"]
1162pub const OT_RADIO_FRAME_MIN_SIZE: _bindgen_ty_2 = 3;
1163#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1164pub const OT_RADIO_SYMBOLS_PER_OCTET: _bindgen_ty_2 = 2;
1165#[doc = "< 2.4 GHz IEEE 802.15.4 (bits per second)"]
1166pub const OT_RADIO_BIT_RATE: _bindgen_ty_2 = 250000;
1167#[doc = "< Number of bits per octet"]
1168pub const OT_RADIO_BITS_PER_OCTET: _bindgen_ty_2 = 8;
1169#[doc = "< The O-QPSK PHY symbol rate when operating in the 780MHz, 915MHz, 2380MHz, 2450MHz"]
1170pub const OT_RADIO_SYMBOL_RATE: _bindgen_ty_2 = 62500;
1171#[doc = "< Symbol duration time in unit of microseconds"]
1172pub const OT_RADIO_SYMBOL_TIME: _bindgen_ty_2 = 16;
1173#[doc = "< Time for 10 symbols in unit of microseconds"]
1174pub const OT_RADIO_TEN_SYMBOLS_TIME: _bindgen_ty_2 = 160;
1175#[doc = "< LQI measurement not supported"]
1176pub const OT_RADIO_LQI_NONE: _bindgen_ty_2 = 0;
1177#[doc = "< Invalid or unknown RSSI value"]
1178pub const OT_RADIO_RSSI_INVALID: _bindgen_ty_2 = 127;
1179#[doc = "< Invalid or unknown power value"]
1180pub const OT_RADIO_POWER_INVALID: _bindgen_ty_2 = 127;
1181#[doc = "< Invalid short address."]
1182pub const OT_RADIO_INVALID_SHORT_ADDR: _bindgen_ty_2 = 65534;
1183#[doc = "< Broadcast short address."]
1184pub const OT_RADIO_BROADCAST_SHORT_ADDR: _bindgen_ty_2 = 65535;
1185#[doc = " @defgroup radio-types Radio Types\n\n @brief\n This module includes the platform abstraction for a radio frame.\n\n @{"]
1186pub type _bindgen_ty_2 = ::std::os::raw::c_uint;
1187#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1188pub const OT_RADIO_CHANNEL_PAGE_0: _bindgen_ty_3 = 0;
1189#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1190pub const OT_RADIO_CHANNEL_PAGE_0_MASK: _bindgen_ty_3 = 1;
1191#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1192pub const OT_RADIO_CHANNEL_PAGE_2: _bindgen_ty_3 = 2;
1193#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1194pub const OT_RADIO_CHANNEL_PAGE_2_MASK: _bindgen_ty_3 = 4;
1195#[doc = " Defines the channel page."]
1196pub type _bindgen_ty_3 = ::std::os::raw::c_uint;
1197#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1198pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MIN: _bindgen_ty_4 = 1;
1199#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1200pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MAX: _bindgen_ty_4 = 10;
1201#[doc = "< 915 MHz IEEE 802.15.4-2006"]
1202pub const OT_RADIO_915MHZ_OQPSK_CHANNEL_MASK: _bindgen_ty_4 = 2046;
1203#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1204pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MIN: _bindgen_ty_4 = 11;
1205#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1206pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MAX: _bindgen_ty_4 = 26;
1207#[doc = "< 2.4 GHz IEEE 802.15.4-2006"]
1208pub const OT_RADIO_2P4GHZ_OQPSK_CHANNEL_MASK: _bindgen_ty_4 = 134215680;
1209#[doc = " Defines the frequency band channel range."]
1210pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
1211#[doc = " Represents radio capabilities.\n\n The value is a bit-field indicating the capabilities supported by the radio. See `OT_RADIO_CAPS_*` definitions."]
1212pub type otRadioCaps = u16;
1213#[doc = "< Radio supports no capability."]
1214pub const OT_RADIO_CAPS_NONE: _bindgen_ty_5 = 0;
1215#[doc = "< Radio supports AckTime event."]
1216pub const OT_RADIO_CAPS_ACK_TIMEOUT: _bindgen_ty_5 = 1;
1217#[doc = "< Radio supports Energy Scans."]
1218pub const OT_RADIO_CAPS_ENERGY_SCAN: _bindgen_ty_5 = 2;
1219#[doc = "< Radio supports tx retry logic with collision avoidance (CSMA)."]
1220pub const OT_RADIO_CAPS_TRANSMIT_RETRIES: _bindgen_ty_5 = 4;
1221#[doc = "< Radio supports CSMA backoff for frame tx (but no retry)."]
1222pub const OT_RADIO_CAPS_CSMA_BACKOFF: _bindgen_ty_5 = 8;
1223#[doc = "< Radio supports direct transition from sleep to TX with CSMA."]
1224pub const OT_RADIO_CAPS_SLEEP_TO_TX: _bindgen_ty_5 = 16;
1225#[doc = "< Radio supports tx security."]
1226pub const OT_RADIO_CAPS_TRANSMIT_SEC: _bindgen_ty_5 = 32;
1227#[doc = "< Radio supports tx at specific time."]
1228pub const OT_RADIO_CAPS_TRANSMIT_TIMING: _bindgen_ty_5 = 64;
1229#[doc = "< Radio supports rx at specific time."]
1230pub const OT_RADIO_CAPS_RECEIVE_TIMING: _bindgen_ty_5 = 128;
1231#[doc = "< Radio supports RxOnWhenIdle handling."]
1232pub const OT_RADIO_CAPS_RX_ON_WHEN_IDLE: _bindgen_ty_5 = 256;
1233#[doc = "< Radio supports setting per-frame transmit power."]
1234pub const OT_RADIO_CAPS_TRANSMIT_FRAME_POWER: _bindgen_ty_5 = 512;
1235#[doc = "< Radio supports setting alternate short address."]
1236pub const OT_RADIO_CAPS_ALT_SHORT_ADDR: _bindgen_ty_5 = 1024;
1237#[doc = " Defines constants that are used to indicate different radio capabilities. See `otRadioCaps`."]
1238pub type _bindgen_ty_5 = ::std::os::raw::c_uint;
1239#[doc = " Represents the IEEE 802.15.4 PAN ID."]
1240pub type otPanId = u16;
1241#[doc = " Represents the IEEE 802.15.4 Short Address."]
1242pub type otShortAddress = u16;
1243#[doc = "< Size of IE header in bytes."]
1244pub const OT_IE_HEADER_SIZE: _bindgen_ty_6 = 2;
1245#[doc = "< Size of CSL IE content in bytes."]
1246pub const OT_CSL_IE_SIZE: _bindgen_ty_6 = 4;
1247#[doc = "< Max length for header IE in ACK."]
1248pub const OT_ACK_IE_MAX_SIZE: _bindgen_ty_6 = 16;
1249#[doc = "< Max length of Link Metrics data in Vendor-Specific IE."]
1250pub const OT_ENH_PROBING_IE_DATA_MAX_SIZE: _bindgen_ty_6 = 2;
1251#[doc = " Defines constants about size of header IE in ACK."]
1252pub type _bindgen_ty_6 = ::std::os::raw::c_uint;
1253#[doc = " @struct otExtAddress\n\n Represents the IEEE 802.15.4 Extended Address."]
1254#[repr(C, packed)]
1255#[derive(Debug, Default, Copy, Clone)]
1256pub struct otExtAddress {
1257 #[doc = "< IEEE 802.15.4 Extended Address bytes"]
1258 pub m8: [u8; 8usize],
1259}
1260#[doc = " @struct otMacKey\n\n Represents a MAC Key."]
1261#[repr(C, packed)]
1262#[derive(Debug, Default, Copy, Clone)]
1263pub struct otMacKey {
1264 #[doc = "< MAC Key bytes."]
1265 pub m8: [u8; 16usize],
1266}
1267#[doc = " Represents a MAC Key Ref used by PSA."]
1268pub type otMacKeyRef = otCryptoKeyRef;
1269#[doc = " @struct otMacKeyMaterial\n\n Represents a MAC Key."]
1270#[repr(C)]
1271#[derive(Copy, Clone)]
1272pub struct otMacKeyMaterial {
1273 pub mKeyMaterial: otMacKeyMaterial__bindgen_ty_1,
1274}
1275#[repr(C)]
1276#[derive(Copy, Clone)]
1277pub union otMacKeyMaterial__bindgen_ty_1 {
1278 #[doc = "< Reference to the key stored."]
1279 pub mKeyRef: otMacKeyRef,
1280 #[doc = "< Key stored as literal."]
1281 pub mKey: otMacKey,
1282}
1283impl Default for otMacKeyMaterial__bindgen_ty_1 {
1284 fn default() -> Self {
1285 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1286 unsafe {
1287 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1288 s.assume_init()
1289 }
1290 }
1291}
1292impl Default for otMacKeyMaterial {
1293 fn default() -> Self {
1294 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1295 unsafe {
1296 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1297 s.assume_init()
1298 }
1299 }
1300}
1301#[doc = "< Use Literal Keys."]
1302pub const OT_KEY_TYPE_LITERAL_KEY: otRadioKeyType = 0;
1303#[doc = "< Use Reference to Key."]
1304pub const OT_KEY_TYPE_KEY_REF: otRadioKeyType = 1;
1305#[doc = " Defines constants about key types."]
1306pub type otRadioKeyType = ::std::os::raw::c_uint;
1307#[doc = " Represents the IEEE 802.15.4 Header IE (Information Element) related information of a radio frame."]
1308#[repr(C)]
1309#[derive(Debug, Default, Copy, Clone)]
1310pub struct otRadioIeInfo {
1311 #[doc = "< The time offset to the Thread network time."]
1312 pub mNetworkTimeOffset: i64,
1313 #[doc = "< The Time IE offset from the start of PSDU."]
1314 pub mTimeIeOffset: u8,
1315 #[doc = "< The Time sync sequence."]
1316 pub mTimeSyncSeq: u8,
1317}
1318#[doc = " Represents an IEEE 802.15.4 radio frame."]
1319#[repr(C)]
1320#[derive(Copy, Clone)]
1321pub struct otRadioFrame {
1322 #[doc = "< The PSDU."]
1323 pub mPsdu: *mut u8,
1324 #[doc = "< Length of the PSDU."]
1325 pub mLength: u16,
1326 #[doc = "< Channel used to transmit/receive the frame."]
1327 pub mChannel: u8,
1328 #[doc = "< Radio link type - should be ignored by radio driver."]
1329 pub mRadioType: u8,
1330 pub mInfo: otRadioFrame__bindgen_ty_1,
1331}
1332#[doc = " The union of transmit and receive information for a radio frame."]
1333#[repr(C)]
1334#[derive(Copy, Clone)]
1335pub union otRadioFrame__bindgen_ty_1 {
1336 pub mTxInfo: otRadioFrame__bindgen_ty_1__bindgen_ty_1,
1337 pub mRxInfo: otRadioFrame__bindgen_ty_1__bindgen_ty_2,
1338}
1339#[doc = " Structure representing radio frame transmit information."]
1340#[repr(C)]
1341#[derive(Debug, Copy, Clone)]
1342pub struct otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1343 #[doc = "< The key material used for AES-CCM frame security."]
1344 pub mAesKey: *const otMacKeyMaterial,
1345 #[doc = "< The pointer to the Header IE(s) related information."]
1346 pub mIeInfo: *mut otRadioIeInfo,
1347 #[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`."]
1348 pub mTxDelayBaseTime: u32,
1349 #[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`."]
1350 pub mTxDelay: u32,
1351 #[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`)."]
1352 pub mMaxCsmaBackoffs: u8,
1353 #[doc = "< Maximum number of retries allowed after a transmission failure."]
1354 pub mMaxFrameRetries: u8,
1355 #[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."]
1356 pub mRxChannelAfterTxDone: u8,
1357 #[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()."]
1358 pub mTxPower: i8,
1359 pub _bitfield_align_1: [u8; 0],
1360 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1361 #[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."]
1362 pub mTimestamp: u64,
1363}
1364impl Default for otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1365 fn default() -> Self {
1366 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1367 unsafe {
1368 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1369 s.assume_init()
1370 }
1371 }
1372}
1373impl otRadioFrame__bindgen_ty_1__bindgen_ty_1 {
1374 #[inline]
1375 pub fn mIsHeaderUpdated(&self) -> bool {
1376 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1377 }
1378 #[inline]
1379 pub fn set_mIsHeaderUpdated(&mut self, val: bool) {
1380 unsafe {
1381 let val: u8 = ::std::mem::transmute(val);
1382 self._bitfield_1.set(0usize, 1u8, val as u64)
1383 }
1384 }
1385 #[inline]
1386 pub fn mIsARetx(&self) -> bool {
1387 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1388 }
1389 #[inline]
1390 pub fn set_mIsARetx(&mut self, val: bool) {
1391 unsafe {
1392 let val: u8 = ::std::mem::transmute(val);
1393 self._bitfield_1.set(1usize, 1u8, val as u64)
1394 }
1395 }
1396 #[inline]
1397 pub fn mCsmaCaEnabled(&self) -> bool {
1398 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
1399 }
1400 #[inline]
1401 pub fn set_mCsmaCaEnabled(&mut self, val: bool) {
1402 unsafe {
1403 let val: u8 = ::std::mem::transmute(val);
1404 self._bitfield_1.set(2usize, 1u8, val as u64)
1405 }
1406 }
1407 #[inline]
1408 pub fn mCslPresent(&self) -> bool {
1409 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
1410 }
1411 #[inline]
1412 pub fn set_mCslPresent(&mut self, val: bool) {
1413 unsafe {
1414 let val: u8 = ::std::mem::transmute(val);
1415 self._bitfield_1.set(3usize, 1u8, val as u64)
1416 }
1417 }
1418 #[inline]
1419 pub fn mIsSecurityProcessed(&self) -> bool {
1420 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
1421 }
1422 #[inline]
1423 pub fn set_mIsSecurityProcessed(&mut self, val: bool) {
1424 unsafe {
1425 let val: u8 = ::std::mem::transmute(val);
1426 self._bitfield_1.set(4usize, 1u8, val as u64)
1427 }
1428 }
1429 #[inline]
1430 pub fn new_bitfield_1(
1431 mIsHeaderUpdated: bool,
1432 mIsARetx: bool,
1433 mCsmaCaEnabled: bool,
1434 mCslPresent: bool,
1435 mIsSecurityProcessed: bool,
1436 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1437 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1438 __bindgen_bitfield_unit.set(0usize, 1u8, {
1439 let mIsHeaderUpdated: u8 = unsafe { ::std::mem::transmute(mIsHeaderUpdated) };
1440 mIsHeaderUpdated as u64
1441 });
1442 __bindgen_bitfield_unit.set(1usize, 1u8, {
1443 let mIsARetx: u8 = unsafe { ::std::mem::transmute(mIsARetx) };
1444 mIsARetx as u64
1445 });
1446 __bindgen_bitfield_unit.set(2usize, 1u8, {
1447 let mCsmaCaEnabled: u8 = unsafe { ::std::mem::transmute(mCsmaCaEnabled) };
1448 mCsmaCaEnabled as u64
1449 });
1450 __bindgen_bitfield_unit.set(3usize, 1u8, {
1451 let mCslPresent: u8 = unsafe { ::std::mem::transmute(mCslPresent) };
1452 mCslPresent as u64
1453 });
1454 __bindgen_bitfield_unit.set(4usize, 1u8, {
1455 let mIsSecurityProcessed: u8 = unsafe { ::std::mem::transmute(mIsSecurityProcessed) };
1456 mIsSecurityProcessed as u64
1457 });
1458 __bindgen_bitfield_unit
1459 }
1460}
1461#[doc = " Structure representing radio frame receive information."]
1462#[repr(C)]
1463#[derive(Debug, Default, Copy, Clone)]
1464pub struct otRadioFrame__bindgen_ty_1__bindgen_ty_2 {
1465 #[doc = " The time of the local radio clock in microseconds when the end of\n the SFD was present at the local antenna."]
1466 pub mTimestamp: u64,
1467 #[doc = "< ACK security frame counter (applicable when `mAckedWithSecEnhAck` is set)."]
1468 pub mAckFrameCounter: u32,
1469 #[doc = "< ACK security key index (applicable when `mAckedWithSecEnhAck` is set)."]
1470 pub mAckKeyId: u8,
1471 #[doc = "< Received signal strength indicator in dBm for received frames."]
1472 pub mRssi: i8,
1473 #[doc = "< Link Quality Indicator for received frames."]
1474 pub mLqi: u8,
1475 pub _bitfield_align_1: [u8; 0],
1476 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1477}
1478impl otRadioFrame__bindgen_ty_1__bindgen_ty_2 {
1479 #[inline]
1480 pub fn mAckedWithFramePending(&self) -> bool {
1481 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1482 }
1483 #[inline]
1484 pub fn set_mAckedWithFramePending(&mut self, val: bool) {
1485 unsafe {
1486 let val: u8 = ::std::mem::transmute(val);
1487 self._bitfield_1.set(0usize, 1u8, val as u64)
1488 }
1489 }
1490 #[inline]
1491 pub fn mAckedWithSecEnhAck(&self) -> bool {
1492 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1493 }
1494 #[inline]
1495 pub fn set_mAckedWithSecEnhAck(&mut self, val: bool) {
1496 unsafe {
1497 let val: u8 = ::std::mem::transmute(val);
1498 self._bitfield_1.set(1usize, 1u8, val as u64)
1499 }
1500 }
1501 #[inline]
1502 pub fn new_bitfield_1(
1503 mAckedWithFramePending: bool,
1504 mAckedWithSecEnhAck: bool,
1505 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1506 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1507 __bindgen_bitfield_unit.set(0usize, 1u8, {
1508 let mAckedWithFramePending: u8 =
1509 unsafe { ::std::mem::transmute(mAckedWithFramePending) };
1510 mAckedWithFramePending as u64
1511 });
1512 __bindgen_bitfield_unit.set(1usize, 1u8, {
1513 let mAckedWithSecEnhAck: u8 = unsafe { ::std::mem::transmute(mAckedWithSecEnhAck) };
1514 mAckedWithSecEnhAck as u64
1515 });
1516 __bindgen_bitfield_unit
1517 }
1518}
1519impl Default for otRadioFrame__bindgen_ty_1 {
1520 fn default() -> Self {
1521 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1522 unsafe {
1523 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1524 s.assume_init()
1525 }
1526 }
1527}
1528impl Default for otRadioFrame {
1529 fn default() -> Self {
1530 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1531 unsafe {
1532 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1533 s.assume_init()
1534 }
1535 }
1536}
1537pub const OT_RADIO_STATE_DISABLED: otRadioState = 0;
1538pub const OT_RADIO_STATE_SLEEP: otRadioState = 1;
1539pub const OT_RADIO_STATE_RECEIVE: otRadioState = 2;
1540pub const OT_RADIO_STATE_TRANSMIT: otRadioState = 3;
1541pub const OT_RADIO_STATE_INVALID: otRadioState = 255;
1542#[doc = " Represents the state of a radio.\n Initially, a radio is in the Disabled state."]
1543pub type otRadioState = ::std::os::raw::c_uint;
1544#[doc = " Represents radio coexistence metrics."]
1545#[repr(C)]
1546#[derive(Debug, Default, Copy, Clone)]
1547pub struct otRadioCoexMetrics {
1548 #[doc = "< Number of grant glitches."]
1549 pub mNumGrantGlitch: u32,
1550 #[doc = "< Number of tx requests."]
1551 pub mNumTxRequest: u32,
1552 #[doc = "< Number of tx requests while grant was active."]
1553 pub mNumTxGrantImmediate: u32,
1554 #[doc = "< Number of tx requests while grant was inactive."]
1555 pub mNumTxGrantWait: u32,
1556 #[doc = "< Number of tx requests while grant was inactive that were ultimately granted."]
1557 pub mNumTxGrantWaitActivated: u32,
1558 #[doc = "< Number of tx requests while grant was inactive that timed out."]
1559 pub mNumTxGrantWaitTimeout: u32,
1560 #[doc = "< Number of tx that were in progress when grant was deactivated."]
1561 pub mNumTxGrantDeactivatedDuringRequest: u32,
1562 #[doc = "< Number of tx requests that were not granted within 50us."]
1563 pub mNumTxDelayedGrant: u32,
1564 #[doc = "< Average time in usec from tx request to grant."]
1565 pub mAvgTxRequestToGrantTime: u32,
1566 #[doc = "< Number of rx requests."]
1567 pub mNumRxRequest: u32,
1568 #[doc = "< Number of rx requests while grant was active."]
1569 pub mNumRxGrantImmediate: u32,
1570 #[doc = "< Number of rx requests while grant was inactive."]
1571 pub mNumRxGrantWait: u32,
1572 #[doc = "< Number of rx requests while grant was inactive that were ultimately granted."]
1573 pub mNumRxGrantWaitActivated: u32,
1574 #[doc = "< Number of rx requests while grant was inactive that timed out."]
1575 pub mNumRxGrantWaitTimeout: u32,
1576 #[doc = "< Number of rx that were in progress when grant was deactivated."]
1577 pub mNumRxGrantDeactivatedDuringRequest: u32,
1578 #[doc = "< Number of rx requests that were not granted within 50us."]
1579 pub mNumRxDelayedGrant: u32,
1580 #[doc = "< Average time in usec from rx request to grant."]
1581 pub mAvgRxRequestToGrantTime: u32,
1582 #[doc = "< Number of rx requests that completed without receiving grant."]
1583 pub mNumRxGrantNone: u32,
1584 #[doc = "< Stats collection stopped due to saturation."]
1585 pub mStopped: bool,
1586}
1587#[doc = " Represents what metrics are specified to query."]
1588#[repr(C, packed)]
1589#[derive(Debug, Default, Copy, Clone)]
1590pub struct otLinkMetrics {
1591 pub _bitfield_align_1: [u8; 0],
1592 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
1593}
1594impl otLinkMetrics {
1595 #[inline]
1596 pub fn mPduCount(&self) -> bool {
1597 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
1598 }
1599 #[inline]
1600 pub fn set_mPduCount(&mut self, val: bool) {
1601 unsafe {
1602 let val: u8 = ::std::mem::transmute(val);
1603 self._bitfield_1.set(0usize, 1u8, val as u64)
1604 }
1605 }
1606 #[inline]
1607 pub fn mLqi(&self) -> bool {
1608 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
1609 }
1610 #[inline]
1611 pub fn set_mLqi(&mut self, val: bool) {
1612 unsafe {
1613 let val: u8 = ::std::mem::transmute(val);
1614 self._bitfield_1.set(1usize, 1u8, val as u64)
1615 }
1616 }
1617 #[inline]
1618 pub fn mLinkMargin(&self) -> bool {
1619 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
1620 }
1621 #[inline]
1622 pub fn set_mLinkMargin(&mut self, val: bool) {
1623 unsafe {
1624 let val: u8 = ::std::mem::transmute(val);
1625 self._bitfield_1.set(2usize, 1u8, val as u64)
1626 }
1627 }
1628 #[inline]
1629 pub fn mRssi(&self) -> bool {
1630 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
1631 }
1632 #[inline]
1633 pub fn set_mRssi(&mut self, val: bool) {
1634 unsafe {
1635 let val: u8 = ::std::mem::transmute(val);
1636 self._bitfield_1.set(3usize, 1u8, val as u64)
1637 }
1638 }
1639 #[inline]
1640 pub fn mReserved(&self) -> bool {
1641 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
1642 }
1643 #[inline]
1644 pub fn set_mReserved(&mut self, val: bool) {
1645 unsafe {
1646 let val: u8 = ::std::mem::transmute(val);
1647 self._bitfield_1.set(4usize, 1u8, val as u64)
1648 }
1649 }
1650 #[inline]
1651 pub fn new_bitfield_1(
1652 mPduCount: bool,
1653 mLqi: bool,
1654 mLinkMargin: bool,
1655 mRssi: bool,
1656 mReserved: bool,
1657 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
1658 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
1659 __bindgen_bitfield_unit.set(0usize, 1u8, {
1660 let mPduCount: u8 = unsafe { ::std::mem::transmute(mPduCount) };
1661 mPduCount as u64
1662 });
1663 __bindgen_bitfield_unit.set(1usize, 1u8, {
1664 let mLqi: u8 = unsafe { ::std::mem::transmute(mLqi) };
1665 mLqi as u64
1666 });
1667 __bindgen_bitfield_unit.set(2usize, 1u8, {
1668 let mLinkMargin: u8 = unsafe { ::std::mem::transmute(mLinkMargin) };
1669 mLinkMargin as u64
1670 });
1671 __bindgen_bitfield_unit.set(3usize, 1u8, {
1672 let mRssi: u8 = unsafe { ::std::mem::transmute(mRssi) };
1673 mRssi as u64
1674 });
1675 __bindgen_bitfield_unit.set(4usize, 1u8, {
1676 let mReserved: u8 = unsafe { ::std::mem::transmute(mReserved) };
1677 mReserved as u64
1678 });
1679 __bindgen_bitfield_unit
1680 }
1681}
1682extern "C" {
1683 #[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)."]
1684 pub fn otPlatRadioGetCaps(aInstance: *mut otInstance) -> otRadioCaps;
1685}
1686extern "C" {
1687 #[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."]
1688 pub fn otPlatRadioGetVersionString(aInstance: *mut otInstance)
1689 -> *const ::std::os::raw::c_char;
1690}
1691extern "C" {
1692 #[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."]
1693 pub fn otPlatRadioGetReceiveSensitivity(aInstance: *mut otInstance) -> i8;
1694}
1695extern "C" {
1696 #[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."]
1697 pub fn otPlatRadioGetIeeeEui64(aInstance: *mut otInstance, aIeeeEui64: *mut u8);
1698}
1699extern "C" {
1700 #[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."]
1701 pub fn otPlatRadioSetPanId(aInstance: *mut otInstance, aPanId: otPanId);
1702}
1703extern "C" {
1704 #[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."]
1705 pub fn otPlatRadioSetExtendedAddress(
1706 aInstance: *mut otInstance,
1707 aExtAddress: *const otExtAddress,
1708 );
1709}
1710extern "C" {
1711 #[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."]
1712 pub fn otPlatRadioSetShortAddress(aInstance: *mut otInstance, aShortAddress: otShortAddress);
1713}
1714extern "C" {
1715 #[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."]
1716 pub fn otPlatRadioSetAlternateShortAddress(
1717 aInstance: *mut otInstance,
1718 aShortAddress: otShortAddress,
1719 );
1720}
1721extern "C" {
1722 #[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."]
1723 pub fn otPlatRadioGetTransmitPower(aInstance: *mut otInstance, aPower: *mut i8) -> otError;
1724}
1725extern "C" {
1726 #[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."]
1727 pub fn otPlatRadioSetTransmitPower(aInstance: *mut otInstance, aPower: i8) -> otError;
1728}
1729extern "C" {
1730 #[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."]
1731 pub fn otPlatRadioGetCcaEnergyDetectThreshold(
1732 aInstance: *mut otInstance,
1733 aThreshold: *mut i8,
1734 ) -> otError;
1735}
1736extern "C" {
1737 #[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."]
1738 pub fn otPlatRadioSetCcaEnergyDetectThreshold(
1739 aInstance: *mut otInstance,
1740 aThreshold: i8,
1741 ) -> otError;
1742}
1743extern "C" {
1744 #[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."]
1745 pub fn otPlatRadioGetFemLnaGain(aInstance: *mut otInstance, aGain: *mut i8) -> otError;
1746}
1747extern "C" {
1748 #[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."]
1749 pub fn otPlatRadioSetFemLnaGain(aInstance: *mut otInstance, aGain: i8) -> otError;
1750}
1751extern "C" {
1752 #[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."]
1753 pub fn otPlatRadioGetPromiscuous(aInstance: *mut otInstance) -> bool;
1754}
1755extern "C" {
1756 #[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."]
1757 pub fn otPlatRadioSetPromiscuous(aInstance: *mut otInstance, aEnable: bool);
1758}
1759extern "C" {
1760 #[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."]
1761 pub fn otPlatRadioSetRxOnWhenIdle(aInstance: *mut otInstance, aEnable: bool);
1762}
1763extern "C" {
1764 #[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."]
1765 pub fn otPlatRadioSetMacKey(
1766 aInstance: *mut otInstance,
1767 aKeyIdMode: u8,
1768 aKeyId: u8,
1769 aPrevKey: *const otMacKeyMaterial,
1770 aCurrKey: *const otMacKeyMaterial,
1771 aNextKey: *const otMacKeyMaterial,
1772 aKeyType: otRadioKeyType,
1773 );
1774}
1775extern "C" {
1776 #[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."]
1777 pub fn otPlatRadioSetMacFrameCounter(aInstance: *mut otInstance, aMacFrameCounter: u32);
1778}
1779extern "C" {
1780 #[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."]
1781 pub fn otPlatRadioSetMacFrameCounterIfLarger(aInstance: *mut otInstance, aMacFrameCounter: u32);
1782}
1783extern "C" {
1784 #[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."]
1785 pub fn otPlatRadioGetNow(aInstance: *mut otInstance) -> u64;
1786}
1787extern "C" {
1788 #[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."]
1789 pub fn otPlatRadioGetBusSpeed(aInstance: *mut otInstance) -> u32;
1790}
1791extern "C" {
1792 #[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."]
1793 pub fn otPlatRadioGetBusLatency(aInstance: *mut otInstance) -> u32;
1794}
1795extern "C" {
1796 #[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."]
1797 pub fn otPlatRadioGetState(aInstance: *mut otInstance) -> otRadioState;
1798}
1799extern "C" {
1800 #[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."]
1801 pub fn otPlatRadioEnable(aInstance: *mut otInstance) -> otError;
1802}
1803extern "C" {
1804 #[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."]
1805 pub fn otPlatRadioDisable(aInstance: *mut otInstance) -> otError;
1806}
1807extern "C" {
1808 #[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."]
1809 pub fn otPlatRadioIsEnabled(aInstance: *mut otInstance) -> bool;
1810}
1811extern "C" {
1812 #[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."]
1813 pub fn otPlatRadioSleep(aInstance: *mut otInstance) -> otError;
1814}
1815extern "C" {
1816 #[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."]
1817 pub fn otPlatRadioReceive(aInstance: *mut otInstance, aChannel: u8) -> otError;
1818}
1819extern "C" {
1820 #[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."]
1821 pub fn otPlatRadioReceiveAt(
1822 aInstance: *mut otInstance,
1823 aChannel: u8,
1824 aStart: u32,
1825 aDuration: u32,
1826 ) -> otError;
1827}
1828extern "C" {
1829 #[doc = " The radio driver calls this function 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."]
1830 pub fn otPlatRadioReceiveDone(
1831 aInstance: *mut otInstance,
1832 aFrame: *mut otRadioFrame,
1833 aError: otError,
1834 );
1835}
1836extern "C" {
1837 #[doc = " The radio driver calls this function 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."]
1838 pub fn otPlatDiagRadioReceiveDone(
1839 aInstance: *mut otInstance,
1840 aFrame: *mut otRadioFrame,
1841 aError: otError,
1842 );
1843}
1844extern "C" {
1845 #[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."]
1846 pub fn otPlatRadioGetTransmitBuffer(aInstance: *mut otInstance) -> *mut otRadioFrame;
1847}
1848extern "C" {
1849 #[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."]
1850 pub fn otPlatRadioTransmit(aInstance: *mut otInstance, aFrame: *mut otRadioFrame) -> otError;
1851}
1852extern "C" {
1853 #[doc = " The radio driver calls this function 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."]
1854 pub fn otPlatRadioTxStarted(aInstance: *mut otInstance, aFrame: *mut otRadioFrame);
1855}
1856extern "C" {
1857 #[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."]
1858 pub fn otPlatRadioTxDone(
1859 aInstance: *mut otInstance,
1860 aFrame: *mut otRadioFrame,
1861 aAckFrame: *mut otRadioFrame,
1862 aError: otError,
1863 );
1864}
1865extern "C" {
1866 #[doc = " The radio driver calls this function 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."]
1867 pub fn otPlatDiagRadioTransmitDone(
1868 aInstance: *mut otInstance,
1869 aFrame: *mut otRadioFrame,
1870 aError: otError,
1871 );
1872}
1873extern "C" {
1874 #[doc = " Return a recent RSSI measurement when the radio is in receive state.\n\n If the radio is not in receive state, then `OT_RADIO_RSSI_INVALID` MUST be returned. If the radio is in receive\n state, then a single RSSI measurement is taken on the current receive channel and returned.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The RSSI in dBm when it is valid. `OT_RADIO_RSSI_INVALID` when RSSI is invalid."]
1875 pub fn otPlatRadioGetRssi(aInstance: *mut otInstance) -> i8;
1876}
1877extern "C" {
1878 #[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."]
1879 pub fn otPlatRadioEnergyScan(
1880 aInstance: *mut otInstance,
1881 aScanChannel: u8,
1882 aScanDuration: u16,
1883 ) -> otError;
1884}
1885extern "C" {
1886 #[doc = " The radio driver calls this function 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."]
1887 pub fn otPlatRadioEnergyScanDone(aInstance: *mut otInstance, aEnergyScanMaxRssi: i8);
1888}
1889extern "C" {
1890 #[doc = " The radio driver calls this function to notify OpenThread that the spinel bus latency has been changed.\n\n @param[in] aInstance The OpenThread instance structure."]
1891 pub fn otPlatRadioBusLatencyChanged(aInstance: *mut otInstance);
1892}
1893extern "C" {
1894 #[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."]
1895 pub fn otPlatRadioEnableSrcMatch(aInstance: *mut otInstance, aEnable: bool);
1896}
1897extern "C" {
1898 #[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."]
1899 pub fn otPlatRadioAddSrcMatchShortEntry(
1900 aInstance: *mut otInstance,
1901 aShortAddress: otShortAddress,
1902 ) -> otError;
1903}
1904extern "C" {
1905 #[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."]
1906 pub fn otPlatRadioAddSrcMatchExtEntry(
1907 aInstance: *mut otInstance,
1908 aExtAddress: *const otExtAddress,
1909 ) -> otError;
1910}
1911extern "C" {
1912 #[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."]
1913 pub fn otPlatRadioClearSrcMatchShortEntry(
1914 aInstance: *mut otInstance,
1915 aShortAddress: otShortAddress,
1916 ) -> otError;
1917}
1918extern "C" {
1919 #[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."]
1920 pub fn otPlatRadioClearSrcMatchExtEntry(
1921 aInstance: *mut otInstance,
1922 aExtAddress: *const otExtAddress,
1923 ) -> otError;
1924}
1925extern "C" {
1926 #[doc = " Clear all short addresses from the source address match table.\n\n @param[in] aInstance The OpenThread instance structure."]
1927 pub fn otPlatRadioClearSrcMatchShortEntries(aInstance: *mut otInstance);
1928}
1929extern "C" {
1930 #[doc = " Clear all the extended/long addresses from source address match table.\n\n @param[in] aInstance The OpenThread instance structure."]
1931 pub fn otPlatRadioClearSrcMatchExtEntries(aInstance: *mut otInstance);
1932}
1933extern "C" {
1934 #[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."]
1935 pub fn otPlatRadioGetSupportedChannelMask(aInstance: *mut otInstance) -> u32;
1936}
1937extern "C" {
1938 #[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."]
1939 pub fn otPlatRadioGetPreferredChannelMask(aInstance: *mut otInstance) -> u32;
1940}
1941extern "C" {
1942 #[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."]
1943 pub fn otPlatRadioSetCoexEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
1944}
1945extern "C" {
1946 #[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."]
1947 pub fn otPlatRadioIsCoexEnabled(aInstance: *mut otInstance) -> bool;
1948}
1949extern "C" {
1950 #[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."]
1951 pub fn otPlatRadioGetCoexMetrics(
1952 aInstance: *mut otInstance,
1953 aCoexMetrics: *mut otRadioCoexMetrics,
1954 ) -> otError;
1955}
1956extern "C" {
1957 #[doc = " Enable or disable CSL receiver.\n\n Regarding @p aExtAddr, this function assumes big-endian byte order. Note that this differs from\n `otPlatRadioSetExtendedAddress()`, `otPlatRadioAddSrcMatchExtEntry()`, and `otPlatRadioClearSrcMatchExtEntry()`,\n which use little-endian byte order for the Extended MAC address.\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. The @p aExtAddr assumes big-endian\n byte order.\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."]
1958 pub fn otPlatRadioEnableCsl(
1959 aInstance: *mut otInstance,
1960 aCslPeriod: u32,
1961 aShortAddr: otShortAddress,
1962 aExtAddr: *const otExtAddress,
1963 ) -> otError;
1964}
1965extern "C" {
1966 #[doc = " Reset CSL receiver in the platform.\n\n @note Defaults to `otPlatRadioEnableCsl(aInstance,0, Mac::kShortAddrInvalid, NULL);`\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."]
1967 pub fn otPlatRadioResetCsl(aInstance: *mut otInstance) -> otError;
1968}
1969extern "C" {
1970 #[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."]
1971 pub fn otPlatRadioUpdateCslSampleTime(aInstance: *mut otInstance, aCslSampleTime: u32);
1972}
1973extern "C" {
1974 #[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."]
1975 pub fn otPlatRadioGetCslAccuracy(aInstance: *mut otInstance) -> u8;
1976}
1977extern "C" {
1978 #[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."]
1979 pub fn otPlatRadioGetCslUncertainty(aInstance: *mut otInstance) -> u8;
1980}
1981extern "C" {
1982 #[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."]
1983 pub fn otPlatRadioSetChannelMaxTransmitPower(
1984 aInstance: *mut otInstance,
1985 aChannel: u8,
1986 aMaxPower: i8,
1987 ) -> otError;
1988}
1989extern "C" {
1990 #[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."]
1991 pub fn otPlatRadioSetRegion(aInstance: *mut otInstance, aRegionCode: u16) -> otError;
1992}
1993extern "C" {
1994 #[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 NULL.\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."]
1995 pub fn otPlatRadioGetRegion(aInstance: *mut otInstance, aRegionCode: *mut u16) -> otError;
1996}
1997extern "C" {
1998 #[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 function 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 Regarding @p aExtAddress, this function assumes big-endian byte order. Note that this differs from\n `otPlatRadioSetExtendedAddress()`, `otPlatRadioAddSrcMatchExtEntry()`, and `otPlatRadioClearSrcMatchExtEntry()`,\n which use little-endian byte order for the Extended MAC address.\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 aExtAddress MUST NOT be `NULL`.\n The @p aExtAddress assumes big-endian byte order.\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."]
1999 pub fn otPlatRadioConfigureEnhAckProbing(
2000 aInstance: *mut otInstance,
2001 aLinkMetrics: otLinkMetrics,
2002 aShortAddress: otShortAddress,
2003 aExtAddress: *const otExtAddress,
2004 ) -> otError;
2005}
2006extern "C" {
2007 #[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."]
2008 pub fn otPlatRadioAddCalibratedPower(
2009 aInstance: *mut otInstance,
2010 aChannel: u8,
2011 aActualPower: i16,
2012 aRawPowerSetting: *const u8,
2013 aRawPowerSettingLength: u16,
2014 ) -> otError;
2015}
2016extern "C" {
2017 #[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."]
2018 pub fn otPlatRadioClearCalibratedPowers(aInstance: *mut otInstance) -> otError;
2019}
2020extern "C" {
2021 #[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."]
2022 pub fn otPlatRadioSetChannelTargetPower(
2023 aInstance: *mut otInstance,
2024 aChannel: u8,
2025 aTargetPower: i16,
2026 ) -> otError;
2027}
2028extern "C" {
2029 #[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."]
2030 pub fn otPlatRadioGetRawPowerSetting(
2031 aInstance: *mut otInstance,
2032 aChannel: u8,
2033 aRawPowerSetting: *mut u8,
2034 aRawPowerSettingLength: *mut u16,
2035 ) -> otError;
2036}
2037#[doc = " @struct otIp6InterfaceIdentifier\n\n Represents the Interface Identifier of an IPv6 address."]
2038#[repr(C, packed)]
2039#[derive(Copy, Clone)]
2040pub struct otIp6InterfaceIdentifier {
2041 #[doc = "< The Interface Identifier accessor fields"]
2042 pub mFields: otIp6InterfaceIdentifier__bindgen_ty_1,
2043}
2044#[repr(C, packed)]
2045#[derive(Copy, Clone)]
2046pub union otIp6InterfaceIdentifier__bindgen_ty_1 {
2047 #[doc = "< 8-bit fields"]
2048 pub m8: [u8; 8usize],
2049 #[doc = "< 16-bit fields"]
2050 pub m16: [u16; 4usize],
2051 #[doc = "< 32-bit fields"]
2052 pub m32: [u32; 2usize],
2053}
2054impl Default for otIp6InterfaceIdentifier__bindgen_ty_1 {
2055 fn default() -> Self {
2056 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2057 unsafe {
2058 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2059 s.assume_init()
2060 }
2061 }
2062}
2063impl Default for otIp6InterfaceIdentifier {
2064 fn default() -> Self {
2065 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2066 unsafe {
2067 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2068 s.assume_init()
2069 }
2070 }
2071}
2072#[doc = " @struct otIp6NetworkPrefix\n\n Represents the Network Prefix of an IPv6 address (most significant 64 bits of the address)."]
2073#[repr(C, packed)]
2074#[derive(Debug, Default, Copy, Clone)]
2075pub struct otIp6NetworkPrefix {
2076 #[doc = "< The Network Prefix."]
2077 pub m8: [u8; 8usize],
2078}
2079#[doc = " @struct otIp6AddressComponents\n\n Represents the components of an IPv6 address."]
2080#[repr(C, packed)]
2081#[derive(Copy, Clone)]
2082pub struct otIp6AddressComponents {
2083 #[doc = "< The Network Prefix (most significant 64 bits of the address)"]
2084 pub mNetworkPrefix: otIp6NetworkPrefix,
2085 #[doc = "< The Interface Identifier (least significant 64 bits of the address)"]
2086 pub mIid: otIp6InterfaceIdentifier,
2087}
2088impl Default for otIp6AddressComponents {
2089 fn default() -> Self {
2090 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2091 unsafe {
2092 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2093 s.assume_init()
2094 }
2095 }
2096}
2097#[doc = " @struct otIp6Address\n\n Represents an IPv6 address."]
2098#[repr(C, packed)]
2099#[derive(Copy, Clone)]
2100pub struct otIp6Address {
2101 #[doc = "< IPv6 accessor fields"]
2102 pub mFields: otIp6Address__bindgen_ty_1,
2103}
2104#[repr(C, packed)]
2105#[derive(Copy, Clone)]
2106pub union otIp6Address__bindgen_ty_1 {
2107 #[doc = "< 8-bit fields"]
2108 pub m8: [u8; 16usize],
2109 #[doc = "< 16-bit fields"]
2110 pub m16: [u16; 8usize],
2111 #[doc = "< 32-bit fields"]
2112 pub m32: [u32; 4usize],
2113 #[doc = "< IPv6 address components"]
2114 pub mComponents: otIp6AddressComponents,
2115}
2116impl Default for otIp6Address__bindgen_ty_1 {
2117 fn default() -> Self {
2118 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2119 unsafe {
2120 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2121 s.assume_init()
2122 }
2123 }
2124}
2125impl Default for otIp6Address {
2126 fn default() -> Self {
2127 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2128 unsafe {
2129 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2130 s.assume_init()
2131 }
2132 }
2133}
2134#[doc = " @struct otIp6Prefix\n\n Represents an IPv6 prefix."]
2135#[repr(C, packed)]
2136#[derive(Copy, Clone)]
2137pub struct otIp6Prefix {
2138 #[doc = "< The IPv6 prefix."]
2139 pub mPrefix: otIp6Address,
2140 #[doc = "< The IPv6 prefix length (in bits)."]
2141 pub mLength: u8,
2142}
2143impl Default for otIp6Prefix {
2144 fn default() -> Self {
2145 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2146 unsafe {
2147 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2148 s.assume_init()
2149 }
2150 }
2151}
2152#[doc = "< Thread assigned address (ALOC, RLOC, MLEID, etc)"]
2153pub const OT_ADDRESS_ORIGIN_THREAD: _bindgen_ty_7 = 0;
2154#[doc = "< SLAAC assigned address"]
2155pub const OT_ADDRESS_ORIGIN_SLAAC: _bindgen_ty_7 = 1;
2156#[doc = "< DHCPv6 assigned address"]
2157pub const OT_ADDRESS_ORIGIN_DHCPV6: _bindgen_ty_7 = 2;
2158#[doc = "< Manually assigned address"]
2159pub const OT_ADDRESS_ORIGIN_MANUAL: _bindgen_ty_7 = 3;
2160#[doc = " IPv6 Address origins"]
2161pub type _bindgen_ty_7 = ::std::os::raw::c_uint;
2162#[doc = " Represents an IPv6 network interface unicast address."]
2163#[repr(C)]
2164#[derive(Copy, Clone)]
2165pub struct otNetifAddress {
2166 #[doc = "< The IPv6 unicast address."]
2167 pub mAddress: otIp6Address,
2168 #[doc = "< The Prefix length (in bits)."]
2169 pub mPrefixLength: u8,
2170 #[doc = "< The IPv6 address origin."]
2171 pub mAddressOrigin: u8,
2172 pub _bitfield_align_1: [u8; 0],
2173 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2174 #[doc = "< A pointer to the next network interface address."]
2175 pub mNext: *const otNetifAddress,
2176}
2177impl Default for otNetifAddress {
2178 fn default() -> Self {
2179 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2180 unsafe {
2181 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2182 s.assume_init()
2183 }
2184 }
2185}
2186impl otNetifAddress {
2187 #[inline]
2188 pub fn mPreferred(&self) -> bool {
2189 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2190 }
2191 #[inline]
2192 pub fn set_mPreferred(&mut self, val: bool) {
2193 unsafe {
2194 let val: u8 = ::std::mem::transmute(val);
2195 self._bitfield_1.set(0usize, 1u8, val as u64)
2196 }
2197 }
2198 #[inline]
2199 pub fn mValid(&self) -> bool {
2200 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
2201 }
2202 #[inline]
2203 pub fn set_mValid(&mut self, val: bool) {
2204 unsafe {
2205 let val: u8 = ::std::mem::transmute(val);
2206 self._bitfield_1.set(1usize, 1u8, val as u64)
2207 }
2208 }
2209 #[inline]
2210 pub fn mScopeOverrideValid(&self) -> bool {
2211 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2212 }
2213 #[inline]
2214 pub fn set_mScopeOverrideValid(&mut self, val: bool) {
2215 unsafe {
2216 let val: u8 = ::std::mem::transmute(val);
2217 self._bitfield_1.set(2usize, 1u8, val as u64)
2218 }
2219 }
2220 #[inline]
2221 pub fn mScopeOverride(&self) -> ::std::os::raw::c_uint {
2222 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 4u8) as u32) }
2223 }
2224 #[inline]
2225 pub fn set_mScopeOverride(&mut self, val: ::std::os::raw::c_uint) {
2226 unsafe {
2227 let val: u32 = ::std::mem::transmute(val);
2228 self._bitfield_1.set(3usize, 4u8, val as u64)
2229 }
2230 }
2231 #[inline]
2232 pub fn mRloc(&self) -> bool {
2233 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
2234 }
2235 #[inline]
2236 pub fn set_mRloc(&mut self, val: bool) {
2237 unsafe {
2238 let val: u8 = ::std::mem::transmute(val);
2239 self._bitfield_1.set(7usize, 1u8, val as u64)
2240 }
2241 }
2242 #[inline]
2243 pub fn mMeshLocal(&self) -> bool {
2244 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
2245 }
2246 #[inline]
2247 pub fn set_mMeshLocal(&mut self, val: bool) {
2248 unsafe {
2249 let val: u8 = ::std::mem::transmute(val);
2250 self._bitfield_1.set(8usize, 1u8, val as u64)
2251 }
2252 }
2253 #[inline]
2254 pub fn mSrpRegistered(&self) -> bool {
2255 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
2256 }
2257 #[inline]
2258 pub fn set_mSrpRegistered(&mut self, val: bool) {
2259 unsafe {
2260 let val: u8 = ::std::mem::transmute(val);
2261 self._bitfield_1.set(9usize, 1u8, val as u64)
2262 }
2263 }
2264 #[inline]
2265 pub fn new_bitfield_1(
2266 mPreferred: bool,
2267 mValid: bool,
2268 mScopeOverrideValid: bool,
2269 mScopeOverride: ::std::os::raw::c_uint,
2270 mRloc: bool,
2271 mMeshLocal: bool,
2272 mSrpRegistered: bool,
2273 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2274 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
2275 __bindgen_bitfield_unit.set(0usize, 1u8, {
2276 let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
2277 mPreferred as u64
2278 });
2279 __bindgen_bitfield_unit.set(1usize, 1u8, {
2280 let mValid: u8 = unsafe { ::std::mem::transmute(mValid) };
2281 mValid as u64
2282 });
2283 __bindgen_bitfield_unit.set(2usize, 1u8, {
2284 let mScopeOverrideValid: u8 = unsafe { ::std::mem::transmute(mScopeOverrideValid) };
2285 mScopeOverrideValid as u64
2286 });
2287 __bindgen_bitfield_unit.set(3usize, 4u8, {
2288 let mScopeOverride: u32 = unsafe { ::std::mem::transmute(mScopeOverride) };
2289 mScopeOverride as u64
2290 });
2291 __bindgen_bitfield_unit.set(7usize, 1u8, {
2292 let mRloc: u8 = unsafe { ::std::mem::transmute(mRloc) };
2293 mRloc as u64
2294 });
2295 __bindgen_bitfield_unit.set(8usize, 1u8, {
2296 let mMeshLocal: u8 = unsafe { ::std::mem::transmute(mMeshLocal) };
2297 mMeshLocal as u64
2298 });
2299 __bindgen_bitfield_unit.set(9usize, 1u8, {
2300 let mSrpRegistered: u8 = unsafe { ::std::mem::transmute(mSrpRegistered) };
2301 mSrpRegistered as u64
2302 });
2303 __bindgen_bitfield_unit
2304 }
2305}
2306#[doc = " Represents an IPv6 network interface multicast address."]
2307#[repr(C)]
2308#[derive(Copy, Clone)]
2309pub struct otNetifMulticastAddress {
2310 #[doc = "< The IPv6 multicast address."]
2311 pub mAddress: otIp6Address,
2312 #[doc = "< A pointer to the next network interface multicast address."]
2313 pub mNext: *const otNetifMulticastAddress,
2314}
2315impl Default for otNetifMulticastAddress {
2316 fn default() -> Self {
2317 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2318 unsafe {
2319 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2320 s.assume_init()
2321 }
2322 }
2323}
2324#[doc = " Represents an IPv6 socket address."]
2325#[repr(C)]
2326#[derive(Copy, Clone)]
2327pub struct otSockAddr {
2328 #[doc = "< An IPv6 address."]
2329 pub mAddress: otIp6Address,
2330 #[doc = "< A transport-layer port."]
2331 pub mPort: u16,
2332}
2333impl Default for otSockAddr {
2334 fn default() -> Self {
2335 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2336 unsafe {
2337 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2338 s.assume_init()
2339 }
2340 }
2341}
2342#[doc = "< Non-ECT"]
2343pub const OT_ECN_NOT_CAPABLE: _bindgen_ty_8 = 0;
2344#[doc = "< ECT(0)"]
2345pub const OT_ECN_CAPABLE_0: _bindgen_ty_8 = 2;
2346#[doc = "< ECT(1)"]
2347pub const OT_ECN_CAPABLE_1: _bindgen_ty_8 = 1;
2348#[doc = "< Congestion encountered (CE)"]
2349pub const OT_ECN_MARKED: _bindgen_ty_8 = 3;
2350#[doc = " ECN statuses, represented as in the IP header."]
2351pub type _bindgen_ty_8 = ::std::os::raw::c_uint;
2352#[doc = " Represents the local and peer IPv6 socket addresses."]
2353#[repr(C)]
2354#[derive(Copy, Clone)]
2355pub struct otMessageInfo {
2356 #[doc = "< The local IPv6 address."]
2357 pub mSockAddr: otIp6Address,
2358 #[doc = "< The peer IPv6 address."]
2359 pub mPeerAddr: otIp6Address,
2360 #[doc = "< The local transport-layer port."]
2361 pub mSockPort: u16,
2362 #[doc = "< The peer transport-layer port."]
2363 pub mPeerPort: u16,
2364 #[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."]
2365 pub mHopLimit: u8,
2366 pub _bitfield_align_1: [u8; 0],
2367 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2368}
2369impl Default for otMessageInfo {
2370 fn default() -> Self {
2371 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2372 unsafe {
2373 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2374 s.assume_init()
2375 }
2376 }
2377}
2378impl otMessageInfo {
2379 #[inline]
2380 pub fn mEcn(&self) -> u8 {
2381 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
2382 }
2383 #[inline]
2384 pub fn set_mEcn(&mut self, val: u8) {
2385 unsafe {
2386 let val: u8 = ::std::mem::transmute(val);
2387 self._bitfield_1.set(0usize, 2u8, val as u64)
2388 }
2389 }
2390 #[inline]
2391 pub fn mIsHostInterface(&self) -> bool {
2392 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2393 }
2394 #[inline]
2395 pub fn set_mIsHostInterface(&mut self, val: bool) {
2396 unsafe {
2397 let val: u8 = ::std::mem::transmute(val);
2398 self._bitfield_1.set(2usize, 1u8, val as u64)
2399 }
2400 }
2401 #[inline]
2402 pub fn mAllowZeroHopLimit(&self) -> bool {
2403 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
2404 }
2405 #[inline]
2406 pub fn set_mAllowZeroHopLimit(&mut self, val: bool) {
2407 unsafe {
2408 let val: u8 = ::std::mem::transmute(val);
2409 self._bitfield_1.set(3usize, 1u8, val as u64)
2410 }
2411 }
2412 #[inline]
2413 pub fn mMulticastLoop(&self) -> bool {
2414 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2415 }
2416 #[inline]
2417 pub fn set_mMulticastLoop(&mut self, val: bool) {
2418 unsafe {
2419 let val: u8 = ::std::mem::transmute(val);
2420 self._bitfield_1.set(4usize, 1u8, val as u64)
2421 }
2422 }
2423 #[inline]
2424 pub fn new_bitfield_1(
2425 mEcn: u8,
2426 mIsHostInterface: bool,
2427 mAllowZeroHopLimit: bool,
2428 mMulticastLoop: bool,
2429 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2430 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2431 __bindgen_bitfield_unit.set(0usize, 2u8, {
2432 let mEcn: u8 = unsafe { ::std::mem::transmute(mEcn) };
2433 mEcn as u64
2434 });
2435 __bindgen_bitfield_unit.set(2usize, 1u8, {
2436 let mIsHostInterface: u8 = unsafe { ::std::mem::transmute(mIsHostInterface) };
2437 mIsHostInterface as u64
2438 });
2439 __bindgen_bitfield_unit.set(3usize, 1u8, {
2440 let mAllowZeroHopLimit: u8 = unsafe { ::std::mem::transmute(mAllowZeroHopLimit) };
2441 mAllowZeroHopLimit as u64
2442 });
2443 __bindgen_bitfield_unit.set(4usize, 1u8, {
2444 let mMulticastLoop: u8 = unsafe { ::std::mem::transmute(mMulticastLoop) };
2445 mMulticastLoop as u64
2446 });
2447 __bindgen_bitfield_unit
2448 }
2449}
2450#[doc = "< IPv6 Hop-by-Hop Option"]
2451pub const OT_IP6_PROTO_HOP_OPTS: _bindgen_ty_9 = 0;
2452#[doc = "< Transmission Control Protocol"]
2453pub const OT_IP6_PROTO_TCP: _bindgen_ty_9 = 6;
2454#[doc = "< User Datagram"]
2455pub const OT_IP6_PROTO_UDP: _bindgen_ty_9 = 17;
2456#[doc = "< IPv6 encapsulation"]
2457pub const OT_IP6_PROTO_IP6: _bindgen_ty_9 = 41;
2458#[doc = "< Routing Header for IPv6"]
2459pub const OT_IP6_PROTO_ROUTING: _bindgen_ty_9 = 43;
2460#[doc = "< Fragment Header for IPv6"]
2461pub const OT_IP6_PROTO_FRAGMENT: _bindgen_ty_9 = 44;
2462#[doc = "< ICMP for IPv6"]
2463pub const OT_IP6_PROTO_ICMP6: _bindgen_ty_9 = 58;
2464#[doc = "< No Next Header for IPv6"]
2465pub const OT_IP6_PROTO_NONE: _bindgen_ty_9 = 59;
2466#[doc = "< Destination Options for IPv6"]
2467pub const OT_IP6_PROTO_DST_OPTS: _bindgen_ty_9 = 60;
2468#[doc = " Internet Protocol Numbers."]
2469pub type _bindgen_ty_9 = ::std::os::raw::c_uint;
2470extern "C" {
2471 #[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)."]
2472 pub fn otIp6SetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
2473}
2474extern "C" {
2475 #[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."]
2476 pub fn otIp6IsEnabled(aInstance: *mut otInstance) -> bool;
2477}
2478extern "C" {
2479 #[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."]
2480 pub fn otIp6AddUnicastAddress(
2481 aInstance: *mut otInstance,
2482 aAddress: *const otNetifAddress,
2483 ) -> otError;
2484}
2485extern "C" {
2486 #[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."]
2487 pub fn otIp6RemoveUnicastAddress(
2488 aInstance: *mut otInstance,
2489 aAddress: *const otIp6Address,
2490 ) -> otError;
2491}
2492extern "C" {
2493 #[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."]
2494 pub fn otIp6GetUnicastAddresses(aInstance: *mut otInstance) -> *const otNetifAddress;
2495}
2496extern "C" {
2497 #[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."]
2498 pub fn otIp6HasUnicastAddress(
2499 aInstance: *mut otInstance,
2500 aAddress: *const otIp6Address,
2501 ) -> bool;
2502}
2503extern "C" {
2504 #[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."]
2505 pub fn otIp6SubscribeMulticastAddress(
2506 aInstance: *mut otInstance,
2507 aAddress: *const otIp6Address,
2508 ) -> otError;
2509}
2510extern "C" {
2511 #[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."]
2512 pub fn otIp6UnsubscribeMulticastAddress(
2513 aInstance: *mut otInstance,
2514 aAddress: *const otIp6Address,
2515 ) -> otError;
2516}
2517extern "C" {
2518 #[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."]
2519 pub fn otIp6GetMulticastAddresses(aInstance: *mut otInstance)
2520 -> *const otNetifMulticastAddress;
2521}
2522extern "C" {
2523 #[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"]
2524 pub fn otIp6NewMessage(
2525 aInstance: *mut otInstance,
2526 aSettings: *const otMessageSettings,
2527 ) -> *mut otMessage;
2528}
2529extern "C" {
2530 #[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"]
2531 pub fn otIp6NewMessageFromBuffer(
2532 aInstance: *mut otInstance,
2533 aData: *const u8,
2534 aDataLength: u16,
2535 aSettings: *const otMessageSettings,
2536 ) -> *mut otMessage;
2537}
2538#[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."]
2539pub type otIp6ReceiveCallback = ::std::option::Option<
2540 unsafe extern "C" fn(aMessage: *mut otMessage, aContext: *mut ::std::os::raw::c_void),
2541>;
2542extern "C" {
2543 #[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"]
2544 pub fn otIp6SetReceiveCallback(
2545 aInstance: *mut otInstance,
2546 aCallback: otIp6ReceiveCallback,
2547 aCallbackContext: *mut ::std::os::raw::c_void,
2548 );
2549}
2550#[doc = " Represents IPv6 address information."]
2551#[repr(C)]
2552#[derive(Debug, Copy, Clone)]
2553pub struct otIp6AddressInfo {
2554 #[doc = "< A pointer to the IPv6 address."]
2555 pub mAddress: *const otIp6Address,
2556 #[doc = "< The prefix length of mAddress if it is a unicast address."]
2557 pub mPrefixLength: u8,
2558 pub _bitfield_align_1: [u8; 0],
2559 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
2560 pub __bindgen_padding_0: [u16; 3usize],
2561}
2562impl Default for otIp6AddressInfo {
2563 fn default() -> Self {
2564 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
2565 unsafe {
2566 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
2567 s.assume_init()
2568 }
2569 }
2570}
2571impl otIp6AddressInfo {
2572 #[inline]
2573 pub fn mScope(&self) -> u8 {
2574 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
2575 }
2576 #[inline]
2577 pub fn set_mScope(&mut self, val: u8) {
2578 unsafe {
2579 let val: u8 = ::std::mem::transmute(val);
2580 self._bitfield_1.set(0usize, 4u8, val as u64)
2581 }
2582 }
2583 #[inline]
2584 pub fn mPreferred(&self) -> bool {
2585 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2586 }
2587 #[inline]
2588 pub fn set_mPreferred(&mut self, val: bool) {
2589 unsafe {
2590 let val: u8 = ::std::mem::transmute(val);
2591 self._bitfield_1.set(4usize, 1u8, val as u64)
2592 }
2593 }
2594 #[inline]
2595 pub fn mMeshLocal(&self) -> bool {
2596 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
2597 }
2598 #[inline]
2599 pub fn set_mMeshLocal(&mut self, val: bool) {
2600 unsafe {
2601 let val: u8 = ::std::mem::transmute(val);
2602 self._bitfield_1.set(5usize, 1u8, val as u64)
2603 }
2604 }
2605 #[inline]
2606 pub fn new_bitfield_1(
2607 mScope: u8,
2608 mPreferred: bool,
2609 mMeshLocal: bool,
2610 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
2611 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
2612 __bindgen_bitfield_unit.set(0usize, 4u8, {
2613 let mScope: u8 = unsafe { ::std::mem::transmute(mScope) };
2614 mScope as u64
2615 });
2616 __bindgen_bitfield_unit.set(4usize, 1u8, {
2617 let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
2618 mPreferred as u64
2619 });
2620 __bindgen_bitfield_unit.set(5usize, 1u8, {
2621 let mMeshLocal: u8 = unsafe { ::std::mem::transmute(mMeshLocal) };
2622 mMeshLocal as u64
2623 });
2624 __bindgen_bitfield_unit
2625 }
2626}
2627#[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."]
2628pub type otIp6AddressCallback = ::std::option::Option<
2629 unsafe extern "C" fn(
2630 aAddressInfo: *const otIp6AddressInfo,
2631 aIsAdded: bool,
2632 aContext: *mut ::std::os::raw::c_void,
2633 ),
2634>;
2635extern "C" {
2636 #[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."]
2637 pub fn otIp6SetAddressCallback(
2638 aInstance: *mut otInstance,
2639 aCallback: otIp6AddressCallback,
2640 aCallbackContext: *mut ::std::os::raw::c_void,
2641 );
2642}
2643extern "C" {
2644 #[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"]
2645 pub fn otIp6IsReceiveFilterEnabled(aInstance: *mut otInstance) -> bool;
2646}
2647extern "C" {
2648 #[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"]
2649 pub fn otIp6SetReceiveFilterEnabled(aInstance: *mut otInstance, aEnabled: bool);
2650}
2651extern "C" {
2652 #[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."]
2653 pub fn otIp6Send(aInstance: *mut otInstance, aMessage: *mut otMessage) -> otError;
2654}
2655extern "C" {
2656 #[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."]
2657 pub fn otIp6AddUnsecurePort(aInstance: *mut otInstance, aPort: u16) -> otError;
2658}
2659extern "C" {
2660 #[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."]
2661 pub fn otIp6RemoveUnsecurePort(aInstance: *mut otInstance, aPort: u16) -> otError;
2662}
2663extern "C" {
2664 #[doc = " Removes all ports from the allowed unsecure port list.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
2665 pub fn otIp6RemoveAllUnsecurePorts(aInstance: *mut otInstance);
2666}
2667extern "C" {
2668 #[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."]
2669 pub fn otIp6GetUnsecurePorts(aInstance: *mut otInstance, aNumEntries: *mut u8) -> *const u16;
2670}
2671extern "C" {
2672 #[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."]
2673 pub fn otIp6IsAddressEqual(aFirst: *const otIp6Address, aSecond: *const otIp6Address) -> bool;
2674}
2675extern "C" {
2676 #[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."]
2677 pub fn otIp6ArePrefixesEqual(aFirst: *const otIp6Prefix, aSecond: *const otIp6Prefix) -> bool;
2678}
2679extern "C" {
2680 #[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."]
2681 pub fn otIp6AddressFromString(
2682 aString: *const ::std::os::raw::c_char,
2683 aAddress: *mut otIp6Address,
2684 ) -> otError;
2685}
2686extern "C" {
2687 #[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."]
2688 pub fn otIp6PrefixFromString(
2689 aString: *const ::std::os::raw::c_char,
2690 aPrefix: *mut otIp6Prefix,
2691 ) -> otError;
2692}
2693extern "C" {
2694 #[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`."]
2695 pub fn otIp6AddressToString(
2696 aAddress: *const otIp6Address,
2697 aBuffer: *mut ::std::os::raw::c_char,
2698 aSize: u16,
2699 );
2700}
2701extern "C" {
2702 #[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`."]
2703 pub fn otIp6SockAddrToString(
2704 aSockAddr: *const otSockAddr,
2705 aBuffer: *mut ::std::os::raw::c_char,
2706 aSize: u16,
2707 );
2708}
2709extern "C" {
2710 #[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`."]
2711 pub fn otIp6PrefixToString(
2712 aPrefix: *const otIp6Prefix,
2713 aBuffer: *mut ::std::os::raw::c_char,
2714 aSize: u16,
2715 );
2716}
2717extern "C" {
2718 #[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."]
2719 pub fn otIp6PrefixMatch(aFirst: *const otIp6Address, aSecond: *const otIp6Address) -> u8;
2720}
2721extern "C" {
2722 #[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."]
2723 pub fn otIp6GetPrefix(aAddress: *const otIp6Address, aLength: u8, aPrefix: *mut otIp6Prefix);
2724}
2725extern "C" {
2726 #[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."]
2727 pub fn otIp6IsAddressUnspecified(aAddress: *const otIp6Address) -> bool;
2728}
2729extern "C" {
2730 #[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."]
2731 pub fn otIp6SelectSourceAddress(
2732 aInstance: *mut otInstance,
2733 aMessageInfo: *mut otMessageInfo,
2734 ) -> otError;
2735}
2736extern "C" {
2737 #[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."]
2738 pub fn otIp6IsSlaacEnabled(aInstance: *mut otInstance) -> bool;
2739}
2740extern "C" {
2741 #[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."]
2742 pub fn otIp6SetSlaacEnabled(aInstance: *mut otInstance, aEnabled: bool);
2743}
2744#[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."]
2745pub type otIp6SlaacPrefixFilter = ::std::option::Option<
2746 unsafe extern "C" fn(aInstance: *mut otInstance, aPrefix: *const otIp6Prefix) -> bool,
2747>;
2748extern "C" {
2749 #[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."]
2750 pub fn otIp6SetSlaacPrefixFilter(aInstance: *mut otInstance, aFilter: otIp6SlaacPrefixFilter);
2751}
2752#[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"]
2753pub type otIp6RegisterMulticastListenersCallback = ::std::option::Option<
2754 unsafe extern "C" fn(
2755 aContext: *mut ::std::os::raw::c_void,
2756 aError: otError,
2757 aMlrStatus: u8,
2758 aFailedAddresses: *const otIp6Address,
2759 aFailedAddressNum: u8,
2760 ),
2761>;
2762extern "C" {
2763 #[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"]
2764 pub fn otIp6RegisterMulticastListeners(
2765 aInstance: *mut otInstance,
2766 aAddresses: *const otIp6Address,
2767 aAddressNum: u8,
2768 aTimeout: *const u32,
2769 aCallback: otIp6RegisterMulticastListenersCallback,
2770 aContext: *mut ::std::os::raw::c_void,
2771 ) -> otError;
2772}
2773extern "C" {
2774 #[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."]
2775 pub fn otIp6SetMeshLocalIid(
2776 aInstance: *mut otInstance,
2777 aIid: *const otIp6InterfaceIdentifier,
2778 ) -> otError;
2779}
2780extern "C" {
2781 #[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."]
2782 pub fn otIp6ProtoToString(aIpProto: u8) -> *const ::std::os::raw::c_char;
2783}
2784#[doc = " Represents the counters for packets and bytes."]
2785#[repr(C)]
2786#[derive(Debug, Default, Copy, Clone)]
2787pub struct otPacketsAndBytes {
2788 #[doc = "< The number of packets."]
2789 pub mPackets: u64,
2790 #[doc = "< The number of bytes."]
2791 pub mBytes: u64,
2792}
2793#[doc = " Represents the counters of packets forwarded via Border Routing."]
2794#[repr(C)]
2795#[derive(Debug, Default, Copy, Clone)]
2796pub struct otBorderRoutingCounters {
2797 #[doc = "< The counters for inbound unicast."]
2798 pub mInboundUnicast: otPacketsAndBytes,
2799 #[doc = "< The counters for inbound multicast."]
2800 pub mInboundMulticast: otPacketsAndBytes,
2801 #[doc = "< The counters for outbound unicast."]
2802 pub mOutboundUnicast: otPacketsAndBytes,
2803 #[doc = "< The counters for outbound multicast."]
2804 pub mOutboundMulticast: otPacketsAndBytes,
2805 #[doc = "< The counters for inbound Internet when DHCPv6 PD enabled."]
2806 pub mInboundInternet: otPacketsAndBytes,
2807 #[doc = "< The counters for outbound Internet when DHCPv6 PD enabled."]
2808 pub mOutboundInternet: otPacketsAndBytes,
2809 #[doc = "< The number of received RA packets."]
2810 pub mRaRx: u32,
2811 #[doc = "< The number of RA packets successfully transmitted."]
2812 pub mRaTxSuccess: u32,
2813 #[doc = "< The number of RA packets failed to transmit."]
2814 pub mRaTxFailure: u32,
2815 #[doc = "< The number of received RS packets."]
2816 pub mRsRx: u32,
2817 #[doc = "< The number of RS packets successfully transmitted."]
2818 pub mRsTxSuccess: u32,
2819 #[doc = "< The number of RS packets failed to transmit."]
2820 pub mRsTxFailure: u32,
2821}
2822extern "C" {
2823 #[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."]
2824 pub fn otIp6GetBorderRoutingCounters(
2825 aInstance: *mut otInstance,
2826 ) -> *const otBorderRoutingCounters;
2827}
2828extern "C" {
2829 #[doc = " Resets the Border Routing counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
2830 pub fn otIp6ResetBorderRoutingCounters(aInstance: *mut otInstance);
2831}
2832#[doc = " @struct otNetworkKey\n\n Represents a Thread Network Key."]
2833#[repr(C, packed)]
2834#[derive(Debug, Default, Copy, Clone)]
2835pub struct otNetworkKey {
2836 #[doc = "< Byte values"]
2837 pub m8: [u8; 16usize],
2838}
2839#[doc = " This datatype represents KeyRef to NetworkKey."]
2840pub type otNetworkKeyRef = otCryptoKeyRef;
2841#[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`)."]
2842#[repr(C)]
2843#[derive(Debug, Default, Copy, Clone)]
2844pub struct otNetworkName {
2845 #[doc = "< Byte values. The `+ 1` is for null char."]
2846 pub m8: [::std::os::raw::c_char; 17usize],
2847}
2848#[doc = " Represents an Extended PAN ID."]
2849#[repr(C, packed)]
2850#[derive(Debug, Default, Copy, Clone)]
2851pub struct otExtendedPanId {
2852 #[doc = "< Byte values"]
2853 pub m8: [u8; 8usize],
2854}
2855#[doc = " @struct otIp6NetworkPrefix\n\n Represents the Network Prefix of an IPv6 address (most significant 64 bits of the address)."]
2856pub type otMeshLocalPrefix = otIp6NetworkPrefix;
2857#[doc = " Represents PSKc."]
2858#[repr(C, packed)]
2859#[derive(Debug, Default, Copy, Clone)]
2860pub struct otPskc {
2861 #[doc = "< Byte values"]
2862 pub m8: [u8; 16usize],
2863}
2864#[doc = " This datatype represents KeyRef to PSKc."]
2865pub type otPskcRef = otCryptoKeyRef;
2866#[doc = " Represent Security Policy."]
2867#[repr(C)]
2868#[derive(Debug, Default, Copy, Clone)]
2869pub struct otSecurityPolicy {
2870 #[doc = "< The value for thrKeyRotation in units of hours."]
2871 pub mRotationTime: u16,
2872 pub _bitfield_align_1: [u8; 0],
2873 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
2874}
2875impl otSecurityPolicy {
2876 #[inline]
2877 pub fn mObtainNetworkKeyEnabled(&self) -> bool {
2878 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
2879 }
2880 #[inline]
2881 pub fn set_mObtainNetworkKeyEnabled(&mut self, val: bool) {
2882 unsafe {
2883 let val: u8 = ::std::mem::transmute(val);
2884 self._bitfield_1.set(0usize, 1u8, val as u64)
2885 }
2886 }
2887 #[inline]
2888 pub fn mNativeCommissioningEnabled(&self) -> bool {
2889 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
2890 }
2891 #[inline]
2892 pub fn set_mNativeCommissioningEnabled(&mut self, val: bool) {
2893 unsafe {
2894 let val: u8 = ::std::mem::transmute(val);
2895 self._bitfield_1.set(1usize, 1u8, val as u64)
2896 }
2897 }
2898 #[inline]
2899 pub fn mRoutersEnabled(&self) -> bool {
2900 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
2901 }
2902 #[inline]
2903 pub fn set_mRoutersEnabled(&mut self, val: bool) {
2904 unsafe {
2905 let val: u8 = ::std::mem::transmute(val);
2906 self._bitfield_1.set(2usize, 1u8, val as u64)
2907 }
2908 }
2909 #[inline]
2910 pub fn mExternalCommissioningEnabled(&self) -> bool {
2911 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
2912 }
2913 #[inline]
2914 pub fn set_mExternalCommissioningEnabled(&mut self, val: bool) {
2915 unsafe {
2916 let val: u8 = ::std::mem::transmute(val);
2917 self._bitfield_1.set(3usize, 1u8, val as u64)
2918 }
2919 }
2920 #[inline]
2921 pub fn mCommercialCommissioningEnabled(&self) -> bool {
2922 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
2923 }
2924 #[inline]
2925 pub fn set_mCommercialCommissioningEnabled(&mut self, val: bool) {
2926 unsafe {
2927 let val: u8 = ::std::mem::transmute(val);
2928 self._bitfield_1.set(4usize, 1u8, val as u64)
2929 }
2930 }
2931 #[inline]
2932 pub fn mAutonomousEnrollmentEnabled(&self) -> bool {
2933 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
2934 }
2935 #[inline]
2936 pub fn set_mAutonomousEnrollmentEnabled(&mut self, val: bool) {
2937 unsafe {
2938 let val: u8 = ::std::mem::transmute(val);
2939 self._bitfield_1.set(5usize, 1u8, val as u64)
2940 }
2941 }
2942 #[inline]
2943 pub fn mNetworkKeyProvisioningEnabled(&self) -> bool {
2944 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
2945 }
2946 #[inline]
2947 pub fn set_mNetworkKeyProvisioningEnabled(&mut self, val: bool) {
2948 unsafe {
2949 let val: u8 = ::std::mem::transmute(val);
2950 self._bitfield_1.set(6usize, 1u8, val as u64)
2951 }
2952 }
2953 #[inline]
2954 pub fn mTobleLinkEnabled(&self) -> bool {
2955 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
2956 }
2957 #[inline]
2958 pub fn set_mTobleLinkEnabled(&mut self, val: bool) {
2959 unsafe {
2960 let val: u8 = ::std::mem::transmute(val);
2961 self._bitfield_1.set(7usize, 1u8, val as u64)
2962 }
2963 }
2964 #[inline]
2965 pub fn mNonCcmRoutersEnabled(&self) -> bool {
2966 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
2967 }
2968 #[inline]
2969 pub fn set_mNonCcmRoutersEnabled(&mut self, val: bool) {
2970 unsafe {
2971 let val: u8 = ::std::mem::transmute(val);
2972 self._bitfield_1.set(8usize, 1u8, val as u64)
2973 }
2974 }
2975 #[inline]
2976 pub fn mVersionThresholdForRouting(&self) -> u8 {
2977 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 3u8) as u8) }
2978 }
2979 #[inline]
2980 pub fn set_mVersionThresholdForRouting(&mut self, val: u8) {
2981 unsafe {
2982 let val: u8 = ::std::mem::transmute(val);
2983 self._bitfield_1.set(9usize, 3u8, val as u64)
2984 }
2985 }
2986 #[inline]
2987 pub fn new_bitfield_1(
2988 mObtainNetworkKeyEnabled: bool,
2989 mNativeCommissioningEnabled: bool,
2990 mRoutersEnabled: bool,
2991 mExternalCommissioningEnabled: bool,
2992 mCommercialCommissioningEnabled: bool,
2993 mAutonomousEnrollmentEnabled: bool,
2994 mNetworkKeyProvisioningEnabled: bool,
2995 mTobleLinkEnabled: bool,
2996 mNonCcmRoutersEnabled: bool,
2997 mVersionThresholdForRouting: u8,
2998 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
2999 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3000 __bindgen_bitfield_unit.set(0usize, 1u8, {
3001 let mObtainNetworkKeyEnabled: u8 =
3002 unsafe { ::std::mem::transmute(mObtainNetworkKeyEnabled) };
3003 mObtainNetworkKeyEnabled as u64
3004 });
3005 __bindgen_bitfield_unit.set(1usize, 1u8, {
3006 let mNativeCommissioningEnabled: u8 =
3007 unsafe { ::std::mem::transmute(mNativeCommissioningEnabled) };
3008 mNativeCommissioningEnabled as u64
3009 });
3010 __bindgen_bitfield_unit.set(2usize, 1u8, {
3011 let mRoutersEnabled: u8 = unsafe { ::std::mem::transmute(mRoutersEnabled) };
3012 mRoutersEnabled as u64
3013 });
3014 __bindgen_bitfield_unit.set(3usize, 1u8, {
3015 let mExternalCommissioningEnabled: u8 =
3016 unsafe { ::std::mem::transmute(mExternalCommissioningEnabled) };
3017 mExternalCommissioningEnabled as u64
3018 });
3019 __bindgen_bitfield_unit.set(4usize, 1u8, {
3020 let mCommercialCommissioningEnabled: u8 =
3021 unsafe { ::std::mem::transmute(mCommercialCommissioningEnabled) };
3022 mCommercialCommissioningEnabled as u64
3023 });
3024 __bindgen_bitfield_unit.set(5usize, 1u8, {
3025 let mAutonomousEnrollmentEnabled: u8 =
3026 unsafe { ::std::mem::transmute(mAutonomousEnrollmentEnabled) };
3027 mAutonomousEnrollmentEnabled as u64
3028 });
3029 __bindgen_bitfield_unit.set(6usize, 1u8, {
3030 let mNetworkKeyProvisioningEnabled: u8 =
3031 unsafe { ::std::mem::transmute(mNetworkKeyProvisioningEnabled) };
3032 mNetworkKeyProvisioningEnabled as u64
3033 });
3034 __bindgen_bitfield_unit.set(7usize, 1u8, {
3035 let mTobleLinkEnabled: u8 = unsafe { ::std::mem::transmute(mTobleLinkEnabled) };
3036 mTobleLinkEnabled as u64
3037 });
3038 __bindgen_bitfield_unit.set(8usize, 1u8, {
3039 let mNonCcmRoutersEnabled: u8 = unsafe { ::std::mem::transmute(mNonCcmRoutersEnabled) };
3040 mNonCcmRoutersEnabled as u64
3041 });
3042 __bindgen_bitfield_unit.set(9usize, 3u8, {
3043 let mVersionThresholdForRouting: u8 =
3044 unsafe { ::std::mem::transmute(mVersionThresholdForRouting) };
3045 mVersionThresholdForRouting as u64
3046 });
3047 __bindgen_bitfield_unit
3048 }
3049}
3050#[doc = " Represents a Channel Mask.\n\n The least significant bit (LSB), also referred to as bit 0, corresponds to channel number 0, and so on.\n"]
3051pub type otChannelMask = u32;
3052#[doc = " Represents presence of different components in Active or Pending Operational Dataset."]
3053#[repr(C)]
3054#[derive(Debug, Default, Copy, Clone)]
3055pub struct otOperationalDatasetComponents {
3056 #[doc = "< TRUE if Active Timestamp is present, FALSE otherwise."]
3057 pub mIsActiveTimestampPresent: bool,
3058 #[doc = "< TRUE if Pending Timestamp is present, FALSE otherwise."]
3059 pub mIsPendingTimestampPresent: bool,
3060 #[doc = "< TRUE if Network Key is present, FALSE otherwise."]
3061 pub mIsNetworkKeyPresent: bool,
3062 #[doc = "< TRUE if Network Name is present, FALSE otherwise."]
3063 pub mIsNetworkNamePresent: bool,
3064 #[doc = "< TRUE if Extended PAN ID is present, FALSE otherwise."]
3065 pub mIsExtendedPanIdPresent: bool,
3066 #[doc = "< TRUE if Mesh Local Prefix is present, FALSE otherwise."]
3067 pub mIsMeshLocalPrefixPresent: bool,
3068 #[doc = "< TRUE if Delay Timer is present, FALSE otherwise."]
3069 pub mIsDelayPresent: bool,
3070 #[doc = "< TRUE if PAN ID is present, FALSE otherwise."]
3071 pub mIsPanIdPresent: bool,
3072 #[doc = "< TRUE if Channel is present, FALSE otherwise."]
3073 pub mIsChannelPresent: bool,
3074 #[doc = "< TRUE if PSKc is present, FALSE otherwise."]
3075 pub mIsPskcPresent: bool,
3076 #[doc = "< TRUE if Security Policy is present, FALSE otherwise."]
3077 pub mIsSecurityPolicyPresent: bool,
3078 #[doc = "< TRUE if Channel Mask is present, FALSE otherwise."]
3079 pub mIsChannelMaskPresent: bool,
3080 #[doc = "< TRUE if Wake-up Channel is present, FALSE otherwise."]
3081 pub mIsWakeupChannelPresent: bool,
3082}
3083#[doc = " Represents a Thread Dataset timestamp component."]
3084#[repr(C)]
3085#[derive(Debug, Default, Copy, Clone)]
3086pub struct otTimestamp {
3087 pub mSeconds: u64,
3088 pub mTicks: u16,
3089 pub mAuthoritative: bool,
3090}
3091#[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."]
3092#[repr(C)]
3093#[derive(Debug, Default, Copy, Clone)]
3094pub struct otOperationalDataset {
3095 #[doc = "< Active Timestamp"]
3096 pub mActiveTimestamp: otTimestamp,
3097 #[doc = "< Pending Timestamp"]
3098 pub mPendingTimestamp: otTimestamp,
3099 #[doc = "< Network Key"]
3100 pub mNetworkKey: otNetworkKey,
3101 #[doc = "< Network Name"]
3102 pub mNetworkName: otNetworkName,
3103 #[doc = "< Extended PAN ID"]
3104 pub mExtendedPanId: otExtendedPanId,
3105 #[doc = "< Mesh Local Prefix"]
3106 pub mMeshLocalPrefix: otMeshLocalPrefix,
3107 #[doc = "< Delay Timer"]
3108 pub mDelay: u32,
3109 #[doc = "< PAN ID"]
3110 pub mPanId: otPanId,
3111 #[doc = "< Channel"]
3112 pub mChannel: u16,
3113 #[doc = "< Wake-up Channel"]
3114 pub mWakeupChannel: u16,
3115 #[doc = "< PSKc"]
3116 pub mPskc: otPskc,
3117 #[doc = "< Security Policy"]
3118 pub mSecurityPolicy: otSecurityPolicy,
3119 #[doc = "< Channel Mask"]
3120 pub mChannelMask: otChannelMask,
3121 #[doc = "< Specifies which components are set in the Dataset."]
3122 pub mComponents: otOperationalDatasetComponents,
3123}
3124#[doc = " Represents an Active or Pending Operational Dataset.\n\n The Operational Dataset is TLV encoded as specified by Thread."]
3125#[repr(C)]
3126#[derive(Debug, Copy, Clone)]
3127pub struct otOperationalDatasetTlvs {
3128 #[doc = "< Operational Dataset TLVs."]
3129 pub mTlvs: [u8; 254usize],
3130 #[doc = "< Size of Operational Dataset in bytes."]
3131 pub mLength: u8,
3132}
3133impl Default for otOperationalDatasetTlvs {
3134 fn default() -> Self {
3135 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3136 unsafe {
3137 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3138 s.assume_init()
3139 }
3140 }
3141}
3142#[doc = "< meshcop Channel TLV"]
3143pub const OT_MESHCOP_TLV_CHANNEL: otMeshcopTlvType = 0;
3144#[doc = "< meshcop Pan Id TLV"]
3145pub const OT_MESHCOP_TLV_PANID: otMeshcopTlvType = 1;
3146#[doc = "< meshcop Extended Pan Id TLV"]
3147pub const OT_MESHCOP_TLV_EXTPANID: otMeshcopTlvType = 2;
3148#[doc = "< meshcop Network Name TLV"]
3149pub const OT_MESHCOP_TLV_NETWORKNAME: otMeshcopTlvType = 3;
3150#[doc = "< meshcop PSKc TLV"]
3151pub const OT_MESHCOP_TLV_PSKC: otMeshcopTlvType = 4;
3152#[doc = "< meshcop Network Key TLV"]
3153pub const OT_MESHCOP_TLV_NETWORKKEY: otMeshcopTlvType = 5;
3154#[doc = "< meshcop Network Key Sequence TLV"]
3155pub const OT_MESHCOP_TLV_NETWORK_KEY_SEQUENCE: otMeshcopTlvType = 6;
3156#[doc = "< meshcop Mesh Local Prefix TLV"]
3157pub const OT_MESHCOP_TLV_MESHLOCALPREFIX: otMeshcopTlvType = 7;
3158#[doc = "< meshcop Steering Data TLV"]
3159pub const OT_MESHCOP_TLV_STEERING_DATA: otMeshcopTlvType = 8;
3160#[doc = "< meshcop Border Agent Locator TLV"]
3161pub const OT_MESHCOP_TLV_BORDER_AGENT_RLOC: otMeshcopTlvType = 9;
3162#[doc = "< meshcop Commissioner ID TLV"]
3163pub const OT_MESHCOP_TLV_COMMISSIONER_ID: otMeshcopTlvType = 10;
3164#[doc = "< meshcop Commissioner Session ID TLV"]
3165pub const OT_MESHCOP_TLV_COMM_SESSION_ID: otMeshcopTlvType = 11;
3166#[doc = "< meshcop Security Policy TLV"]
3167pub const OT_MESHCOP_TLV_SECURITYPOLICY: otMeshcopTlvType = 12;
3168#[doc = "< meshcop Get TLV"]
3169pub const OT_MESHCOP_TLV_GET: otMeshcopTlvType = 13;
3170#[doc = "< meshcop Active Timestamp TLV"]
3171pub const OT_MESHCOP_TLV_ACTIVETIMESTAMP: otMeshcopTlvType = 14;
3172#[doc = "< meshcop Commissioner UDP Port TLV"]
3173pub const OT_MESHCOP_TLV_COMMISSIONER_UDP_PORT: otMeshcopTlvType = 15;
3174#[doc = "< meshcop State TLV"]
3175pub const OT_MESHCOP_TLV_STATE: otMeshcopTlvType = 16;
3176#[doc = "< meshcop Joiner DTLS Encapsulation TLV"]
3177pub const OT_MESHCOP_TLV_JOINER_DTLS: otMeshcopTlvType = 17;
3178#[doc = "< meshcop Joiner UDP Port TLV"]
3179pub const OT_MESHCOP_TLV_JOINER_UDP_PORT: otMeshcopTlvType = 18;
3180#[doc = "< meshcop Joiner IID TLV"]
3181pub const OT_MESHCOP_TLV_JOINER_IID: otMeshcopTlvType = 19;
3182#[doc = "< meshcop Joiner Router Locator TLV"]
3183pub const OT_MESHCOP_TLV_JOINER_RLOC: otMeshcopTlvType = 20;
3184#[doc = "< meshcop Joiner Router KEK TLV"]
3185pub const OT_MESHCOP_TLV_JOINER_ROUTER_KEK: otMeshcopTlvType = 21;
3186#[doc = "< meshcop Provisioning URL TLV"]
3187pub const OT_MESHCOP_TLV_PROVISIONING_URL: otMeshcopTlvType = 32;
3188#[doc = "< meshcop Vendor Name TLV"]
3189pub const OT_MESHCOP_TLV_VENDOR_NAME_TLV: otMeshcopTlvType = 33;
3190#[doc = "< meshcop Vendor Model TLV"]
3191pub const OT_MESHCOP_TLV_VENDOR_MODEL_TLV: otMeshcopTlvType = 34;
3192#[doc = "< meshcop Vendor SW Version TLV"]
3193pub const OT_MESHCOP_TLV_VENDOR_SW_VERSION_TLV: otMeshcopTlvType = 35;
3194#[doc = "< meshcop Vendor Data TLV"]
3195pub const OT_MESHCOP_TLV_VENDOR_DATA_TLV: otMeshcopTlvType = 36;
3196#[doc = "< meshcop Vendor Stack Version TLV"]
3197pub const OT_MESHCOP_TLV_VENDOR_STACK_VERSION_TLV: otMeshcopTlvType = 37;
3198#[doc = "< meshcop UDP encapsulation TLV"]
3199pub const OT_MESHCOP_TLV_UDP_ENCAPSULATION_TLV: otMeshcopTlvType = 48;
3200#[doc = "< meshcop IPv6 address TLV"]
3201pub const OT_MESHCOP_TLV_IPV6_ADDRESS_TLV: otMeshcopTlvType = 49;
3202#[doc = "< meshcop Pending Timestamp TLV"]
3203pub const OT_MESHCOP_TLV_PENDINGTIMESTAMP: otMeshcopTlvType = 51;
3204#[doc = "< meshcop Delay Timer TLV"]
3205pub const OT_MESHCOP_TLV_DELAYTIMER: otMeshcopTlvType = 52;
3206#[doc = "< meshcop Channel Mask TLV"]
3207pub const OT_MESHCOP_TLV_CHANNELMASK: otMeshcopTlvType = 53;
3208#[doc = "< meshcop Count TLV"]
3209pub const OT_MESHCOP_TLV_COUNT: otMeshcopTlvType = 54;
3210#[doc = "< meshcop Period TLV"]
3211pub const OT_MESHCOP_TLV_PERIOD: otMeshcopTlvType = 55;
3212#[doc = "< meshcop Scan Duration TLV"]
3213pub const OT_MESHCOP_TLV_SCAN_DURATION: otMeshcopTlvType = 56;
3214#[doc = "< meshcop Energy List TLV"]
3215pub const OT_MESHCOP_TLV_ENERGY_LIST: otMeshcopTlvType = 57;
3216#[doc = "< meshcop Thread Domain Name TLV"]
3217pub const OT_MESHCOP_TLV_THREAD_DOMAIN_NAME: otMeshcopTlvType = 59;
3218#[doc = "< meshcop Wake-up Channel TLV"]
3219pub const OT_MESHCOP_TLV_WAKEUP_CHANNEL: otMeshcopTlvType = 74;
3220#[doc = "< meshcop Discovery Request TLV"]
3221pub const OT_MESHCOP_TLV_DISCOVERYREQUEST: otMeshcopTlvType = 128;
3222#[doc = "< meshcop Discovery Response TLV"]
3223pub const OT_MESHCOP_TLV_DISCOVERYRESPONSE: otMeshcopTlvType = 129;
3224#[doc = "< meshcop Joiner Advertisement TLV"]
3225pub const OT_MESHCOP_TLV_JOINERADVERTISEMENT: otMeshcopTlvType = 241;
3226#[doc = " Represents meshcop TLV types."]
3227pub type otMeshcopTlvType = ::std::os::raw::c_uint;
3228#[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."]
3229pub type otDatasetMgmtSetCallback = ::std::option::Option<
3230 unsafe extern "C" fn(aResult: otError, aContext: *mut ::std::os::raw::c_void),
3231>;
3232extern "C" {
3233 #[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."]
3234 pub fn otDatasetIsCommissioned(aInstance: *mut otInstance) -> bool;
3235}
3236extern "C" {
3237 #[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."]
3238 pub fn otDatasetGetActive(
3239 aInstance: *mut otInstance,
3240 aDataset: *mut otOperationalDataset,
3241 ) -> otError;
3242}
3243extern "C" {
3244 #[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."]
3245 pub fn otDatasetGetActiveTlvs(
3246 aInstance: *mut otInstance,
3247 aDataset: *mut otOperationalDatasetTlvs,
3248 ) -> otError;
3249}
3250extern "C" {
3251 #[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."]
3252 pub fn otDatasetSetActive(
3253 aInstance: *mut otInstance,
3254 aDataset: *const otOperationalDataset,
3255 ) -> otError;
3256}
3257extern "C" {
3258 #[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."]
3259 pub fn otDatasetSetActiveTlvs(
3260 aInstance: *mut otInstance,
3261 aDataset: *const otOperationalDatasetTlvs,
3262 ) -> otError;
3263}
3264extern "C" {
3265 #[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."]
3266 pub fn otDatasetGetPending(
3267 aInstance: *mut otInstance,
3268 aDataset: *mut otOperationalDataset,
3269 ) -> otError;
3270}
3271extern "C" {
3272 #[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."]
3273 pub fn otDatasetGetPendingTlvs(
3274 aInstance: *mut otInstance,
3275 aDataset: *mut otOperationalDatasetTlvs,
3276 ) -> otError;
3277}
3278extern "C" {
3279 #[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."]
3280 pub fn otDatasetSetPending(
3281 aInstance: *mut otInstance,
3282 aDataset: *const otOperationalDataset,
3283 ) -> otError;
3284}
3285extern "C" {
3286 #[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."]
3287 pub fn otDatasetSetPendingTlvs(
3288 aInstance: *mut otInstance,
3289 aDataset: *const otOperationalDatasetTlvs,
3290 ) -> otError;
3291}
3292extern "C" {
3293 #[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."]
3294 pub fn otDatasetSendMgmtActiveGet(
3295 aInstance: *mut otInstance,
3296 aDatasetComponents: *const otOperationalDatasetComponents,
3297 aTlvTypes: *const u8,
3298 aLength: u8,
3299 aAddress: *const otIp6Address,
3300 ) -> otError;
3301}
3302extern "C" {
3303 #[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."]
3304 pub fn otDatasetSendMgmtActiveSet(
3305 aInstance: *mut otInstance,
3306 aDataset: *const otOperationalDataset,
3307 aTlvs: *const u8,
3308 aLength: u8,
3309 aCallback: otDatasetMgmtSetCallback,
3310 aContext: *mut ::std::os::raw::c_void,
3311 ) -> otError;
3312}
3313extern "C" {
3314 #[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."]
3315 pub fn otDatasetSendMgmtPendingGet(
3316 aInstance: *mut otInstance,
3317 aDatasetComponents: *const otOperationalDatasetComponents,
3318 aTlvTypes: *const u8,
3319 aLength: u8,
3320 aAddress: *const otIp6Address,
3321 ) -> otError;
3322}
3323extern "C" {
3324 #[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."]
3325 pub fn otDatasetSendMgmtPendingSet(
3326 aInstance: *mut otInstance,
3327 aDataset: *const otOperationalDataset,
3328 aTlvs: *const u8,
3329 aLength: u8,
3330 aCallback: otDatasetMgmtSetCallback,
3331 aContext: *mut ::std::os::raw::c_void,
3332 ) -> otError;
3333}
3334extern "C" {
3335 #[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."]
3336 pub fn otDatasetGeneratePskc(
3337 aPassPhrase: *const ::std::os::raw::c_char,
3338 aNetworkName: *const otNetworkName,
3339 aExtPanId: *const otExtendedPanId,
3340 aPskc: *mut otPskc,
3341 ) -> otError;
3342}
3343extern "C" {
3344 #[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)."]
3345 pub fn otNetworkNameFromString(
3346 aNetworkName: *mut otNetworkName,
3347 aNameString: *const ::std::os::raw::c_char,
3348 ) -> otError;
3349}
3350extern "C" {
3351 #[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`."]
3352 pub fn otDatasetParseTlvs(
3353 aDatasetTlvs: *const otOperationalDatasetTlvs,
3354 aDataset: *mut otOperationalDataset,
3355 ) -> otError;
3356}
3357extern "C" {
3358 #[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."]
3359 pub fn otDatasetConvertToTlvs(
3360 aDataset: *const otOperationalDataset,
3361 aDatasetTlvs: *mut otOperationalDatasetTlvs,
3362 );
3363}
3364extern "C" {
3365 #[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."]
3366 pub fn otDatasetUpdateTlvs(
3367 aDataset: *const otOperationalDataset,
3368 aDatasetTlvs: *mut otOperationalDatasetTlvs,
3369 ) -> otError;
3370}
3371pub const OT_JOINER_STATE_IDLE: otJoinerState = 0;
3372pub const OT_JOINER_STATE_DISCOVER: otJoinerState = 1;
3373pub const OT_JOINER_STATE_CONNECT: otJoinerState = 2;
3374pub const OT_JOINER_STATE_CONNECTED: otJoinerState = 3;
3375pub const OT_JOINER_STATE_ENTRUST: otJoinerState = 4;
3376pub const OT_JOINER_STATE_JOINED: otJoinerState = 5;
3377#[doc = " Defines the Joiner State."]
3378pub type otJoinerState = ::std::os::raw::c_uint;
3379#[doc = " Represents a Joiner Discerner."]
3380#[repr(C)]
3381#[derive(Debug, Default, Copy, Clone)]
3382pub struct otJoinerDiscerner {
3383 #[doc = "< Discerner value (the lowest `mLength` bits specify the discerner)."]
3384 pub mValue: u64,
3385 #[doc = "< Length (number of bits) - must be non-zero and at most `OT_JOINER_MAX_DISCERNER_LENGTH`."]
3386 pub mLength: u8,
3387}
3388#[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."]
3389pub type otJoinerCallback = ::std::option::Option<
3390 unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
3391>;
3392extern "C" {
3393 #[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."]
3394 pub fn otJoinerStart(
3395 aInstance: *mut otInstance,
3396 aPskd: *const ::std::os::raw::c_char,
3397 aProvisioningUrl: *const ::std::os::raw::c_char,
3398 aVendorName: *const ::std::os::raw::c_char,
3399 aVendorModel: *const ::std::os::raw::c_char,
3400 aVendorSwVersion: *const ::std::os::raw::c_char,
3401 aVendorData: *const ::std::os::raw::c_char,
3402 aCallback: otJoinerCallback,
3403 aContext: *mut ::std::os::raw::c_void,
3404 ) -> otError;
3405}
3406extern "C" {
3407 #[doc = " Disables the Thread Joiner role.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
3408 pub fn otJoinerStop(aInstance: *mut otInstance);
3409}
3410extern "C" {
3411 #[doc = " Gets the Joiner State.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The joiner state."]
3412 pub fn otJoinerGetState(aInstance: *mut otInstance) -> otJoinerState;
3413}
3414extern "C" {
3415 #[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."]
3416 pub fn otJoinerGetId(aInstance: *mut otInstance) -> *const otExtAddress;
3417}
3418extern "C" {
3419 #[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."]
3420 pub fn otJoinerSetDiscerner(
3421 aInstance: *mut otInstance,
3422 aDiscerner: *mut otJoinerDiscerner,
3423 ) -> otError;
3424}
3425extern "C" {
3426 #[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."]
3427 pub fn otJoinerGetDiscerner(aInstance: *mut otInstance) -> *const otJoinerDiscerner;
3428}
3429extern "C" {
3430 #[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."]
3431 pub fn otJoinerStateToString(aState: otJoinerState) -> *const ::std::os::raw::c_char;
3432}
3433#[doc = "< Commissioner role is disabled."]
3434pub const OT_COMMISSIONER_STATE_DISABLED: otCommissionerState = 0;
3435#[doc = "< Currently petitioning to become a Commissioner."]
3436pub const OT_COMMISSIONER_STATE_PETITION: otCommissionerState = 1;
3437#[doc = "< Commissioner role is active."]
3438pub const OT_COMMISSIONER_STATE_ACTIVE: otCommissionerState = 2;
3439#[doc = " Defines the Commissioner State."]
3440pub type otCommissionerState = ::std::os::raw::c_uint;
3441pub const OT_COMMISSIONER_JOINER_START: otCommissionerJoinerEvent = 0;
3442pub const OT_COMMISSIONER_JOINER_CONNECTED: otCommissionerJoinerEvent = 1;
3443pub const OT_COMMISSIONER_JOINER_FINALIZE: otCommissionerJoinerEvent = 2;
3444pub const OT_COMMISSIONER_JOINER_END: otCommissionerJoinerEvent = 3;
3445pub const OT_COMMISSIONER_JOINER_REMOVED: otCommissionerJoinerEvent = 4;
3446#[doc = " Defines a Joiner Event on the Commissioner."]
3447pub type otCommissionerJoinerEvent = ::std::os::raw::c_uint;
3448#[doc = " Represents the steering data."]
3449#[repr(C)]
3450#[derive(Debug, Default, Copy, Clone)]
3451pub struct otSteeringData {
3452 #[doc = "< Length of steering data (bytes)"]
3453 pub mLength: u8,
3454 #[doc = "< Byte values"]
3455 pub m8: [u8; 16usize],
3456}
3457#[doc = " Represents a Commissioning Dataset."]
3458#[repr(C)]
3459#[derive(Debug, Default, Copy, Clone)]
3460pub struct otCommissioningDataset {
3461 #[doc = "< Border Router RLOC16"]
3462 pub mLocator: u16,
3463 #[doc = "< Commissioner Session Id"]
3464 pub mSessionId: u16,
3465 #[doc = "< Steering Data"]
3466 pub mSteeringData: otSteeringData,
3467 #[doc = "< Joiner UDP Port"]
3468 pub mJoinerUdpPort: u16,
3469 pub _bitfield_align_1: [u8; 0],
3470 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3471 pub __bindgen_padding_0: u8,
3472}
3473impl otCommissioningDataset {
3474 #[inline]
3475 pub fn mIsLocatorSet(&self) -> bool {
3476 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
3477 }
3478 #[inline]
3479 pub fn set_mIsLocatorSet(&mut self, val: bool) {
3480 unsafe {
3481 let val: u8 = ::std::mem::transmute(val);
3482 self._bitfield_1.set(0usize, 1u8, val as u64)
3483 }
3484 }
3485 #[inline]
3486 pub fn mIsSessionIdSet(&self) -> bool {
3487 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
3488 }
3489 #[inline]
3490 pub fn set_mIsSessionIdSet(&mut self, val: bool) {
3491 unsafe {
3492 let val: u8 = ::std::mem::transmute(val);
3493 self._bitfield_1.set(1usize, 1u8, val as u64)
3494 }
3495 }
3496 #[inline]
3497 pub fn mIsSteeringDataSet(&self) -> bool {
3498 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
3499 }
3500 #[inline]
3501 pub fn set_mIsSteeringDataSet(&mut self, val: bool) {
3502 unsafe {
3503 let val: u8 = ::std::mem::transmute(val);
3504 self._bitfield_1.set(2usize, 1u8, val as u64)
3505 }
3506 }
3507 #[inline]
3508 pub fn mIsJoinerUdpPortSet(&self) -> bool {
3509 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
3510 }
3511 #[inline]
3512 pub fn set_mIsJoinerUdpPortSet(&mut self, val: bool) {
3513 unsafe {
3514 let val: u8 = ::std::mem::transmute(val);
3515 self._bitfield_1.set(3usize, 1u8, val as u64)
3516 }
3517 }
3518 #[inline]
3519 pub fn mHasExtraTlv(&self) -> bool {
3520 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3521 }
3522 #[inline]
3523 pub fn set_mHasExtraTlv(&mut self, val: bool) {
3524 unsafe {
3525 let val: u8 = ::std::mem::transmute(val);
3526 self._bitfield_1.set(4usize, 1u8, val as u64)
3527 }
3528 }
3529 #[inline]
3530 pub fn new_bitfield_1(
3531 mIsLocatorSet: bool,
3532 mIsSessionIdSet: bool,
3533 mIsSteeringDataSet: bool,
3534 mIsJoinerUdpPortSet: bool,
3535 mHasExtraTlv: bool,
3536 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
3537 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
3538 __bindgen_bitfield_unit.set(0usize, 1u8, {
3539 let mIsLocatorSet: u8 = unsafe { ::std::mem::transmute(mIsLocatorSet) };
3540 mIsLocatorSet as u64
3541 });
3542 __bindgen_bitfield_unit.set(1usize, 1u8, {
3543 let mIsSessionIdSet: u8 = unsafe { ::std::mem::transmute(mIsSessionIdSet) };
3544 mIsSessionIdSet as u64
3545 });
3546 __bindgen_bitfield_unit.set(2usize, 1u8, {
3547 let mIsSteeringDataSet: u8 = unsafe { ::std::mem::transmute(mIsSteeringDataSet) };
3548 mIsSteeringDataSet as u64
3549 });
3550 __bindgen_bitfield_unit.set(3usize, 1u8, {
3551 let mIsJoinerUdpPortSet: u8 = unsafe { ::std::mem::transmute(mIsJoinerUdpPortSet) };
3552 mIsJoinerUdpPortSet as u64
3553 });
3554 __bindgen_bitfield_unit.set(4usize, 1u8, {
3555 let mHasExtraTlv: u8 = unsafe { ::std::mem::transmute(mHasExtraTlv) };
3556 mHasExtraTlv as u64
3557 });
3558 __bindgen_bitfield_unit
3559 }
3560}
3561#[doc = " Represents a Joiner PSKd."]
3562#[repr(C)]
3563#[derive(Debug, Copy, Clone)]
3564pub struct otJoinerPskd {
3565 #[doc = "< Char string array (must be null terminated - +1 is for null char)."]
3566 pub m8: [::std::os::raw::c_char; 33usize],
3567}
3568impl Default for otJoinerPskd {
3569 fn default() -> Self {
3570 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3571 unsafe {
3572 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3573 s.assume_init()
3574 }
3575 }
3576}
3577#[doc = "< Accept any Joiner (no EUI64 or Discerner is specified)."]
3578pub const OT_JOINER_INFO_TYPE_ANY: otJoinerInfoType = 0;
3579#[doc = "< Joiner EUI-64 is specified (`mSharedId.mEui64` in `otJoinerInfo`)."]
3580pub const OT_JOINER_INFO_TYPE_EUI64: otJoinerInfoType = 1;
3581#[doc = "< Joiner Discerner is specified (`mSharedId.mDiscerner` in `otJoinerInfo`)."]
3582pub const OT_JOINER_INFO_TYPE_DISCERNER: otJoinerInfoType = 2;
3583#[doc = " Defines a Joiner Info Type."]
3584pub type otJoinerInfoType = ::std::os::raw::c_uint;
3585#[doc = " Represents a Joiner Info."]
3586#[repr(C)]
3587#[derive(Copy, Clone)]
3588pub struct otJoinerInfo {
3589 #[doc = "< Joiner type."]
3590 pub mType: otJoinerInfoType,
3591 #[doc = "< Shared fields"]
3592 pub mSharedId: otJoinerInfo__bindgen_ty_1,
3593 #[doc = "< Joiner PSKd"]
3594 pub mPskd: otJoinerPskd,
3595 #[doc = "< Joiner expiration time in msec"]
3596 pub mExpirationTime: u32,
3597}
3598#[repr(C)]
3599#[derive(Copy, Clone)]
3600pub union otJoinerInfo__bindgen_ty_1 {
3601 #[doc = "< Joiner EUI64 (when `mType` is `OT_JOINER_INFO_TYPE_EUI64`)"]
3602 pub mEui64: otExtAddress,
3603 #[doc = "< Joiner Discerner (when `mType` is `OT_JOINER_INFO_TYPE_DISCERNER`)"]
3604 pub mDiscerner: otJoinerDiscerner,
3605}
3606impl Default for otJoinerInfo__bindgen_ty_1 {
3607 fn default() -> Self {
3608 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3609 unsafe {
3610 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3611 s.assume_init()
3612 }
3613 }
3614}
3615impl Default for otJoinerInfo {
3616 fn default() -> Self {
3617 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3618 unsafe {
3619 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3620 s.assume_init()
3621 }
3622 }
3623}
3624#[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."]
3625pub type otCommissionerStateCallback = ::std::option::Option<
3626 unsafe extern "C" fn(aState: otCommissionerState, aContext: *mut ::std::os::raw::c_void),
3627>;
3628#[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."]
3629pub type otCommissionerJoinerCallback = ::std::option::Option<
3630 unsafe extern "C" fn(
3631 aEvent: otCommissionerJoinerEvent,
3632 aJoinerInfo: *const otJoinerInfo,
3633 aJoinerId: *const otExtAddress,
3634 aContext: *mut ::std::os::raw::c_void,
3635 ),
3636>;
3637extern "C" {
3638 #[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."]
3639 pub fn otCommissionerStart(
3640 aInstance: *mut otInstance,
3641 aStateCallback: otCommissionerStateCallback,
3642 aJoinerCallback: otCommissionerJoinerCallback,
3643 aCallbackContext: *mut ::std::os::raw::c_void,
3644 ) -> otError;
3645}
3646extern "C" {
3647 #[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."]
3648 pub fn otCommissionerStop(aInstance: *mut otInstance) -> otError;
3649}
3650extern "C" {
3651 #[doc = " Returns the Commissioner Id.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Commissioner Id."]
3652 pub fn otCommissionerGetId(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
3653}
3654extern "C" {
3655 #[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."]
3656 pub fn otCommissionerSetId(
3657 aInstance: *mut otInstance,
3658 aId: *const ::std::os::raw::c_char,
3659 ) -> otError;
3660}
3661extern "C" {
3662 #[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()."]
3663 pub fn otCommissionerAddJoiner(
3664 aInstance: *mut otInstance,
3665 aEui64: *const otExtAddress,
3666 aPskd: *const ::std::os::raw::c_char,
3667 aTimeout: u32,
3668 ) -> otError;
3669}
3670extern "C" {
3671 #[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()."]
3672 pub fn otCommissionerAddJoinerWithDiscerner(
3673 aInstance: *mut otInstance,
3674 aDiscerner: *const otJoinerDiscerner,
3675 aPskd: *const ::std::os::raw::c_char,
3676 aTimeout: u32,
3677 ) -> otError;
3678}
3679extern "C" {
3680 #[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."]
3681 pub fn otCommissionerGetNextJoinerInfo(
3682 aInstance: *mut otInstance,
3683 aIterator: *mut u16,
3684 aJoiner: *mut otJoinerInfo,
3685 ) -> otError;
3686}
3687extern "C" {
3688 #[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()."]
3689 pub fn otCommissionerRemoveJoiner(
3690 aInstance: *mut otInstance,
3691 aEui64: *const otExtAddress,
3692 ) -> otError;
3693}
3694extern "C" {
3695 #[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()."]
3696 pub fn otCommissionerRemoveJoinerWithDiscerner(
3697 aInstance: *mut otInstance,
3698 aDiscerner: *const otJoinerDiscerner,
3699 ) -> otError;
3700}
3701extern "C" {
3702 #[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."]
3703 pub fn otCommissionerGetProvisioningUrl(
3704 aInstance: *mut otInstance,
3705 ) -> *const ::std::os::raw::c_char;
3706}
3707extern "C" {
3708 #[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)."]
3709 pub fn otCommissionerSetProvisioningUrl(
3710 aInstance: *mut otInstance,
3711 aProvisioningUrl: *const ::std::os::raw::c_char,
3712 ) -> otError;
3713}
3714extern "C" {
3715 #[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()."]
3716 pub fn otCommissionerAnnounceBegin(
3717 aInstance: *mut otInstance,
3718 aChannelMask: u32,
3719 aCount: u8,
3720 aPeriod: u16,
3721 aAddress: *const otIp6Address,
3722 ) -> otError;
3723}
3724#[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."]
3725pub type otCommissionerEnergyReportCallback = ::std::option::Option<
3726 unsafe extern "C" fn(
3727 aChannelMask: u32,
3728 aEnergyList: *const u8,
3729 aEnergyListLength: u8,
3730 aContext: *mut ::std::os::raw::c_void,
3731 ),
3732>;
3733extern "C" {
3734 #[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()."]
3735 pub fn otCommissionerEnergyScan(
3736 aInstance: *mut otInstance,
3737 aChannelMask: u32,
3738 aCount: u8,
3739 aPeriod: u16,
3740 aScanDuration: u16,
3741 aAddress: *const otIp6Address,
3742 aCallback: otCommissionerEnergyReportCallback,
3743 aContext: *mut ::std::os::raw::c_void,
3744 ) -> otError;
3745}
3746#[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."]
3747pub type otCommissionerPanIdConflictCallback = ::std::option::Option<
3748 unsafe extern "C" fn(aPanId: u16, aChannelMask: u32, aContext: *mut ::std::os::raw::c_void),
3749>;
3750extern "C" {
3751 #[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()."]
3752 pub fn otCommissionerPanIdQuery(
3753 aInstance: *mut otInstance,
3754 aPanId: u16,
3755 aChannelMask: u32,
3756 aAddress: *const otIp6Address,
3757 aCallback: otCommissionerPanIdConflictCallback,
3758 aContext: *mut ::std::os::raw::c_void,
3759 ) -> otError;
3760}
3761extern "C" {
3762 #[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."]
3763 pub fn otCommissionerSendMgmtGet(
3764 aInstance: *mut otInstance,
3765 aTlvs: *const u8,
3766 aLength: u8,
3767 ) -> otError;
3768}
3769extern "C" {
3770 #[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."]
3771 pub fn otCommissionerSendMgmtSet(
3772 aInstance: *mut otInstance,
3773 aDataset: *const otCommissioningDataset,
3774 aTlvs: *const u8,
3775 aLength: u8,
3776 ) -> otError;
3777}
3778extern "C" {
3779 #[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."]
3780 pub fn otCommissionerGetSessionId(aInstance: *mut otInstance) -> u16;
3781}
3782extern "C" {
3783 #[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."]
3784 pub fn otCommissionerGetState(aInstance: *mut otInstance) -> otCommissionerState;
3785}
3786pub type otNetworkDataIterator = u32;
3787#[doc = " Represents a Border Router configuration."]
3788#[repr(C)]
3789#[repr(align(4))]
3790#[derive(Copy, Clone)]
3791pub struct otBorderRouterConfig {
3792 #[doc = "< The IPv6 prefix."]
3793 pub mPrefix: otIp6Prefix,
3794 pub _bitfield_align_1: [u8; 0],
3795 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
3796 #[doc = "< The border router's RLOC16 (value ignored on config add)."]
3797 pub mRloc16: u16,
3798}
3799impl Default for otBorderRouterConfig {
3800 fn default() -> Self {
3801 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3802 unsafe {
3803 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3804 s.assume_init()
3805 }
3806 }
3807}
3808impl otBorderRouterConfig {
3809 #[inline]
3810 pub fn mPreference(&self) -> ::std::os::raw::c_int {
3811 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
3812 }
3813 #[inline]
3814 pub fn set_mPreference(&mut self, val: ::std::os::raw::c_int) {
3815 unsafe {
3816 let val: u32 = ::std::mem::transmute(val);
3817 self._bitfield_1.set(0usize, 2u8, val as u64)
3818 }
3819 }
3820 #[inline]
3821 pub fn mPreferred(&self) -> bool {
3822 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
3823 }
3824 #[inline]
3825 pub fn set_mPreferred(&mut self, val: bool) {
3826 unsafe {
3827 let val: u8 = ::std::mem::transmute(val);
3828 self._bitfield_1.set(2usize, 1u8, val as u64)
3829 }
3830 }
3831 #[inline]
3832 pub fn mSlaac(&self) -> bool {
3833 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
3834 }
3835 #[inline]
3836 pub fn set_mSlaac(&mut self, val: bool) {
3837 unsafe {
3838 let val: u8 = ::std::mem::transmute(val);
3839 self._bitfield_1.set(3usize, 1u8, val as u64)
3840 }
3841 }
3842 #[inline]
3843 pub fn mDhcp(&self) -> bool {
3844 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
3845 }
3846 #[inline]
3847 pub fn set_mDhcp(&mut self, val: bool) {
3848 unsafe {
3849 let val: u8 = ::std::mem::transmute(val);
3850 self._bitfield_1.set(4usize, 1u8, val as u64)
3851 }
3852 }
3853 #[inline]
3854 pub fn mConfigure(&self) -> bool {
3855 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
3856 }
3857 #[inline]
3858 pub fn set_mConfigure(&mut self, val: bool) {
3859 unsafe {
3860 let val: u8 = ::std::mem::transmute(val);
3861 self._bitfield_1.set(5usize, 1u8, val as u64)
3862 }
3863 }
3864 #[inline]
3865 pub fn mDefaultRoute(&self) -> bool {
3866 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
3867 }
3868 #[inline]
3869 pub fn set_mDefaultRoute(&mut self, val: bool) {
3870 unsafe {
3871 let val: u8 = ::std::mem::transmute(val);
3872 self._bitfield_1.set(6usize, 1u8, val as u64)
3873 }
3874 }
3875 #[inline]
3876 pub fn mOnMesh(&self) -> bool {
3877 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 1u8) as u8) }
3878 }
3879 #[inline]
3880 pub fn set_mOnMesh(&mut self, val: bool) {
3881 unsafe {
3882 let val: u8 = ::std::mem::transmute(val);
3883 self._bitfield_1.set(7usize, 1u8, val as u64)
3884 }
3885 }
3886 #[inline]
3887 pub fn mStable(&self) -> bool {
3888 unsafe { ::std::mem::transmute(self._bitfield_1.get(8usize, 1u8) as u8) }
3889 }
3890 #[inline]
3891 pub fn set_mStable(&mut self, val: bool) {
3892 unsafe {
3893 let val: u8 = ::std::mem::transmute(val);
3894 self._bitfield_1.set(8usize, 1u8, val as u64)
3895 }
3896 }
3897 #[inline]
3898 pub fn mNdDns(&self) -> bool {
3899 unsafe { ::std::mem::transmute(self._bitfield_1.get(9usize, 1u8) as u8) }
3900 }
3901 #[inline]
3902 pub fn set_mNdDns(&mut self, val: bool) {
3903 unsafe {
3904 let val: u8 = ::std::mem::transmute(val);
3905 self._bitfield_1.set(9usize, 1u8, val as u64)
3906 }
3907 }
3908 #[inline]
3909 pub fn mDp(&self) -> bool {
3910 unsafe { ::std::mem::transmute(self._bitfield_1.get(10usize, 1u8) as u8) }
3911 }
3912 #[inline]
3913 pub fn set_mDp(&mut self, val: bool) {
3914 unsafe {
3915 let val: u8 = ::std::mem::transmute(val);
3916 self._bitfield_1.set(10usize, 1u8, val as u64)
3917 }
3918 }
3919 #[inline]
3920 pub fn new_bitfield_1(
3921 mPreference: ::std::os::raw::c_int,
3922 mPreferred: bool,
3923 mSlaac: bool,
3924 mDhcp: bool,
3925 mConfigure: bool,
3926 mDefaultRoute: bool,
3927 mOnMesh: bool,
3928 mStable: bool,
3929 mNdDns: bool,
3930 mDp: bool,
3931 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
3932 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
3933 __bindgen_bitfield_unit.set(0usize, 2u8, {
3934 let mPreference: u32 = unsafe { ::std::mem::transmute(mPreference) };
3935 mPreference as u64
3936 });
3937 __bindgen_bitfield_unit.set(2usize, 1u8, {
3938 let mPreferred: u8 = unsafe { ::std::mem::transmute(mPreferred) };
3939 mPreferred as u64
3940 });
3941 __bindgen_bitfield_unit.set(3usize, 1u8, {
3942 let mSlaac: u8 = unsafe { ::std::mem::transmute(mSlaac) };
3943 mSlaac as u64
3944 });
3945 __bindgen_bitfield_unit.set(4usize, 1u8, {
3946 let mDhcp: u8 = unsafe { ::std::mem::transmute(mDhcp) };
3947 mDhcp as u64
3948 });
3949 __bindgen_bitfield_unit.set(5usize, 1u8, {
3950 let mConfigure: u8 = unsafe { ::std::mem::transmute(mConfigure) };
3951 mConfigure as u64
3952 });
3953 __bindgen_bitfield_unit.set(6usize, 1u8, {
3954 let mDefaultRoute: u8 = unsafe { ::std::mem::transmute(mDefaultRoute) };
3955 mDefaultRoute as u64
3956 });
3957 __bindgen_bitfield_unit.set(7usize, 1u8, {
3958 let mOnMesh: u8 = unsafe { ::std::mem::transmute(mOnMesh) };
3959 mOnMesh as u64
3960 });
3961 __bindgen_bitfield_unit.set(8usize, 1u8, {
3962 let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
3963 mStable as u64
3964 });
3965 __bindgen_bitfield_unit.set(9usize, 1u8, {
3966 let mNdDns: u8 = unsafe { ::std::mem::transmute(mNdDns) };
3967 mNdDns as u64
3968 });
3969 __bindgen_bitfield_unit.set(10usize, 1u8, {
3970 let mDp: u8 = unsafe { ::std::mem::transmute(mDp) };
3971 mDp as u64
3972 });
3973 __bindgen_bitfield_unit
3974 }
3975}
3976#[doc = " Represents 6LoWPAN Context ID information associated with a prefix in Network Data."]
3977#[repr(C)]
3978#[derive(Copy, Clone)]
3979pub struct otLowpanContextInfo {
3980 #[doc = "< The 6LoWPAN Context ID."]
3981 pub mContextId: u8,
3982 pub _bitfield_align_1: [u8; 0],
3983 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
3984 #[doc = "< The associated IPv6 prefix."]
3985 pub mPrefix: otIp6Prefix,
3986}
3987impl Default for otLowpanContextInfo {
3988 fn default() -> Self {
3989 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
3990 unsafe {
3991 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
3992 s.assume_init()
3993 }
3994 }
3995}
3996impl otLowpanContextInfo {
3997 #[inline]
3998 pub fn mCompressFlag(&self) -> bool {
3999 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
4000 }
4001 #[inline]
4002 pub fn set_mCompressFlag(&mut self, val: bool) {
4003 unsafe {
4004 let val: u8 = ::std::mem::transmute(val);
4005 self._bitfield_1.set(0usize, 1u8, val as u64)
4006 }
4007 }
4008 #[inline]
4009 pub fn mStable(&self) -> bool {
4010 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
4011 }
4012 #[inline]
4013 pub fn set_mStable(&mut self, val: bool) {
4014 unsafe {
4015 let val: u8 = ::std::mem::transmute(val);
4016 self._bitfield_1.set(1usize, 1u8, val as u64)
4017 }
4018 }
4019 #[inline]
4020 pub fn new_bitfield_1(
4021 mCompressFlag: bool,
4022 mStable: bool,
4023 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4024 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4025 __bindgen_bitfield_unit.set(0usize, 1u8, {
4026 let mCompressFlag: u8 = unsafe { ::std::mem::transmute(mCompressFlag) };
4027 mCompressFlag as u64
4028 });
4029 __bindgen_bitfield_unit.set(1usize, 1u8, {
4030 let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
4031 mStable as u64
4032 });
4033 __bindgen_bitfield_unit
4034 }
4035}
4036#[doc = " Represents an External Route configuration."]
4037#[repr(C)]
4038#[repr(align(4))]
4039#[derive(Copy, Clone)]
4040pub struct otExternalRouteConfig {
4041 #[doc = "< The IPv6 prefix."]
4042 pub mPrefix: otIp6Prefix,
4043 #[doc = "< The border router's RLOC16 (value ignored on config add)."]
4044 pub mRloc16: u16,
4045 pub _bitfield_align_1: [u8; 0],
4046 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4047 pub __bindgen_padding_0: [u8; 3usize],
4048}
4049impl Default for otExternalRouteConfig {
4050 fn default() -> Self {
4051 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4052 unsafe {
4053 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4054 s.assume_init()
4055 }
4056 }
4057}
4058impl otExternalRouteConfig {
4059 #[inline]
4060 pub fn mPreference(&self) -> ::std::os::raw::c_int {
4061 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u32) }
4062 }
4063 #[inline]
4064 pub fn set_mPreference(&mut self, val: ::std::os::raw::c_int) {
4065 unsafe {
4066 let val: u32 = ::std::mem::transmute(val);
4067 self._bitfield_1.set(0usize, 2u8, val as u64)
4068 }
4069 }
4070 #[inline]
4071 pub fn mNat64(&self) -> bool {
4072 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
4073 }
4074 #[inline]
4075 pub fn set_mNat64(&mut self, val: bool) {
4076 unsafe {
4077 let val: u8 = ::std::mem::transmute(val);
4078 self._bitfield_1.set(2usize, 1u8, val as u64)
4079 }
4080 }
4081 #[inline]
4082 pub fn mStable(&self) -> bool {
4083 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
4084 }
4085 #[inline]
4086 pub fn set_mStable(&mut self, val: bool) {
4087 unsafe {
4088 let val: u8 = ::std::mem::transmute(val);
4089 self._bitfield_1.set(3usize, 1u8, val as u64)
4090 }
4091 }
4092 #[inline]
4093 pub fn mNextHopIsThisDevice(&self) -> bool {
4094 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
4095 }
4096 #[inline]
4097 pub fn set_mNextHopIsThisDevice(&mut self, val: bool) {
4098 unsafe {
4099 let val: u8 = ::std::mem::transmute(val);
4100 self._bitfield_1.set(4usize, 1u8, val as u64)
4101 }
4102 }
4103 #[inline]
4104 pub fn mAdvPio(&self) -> bool {
4105 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
4106 }
4107 #[inline]
4108 pub fn set_mAdvPio(&mut self, val: bool) {
4109 unsafe {
4110 let val: u8 = ::std::mem::transmute(val);
4111 self._bitfield_1.set(5usize, 1u8, val as u64)
4112 }
4113 }
4114 #[inline]
4115 pub fn new_bitfield_1(
4116 mPreference: ::std::os::raw::c_int,
4117 mNat64: bool,
4118 mStable: bool,
4119 mNextHopIsThisDevice: bool,
4120 mAdvPio: bool,
4121 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4122 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4123 __bindgen_bitfield_unit.set(0usize, 2u8, {
4124 let mPreference: u32 = unsafe { ::std::mem::transmute(mPreference) };
4125 mPreference as u64
4126 });
4127 __bindgen_bitfield_unit.set(2usize, 1u8, {
4128 let mNat64: u8 = unsafe { ::std::mem::transmute(mNat64) };
4129 mNat64 as u64
4130 });
4131 __bindgen_bitfield_unit.set(3usize, 1u8, {
4132 let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
4133 mStable as u64
4134 });
4135 __bindgen_bitfield_unit.set(4usize, 1u8, {
4136 let mNextHopIsThisDevice: u8 = unsafe { ::std::mem::transmute(mNextHopIsThisDevice) };
4137 mNextHopIsThisDevice as u64
4138 });
4139 __bindgen_bitfield_unit.set(5usize, 1u8, {
4140 let mAdvPio: u8 = unsafe { ::std::mem::transmute(mAdvPio) };
4141 mAdvPio as u64
4142 });
4143 __bindgen_bitfield_unit
4144 }
4145}
4146#[doc = "< Low route preference."]
4147pub const OT_ROUTE_PREFERENCE_LOW: otRoutePreference = -1;
4148#[doc = "< Medium route preference."]
4149pub const OT_ROUTE_PREFERENCE_MED: otRoutePreference = 0;
4150#[doc = "< High route preference."]
4151pub const OT_ROUTE_PREFERENCE_HIGH: otRoutePreference = 1;
4152#[doc = " Defines valid values for `mPreference` in `otExternalRouteConfig` and `otBorderRouterConfig`."]
4153pub type otRoutePreference = ::std::os::raw::c_int;
4154#[doc = " Represents a Server configuration."]
4155#[repr(C)]
4156#[derive(Debug, Copy, Clone)]
4157pub struct otServerConfig {
4158 pub _bitfield_align_1: [u8; 0],
4159 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4160 #[doc = "< Length of server data."]
4161 pub mServerDataLength: u8,
4162 #[doc = "< Server data bytes."]
4163 pub mServerData: [u8; 248usize],
4164 #[doc = "< The Server RLOC16."]
4165 pub mRloc16: u16,
4166}
4167impl Default for otServerConfig {
4168 fn default() -> Self {
4169 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4170 unsafe {
4171 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4172 s.assume_init()
4173 }
4174 }
4175}
4176impl otServerConfig {
4177 #[inline]
4178 pub fn mStable(&self) -> bool {
4179 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
4180 }
4181 #[inline]
4182 pub fn set_mStable(&mut self, val: bool) {
4183 unsafe {
4184 let val: u8 = ::std::mem::transmute(val);
4185 self._bitfield_1.set(0usize, 1u8, val as u64)
4186 }
4187 }
4188 #[inline]
4189 pub fn new_bitfield_1(mStable: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4190 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4191 __bindgen_bitfield_unit.set(0usize, 1u8, {
4192 let mStable: u8 = unsafe { ::std::mem::transmute(mStable) };
4193 mStable as u64
4194 });
4195 __bindgen_bitfield_unit
4196 }
4197}
4198#[doc = " Represents a Service configuration."]
4199#[repr(C)]
4200#[derive(Debug, Copy, Clone)]
4201pub struct otServiceConfig {
4202 #[doc = "< Service ID (when iterating over the Network Data)."]
4203 pub mServiceId: u8,
4204 #[doc = "< IANA Enterprise Number."]
4205 pub mEnterpriseNumber: u32,
4206 #[doc = "< Length of service data."]
4207 pub mServiceDataLength: u8,
4208 #[doc = "< Service data bytes."]
4209 pub mServiceData: [u8; 252usize],
4210 #[doc = "< The Server configuration."]
4211 pub mServerConfig: otServerConfig,
4212}
4213impl Default for otServiceConfig {
4214 fn default() -> Self {
4215 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4216 unsafe {
4217 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4218 s.assume_init()
4219 }
4220 }
4221}
4222extern "C" {
4223 #[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."]
4224 pub fn otNetDataGet(
4225 aInstance: *mut otInstance,
4226 aStable: bool,
4227 aData: *mut u8,
4228 aDataLength: *mut u8,
4229 ) -> otError;
4230}
4231extern "C" {
4232 #[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."]
4233 pub fn otNetDataGetLength(aInstance: *mut otInstance) -> u8;
4234}
4235extern "C" {
4236 #[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)."]
4237 pub fn otNetDataGetMaxLength(aInstance: *mut otInstance) -> u8;
4238}
4239extern "C" {
4240 #[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"]
4241 pub fn otNetDataResetMaxLength(aInstance: *mut otInstance);
4242}
4243extern "C" {
4244 #[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."]
4245 pub fn otNetDataGetNextOnMeshPrefix(
4246 aInstance: *mut otInstance,
4247 aIterator: *mut otNetworkDataIterator,
4248 aConfig: *mut otBorderRouterConfig,
4249 ) -> otError;
4250}
4251extern "C" {
4252 #[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."]
4253 pub fn otNetDataGetNextRoute(
4254 aInstance: *mut otInstance,
4255 aIterator: *mut otNetworkDataIterator,
4256 aConfig: *mut otExternalRouteConfig,
4257 ) -> otError;
4258}
4259extern "C" {
4260 #[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."]
4261 pub fn otNetDataGetNextService(
4262 aInstance: *mut otInstance,
4263 aIterator: *mut otNetworkDataIterator,
4264 aConfig: *mut otServiceConfig,
4265 ) -> otError;
4266}
4267extern "C" {
4268 #[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."]
4269 pub fn otNetDataGetNextLowpanContextInfo(
4270 aInstance: *mut otInstance,
4271 aIterator: *mut otNetworkDataIterator,
4272 aContextInfo: *mut otLowpanContextInfo,
4273 ) -> otError;
4274}
4275extern "C" {
4276 #[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."]
4277 pub fn otNetDataGetCommissioningDataset(
4278 aInstance: *mut otInstance,
4279 aDataset: *mut otCommissioningDataset,
4280 );
4281}
4282extern "C" {
4283 #[doc = " Get the Network Data Version.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Network Data Version."]
4284 pub fn otNetDataGetVersion(aInstance: *mut otInstance) -> u8;
4285}
4286extern "C" {
4287 #[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."]
4288 pub fn otNetDataGetStableVersion(aInstance: *mut otInstance) -> u8;
4289}
4290extern "C" {
4291 #[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."]
4292 pub fn otNetDataSteeringDataCheckJoiner(
4293 aInstance: *mut otInstance,
4294 aEui64: *const otExtAddress,
4295 ) -> otError;
4296}
4297extern "C" {
4298 #[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."]
4299 pub fn otNetDataSteeringDataCheckJoinerWithDiscerner(
4300 aInstance: *mut otInstance,
4301 aDiscerner: *const otJoinerDiscerner,
4302 ) -> otError;
4303}
4304extern "C" {
4305 #[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."]
4306 pub fn otNetDataContainsOmrPrefix(
4307 aInstance: *mut otInstance,
4308 aPrefix: *const otIp6Prefix,
4309 ) -> bool;
4310}
4311#[doc = "< Backbone function is disabled."]
4312pub const OT_BACKBONE_ROUTER_STATE_DISABLED: otBackboneRouterState = 0;
4313#[doc = "< Secondary Backbone Router."]
4314pub const OT_BACKBONE_ROUTER_STATE_SECONDARY: otBackboneRouterState = 1;
4315#[doc = "< The Primary Backbone Router."]
4316pub const OT_BACKBONE_ROUTER_STATE_PRIMARY: otBackboneRouterState = 2;
4317#[doc = " Represents the Backbone Router Status."]
4318pub type otBackboneRouterState = ::std::os::raw::c_uint;
4319extern "C" {
4320 #[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"]
4321 pub fn otBackboneRouterSetEnabled(aInstance: *mut otInstance, aEnable: bool);
4322}
4323extern "C" {
4324 #[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"]
4325 pub fn otBackboneRouterGetState(aInstance: *mut otInstance) -> otBackboneRouterState;
4326}
4327extern "C" {
4328 #[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"]
4329 pub fn otBackboneRouterGetConfig(
4330 aInstance: *mut otInstance,
4331 aConfig: *mut otBackboneRouterConfig,
4332 );
4333}
4334extern "C" {
4335 #[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"]
4336 pub fn otBackboneRouterSetConfig(
4337 aInstance: *mut otInstance,
4338 aConfig: *const otBackboneRouterConfig,
4339 ) -> otError;
4340}
4341extern "C" {
4342 #[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"]
4343 pub fn otBackboneRouterRegister(aInstance: *mut otInstance) -> otError;
4344}
4345extern "C" {
4346 #[doc = " Returns the Backbone Router registration jitter value.\n\n @returns The Backbone Router registration jitter value.\n\n @sa otBackboneRouterSetRegistrationJitter"]
4347 pub fn otBackboneRouterGetRegistrationJitter(aInstance: *mut otInstance) -> u8;
4348}
4349extern "C" {
4350 #[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"]
4351 pub fn otBackboneRouterSetRegistrationJitter(aInstance: *mut otInstance, aJitter: u8);
4352}
4353extern "C" {
4354 #[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."]
4355 pub fn otBackboneRouterGetDomainPrefix(
4356 aInstance: *mut otInstance,
4357 aConfig: *mut otBorderRouterConfig,
4358 ) -> otError;
4359}
4360extern "C" {
4361 #[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."]
4362 pub fn otBackboneRouterConfigNextDuaRegistrationResponse(
4363 aInstance: *mut otInstance,
4364 aMlIid: *const otIp6InterfaceIdentifier,
4365 aStatus: u8,
4366 );
4367}
4368extern "C" {
4369 #[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."]
4370 pub fn otBackboneRouterConfigNextMulticastListenerRegistrationResponse(
4371 aInstance: *mut otInstance,
4372 aStatus: u8,
4373 );
4374}
4375#[doc = "< Multicast Listener was added."]
4376pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_ADDED: otBackboneRouterMulticastListenerEvent = 0;
4377#[doc = "< Multicast Listener was removed or expired."]
4378pub const OT_BACKBONE_ROUTER_MULTICAST_LISTENER_REMOVED: otBackboneRouterMulticastListenerEvent = 1;
4379#[doc = " Represents the Multicast Listener events."]
4380pub type otBackboneRouterMulticastListenerEvent = ::std::os::raw::c_uint;
4381#[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."]
4382pub type otBackboneRouterMulticastListenerCallback = ::std::option::Option<
4383 unsafe extern "C" fn(
4384 aContext: *mut ::std::os::raw::c_void,
4385 aEvent: otBackboneRouterMulticastListenerEvent,
4386 aAddress: *const otIp6Address,
4387 ),
4388>;
4389extern "C" {
4390 #[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."]
4391 pub fn otBackboneRouterSetMulticastListenerCallback(
4392 aInstance: *mut otInstance,
4393 aCallback: otBackboneRouterMulticastListenerCallback,
4394 aContext: *mut ::std::os::raw::c_void,
4395 );
4396}
4397extern "C" {
4398 #[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"]
4399 pub fn otBackboneRouterMulticastListenerClear(aInstance: *mut otInstance);
4400}
4401extern "C" {
4402 #[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"]
4403 pub fn otBackboneRouterMulticastListenerAdd(
4404 aInstance: *mut otInstance,
4405 aAddress: *const otIp6Address,
4406 aTimeout: u32,
4407 ) -> otError;
4408}
4409pub type otBackboneRouterMulticastListenerIterator = u16;
4410#[doc = " Represents a Backbone Router Multicast Listener info."]
4411#[repr(C)]
4412#[derive(Copy, Clone)]
4413pub struct otBackboneRouterMulticastListenerInfo {
4414 pub mAddress: otIp6Address,
4415 pub mTimeout: u32,
4416}
4417impl Default for otBackboneRouterMulticastListenerInfo {
4418 fn default() -> Self {
4419 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4420 unsafe {
4421 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4422 s.assume_init()
4423 }
4424 }
4425}
4426extern "C" {
4427 #[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"]
4428 pub fn otBackboneRouterMulticastListenerGetNext(
4429 aInstance: *mut otInstance,
4430 aIterator: *mut otBackboneRouterMulticastListenerIterator,
4431 aListenerInfo: *mut otBackboneRouterMulticastListenerInfo,
4432 ) -> otError;
4433}
4434#[doc = "< ND Proxy was added."]
4435pub const OT_BACKBONE_ROUTER_NDPROXY_ADDED: otBackboneRouterNdProxyEvent = 0;
4436#[doc = "< ND Proxy was removed."]
4437pub const OT_BACKBONE_ROUTER_NDPROXY_REMOVED: otBackboneRouterNdProxyEvent = 1;
4438#[doc = "< ND Proxy was renewed."]
4439pub const OT_BACKBONE_ROUTER_NDPROXY_RENEWED: otBackboneRouterNdProxyEvent = 2;
4440#[doc = "< All ND Proxies were cleared."]
4441pub const OT_BACKBONE_ROUTER_NDPROXY_CLEARED: otBackboneRouterNdProxyEvent = 3;
4442#[doc = " Represents the ND Proxy events."]
4443pub type otBackboneRouterNdProxyEvent = ::std::os::raw::c_uint;
4444#[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 NULL if @p aEvent is\n `OT_BACKBONE_ROUTER_NDPROXY_CLEARED`."]
4445pub type otBackboneRouterNdProxyCallback = ::std::option::Option<
4446 unsafe extern "C" fn(
4447 aContext: *mut ::std::os::raw::c_void,
4448 aEvent: otBackboneRouterNdProxyEvent,
4449 aDua: *const otIp6Address,
4450 ),
4451>;
4452extern "C" {
4453 #[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."]
4454 pub fn otBackboneRouterSetNdProxyCallback(
4455 aInstance: *mut otInstance,
4456 aCallback: otBackboneRouterNdProxyCallback,
4457 aContext: *mut ::std::os::raw::c_void,
4458 );
4459}
4460#[doc = " Represents the Backbone Router ND Proxy info."]
4461#[repr(C)]
4462#[derive(Debug, Copy, Clone)]
4463pub struct otBackboneRouterNdProxyInfo {
4464 #[doc = "< Mesh-local IID"]
4465 pub mMeshLocalIid: *mut otIp6InterfaceIdentifier,
4466 #[doc = "< Time since last transaction (Seconds)"]
4467 pub mTimeSinceLastTransaction: u32,
4468 #[doc = "< RLOC16"]
4469 pub mRloc16: u16,
4470}
4471impl Default for otBackboneRouterNdProxyInfo {
4472 fn default() -> Self {
4473 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4474 unsafe {
4475 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4476 s.assume_init()
4477 }
4478 }
4479}
4480extern "C" {
4481 #[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."]
4482 pub fn otBackboneRouterGetNdProxyInfo(
4483 aInstance: *mut otInstance,
4484 aDua: *const otIp6Address,
4485 aNdProxyInfo: *mut otBackboneRouterNdProxyInfo,
4486 ) -> otError;
4487}
4488#[doc = "< Domain Prefix was added."]
4489pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_ADDED: otBackboneRouterDomainPrefixEvent = 0;
4490#[doc = "< Domain Prefix was removed."]
4491pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_REMOVED: otBackboneRouterDomainPrefixEvent = 1;
4492#[doc = "< Domain Prefix was changed."]
4493pub const OT_BACKBONE_ROUTER_DOMAIN_PREFIX_CHANGED: otBackboneRouterDomainPrefixEvent = 2;
4494#[doc = " Represents the Domain Prefix events."]
4495pub type otBackboneRouterDomainPrefixEvent = ::std::os::raw::c_uint;
4496#[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, NULL otherwise."]
4497pub type otBackboneRouterDomainPrefixCallback = ::std::option::Option<
4498 unsafe extern "C" fn(
4499 aContext: *mut ::std::os::raw::c_void,
4500 aEvent: otBackboneRouterDomainPrefixEvent,
4501 aDomainPrefix: *const otIp6Prefix,
4502 ),
4503>;
4504extern "C" {
4505 #[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."]
4506 pub fn otBackboneRouterSetDomainPrefixCallback(
4507 aInstance: *mut otInstance,
4508 aCallback: otBackboneRouterDomainPrefixCallback,
4509 aContext: *mut ::std::os::raw::c_void,
4510 );
4511}
4512#[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)."]
4513#[repr(C)]
4514#[derive(Debug, Copy, Clone)]
4515pub struct otDnsTxtEntry {
4516 #[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."]
4517 pub mKey: *const ::std::os::raw::c_char,
4518 #[doc = "< The TXT record value or already encoded TXT-DATA (depending on `mKey`)."]
4519 pub mValue: *const u8,
4520 #[doc = "< Number of bytes in `mValue` buffer."]
4521 pub mValueLength: u16,
4522}
4523impl Default for otDnsTxtEntry {
4524 fn default() -> Self {
4525 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4526 unsafe {
4527 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4528 s.assume_init()
4529 }
4530 }
4531}
4532#[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."]
4533#[repr(C)]
4534#[derive(Debug, Copy, Clone)]
4535pub struct otDnsTxtEntryIterator {
4536 pub mPtr: *const ::std::os::raw::c_void,
4537 pub mData: [u16; 2usize],
4538 pub mChar: [::std::os::raw::c_char; 65usize],
4539}
4540impl Default for otDnsTxtEntryIterator {
4541 fn default() -> Self {
4542 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4543 unsafe {
4544 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4545 s.assume_init()
4546 }
4547 }
4548}
4549extern "C" {
4550 #[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."]
4551 pub fn otDnsInitTxtEntryIterator(
4552 aIterator: *mut otDnsTxtEntryIterator,
4553 aTxtData: *const u8,
4554 aTxtDataLength: u16,
4555 );
4556}
4557extern "C" {
4558 #[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."]
4559 pub fn otDnsGetNextTxtEntry(
4560 aIterator: *mut otDnsTxtEntryIterator,
4561 aEntry: *mut otDnsTxtEntry,
4562 ) -> otError;
4563}
4564extern "C" {
4565 #[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."]
4566 pub fn otDnsEncodeTxtData(
4567 aTxtEntries: *const otDnsTxtEntry,
4568 aNumTxtEntries: u16,
4569 aTxtData: *mut u8,
4570 aTxtDataLength: *mut u16,
4571 ) -> otError;
4572}
4573extern "C" {
4574 #[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."]
4575 pub fn otDnsSetNameCompressionEnabled(aEnabled: bool);
4576}
4577extern "C" {
4578 #[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."]
4579 pub fn otDnsIsNameCompressionEnabled() -> bool;
4580}
4581#[doc = " Represents a Border Agent Identifier."]
4582#[repr(C)]
4583#[derive(Debug, Default, Copy, Clone)]
4584pub struct otBorderAgentId {
4585 #[doc = "< Border Agent ID bytes."]
4586 pub mId: [u8; 16usize],
4587}
4588#[doc = " Defines Border Agent counters.\n\n The `mEpskc` related counters require `OPENTHREAD_CONFIG_BORDER_AGENT_EPHEMERAL_KEY_ENABLE`."]
4589#[repr(C)]
4590#[derive(Debug, Default, Copy, Clone)]
4591pub struct otBorderAgentCounters {
4592 #[doc = "< The number of ePSKc activations"]
4593 pub mEpskcActivations: u32,
4594 #[doc = "< The number of ePSKc deactivations via API"]
4595 pub mEpskcDeactivationClears: u32,
4596 #[doc = "< The number of ePSKc deactivations due to timeout"]
4597 pub mEpskcDeactivationTimeouts: u32,
4598 #[doc = "< The number of ePSKc deactivations due to reached max attempts"]
4599 pub mEpskcDeactivationMaxAttempts: u32,
4600 #[doc = "< The number of ePSKc deactivations due to commissioner disconnected"]
4601 pub mEpskcDeactivationDisconnects: u32,
4602 #[doc = "< The number of invalid border agent state errors at ePSKc activation"]
4603 pub mEpskcInvalidBaStateErrors: u32,
4604 #[doc = "< The number of invalid args errors at ePSKc activation"]
4605 pub mEpskcInvalidArgsErrors: u32,
4606 #[doc = "< The number of start secure session errors at ePSKc activation"]
4607 pub mEpskcStartSecureSessionErrors: u32,
4608 #[doc = "< The number of established secure sessions with ePSKc"]
4609 pub mEpskcSecureSessionSuccesses: u32,
4610 #[doc = "< The number of failed secure sessions with ePSKc"]
4611 pub mEpskcSecureSessionFailures: u32,
4612 #[doc = "< The number of successful commissioner petitions with ePSKc"]
4613 pub mEpskcCommissionerPetitions: u32,
4614 #[doc = "< The number of established secure sessions with PSKc"]
4615 pub mPskcSecureSessionSuccesses: u32,
4616 #[doc = "< The number of failed secure sessions with PSKc"]
4617 pub mPskcSecureSessionFailures: u32,
4618 #[doc = "< The number of successful commissioner petitions with PSKc"]
4619 pub mPskcCommissionerPetitions: u32,
4620 #[doc = "< The number of MGMT_ACTIVE_GET.req sent over secure sessions"]
4621 pub mMgmtActiveGets: u32,
4622 #[doc = "< The number of MGMT_PENDING_GET.req sent over secure sessions"]
4623 pub mMgmtPendingGets: u32,
4624}
4625#[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."]
4626#[repr(C)]
4627#[derive(Copy, Clone)]
4628pub struct otBorderAgentSessionInfo {
4629 #[doc = "< Socket address (IPv6 address and port number) of session peer."]
4630 pub mPeerSockAddr: otSockAddr,
4631 #[doc = "< Indicates whether the session is connected."]
4632 pub mIsConnected: bool,
4633 #[doc = "< Indicates whether the session is accepted as full commissioner."]
4634 pub mIsCommissioner: bool,
4635 #[doc = "< Milliseconds since the session was first established."]
4636 pub mLifetime: u64,
4637}
4638impl Default for otBorderAgentSessionInfo {
4639 fn default() -> Self {
4640 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4641 unsafe {
4642 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4643 s.assume_init()
4644 }
4645 }
4646}
4647#[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."]
4648#[repr(C)]
4649#[derive(Debug, Copy, Clone)]
4650pub struct otBorderAgentSessionIterator {
4651 pub mPtr: *mut ::std::os::raw::c_void,
4652 pub mData: u64,
4653}
4654impl Default for otBorderAgentSessionIterator {
4655 fn default() -> Self {
4656 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4657 unsafe {
4658 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4659 s.assume_init()
4660 }
4661 }
4662}
4663#[doc = " Represents the Border Agent MeshCoP Service TXT data."]
4664#[repr(C)]
4665#[derive(Debug, Copy, Clone)]
4666pub struct otBorderAgentMeshCoPServiceTxtData {
4667 pub mData: [u8; 256usize],
4668 pub mLength: u16,
4669}
4670impl Default for otBorderAgentMeshCoPServiceTxtData {
4671 fn default() -> Self {
4672 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4673 unsafe {
4674 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4675 s.assume_init()
4676 }
4677 }
4678}
4679extern "C" {
4680 #[doc = " Enables or disables the Border Agent service on the device.\n\n By default, the Border Agent service is enabled when the `OPENTHREAD_CONFIG_BORDER_AGENT_ENABLE` feature is used.\n This function allows higher-layer code to explicitly control its state. This can be useful in scenarios such as:\n\n - The higher-layer code wishes to delay the start of the Border Agent service (and its mDNS advertisement of the\n `_meshcop._udp` service on the infrastructure link). This allows time to prepare or determine vendor-specific TXT\n data entries for inclusion.\n - Unit tests or test scripts might disable the Border Agent service to prevent it from interfering with specific\n test steps. For example, tests validating mDNS or DNS-SD functionality may disable the Border Agent to prevent its\n registration of the MeshCoP service.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aEnabled A boolean to indicate whether to to enable (TRUE), or disable (FALSE)."]
4681 pub fn otBorderAgentSetEnabled(aInstance: *mut otInstance, aEnabled: bool);
4682}
4683extern "C" {
4684 #[doc = " Indicates whether or not the Border Agent service is enabled.\n\n @param[in] aInstance The OpenThread instance.\n\n @retval TRUE The Border Agent service is enabled.\n @retval FALSE The Border Agent service is disabled."]
4685 pub fn otBorderAgentIsEnabled(aInstance: *mut otInstance) -> bool;
4686}
4687extern "C" {
4688 #[doc = " Indicates whether or not the Border Agent service is enabled and also active.\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."]
4689 pub fn otBorderAgentIsActive(aInstance: *mut otInstance) -> bool;
4690}
4691extern "C" {
4692 #[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."]
4693 pub fn otBorderAgentGetUdpPort(aInstance: *mut otInstance) -> u16;
4694}
4695#[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."]
4696pub type otBorderAgentMeshCoPServiceChangedCallback =
4697 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
4698extern "C" {
4699 #[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."]
4700 pub fn otBorderAgentSetMeshCoPServiceChangedCallback(
4701 aInstance: *mut otInstance,
4702 aCallback: otBorderAgentMeshCoPServiceChangedCallback,
4703 aContext: *mut ::std::os::raw::c_void,
4704 );
4705}
4706extern "C" {
4707 #[doc = " Gets the MeshCoP service TXT data.\n\n The generated TXT data includes a subset of keys (depending on the device's current state and whether features are\n enabled) as specified in the documentation of the `OT_BORDER_AGENT_MESHCOP_SERVICE_TXT_DATA_MAX_LENGTH` constant.\n Notably, if `OPENTHREAD_CONFIG_BORDER_AGENT_MESHCOP_SERVICE_ENABLE` is enabled and `otBorderAgentSetVendorTxtData()`\n was used to set extra vendor-specific TXT data bytes, those vendor-specified TXT data bytes are NOT included in the\n TXT data returned by this function.\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."]
4708 pub fn otBorderAgentGetMeshCoPServiceTxtData(
4709 aInstance: *mut otInstance,
4710 aTxtData: *mut otBorderAgentMeshCoPServiceTxtData,
4711 ) -> otError;
4712}
4713extern "C" {
4714 #[doc = " Sets the base name to construct the service instance name used when advertising the mDNS `_meshcop._udp` service by\n the Border Agent.\n\n Requires the `OPENTHREAD_CONFIG_BORDER_AGENT_MESHCOP_SERVICE_ENABLE` feature.\n\n The name can also be configured using the `OPENTHREAD_CONFIG_BORDER_AGENT_MESHCOP_SERVICE_BASE_NAME` configuration\n option (which is the recommended way to specify this name). This API is provided for projects where the name needs\n to be set after device initialization and at run-time.\n\n Per the Thread specification, the service instance should be a user-friendly name identifying the device model or\n product. A recommended format is \"<VendorName> <ProductName>\".\n\n To construct the full name and ensure name uniqueness, the OpenThread Border Agent module will append the Extended\n Address of the device (as 16-character hex digits) to the given base name.\n\n Note that the same name will be used for the ephemeral key service `_meshcop-e._udp` when the ephemeral key feature\n is enabled and used.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aBaseName The base name to use (MUST not be NULL).\n\n @retval OT_ERROR_NONE The name was set successfully.\n @retval OT_ERROR_INVALID_ARGS The name is too long or invalid."]
4715 pub fn otBorderAgentSetMeshCoPServiceBaseName(
4716 aInstance: *mut otInstance,
4717 aBaseName: *const ::std::os::raw::c_char,
4718 ) -> otError;
4719}
4720extern "C" {
4721 #[doc = " Sets the vendor extra TXT data to be included when the Border Agent advertises the mDNS `_meshcop._udp` service.\n\n Requires the `OPENTHREAD_CONFIG_BORDER_AGENT_MESHCOP_SERVICE_ENABLE` feature.\n\n The provided @p aVendorData bytes are appended as they appear in the buffer to the end of the TXT data generated by\n the Border Agent itself, and are then included in the advertised mDNS `_meshcop._udp` service.\n\n This function itself does not perform any validation of the format of the provided @p aVendorData. Therefore, the\n caller MUST ensure it is formatted properly. Per the Thread specification, vendor-specific Key-Value TXT data pairs\n use TXT keys starting with 'v'. For example, `vn` for vendor name and generally `v*`.\n\n The OpenThread stack will create and retain its own copy of the bytes in @p aVendorData. So, the buffer passed to\n this function does not need to persist beyond the scope of the call.\n\n The vendor TXT data can be set at any time while the Border Agent is in any state. If there is a change from the\n previously set value, it will trigger an update of the registered mDNS service to advertise the new TXT data.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aVendorData A pointer to the buffer containing the vendor TXT data.\n @param[in] aVendorDataLength The length of @p aVendorData in bytes."]
4722 pub fn otBorderAgentSetVendorTxtData(
4723 aInstance: *mut otInstance,
4724 aVendorData: *const u8,
4725 aVendorDataLength: u16,
4726 );
4727}
4728extern "C" {
4729 #[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"]
4730 pub fn otBorderAgentGetId(aInstance: *mut otInstance, aId: *mut otBorderAgentId) -> otError;
4731}
4732extern "C" {
4733 #[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"]
4734 pub fn otBorderAgentSetId(aInstance: *mut otInstance, aId: *const otBorderAgentId) -> otError;
4735}
4736extern "C" {
4737 #[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."]
4738 pub fn otBorderAgentInitSessionIterator(
4739 aInstance: *mut otInstance,
4740 aIterator: *mut otBorderAgentSessionIterator,
4741 );
4742}
4743extern "C" {
4744 #[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."]
4745 pub fn otBorderAgentGetNextSessionInfo(
4746 aIterator: *mut otBorderAgentSessionIterator,
4747 aSessionInfo: *mut otBorderAgentSessionInfo,
4748 ) -> otError;
4749}
4750extern "C" {
4751 #[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."]
4752 pub fn otBorderAgentGetCounters(aInstance: *mut otInstance) -> *const otBorderAgentCounters;
4753}
4754#[doc = "< Ephemeral Key Manager is disabled."]
4755pub const OT_BORDER_AGENT_STATE_DISABLED: otBorderAgentEphemeralKeyState = 0;
4756#[doc = "< Enabled, but no ephemeral key is in use (not set or started)."]
4757pub const OT_BORDER_AGENT_STATE_STOPPED: otBorderAgentEphemeralKeyState = 1;
4758#[doc = "< Ephemeral key is set. Listening to accept secure connections."]
4759pub const OT_BORDER_AGENT_STATE_STARTED: otBorderAgentEphemeralKeyState = 2;
4760#[doc = "< Session is established with an external commissioner candidate."]
4761pub const OT_BORDER_AGENT_STATE_CONNECTED: otBorderAgentEphemeralKeyState = 3;
4762#[doc = "< Session is established and candidate is accepted as full commissioner."]
4763pub const OT_BORDER_AGENT_STATE_ACCEPTED: otBorderAgentEphemeralKeyState = 4;
4764#[doc = " Represents Border Agent's Ephemeral Key Manager state."]
4765pub type otBorderAgentEphemeralKeyState = ::std::os::raw::c_uint;
4766extern "C" {
4767 #[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."]
4768 pub fn otBorderAgentEphemeralKeyGetState(
4769 aInstance: *mut otInstance,
4770 ) -> otBorderAgentEphemeralKeyState;
4771}
4772extern "C" {
4773 #[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."]
4774 pub fn otBorderAgentEphemeralKeySetEnabled(aInstance: *mut otInstance, aEnabled: bool);
4775}
4776extern "C" {
4777 #[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)."]
4778 pub fn otBorderAgentEphemeralKeyStart(
4779 aInstance: *mut otInstance,
4780 aKeyString: *const ::std::os::raw::c_char,
4781 aTimeout: u32,
4782 aUdpPort: u16,
4783 ) -> otError;
4784}
4785extern "C" {
4786 #[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."]
4787 pub fn otBorderAgentEphemeralKeyStop(aInstance: *mut otInstance);
4788}
4789extern "C" {
4790 #[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)."]
4791 pub fn otBorderAgentEphemeralKeyGetUdpPort(aInstance: *mut otInstance) -> u16;
4792}
4793#[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)."]
4794pub type otBorderAgentEphemeralKeyCallback =
4795 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
4796extern "C" {
4797 #[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."]
4798 pub fn otBorderAgentEphemeralKeySetCallback(
4799 aInstance: *mut otInstance,
4800 aCallback: otBorderAgentEphemeralKeyCallback,
4801 aContext: *mut ::std::os::raw::c_void,
4802 );
4803}
4804extern "C" {
4805 #[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."]
4806 pub fn otBorderAgentEphemeralKeyStateToString(
4807 aState: otBorderAgentEphemeralKeyState,
4808 ) -> *const ::std::os::raw::c_char;
4809}
4810#[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()`."]
4811#[repr(C)]
4812#[derive(Debug, Copy, Clone)]
4813pub struct otBorderRoutingPrefixTableIterator {
4814 pub mPtr1: *const ::std::os::raw::c_void,
4815 pub mPtr2: *const ::std::os::raw::c_void,
4816 pub mData0: u32,
4817 pub mData1: u32,
4818 pub mData2: u8,
4819 pub mData3: u8,
4820}
4821impl Default for otBorderRoutingPrefixTableIterator {
4822 fn default() -> Self {
4823 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4824 unsafe {
4825 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4826 s.assume_init()
4827 }
4828 }
4829}
4830#[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."]
4831#[repr(C)]
4832#[derive(Copy, Clone)]
4833pub struct otBorderRoutingRouterEntry {
4834 #[doc = "< IPv6 address of the router."]
4835 pub mAddress: otIp6Address,
4836 #[doc = "< Milliseconds since last update (any message rx) from this router."]
4837 pub mMsecSinceLastUpdate: u32,
4838 #[doc = "< The router's age in seconds (duration since its first discovery)."]
4839 pub mAge: u32,
4840 pub _bitfield_align_1: [u8; 0],
4841 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
4842 pub __bindgen_padding_0: [u8; 3usize],
4843}
4844impl Default for otBorderRoutingRouterEntry {
4845 fn default() -> Self {
4846 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4847 unsafe {
4848 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4849 s.assume_init()
4850 }
4851 }
4852}
4853impl otBorderRoutingRouterEntry {
4854 #[inline]
4855 pub fn mManagedAddressConfigFlag(&self) -> bool {
4856 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
4857 }
4858 #[inline]
4859 pub fn set_mManagedAddressConfigFlag(&mut self, val: bool) {
4860 unsafe {
4861 let val: u8 = ::std::mem::transmute(val);
4862 self._bitfield_1.set(0usize, 1u8, val as u64)
4863 }
4864 }
4865 #[inline]
4866 pub fn mOtherConfigFlag(&self) -> bool {
4867 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
4868 }
4869 #[inline]
4870 pub fn set_mOtherConfigFlag(&mut self, val: bool) {
4871 unsafe {
4872 let val: u8 = ::std::mem::transmute(val);
4873 self._bitfield_1.set(1usize, 1u8, val as u64)
4874 }
4875 }
4876 #[inline]
4877 pub fn mSnacRouterFlag(&self) -> bool {
4878 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
4879 }
4880 #[inline]
4881 pub fn set_mSnacRouterFlag(&mut self, val: bool) {
4882 unsafe {
4883 let val: u8 = ::std::mem::transmute(val);
4884 self._bitfield_1.set(2usize, 1u8, val as u64)
4885 }
4886 }
4887 #[inline]
4888 pub fn mIsLocalDevice(&self) -> bool {
4889 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
4890 }
4891 #[inline]
4892 pub fn set_mIsLocalDevice(&mut self, val: bool) {
4893 unsafe {
4894 let val: u8 = ::std::mem::transmute(val);
4895 self._bitfield_1.set(3usize, 1u8, val as u64)
4896 }
4897 }
4898 #[inline]
4899 pub fn mIsReachable(&self) -> bool {
4900 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
4901 }
4902 #[inline]
4903 pub fn set_mIsReachable(&mut self, val: bool) {
4904 unsafe {
4905 let val: u8 = ::std::mem::transmute(val);
4906 self._bitfield_1.set(4usize, 1u8, val as u64)
4907 }
4908 }
4909 #[inline]
4910 pub fn mIsPeerBr(&self) -> bool {
4911 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
4912 }
4913 #[inline]
4914 pub fn set_mIsPeerBr(&mut self, val: bool) {
4915 unsafe {
4916 let val: u8 = ::std::mem::transmute(val);
4917 self._bitfield_1.set(5usize, 1u8, val as u64)
4918 }
4919 }
4920 #[inline]
4921 pub fn new_bitfield_1(
4922 mManagedAddressConfigFlag: bool,
4923 mOtherConfigFlag: bool,
4924 mSnacRouterFlag: bool,
4925 mIsLocalDevice: bool,
4926 mIsReachable: bool,
4927 mIsPeerBr: bool,
4928 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
4929 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
4930 __bindgen_bitfield_unit.set(0usize, 1u8, {
4931 let mManagedAddressConfigFlag: u8 =
4932 unsafe { ::std::mem::transmute(mManagedAddressConfigFlag) };
4933 mManagedAddressConfigFlag as u64
4934 });
4935 __bindgen_bitfield_unit.set(1usize, 1u8, {
4936 let mOtherConfigFlag: u8 = unsafe { ::std::mem::transmute(mOtherConfigFlag) };
4937 mOtherConfigFlag as u64
4938 });
4939 __bindgen_bitfield_unit.set(2usize, 1u8, {
4940 let mSnacRouterFlag: u8 = unsafe { ::std::mem::transmute(mSnacRouterFlag) };
4941 mSnacRouterFlag as u64
4942 });
4943 __bindgen_bitfield_unit.set(3usize, 1u8, {
4944 let mIsLocalDevice: u8 = unsafe { ::std::mem::transmute(mIsLocalDevice) };
4945 mIsLocalDevice as u64
4946 });
4947 __bindgen_bitfield_unit.set(4usize, 1u8, {
4948 let mIsReachable: u8 = unsafe { ::std::mem::transmute(mIsReachable) };
4949 mIsReachable as u64
4950 });
4951 __bindgen_bitfield_unit.set(5usize, 1u8, {
4952 let mIsPeerBr: u8 = unsafe { ::std::mem::transmute(mIsPeerBr) };
4953 mIsPeerBr as u64
4954 });
4955 __bindgen_bitfield_unit
4956 }
4957}
4958#[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."]
4959#[repr(C)]
4960#[derive(Copy, Clone)]
4961pub struct otBorderRoutingPrefixTableEntry {
4962 #[doc = "< Information about the router advertising this prefix."]
4963 pub mRouter: otBorderRoutingRouterEntry,
4964 #[doc = "< The discovered IPv6 prefix."]
4965 pub mPrefix: otIp6Prefix,
4966 #[doc = "< Indicates whether the prefix is on-link or route prefix."]
4967 pub mIsOnLink: bool,
4968 #[doc = "< Milliseconds since last update of this prefix."]
4969 pub mMsecSinceLastUpdate: u32,
4970 #[doc = "< Valid lifetime of the prefix (in seconds)."]
4971 pub mValidLifetime: u32,
4972 #[doc = "< Route preference when `mIsOnlink` is false."]
4973 pub mRoutePreference: otRoutePreference,
4974 #[doc = "< Preferred lifetime of the on-link prefix when `mIsOnLink`."]
4975 pub mPreferredLifetime: u32,
4976}
4977impl Default for otBorderRoutingPrefixTableEntry {
4978 fn default() -> Self {
4979 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
4980 unsafe {
4981 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
4982 s.assume_init()
4983 }
4984 }
4985}
4986#[doc = " Represents a discovered Recursive DNS Server (RDNSS) address entry.\n\n Address entries are discovered by processing the RDNSS options within received Router Advertisement messages from\n routers on infrastructure link."]
4987#[repr(C)]
4988#[derive(Copy, Clone)]
4989pub struct otBorderRoutingRdnssAddrEntry {
4990 #[doc = "< Information about the router advertising this address."]
4991 pub mRouter: otBorderRoutingRouterEntry,
4992 #[doc = "< The DNS Server IPv6 address."]
4993 pub mAddress: otIp6Address,
4994 #[doc = "< Milliseconds since last update of this address."]
4995 pub mMsecSinceLastUpdate: u32,
4996 #[doc = "< Lifetime of the address (in seconds)."]
4997 pub mLifetime: u32,
4998}
4999impl Default for otBorderRoutingRdnssAddrEntry {
5000 fn default() -> Self {
5001 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5002 unsafe {
5003 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5004 s.assume_init()
5005 }
5006 }
5007}
5008#[doc = " Represents information about a peer Border Router found in the Network Data."]
5009#[repr(C)]
5010#[derive(Debug, Default, Copy, Clone)]
5011pub struct otBorderRoutingPeerBorderRouterEntry {
5012 #[doc = "< The RLOC16 of BR."]
5013 pub mRloc16: u16,
5014 #[doc = "< Seconds since the BR appeared in the Network Data."]
5015 pub mAge: u32,
5016}
5017#[doc = " Represents a group of data of platform-generated RA messages processed."]
5018#[repr(C)]
5019#[derive(Debug, Default, Copy, Clone)]
5020pub struct otPdProcessedRaInfo {
5021 #[doc = "< The number of platform generated RA handled by ProcessPlatformGeneratedRa."]
5022 pub mNumPlatformRaReceived: u32,
5023 #[doc = "< The number of PIO processed for adding OMR prefixes."]
5024 pub mNumPlatformPioProcessed: u32,
5025 #[doc = "< The timestamp of last processed RA message."]
5026 pub mLastPlatformRaMsec: u32,
5027}
5028#[doc = "< BR auto-generates the local OMR prefix."]
5029pub const OT_BORDER_ROUTING_OMR_CONFIG_AUTO: otBorderRoutingOmrConfig = 0;
5030#[doc = "< BR uses a given custom OMR prefix."]
5031pub const OT_BORDER_ROUTING_OMR_CONFIG_CUSTOM: otBorderRoutingOmrConfig = 1;
5032#[doc = "< BR does not add local/PD OMR prefix in Network Data."]
5033pub const OT_BORDER_ROUTING_OMR_CONFIG_DISABLED: otBorderRoutingOmrConfig = 2;
5034#[doc = " Represents the configuration options related to the OMR prefix.\n\n This is used in `otBorderRoutingSetOmrConfig()` to offer manual administration options to explicitly configure\n the OMR prefix or to disable it."]
5035pub type otBorderRoutingOmrConfig = ::std::os::raw::c_uint;
5036#[doc = "< Routing Manager is uninitialized."]
5037pub const OT_BORDER_ROUTING_STATE_UNINITIALIZED: otBorderRoutingState = 0;
5038#[doc = "< Routing Manager is initialized but disabled."]
5039pub const OT_BORDER_ROUTING_STATE_DISABLED: otBorderRoutingState = 1;
5040#[doc = "< Routing Manager in initialized and enabled but currently stopped."]
5041pub const OT_BORDER_ROUTING_STATE_STOPPED: otBorderRoutingState = 2;
5042#[doc = "< Routing Manager is initialized, enabled, and running."]
5043pub const OT_BORDER_ROUTING_STATE_RUNNING: otBorderRoutingState = 3;
5044#[doc = " Represents the state of Border Routing Manager."]
5045pub type otBorderRoutingState = ::std::os::raw::c_uint;
5046#[doc = "< DHCPv6 PD is disabled on the border router."]
5047pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_DISABLED: otBorderRoutingDhcp6PdState = 0;
5048#[doc = "< DHCPv6 PD in enabled but won't try to request and publish a prefix."]
5049pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_STOPPED: otBorderRoutingDhcp6PdState = 1;
5050#[doc = "< DHCPv6 PD is enabled and will try to request and publish a prefix."]
5051pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_RUNNING: otBorderRoutingDhcp6PdState = 2;
5052#[doc = "< DHCPv6 PD is idle; Higher-prf prefix published by other BRs."]
5053pub const OT_BORDER_ROUTING_DHCP6_PD_STATE_IDLE: otBorderRoutingDhcp6PdState = 3;
5054#[doc = " This enumeration represents the state of DHCPv6 Prefix Delegation State."]
5055pub type otBorderRoutingDhcp6PdState = ::std::os::raw::c_uint;
5056extern "C" {
5057 #[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."]
5058 pub fn otBorderRoutingInit(
5059 aInstance: *mut otInstance,
5060 aInfraIfIndex: u32,
5061 aInfraIfIsRunning: bool,
5062 ) -> otError;
5063}
5064extern "C" {
5065 #[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."]
5066 pub fn otBorderRoutingSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
5067}
5068extern "C" {
5069 #[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."]
5070 pub fn otBorderRoutingGetState(aInstance: *mut otInstance) -> otBorderRoutingState;
5071}
5072extern "C" {
5073 #[doc = " Configures the OMR prefix handling in the Border Routing Manager.\n\n This function offers manual administration options to explicitly configure the OMR prefix or to disable it.\n\n By default, `OT_BORDER_ROUTING_OMR_CONFIG_AUTO` is used. In this mode, the Border Routing Manager automatically\n selects and manages the OMR prefix. This can involve auto-generating a local prefix or utilizing a prefix obtained\n through DHCPv6 PD (Prefix Delegation), if the feature is enabled.\n\n The `OT_BORDER_ROUTING_OMR_CONFIG_CUSTOM` option enables the use of a user-specified OMR prefix. When this option\n is selected, the @p aOmrPrefix and @p aPreference parameters are used to define the custom OMR prefix and its\n associated preference. These parameters are ignored for other configuration modes, and @p aOmrPrefix can be `NULL`.\n\n The `OT_BORDER_ROUTING_OMR_CONFIG_DISABLED` option disables the Border Routing Manager's management of the OMR\n prefix. The Routing Manager module itself will not add any local or DHCPv6 PD OMR prefixes to the Network Data.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aConfig The desired OMR configuration.\n @param[in] aOmrPrefix A pointer to the custom OMR prefix. Required only when @p aConfig is\n `OT_BORDER_ROUTING_OMR_CONFIG_CUSTOM`. Otherwise, it can be `NULL`.\n @param[in] aPreference The preference associated with the custom OMR prefix.\n\n @retval OT_ERROR_NONE The OMR configuration was successfully set to @p aConfig.\n @retval OT_ERROR_INVALID_ARGS The provided custom OMR prefix (@p aOmrPrefix) is invalid."]
5074 pub fn otBorderRoutingSetOmrConfig(
5075 aInstance: *mut otInstance,
5076 aConfig: otBorderRoutingOmrConfig,
5077 aOmrPrefix: *const otIp6Prefix,
5078 aPreference: otRoutePreference,
5079 ) -> otError;
5080}
5081extern "C" {
5082 #[doc = " Gets the current OMR prefix configuration mode.\n\n This function retrieves the current OMR configuration and, if a custom OMR prefix is configured, the custom prefix\n and its associated preference.\n\n If the caller does not require the custom OMR prefix and preference, the @p aOmrPrefix and @p aPreference parameters\n can be set to `NULL`.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[out] aOmrPrefix A pointer to an `otIp6Prefix` to return the custom OMR prefix, if the configuration is\n `OT_BORDER_ROUTING_OMR_CONFIG_CUSTOM`.\n @param[out] aPreference A pointer to return the preference associated with the custom OMR prefix.\n\n @return The current OMR prefix configuration mode."]
5083 pub fn otBorderRoutingGetOmrConfig(
5084 aInstance: *mut otInstance,
5085 aOmrPrefix: *mut otIp6Prefix,
5086 aPreference: *mut otRoutePreference,
5087 ) -> otBorderRoutingOmrConfig;
5088}
5089extern "C" {
5090 #[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."]
5091 pub fn otBorderRoutingGetRouteInfoOptionPreference(
5092 aInstance: *mut otInstance,
5093 ) -> otRoutePreference;
5094}
5095extern "C" {
5096 #[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."]
5097 pub fn otBorderRoutingSetRouteInfoOptionPreference(
5098 aInstance: *mut otInstance,
5099 aPreference: otRoutePreference,
5100 );
5101}
5102extern "C" {
5103 #[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."]
5104 pub fn otBorderRoutingClearRouteInfoOptionPreference(aInstance: *mut otInstance);
5105}
5106extern "C" {
5107 #[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."]
5108 pub fn otBorderRoutingSetExtraRouterAdvertOptions(
5109 aInstance: *mut otInstance,
5110 aOptions: *const u8,
5111 aLength: u16,
5112 ) -> otError;
5113}
5114extern "C" {
5115 #[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."]
5116 pub fn otBorderRoutingGetRoutePreference(aInstance: *mut otInstance) -> otRoutePreference;
5117}
5118extern "C" {
5119 #[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."]
5120 pub fn otBorderRoutingSetRoutePreference(
5121 aInstance: *mut otInstance,
5122 aPreference: otRoutePreference,
5123 );
5124}
5125extern "C" {
5126 #[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."]
5127 pub fn otBorderRoutingClearRoutePreference(aInstance: *mut otInstance);
5128}
5129extern "C" {
5130 #[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"]
5131 pub fn otBorderRoutingGetOmrPrefix(
5132 aInstance: *mut otInstance,
5133 aPrefix: *mut otIp6Prefix,
5134 ) -> otError;
5135}
5136extern "C" {
5137 #[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"]
5138 pub fn otBorderRoutingGetPdOmrPrefix(
5139 aInstance: *mut otInstance,
5140 aPrefixInfo: *mut otBorderRoutingPrefixTableEntry,
5141 ) -> otError;
5142}
5143extern "C" {
5144 #[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."]
5145 pub fn otBorderRoutingGetPdProcessedRaInfo(
5146 aInstance: *mut otInstance,
5147 aPdProcessedRaInfo: *mut otPdProcessedRaInfo,
5148 ) -> otError;
5149}
5150extern "C" {
5151 #[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."]
5152 pub fn otBorderRoutingGetFavoredOmrPrefix(
5153 aInstance: *mut otInstance,
5154 aPrefix: *mut otIp6Prefix,
5155 aPreference: *mut otRoutePreference,
5156 ) -> otError;
5157}
5158extern "C" {
5159 #[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."]
5160 pub fn otBorderRoutingGetOnLinkPrefix(
5161 aInstance: *mut otInstance,
5162 aPrefix: *mut otIp6Prefix,
5163 ) -> otError;
5164}
5165extern "C" {
5166 #[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."]
5167 pub fn otBorderRoutingGetFavoredOnLinkPrefix(
5168 aInstance: *mut otInstance,
5169 aPrefix: *mut otIp6Prefix,
5170 ) -> otError;
5171}
5172extern "C" {
5173 #[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."]
5174 pub fn otBorderRoutingGetNat64Prefix(
5175 aInstance: *mut otInstance,
5176 aPrefix: *mut otIp6Prefix,
5177 ) -> otError;
5178}
5179extern "C" {
5180 #[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."]
5181 pub fn otBorderRoutingGetFavoredNat64Prefix(
5182 aInstance: *mut otInstance,
5183 aPrefix: *mut otIp6Prefix,
5184 aPreference: *mut otRoutePreference,
5185 ) -> otError;
5186}
5187extern "C" {
5188 #[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."]
5189 pub fn otBorderRoutingPrefixTableInitIterator(
5190 aInstance: *mut otInstance,
5191 aIterator: *mut otBorderRoutingPrefixTableIterator,
5192 );
5193}
5194extern "C" {
5195 #[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."]
5196 pub fn otBorderRoutingGetNextPrefixTableEntry(
5197 aInstance: *mut otInstance,
5198 aIterator: *mut otBorderRoutingPrefixTableIterator,
5199 aEntry: *mut otBorderRoutingPrefixTableEntry,
5200 ) -> otError;
5201}
5202extern "C" {
5203 #[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."]
5204 pub fn otBorderRoutingGetNextRouterEntry(
5205 aInstance: *mut otInstance,
5206 aIterator: *mut otBorderRoutingPrefixTableIterator,
5207 aEntry: *mut otBorderRoutingRouterEntry,
5208 ) -> otError;
5209}
5210extern "C" {
5211 #[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."]
5212 pub fn otBorderRoutingGetNextPeerBrEntry(
5213 aInstance: *mut otInstance,
5214 aIterator: *mut otBorderRoutingPrefixTableIterator,
5215 aEntry: *mut otBorderRoutingPeerBorderRouterEntry,
5216 ) -> otError;
5217}
5218extern "C" {
5219 #[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."]
5220 pub fn otBorderRoutingCountPeerBrs(aInstance: *mut otInstance, aMinAge: *mut u32) -> u16;
5221}
5222#[doc = " A callback function pointer called when the multi-AIL detection state changes.\n\n This callback function is invoked by the OpenThread stack whenever the Routing Manager determines a change in\n whether Border Routers on the Thread mesh might be connected to different Adjacent Infrastructure Links (AILs).\n\n See `otBorderRoutingIsMultiAilDetected()` for more details.\n\n @param[in] aDetected `TRUE` if multiple AILs are now detected, `FALSE` otherwise.\n @param[in] aContext A pointer to arbitrary context information provided when the callback was registered\n using `otBorderRoutingSetMultiAilCallback()`."]
5223pub type otBorderRoutingMultiAilCallback = ::std::option::Option<
5224 unsafe extern "C" fn(aDetected: bool, aContext: *mut ::std::os::raw::c_void),
5225>;
5226extern "C" {
5227 #[doc = " Gets the current detected state regarding multiple Adjacent Infrastructure Links (AILs).\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_MULTI_AIL_DETECTION_ENABLE`.\n\n It returns whether the Routing Manager currently believes that Border Routers (BRs) on the Thread mesh may be\n connected to different AILs.\n\n The detection mechanism operates as follows: The Routing Manager monitors the number of peer BRs listed in the\n Thread Network Data (see `otBorderRoutingCountPeerBrs()`) and compares this count with the number of peer BRs\n discovered by processing received Router Advertisement (RA) messages on its connected AIL. If the count derived from\n Network Data consistently exceeds the count derived from RAs for a detection duration of 10 minutes, it concludes\n that BRs are likely connected to different AILs. To clear state a shorter window of 1 minute is used.\n\n The detection window of 10 minutes helps to avoid false positives due to transient changes. The Routing Manager uses\n 200 seconds for reachability checks of peer BRs (sending Neighbor Solicitation). Stale Network Data entries are\n also expected to age out within a few minutes. So a 10-minute detection time accommodates both cases.\n\n While generally effective, this detection mechanism may get less reliable in scenarios with a large number of\n BRs, particularly exceeding ten. This is related to the \"Network Data Publisher\" mechanism, where BRs might refrain\n from publishing their external route information in the Network Data to conserve its limited size, potentially\n skewing the Network Data BR count.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n\n @retval TRUE Has detected that BRs are likely connected to multiple AILs.\n @retval FALSE Has not detected (or no longer detects) that BRs are connected to multiple AILs."]
5228 pub fn otBorderRoutingIsMultiAilDetected(aInstance: *mut otInstance) -> bool;
5229}
5230extern "C" {
5231 #[doc = " Sets a callback function to be notified of changes in the multi-AIL detection state.\n\n Requires `OPENTHREAD_CONFIG_BORDER_ROUTING_MULTI_AIL_DETECTION_ENABLE`.\n\n Subsequent calls to this function will overwrite the previous callback setting. Using `NULL` for @p aCallback will\n disable the callback.\n\n @param[in] aInstance A pointer to the OpenThread instance.\n @param[in] aCallback A pointer to the function (`otBorderRoutingMultiAilCallback`) to be called\n upon state changes, or `NULL` to unregister a previously set callback.\n @param[in] aContext A pointer to application-specific context that will be passed back\n in the `aCallback` function. This can be `NULL` if no context is needed."]
5232 pub fn otBorderRoutingSetMultiAilCallback(
5233 aInstance: *mut otInstance,
5234 aCallback: otBorderRoutingMultiAilCallback,
5235 aContext: *mut ::std::os::raw::c_void,
5236 );
5237}
5238extern "C" {
5239 #[doc = " Iterates over the Recursive DNS Server (RDNSS) address entries.\n\n Address entries are discovered by processing the RDNSS options within received Router Advertisement messages from\n routers on infrastructure link.\n\n Address 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 address entry, @p aEntry and @p aIterator are updated.\n @retval OT_ERROR_NOT_FOUND No more entries in the table.\n @retval OT_ERROR_INVALID_ARSG The iterator is invalid (used to iterate over other entry types, e.g. prefix)."]
5240 pub fn otBorderRoutingGetNextRdnssAddrEntry(
5241 aInstance: *mut otInstance,
5242 aIterator: *mut otBorderRoutingPrefixTableIterator,
5243 aEntry: *mut otBorderRoutingRdnssAddrEntry,
5244 ) -> otError;
5245}
5246#[doc = " Callback function pointer to notify of changes to discovered Recursive DNS Server (RDNSS) address entries.\n\n Address entries are discovered by processing the RDNSS options within received Router Advertisement messages from\n routers on infrastructure link.\n\n The `otBorderRoutingGetNextRdnssAddrEntry()` function can be used to iterate over the discovered RDNSS address\n entries.\n\n This callback is invoked when any of the following changes occur to the address entries associated with a discovered\n router:\n - A new RDNSS address is advertised by the router.\n - A previously discovered address is removed due to the router advertising it with a zero lifetime.\n - A previously discovered address has aged out (its lifetime expired without being re-advertised).\n - We determine that the router that advertised the address is now unreachable, and therefore all its associated\n entries are removed.\n\n @param[in] aContext A pointer to arbitrary context information."]
5247pub type otBorderRoutingRdnssAddrCallback =
5248 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
5249extern "C" {
5250 #[doc = " Sets the callback to be notified of changes to discovered Recursive DNS Server (RDNSS) address entries.\n\n A subsequent call to this function, replaces a previously set callback.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aCallback The callback function pointer. Can be `NULL` if no callback is required.\n @param[in] aConext An arbitrary context information (used when invoking the callback).\n"]
5251 pub fn otBorderRoutingSetRdnssAddrCallback(
5252 aInstance: *mut otInstance,
5253 aCallback: otBorderRoutingRdnssAddrCallback,
5254 aContext: *mut ::std::os::raw::c_void,
5255 );
5256}
5257extern "C" {
5258 #[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."]
5259 pub fn otBorderRoutingDhcp6PdSetEnabled(aInstance: *mut otInstance, aEnabled: bool);
5260}
5261extern "C" {
5262 #[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."]
5263 pub fn otBorderRoutingDhcp6PdGetState(
5264 aInstance: *mut otInstance,
5265 ) -> otBorderRoutingDhcp6PdState;
5266}
5267#[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."]
5268pub type otBorderRoutingRequestDhcp6PdCallback = ::std::option::Option<
5269 unsafe extern "C" fn(
5270 aState: otBorderRoutingDhcp6PdState,
5271 aContext: *mut ::std::os::raw::c_void,
5272 ),
5273>;
5274extern "C" {
5275 #[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."]
5276 pub fn otBorderRoutingDhcp6PdSetRequestCallback(
5277 aInstance: *mut otInstance,
5278 aCallback: otBorderRoutingRequestDhcp6PdCallback,
5279 aContext: *mut ::std::os::raw::c_void,
5280 );
5281}
5282extern "C" {
5283 #[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."]
5284 pub fn otBorderRoutingSetOnLinkPrefix(aInstance: *mut otInstance, aPrefix: *const otIp6Prefix);
5285}
5286extern "C" {
5287 #[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."]
5288 pub fn otBorderRouterGetNetData(
5289 aInstance: *mut otInstance,
5290 aStable: bool,
5291 aData: *mut u8,
5292 aDataLength: *mut u8,
5293 ) -> otError;
5294}
5295extern "C" {
5296 #[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"]
5297 pub fn otBorderRouterAddOnMeshPrefix(
5298 aInstance: *mut otInstance,
5299 aConfig: *const otBorderRouterConfig,
5300 ) -> otError;
5301}
5302extern "C" {
5303 #[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"]
5304 pub fn otBorderRouterRemoveOnMeshPrefix(
5305 aInstance: *mut otInstance,
5306 aPrefix: *const otIp6Prefix,
5307 ) -> otError;
5308}
5309extern "C" {
5310 #[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."]
5311 pub fn otBorderRouterGetNextOnMeshPrefix(
5312 aInstance: *mut otInstance,
5313 aIterator: *mut otNetworkDataIterator,
5314 aConfig: *mut otBorderRouterConfig,
5315 ) -> otError;
5316}
5317extern "C" {
5318 #[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"]
5319 pub fn otBorderRouterAddRoute(
5320 aInstance: *mut otInstance,
5321 aConfig: *const otExternalRouteConfig,
5322 ) -> otError;
5323}
5324extern "C" {
5325 #[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"]
5326 pub fn otBorderRouterRemoveRoute(
5327 aInstance: *mut otInstance,
5328 aPrefix: *const otIp6Prefix,
5329 ) -> otError;
5330}
5331extern "C" {
5332 #[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."]
5333 pub fn otBorderRouterGetNextRoute(
5334 aInstance: *mut otInstance,
5335 aIterator: *mut otNetworkDataIterator,
5336 aConfig: *mut otExternalRouteConfig,
5337 ) -> otError;
5338}
5339extern "C" {
5340 #[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"]
5341 pub fn otBorderRouterRegister(aInstance: *mut otInstance) -> otError;
5342}
5343#[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."]
5344pub type otBorderRouterNetDataFullCallback =
5345 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
5346extern "C" {
5347 #[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."]
5348 pub fn otBorderRouterSetNetDataFullCallback(
5349 aInstance: *mut otInstance,
5350 aCallback: otBorderRouterNetDataFullCallback,
5351 aContext: *mut ::std::os::raw::c_void,
5352 );
5353}
5354extern "C" {
5355 #[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."]
5356 pub fn otChannelManagerRequestChannelChange(aInstance: *mut otInstance, aChannel: u8);
5357}
5358extern "C" {
5359 #[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."]
5360 pub fn otChannelManagerGetRequestedChannel(aInstance: *mut otInstance) -> u8;
5361}
5362extern "C" {
5363 #[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."]
5364 pub fn otChannelManagerGetDelay(aInstance: *mut otInstance) -> u16;
5365}
5366extern "C" {
5367 #[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."]
5368 pub fn otChannelManagerSetDelay(aInstance: *mut otInstance, aDelay: u16) -> otError;
5369}
5370extern "C" {
5371 #[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."]
5372 pub fn otChannelManagerRequestChannelSelect(
5373 aInstance: *mut otInstance,
5374 aSkipQualityCheck: bool,
5375 ) -> otError;
5376}
5377extern "C" {
5378 #[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."]
5379 pub fn otChannelManagerRequestCslChannelSelect(
5380 aInstance: *mut otInstance,
5381 aSkipQualityCheck: bool,
5382 ) -> otError;
5383}
5384extern "C" {
5385 #[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."]
5386 pub fn otChannelManagerSetAutoChannelSelectionEnabled(
5387 aInstance: *mut otInstance,
5388 aEnabled: bool,
5389 );
5390}
5391extern "C" {
5392 #[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."]
5393 pub fn otChannelManagerGetAutoChannelSelectionEnabled(aInstance: *mut otInstance) -> bool;
5394}
5395extern "C" {
5396 #[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."]
5397 pub fn otChannelManagerSetAutoCslChannelSelectionEnabled(
5398 aInstance: *mut otInstance,
5399 aEnabled: bool,
5400 );
5401}
5402extern "C" {
5403 #[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."]
5404 pub fn otChannelManagerGetAutoCslChannelSelectionEnabled(aInstance: *mut otInstance) -> bool;
5405}
5406extern "C" {
5407 #[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)."]
5408 pub fn otChannelManagerSetAutoChannelSelectionInterval(
5409 aInstance: *mut otInstance,
5410 aInterval: u32,
5411 ) -> otError;
5412}
5413extern "C" {
5414 #[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."]
5415 pub fn otChannelManagerGetAutoChannelSelectionInterval(aInstance: *mut otInstance) -> u32;
5416}
5417extern "C" {
5418 #[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."]
5419 pub fn otChannelManagerGetSupportedChannels(aInstance: *mut otInstance) -> u32;
5420}
5421extern "C" {
5422 #[doc = " Sets the supported channel mask.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask A channel mask."]
5423 pub fn otChannelManagerSetSupportedChannels(aInstance: *mut otInstance, aChannelMask: u32);
5424}
5425extern "C" {
5426 #[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."]
5427 pub fn otChannelManagerGetFavoredChannels(aInstance: *mut otInstance) -> u32;
5428}
5429extern "C" {
5430 #[doc = " Sets the favored channel mask.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask A channel mask."]
5431 pub fn otChannelManagerSetFavoredChannels(aInstance: *mut otInstance, aChannelMask: u32);
5432}
5433extern "C" {
5434 #[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%."]
5435 pub fn otChannelManagerGetCcaFailureRateThreshold(aInstance: *mut otInstance) -> u16;
5436}
5437extern "C" {
5438 #[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%."]
5439 pub fn otChannelManagerSetCcaFailureRateThreshold(aInstance: *mut otInstance, aThreshold: u16);
5440}
5441extern "C" {
5442 #[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."]
5443 pub fn otChannelMonitorSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
5444}
5445extern "C" {
5446 #[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."]
5447 pub fn otChannelMonitorIsEnabled(aInstance: *mut otInstance) -> bool;
5448}
5449extern "C" {
5450 #[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."]
5451 pub fn otChannelMonitorGetSampleInterval(aInstance: *mut otInstance) -> u32;
5452}
5453extern "C" {
5454 #[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."]
5455 pub fn otChannelMonitorGetRssiThreshold(aInstance: *mut otInstance) -> i8;
5456}
5457extern "C" {
5458 #[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."]
5459 pub fn otChannelMonitorGetSampleWindow(aInstance: *mut otInstance) -> u32;
5460}
5461extern "C" {
5462 #[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."]
5463 pub fn otChannelMonitorGetSampleCount(aInstance: *mut otInstance) -> u32;
5464}
5465extern "C" {
5466 #[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."]
5467 pub fn otChannelMonitorGetChannelOccupancy(aInstance: *mut otInstance, aChannel: u8) -> u16;
5468}
5469extern "C" {
5470 #[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."]
5471 pub fn otChildSupervisionGetInterval(aInstance: *mut otInstance) -> u16;
5472}
5473extern "C" {
5474 #[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."]
5475 pub fn otChildSupervisionSetInterval(aInstance: *mut otInstance, aInterval: u16);
5476}
5477extern "C" {
5478 #[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."]
5479 pub fn otChildSupervisionGetCheckTimeout(aInstance: *mut otInstance) -> u16;
5480}
5481extern "C" {
5482 #[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."]
5483 pub fn otChildSupervisionSetCheckTimeout(aInstance: *mut otInstance, aTimeout: u16);
5484}
5485extern "C" {
5486 #[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."]
5487 pub fn otChildSupervisionGetCheckFailureCounter(aInstance: *mut otInstance) -> u16;
5488}
5489extern "C" {
5490 #[doc = " Reset the supervision check timeout failure counter to zero."]
5491 pub fn otChildSupervisionResetCheckFailureCounter(aInstance: *mut otInstance);
5492}
5493#[doc = " Represents a CLI command."]
5494#[repr(C)]
5495#[derive(Debug, Copy, Clone)]
5496pub struct otCliCommand {
5497 #[doc = "< A pointer to the command string."]
5498 pub mName: *const ::std::os::raw::c_char,
5499 pub mCommand: ::std::option::Option<
5500 unsafe extern "C" fn(
5501 aContext: *mut ::std::os::raw::c_void,
5502 aArgsLength: u8,
5503 aArgs: *mut *mut ::std::os::raw::c_char,
5504 ) -> otError,
5505 >,
5506}
5507impl Default for otCliCommand {
5508 fn default() -> Self {
5509 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5510 unsafe {
5511 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5512 s.assume_init()
5513 }
5514 }
5515}
5516#[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."]
5517pub type otCliOutputCallback = ::std::option::Option<
5518 unsafe extern "C" fn(
5519 aContext: *mut ::std::os::raw::c_void,
5520 aFormat: *const ::std::os::raw::c_char,
5521 aArguments: *mut __va_list_tag,
5522 ) -> ::std::os::raw::c_int,
5523>;
5524extern "C" {
5525 #[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."]
5526 pub fn otCliInit(
5527 aInstance: *mut otInstance,
5528 aCallback: otCliOutputCallback,
5529 aContext: *mut ::std::os::raw::c_void,
5530 );
5531}
5532extern "C" {
5533 #[doc = " Is called to feed in a console input line.\n\n @param[in] aBuf A pointer to a null-terminated string."]
5534 pub fn otCliInputLine(aBuf: *mut ::std::os::raw::c_char);
5535}
5536extern "C" {
5537 #[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."]
5538 pub fn otCliSetUserCommands(
5539 aUserCommands: *const otCliCommand,
5540 aLength: u8,
5541 aContext: *mut ::std::os::raw::c_void,
5542 ) -> otError;
5543}
5544extern "C" {
5545 #[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."]
5546 pub fn otCliOutputBytes(aBytes: *const u8, aLength: u8);
5547}
5548extern "C" {
5549 #[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."]
5550 pub fn otCliOutputFormat(aFmt: *const ::std::os::raw::c_char, ...);
5551}
5552extern "C" {
5553 #[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."]
5554 pub fn otCliAppendResult(aError: otError);
5555}
5556extern "C" {
5557 #[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."]
5558 pub fn otCliPlatLogv(
5559 aLogLevel: otLogLevel,
5560 aLogRegion: otLogRegion,
5561 aFormat: *const ::std::os::raw::c_char,
5562 aArgs: *mut __va_list_tag,
5563 );
5564}
5565extern "C" {
5566 #[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."]
5567 pub fn otCliVendorSetUserCommands();
5568}
5569#[doc = "< Confirmable"]
5570pub const OT_COAP_TYPE_CONFIRMABLE: otCoapType = 0;
5571#[doc = "< Non-confirmable"]
5572pub const OT_COAP_TYPE_NON_CONFIRMABLE: otCoapType = 1;
5573#[doc = "< Acknowledgment"]
5574pub const OT_COAP_TYPE_ACKNOWLEDGMENT: otCoapType = 2;
5575#[doc = "< Reset"]
5576pub const OT_COAP_TYPE_RESET: otCoapType = 3;
5577#[doc = " CoAP Type values (2 bit unsigned integer)."]
5578pub type otCoapType = ::std::os::raw::c_uint;
5579#[doc = "< Empty message code"]
5580pub const OT_COAP_CODE_EMPTY: otCoapCode = 0;
5581#[doc = "< Get"]
5582pub const OT_COAP_CODE_GET: otCoapCode = 1;
5583#[doc = "< Post"]
5584pub const OT_COAP_CODE_POST: otCoapCode = 2;
5585#[doc = "< Put"]
5586pub const OT_COAP_CODE_PUT: otCoapCode = 3;
5587#[doc = "< Delete"]
5588pub const OT_COAP_CODE_DELETE: otCoapCode = 4;
5589#[doc = "< 2.00"]
5590pub const OT_COAP_CODE_RESPONSE_MIN: otCoapCode = 64;
5591#[doc = "< Created"]
5592pub const OT_COAP_CODE_CREATED: otCoapCode = 65;
5593#[doc = "< Deleted"]
5594pub const OT_COAP_CODE_DELETED: otCoapCode = 66;
5595#[doc = "< Valid"]
5596pub const OT_COAP_CODE_VALID: otCoapCode = 67;
5597#[doc = "< Changed"]
5598pub const OT_COAP_CODE_CHANGED: otCoapCode = 68;
5599#[doc = "< Content"]
5600pub const OT_COAP_CODE_CONTENT: otCoapCode = 69;
5601#[doc = "< RFC7959 Continue"]
5602pub const OT_COAP_CODE_CONTINUE: otCoapCode = 95;
5603#[doc = "< Bad Request"]
5604pub const OT_COAP_CODE_BAD_REQUEST: otCoapCode = 128;
5605#[doc = "< Unauthorized"]
5606pub const OT_COAP_CODE_UNAUTHORIZED: otCoapCode = 129;
5607#[doc = "< Bad Option"]
5608pub const OT_COAP_CODE_BAD_OPTION: otCoapCode = 130;
5609#[doc = "< Forbidden"]
5610pub const OT_COAP_CODE_FORBIDDEN: otCoapCode = 131;
5611#[doc = "< Not Found"]
5612pub const OT_COAP_CODE_NOT_FOUND: otCoapCode = 132;
5613#[doc = "< Method Not Allowed"]
5614pub const OT_COAP_CODE_METHOD_NOT_ALLOWED: otCoapCode = 133;
5615#[doc = "< Not Acceptable"]
5616pub const OT_COAP_CODE_NOT_ACCEPTABLE: otCoapCode = 134;
5617#[doc = "< RFC7959 Request Entity Incomplete"]
5618pub const OT_COAP_CODE_REQUEST_INCOMPLETE: otCoapCode = 136;
5619#[doc = "< Precondition Failed"]
5620pub const OT_COAP_CODE_PRECONDITION_FAILED: otCoapCode = 140;
5621#[doc = "< Request Entity Too Large"]
5622pub const OT_COAP_CODE_REQUEST_TOO_LARGE: otCoapCode = 141;
5623#[doc = "< Unsupported Content-Format"]
5624pub const OT_COAP_CODE_UNSUPPORTED_FORMAT: otCoapCode = 143;
5625#[doc = "< Internal Server Error"]
5626pub const OT_COAP_CODE_INTERNAL_ERROR: otCoapCode = 160;
5627#[doc = "< Not Implemented"]
5628pub const OT_COAP_CODE_NOT_IMPLEMENTED: otCoapCode = 161;
5629#[doc = "< Bad Gateway"]
5630pub const OT_COAP_CODE_BAD_GATEWAY: otCoapCode = 162;
5631#[doc = "< Service Unavailable"]
5632pub const OT_COAP_CODE_SERVICE_UNAVAILABLE: otCoapCode = 163;
5633#[doc = "< Gateway Timeout"]
5634pub const OT_COAP_CODE_GATEWAY_TIMEOUT: otCoapCode = 164;
5635#[doc = "< Proxying Not Supported"]
5636pub const OT_COAP_CODE_PROXY_NOT_SUPPORTED: otCoapCode = 165;
5637#[doc = " CoAP Code values."]
5638pub type otCoapCode = ::std::os::raw::c_uint;
5639#[doc = "< If-Match"]
5640pub const OT_COAP_OPTION_IF_MATCH: otCoapOptionType = 1;
5641#[doc = "< Uri-Host"]
5642pub const OT_COAP_OPTION_URI_HOST: otCoapOptionType = 3;
5643#[doc = "< ETag"]
5644pub const OT_COAP_OPTION_E_TAG: otCoapOptionType = 4;
5645#[doc = "< If-None-Match"]
5646pub const OT_COAP_OPTION_IF_NONE_MATCH: otCoapOptionType = 5;
5647#[doc = "< Observe [RFC7641]"]
5648pub const OT_COAP_OPTION_OBSERVE: otCoapOptionType = 6;
5649#[doc = "< Uri-Port"]
5650pub const OT_COAP_OPTION_URI_PORT: otCoapOptionType = 7;
5651#[doc = "< Location-Path"]
5652pub const OT_COAP_OPTION_LOCATION_PATH: otCoapOptionType = 8;
5653#[doc = "< Uri-Path"]
5654pub const OT_COAP_OPTION_URI_PATH: otCoapOptionType = 11;
5655#[doc = "< Content-Format"]
5656pub const OT_COAP_OPTION_CONTENT_FORMAT: otCoapOptionType = 12;
5657#[doc = "< Max-Age"]
5658pub const OT_COAP_OPTION_MAX_AGE: otCoapOptionType = 14;
5659#[doc = "< Uri-Query"]
5660pub const OT_COAP_OPTION_URI_QUERY: otCoapOptionType = 15;
5661#[doc = "< Accept"]
5662pub const OT_COAP_OPTION_ACCEPT: otCoapOptionType = 17;
5663#[doc = "< Location-Query"]
5664pub const OT_COAP_OPTION_LOCATION_QUERY: otCoapOptionType = 20;
5665#[doc = "< Block2 (RFC7959)"]
5666pub const OT_COAP_OPTION_BLOCK2: otCoapOptionType = 23;
5667#[doc = "< Block1 (RFC7959)"]
5668pub const OT_COAP_OPTION_BLOCK1: otCoapOptionType = 27;
5669#[doc = "< Size2 (RFC7959)"]
5670pub const OT_COAP_OPTION_SIZE2: otCoapOptionType = 28;
5671#[doc = "< Proxy-Uri"]
5672pub const OT_COAP_OPTION_PROXY_URI: otCoapOptionType = 35;
5673#[doc = "< Proxy-Scheme"]
5674pub const OT_COAP_OPTION_PROXY_SCHEME: otCoapOptionType = 39;
5675#[doc = "< Size1"]
5676pub const OT_COAP_OPTION_SIZE1: otCoapOptionType = 60;
5677#[doc = " CoAP Option Numbers"]
5678pub type otCoapOptionType = ::std::os::raw::c_uint;
5679#[doc = " Represents a CoAP option."]
5680#[repr(C)]
5681#[derive(Debug, Default, Copy, Clone)]
5682pub struct otCoapOption {
5683 #[doc = "< Option Number"]
5684 pub mNumber: u16,
5685 #[doc = "< Option Length"]
5686 pub mLength: u16,
5687}
5688#[doc = " Acts as an iterator for CoAP options"]
5689#[repr(C)]
5690#[derive(Debug, Copy, Clone)]
5691pub struct otCoapOptionIterator {
5692 #[doc = "< CoAP message"]
5693 pub mMessage: *const otMessage,
5694 #[doc = "< CoAP message option"]
5695 pub mOption: otCoapOption,
5696 #[doc = "< Byte offset of next option"]
5697 pub mNextOptionOffset: u16,
5698}
5699impl Default for otCoapOptionIterator {
5700 fn default() -> Self {
5701 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5702 unsafe {
5703 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5704 s.assume_init()
5705 }
5706 }
5707}
5708#[doc = " text/plain; charset=utf-8: [RFC2046][RFC3676][RFC5147]"]
5709pub const OT_COAP_OPTION_CONTENT_FORMAT_TEXT_PLAIN: otCoapOptionContentFormat = 0;
5710#[doc = " application/cose; cose-type=\"cose-encrypt0\": [RFC8152]"]
5711pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_ENCRYPT0: otCoapOptionContentFormat = 16;
5712#[doc = " application/cose; cose-type=\"cose-mac0\": [RFC8152]"]
5713pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_MAC0: otCoapOptionContentFormat = 17;
5714#[doc = " application/cose; cose-type=\"cose-sign1\": [RFC8152]"]
5715pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_SIGN1: otCoapOptionContentFormat = 18;
5716#[doc = " application/link-format: [RFC6690]"]
5717pub const OT_COAP_OPTION_CONTENT_FORMAT_LINK_FORMAT: otCoapOptionContentFormat = 40;
5718#[doc = " application/xml: [RFC3023]"]
5719pub const OT_COAP_OPTION_CONTENT_FORMAT_XML: otCoapOptionContentFormat = 41;
5720#[doc = " application/octet-stream: [RFC2045][RFC2046]"]
5721pub const OT_COAP_OPTION_CONTENT_FORMAT_OCTET_STREAM: otCoapOptionContentFormat = 42;
5722#[doc = " application/exi:\n [\"Efficient XML Interchange (EXI) Format 1.0 (Second Edition)\", February 2014]"]
5723pub const OT_COAP_OPTION_CONTENT_FORMAT_EXI: otCoapOptionContentFormat = 47;
5724#[doc = " application/json: [RFC7159]"]
5725pub const OT_COAP_OPTION_CONTENT_FORMAT_JSON: otCoapOptionContentFormat = 50;
5726#[doc = " application/json-patch+json: [RFC6902]"]
5727pub const OT_COAP_OPTION_CONTENT_FORMAT_JSON_PATCH_JSON: otCoapOptionContentFormat = 51;
5728#[doc = " application/merge-patch+json: [RFC7396]"]
5729pub const OT_COAP_OPTION_CONTENT_FORMAT_MERGE_PATCH_JSON: otCoapOptionContentFormat = 52;
5730#[doc = " application/cbor: [RFC7049]"]
5731pub const OT_COAP_OPTION_CONTENT_FORMAT_CBOR: otCoapOptionContentFormat = 60;
5732#[doc = " application/cwt: [RFC8392]"]
5733pub const OT_COAP_OPTION_CONTENT_FORMAT_CWT: otCoapOptionContentFormat = 61;
5734#[doc = " application/cose; cose-type=\"cose-encrypt\": [RFC8152]"]
5735pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_ENCRYPT: otCoapOptionContentFormat = 96;
5736#[doc = " application/cose; cose-type=\"cose-mac\": [RFC8152]"]
5737pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_MAC: otCoapOptionContentFormat = 97;
5738#[doc = " application/cose; cose-type=\"cose-sign\": [RFC8152]"]
5739pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_SIGN: otCoapOptionContentFormat = 98;
5740#[doc = " application/cose-key: [RFC8152]"]
5741pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_KEY: otCoapOptionContentFormat = 101;
5742#[doc = " application/cose-key-set: [RFC8152]"]
5743pub const OT_COAP_OPTION_CONTENT_FORMAT_COSE_KEY_SET: otCoapOptionContentFormat = 102;
5744#[doc = " application/senml+json: [RFC8428]"]
5745pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_JSON: otCoapOptionContentFormat = 110;
5746#[doc = " application/sensml+json: [RFC8428]"]
5747pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_JSON: otCoapOptionContentFormat = 111;
5748#[doc = " application/senml+cbor: [RFC8428]"]
5749pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_CBOR: otCoapOptionContentFormat = 112;
5750#[doc = " application/sensml+cbor: [RFC8428]"]
5751pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_CBOR: otCoapOptionContentFormat = 113;
5752#[doc = " application/senml-exi: [RFC8428]"]
5753pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_EXI: otCoapOptionContentFormat = 114;
5754#[doc = " application/sensml-exi: [RFC8428]"]
5755pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_EXI: otCoapOptionContentFormat = 115;
5756#[doc = " application/coap-group+json: [RFC7390]"]
5757pub const OT_COAP_OPTION_CONTENT_FORMAT_COAP_GROUP_JSON: otCoapOptionContentFormat = 256;
5758#[doc = " application/senml+xml: [RFC8428]"]
5759pub const OT_COAP_OPTION_CONTENT_FORMAT_SENML_XML: otCoapOptionContentFormat = 310;
5760#[doc = " application/sensml+xml: [RFC8428]"]
5761pub const OT_COAP_OPTION_CONTENT_FORMAT_SENSML_XML: otCoapOptionContentFormat = 311;
5762#[doc = " CoAP Content Format codes. The full list is documented at\n https://www.iana.org/assignments/core-parameters/core-parameters.xhtml#content-formats"]
5763pub type otCoapOptionContentFormat = ::std::os::raw::c_uint;
5764pub const OT_COAP_OPTION_BLOCK_SZX_16: otCoapBlockSzx = 0;
5765pub const OT_COAP_OPTION_BLOCK_SZX_32: otCoapBlockSzx = 1;
5766pub const OT_COAP_OPTION_BLOCK_SZX_64: otCoapBlockSzx = 2;
5767pub const OT_COAP_OPTION_BLOCK_SZX_128: otCoapBlockSzx = 3;
5768pub const OT_COAP_OPTION_BLOCK_SZX_256: otCoapBlockSzx = 4;
5769pub const OT_COAP_OPTION_BLOCK_SZX_512: otCoapBlockSzx = 5;
5770pub const OT_COAP_OPTION_BLOCK_SZX_1024: otCoapBlockSzx = 6;
5771#[doc = " CoAP Block Size Exponents"]
5772pub type otCoapBlockSzx = ::std::os::raw::c_uint;
5773#[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."]
5774pub type otCoapResponseHandler = ::std::option::Option<
5775 unsafe extern "C" fn(
5776 aContext: *mut ::std::os::raw::c_void,
5777 aMessage: *mut otMessage,
5778 aMessageInfo: *const otMessageInfo,
5779 aResult: otError,
5780 ),
5781>;
5782#[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."]
5783pub type otCoapRequestHandler = ::std::option::Option<
5784 unsafe extern "C" fn(
5785 aContext: *mut ::std::os::raw::c_void,
5786 aMessage: *mut otMessage,
5787 aMessageInfo: *const otMessageInfo,
5788 ),
5789>;
5790#[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."]
5791pub type otCoapBlockwiseReceiveHook = ::std::option::Option<
5792 unsafe extern "C" fn(
5793 aContext: *mut ::std::os::raw::c_void,
5794 aBlock: *const u8,
5795 aPosition: u32,
5796 aBlockLength: u16,
5797 aMore: bool,
5798 aTotalLength: u32,
5799 ) -> otError,
5800>;
5801#[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."]
5802pub type otCoapBlockwiseTransmitHook = ::std::option::Option<
5803 unsafe extern "C" fn(
5804 aContext: *mut ::std::os::raw::c_void,
5805 aBlock: *mut u8,
5806 aPosition: u32,
5807 aBlockLength: *mut u16,
5808 aMore: *mut bool,
5809 ) -> otError,
5810>;
5811#[doc = " Represents a CoAP resource."]
5812#[repr(C)]
5813#[derive(Debug, Copy, Clone)]
5814pub struct otCoapResource {
5815 #[doc = "< The URI Path string"]
5816 pub mUriPath: *const ::std::os::raw::c_char,
5817 #[doc = "< The callback for handling a received request"]
5818 pub mHandler: otCoapRequestHandler,
5819 #[doc = "< Application-specific context"]
5820 pub mContext: *mut ::std::os::raw::c_void,
5821 #[doc = "< The next CoAP resource in the list"]
5822 pub mNext: *mut otCoapResource,
5823}
5824impl Default for otCoapResource {
5825 fn default() -> Self {
5826 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5827 unsafe {
5828 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5829 s.assume_init()
5830 }
5831 }
5832}
5833#[doc = " Represents a CoAP resource with block-wise transfer."]
5834#[repr(C)]
5835#[derive(Debug, Copy, Clone)]
5836pub struct otCoapBlockwiseResource {
5837 #[doc = "< The URI Path string"]
5838 pub mUriPath: *const ::std::os::raw::c_char,
5839 #[doc = "< The callback for handling a received request"]
5840 pub mHandler: otCoapRequestHandler,
5841 #[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."]
5842 pub mReceiveHook: otCoapBlockwiseReceiveHook,
5843 #[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."]
5844 pub mTransmitHook: otCoapBlockwiseTransmitHook,
5845 #[doc = "< Application-specific context"]
5846 pub mContext: *mut ::std::os::raw::c_void,
5847 #[doc = "< The next CoAP resource in the list"]
5848 pub mNext: *mut otCoapBlockwiseResource,
5849}
5850impl Default for otCoapBlockwiseResource {
5851 fn default() -> Self {
5852 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
5853 unsafe {
5854 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
5855 s.assume_init()
5856 }
5857 }
5858}
5859#[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."]
5860#[repr(C)]
5861#[derive(Debug, Default, Copy, Clone)]
5862pub struct otCoapTxParameters {
5863 #[doc = " Minimum spacing before first retransmission when ACK is not received, in milliseconds (RFC7252 default value is\n 2000ms)."]
5864 pub mAckTimeout: u32,
5865 #[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)."]
5866 pub mAckRandomFactorNumerator: u8,
5867 #[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)."]
5868 pub mAckRandomFactorDenominator: u8,
5869 #[doc = " Maximum number of retransmissions for CoAP Confirmable messages (RFC7252 default value is 4)."]
5870 pub mMaxRetransmit: u8,
5871}
5872extern "C" {
5873 #[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."]
5874 pub fn otCoapMessageInit(aMessage: *mut otMessage, aType: otCoapType, aCode: otCoapCode);
5875}
5876extern "C" {
5877 #[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."]
5878 pub fn otCoapMessageInitResponse(
5879 aResponse: *mut otMessage,
5880 aRequest: *const otMessage,
5881 aType: otCoapType,
5882 aCode: otCoapCode,
5883 ) -> otError;
5884}
5885extern "C" {
5886 #[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."]
5887 pub fn otCoapMessageSetToken(
5888 aMessage: *mut otMessage,
5889 aToken: *const u8,
5890 aTokenLength: u8,
5891 ) -> otError;
5892}
5893extern "C" {
5894 #[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."]
5895 pub fn otCoapMessageGenerateToken(aMessage: *mut otMessage, aTokenLength: u8);
5896}
5897extern "C" {
5898 #[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."]
5899 pub fn otCoapMessageAppendContentFormatOption(
5900 aMessage: *mut otMessage,
5901 aContentFormat: otCoapOptionContentFormat,
5902 ) -> otError;
5903}
5904extern "C" {
5905 #[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."]
5906 pub fn otCoapMessageAppendOption(
5907 aMessage: *mut otMessage,
5908 aNumber: u16,
5909 aLength: u16,
5910 aValue: *const ::std::os::raw::c_void,
5911 ) -> otError;
5912}
5913extern "C" {
5914 #[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"]
5915 pub fn otCoapMessageAppendUintOption(
5916 aMessage: *mut otMessage,
5917 aNumber: u16,
5918 aValue: u32,
5919 ) -> otError;
5920}
5921extern "C" {
5922 #[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."]
5923 pub fn otCoapMessageAppendObserveOption(aMessage: *mut otMessage, aObserve: u32) -> otError;
5924}
5925extern "C" {
5926 #[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."]
5927 pub fn otCoapMessageAppendUriPathOptions(
5928 aMessage: *mut otMessage,
5929 aUriPath: *const ::std::os::raw::c_char,
5930 ) -> otError;
5931}
5932extern "C" {
5933 #[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."]
5934 pub fn otCoapMessageAppendUriQueryOptions(
5935 aMessage: *mut otMessage,
5936 aUriQuery: *const ::std::os::raw::c_char,
5937 ) -> otError;
5938}
5939extern "C" {
5940 #[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."]
5941 pub fn otCoapBlockSizeFromExponent(aSize: otCoapBlockSzx) -> u16;
5942}
5943extern "C" {
5944 #[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."]
5945 pub fn otCoapMessageAppendBlock2Option(
5946 aMessage: *mut otMessage,
5947 aNum: u32,
5948 aMore: bool,
5949 aSize: otCoapBlockSzx,
5950 ) -> otError;
5951}
5952extern "C" {
5953 #[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."]
5954 pub fn otCoapMessageAppendBlock1Option(
5955 aMessage: *mut otMessage,
5956 aNum: u32,
5957 aMore: bool,
5958 aSize: otCoapBlockSzx,
5959 ) -> otError;
5960}
5961extern "C" {
5962 #[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."]
5963 pub fn otCoapMessageAppendProxyUriOption(
5964 aMessage: *mut otMessage,
5965 aUriPath: *const ::std::os::raw::c_char,
5966 ) -> otError;
5967}
5968extern "C" {
5969 #[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."]
5970 pub fn otCoapMessageAppendMaxAgeOption(aMessage: *mut otMessage, aMaxAge: u32) -> otError;
5971}
5972extern "C" {
5973 #[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."]
5974 pub fn otCoapMessageAppendUriQueryOption(
5975 aMessage: *mut otMessage,
5976 aUriQuery: *const ::std::os::raw::c_char,
5977 ) -> otError;
5978}
5979extern "C" {
5980 #[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."]
5981 pub fn otCoapMessageSetPayloadMarker(aMessage: *mut otMessage) -> otError;
5982}
5983extern "C" {
5984 #[doc = " Returns the Type value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Type value."]
5985 pub fn otCoapMessageGetType(aMessage: *const otMessage) -> otCoapType;
5986}
5987extern "C" {
5988 #[doc = " Returns the Code value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Code value."]
5989 pub fn otCoapMessageGetCode(aMessage: *const otMessage) -> otCoapCode;
5990}
5991extern "C" {
5992 #[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."]
5993 pub fn otCoapMessageSetCode(aMessage: *mut otMessage, aCode: otCoapCode);
5994}
5995extern "C" {
5996 #[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."]
5997 pub fn otCoapMessageCodeToString(aMessage: *const otMessage) -> *const ::std::os::raw::c_char;
5998}
5999extern "C" {
6000 #[doc = " Returns the Message ID value.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Message ID value."]
6001 pub fn otCoapMessageGetMessageId(aMessage: *const otMessage) -> u16;
6002}
6003extern "C" {
6004 #[doc = " Returns the Token length.\n\n @param[in] aMessage A pointer to the CoAP message.\n\n @returns The Token length."]
6005 pub fn otCoapMessageGetTokenLength(aMessage: *const otMessage) -> u8;
6006}
6007extern "C" {
6008 #[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."]
6009 pub fn otCoapMessageGetToken(aMessage: *const otMessage) -> *const u8;
6010}
6011extern "C" {
6012 #[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."]
6013 pub fn otCoapOptionIteratorInit(
6014 aIterator: *mut otCoapOptionIterator,
6015 aMessage: *const otMessage,
6016 ) -> otError;
6017}
6018extern "C" {
6019 #[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."]
6020 pub fn otCoapOptionIteratorGetFirstOptionMatching(
6021 aIterator: *mut otCoapOptionIterator,
6022 aOption: u16,
6023 ) -> *const otCoapOption;
6024}
6025extern "C" {
6026 #[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."]
6027 pub fn otCoapOptionIteratorGetFirstOption(
6028 aIterator: *mut otCoapOptionIterator,
6029 ) -> *const otCoapOption;
6030}
6031extern "C" {
6032 #[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."]
6033 pub fn otCoapOptionIteratorGetNextOptionMatching(
6034 aIterator: *mut otCoapOptionIterator,
6035 aOption: u16,
6036 ) -> *const otCoapOption;
6037}
6038extern "C" {
6039 #[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."]
6040 pub fn otCoapOptionIteratorGetNextOption(
6041 aIterator: *mut otCoapOptionIterator,
6042 ) -> *const otCoapOption;
6043}
6044extern "C" {
6045 #[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"]
6046 pub fn otCoapOptionIteratorGetOptionUintValue(
6047 aIterator: *mut otCoapOptionIterator,
6048 aValue: *mut u64,
6049 ) -> otError;
6050}
6051extern "C" {
6052 #[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."]
6053 pub fn otCoapOptionIteratorGetOptionValue(
6054 aIterator: *mut otCoapOptionIterator,
6055 aValue: *mut ::std::os::raw::c_void,
6056 ) -> otError;
6057}
6058extern "C" {
6059 #[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."]
6060 pub fn otCoapNewMessage(
6061 aInstance: *mut otInstance,
6062 aSettings: *const otMessageSettings,
6063 ) -> *mut otMessage;
6064}
6065extern "C" {
6066 #[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."]
6067 pub fn otCoapSendRequestWithParameters(
6068 aInstance: *mut otInstance,
6069 aMessage: *mut otMessage,
6070 aMessageInfo: *const otMessageInfo,
6071 aHandler: otCoapResponseHandler,
6072 aContext: *mut ::std::os::raw::c_void,
6073 aTxParameters: *const otCoapTxParameters,
6074 ) -> otError;
6075}
6076extern "C" {
6077 #[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."]
6078 pub fn otCoapSendRequestBlockWiseWithParameters(
6079 aInstance: *mut otInstance,
6080 aMessage: *mut otMessage,
6081 aMessageInfo: *const otMessageInfo,
6082 aHandler: otCoapResponseHandler,
6083 aContext: *mut ::std::os::raw::c_void,
6084 aTxParameters: *const otCoapTxParameters,
6085 aTransmitHook: otCoapBlockwiseTransmitHook,
6086 aReceiveHook: otCoapBlockwiseReceiveHook,
6087 ) -> otError;
6088}
6089extern "C" {
6090 #[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."]
6091 pub fn otCoapStart(aInstance: *mut otInstance, aPort: u16) -> otError;
6092}
6093extern "C" {
6094 #[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."]
6095 pub fn otCoapStop(aInstance: *mut otInstance) -> otError;
6096}
6097extern "C" {
6098 #[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."]
6099 pub fn otCoapAddResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
6100}
6101extern "C" {
6102 #[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."]
6103 pub fn otCoapRemoveResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
6104}
6105extern "C" {
6106 #[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."]
6107 pub fn otCoapAddBlockWiseResource(
6108 aInstance: *mut otInstance,
6109 aResource: *mut otCoapBlockwiseResource,
6110 );
6111}
6112extern "C" {
6113 #[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."]
6114 pub fn otCoapRemoveBlockWiseResource(
6115 aInstance: *mut otInstance,
6116 aResource: *mut otCoapBlockwiseResource,
6117 );
6118}
6119extern "C" {
6120 #[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."]
6121 pub fn otCoapSetDefaultHandler(
6122 aInstance: *mut otInstance,
6123 aHandler: otCoapRequestHandler,
6124 aContext: *mut ::std::os::raw::c_void,
6125 );
6126}
6127extern "C" {
6128 #[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."]
6129 pub fn otCoapSendResponseWithParameters(
6130 aInstance: *mut otInstance,
6131 aMessage: *mut otMessage,
6132 aMessageInfo: *const otMessageInfo,
6133 aTxParameters: *const otCoapTxParameters,
6134 ) -> otError;
6135}
6136extern "C" {
6137 #[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."]
6138 pub fn otCoapSendResponseBlockWiseWithParameters(
6139 aInstance: *mut otInstance,
6140 aMessage: *mut otMessage,
6141 aMessageInfo: *const otMessageInfo,
6142 aTxParameters: *const otCoapTxParameters,
6143 aContext: *mut ::std::os::raw::c_void,
6144 aTransmitHook: otCoapBlockwiseTransmitHook,
6145 ) -> otError;
6146}
6147#[doc = "< Connection established"]
6148pub const OT_COAP_SECURE_CONNECTED: otCoapSecureConnectEvent = 0;
6149#[doc = "< Disconnected by peer"]
6150pub const OT_COAP_SECURE_DISCONNECTED_PEER_CLOSED: otCoapSecureConnectEvent = 1;
6151#[doc = "< Disconnected locally"]
6152pub const OT_COAP_SECURE_DISCONNECTED_LOCAL_CLOSED: otCoapSecureConnectEvent = 2;
6153#[doc = "< Disconnected due to reaching the max connection attempts"]
6154pub const OT_COAP_SECURE_DISCONNECTED_MAX_ATTEMPTS: otCoapSecureConnectEvent = 3;
6155#[doc = "< Disconnected due to an error"]
6156pub const OT_COAP_SECURE_DISCONNECTED_ERROR: otCoapSecureConnectEvent = 4;
6157#[doc = " CoAP secure connection event types."]
6158pub type otCoapSecureConnectEvent = ::std::os::raw::c_uint;
6159#[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."]
6160pub type otHandleCoapSecureClientConnect = ::std::option::Option<
6161 unsafe extern "C" fn(aEvent: otCoapSecureConnectEvent, aContext: *mut ::std::os::raw::c_void),
6162>;
6163#[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."]
6164pub type otCoapSecureAutoStopCallback =
6165 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
6166extern "C" {
6167 #[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."]
6168 pub fn otCoapSecureStart(aInstance: *mut otInstance, aPort: u16) -> otError;
6169}
6170extern "C" {
6171 #[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."]
6172 pub fn otCoapSecureStartWithMaxConnAttempts(
6173 aInstance: *mut otInstance,
6174 aPort: u16,
6175 aMaxAttempts: u16,
6176 aCallback: otCoapSecureAutoStopCallback,
6177 aContext: *mut ::std::os::raw::c_void,
6178 ) -> otError;
6179}
6180extern "C" {
6181 #[doc = " Stops the CoAP Secure server.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
6182 pub fn otCoapSecureStop(aInstance: *mut otInstance);
6183}
6184extern "C" {
6185 #[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."]
6186 pub fn otCoapSecureSetPsk(
6187 aInstance: *mut otInstance,
6188 aPsk: *const u8,
6189 aPskLength: u16,
6190 aPskIdentity: *const u8,
6191 aPskIdLength: u16,
6192 );
6193}
6194extern "C" {
6195 #[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."]
6196 pub fn otCoapSecureGetPeerCertificateBase64(
6197 aInstance: *mut otInstance,
6198 aPeerCert: *mut ::std::os::raw::c_uchar,
6199 aCertLength: *mut usize,
6200 aCertBufferSize: usize,
6201 ) -> otError;
6202}
6203extern "C" {
6204 #[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."]
6205 pub fn otCoapSecureSetSslAuthMode(aInstance: *mut otInstance, aVerifyPeerCertificate: bool);
6206}
6207extern "C" {
6208 #[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."]
6209 pub fn otCoapSecureSetCertificate(
6210 aInstance: *mut otInstance,
6211 aX509Cert: *const u8,
6212 aX509Length: u32,
6213 aPrivateKey: *const u8,
6214 aPrivateKeyLength: u32,
6215 );
6216}
6217extern "C" {
6218 #[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."]
6219 pub fn otCoapSecureSetCaCertificateChain(
6220 aInstance: *mut otInstance,
6221 aX509CaCertificateChain: *const u8,
6222 aX509CaCertChainLength: u32,
6223 );
6224}
6225extern "C" {
6226 #[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."]
6227 pub fn otCoapSecureConnect(
6228 aInstance: *mut otInstance,
6229 aSockAddr: *const otSockAddr,
6230 aHandler: otHandleCoapSecureClientConnect,
6231 aContext: *mut ::std::os::raw::c_void,
6232 ) -> otError;
6233}
6234extern "C" {
6235 #[doc = " Stops the DTLS connection.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
6236 pub fn otCoapSecureDisconnect(aInstance: *mut otInstance);
6237}
6238extern "C" {
6239 #[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."]
6240 pub fn otCoapSecureIsConnected(aInstance: *mut otInstance) -> bool;
6241}
6242extern "C" {
6243 #[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."]
6244 pub fn otCoapSecureIsConnectionActive(aInstance: *mut otInstance) -> bool;
6245}
6246extern "C" {
6247 #[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."]
6248 pub fn otCoapSecureIsClosed(aInstance: *mut otInstance) -> bool;
6249}
6250extern "C" {
6251 #[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."]
6252 pub fn otCoapSecureSendRequestBlockWise(
6253 aInstance: *mut otInstance,
6254 aMessage: *mut otMessage,
6255 aHandler: otCoapResponseHandler,
6256 aContext: *mut ::std::os::raw::c_void,
6257 aTransmitHook: otCoapBlockwiseTransmitHook,
6258 aReceiveHook: otCoapBlockwiseReceiveHook,
6259 ) -> otError;
6260}
6261extern "C" {
6262 #[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."]
6263 pub fn otCoapSecureSendRequest(
6264 aInstance: *mut otInstance,
6265 aMessage: *mut otMessage,
6266 aHandler: otCoapResponseHandler,
6267 aContext: *mut ::std::os::raw::c_void,
6268 ) -> otError;
6269}
6270extern "C" {
6271 #[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."]
6272 pub fn otCoapSecureAddResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
6273}
6274extern "C" {
6275 #[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."]
6276 pub fn otCoapSecureRemoveResource(aInstance: *mut otInstance, aResource: *mut otCoapResource);
6277}
6278extern "C" {
6279 #[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."]
6280 pub fn otCoapSecureAddBlockWiseResource(
6281 aInstance: *mut otInstance,
6282 aResource: *mut otCoapBlockwiseResource,
6283 );
6284}
6285extern "C" {
6286 #[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."]
6287 pub fn otCoapSecureRemoveBlockWiseResource(
6288 aInstance: *mut otInstance,
6289 aResource: *mut otCoapBlockwiseResource,
6290 );
6291}
6292extern "C" {
6293 #[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."]
6294 pub fn otCoapSecureSetDefaultHandler(
6295 aInstance: *mut otInstance,
6296 aHandler: otCoapRequestHandler,
6297 aContext: *mut ::std::os::raw::c_void,
6298 );
6299}
6300extern "C" {
6301 #[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."]
6302 pub fn otCoapSecureSetClientConnectEventCallback(
6303 aInstance: *mut otInstance,
6304 aHandler: otHandleCoapSecureClientConnect,
6305 aContext: *mut ::std::os::raw::c_void,
6306 );
6307}
6308extern "C" {
6309 #[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."]
6310 pub fn otCoapSecureSendResponseBlockWise(
6311 aInstance: *mut otInstance,
6312 aMessage: *mut otMessage,
6313 aMessageInfo: *const otMessageInfo,
6314 aContext: *mut ::std::os::raw::c_void,
6315 aTransmitHook: otCoapBlockwiseTransmitHook,
6316 ) -> otError;
6317}
6318extern "C" {
6319 #[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."]
6320 pub fn otCoapSecureSendResponse(
6321 aInstance: *mut otInstance,
6322 aMessage: *mut otMessage,
6323 aMessageInfo: *const otMessageInfo,
6324 ) -> otError;
6325}
6326extern "C" {
6327 #[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."]
6328 pub fn otDatasetCreateNewNetwork(
6329 aInstance: *mut otInstance,
6330 aDataset: *mut otOperationalDataset,
6331 ) -> otError;
6332}
6333extern "C" {
6334 #[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)."]
6335 pub fn otDatasetGetDelayTimerMinimal(aInstance: *mut otInstance) -> u32;
6336}
6337extern "C" {
6338 #[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."]
6339 pub fn otDatasetSetDelayTimerMinimal(
6340 aInstance: *mut otInstance,
6341 aDelayTimerMinimal: u32,
6342 ) -> otError;
6343}
6344#[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()`)."]
6345pub type otDatasetUpdaterCallback = ::std::option::Option<
6346 unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
6347>;
6348extern "C" {
6349 #[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."]
6350 pub fn otDatasetUpdaterRequestUpdate(
6351 aInstance: *mut otInstance,
6352 aDataset: *const otOperationalDataset,
6353 aCallback: otDatasetUpdaterCallback,
6354 aContext: *mut ::std::os::raw::c_void,
6355 ) -> otError;
6356}
6357extern "C" {
6358 #[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."]
6359 pub fn otDatasetUpdaterCancelUpdate(aInstance: *mut otInstance);
6360}
6361extern "C" {
6362 #[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."]
6363 pub fn otDatasetUpdaterIsUpdateOngoing(aInstance: *mut otInstance) -> bool;
6364}
6365#[doc = "< Input mode without pull resistor."]
6366pub const OT_GPIO_MODE_INPUT: otGpioMode = 0;
6367#[doc = "< Output mode."]
6368pub const OT_GPIO_MODE_OUTPUT: otGpioMode = 1;
6369#[doc = " Defines the gpio modes."]
6370pub type otGpioMode = ::std::os::raw::c_uint;
6371#[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."]
6372pub type otPlatDiagOutputCallback = ::std::option::Option<
6373 unsafe extern "C" fn(
6374 aFormat: *const ::std::os::raw::c_char,
6375 aArguments: *mut __va_list_tag,
6376 aContext: *mut ::std::os::raw::c_void,
6377 ),
6378>;
6379extern "C" {
6380 #[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."]
6381 pub fn otPlatDiagSetOutputCallback(
6382 aInstance: *mut otInstance,
6383 aCallback: otPlatDiagOutputCallback,
6384 aContext: *mut ::std::os::raw::c_void,
6385 );
6386}
6387extern "C" {
6388 #[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."]
6389 pub fn otPlatDiagProcess(
6390 aInstance: *mut otInstance,
6391 aArgsLength: u8,
6392 aArgs: *mut *mut ::std::os::raw::c_char,
6393 ) -> otError;
6394}
6395extern "C" {
6396 #[doc = " Enables/disables the factory diagnostics mode.\n\n @param[in] aMode TRUE to enable diagnostics mode, FALSE otherwise."]
6397 pub fn otPlatDiagModeSet(aMode: bool);
6398}
6399extern "C" {
6400 #[doc = " Indicates whether or not factory diagnostics mode is enabled.\n\n @returns TRUE if factory diagnostics mode is enabled, FALSE otherwise."]
6401 pub fn otPlatDiagModeGet() -> bool;
6402}
6403extern "C" {
6404 #[doc = " Sets the channel to use for factory diagnostics.\n\n @param[in] aChannel The channel value."]
6405 pub fn otPlatDiagChannelSet(aChannel: u8);
6406}
6407extern "C" {
6408 #[doc = " Sets the transmit power to use for factory diagnostics.\n\n @param[in] aTxPower The transmit power value."]
6409 pub fn otPlatDiagTxPowerSet(aTxPower: i8);
6410}
6411extern "C" {
6412 #[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."]
6413 pub fn otPlatDiagRadioReceived(
6414 aInstance: *mut otInstance,
6415 aFrame: *mut otRadioFrame,
6416 aError: otError,
6417 );
6418}
6419extern "C" {
6420 #[doc = " Processes the alarm event.\n\n @param[in] aInstance The OpenThread instance for current request."]
6421 pub fn otPlatDiagAlarmCallback(aInstance: *mut otInstance);
6422}
6423extern "C" {
6424 #[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."]
6425 pub fn otPlatDiagGpioSet(aGpio: u32, aValue: bool) -> otError;
6426}
6427extern "C" {
6428 #[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."]
6429 pub fn otPlatDiagGpioGet(aGpio: u32, aValue: *mut bool) -> otError;
6430}
6431extern "C" {
6432 #[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."]
6433 pub fn otPlatDiagGpioSetMode(aGpio: u32, aMode: otGpioMode) -> otError;
6434}
6435extern "C" {
6436 #[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."]
6437 pub fn otPlatDiagGpioGetMode(aGpio: u32, aMode: *mut otGpioMode) -> otError;
6438}
6439extern "C" {
6440 #[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."]
6441 pub fn otPlatDiagRadioSetRawPowerSetting(
6442 aInstance: *mut otInstance,
6443 aRawPowerSetting: *const u8,
6444 aRawPowerSettingLength: u16,
6445 ) -> otError;
6446}
6447extern "C" {
6448 #[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."]
6449 pub fn otPlatDiagRadioGetRawPowerSetting(
6450 aInstance: *mut otInstance,
6451 aRawPowerSetting: *mut u8,
6452 aRawPowerSettingLength: *mut u16,
6453 ) -> otError;
6454}
6455extern "C" {
6456 #[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."]
6457 pub fn otPlatDiagRadioRawPowerSettingEnable(
6458 aInstance: *mut otInstance,
6459 aEnable: bool,
6460 ) -> otError;
6461}
6462extern "C" {
6463 #[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."]
6464 pub fn otPlatDiagRadioTransmitCarrier(aInstance: *mut otInstance, aEnable: bool) -> otError;
6465}
6466extern "C" {
6467 #[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."]
6468 pub fn otPlatDiagRadioTransmitStream(aInstance: *mut otInstance, aEnable: bool) -> otError;
6469}
6470extern "C" {
6471 #[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."]
6472 pub fn otPlatDiagRadioGetPowerSettings(
6473 aInstance: *mut otInstance,
6474 aChannel: u8,
6475 aTargetPower: *mut i16,
6476 aActualPower: *mut i16,
6477 aRawPowerSetting: *mut u8,
6478 aRawPowerSettingLength: *mut u16,
6479 ) -> otError;
6480}
6481#[doc = " @addtogroup api-factory-diagnostics\n\n @brief\n This module includes functions that control the Thread stack's execution.\n\n @{"]
6482pub type otDiagOutputCallback = otPlatDiagOutputCallback;
6483extern "C" {
6484 #[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."]
6485 pub fn otDiagSetOutputCallback(
6486 aInstance: *mut otInstance,
6487 aCallback: otDiagOutputCallback,
6488 aContext: *mut ::std::os::raw::c_void,
6489 );
6490}
6491extern "C" {
6492 #[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."]
6493 pub fn otDiagProcessCmd(
6494 aInstance: *mut otInstance,
6495 aArgsLength: u8,
6496 aArgs: *mut *mut ::std::os::raw::c_char,
6497 ) -> otError;
6498}
6499extern "C" {
6500 #[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."]
6501 pub fn otDiagProcessCmdLine(
6502 aInstance: *mut otInstance,
6503 aString: *const ::std::os::raw::c_char,
6504 ) -> otError;
6505}
6506extern "C" {
6507 #[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."]
6508 pub fn otDiagIsEnabled(aInstance: *mut otInstance) -> bool;
6509}
6510#[doc = "< Indicates the flag is not specified."]
6511pub const OT_DNS_FLAG_UNSPECIFIED: otDnsRecursionFlag = 0;
6512#[doc = "< Indicates DNS name server can resolve the query recursively."]
6513pub const OT_DNS_FLAG_RECURSION_DESIRED: otDnsRecursionFlag = 1;
6514#[doc = "< Indicates DNS name server can not resolve the query recursively."]
6515pub const OT_DNS_FLAG_NO_RECURSION: otDnsRecursionFlag = 2;
6516#[doc = " Type represents the \"Recursion Desired\" (RD) flag in an `otDnsQueryConfig`."]
6517pub type otDnsRecursionFlag = ::std::os::raw::c_uint;
6518#[doc = "< NAT64 mode is not specified. Use default NAT64 mode."]
6519pub const OT_DNS_NAT64_UNSPECIFIED: otDnsNat64Mode = 0;
6520#[doc = "< Allow NAT64 address translation during DNS client address resolution."]
6521pub const OT_DNS_NAT64_ALLOW: otDnsNat64Mode = 1;
6522#[doc = "< Do not allow NAT64 address translation during DNS client address resolution."]
6523pub const OT_DNS_NAT64_DISALLOW: otDnsNat64Mode = 2;
6524#[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."]
6525pub type otDnsNat64Mode = ::std::os::raw::c_uint;
6526#[doc = "< Mode is not specified. Use default service mode."]
6527pub const OT_DNS_SERVICE_MODE_UNSPECIFIED: otDnsServiceMode = 0;
6528#[doc = "< Query for SRV record only."]
6529pub const OT_DNS_SERVICE_MODE_SRV: otDnsServiceMode = 1;
6530#[doc = "< Query for TXT record only."]
6531pub const OT_DNS_SERVICE_MODE_TXT: otDnsServiceMode = 2;
6532#[doc = "< Query for both SRV and TXT records in same message."]
6533pub const OT_DNS_SERVICE_MODE_SRV_TXT: otDnsServiceMode = 3;
6534#[doc = "< Query in parallel for SRV and TXT using separate messages."]
6535pub const OT_DNS_SERVICE_MODE_SRV_TXT_SEPARATE: otDnsServiceMode = 4;
6536#[doc = "< Query for TXT/SRV together first, if fails then query separately."]
6537pub const OT_DNS_SERVICE_MODE_SRV_TXT_OPTIMIZE: otDnsServiceMode = 5;
6538#[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."]
6539pub type otDnsServiceMode = ::std::os::raw::c_uint;
6540pub const OT_DNS_TRANSPORT_UNSPECIFIED: otDnsTransportProto = 0;
6541#[doc = " DNS transport is unspecified."]
6542pub const OT_DNS_TRANSPORT_UDP: otDnsTransportProto = 1;
6543#[doc = " DNS query should be sent via UDP."]
6544pub const OT_DNS_TRANSPORT_TCP: otDnsTransportProto = 2;
6545#[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."]
6546pub type otDnsTransportProto = ::std::os::raw::c_uint;
6547#[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`."]
6548#[repr(C)]
6549#[derive(Copy, Clone)]
6550pub struct otDnsQueryConfig {
6551 #[doc = "< Server address (IPv6 addr/port). All zero or zero port for unspecified."]
6552 pub mServerSockAddr: otSockAddr,
6553 #[doc = "< Wait time (in msec) to rx response. Zero indicates unspecified value."]
6554 pub mResponseTimeout: u32,
6555 #[doc = "< Maximum tx attempts before reporting failure. Zero for unspecified value."]
6556 pub mMaxTxAttempts: u8,
6557 #[doc = "< Indicates whether the server can resolve the query recursively or not."]
6558 pub mRecursionFlag: otDnsRecursionFlag,
6559 #[doc = "< Allow/Disallow NAT64 address translation during address resolution."]
6560 pub mNat64Mode: otDnsNat64Mode,
6561 #[doc = "< Determines which records to query during service resolution."]
6562 pub mServiceMode: otDnsServiceMode,
6563 #[doc = "< Select default transport protocol."]
6564 pub mTransportProto: otDnsTransportProto,
6565}
6566impl Default for otDnsQueryConfig {
6567 fn default() -> Self {
6568 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6569 unsafe {
6570 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6571 s.assume_init()
6572 }
6573 }
6574}
6575extern "C" {
6576 #[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."]
6577 pub fn otDnsClientGetDefaultConfig(aInstance: *mut otInstance) -> *const otDnsQueryConfig;
6578}
6579extern "C" {
6580 #[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."]
6581 pub fn otDnsClientSetDefaultConfig(
6582 aInstance: *mut otInstance,
6583 aConfig: *const otDnsQueryConfig,
6584 );
6585}
6586#[repr(C)]
6587#[derive(Debug, Copy, Clone)]
6588pub struct otDnsAddressResponse {
6589 _unused: [u8; 0],
6590}
6591#[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"]
6592pub type otDnsAddressCallback = ::std::option::Option<
6593 unsafe extern "C" fn(
6594 aError: otError,
6595 aResponse: *const otDnsAddressResponse,
6596 aContext: *mut ::std::os::raw::c_void,
6597 ),
6598>;
6599extern "C" {
6600 #[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."]
6601 pub fn otDnsClientResolveAddress(
6602 aInstance: *mut otInstance,
6603 aHostName: *const ::std::os::raw::c_char,
6604 aCallback: otDnsAddressCallback,
6605 aContext: *mut ::std::os::raw::c_void,
6606 aConfig: *const otDnsQueryConfig,
6607 ) -> otError;
6608}
6609extern "C" {
6610 #[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."]
6611 pub fn otDnsClientResolveIp4Address(
6612 aInstance: *mut otInstance,
6613 aHostName: *const ::std::os::raw::c_char,
6614 aCallback: otDnsAddressCallback,
6615 aContext: *mut ::std::os::raw::c_void,
6616 aConfig: *const otDnsQueryConfig,
6617 ) -> otError;
6618}
6619extern "C" {
6620 #[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."]
6621 pub fn otDnsAddressResponseGetHostName(
6622 aResponse: *const otDnsAddressResponse,
6623 aNameBuffer: *mut ::std::os::raw::c_char,
6624 aNameBufferSize: u16,
6625 ) -> otError;
6626}
6627extern "C" {
6628 #[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)."]
6629 pub fn otDnsAddressResponseGetAddress(
6630 aResponse: *const otDnsAddressResponse,
6631 aIndex: u16,
6632 aAddress: *mut otIp6Address,
6633 aTtl: *mut u32,
6634 ) -> otError;
6635}
6636#[repr(C)]
6637#[derive(Debug, Copy, Clone)]
6638pub struct otDnsBrowseResponse {
6639 _unused: [u8; 0],
6640}
6641#[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()`."]
6642pub type otDnsBrowseCallback = ::std::option::Option<
6643 unsafe extern "C" fn(
6644 aError: otError,
6645 aResponse: *const otDnsBrowseResponse,
6646 aContext: *mut ::std::os::raw::c_void,
6647 ),
6648>;
6649#[doc = " Provides info for a DNS service instance."]
6650#[repr(C)]
6651#[derive(Copy, Clone)]
6652pub struct otDnsServiceInfo {
6653 #[doc = "< Service record TTL (in seconds)."]
6654 pub mTtl: u32,
6655 #[doc = "< Service port number."]
6656 pub mPort: u16,
6657 #[doc = "< Service priority."]
6658 pub mPriority: u16,
6659 #[doc = "< Service weight."]
6660 pub mWeight: u16,
6661 #[doc = "< Buffer to output the service host name (can be NULL if not needed)."]
6662 pub mHostNameBuffer: *mut ::std::os::raw::c_char,
6663 #[doc = "< Size of `mHostNameBuffer`."]
6664 pub mHostNameBufferSize: u16,
6665 #[doc = "< The host IPv6 address. Set to all zero if not available."]
6666 pub mHostAddress: otIp6Address,
6667 #[doc = "< The host address TTL."]
6668 pub mHostAddressTtl: u32,
6669 #[doc = "< Buffer to output TXT data (can be NULL if not needed)."]
6670 pub mTxtData: *mut u8,
6671 #[doc = "< On input, size of `mTxtData` buffer. On output number bytes written."]
6672 pub mTxtDataSize: u16,
6673 #[doc = "< Indicates if TXT data could not fit in `mTxtDataSize` and was truncated."]
6674 pub mTxtDataTruncated: bool,
6675 #[doc = "< The TXT data TTL."]
6676 pub mTxtDataTtl: u32,
6677}
6678impl Default for otDnsServiceInfo {
6679 fn default() -> Self {
6680 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6681 unsafe {
6682 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6683 s.assume_init()
6684 }
6685 }
6686}
6687extern "C" {
6688 #[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."]
6689 pub fn otDnsClientBrowse(
6690 aInstance: *mut otInstance,
6691 aServiceName: *const ::std::os::raw::c_char,
6692 aCallback: otDnsBrowseCallback,
6693 aContext: *mut ::std::os::raw::c_void,
6694 aConfig: *const otDnsQueryConfig,
6695 ) -> otError;
6696}
6697extern "C" {
6698 #[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."]
6699 pub fn otDnsBrowseResponseGetServiceName(
6700 aResponse: *const otDnsBrowseResponse,
6701 aNameBuffer: *mut ::std::os::raw::c_char,
6702 aNameBufferSize: u16,
6703 ) -> otError;
6704}
6705extern "C" {
6706 #[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."]
6707 pub fn otDnsBrowseResponseGetServiceInstance(
6708 aResponse: *const otDnsBrowseResponse,
6709 aIndex: u16,
6710 aLabelBuffer: *mut ::std::os::raw::c_char,
6711 aLabelBufferSize: u8,
6712 ) -> otError;
6713}
6714extern "C" {
6715 #[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."]
6716 pub fn otDnsBrowseResponseGetServiceInfo(
6717 aResponse: *const otDnsBrowseResponse,
6718 aInstanceLabel: *const ::std::os::raw::c_char,
6719 aServiceInfo: *mut otDnsServiceInfo,
6720 ) -> otError;
6721}
6722extern "C" {
6723 #[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."]
6724 pub fn otDnsBrowseResponseGetHostAddress(
6725 aResponse: *const otDnsBrowseResponse,
6726 aHostName: *const ::std::os::raw::c_char,
6727 aIndex: u16,
6728 aAddress: *mut otIp6Address,
6729 aTtl: *mut u32,
6730 ) -> otError;
6731}
6732#[repr(C)]
6733#[derive(Debug, Copy, Clone)]
6734pub struct otDnsServiceResponse {
6735 _unused: [u8; 0],
6736}
6737#[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()`."]
6738pub type otDnsServiceCallback = ::std::option::Option<
6739 unsafe extern "C" fn(
6740 aError: otError,
6741 aResponse: *const otDnsServiceResponse,
6742 aContext: *mut ::std::os::raw::c_void,
6743 ),
6744>;
6745extern "C" {
6746 #[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."]
6747 pub fn otDnsClientResolveService(
6748 aInstance: *mut otInstance,
6749 aInstanceLabel: *const ::std::os::raw::c_char,
6750 aServiceName: *const ::std::os::raw::c_char,
6751 aCallback: otDnsServiceCallback,
6752 aContext: *mut ::std::os::raw::c_void,
6753 aConfig: *const otDnsQueryConfig,
6754 ) -> otError;
6755}
6756extern "C" {
6757 #[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."]
6758 pub fn otDnsClientResolveServiceAndHostAddress(
6759 aInstance: *mut otInstance,
6760 aInstanceLabel: *const ::std::os::raw::c_char,
6761 aServiceName: *const ::std::os::raw::c_char,
6762 aCallback: otDnsServiceCallback,
6763 aContext: *mut ::std::os::raw::c_void,
6764 aConfig: *const otDnsQueryConfig,
6765 ) -> otError;
6766}
6767extern "C" {
6768 #[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."]
6769 pub fn otDnsServiceResponseGetServiceName(
6770 aResponse: *const otDnsServiceResponse,
6771 aLabelBuffer: *mut ::std::os::raw::c_char,
6772 aLabelBufferSize: u8,
6773 aNameBuffer: *mut ::std::os::raw::c_char,
6774 aNameBufferSize: u16,
6775 ) -> otError;
6776}
6777extern "C" {
6778 #[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."]
6779 pub fn otDnsServiceResponseGetServiceInfo(
6780 aResponse: *const otDnsServiceResponse,
6781 aServiceInfo: *mut otDnsServiceInfo,
6782 ) -> otError;
6783}
6784extern "C" {
6785 #[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."]
6786 pub fn otDnsServiceResponseGetHostAddress(
6787 aResponse: *const otDnsServiceResponse,
6788 aHostName: *const ::std::os::raw::c_char,
6789 aIndex: u16,
6790 aAddress: *mut otIp6Address,
6791 aTtl: *mut u32,
6792 ) -> otError;
6793}
6794#[repr(C)]
6795#[derive(Debug, Copy, Clone)]
6796pub struct otDnsRecordResponse {
6797 _unused: [u8; 0],
6798}
6799#[doc = " Pointer is called when a DNS response is received for a DNS query to an arbitrary record type.\n\n Within this callback the user can use `otDnsRecordResponseGet{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 the stack.\n - OT_ERROR_RESPONSE_TIMEOUT No DNS response has been received within timeout.\n"]
6800pub type otDnsRecordCallback = ::std::option::Option<
6801 unsafe extern "C" fn(
6802 aError: otError,
6803 aResponse: *const otDnsRecordResponse,
6804 aContext: *mut ::std::os::raw::c_void,
6805 ),
6806>;
6807#[doc = "< Answer section."]
6808pub const OT_DNS_SECTION_ANSWER: otDnsRecordSection = 0;
6809#[doc = "< Authority section."]
6810pub const OT_DNS_SECTION_AUTHORITY: otDnsRecordSection = 1;
6811#[doc = "< Additional section."]
6812pub const OT_DNS_SECTION_ADDITIONAL: otDnsRecordSection = 2;
6813#[doc = " Represents a section in a DNS query/response message."]
6814pub type otDnsRecordSection = ::std::os::raw::c_uint;
6815#[doc = " Represents info for a record in an `otDnsRecordResponse`.\n\n This struct is used as input to `otDnsRecordResponseGetRecordInfo()`."]
6816#[repr(C)]
6817#[derive(Debug, Copy, Clone)]
6818pub struct otDnsRecordInfo {
6819 #[doc = "< Buffer to output the name (MUST NOT be NULL)."]
6820 pub mNameBuffer: *mut ::std::os::raw::c_char,
6821 #[doc = "< Size of `mNameBuffer`."]
6822 pub mNameBufferSize: u16,
6823 #[doc = "< The record type."]
6824 pub mRecordType: u16,
6825 #[doc = "< The record data length (in bytes)."]
6826 pub mRecordLength: u16,
6827 #[doc = "< Record TTL (in seconds)."]
6828 pub mTtl: u32,
6829 #[doc = "< Buffer to output the data (Can be NULL if data not needed)."]
6830 pub mDataBuffer: *mut u8,
6831 #[doc = "< On input, size of `mDataBuffer`. On output number of bytes written."]
6832 pub mDataBufferSize: u16,
6833 #[doc = "< Indicates the section of the record."]
6834 pub mSection: otDnsRecordSection,
6835}
6836impl Default for otDnsRecordInfo {
6837 fn default() -> Self {
6838 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6839 unsafe {
6840 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6841 s.assume_init()
6842 }
6843 }
6844}
6845extern "C" {
6846 #[doc = " Sends a DNS query for a given record type and name.\n\n Requires `OPENTHREAD_CONFIG_DNS_CLIENT_ARBITRARY_RECORD_QUERY_ENABLE`.\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] aRecordType The resource record type to query.\n @param[in] aFirstLabel The first label of the name to be queried (can be NULL if not needed).\n @param[in] aNextLabels The next labels of the name to be queried (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 used when @p aCallback is invoked.\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 outcome.\n @retval OT_ERROR_NO_BUFS Insufficient buffer to prepare and send query.\n @retval OT_ERROR_INVALID_STATE Cannot send query since Thread interface is not up."]
6847 pub fn otDnsClientQueryRecord(
6848 aInstance: *mut otInstance,
6849 aRecordType: u16,
6850 aFirstLabel: *const ::std::os::raw::c_char,
6851 aNextLabels: *const ::std::os::raw::c_char,
6852 aCallback: otDnsRecordCallback,
6853 aContext: *mut ::std::os::raw::c_void,
6854 aConfig: *const otDnsQueryConfig,
6855 ) -> otError;
6856}
6857extern "C" {
6858 #[doc = " Gets the query name associated with a record query DNS response.\n\n MUST only be used from `otDnsRecordCallback`.\n\n @param[in] aResponse A pointer to the response.\n @param[out] aNameBuffer A buffer to char array to output the full query name (MUST NOT be NULL).\n @param[in] aNameBufferSize The size of @p aNameBuffer.\n\n @retval OT_ERROR_NONE The full query name was read successfully.\n @retval OT_ERROR_NO_BUFS The name does not fit in @p aNameBuffer."]
6859 pub fn otDnsRecordResponseGetQueryName(
6860 aResponse: *const otDnsRecordResponse,
6861 aNameBuffer: *mut ::std::os::raw::c_char,
6862 aNameBufferSize: u16,
6863 ) -> otError;
6864}
6865extern "C" {
6866 #[doc = " Reads the records from a DNS query response.\n\n MUST only be used from `otDnsRecordCallback`.\n\n The response may include multiple records. @p aIndex can be used to iterate through the list. Index zero gets the\n first record and so on. When we reach the end of the list, `OT_ERROR_NOT_FOUND` is returned.\n\n Upon successful retrieval (`OT_ERROR_NONE`):\n - `mRecordLength` is set to the actual length of the record's data.\n - The data is copied into `mDataBuffer` (if not `NULL`) up to its capacity specified by `mDataBufferSize`.\n - `mDataBufferSize` is then updated to reflect the number of bytes actually written into `mDataBuffer`.\n\n If the retrieved record type is NS, CNAME, SOA, PTR, MX, RP, AFSDB, RT, PX, SRV, KX, DNAME, or NSEC, the record\n data in the received response contains a DNS name which may use DNS name compression. For these specific record\n types, the record data is first decompressed such that it contains the full uncompressed DNS name. This decompressed\n data is then provided in `mDataBuffer`, and `mRecordDataLength` will indicate the length of this decompressed data.\n For all other record types, the record data is read and provided as it appears in the received response message.\n\n @param[in] aResponse A pointer to the response.\n @param[in] aIndex The record index to retrieve.\n @param[out] aRecordInfo A pointer to a `otDnsRecordInfo` to populate with read record info.\n\n @retval OT_ERROR_NONE The record was read successfully.\n @retval OT_ERROR_NOT_FOUND No 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_NO_BUFS The record name does not fit in the provided `mNameBufferSize` in @p aRecordInfo, or\n failed to allocate buffer to decompress a compressed DNS name."]
6867 pub fn otDnsRecordResponseGetRecordInfo(
6868 aResponse: *const otDnsRecordResponse,
6869 aIndex: u16,
6870 aRecordInfo: *mut otDnsRecordInfo,
6871 ) -> otError;
6872}
6873#[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"]
6874pub type otDnssdQuerySubscribeCallback = ::std::option::Option<
6875 unsafe extern "C" fn(
6876 aContext: *mut ::std::os::raw::c_void,
6877 aFullName: *const ::std::os::raw::c_char,
6878 ),
6879>;
6880#[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.\")."]
6881pub type otDnssdQueryUnsubscribeCallback = ::std::option::Option<
6882 unsafe extern "C" fn(
6883 aContext: *mut ::std::os::raw::c_void,
6884 aFullName: *const ::std::os::raw::c_char,
6885 ),
6886>;
6887#[doc = " This opaque type represents a DNS-SD query."]
6888pub type otDnssdQuery = ::std::os::raw::c_void;
6889#[doc = " Represents information of a discovered service instance for a DNS-SD query."]
6890#[repr(C)]
6891#[derive(Debug, Copy, Clone)]
6892pub struct otDnssdServiceInstanceInfo {
6893 #[doc = "< Full instance name (e.g. \"OpenThread._ipps._tcp.default.service.arpa.\")."]
6894 pub mFullName: *const ::std::os::raw::c_char,
6895 #[doc = "< Host name (e.g. \"ot-host.default.service.arpa.\")."]
6896 pub mHostName: *const ::std::os::raw::c_char,
6897 #[doc = "< Number of host IPv6 addresses."]
6898 pub mAddressNum: u8,
6899 #[doc = "< Host IPv6 addresses."]
6900 pub mAddresses: *const otIp6Address,
6901 #[doc = "< Service port."]
6902 pub mPort: u16,
6903 #[doc = "< Service priority."]
6904 pub mPriority: u16,
6905 #[doc = "< Service weight."]
6906 pub mWeight: u16,
6907 #[doc = "< Service TXT RDATA length."]
6908 pub mTxtLength: u16,
6909 #[doc = "< Service TXT RDATA."]
6910 pub mTxtData: *const u8,
6911 #[doc = "< Service TTL (in seconds)."]
6912 pub mTtl: u32,
6913}
6914impl Default for otDnssdServiceInstanceInfo {
6915 fn default() -> Self {
6916 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6917 unsafe {
6918 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6919 s.assume_init()
6920 }
6921 }
6922}
6923#[doc = " Represents information of a discovered host for a DNS-SD query."]
6924#[repr(C)]
6925#[derive(Debug, Copy, Clone)]
6926pub struct otDnssdHostInfo {
6927 #[doc = "< Number of host IPv6 addresses."]
6928 pub mAddressNum: u8,
6929 #[doc = "< Host IPv6 addresses."]
6930 pub mAddresses: *const otIp6Address,
6931 #[doc = "< Service TTL (in seconds)."]
6932 pub mTtl: u32,
6933}
6934impl Default for otDnssdHostInfo {
6935 fn default() -> Self {
6936 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
6937 unsafe {
6938 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
6939 s.assume_init()
6940 }
6941 }
6942}
6943#[doc = "< Service type unspecified."]
6944pub const OT_DNSSD_QUERY_TYPE_NONE: otDnssdQueryType = 0;
6945#[doc = "< Service type browse service."]
6946pub const OT_DNSSD_QUERY_TYPE_BROWSE: otDnssdQueryType = 1;
6947#[doc = "< Service type resolve service instance."]
6948pub const OT_DNSSD_QUERY_TYPE_RESOLVE: otDnssdQueryType = 2;
6949#[doc = "< Service type resolve hostname."]
6950pub const OT_DNSSD_QUERY_TYPE_RESOLVE_HOST: otDnssdQueryType = 3;
6951#[doc = " Specifies a DNS-SD query type."]
6952pub type otDnssdQueryType = ::std::os::raw::c_uint;
6953#[doc = " Represents the count of queries, responses, failures handled by upstream DNS server.\n\n Requires `OPENTHREAD_CONFIG_DNS_UPSTREAM_QUERY_ENABLE`."]
6954#[repr(C)]
6955#[derive(Debug, Default, Copy, Clone)]
6956pub struct otUpstreamDnsCounters {
6957 #[doc = "< The number of queries forwarded."]
6958 pub mQueries: u32,
6959 #[doc = "< The number of responses forwarded."]
6960 pub mResponses: u32,
6961 #[doc = "< The number of upstream DNS failures."]
6962 pub mFailures: u32,
6963}
6964#[doc = " Contains the counters of DNS-SD server."]
6965#[repr(C)]
6966#[derive(Debug, Default, Copy, Clone)]
6967pub struct otDnssdCounters {
6968 #[doc = "< The number of successful responses."]
6969 pub mSuccessResponse: u32,
6970 #[doc = "< The number of server failure responses."]
6971 pub mServerFailureResponse: u32,
6972 #[doc = "< The number of format error responses."]
6973 pub mFormatErrorResponse: u32,
6974 #[doc = "< The number of name error responses."]
6975 pub mNameErrorResponse: u32,
6976 #[doc = "< The number of 'not implemented' responses."]
6977 pub mNotImplementedResponse: u32,
6978 #[doc = "< The number of other responses."]
6979 pub mOtherResponse: u32,
6980 #[doc = "< The number of queries resolved by the local SRP server."]
6981 pub mResolvedBySrp: u32,
6982 #[doc = "< The number of queries, responses,\n< failures handled by upstream DNS server."]
6983 pub mUpstreamDnsCounters: otUpstreamDnsCounters,
6984}
6985extern "C" {
6986 #[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."]
6987 pub fn otDnssdQuerySetCallbacks(
6988 aInstance: *mut otInstance,
6989 aSubscribe: otDnssdQuerySubscribeCallback,
6990 aUnsubscribe: otDnssdQueryUnsubscribeCallback,
6991 aContext: *mut ::std::os::raw::c_void,
6992 );
6993}
6994extern "C" {
6995 #[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."]
6996 pub fn otDnssdQueryHandleDiscoveredServiceInstance(
6997 aInstance: *mut otInstance,
6998 aServiceFullName: *const ::std::os::raw::c_char,
6999 aInstanceInfo: *mut otDnssdServiceInstanceInfo,
7000 );
7001}
7002extern "C" {
7003 #[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."]
7004 pub fn otDnssdQueryHandleDiscoveredHost(
7005 aInstance: *mut otInstance,
7006 aHostFullName: *const ::std::os::raw::c_char,
7007 aHostInfo: *mut otDnssdHostInfo,
7008 );
7009}
7010extern "C" {
7011 #[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."]
7012 pub fn otDnssdGetNextQuery(
7013 aInstance: *mut otInstance,
7014 aQuery: *const otDnssdQuery,
7015 ) -> *const otDnssdQuery;
7016}
7017extern "C" {
7018 #[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."]
7019 pub fn otDnssdGetQueryTypeAndName(
7020 aQuery: *const otDnssdQuery,
7021 aNameOutput: *mut [::std::os::raw::c_char; 255usize],
7022 ) -> otDnssdQueryType;
7023}
7024extern "C" {
7025 #[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."]
7026 pub fn otDnssdGetCounters(aInstance: *mut otInstance) -> *const otDnssdCounters;
7027}
7028extern "C" {
7029 #[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"]
7030 pub fn otDnssdUpstreamQuerySetEnabled(aInstance: *mut otInstance, aEnabled: bool);
7031}
7032extern "C" {
7033 #[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"]
7034 pub fn otDnssdUpstreamQueryIsEnabled(aInstance: *mut otInstance) -> bool;
7035}
7036extern "C" {
7037 #[doc = " @note This API is deprecated and use of it is discouraged."]
7038 pub fn otHeapCAlloc(aCount: usize, aSize: usize) -> *mut ::std::os::raw::c_void;
7039}
7040extern "C" {
7041 #[doc = " @note This API is deprecated and use of it is discouraged."]
7042 pub fn otHeapFree(aPointer: *mut ::std::os::raw::c_void);
7043}
7044#[doc = "< Destination Unreachable"]
7045pub const OT_ICMP6_TYPE_DST_UNREACH: otIcmp6Type = 1;
7046#[doc = "< Packet To Big"]
7047pub const OT_ICMP6_TYPE_PACKET_TO_BIG: otIcmp6Type = 2;
7048#[doc = "< Time Exceeded"]
7049pub const OT_ICMP6_TYPE_TIME_EXCEEDED: otIcmp6Type = 3;
7050#[doc = "< Parameter Problem"]
7051pub const OT_ICMP6_TYPE_PARAMETER_PROBLEM: otIcmp6Type = 4;
7052#[doc = "< Echo Request"]
7053pub const OT_ICMP6_TYPE_ECHO_REQUEST: otIcmp6Type = 128;
7054#[doc = "< Echo Reply"]
7055pub const OT_ICMP6_TYPE_ECHO_REPLY: otIcmp6Type = 129;
7056#[doc = "< Router Solicitation"]
7057pub const OT_ICMP6_TYPE_ROUTER_SOLICIT: otIcmp6Type = 133;
7058#[doc = "< Router Advertisement"]
7059pub const OT_ICMP6_TYPE_ROUTER_ADVERT: otIcmp6Type = 134;
7060#[doc = "< Neighbor Solicitation"]
7061pub const OT_ICMP6_TYPE_NEIGHBOR_SOLICIT: otIcmp6Type = 135;
7062#[doc = "< Neighbor Advertisement"]
7063pub const OT_ICMP6_TYPE_NEIGHBOR_ADVERT: otIcmp6Type = 136;
7064#[doc = " ICMPv6 Message Types"]
7065pub type otIcmp6Type = ::std::os::raw::c_uint;
7066#[doc = "< Destination Unreachable (Type 1) - No Route"]
7067pub const OT_ICMP6_CODE_DST_UNREACH_NO_ROUTE: otIcmp6Code = 0;
7068#[doc = "< Destination Unreachable (Type 1) - Administratively Prohibited"]
7069pub const OT_ICMP6_CODE_DST_UNREACH_PROHIBITED: otIcmp6Code = 1;
7070#[doc = "< Time Exceeded (Type 3) - Fragment Reassembly"]
7071pub const OT_ICMP6_CODE_FRAGM_REAS_TIME_EX: otIcmp6Code = 1;
7072#[doc = " ICMPv6 Message Codes"]
7073pub type otIcmp6Code = ::std::os::raw::c_uint;
7074#[doc = " @struct otIcmp6Header\n\n Represents an ICMPv6 header."]
7075#[repr(C, packed)]
7076#[derive(Copy, Clone)]
7077pub struct otIcmp6Header {
7078 #[doc = "< Type"]
7079 pub mType: u8,
7080 #[doc = "< Code"]
7081 pub mCode: u8,
7082 #[doc = "< Checksum"]
7083 pub mChecksum: u16,
7084 #[doc = "< Message-specific data"]
7085 pub mData: otIcmp6Header__bindgen_ty_1,
7086}
7087#[repr(C, packed)]
7088#[derive(Copy, Clone)]
7089pub union otIcmp6Header__bindgen_ty_1 {
7090 pub m8: [u8; 4usize],
7091 pub m16: [u16; 2usize],
7092 pub m32: [u32; 1usize],
7093}
7094impl Default for otIcmp6Header__bindgen_ty_1 {
7095 fn default() -> Self {
7096 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7097 unsafe {
7098 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7099 s.assume_init()
7100 }
7101 }
7102}
7103impl Default for otIcmp6Header {
7104 fn default() -> Self {
7105 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7106 unsafe {
7107 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7108 s.assume_init()
7109 }
7110 }
7111}
7112#[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."]
7113pub type otIcmp6ReceiveCallback = ::std::option::Option<
7114 unsafe extern "C" fn(
7115 aContext: *mut ::std::os::raw::c_void,
7116 aMessage: *mut otMessage,
7117 aMessageInfo: *const otMessageInfo,
7118 aIcmpHeader: *const otIcmp6Header,
7119 ),
7120>;
7121#[doc = " Implements ICMPv6 message handler."]
7122#[repr(C)]
7123#[derive(Debug, Copy, Clone)]
7124pub struct otIcmp6Handler {
7125 #[doc = "< The ICMPv6 received callback"]
7126 pub mReceiveCallback: otIcmp6ReceiveCallback,
7127 #[doc = "< A pointer to arbitrary context information."]
7128 pub mContext: *mut ::std::os::raw::c_void,
7129 #[doc = "< A pointer to the next handler in the list."]
7130 pub mNext: *mut otIcmp6Handler,
7131}
7132impl Default for otIcmp6Handler {
7133 fn default() -> Self {
7134 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
7135 unsafe {
7136 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
7137 s.assume_init()
7138 }
7139 }
7140}
7141#[doc = "< ICMPv6 Echo processing disabled"]
7142pub const OT_ICMP6_ECHO_HANDLER_DISABLED: otIcmp6EchoMode = 0;
7143#[doc = "< ICMPv6 Echo processing enabled only for unicast requests only"]
7144pub const OT_ICMP6_ECHO_HANDLER_UNICAST_ONLY: otIcmp6EchoMode = 1;
7145#[doc = "< ICMPv6 Echo processing enabled only for multicast requests only"]
7146pub const OT_ICMP6_ECHO_HANDLER_MULTICAST_ONLY: otIcmp6EchoMode = 2;
7147#[doc = "< ICMPv6 Echo processing enabled for unicast and multicast requests"]
7148pub const OT_ICMP6_ECHO_HANDLER_ALL: otIcmp6EchoMode = 3;
7149#[doc = "< ICMPv6 Echo processing enabled for RLOC/ALOC destinations only"]
7150pub const OT_ICMP6_ECHO_HANDLER_RLOC_ALOC_ONLY: otIcmp6EchoMode = 4;
7151#[doc = " ICMPv6 Echo Reply Modes"]
7152pub type otIcmp6EchoMode = ::std::os::raw::c_uint;
7153extern "C" {
7154 #[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"]
7155 pub fn otIcmp6GetEchoMode(aInstance: *mut otInstance) -> otIcmp6EchoMode;
7156}
7157extern "C" {
7158 #[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."]
7159 pub fn otIcmp6SetEchoMode(aInstance: *mut otInstance, aMode: otIcmp6EchoMode);
7160}
7161extern "C" {
7162 #[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."]
7163 pub fn otIcmp6RegisterHandler(
7164 aInstance: *mut otInstance,
7165 aHandler: *mut otIcmp6Handler,
7166 ) -> otError;
7167}
7168extern "C" {
7169 #[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."]
7170 pub fn otIcmp6SendEchoRequest(
7171 aInstance: *mut otInstance,
7172 aMessage: *mut otMessage,
7173 aMessageInfo: *const otMessageInfo,
7174 aIdentifier: u16,
7175 ) -> otError;
7176}
7177#[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."]
7178pub type otJamDetectionCallback = ::std::option::Option<
7179 unsafe extern "C" fn(aJamState: bool, aContext: *mut ::std::os::raw::c_void),
7180>;
7181extern "C" {
7182 #[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."]
7183 pub fn otJamDetectionSetRssiThreshold(
7184 aInstance: *mut otInstance,
7185 aRssiThreshold: i8,
7186 ) -> otError;
7187}
7188extern "C" {
7189 #[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."]
7190 pub fn otJamDetectionGetRssiThreshold(aInstance: *mut otInstance) -> i8;
7191}
7192extern "C" {
7193 #[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)"]
7194 pub fn otJamDetectionSetWindow(aInstance: *mut otInstance, aWindow: u8) -> otError;
7195}
7196extern "C" {
7197 #[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."]
7198 pub fn otJamDetectionGetWindow(aInstance: *mut otInstance) -> u8;
7199}
7200extern "C" {
7201 #[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."]
7202 pub fn otJamDetectionSetBusyPeriod(aInstance: *mut otInstance, aBusyPeriod: u8) -> otError;
7203}
7204extern "C" {
7205 #[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."]
7206 pub fn otJamDetectionGetBusyPeriod(aInstance: *mut otInstance) -> u8;
7207}
7208extern "C" {
7209 #[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."]
7210 pub fn otJamDetectionStart(
7211 aInstance: *mut otInstance,
7212 aCallback: otJamDetectionCallback,
7213 aContext: *mut ::std::os::raw::c_void,
7214 ) -> otError;
7215}
7216extern "C" {
7217 #[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."]
7218 pub fn otJamDetectionStop(aInstance: *mut otInstance) -> otError;
7219}
7220extern "C" {
7221 #[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)."]
7222 pub fn otJamDetectionIsEnabled(aInstance: *mut otInstance) -> bool;
7223}
7224extern "C" {
7225 #[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)."]
7226 pub fn otJamDetectionGetState(aInstance: *mut otInstance) -> bool;
7227}
7228extern "C" {
7229 #[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."]
7230 pub fn otJamDetectionGetHistoryBitmap(aInstance: *mut otInstance) -> u64;
7231}
7232pub type otMacFilterIterator = u8;
7233#[doc = "< Address filter is disabled."]
7234pub const OT_MAC_FILTER_ADDRESS_MODE_DISABLED: otMacFilterAddressMode = 0;
7235#[doc = "< Allowlist address filter mode is enabled."]
7236pub const OT_MAC_FILTER_ADDRESS_MODE_ALLOWLIST: otMacFilterAddressMode = 1;
7237#[doc = "< Denylist address filter mode is enabled."]
7238pub const OT_MAC_FILTER_ADDRESS_MODE_DENYLIST: otMacFilterAddressMode = 2;
7239#[doc = " Defines address mode of the mac filter."]
7240pub type otMacFilterAddressMode = ::std::os::raw::c_uint;
7241#[doc = " Represents a Mac Filter entry."]
7242#[repr(C)]
7243#[derive(Debug, Default, Copy, Clone)]
7244pub struct otMacFilterEntry {
7245 #[doc = "< IEEE 802.15.4 Extended Address"]
7246 pub mExtAddress: otExtAddress,
7247 #[doc = "< Received signal strength"]
7248 pub mRssIn: i8,
7249}
7250#[doc = " Represents the MAC layer counters."]
7251#[repr(C)]
7252#[derive(Debug, Default, Copy, Clone)]
7253pub struct otMacCounters {
7254 #[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"]
7255 pub mTxTotal: u32,
7256 #[doc = " The total number of unique unicast MAC frame transmission requests."]
7257 pub mTxUnicast: u32,
7258 #[doc = " The total number of unique broadcast MAC frame transmission requests."]
7259 pub mTxBroadcast: u32,
7260 #[doc = " The total number of unique MAC frame transmission requests with requested acknowledgment."]
7261 pub mTxAckRequested: u32,
7262 #[doc = " The total number of unique MAC frame transmission requests that were acked."]
7263 pub mTxAcked: u32,
7264 #[doc = " The total number of unique MAC frame transmission requests without requested acknowledgment."]
7265 pub mTxNoAckRequested: u32,
7266 #[doc = " The total number of unique MAC Data frame transmission requests."]
7267 pub mTxData: u32,
7268 #[doc = " The total number of unique MAC Data Poll frame transmission requests."]
7269 pub mTxDataPoll: u32,
7270 #[doc = " The total number of unique MAC Beacon frame transmission requests."]
7271 pub mTxBeacon: u32,
7272 #[doc = " The total number of unique MAC Beacon Request frame transmission requests."]
7273 pub mTxBeaconRequest: u32,
7274 #[doc = " The total number of unique other MAC frame transmission requests.\n\n This counter is currently used for counting out-of-band frames."]
7275 pub mTxOther: u32,
7276 #[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."]
7277 pub mTxRetry: u32,
7278 #[doc = " The total number of unique MAC transmission packets that meet maximal retry limit for direct packets."]
7279 pub mTxDirectMaxRetryExpiry: u32,
7280 #[doc = " The total number of unique MAC transmission packets that meet maximal retry limit for indirect packets."]
7281 pub mTxIndirectMaxRetryExpiry: u32,
7282 #[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)."]
7283 pub mTxErrCca: u32,
7284 #[doc = " The total number of unique MAC transmission request failures cause by an abort error."]
7285 pub mTxErrAbort: u32,
7286 #[doc = " The total number of unique MAC transmission requests failures caused by a busy channel (a CSMA/CA fail)."]
7287 pub mTxErrBusyChannel: u32,
7288 #[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."]
7289 pub mRxTotal: u32,
7290 #[doc = " The total number of unicast frames received."]
7291 pub mRxUnicast: u32,
7292 #[doc = " The total number of broadcast frames received."]
7293 pub mRxBroadcast: u32,
7294 #[doc = " The total number of MAC Data frames received."]
7295 pub mRxData: u32,
7296 #[doc = " The total number of MAC Data Poll frames received."]
7297 pub mRxDataPoll: u32,
7298 #[doc = " The total number of MAC Beacon frames received."]
7299 pub mRxBeacon: u32,
7300 #[doc = " The total number of MAC Beacon Request frames received."]
7301 pub mRxBeaconRequest: u32,
7302 #[doc = " The total number of other types of frames received."]
7303 pub mRxOther: u32,
7304 #[doc = " The total number of frames dropped by MAC Filter module, for example received from denylisted node."]
7305 pub mRxAddressFiltered: u32,
7306 #[doc = " The total number of frames dropped by destination address check, for example received frame for other node."]
7307 pub mRxDestAddrFiltered: u32,
7308 #[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."]
7309 pub mRxDuplicated: u32,
7310 #[doc = " The total number of frames dropped because of missing or malformed content."]
7311 pub mRxErrNoFrame: u32,
7312 #[doc = " The total number of frames dropped due to unknown neighbor."]
7313 pub mRxErrUnknownNeighbor: u32,
7314 #[doc = " The total number of frames dropped due to invalid source address."]
7315 pub mRxErrInvalidSrcAddr: u32,
7316 #[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."]
7317 pub mRxErrSec: u32,
7318 #[doc = " The total number of frames dropped due to invalid FCS."]
7319 pub mRxErrFcs: u32,
7320 #[doc = " The total number of frames dropped due to other error."]
7321 pub mRxErrOther: u32,
7322}
7323#[doc = " Represents a received IEEE 802.15.4 Beacon."]
7324#[repr(C)]
7325#[repr(align(4))]
7326#[derive(Debug, Default, Copy, Clone)]
7327pub struct otActiveScanResult {
7328 #[doc = "< IEEE 802.15.4 Extended Address"]
7329 pub mExtAddress: otExtAddress,
7330 #[doc = "< Thread Network Name"]
7331 pub mNetworkName: otNetworkName,
7332 #[doc = "< Thread Extended PAN ID"]
7333 pub mExtendedPanId: otExtendedPanId,
7334 #[doc = "< Steering Data"]
7335 pub mSteeringData: otSteeringData,
7336 #[doc = "< IEEE 802.15.4 PAN ID"]
7337 pub mPanId: u16,
7338 #[doc = "< Joiner UDP Port"]
7339 pub mJoinerUdpPort: u16,
7340 #[doc = "< IEEE 802.15.4 Channel"]
7341 pub mChannel: u8,
7342 #[doc = "< RSSI (dBm)"]
7343 pub mRssi: i8,
7344 #[doc = "< LQI"]
7345 pub mLqi: u8,
7346 pub _bitfield_align_1: [u8; 0],
7347 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7348 pub __bindgen_padding_0: u16,
7349}
7350impl otActiveScanResult {
7351 #[inline]
7352 pub fn mVersion(&self) -> ::std::os::raw::c_uint {
7353 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u32) }
7354 }
7355 #[inline]
7356 pub fn set_mVersion(&mut self, val: ::std::os::raw::c_uint) {
7357 unsafe {
7358 let val: u32 = ::std::mem::transmute(val);
7359 self._bitfield_1.set(0usize, 4u8, val as u64)
7360 }
7361 }
7362 #[inline]
7363 pub fn mIsNative(&self) -> bool {
7364 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
7365 }
7366 #[inline]
7367 pub fn set_mIsNative(&mut self, val: bool) {
7368 unsafe {
7369 let val: u8 = ::std::mem::transmute(val);
7370 self._bitfield_1.set(4usize, 1u8, val as u64)
7371 }
7372 }
7373 #[inline]
7374 pub fn mDiscover(&self) -> bool {
7375 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 1u8) as u8) }
7376 }
7377 #[inline]
7378 pub fn set_mDiscover(&mut self, val: bool) {
7379 unsafe {
7380 let val: u8 = ::std::mem::transmute(val);
7381 self._bitfield_1.set(5usize, 1u8, val as u64)
7382 }
7383 }
7384 #[inline]
7385 pub fn mIsJoinable(&self) -> bool {
7386 unsafe { ::std::mem::transmute(self._bitfield_1.get(6usize, 1u8) as u8) }
7387 }
7388 #[inline]
7389 pub fn set_mIsJoinable(&mut self, val: bool) {
7390 unsafe {
7391 let val: u8 = ::std::mem::transmute(val);
7392 self._bitfield_1.set(6usize, 1u8, val as u64)
7393 }
7394 }
7395 #[inline]
7396 pub fn new_bitfield_1(
7397 mVersion: ::std::os::raw::c_uint,
7398 mIsNative: bool,
7399 mDiscover: bool,
7400 mIsJoinable: bool,
7401 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7402 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7403 __bindgen_bitfield_unit.set(0usize, 4u8, {
7404 let mVersion: u32 = unsafe { ::std::mem::transmute(mVersion) };
7405 mVersion as u64
7406 });
7407 __bindgen_bitfield_unit.set(4usize, 1u8, {
7408 let mIsNative: u8 = unsafe { ::std::mem::transmute(mIsNative) };
7409 mIsNative as u64
7410 });
7411 __bindgen_bitfield_unit.set(5usize, 1u8, {
7412 let mDiscover: u8 = unsafe { ::std::mem::transmute(mDiscover) };
7413 mDiscover as u64
7414 });
7415 __bindgen_bitfield_unit.set(6usize, 1u8, {
7416 let mIsJoinable: u8 = unsafe { ::std::mem::transmute(mIsJoinable) };
7417 mIsJoinable as u64
7418 });
7419 __bindgen_bitfield_unit
7420 }
7421}
7422#[doc = " Represents an energy scan result."]
7423#[repr(C)]
7424#[derive(Debug, Default, Copy, Clone)]
7425pub struct otEnergyScanResult {
7426 #[doc = "< IEEE 802.15.4 Channel"]
7427 pub mChannel: u8,
7428 #[doc = "< The max RSSI (dBm)"]
7429 pub mMaxRssi: i8,
7430}
7431#[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."]
7432pub type otHandleActiveScanResult = ::std::option::Option<
7433 unsafe extern "C" fn(aResult: *mut otActiveScanResult, aContext: *mut ::std::os::raw::c_void),
7434>;
7435extern "C" {
7436 #[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."]
7437 pub fn otLinkActiveScan(
7438 aInstance: *mut otInstance,
7439 aScanChannels: u32,
7440 aScanDuration: u16,
7441 aCallback: otHandleActiveScanResult,
7442 aCallbackContext: *mut ::std::os::raw::c_void,
7443 ) -> otError;
7444}
7445extern "C" {
7446 #[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."]
7447 pub fn otLinkIsActiveScanInProgress(aInstance: *mut otInstance) -> bool;
7448}
7449#[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."]
7450pub type otHandleEnergyScanResult = ::std::option::Option<
7451 unsafe extern "C" fn(aResult: *mut otEnergyScanResult, aContext: *mut ::std::os::raw::c_void),
7452>;
7453extern "C" {
7454 #[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."]
7455 pub fn otLinkEnergyScan(
7456 aInstance: *mut otInstance,
7457 aScanChannels: u32,
7458 aScanDuration: u16,
7459 aCallback: otHandleEnergyScanResult,
7460 aCallbackContext: *mut ::std::os::raw::c_void,
7461 ) -> otError;
7462}
7463extern "C" {
7464 #[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."]
7465 pub fn otLinkIsEnergyScanInProgress(aInstance: *mut otInstance) -> bool;
7466}
7467extern "C" {
7468 #[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."]
7469 pub fn otLinkSendDataRequest(aInstance: *mut otInstance) -> otError;
7470}
7471extern "C" {
7472 #[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."]
7473 pub fn otLinkIsInTransmitState(aInstance: *mut otInstance) -> bool;
7474}
7475extern "C" {
7476 #[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"]
7477 pub fn otLinkGetChannel(aInstance: *mut otInstance) -> u8;
7478}
7479extern "C" {
7480 #[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"]
7481 pub fn otLinkSetChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7482}
7483extern "C" {
7484 #[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."]
7485 pub fn otLinkGetSupportedChannelMask(aInstance: *mut otInstance) -> u32;
7486}
7487extern "C" {
7488 #[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."]
7489 pub fn otLinkSetSupportedChannelMask(aInstance: *mut otInstance, aChannelMask: u32) -> otError;
7490}
7491extern "C" {
7492 #[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."]
7493 pub fn otLinkGetExtendedAddress(aInstance: *mut otInstance) -> *const otExtAddress;
7494}
7495extern "C" {
7496 #[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."]
7497 pub fn otLinkSetExtendedAddress(
7498 aInstance: *mut otInstance,
7499 aExtAddress: *const otExtAddress,
7500 ) -> otError;
7501}
7502extern "C" {
7503 #[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."]
7504 pub fn otLinkGetFactoryAssignedIeeeEui64(aInstance: *mut otInstance, aEui64: *mut otExtAddress);
7505}
7506extern "C" {
7507 #[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"]
7508 pub fn otLinkGetPanId(aInstance: *mut otInstance) -> otPanId;
7509}
7510extern "C" {
7511 #[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"]
7512 pub fn otLinkSetPanId(aInstance: *mut otInstance, aPanId: otPanId) -> otError;
7513}
7514extern "C" {
7515 #[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"]
7516 pub fn otLinkGetPollPeriod(aInstance: *mut otInstance) -> u32;
7517}
7518extern "C" {
7519 #[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"]
7520 pub fn otLinkSetPollPeriod(aInstance: *mut otInstance, aPollPeriod: u32) -> otError;
7521}
7522extern "C" {
7523 #[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."]
7524 pub fn otLinkGetShortAddress(aInstance: *mut otInstance) -> otShortAddress;
7525}
7526extern "C" {
7527 #[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."]
7528 pub fn otLinkGetAlternateShortAddress(aInstance: *mut otInstance) -> otShortAddress;
7529}
7530extern "C" {
7531 #[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."]
7532 pub fn otLinkGetMaxFrameRetriesDirect(aInstance: *mut otInstance) -> u8;
7533}
7534extern "C" {
7535 #[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."]
7536 pub fn otLinkSetMaxFrameRetriesDirect(aInstance: *mut otInstance, aMaxFrameRetriesDirect: u8);
7537}
7538extern "C" {
7539 #[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."]
7540 pub fn otLinkGetMaxFrameRetriesIndirect(aInstance: *mut otInstance) -> u8;
7541}
7542extern "C" {
7543 #[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."]
7544 pub fn otLinkSetMaxFrameRetriesIndirect(
7545 aInstance: *mut otInstance,
7546 aMaxFrameRetriesIndirect: u8,
7547 );
7548}
7549extern "C" {
7550 #[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."]
7551 pub fn otLinkGetFrameCounter(aInstance: *mut otInstance) -> u32;
7552}
7553extern "C" {
7554 #[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."]
7555 pub fn otLinkFilterGetAddressMode(aInstance: *mut otInstance) -> otMacFilterAddressMode;
7556}
7557extern "C" {
7558 #[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."]
7559 pub fn otLinkFilterSetAddressMode(aInstance: *mut otInstance, aMode: otMacFilterAddressMode);
7560}
7561extern "C" {
7562 #[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."]
7563 pub fn otLinkFilterAddAddress(
7564 aInstance: *mut otInstance,
7565 aExtAddress: *const otExtAddress,
7566 ) -> otError;
7567}
7568extern "C" {
7569 #[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)."]
7570 pub fn otLinkFilterRemoveAddress(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
7571}
7572extern "C" {
7573 #[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."]
7574 pub fn otLinkFilterClearAddresses(aInstance: *mut otInstance);
7575}
7576extern "C" {
7577 #[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."]
7578 pub fn otLinkFilterGetNextAddress(
7579 aInstance: *mut otInstance,
7580 aIterator: *mut otMacFilterIterator,
7581 aEntry: *mut otMacFilterEntry,
7582 ) -> otError;
7583}
7584extern "C" {
7585 #[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."]
7586 pub fn otLinkFilterAddRssIn(
7587 aInstance: *mut otInstance,
7588 aExtAddress: *const otExtAddress,
7589 aRss: i8,
7590 ) -> otError;
7591}
7592extern "C" {
7593 #[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."]
7594 pub fn otLinkFilterRemoveRssIn(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
7595}
7596extern "C" {
7597 #[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."]
7598 pub fn otLinkFilterSetDefaultRssIn(aInstance: *mut otInstance, aRss: i8);
7599}
7600extern "C" {
7601 #[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."]
7602 pub fn otLinkFilterClearDefaultRssIn(aInstance: *mut otInstance);
7603}
7604extern "C" {
7605 #[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."]
7606 pub fn otLinkFilterClearAllRssIn(aInstance: *mut otInstance);
7607}
7608extern "C" {
7609 #[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."]
7610 pub fn otLinkFilterGetNextRssIn(
7611 aInstance: *mut otInstance,
7612 aIterator: *mut otMacFilterIterator,
7613 aEntry: *mut otMacFilterEntry,
7614 ) -> otError;
7615}
7616extern "C" {
7617 #[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"]
7618 pub fn otLinkSetRadioFilterEnabled(aInstance: *mut otInstance, aFilterEnabled: bool);
7619}
7620extern "C" {
7621 #[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."]
7622 pub fn otLinkIsRadioFilterEnabled(aInstance: *mut otInstance) -> bool;
7623}
7624extern "C" {
7625 #[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."]
7626 pub fn otLinkConvertRssToLinkQuality(aInstance: *mut otInstance, aRss: i8) -> u8;
7627}
7628extern "C" {
7629 #[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."]
7630 pub fn otLinkConvertLinkQualityToRss(aInstance: *mut otInstance, aLinkQuality: u8) -> i8;
7631}
7632extern "C" {
7633 #[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."]
7634 pub fn otLinkGetTxDirectRetrySuccessHistogram(
7635 aInstance: *mut otInstance,
7636 aNumberOfEntries: *mut u8,
7637 ) -> *const u32;
7638}
7639extern "C" {
7640 #[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."]
7641 pub fn otLinkGetTxIndirectRetrySuccessHistogram(
7642 aInstance: *mut otInstance,
7643 aNumberOfEntries: *mut u8,
7644 ) -> *const u32;
7645}
7646extern "C" {
7647 #[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."]
7648 pub fn otLinkResetTxRetrySuccessHistogram(aInstance: *mut otInstance);
7649}
7650extern "C" {
7651 #[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."]
7652 pub fn otLinkGetCounters(aInstance: *mut otInstance) -> *const otMacCounters;
7653}
7654extern "C" {
7655 #[doc = " Resets the MAC layer counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
7656 pub fn otLinkResetCounters(aInstance: *mut otInstance);
7657}
7658#[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."]
7659pub type otLinkPcapCallback = ::std::option::Option<
7660 unsafe extern "C" fn(
7661 aFrame: *const otRadioFrame,
7662 aIsTx: bool,
7663 aContext: *mut ::std::os::raw::c_void,
7664 ),
7665>;
7666extern "C" {
7667 #[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."]
7668 pub fn otLinkSetPcapCallback(
7669 aInstance: *mut otInstance,
7670 aPcapCallback: otLinkPcapCallback,
7671 aCallbackContext: *mut ::std::os::raw::c_void,
7672 );
7673}
7674extern "C" {
7675 #[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."]
7676 pub fn otLinkIsPromiscuous(aInstance: *mut otInstance) -> bool;
7677}
7678extern "C" {
7679 #[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."]
7680 pub fn otLinkSetPromiscuous(aInstance: *mut otInstance, aPromiscuous: bool) -> otError;
7681}
7682extern "C" {
7683 #[doc = " Gets the CSL channel.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The CSL channel."]
7684 pub fn otLinkGetCslChannel(aInstance: *mut otInstance) -> u8;
7685}
7686extern "C" {
7687 #[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."]
7688 pub fn otLinkSetCslChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7689}
7690extern "C" {
7691 #[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."]
7692 pub fn otLinkGetCslPeriod(aInstance: *mut otInstance) -> u32;
7693}
7694extern "C" {
7695 #[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"]
7696 pub fn otLinkSetCslPeriod(aInstance: *mut otInstance, aPeriod: u32) -> otError;
7697}
7698extern "C" {
7699 #[doc = " Gets the CSL timeout.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The CSL timeout in seconds."]
7700 pub fn otLinkGetCslTimeout(aInstance: *mut otInstance) -> u32;
7701}
7702extern "C" {
7703 #[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."]
7704 pub fn otLinkSetCslTimeout(aInstance: *mut otInstance, aTimeout: u32) -> otError;
7705}
7706extern "C" {
7707 #[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."]
7708 pub fn otLinkGetCcaFailureRate(aInstance: *mut otInstance) -> u16;
7709}
7710extern "C" {
7711 #[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."]
7712 pub fn otLinkSetEnabled(aInstance: *mut otInstance, aEnable: bool) -> otError;
7713}
7714extern "C" {
7715 #[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."]
7716 pub fn otLinkIsEnabled(aInstance: *mut otInstance) -> bool;
7717}
7718extern "C" {
7719 #[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."]
7720 pub fn otLinkIsCslEnabled(aInstance: *mut otInstance) -> bool;
7721}
7722extern "C" {
7723 #[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."]
7724 pub fn otLinkIsCslSupported(aInstance: *mut otInstance) -> bool;
7725}
7726extern "C" {
7727 #[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."]
7728 pub fn otLinkSendEmptyData(aInstance: *mut otInstance) -> otError;
7729}
7730extern "C" {
7731 #[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."]
7732 pub fn otLinkSetRegion(aInstance: *mut otInstance, aRegionCode: u16) -> otError;
7733}
7734extern "C" {
7735 #[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 NULL.\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."]
7736 pub fn otLinkGetRegion(aInstance: *mut otInstance, aRegionCode: *mut u16) -> otError;
7737}
7738extern "C" {
7739 #[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."]
7740 pub fn otLinkGetWakeupChannel(aInstance: *mut otInstance) -> u8;
7741}
7742extern "C" {
7743 #[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."]
7744 pub fn otLinkSetWakeupChannel(aInstance: *mut otInstance, aChannel: u8) -> otError;
7745}
7746extern "C" {
7747 #[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."]
7748 pub fn otLinkSetWakeUpListenEnabled(aInstance: *mut otInstance, aEnable: bool) -> otError;
7749}
7750extern "C" {
7751 #[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."]
7752 pub fn otLinkIsWakeupListenEnabled(aInstance: *mut otInstance) -> bool;
7753}
7754extern "C" {
7755 #[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."]
7756 pub fn otLinkGetWakeupListenParameters(
7757 aInstance: *mut otInstance,
7758 aInterval: *mut u32,
7759 aDuration: *mut u32,
7760 );
7761}
7762extern "C" {
7763 #[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."]
7764 pub fn otLinkSetWakeupListenParameters(
7765 aInstance: *mut otInstance,
7766 aInterval: u32,
7767 aDuration: u32,
7768 ) -> otError;
7769}
7770extern "C" {
7771 #[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."]
7772 pub fn otLinkSetRxOnWhenIdle(aInstance: *mut otInstance, aRxOnWhenIdle: bool) -> otError;
7773}
7774#[doc = " Represents the result (value) for a Link Metrics query."]
7775#[repr(C)]
7776#[derive(Debug, Default, Copy, Clone)]
7777pub struct otLinkMetricsValues {
7778 #[doc = "< Specifies which metrics values are present/included."]
7779 pub mMetrics: otLinkMetrics,
7780 #[doc = "< The value of Pdu Count."]
7781 pub mPduCountValue: u32,
7782 #[doc = "< The value LQI."]
7783 pub mLqiValue: u8,
7784 #[doc = "< The value of Link Margin."]
7785 pub mLinkMarginValue: u8,
7786 #[doc = "< The value of Rssi."]
7787 pub mRssiValue: i8,
7788}
7789#[doc = " Represents which frames are accounted in a Forward Tracking Series."]
7790#[repr(C, packed)]
7791#[derive(Debug, Default, Copy, Clone)]
7792pub struct otLinkMetricsSeriesFlags {
7793 pub _bitfield_align_1: [u8; 0],
7794 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
7795}
7796impl otLinkMetricsSeriesFlags {
7797 #[inline]
7798 pub fn mLinkProbe(&self) -> bool {
7799 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
7800 }
7801 #[inline]
7802 pub fn set_mLinkProbe(&mut self, val: bool) {
7803 unsafe {
7804 let val: u8 = ::std::mem::transmute(val);
7805 self._bitfield_1.set(0usize, 1u8, val as u64)
7806 }
7807 }
7808 #[inline]
7809 pub fn mMacData(&self) -> bool {
7810 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
7811 }
7812 #[inline]
7813 pub fn set_mMacData(&mut self, val: bool) {
7814 unsafe {
7815 let val: u8 = ::std::mem::transmute(val);
7816 self._bitfield_1.set(1usize, 1u8, val as u64)
7817 }
7818 }
7819 #[inline]
7820 pub fn mMacDataRequest(&self) -> bool {
7821 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
7822 }
7823 #[inline]
7824 pub fn set_mMacDataRequest(&mut self, val: bool) {
7825 unsafe {
7826 let val: u8 = ::std::mem::transmute(val);
7827 self._bitfield_1.set(2usize, 1u8, val as u64)
7828 }
7829 }
7830 #[inline]
7831 pub fn mMacAck(&self) -> bool {
7832 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
7833 }
7834 #[inline]
7835 pub fn set_mMacAck(&mut self, val: bool) {
7836 unsafe {
7837 let val: u8 = ::std::mem::transmute(val);
7838 self._bitfield_1.set(3usize, 1u8, val as u64)
7839 }
7840 }
7841 #[inline]
7842 pub fn new_bitfield_1(
7843 mLinkProbe: bool,
7844 mMacData: bool,
7845 mMacDataRequest: bool,
7846 mMacAck: bool,
7847 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
7848 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
7849 __bindgen_bitfield_unit.set(0usize, 1u8, {
7850 let mLinkProbe: u8 = unsafe { ::std::mem::transmute(mLinkProbe) };
7851 mLinkProbe as u64
7852 });
7853 __bindgen_bitfield_unit.set(1usize, 1u8, {
7854 let mMacData: u8 = unsafe { ::std::mem::transmute(mMacData) };
7855 mMacData as u64
7856 });
7857 __bindgen_bitfield_unit.set(2usize, 1u8, {
7858 let mMacDataRequest: u8 = unsafe { ::std::mem::transmute(mMacDataRequest) };
7859 mMacDataRequest as u64
7860 });
7861 __bindgen_bitfield_unit.set(3usize, 1u8, {
7862 let mMacAck: u8 = unsafe { ::std::mem::transmute(mMacAck) };
7863 mMacAck as u64
7864 });
7865 __bindgen_bitfield_unit
7866 }
7867}
7868#[doc = "< Clear."]
7869pub const OT_LINK_METRICS_ENH_ACK_CLEAR: otLinkMetricsEnhAckFlags = 0;
7870#[doc = "< Register."]
7871pub const OT_LINK_METRICS_ENH_ACK_REGISTER: otLinkMetricsEnhAckFlags = 1;
7872#[doc = " Enhanced-ACK Flags.\n\n These are used in Enhanced-ACK Based Probing to indicate whether to register or clear the probing."]
7873pub type otLinkMetricsEnhAckFlags = ::std::os::raw::c_uint;
7874pub const OT_LINK_METRICS_STATUS_SUCCESS: otLinkMetricsStatus = 0;
7875pub const OT_LINK_METRICS_STATUS_CANNOT_SUPPORT_NEW_SERIES: otLinkMetricsStatus = 1;
7876pub const OT_LINK_METRICS_STATUS_SERIESID_ALREADY_REGISTERED: otLinkMetricsStatus = 2;
7877pub const OT_LINK_METRICS_STATUS_SERIESID_NOT_RECOGNIZED: otLinkMetricsStatus = 3;
7878pub const OT_LINK_METRICS_STATUS_NO_MATCHING_FRAMES_RECEIVED: otLinkMetricsStatus = 4;
7879pub const OT_LINK_METRICS_STATUS_OTHER_ERROR: otLinkMetricsStatus = 254;
7880#[doc = " Link Metrics Status values."]
7881pub type otLinkMetricsStatus = ::std::os::raw::c_uint;
7882#[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."]
7883pub type otLinkMetricsReportCallback = ::std::option::Option<
7884 unsafe extern "C" fn(
7885 aSource: *const otIp6Address,
7886 aMetricsValues: *const otLinkMetricsValues,
7887 aStatus: otLinkMetricsStatus,
7888 aContext: *mut ::std::os::raw::c_void,
7889 ),
7890>;
7891#[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."]
7892pub type otLinkMetricsMgmtResponseCallback = ::std::option::Option<
7893 unsafe extern "C" fn(
7894 aSource: *const otIp6Address,
7895 aStatus: otLinkMetricsStatus,
7896 aContext: *mut ::std::os::raw::c_void,
7897 ),
7898>;
7899#[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."]
7900pub type otLinkMetricsEnhAckProbingIeReportCallback = ::std::option::Option<
7901 unsafe extern "C" fn(
7902 aShortAddress: otShortAddress,
7903 aExtAddress: *const otExtAddress,
7904 aMetricsValues: *const otLinkMetricsValues,
7905 aContext: *mut ::std::os::raw::c_void,
7906 ),
7907>;
7908extern "C" {
7909 #[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."]
7910 pub fn otLinkMetricsQuery(
7911 aInstance: *mut otInstance,
7912 aDestination: *const otIp6Address,
7913 aSeriesId: u8,
7914 aLinkMetricsFlags: *const otLinkMetrics,
7915 aCallback: otLinkMetricsReportCallback,
7916 aCallbackContext: *mut ::std::os::raw::c_void,
7917 ) -> otError;
7918}
7919extern "C" {
7920 #[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."]
7921 pub fn otLinkMetricsConfigForwardTrackingSeries(
7922 aInstance: *mut otInstance,
7923 aDestination: *const otIp6Address,
7924 aSeriesId: u8,
7925 aSeriesFlags: otLinkMetricsSeriesFlags,
7926 aLinkMetricsFlags: *const otLinkMetrics,
7927 aCallback: otLinkMetricsMgmtResponseCallback,
7928 aCallbackContext: *mut ::std::os::raw::c_void,
7929 ) -> otError;
7930}
7931extern "C" {
7932 #[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."]
7933 pub fn otLinkMetricsConfigEnhAckProbing(
7934 aInstance: *mut otInstance,
7935 aDestination: *const otIp6Address,
7936 aEnhAckFlags: otLinkMetricsEnhAckFlags,
7937 aLinkMetricsFlags: *const otLinkMetrics,
7938 aCallback: otLinkMetricsMgmtResponseCallback,
7939 aCallbackContext: *mut ::std::os::raw::c_void,
7940 aEnhAckCallback: otLinkMetricsEnhAckProbingIeReportCallback,
7941 aEnhAckCallbackContext: *mut ::std::os::raw::c_void,
7942 ) -> otError;
7943}
7944extern "C" {
7945 #[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."]
7946 pub fn otLinkMetricsSendLinkProbe(
7947 aInstance: *mut otInstance,
7948 aDestination: *const otIp6Address,
7949 aSeriesId: u8,
7950 aLength: u8,
7951 ) -> otError;
7952}
7953extern "C" {
7954 #[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."]
7955 pub fn otLinkMetricsManagerIsEnabled(aInstance: *mut otInstance) -> bool;
7956}
7957extern "C" {
7958 #[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."]
7959 pub fn otLinkMetricsManagerSetEnabled(aInstance: *mut otInstance, aEnable: bool);
7960}
7961extern "C" {
7962 #[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."]
7963 pub fn otLinkMetricsManagerGetMetricsValueByExtAddr(
7964 aInstance: *mut otInstance,
7965 aExtAddress: *const otExtAddress,
7966 aLinkMetricsValues: *mut otLinkMetricsValues,
7967 ) -> otError;
7968}
7969#[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."]
7970pub type otLinkRawReceiveDone = ::std::option::Option<
7971 unsafe extern "C" fn(aInstance: *mut otInstance, aFrame: *mut otRadioFrame, aError: otError),
7972>;
7973extern "C" {
7974 #[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."]
7975 pub fn otLinkRawSetReceiveDone(
7976 aInstance: *mut otInstance,
7977 aCallback: otLinkRawReceiveDone,
7978 ) -> otError;
7979}
7980extern "C" {
7981 #[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."]
7982 pub fn otLinkRawIsEnabled(aInstance: *mut otInstance) -> bool;
7983}
7984extern "C" {
7985 #[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."]
7986 pub fn otLinkRawGetPromiscuous(aInstance: *mut otInstance) -> bool;
7987}
7988extern "C" {
7989 #[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."]
7990 pub fn otLinkRawSetPromiscuous(aInstance: *mut otInstance, aEnable: bool) -> otError;
7991}
7992extern "C" {
7993 #[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."]
7994 pub fn otLinkRawSetShortAddress(aInstance: *mut otInstance, aShortAddress: u16) -> otError;
7995}
7996extern "C" {
7997 #[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."]
7998 pub fn otLinkRawSetAlternateShortAddress(
7999 aInstance: *mut otInstance,
8000 aShortAddress: otShortAddress,
8001 ) -> otError;
8002}
8003extern "C" {
8004 #[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"]
8005 pub fn otLinkRawSleep(aInstance: *mut otInstance) -> otError;
8006}
8007extern "C" {
8008 #[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."]
8009 pub fn otLinkRawReceive(aInstance: *mut otInstance) -> otError;
8010}
8011extern "C" {
8012 #[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."]
8013 pub fn otLinkRawGetTransmitBuffer(aInstance: *mut otInstance) -> *mut otRadioFrame;
8014}
8015#[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."]
8016pub type otLinkRawTransmitDone = ::std::option::Option<
8017 unsafe extern "C" fn(
8018 aInstance: *mut otInstance,
8019 aFrame: *mut otRadioFrame,
8020 aAckFrame: *mut otRadioFrame,
8021 aError: otError,
8022 ),
8023>;
8024extern "C" {
8025 #[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."]
8026 pub fn otLinkRawTransmit(
8027 aInstance: *mut otInstance,
8028 aCallback: otLinkRawTransmitDone,
8029 ) -> otError;
8030}
8031extern "C" {
8032 #[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."]
8033 pub fn otLinkRawGetRssi(aInstance: *mut otInstance) -> i8;
8034}
8035extern "C" {
8036 #[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."]
8037 pub fn otLinkRawGetCaps(aInstance: *mut otInstance) -> otRadioCaps;
8038}
8039#[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."]
8040pub type otLinkRawEnergyScanDone =
8041 ::std::option::Option<unsafe extern "C" fn(aInstance: *mut otInstance, aEnergyScanMaxRssi: i8)>;
8042extern "C" {
8043 #[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."]
8044 pub fn otLinkRawEnergyScan(
8045 aInstance: *mut otInstance,
8046 aScanChannel: u8,
8047 aScanDuration: u16,
8048 aCallback: otLinkRawEnergyScanDone,
8049 ) -> otError;
8050}
8051extern "C" {
8052 #[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."]
8053 pub fn otLinkRawSrcMatchEnable(aInstance: *mut otInstance, aEnable: bool) -> otError;
8054}
8055extern "C" {
8056 #[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."]
8057 pub fn otLinkRawSrcMatchAddShortEntry(
8058 aInstance: *mut otInstance,
8059 aShortAddress: u16,
8060 ) -> otError;
8061}
8062extern "C" {
8063 #[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."]
8064 pub fn otLinkRawSrcMatchAddExtEntry(
8065 aInstance: *mut otInstance,
8066 aExtAddress: *const otExtAddress,
8067 ) -> otError;
8068}
8069extern "C" {
8070 #[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."]
8071 pub fn otLinkRawSrcMatchClearShortEntry(
8072 aInstance: *mut otInstance,
8073 aShortAddress: u16,
8074 ) -> otError;
8075}
8076extern "C" {
8077 #[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."]
8078 pub fn otLinkRawSrcMatchClearExtEntry(
8079 aInstance: *mut otInstance,
8080 aExtAddress: *const otExtAddress,
8081 ) -> otError;
8082}
8083extern "C" {
8084 #[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."]
8085 pub fn otLinkRawSrcMatchClearShortEntries(aInstance: *mut otInstance) -> otError;
8086}
8087extern "C" {
8088 #[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."]
8089 pub fn otLinkRawSrcMatchClearExtEntries(aInstance: *mut otInstance) -> otError;
8090}
8091extern "C" {
8092 #[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."]
8093 pub fn otLinkRawSetMacKey(
8094 aInstance: *mut otInstance,
8095 aKeyIdMode: u8,
8096 aKeyId: u8,
8097 aPrevKey: *const otMacKey,
8098 aCurrKey: *const otMacKey,
8099 aNextKey: *const otMacKey,
8100 ) -> otError;
8101}
8102extern "C" {
8103 #[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."]
8104 pub fn otLinkRawSetMacFrameCounter(
8105 aInstance: *mut otInstance,
8106 aMacFrameCounter: u32,
8107 ) -> otError;
8108}
8109extern "C" {
8110 #[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."]
8111 pub fn otLinkRawSetMacFrameCounterIfLarger(
8112 aInstance: *mut otInstance,
8113 aMacFrameCounter: u32,
8114 ) -> otError;
8115}
8116extern "C" {
8117 #[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."]
8118 pub fn otLinkRawGetRadioTime(aInstance: *mut otInstance) -> u64;
8119}
8120extern "C" {
8121 #[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."]
8122 pub fn otLoggingGetLevel() -> otLogLevel;
8123}
8124extern "C" {
8125 #[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."]
8126 pub fn otLoggingSetLevel(aLogLevel: otLogLevel) -> otError;
8127}
8128extern "C" {
8129 #[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."]
8130 pub fn otLogCritPlat(aFormat: *const ::std::os::raw::c_char, ...);
8131}
8132extern "C" {
8133 #[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."]
8134 pub fn otLogWarnPlat(aFormat: *const ::std::os::raw::c_char, ...);
8135}
8136extern "C" {
8137 #[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."]
8138 pub fn otLogNotePlat(aFormat: *const ::std::os::raw::c_char, ...);
8139}
8140extern "C" {
8141 #[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."]
8142 pub fn otLogInfoPlat(aFormat: *const ::std::os::raw::c_char, ...);
8143}
8144extern "C" {
8145 #[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."]
8146 pub fn otLogDebgPlat(aFormat: *const ::std::os::raw::c_char, ...);
8147}
8148extern "C" {
8149 #[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."]
8150 pub fn otDumpCritPlat(
8151 aText: *const ::std::os::raw::c_char,
8152 aData: *const ::std::os::raw::c_void,
8153 aDataLength: u16,
8154 );
8155}
8156extern "C" {
8157 #[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."]
8158 pub fn otDumpWarnPlat(
8159 aText: *const ::std::os::raw::c_char,
8160 aData: *const ::std::os::raw::c_void,
8161 aDataLength: u16,
8162 );
8163}
8164extern "C" {
8165 #[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."]
8166 pub fn otDumpNotePlat(
8167 aText: *const ::std::os::raw::c_char,
8168 aData: *const ::std::os::raw::c_void,
8169 aDataLength: u16,
8170 );
8171}
8172extern "C" {
8173 #[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."]
8174 pub fn otDumpInfoPlat(
8175 aText: *const ::std::os::raw::c_char,
8176 aData: *const ::std::os::raw::c_void,
8177 aDataLength: u16,
8178 );
8179}
8180extern "C" {
8181 #[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."]
8182 pub fn otDumpDebgPlat(
8183 aText: *const ::std::os::raw::c_char,
8184 aData: *const ::std::os::raw::c_void,
8185 aDataLength: u16,
8186 );
8187}
8188extern "C" {
8189 #[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."]
8190 pub fn otLogPlat(
8191 aLogLevel: otLogLevel,
8192 aPlatModuleName: *const ::std::os::raw::c_char,
8193 aFormat: *const ::std::os::raw::c_char,
8194 ...
8195 );
8196}
8197extern "C" {
8198 #[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."]
8199 pub fn otLogPlatArgs(
8200 aLogLevel: otLogLevel,
8201 aPlatModuleName: *const ::std::os::raw::c_char,
8202 aFormat: *const ::std::os::raw::c_char,
8203 aArgs: *mut __va_list_tag,
8204 );
8205}
8206extern "C" {
8207 #[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."]
8208 pub fn otLogCli(aLogLevel: otLogLevel, aFormat: *const ::std::os::raw::c_char, ...);
8209}
8210#[doc = " Represents information used for generating hex dump output."]
8211#[repr(C)]
8212#[derive(Debug, Copy, Clone)]
8213pub struct otLogHexDumpInfo {
8214 #[doc = "< The data byes."]
8215 pub mDataBytes: *const u8,
8216 #[doc = "< The data length (number of bytes in @p mDataBytes)"]
8217 pub mDataLength: u16,
8218 #[doc = "< Title string to add table header (MUST NOT be `NULL`)."]
8219 pub mTitle: *const ::std::os::raw::c_char,
8220 #[doc = "< Buffer to output one line of generated hex dump."]
8221 pub mLine: [::std::os::raw::c_char; 73usize],
8222 #[doc = "< Iterator used by OT stack. MUST be initialized to zero."]
8223 pub mIterator: u16,
8224}
8225impl Default for otLogHexDumpInfo {
8226 fn default() -> Self {
8227 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8228 unsafe {
8229 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8230 s.assume_init()
8231 }
8232 }
8233}
8234extern "C" {
8235 #[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."]
8236 pub fn otLogGenerateNextHexDumpLine(aInfo: *mut otLogHexDumpInfo) -> otError;
8237}
8238#[doc = " Represents information associated with a radio link."]
8239#[repr(C)]
8240#[derive(Debug, Default, Copy, Clone)]
8241pub struct otRadioLinkInfo {
8242 #[doc = "< Preference level of radio link"]
8243 pub mPreference: u8,
8244}
8245#[doc = " Represents multi radio link information associated with a neighbor."]
8246#[repr(C)]
8247#[derive(Debug, Default, Copy, Clone)]
8248pub struct otMultiRadioNeighborInfo {
8249 pub _bitfield_align_1: [u8; 0],
8250 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8251 #[doc = "< Additional info for 15.4 radio link (applicable when supported)."]
8252 pub mIeee802154Info: otRadioLinkInfo,
8253 #[doc = "< Additional info for TREL radio link (applicable when supported)."]
8254 pub mTrelUdp6Info: otRadioLinkInfo,
8255}
8256impl otMultiRadioNeighborInfo {
8257 #[inline]
8258 pub fn mSupportsIeee802154(&self) -> bool {
8259 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8260 }
8261 #[inline]
8262 pub fn set_mSupportsIeee802154(&mut self, val: bool) {
8263 unsafe {
8264 let val: u8 = ::std::mem::transmute(val);
8265 self._bitfield_1.set(0usize, 1u8, val as u64)
8266 }
8267 }
8268 #[inline]
8269 pub fn mSupportsTrelUdp6(&self) -> bool {
8270 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8271 }
8272 #[inline]
8273 pub fn set_mSupportsTrelUdp6(&mut self, val: bool) {
8274 unsafe {
8275 let val: u8 = ::std::mem::transmute(val);
8276 self._bitfield_1.set(1usize, 1u8, val as u64)
8277 }
8278 }
8279 #[inline]
8280 pub fn new_bitfield_1(
8281 mSupportsIeee802154: bool,
8282 mSupportsTrelUdp6: bool,
8283 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8284 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8285 __bindgen_bitfield_unit.set(0usize, 1u8, {
8286 let mSupportsIeee802154: u8 = unsafe { ::std::mem::transmute(mSupportsIeee802154) };
8287 mSupportsIeee802154 as u64
8288 });
8289 __bindgen_bitfield_unit.set(1usize, 1u8, {
8290 let mSupportsTrelUdp6: u8 = unsafe { ::std::mem::transmute(mSupportsTrelUdp6) };
8291 mSupportsTrelUdp6 as u64
8292 });
8293 __bindgen_bitfield_unit
8294 }
8295}
8296extern "C" {
8297 #[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."]
8298 pub fn otMultiRadioGetNeighborInfo(
8299 aInstance: *mut otInstance,
8300 aExtAddress: *const otExtAddress,
8301 aNeighborInfo: *mut otMultiRadioNeighborInfo,
8302 ) -> otError;
8303}
8304#[doc = " @struct otIp4Address\n\n Represents an IPv4 address."]
8305#[repr(C, packed)]
8306#[derive(Copy, Clone)]
8307pub struct otIp4Address {
8308 pub mFields: otIp4Address__bindgen_ty_1,
8309}
8310#[repr(C, packed)]
8311#[derive(Copy, Clone)]
8312pub union otIp4Address__bindgen_ty_1 {
8313 #[doc = "< 8-bit fields"]
8314 pub m8: [u8; 4usize],
8315 #[doc = "< 32-bit representation"]
8316 pub m32: u32,
8317}
8318impl Default for otIp4Address__bindgen_ty_1 {
8319 fn default() -> Self {
8320 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8321 unsafe {
8322 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8323 s.assume_init()
8324 }
8325 }
8326}
8327impl Default for otIp4Address {
8328 fn default() -> Self {
8329 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8330 unsafe {
8331 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8332 s.assume_init()
8333 }
8334 }
8335}
8336#[doc = " @struct otIp4Cidr\n\n Represents an IPv4 CIDR block."]
8337#[repr(C)]
8338#[derive(Copy, Clone)]
8339pub struct otIp4Cidr {
8340 pub mAddress: otIp4Address,
8341 pub mLength: u8,
8342}
8343impl Default for otIp4Cidr {
8344 fn default() -> Self {
8345 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8346 unsafe {
8347 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8348 s.assume_init()
8349 }
8350 }
8351}
8352#[doc = " Represents the counters for NAT64."]
8353#[repr(C)]
8354#[derive(Debug, Default, Copy, Clone)]
8355pub struct otNat64Counters {
8356 #[doc = "< Number of packets translated from IPv4 to IPv6."]
8357 pub m4To6Packets: u64,
8358 #[doc = "< Sum of size of packets translated from IPv4 to IPv6."]
8359 pub m4To6Bytes: u64,
8360 #[doc = "< Number of packets translated from IPv6 to IPv4."]
8361 pub m6To4Packets: u64,
8362 #[doc = "< Sum of size of packets translated from IPv6 to IPv4."]
8363 pub m6To4Bytes: u64,
8364}
8365#[doc = " Represents the counters for the protocols supported by NAT64."]
8366#[repr(C)]
8367#[derive(Debug, Default, Copy, Clone)]
8368pub struct otNat64ProtocolCounters {
8369 #[doc = "< Counters for sum of all protocols."]
8370 pub mTotal: otNat64Counters,
8371 #[doc = "< Counters for ICMP and ICMPv6."]
8372 pub mIcmp: otNat64Counters,
8373 #[doc = "< Counters for UDP."]
8374 pub mUdp: otNat64Counters,
8375 #[doc = "< Counters for TCP."]
8376 pub mTcp: otNat64Counters,
8377}
8378#[doc = "< Packet drop for unknown reasons."]
8379pub const OT_NAT64_DROP_REASON_UNKNOWN: otNat64DropReason = 0;
8380#[doc = "< Packet drop due to failed to parse the datagram."]
8381pub const OT_NAT64_DROP_REASON_ILLEGAL_PACKET: otNat64DropReason = 1;
8382#[doc = "< Packet drop due to unsupported IP protocol."]
8383pub const OT_NAT64_DROP_REASON_UNSUPPORTED_PROTO: otNat64DropReason = 2;
8384#[doc = "< Packet drop due to no mappings found or mapping pool exhausted."]
8385pub const OT_NAT64_DROP_REASON_NO_MAPPING: otNat64DropReason = 3;
8386pub const OT_NAT64_DROP_REASON_COUNT: otNat64DropReason = 4;
8387#[doc = " Packet drop reasons."]
8388pub type otNat64DropReason = ::std::os::raw::c_uint;
8389#[doc = " Represents the counters of dropped packets due to errors when handling NAT64 packets."]
8390#[repr(C)]
8391#[derive(Debug, Default, Copy, Clone)]
8392pub struct otNat64ErrorCounters {
8393 #[doc = "< Errors translating IPv4 packets."]
8394 pub mCount4To6: [u64; 4usize],
8395 #[doc = "< Errors translating IPv6 packets."]
8396 pub mCount6To4: [u64; 4usize],
8397}
8398extern "C" {
8399 #[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."]
8400 pub fn otNat64GetCounters(aInstance: *mut otInstance, aCounters: *mut otNat64ProtocolCounters);
8401}
8402extern "C" {
8403 #[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."]
8404 pub fn otNat64GetErrorCounters(
8405 aInstance: *mut otInstance,
8406 aCounters: *mut otNat64ErrorCounters,
8407 );
8408}
8409#[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."]
8410#[repr(C)]
8411#[derive(Copy, Clone)]
8412pub struct otNat64AddressMapping {
8413 #[doc = "< The unique id for a mapping session."]
8414 pub mId: u64,
8415 #[doc = "< The IPv4 address of the mapping."]
8416 pub mIp4: otIp4Address,
8417 #[doc = "< The IPv6 address of the mapping."]
8418 pub mIp6: otIp6Address,
8419 #[doc = " The source port or ICMP ID of the mapping. Used when\n OPENTHREAD_CONFIG_NAT64_PORT_TRANSLATION_ENABLE is true."]
8420 pub mSrcPortOrId: u16,
8421 #[doc = " The translated port or ICMP ID of the mapping. Used when\n OPENTHREAD_CONFIG_NAT64_PORT_TRANSLATION_ENABLE is true."]
8422 pub mTranslatedPortOrId: u16,
8423 #[doc = "< Remaining time before expiry in milliseconds."]
8424 pub mRemainingTimeMs: u32,
8425 pub mCounters: otNat64ProtocolCounters,
8426}
8427impl Default for otNat64AddressMapping {
8428 fn default() -> Self {
8429 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8430 unsafe {
8431 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8432 s.assume_init()
8433 }
8434 }
8435}
8436#[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()`."]
8437#[repr(C)]
8438#[derive(Debug, Copy, Clone)]
8439pub struct otNat64AddressMappingIterator {
8440 pub mPtr: *mut ::std::os::raw::c_void,
8441}
8442impl Default for otNat64AddressMappingIterator {
8443 fn default() -> Self {
8444 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
8445 unsafe {
8446 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
8447 s.assume_init()
8448 }
8449 }
8450}
8451extern "C" {
8452 #[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."]
8453 pub fn otNat64InitAddressMappingIterator(
8454 aInstance: *mut otInstance,
8455 aIterator: *mut otNat64AddressMappingIterator,
8456 );
8457}
8458extern "C" {
8459 #[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."]
8460 pub fn otNat64GetNextAddressMapping(
8461 aInstance: *mut otInstance,
8462 aIterator: *mut otNat64AddressMappingIterator,
8463 aMapping: *mut otNat64AddressMapping,
8464 ) -> otError;
8465}
8466#[doc = "< NAT64 is disabled."]
8467pub const OT_NAT64_STATE_DISABLED: otNat64State = 0;
8468#[doc = "< NAT64 is enabled, but one or more dependencies of NAT64 are not running."]
8469pub const OT_NAT64_STATE_NOT_RUNNING: otNat64State = 1;
8470#[doc = "< NAT64 is enabled, but this BR is not an active NAT64 BR."]
8471pub const OT_NAT64_STATE_IDLE: otNat64State = 2;
8472#[doc = "< The BR is publishing a NAT64 prefix and/or translating packets."]
8473pub const OT_NAT64_STATE_ACTIVE: otNat64State = 3;
8474#[doc = " States of NAT64."]
8475pub type otNat64State = ::std::os::raw::c_uint;
8476extern "C" {
8477 #[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."]
8478 pub fn otNat64GetTranslatorState(aInstance: *mut otInstance) -> otNat64State;
8479}
8480extern "C" {
8481 #[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."]
8482 pub fn otNat64GetPrefixManagerState(aInstance: *mut otInstance) -> otNat64State;
8483}
8484extern "C" {
8485 #[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"]
8486 pub fn otNat64SetEnabled(aInstance: *mut otInstance, aEnabled: bool);
8487}
8488extern "C" {
8489 #[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"]
8490 pub fn otIp4NewMessage(
8491 aInstance: *mut otInstance,
8492 aSettings: *const otMessageSettings,
8493 ) -> *mut otMessage;
8494}
8495extern "C" {
8496 #[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"]
8497 pub fn otNat64SetIp4Cidr(aInstance: *mut otInstance, aCidr: *const otIp4Cidr) -> otError;
8498}
8499extern "C" {
8500 #[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"]
8501 pub fn otNat64ClearIp4Cidr(aInstance: *mut otInstance);
8502}
8503extern "C" {
8504 #[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."]
8505 pub fn otNat64Send(aInstance: *mut otInstance, aMessage: *mut otMessage) -> otError;
8506}
8507#[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."]
8508pub type otNat64ReceiveIp4Callback = ::std::option::Option<
8509 unsafe extern "C" fn(aMessage: *mut otMessage, aContext: *mut ::std::os::raw::c_void),
8510>;
8511extern "C" {
8512 #[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."]
8513 pub fn otNat64SetReceiveIp4Callback(
8514 aInstance: *mut otInstance,
8515 aCallback: otNat64ReceiveIp4Callback,
8516 aContext: *mut ::std::os::raw::c_void,
8517 );
8518}
8519extern "C" {
8520 #[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."]
8521 pub fn otNat64GetCidr(aInstance: *mut otInstance, aCidr: *mut otIp4Cidr) -> otError;
8522}
8523extern "C" {
8524 #[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."]
8525 pub fn otIp4IsAddressEqual(aFirst: *const otIp4Address, aSecond: *const otIp4Address) -> bool;
8526}
8527extern "C" {
8528 #[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."]
8529 pub fn otIp4ExtractFromIp6Address(
8530 aPrefixLength: u8,
8531 aIp6Address: *const otIp6Address,
8532 aIp4Address: *mut otIp4Address,
8533 );
8534}
8535extern "C" {
8536 #[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."]
8537 pub fn otIp4FromIp4MappedIp6Address(
8538 aIp6Address: *const otIp6Address,
8539 aIp4Address: *mut otIp4Address,
8540 ) -> otError;
8541}
8542extern "C" {
8543 #[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."]
8544 pub fn otIp4ToIp4MappedIp6Address(
8545 aIp4Address: *const otIp4Address,
8546 aIp6Address: *mut otIp6Address,
8547 );
8548}
8549extern "C" {
8550 #[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 NULL).\n @param[in] aSize The size of @p aBuffer (in bytes)."]
8551 pub fn otIp4AddressToString(
8552 aAddress: *const otIp4Address,
8553 aBuffer: *mut ::std::os::raw::c_char,
8554 aSize: u16,
8555 );
8556}
8557extern "C" {
8558 #[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."]
8559 pub fn otIp4CidrFromString(
8560 aString: *const ::std::os::raw::c_char,
8561 aCidr: *mut otIp4Cidr,
8562 ) -> otError;
8563}
8564extern "C" {
8565 #[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 NULL).\n @param[in] aSize The size of @p aBuffer (in bytes)."]
8566 pub fn otIp4CidrToString(
8567 aCidr: *const otIp4Cidr,
8568 aBuffer: *mut ::std::os::raw::c_char,
8569 aSize: u16,
8570 );
8571}
8572extern "C" {
8573 #[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."]
8574 pub fn otIp4AddressFromString(
8575 aString: *const ::std::os::raw::c_char,
8576 aAddress: *mut otIp4Address,
8577 ) -> otError;
8578}
8579extern "C" {
8580 #[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."]
8581 pub fn otNat64SynthesizeIp6Address(
8582 aInstance: *mut otInstance,
8583 aIp4Address: *const otIp4Address,
8584 aIp6Address: *mut otIp6Address,
8585 ) -> otError;
8586}
8587#[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."]
8588pub type otNcpHdlcSendCallback = ::std::option::Option<
8589 unsafe extern "C" fn(aBuf: *const u8, aBufLength: u16) -> ::std::os::raw::c_int,
8590>;
8591extern "C" {
8592 #[doc = " Is called after NCP send finished."]
8593 pub fn otNcpHdlcSendDone();
8594}
8595extern "C" {
8596 #[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."]
8597 pub fn otNcpHdlcReceive(aBuf: *const u8, aBufLength: u16);
8598}
8599extern "C" {
8600 #[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."]
8601 pub fn otNcpHdlcInit(aInstance: *mut otInstance, aSendCallback: otNcpHdlcSendCallback);
8602}
8603extern "C" {
8604 #[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."]
8605 pub fn otNcpHdlcInitMulti(
8606 aInstance: *mut *mut otInstance,
8607 aCount: u8,
8608 aSendCallback: otNcpHdlcSendCallback,
8609 );
8610}
8611extern "C" {
8612 #[doc = " Initialize the NCP based on SPI framing.\n\n @param[in] aInstance The OpenThread instance structure."]
8613 pub fn otNcpSpiInit(aInstance: *mut otInstance);
8614}
8615extern "C" {
8616 #[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."]
8617 pub fn otNcpStreamWrite(
8618 aStreamId: ::std::os::raw::c_int,
8619 aDataPtr: *const u8,
8620 aDataLen: ::std::os::raw::c_int,
8621 ) -> otError;
8622}
8623extern "C" {
8624 #[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."]
8625 pub fn otNcpPlatLogv(
8626 aLogLevel: otLogLevel,
8627 aLogRegion: otLogRegion,
8628 aFormat: *const ::std::os::raw::c_char,
8629 aArgs: *mut __va_list_tag,
8630 );
8631}
8632#[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."]
8633pub type otNcpDelegateAllowPeekPoke =
8634 ::std::option::Option<unsafe extern "C" fn(aAddress: u32, aCount: u16) -> bool>;
8635extern "C" {
8636 #[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."]
8637 pub fn otNcpRegisterPeekPokeDelegates(
8638 aAllowPeekDelegate: otNcpDelegateAllowPeekPoke,
8639 aAllowPokeDelegate: otNcpDelegateAllowPeekPoke,
8640 );
8641}
8642#[doc = "< The Thread stack is disabled."]
8643pub const OT_DEVICE_ROLE_DISABLED: otDeviceRole = 0;
8644#[doc = "< Not currently participating in a Thread network/partition."]
8645pub const OT_DEVICE_ROLE_DETACHED: otDeviceRole = 1;
8646#[doc = "< The Thread Child role."]
8647pub const OT_DEVICE_ROLE_CHILD: otDeviceRole = 2;
8648#[doc = "< The Thread Router role."]
8649pub const OT_DEVICE_ROLE_ROUTER: otDeviceRole = 3;
8650#[doc = "< The Thread Leader role."]
8651pub const OT_DEVICE_ROLE_LEADER: otDeviceRole = 4;
8652#[doc = " Represents a Thread device role."]
8653pub type otDeviceRole = ::std::os::raw::c_uint;
8654#[doc = " Represents an MLE Link Mode configuration."]
8655#[repr(C, packed)]
8656#[derive(Debug, Default, Copy, Clone)]
8657pub struct otLinkModeConfig {
8658 pub _bitfield_align_1: [u8; 0],
8659 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8660}
8661impl otLinkModeConfig {
8662 #[inline]
8663 pub fn mRxOnWhenIdle(&self) -> bool {
8664 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8665 }
8666 #[inline]
8667 pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
8668 unsafe {
8669 let val: u8 = ::std::mem::transmute(val);
8670 self._bitfield_1.set(0usize, 1u8, val as u64)
8671 }
8672 }
8673 #[inline]
8674 pub fn mDeviceType(&self) -> bool {
8675 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8676 }
8677 #[inline]
8678 pub fn set_mDeviceType(&mut self, val: bool) {
8679 unsafe {
8680 let val: u8 = ::std::mem::transmute(val);
8681 self._bitfield_1.set(1usize, 1u8, val as u64)
8682 }
8683 }
8684 #[inline]
8685 pub fn mNetworkData(&self) -> bool {
8686 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
8687 }
8688 #[inline]
8689 pub fn set_mNetworkData(&mut self, val: bool) {
8690 unsafe {
8691 let val: u8 = ::std::mem::transmute(val);
8692 self._bitfield_1.set(2usize, 1u8, val as u64)
8693 }
8694 }
8695 #[inline]
8696 pub fn new_bitfield_1(
8697 mRxOnWhenIdle: bool,
8698 mDeviceType: bool,
8699 mNetworkData: bool,
8700 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8701 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8702 __bindgen_bitfield_unit.set(0usize, 1u8, {
8703 let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
8704 mRxOnWhenIdle as u64
8705 });
8706 __bindgen_bitfield_unit.set(1usize, 1u8, {
8707 let mDeviceType: u8 = unsafe { ::std::mem::transmute(mDeviceType) };
8708 mDeviceType as u64
8709 });
8710 __bindgen_bitfield_unit.set(2usize, 1u8, {
8711 let mNetworkData: u8 = unsafe { ::std::mem::transmute(mNetworkData) };
8712 mNetworkData as u64
8713 });
8714 __bindgen_bitfield_unit
8715 }
8716}
8717#[doc = " Holds diagnostic information for a neighboring Thread node"]
8718#[repr(C)]
8719#[derive(Debug, Default, Copy, Clone)]
8720pub struct otNeighborInfo {
8721 #[doc = "< IEEE 802.15.4 Extended Address"]
8722 pub mExtAddress: otExtAddress,
8723 #[doc = "< Seconds since last heard"]
8724 pub mAge: u32,
8725 #[doc = "< Seconds since link establishment (requires `CONFIG_UPTIME_ENABLE`)"]
8726 pub mConnectionTime: u32,
8727 #[doc = "< RLOC16"]
8728 pub mRloc16: u16,
8729 #[doc = "< Link Frame Counter"]
8730 pub mLinkFrameCounter: u32,
8731 #[doc = "< MLE Frame Counter"]
8732 pub mMleFrameCounter: u32,
8733 #[doc = "< Link Quality In"]
8734 pub mLinkQualityIn: u8,
8735 #[doc = "< Average RSSI"]
8736 pub mAverageRssi: i8,
8737 #[doc = "< Last observed RSSI"]
8738 pub mLastRssi: i8,
8739 #[doc = "< Link Margin"]
8740 pub mLinkMargin: u8,
8741 #[doc = "< Frame error rate (0xffff->100%). Requires error tracking feature."]
8742 pub mFrameErrorRate: u16,
8743 #[doc = "< (IPv6) msg error rate (0xffff->100%). Requires error tracking feature."]
8744 pub mMessageErrorRate: u16,
8745 #[doc = "< Thread version of the neighbor"]
8746 pub mVersion: u16,
8747 pub _bitfield_align_1: [u8; 0],
8748 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8749 pub __bindgen_padding_0: u8,
8750}
8751impl otNeighborInfo {
8752 #[inline]
8753 pub fn mRxOnWhenIdle(&self) -> bool {
8754 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8755 }
8756 #[inline]
8757 pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
8758 unsafe {
8759 let val: u8 = ::std::mem::transmute(val);
8760 self._bitfield_1.set(0usize, 1u8, val as u64)
8761 }
8762 }
8763 #[inline]
8764 pub fn mFullThreadDevice(&self) -> bool {
8765 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8766 }
8767 #[inline]
8768 pub fn set_mFullThreadDevice(&mut self, val: bool) {
8769 unsafe {
8770 let val: u8 = ::std::mem::transmute(val);
8771 self._bitfield_1.set(1usize, 1u8, val as u64)
8772 }
8773 }
8774 #[inline]
8775 pub fn mFullNetworkData(&self) -> bool {
8776 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
8777 }
8778 #[inline]
8779 pub fn set_mFullNetworkData(&mut self, val: bool) {
8780 unsafe {
8781 let val: u8 = ::std::mem::transmute(val);
8782 self._bitfield_1.set(2usize, 1u8, val as u64)
8783 }
8784 }
8785 #[inline]
8786 pub fn mIsChild(&self) -> bool {
8787 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
8788 }
8789 #[inline]
8790 pub fn set_mIsChild(&mut self, val: bool) {
8791 unsafe {
8792 let val: u8 = ::std::mem::transmute(val);
8793 self._bitfield_1.set(3usize, 1u8, val as u64)
8794 }
8795 }
8796 #[inline]
8797 pub fn new_bitfield_1(
8798 mRxOnWhenIdle: bool,
8799 mFullThreadDevice: bool,
8800 mFullNetworkData: bool,
8801 mIsChild: bool,
8802 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8803 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8804 __bindgen_bitfield_unit.set(0usize, 1u8, {
8805 let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
8806 mRxOnWhenIdle as u64
8807 });
8808 __bindgen_bitfield_unit.set(1usize, 1u8, {
8809 let mFullThreadDevice: u8 = unsafe { ::std::mem::transmute(mFullThreadDevice) };
8810 mFullThreadDevice as u64
8811 });
8812 __bindgen_bitfield_unit.set(2usize, 1u8, {
8813 let mFullNetworkData: u8 = unsafe { ::std::mem::transmute(mFullNetworkData) };
8814 mFullNetworkData as u64
8815 });
8816 __bindgen_bitfield_unit.set(3usize, 1u8, {
8817 let mIsChild: u8 = unsafe { ::std::mem::transmute(mIsChild) };
8818 mIsChild as u64
8819 });
8820 __bindgen_bitfield_unit
8821 }
8822}
8823pub type otNeighborInfoIterator = i16;
8824#[doc = " Represents the Thread Leader Data."]
8825#[repr(C)]
8826#[derive(Debug, Default, Copy, Clone)]
8827pub struct otLeaderData {
8828 #[doc = "< Partition ID"]
8829 pub mPartitionId: u32,
8830 #[doc = "< Leader Weight"]
8831 pub mWeighting: u8,
8832 #[doc = "< Full Network Data Version"]
8833 pub mDataVersion: u8,
8834 #[doc = "< Stable Network Data Version"]
8835 pub mStableDataVersion: u8,
8836 #[doc = "< Leader Router ID"]
8837 pub mLeaderRouterId: u8,
8838}
8839#[doc = " Holds diagnostic information for a Thread Router"]
8840#[repr(C)]
8841#[derive(Debug, Default, Copy, Clone)]
8842pub struct otRouterInfo {
8843 #[doc = "< IEEE 802.15.4 Extended Address"]
8844 pub mExtAddress: otExtAddress,
8845 #[doc = "< RLOC16"]
8846 pub mRloc16: u16,
8847 #[doc = "< Router ID"]
8848 pub mRouterId: u8,
8849 #[doc = "< Next hop to router"]
8850 pub mNextHop: u8,
8851 #[doc = "< Path cost to router"]
8852 pub mPathCost: u8,
8853 #[doc = "< Link Quality In"]
8854 pub mLinkQualityIn: u8,
8855 #[doc = "< Link Quality Out"]
8856 pub mLinkQualityOut: u8,
8857 #[doc = "< Time last heard"]
8858 pub mAge: u8,
8859 pub _bitfield_align_1: [u8; 0],
8860 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
8861 #[doc = "< Thread version"]
8862 pub mVersion: u8,
8863 #[doc = "< CSL clock accuracy, in ± ppm"]
8864 pub mCslClockAccuracy: u8,
8865 #[doc = "< CSL uncertainty, in ±10 us"]
8866 pub mCslUncertainty: u8,
8867}
8868impl otRouterInfo {
8869 #[inline]
8870 pub fn mAllocated(&self) -> bool {
8871 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
8872 }
8873 #[inline]
8874 pub fn set_mAllocated(&mut self, val: bool) {
8875 unsafe {
8876 let val: u8 = ::std::mem::transmute(val);
8877 self._bitfield_1.set(0usize, 1u8, val as u64)
8878 }
8879 }
8880 #[inline]
8881 pub fn mLinkEstablished(&self) -> bool {
8882 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
8883 }
8884 #[inline]
8885 pub fn set_mLinkEstablished(&mut self, val: bool) {
8886 unsafe {
8887 let val: u8 = ::std::mem::transmute(val);
8888 self._bitfield_1.set(1usize, 1u8, val as u64)
8889 }
8890 }
8891 #[inline]
8892 pub fn new_bitfield_1(
8893 mAllocated: bool,
8894 mLinkEstablished: bool,
8895 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
8896 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
8897 __bindgen_bitfield_unit.set(0usize, 1u8, {
8898 let mAllocated: u8 = unsafe { ::std::mem::transmute(mAllocated) };
8899 mAllocated as u64
8900 });
8901 __bindgen_bitfield_unit.set(1usize, 1u8, {
8902 let mLinkEstablished: u8 = unsafe { ::std::mem::transmute(mLinkEstablished) };
8903 mLinkEstablished as u64
8904 });
8905 __bindgen_bitfield_unit
8906 }
8907}
8908#[doc = " Represents the IP level counters."]
8909#[repr(C)]
8910#[derive(Debug, Default, Copy, Clone)]
8911pub struct otIpCounters {
8912 #[doc = "< The number of IPv6 packets successfully transmitted."]
8913 pub mTxSuccess: u32,
8914 #[doc = "< The number of IPv6 packets successfully received."]
8915 pub mRxSuccess: u32,
8916 #[doc = "< The number of IPv6 packets failed to transmit."]
8917 pub mTxFailure: u32,
8918 #[doc = "< The number of IPv6 packets failed to receive."]
8919 pub mRxFailure: u32,
8920}
8921#[doc = " Represents the Thread MLE counters."]
8922#[repr(C)]
8923#[derive(Debug, Default, Copy, Clone)]
8924pub struct otMleCounters {
8925 #[doc = "< Number of times device entered OT_DEVICE_ROLE_DISABLED role."]
8926 pub mDisabledRole: u16,
8927 #[doc = "< Number of times device entered OT_DEVICE_ROLE_DETACHED role."]
8928 pub mDetachedRole: u16,
8929 #[doc = "< Number of times device entered OT_DEVICE_ROLE_CHILD role."]
8930 pub mChildRole: u16,
8931 #[doc = "< Number of times device entered OT_DEVICE_ROLE_ROUTER role."]
8932 pub mRouterRole: u16,
8933 #[doc = "< Number of times device entered OT_DEVICE_ROLE_LEADER role."]
8934 pub mLeaderRole: u16,
8935 #[doc = "< Number of attach attempts while device was detached."]
8936 pub mAttachAttempts: u16,
8937 #[doc = "< Number of changes to partition ID."]
8938 pub mPartitionIdChanges: u16,
8939 #[doc = "< Number of attempts to attach to a better partition."]
8940 pub mBetterPartitionAttachAttempts: u16,
8941 #[doc = "< Number of attempts to attach to find a better parent (parent search)."]
8942 pub mBetterParentAttachAttempts: u16,
8943 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_DISABLED role."]
8944 pub mDisabledTime: u64,
8945 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_DETACHED role."]
8946 pub mDetachedTime: u64,
8947 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_CHILD role."]
8948 pub mChildTime: u64,
8949 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_ROUTER role."]
8950 pub mRouterTime: u64,
8951 #[doc = "< Number of milliseconds device has been in OT_DEVICE_ROLE_LEADER role."]
8952 pub mLeaderTime: u64,
8953 #[doc = "< Number of milliseconds tracked by previous counters."]
8954 pub mTrackedTime: u64,
8955 #[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)."]
8956 pub mParentChanges: u16,
8957}
8958#[doc = " Represents the MLE Parent Response data."]
8959#[repr(C)]
8960#[derive(Debug, Default, Copy, Clone)]
8961pub struct otThreadParentResponseInfo {
8962 #[doc = "< IEEE 802.15.4 Extended Address of the Parent"]
8963 pub mExtAddr: otExtAddress,
8964 #[doc = "< Short address of the Parent"]
8965 pub mRloc16: u16,
8966 #[doc = "< Rssi of the Parent"]
8967 pub mRssi: i8,
8968 #[doc = "< Parent priority"]
8969 pub mPriority: i8,
8970 #[doc = "< Parent Link Quality 3"]
8971 pub mLinkQuality3: u8,
8972 #[doc = "< Parent Link Quality 2"]
8973 pub mLinkQuality2: u8,
8974 #[doc = "< Parent Link Quality 1"]
8975 pub mLinkQuality1: u8,
8976 #[doc = "< Is the node receiving parent response attached"]
8977 pub mIsAttached: bool,
8978}
8979#[doc = " This callback informs the application that the detaching process has finished.\n\n @param[in] aContext A pointer to application-specific context."]
8980pub type otDetachGracefullyCallback =
8981 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
8982#[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."]
8983pub type otWakeupCallback = ::std::option::Option<
8984 unsafe extern "C" fn(aError: otError, aContext: *mut ::std::os::raw::c_void),
8985>;
8986extern "C" {
8987 #[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."]
8988 pub fn otThreadSetEnabled(aInstance: *mut otInstance, aEnabled: bool) -> otError;
8989}
8990extern "C" {
8991 #[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."]
8992 pub fn otThreadGetVersion() -> u16;
8993}
8994extern "C" {
8995 #[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."]
8996 pub fn otThreadIsSingleton(aInstance: *mut otInstance) -> bool;
8997}
8998extern "C" {
8999 #[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."]
9000 pub fn otThreadDiscover(
9001 aInstance: *mut otInstance,
9002 aScanChannels: u32,
9003 aPanId: u16,
9004 aJoiner: bool,
9005 aEnableEui64Filtering: bool,
9006 aCallback: otHandleActiveScanResult,
9007 aCallbackContext: *mut ::std::os::raw::c_void,
9008 ) -> otError;
9009}
9010extern "C" {
9011 #[doc = " Determines if an MLE Thread Discovery is currently in progress.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
9012 pub fn otThreadIsDiscoverInProgress(aInstance: *mut otInstance) -> bool;
9013}
9014extern "C" {
9015 #[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."]
9016 pub fn otThreadSetJoinerAdvertisement(
9017 aInstance: *mut otInstance,
9018 aOui: u32,
9019 aAdvData: *const u8,
9020 aAdvDataLength: u8,
9021 ) -> otError;
9022}
9023extern "C" {
9024 #[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"]
9025 pub fn otThreadGetChildTimeout(aInstance: *mut otInstance) -> u32;
9026}
9027extern "C" {
9028 #[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"]
9029 pub fn otThreadSetChildTimeout(aInstance: *mut otInstance, aTimeout: u32);
9030}
9031extern "C" {
9032 #[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"]
9033 pub fn otThreadGetExtendedPanId(aInstance: *mut otInstance) -> *const otExtendedPanId;
9034}
9035extern "C" {
9036 #[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"]
9037 pub fn otThreadSetExtendedPanId(
9038 aInstance: *mut otInstance,
9039 aExtendedPanId: *const otExtendedPanId,
9040 ) -> otError;
9041}
9042extern "C" {
9043 #[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."]
9044 pub fn otThreadGetLeaderRloc(
9045 aInstance: *mut otInstance,
9046 aLeaderRloc: *mut otIp6Address,
9047 ) -> otError;
9048}
9049extern "C" {
9050 #[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"]
9051 pub fn otThreadGetLinkMode(aInstance: *mut otInstance) -> otLinkModeConfig;
9052}
9053extern "C" {
9054 #[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"]
9055 pub fn otThreadSetLinkMode(aInstance: *mut otInstance, aConfig: otLinkModeConfig) -> otError;
9056}
9057extern "C" {
9058 #[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"]
9059 pub fn otThreadGetNetworkKey(aInstance: *mut otInstance, aNetworkKey: *mut otNetworkKey);
9060}
9061extern "C" {
9062 #[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"]
9063 pub fn otThreadGetNetworkKeyRef(aInstance: *mut otInstance) -> otNetworkKeyRef;
9064}
9065extern "C" {
9066 #[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"]
9067 pub fn otThreadSetNetworkKey(aInstance: *mut otInstance, aKey: *const otNetworkKey) -> otError;
9068}
9069extern "C" {
9070 #[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"]
9071 pub fn otThreadSetNetworkKeyRef(
9072 aInstance: *mut otInstance,
9073 aKeyRef: otNetworkKeyRef,
9074 ) -> otError;
9075}
9076extern "C" {
9077 #[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."]
9078 pub fn otThreadGetRloc(aInstance: *mut otInstance) -> *const otIp6Address;
9079}
9080extern "C" {
9081 #[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."]
9082 pub fn otThreadGetMeshLocalEid(aInstance: *mut otInstance) -> *const otIp6Address;
9083}
9084extern "C" {
9085 #[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."]
9086 pub fn otThreadGetMeshLocalPrefix(aInstance: *mut otInstance) -> *const otMeshLocalPrefix;
9087}
9088extern "C" {
9089 #[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."]
9090 pub fn otThreadSetMeshLocalPrefix(
9091 aInstance: *mut otInstance,
9092 aMeshLocalPrefix: *const otMeshLocalPrefix,
9093 ) -> otError;
9094}
9095extern "C" {
9096 #[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."]
9097 pub fn otThreadGetLinkLocalIp6Address(aInstance: *mut otInstance) -> *const otIp6Address;
9098}
9099extern "C" {
9100 #[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."]
9101 pub fn otThreadGetLinkLocalAllThreadNodesMulticastAddress(
9102 aInstance: *mut otInstance,
9103 ) -> *const otIp6Address;
9104}
9105extern "C" {
9106 #[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."]
9107 pub fn otThreadGetRealmLocalAllThreadNodesMulticastAddress(
9108 aInstance: *mut otInstance,
9109 ) -> *const otIp6Address;
9110}
9111extern "C" {
9112 #[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."]
9113 pub fn otThreadGetServiceAloc(
9114 aInstance: *mut otInstance,
9115 aServiceId: u8,
9116 aServiceAloc: *mut otIp6Address,
9117 ) -> otError;
9118}
9119extern "C" {
9120 #[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"]
9121 pub fn otThreadGetNetworkName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9122}
9123extern "C" {
9124 #[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"]
9125 pub fn otThreadSetNetworkName(
9126 aInstance: *mut otInstance,
9127 aNetworkName: *const ::std::os::raw::c_char,
9128 ) -> otError;
9129}
9130extern "C" {
9131 #[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"]
9132 pub fn otThreadGetDomainName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9133}
9134extern "C" {
9135 #[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"]
9136 pub fn otThreadSetDomainName(
9137 aInstance: *mut otInstance,
9138 aDomainName: *const ::std::os::raw::c_char,
9139 ) -> otError;
9140}
9141extern "C" {
9142 #[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"]
9143 pub fn otThreadSetFixedDuaInterfaceIdentifier(
9144 aInstance: *mut otInstance,
9145 aIid: *const otIp6InterfaceIdentifier,
9146 ) -> otError;
9147}
9148extern "C" {
9149 #[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"]
9150 pub fn otThreadGetFixedDuaInterfaceIdentifier(
9151 aInstance: *mut otInstance,
9152 ) -> *const otIp6InterfaceIdentifier;
9153}
9154extern "C" {
9155 #[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"]
9156 pub fn otThreadGetKeySequenceCounter(aInstance: *mut otInstance) -> u32;
9157}
9158extern "C" {
9159 #[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"]
9160 pub fn otThreadSetKeySequenceCounter(aInstance: *mut otInstance, aKeySequenceCounter: u32);
9161}
9162extern "C" {
9163 #[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"]
9164 pub fn otThreadGetKeySwitchGuardTime(aInstance: *mut otInstance) -> u16;
9165}
9166extern "C" {
9167 #[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"]
9168 pub fn otThreadSetKeySwitchGuardTime(aInstance: *mut otInstance, aKeySwitchGuardTime: u16);
9169}
9170extern "C" {
9171 #[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."]
9172 pub fn otThreadBecomeDetached(aInstance: *mut otInstance) -> otError;
9173}
9174extern "C" {
9175 #[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."]
9176 pub fn otThreadBecomeChild(aInstance: *mut otInstance) -> otError;
9177}
9178extern "C" {
9179 #[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."]
9180 pub fn otThreadGetNextNeighborInfo(
9181 aInstance: *mut otInstance,
9182 aIterator: *mut otNeighborInfoIterator,
9183 aInfo: *mut otNeighborInfo,
9184 ) -> otError;
9185}
9186extern "C" {
9187 #[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."]
9188 pub fn otThreadGetDeviceRole(aInstance: *mut otInstance) -> otDeviceRole;
9189}
9190extern "C" {
9191 #[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."]
9192 pub fn otThreadDeviceRoleToString(aRole: otDeviceRole) -> *const ::std::os::raw::c_char;
9193}
9194extern "C" {
9195 #[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."]
9196 pub fn otThreadGetLeaderData(
9197 aInstance: *mut otInstance,
9198 aLeaderData: *mut otLeaderData,
9199 ) -> otError;
9200}
9201extern "C" {
9202 #[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."]
9203 pub fn otThreadGetLeaderRouterId(aInstance: *mut otInstance) -> u8;
9204}
9205extern "C" {
9206 #[doc = " Get the Leader's Weight.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Leader's Weight."]
9207 pub fn otThreadGetLeaderWeight(aInstance: *mut otInstance) -> u8;
9208}
9209extern "C" {
9210 #[doc = " Get the Partition ID.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The Partition ID."]
9211 pub fn otThreadGetPartitionId(aInstance: *mut otInstance) -> u32;
9212}
9213extern "C" {
9214 #[doc = " Get the RLOC16.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The RLOC16."]
9215 pub fn otThreadGetRloc16(aInstance: *mut otInstance) -> u16;
9216}
9217extern "C" {
9218 #[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."]
9219 pub fn otThreadGetParentInfo(
9220 aInstance: *mut otInstance,
9221 aParentInfo: *mut otRouterInfo,
9222 ) -> otError;
9223}
9224extern "C" {
9225 #[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."]
9226 pub fn otThreadGetParentAverageRssi(
9227 aInstance: *mut otInstance,
9228 aParentRssi: *mut i8,
9229 ) -> otError;
9230}
9231extern "C" {
9232 #[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."]
9233 pub fn otThreadGetParentLastRssi(aInstance: *mut otInstance, aLastRssi: *mut i8) -> otError;
9234}
9235extern "C" {
9236 #[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."]
9237 pub fn otThreadSearchForBetterParent(aInstance: *mut otInstance) -> otError;
9238}
9239extern "C" {
9240 #[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."]
9241 pub fn otThreadGetIp6Counters(aInstance: *mut otInstance) -> *const otIpCounters;
9242}
9243extern "C" {
9244 #[doc = " Resets the IPv6 counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
9245 pub fn otThreadResetIp6Counters(aInstance: *mut otInstance);
9246}
9247extern "C" {
9248 #[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."]
9249 pub fn otThreadGetTimeInQueueHistogram(
9250 aInstance: *mut otInstance,
9251 aNumBins: *mut u16,
9252 aBinInterval: *mut u32,
9253 ) -> *const u32;
9254}
9255extern "C" {
9256 #[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)."]
9257 pub fn otThreadGetMaxTimeInQueue(aInstance: *mut otInstance) -> u32;
9258}
9259extern "C" {
9260 #[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."]
9261 pub fn otThreadResetTimeInQueueStat(aInstance: *mut otInstance);
9262}
9263extern "C" {
9264 #[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."]
9265 pub fn otThreadGetMleCounters(aInstance: *mut otInstance) -> *const otMleCounters;
9266}
9267extern "C" {
9268 #[doc = " Resets the Thread MLE counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
9269 pub fn otThreadResetMleCounters(aInstance: *mut otInstance);
9270}
9271extern "C" {
9272 #[doc = " Gets the current attach duration (number of seconds since the device last attached).\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."]
9273 pub fn otThreadGetCurrentAttachDuration(aInstance: *mut otInstance) -> u32;
9274}
9275#[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."]
9276pub type otThreadParentResponseCallback = ::std::option::Option<
9277 unsafe extern "C" fn(
9278 aInfo: *mut otThreadParentResponseInfo,
9279 aContext: *mut ::std::os::raw::c_void,
9280 ),
9281>;
9282extern "C" {
9283 #[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."]
9284 pub fn otThreadRegisterParentResponseCallback(
9285 aInstance: *mut otInstance,
9286 aCallback: otThreadParentResponseCallback,
9287 aContext: *mut ::std::os::raw::c_void,
9288 );
9289}
9290#[doc = " Represents the Thread Discovery Request data."]
9291#[repr(C)]
9292#[derive(Debug, Default, Copy, Clone)]
9293pub struct otThreadDiscoveryRequestInfo {
9294 #[doc = "< IEEE 802.15.4 Extended Address of the requester"]
9295 pub mExtAddress: otExtAddress,
9296 pub _bitfield_align_1: [u8; 0],
9297 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
9298}
9299impl otThreadDiscoveryRequestInfo {
9300 #[inline]
9301 pub fn mVersion(&self) -> u8 {
9302 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 4u8) as u8) }
9303 }
9304 #[inline]
9305 pub fn set_mVersion(&mut self, val: u8) {
9306 unsafe {
9307 let val: u8 = ::std::mem::transmute(val);
9308 self._bitfield_1.set(0usize, 4u8, val as u64)
9309 }
9310 }
9311 #[inline]
9312 pub fn mIsJoiner(&self) -> bool {
9313 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
9314 }
9315 #[inline]
9316 pub fn set_mIsJoiner(&mut self, val: bool) {
9317 unsafe {
9318 let val: u8 = ::std::mem::transmute(val);
9319 self._bitfield_1.set(4usize, 1u8, val as u64)
9320 }
9321 }
9322 #[inline]
9323 pub fn new_bitfield_1(mVersion: u8, mIsJoiner: bool) -> __BindgenBitfieldUnit<[u8; 1usize]> {
9324 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
9325 __bindgen_bitfield_unit.set(0usize, 4u8, {
9326 let mVersion: u8 = unsafe { ::std::mem::transmute(mVersion) };
9327 mVersion as u64
9328 });
9329 __bindgen_bitfield_unit.set(4usize, 1u8, {
9330 let mIsJoiner: u8 = unsafe { ::std::mem::transmute(mIsJoiner) };
9331 mIsJoiner as u64
9332 });
9333 __bindgen_bitfield_unit
9334 }
9335}
9336#[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."]
9337pub type otThreadDiscoveryRequestCallback = ::std::option::Option<
9338 unsafe extern "C" fn(
9339 aInfo: *const otThreadDiscoveryRequestInfo,
9340 aContext: *mut ::std::os::raw::c_void,
9341 ),
9342>;
9343extern "C" {
9344 #[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."]
9345 pub fn otThreadSetDiscoveryRequestCallback(
9346 aInstance: *mut otInstance,
9347 aCallback: otThreadDiscoveryRequestCallback,
9348 aContext: *mut ::std::os::raw::c_void,
9349 );
9350}
9351#[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)."]
9352pub type otThreadAnycastLocatorCallback = ::std::option::Option<
9353 unsafe extern "C" fn(
9354 aContext: *mut ::std::os::raw::c_void,
9355 aError: otError,
9356 aMeshLocalAddress: *const otIp6Address,
9357 aRloc16: u16,
9358 ),
9359>;
9360extern "C" {
9361 #[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."]
9362 pub fn otThreadLocateAnycastDestination(
9363 aInstance: *mut otInstance,
9364 aAnycastAddress: *const otIp6Address,
9365 aCallback: otThreadAnycastLocatorCallback,
9366 aContext: *mut ::std::os::raw::c_void,
9367 ) -> otError;
9368}
9369extern "C" {
9370 #[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."]
9371 pub fn otThreadIsAnycastLocateInProgress(aInstance: *mut otInstance) -> bool;
9372}
9373extern "C" {
9374 #[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."]
9375 pub fn otThreadSendAddressNotification(
9376 aInstance: *mut otInstance,
9377 aDestination: *mut otIp6Address,
9378 aTarget: *mut otIp6Address,
9379 aMlIid: *mut otIp6InterfaceIdentifier,
9380 );
9381}
9382extern "C" {
9383 #[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."]
9384 pub fn otThreadSendProactiveBackboneNotification(
9385 aInstance: *mut otInstance,
9386 aTarget: *mut otIp6Address,
9387 aMlIid: *mut otIp6InterfaceIdentifier,
9388 aTimeSinceLastTransaction: u32,
9389 ) -> otError;
9390}
9391extern "C" {
9392 #[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."]
9393 pub fn otThreadDetachGracefully(
9394 aInstance: *mut otInstance,
9395 aCallback: otDetachGracefullyCallback,
9396 aContext: *mut ::std::os::raw::c_void,
9397 ) -> otError;
9398}
9399extern "C" {
9400 #[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`."]
9401 pub fn otConvertDurationInSecondsToString(
9402 aDuration: u32,
9403 aBuffer: *mut ::std::os::raw::c_char,
9404 aSize: u16,
9405 );
9406}
9407extern "C" {
9408 #[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."]
9409 pub fn otThreadSetStoreFrameCounterAhead(
9410 aInstance: *mut otInstance,
9411 aStoreFrameCounterAhead: u32,
9412 );
9413}
9414extern "C" {
9415 #[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."]
9416 pub fn otThreadGetStoreFrameCounterAhead(aInstance: *mut otInstance) -> u32;
9417}
9418extern "C" {
9419 #[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."]
9420 pub fn otThreadWakeup(
9421 aInstance: *mut otInstance,
9422 aWedAddress: *const otExtAddress,
9423 aWakeupIntervalUs: u16,
9424 aWakeupDurationMs: u16,
9425 aCallback: otWakeupCallback,
9426 aCallbackContext: *mut ::std::os::raw::c_void,
9427 ) -> otError;
9428}
9429pub type otNetworkDiagIterator = u16;
9430#[doc = " Represents a Network Diagnostic Connectivity value."]
9431#[repr(C)]
9432#[derive(Debug, Default, Copy, Clone)]
9433pub struct otNetworkDiagConnectivity {
9434 #[doc = "< The priority of the sender as a parent."]
9435 pub mParentPriority: i8,
9436 #[doc = "< Number of neighbors with link of quality 3."]
9437 pub mLinkQuality3: u8,
9438 #[doc = "< Number of neighbors with link of quality 2."]
9439 pub mLinkQuality2: u8,
9440 #[doc = "< Number of neighbors with link of quality 1."]
9441 pub mLinkQuality1: u8,
9442 #[doc = "< Cost to the Leader."]
9443 pub mLeaderCost: u8,
9444 #[doc = "< Most recent received ID seq number."]
9445 pub mIdSequence: u8,
9446 #[doc = "< Number of active routers."]
9447 pub mActiveRouters: u8,
9448 #[doc = "< Buffer capacity in bytes for SEDs. Optional."]
9449 pub mSedBufferSize: u16,
9450 #[doc = "< Queue capacity (number of IPv6 datagrams) per SED. Optional."]
9451 pub mSedDatagramCount: u8,
9452}
9453#[doc = " Represents a Network Diagnostic Route data."]
9454#[repr(C)]
9455#[derive(Debug, Default, Copy, Clone)]
9456pub struct otNetworkDiagRouteData {
9457 #[doc = "< The Assigned Router ID."]
9458 pub mRouterId: u8,
9459 pub _bitfield_align_1: [u8; 0],
9460 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
9461}
9462impl otNetworkDiagRouteData {
9463 #[inline]
9464 pub fn mLinkQualityOut(&self) -> u8 {
9465 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 2u8) as u8) }
9466 }
9467 #[inline]
9468 pub fn set_mLinkQualityOut(&mut self, val: u8) {
9469 unsafe {
9470 let val: u8 = ::std::mem::transmute(val);
9471 self._bitfield_1.set(0usize, 2u8, val as u64)
9472 }
9473 }
9474 #[inline]
9475 pub fn mLinkQualityIn(&self) -> u8 {
9476 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) }
9477 }
9478 #[inline]
9479 pub fn set_mLinkQualityIn(&mut self, val: u8) {
9480 unsafe {
9481 let val: u8 = ::std::mem::transmute(val);
9482 self._bitfield_1.set(2usize, 2u8, val as u64)
9483 }
9484 }
9485 #[inline]
9486 pub fn mRouteCost(&self) -> u8 {
9487 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 4u8) as u8) }
9488 }
9489 #[inline]
9490 pub fn set_mRouteCost(&mut self, val: u8) {
9491 unsafe {
9492 let val: u8 = ::std::mem::transmute(val);
9493 self._bitfield_1.set(4usize, 4u8, val as u64)
9494 }
9495 }
9496 #[inline]
9497 pub fn new_bitfield_1(
9498 mLinkQualityOut: u8,
9499 mLinkQualityIn: u8,
9500 mRouteCost: u8,
9501 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
9502 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
9503 __bindgen_bitfield_unit.set(0usize, 2u8, {
9504 let mLinkQualityOut: u8 = unsafe { ::std::mem::transmute(mLinkQualityOut) };
9505 mLinkQualityOut as u64
9506 });
9507 __bindgen_bitfield_unit.set(2usize, 2u8, {
9508 let mLinkQualityIn: u8 = unsafe { ::std::mem::transmute(mLinkQualityIn) };
9509 mLinkQualityIn as u64
9510 });
9511 __bindgen_bitfield_unit.set(4usize, 4u8, {
9512 let mRouteCost: u8 = unsafe { ::std::mem::transmute(mRouteCost) };
9513 mRouteCost as u64
9514 });
9515 __bindgen_bitfield_unit
9516 }
9517}
9518#[doc = " Represents a Network Diagnostic Route64 TLV value."]
9519#[repr(C)]
9520#[derive(Debug, Copy, Clone)]
9521pub struct otNetworkDiagRoute {
9522 #[doc = "< Sequence number for Router ID assignments."]
9523 pub mIdSequence: u8,
9524 #[doc = "< Number of routes."]
9525 pub mRouteCount: u8,
9526 #[doc = "< Link Quality and Routing Cost data."]
9527 pub mRouteData: [otNetworkDiagRouteData; 63usize],
9528}
9529impl Default for otNetworkDiagRoute {
9530 fn default() -> Self {
9531 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9532 unsafe {
9533 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9534 s.assume_init()
9535 }
9536 }
9537}
9538#[doc = " Represents a Network Diagnostic Enhanced Route data."]
9539#[repr(C)]
9540#[derive(Debug, Default, Copy, Clone)]
9541pub struct otNetworkDiagEnhRouteData {
9542 #[doc = "< The Router ID."]
9543 pub mRouterId: u8,
9544 pub _bitfield_align_1: [u8; 0],
9545 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
9546 #[doc = " The next hop Router ID tracked towards this router.\n\n This field indicates the next hop router towards `mRouterId` when using multi-hop forwarding.\n\n If the device has no direct link with the router (`mHasLink == false`), this field indicates the next hop router\n that would be used to forward messages destined to `mRouterId`.\n\n If the device has a direct link with the router (`mHasLink == true`), this field indicates the alternate\n multi-hop path that may be used. Note that whether the direct link or this alternate path through the next hop\n is used to forward messages depends on their associated total path costs.\n\n If there is no next hop, then `OT_NETWORK_MAX_ROUTER_ID + 1` is used."]
9547 pub mNextHop: u8,
9548 #[doc = " The route cost associated with forwarding to `mRouterId` using `mNextHop` (when valid).\n\n This is the route cost `mNextHop` has claimed to have towards `mRouterId`. Importantly, it does not include the\n link cost to send to `mNextHop` itself."]
9549 pub mNextHopCost: u8,
9550}
9551impl otNetworkDiagEnhRouteData {
9552 #[inline]
9553 pub fn mIsSelf(&self) -> bool {
9554 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
9555 }
9556 #[inline]
9557 pub fn set_mIsSelf(&mut self, val: bool) {
9558 unsafe {
9559 let val: u8 = ::std::mem::transmute(val);
9560 self._bitfield_1.set(0usize, 1u8, val as u64)
9561 }
9562 }
9563 #[inline]
9564 pub fn mHasLink(&self) -> bool {
9565 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
9566 }
9567 #[inline]
9568 pub fn set_mHasLink(&mut self, val: bool) {
9569 unsafe {
9570 let val: u8 = ::std::mem::transmute(val);
9571 self._bitfield_1.set(1usize, 1u8, val as u64)
9572 }
9573 }
9574 #[inline]
9575 pub fn mLinkQualityOut(&self) -> u8 {
9576 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 2u8) as u8) }
9577 }
9578 #[inline]
9579 pub fn set_mLinkQualityOut(&mut self, val: u8) {
9580 unsafe {
9581 let val: u8 = ::std::mem::transmute(val);
9582 self._bitfield_1.set(2usize, 2u8, val as u64)
9583 }
9584 }
9585 #[inline]
9586 pub fn mLinkQualityIn(&self) -> u8 {
9587 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 2u8) as u8) }
9588 }
9589 #[inline]
9590 pub fn set_mLinkQualityIn(&mut self, val: u8) {
9591 unsafe {
9592 let val: u8 = ::std::mem::transmute(val);
9593 self._bitfield_1.set(4usize, 2u8, val as u64)
9594 }
9595 }
9596 #[inline]
9597 pub fn new_bitfield_1(
9598 mIsSelf: bool,
9599 mHasLink: bool,
9600 mLinkQualityOut: u8,
9601 mLinkQualityIn: u8,
9602 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
9603 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
9604 __bindgen_bitfield_unit.set(0usize, 1u8, {
9605 let mIsSelf: u8 = unsafe { ::std::mem::transmute(mIsSelf) };
9606 mIsSelf as u64
9607 });
9608 __bindgen_bitfield_unit.set(1usize, 1u8, {
9609 let mHasLink: u8 = unsafe { ::std::mem::transmute(mHasLink) };
9610 mHasLink as u64
9611 });
9612 __bindgen_bitfield_unit.set(2usize, 2u8, {
9613 let mLinkQualityOut: u8 = unsafe { ::std::mem::transmute(mLinkQualityOut) };
9614 mLinkQualityOut as u64
9615 });
9616 __bindgen_bitfield_unit.set(4usize, 2u8, {
9617 let mLinkQualityIn: u8 = unsafe { ::std::mem::transmute(mLinkQualityIn) };
9618 mLinkQualityIn as u64
9619 });
9620 __bindgen_bitfield_unit
9621 }
9622}
9623#[doc = " Represents a Network Diagnostic Enhanced Route TLV value."]
9624#[repr(C)]
9625#[derive(Debug, Copy, Clone)]
9626pub struct otNetworkDiagEnhRoute {
9627 #[doc = "< Number of `mRouteData` entries."]
9628 pub mRouteCount: u8,
9629 #[doc = "< Route Data per router."]
9630 pub mRouteData: [otNetworkDiagEnhRouteData; 63usize],
9631}
9632impl Default for otNetworkDiagEnhRoute {
9633 fn default() -> Self {
9634 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9635 unsafe {
9636 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9637 s.assume_init()
9638 }
9639 }
9640}
9641#[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."]
9642#[repr(C)]
9643#[derive(Debug, Default, Copy, Clone)]
9644pub struct otNetworkDiagMacCounters {
9645 pub mIfInUnknownProtos: u32,
9646 pub mIfInErrors: u32,
9647 pub mIfOutErrors: u32,
9648 pub mIfInUcastPkts: u32,
9649 pub mIfInBroadcastPkts: u32,
9650 pub mIfInDiscards: u32,
9651 pub mIfOutUcastPkts: u32,
9652 pub mIfOutBroadcastPkts: u32,
9653 pub mIfOutDiscards: u32,
9654}
9655#[doc = " Represents a Network Diagnostics MLE Counters value."]
9656#[repr(C)]
9657#[derive(Debug, Default, Copy, Clone)]
9658pub struct otNetworkDiagMleCounters {
9659 #[doc = "< Number of times device entered disabled role."]
9660 pub mDisabledRole: u16,
9661 #[doc = "< Number of times device entered detached role."]
9662 pub mDetachedRole: u16,
9663 #[doc = "< Number of times device entered child role."]
9664 pub mChildRole: u16,
9665 #[doc = "< Number of times device entered router role."]
9666 pub mRouterRole: u16,
9667 #[doc = "< Number of times device entered leader role."]
9668 pub mLeaderRole: u16,
9669 #[doc = "< Number of attach attempts while device was detached."]
9670 pub mAttachAttempts: u16,
9671 #[doc = "< Number of changes to partition ID."]
9672 pub mPartitionIdChanges: u16,
9673 #[doc = "< Number of attempts to attach to a better partition."]
9674 pub mBetterPartitionAttachAttempts: u16,
9675 #[doc = "< Number of time device changed its parent."]
9676 pub mParentChanges: u16,
9677 #[doc = "< Milliseconds tracked by next counters (zero if not supported)."]
9678 pub mTrackedTime: u64,
9679 #[doc = "< Milliseconds device has been in disabled role."]
9680 pub mDisabledTime: u64,
9681 #[doc = "< Milliseconds device has been in detached role."]
9682 pub mDetachedTime: u64,
9683 #[doc = "< Milliseconds device has been in child role."]
9684 pub mChildTime: u64,
9685 #[doc = "< Milliseconds device has been in router role."]
9686 pub mRouterTime: u64,
9687 #[doc = "< Milliseconds device has been in leader role."]
9688 pub mLeaderTime: u64,
9689}
9690#[doc = " Represents a Network Diagnostic Child Table Entry."]
9691#[repr(C)]
9692#[repr(align(2))]
9693#[derive(Debug, Default, Copy, Clone)]
9694pub struct otNetworkDiagChildEntry {
9695 pub _bitfield_align_1: [u16; 0],
9696 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 2usize]>,
9697 #[doc = "< Link mode."]
9698 pub mMode: otLinkModeConfig,
9699}
9700impl otNetworkDiagChildEntry {
9701 #[inline]
9702 pub fn mTimeout(&self) -> u16 {
9703 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 5u8) as u16) }
9704 }
9705 #[inline]
9706 pub fn set_mTimeout(&mut self, val: u16) {
9707 unsafe {
9708 let val: u16 = ::std::mem::transmute(val);
9709 self._bitfield_1.set(0usize, 5u8, val as u64)
9710 }
9711 }
9712 #[inline]
9713 pub fn mLinkQuality(&self) -> u8 {
9714 unsafe { ::std::mem::transmute(self._bitfield_1.get(5usize, 2u8) as u8) }
9715 }
9716 #[inline]
9717 pub fn set_mLinkQuality(&mut self, val: u8) {
9718 unsafe {
9719 let val: u8 = ::std::mem::transmute(val);
9720 self._bitfield_1.set(5usize, 2u8, val as u64)
9721 }
9722 }
9723 #[inline]
9724 pub fn mChildId(&self) -> u16 {
9725 unsafe { ::std::mem::transmute(self._bitfield_1.get(7usize, 9u8) as u16) }
9726 }
9727 #[inline]
9728 pub fn set_mChildId(&mut self, val: u16) {
9729 unsafe {
9730 let val: u16 = ::std::mem::transmute(val);
9731 self._bitfield_1.set(7usize, 9u8, val as u64)
9732 }
9733 }
9734 #[inline]
9735 pub fn new_bitfield_1(
9736 mTimeout: u16,
9737 mLinkQuality: u8,
9738 mChildId: u16,
9739 ) -> __BindgenBitfieldUnit<[u8; 2usize]> {
9740 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 2usize]> = Default::default();
9741 __bindgen_bitfield_unit.set(0usize, 5u8, {
9742 let mTimeout: u16 = unsafe { ::std::mem::transmute(mTimeout) };
9743 mTimeout as u64
9744 });
9745 __bindgen_bitfield_unit.set(5usize, 2u8, {
9746 let mLinkQuality: u8 = unsafe { ::std::mem::transmute(mLinkQuality) };
9747 mLinkQuality as u64
9748 });
9749 __bindgen_bitfield_unit.set(7usize, 9u8, {
9750 let mChildId: u16 = unsafe { ::std::mem::transmute(mChildId) };
9751 mChildId as u64
9752 });
9753 __bindgen_bitfield_unit
9754 }
9755}
9756#[doc = " Represents a Network Diagnostic TLV."]
9757#[repr(C)]
9758#[derive(Copy, Clone)]
9759pub struct otNetworkDiagTlv {
9760 #[doc = "< The Network Diagnostic TLV type."]
9761 pub mType: u8,
9762 pub mData: otNetworkDiagTlv__bindgen_ty_1,
9763}
9764#[repr(C)]
9765#[derive(Copy, Clone)]
9766pub union otNetworkDiagTlv__bindgen_ty_1 {
9767 pub mExtAddress: otExtAddress,
9768 pub mEui64: otExtAddress,
9769 pub mAddr16: u16,
9770 pub mMode: otLinkModeConfig,
9771 pub mTimeout: u32,
9772 pub mConnectivity: otNetworkDiagConnectivity,
9773 pub mRoute: otNetworkDiagRoute,
9774 pub mEnhRoute: otNetworkDiagEnhRoute,
9775 pub mLeaderData: otLeaderData,
9776 pub mMacCounters: otNetworkDiagMacCounters,
9777 pub mMleCounters: otNetworkDiagMleCounters,
9778 pub mBatteryLevel: u8,
9779 pub mSupplyVoltage: u16,
9780 pub mMaxChildTimeout: u32,
9781 pub mVersion: u16,
9782 pub mVendorName: [::std::os::raw::c_char; 33usize],
9783 pub mVendorModel: [::std::os::raw::c_char; 33usize],
9784 pub mVendorSwVersion: [::std::os::raw::c_char; 17usize],
9785 pub mThreadStackVersion: [::std::os::raw::c_char; 65usize],
9786 pub mVendorAppUrl: [::std::os::raw::c_char; 97usize],
9787 pub mNonPreferredChannels: otChannelMask,
9788 pub mNetworkData: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1,
9789 pub mIp6AddrList: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2,
9790 pub mChildTable: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3,
9791 pub mChannelPages: otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4,
9792}
9793#[repr(C)]
9794#[derive(Debug, Copy, Clone)]
9795pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1 {
9796 pub mCount: u8,
9797 pub m8: [u8; 254usize],
9798}
9799impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_1 {
9800 fn default() -> Self {
9801 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9802 unsafe {
9803 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9804 s.assume_init()
9805 }
9806 }
9807}
9808#[repr(C)]
9809#[derive(Copy, Clone)]
9810pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2 {
9811 pub mCount: u8,
9812 pub mList: [otIp6Address; 15usize],
9813}
9814impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_2 {
9815 fn default() -> Self {
9816 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9817 unsafe {
9818 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9819 s.assume_init()
9820 }
9821 }
9822}
9823#[repr(C)]
9824#[derive(Debug, Copy, Clone)]
9825pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3 {
9826 pub mCount: u8,
9827 pub mTable: [otNetworkDiagChildEntry; 63usize],
9828}
9829impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_3 {
9830 fn default() -> Self {
9831 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9832 unsafe {
9833 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9834 s.assume_init()
9835 }
9836 }
9837}
9838#[repr(C)]
9839#[derive(Debug, Copy, Clone)]
9840pub struct otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4 {
9841 pub mCount: u8,
9842 pub m8: [u8; 254usize],
9843}
9844impl Default for otNetworkDiagTlv__bindgen_ty_1__bindgen_ty_4 {
9845 fn default() -> Self {
9846 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9847 unsafe {
9848 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9849 s.assume_init()
9850 }
9851 }
9852}
9853impl Default for otNetworkDiagTlv__bindgen_ty_1 {
9854 fn default() -> Self {
9855 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9856 unsafe {
9857 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9858 s.assume_init()
9859 }
9860 }
9861}
9862impl Default for otNetworkDiagTlv {
9863 fn default() -> Self {
9864 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
9865 unsafe {
9866 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
9867 s.assume_init()
9868 }
9869 }
9870}
9871extern "C" {
9872 #[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."]
9873 pub fn otThreadGetNextDiagnosticTlv(
9874 aMessage: *const otMessage,
9875 aIterator: *mut otNetworkDiagIterator,
9876 aNetworkDiagTlv: *mut otNetworkDiagTlv,
9877 ) -> otError;
9878}
9879#[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."]
9880pub type otReceiveDiagnosticGetCallback = ::std::option::Option<
9881 unsafe extern "C" fn(
9882 aError: otError,
9883 aMessage: *mut otMessage,
9884 aMessageInfo: *const otMessageInfo,
9885 aContext: *mut ::std::os::raw::c_void,
9886 ),
9887>;
9888extern "C" {
9889 #[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."]
9890 pub fn otThreadSendDiagnosticGet(
9891 aInstance: *mut otInstance,
9892 aDestination: *const otIp6Address,
9893 aTlvTypes: *const u8,
9894 aCount: u8,
9895 aCallback: otReceiveDiagnosticGetCallback,
9896 aCallbackContext: *mut ::std::os::raw::c_void,
9897 ) -> otError;
9898}
9899extern "C" {
9900 #[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."]
9901 pub fn otThreadSendDiagnosticReset(
9902 aInstance: *mut otInstance,
9903 aDestination: *const otIp6Address,
9904 aTlvTypes: *const u8,
9905 aCount: u8,
9906 ) -> otError;
9907}
9908extern "C" {
9909 #[doc = " Get the vendor name string.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The vendor name string."]
9910 pub fn otThreadGetVendorName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9911}
9912extern "C" {
9913 #[doc = " Get the vendor model string.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n\n @returns The vendor model string."]
9914 pub fn otThreadGetVendorModel(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9915}
9916extern "C" {
9917 #[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."]
9918 pub fn otThreadGetVendorSwVersion(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9919}
9920extern "C" {
9921 #[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."]
9922 pub fn otThreadGetVendorAppUrl(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
9923}
9924extern "C" {
9925 #[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)."]
9926 pub fn otThreadSetVendorName(
9927 aInstance: *mut otInstance,
9928 aVendorName: *const ::std::os::raw::c_char,
9929 ) -> otError;
9930}
9931extern "C" {
9932 #[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)."]
9933 pub fn otThreadSetVendorModel(
9934 aInstance: *mut otInstance,
9935 aVendorModel: *const ::std::os::raw::c_char,
9936 ) -> otError;
9937}
9938extern "C" {
9939 #[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)."]
9940 pub fn otThreadSetVendorSwVersion(
9941 aInstance: *mut otInstance,
9942 aVendorSwVersion: *const ::std::os::raw::c_char,
9943 ) -> otError;
9944}
9945extern "C" {
9946 #[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)."]
9947 pub fn otThreadSetVendorAppUrl(
9948 aInstance: *mut otInstance,
9949 aVendorAppUrl: *const ::std::os::raw::c_char,
9950 ) -> otError;
9951}
9952#[doc = " Callback function pointer to notify when a Network Diagnostic Reset request message is received for the\n `OT_NETWORK_DIAGNOSTIC_TLV_NON_PREFERRED_CHANNELS` TLV.\n\n This is used to inform the device to reevaluate the channels that are presently included in the non-preferred\n channels list and update it if needed based on the reevaluation.\n\n @param[in] aContext A pointer to application-specific context."]
9953pub type otThreadNonPreferredChannelsResetCallback =
9954 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
9955extern "C" {
9956 #[doc = " Sets the non-preferred channels value for `OT_NETWORK_DIAGNOSTIC_TLV_NON_PREFERRED_CHANNELS` TLV.\n\n This value is used to respond to a Network Diagnostic Get request for this TLV.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aChannelMask A channel mask specifying the non-preferred channels."]
9957 pub fn otThreadSetNonPreferredChannels(aInstance: *mut otInstance, aChannelMask: otChannelMask);
9958}
9959extern "C" {
9960 #[doc = " Gets the non-preferred channels for `OT_NETWORK_DIAGNOSTIC_TLV_NON_PREFERRED_CHANNELS` TLV.\n\n @returns The non-preferred channels as a channel mask."]
9961 pub fn otThreadGetNonPreferredChannels(aInstance: *mut otInstance) -> otChannelMask;
9962}
9963extern "C" {
9964 #[doc = " Sets the callback to notify when a Network Diagnostic Reset request message is received for the\n `OT_NETWORK_DIAGNOSTIC_TLV_NON_PREFERRED_CHANNELS` TLV.\n\n A subsequent call to this function will replace the previously set callback.\n\n @param[in] aInstance A pointer to an OpenThread instance.\n @param[in] aCallback The callback function pointer. Can be NULL.\n @param[in] aContext A pointer to application-specific context used with @p aCallback."]
9965 pub fn otThreadSetNonPreferredChannelsResetCallback(
9966 aInstance: *mut otInstance,
9967 aCallback: otThreadNonPreferredChannelsResetCallback,
9968 aContext: *mut ::std::os::raw::c_void,
9969 );
9970}
9971#[doc = "< The device hasn't attached to a network."]
9972pub const OT_NETWORK_TIME_UNSYNCHRONIZED: otNetworkTimeStatus = -1;
9973#[doc = "< The device hasn’t received time sync for more than two periods time."]
9974pub const OT_NETWORK_TIME_RESYNC_NEEDED: otNetworkTimeStatus = 0;
9975#[doc = "< The device network time is synchronized."]
9976pub const OT_NETWORK_TIME_SYNCHRONIZED: otNetworkTimeStatus = 1;
9977#[doc = " Represents OpenThread time synchronization status."]
9978pub type otNetworkTimeStatus = ::std::os::raw::c_int;
9979#[doc = " Pointer is called when a network time sync or status change occurs."]
9980pub type otNetworkTimeSyncCallbackFn =
9981 ::std::option::Option<unsafe extern "C" fn(aCallbackContext: *mut ::std::os::raw::c_void)>;
9982extern "C" {
9983 #[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."]
9984 pub fn otNetworkTimeGet(
9985 aInstance: *mut otInstance,
9986 aNetworkTime: *mut u64,
9987 ) -> otNetworkTimeStatus;
9988}
9989extern "C" {
9990 #[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."]
9991 pub fn otNetworkTimeSetSyncPeriod(aInstance: *mut otInstance, aTimeSyncPeriod: u16) -> otError;
9992}
9993extern "C" {
9994 #[doc = " Get the time synchronization period.\n\n @param[in] aInstance The OpenThread instance structure.\n\n @returns The time synchronization period."]
9995 pub fn otNetworkTimeGetSyncPeriod(aInstance: *mut otInstance) -> u16;
9996}
9997extern "C" {
9998 #[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."]
9999 pub fn otNetworkTimeSetXtalThreshold(
10000 aInstance: *mut otInstance,
10001 aXTALThreshold: u16,
10002 ) -> otError;
10003}
10004extern "C" {
10005 #[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."]
10006 pub fn otNetworkTimeGetXtalThreshold(aInstance: *mut otInstance) -> u16;
10007}
10008extern "C" {
10009 #[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"]
10010 pub fn otNetworkTimeSyncSetCallback(
10011 aInstance: *mut otInstance,
10012 aCallbackFn: otNetworkTimeSyncCallbackFn,
10013 aCallbackContext: *mut ::std::os::raw::c_void,
10014 );
10015}
10016#[doc = " Represents a ping reply."]
10017#[repr(C)]
10018#[derive(Copy, Clone)]
10019pub struct otPingSenderReply {
10020 #[doc = "< Sender IPv6 address (address from which ping reply was received)."]
10021 pub mSenderAddress: otIp6Address,
10022 #[doc = "< Round trip time in msec."]
10023 pub mRoundTripTime: u16,
10024 #[doc = "< Data size (number of bytes) in reply (excluding IPv6 and ICMP6 headers)."]
10025 pub mSize: u16,
10026 #[doc = "< Sequence number."]
10027 pub mSequenceNumber: u16,
10028 #[doc = "< Hop limit."]
10029 pub mHopLimit: u8,
10030}
10031impl Default for otPingSenderReply {
10032 fn default() -> Self {
10033 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10034 unsafe {
10035 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10036 s.assume_init()
10037 }
10038 }
10039}
10040#[doc = " Represents statistics of a ping request."]
10041#[repr(C)]
10042#[derive(Debug, Default, Copy, Clone)]
10043pub struct otPingSenderStatistics {
10044 #[doc = "< The number of ping requests already sent."]
10045 pub mSentCount: u16,
10046 #[doc = "< The number of ping replies received."]
10047 pub mReceivedCount: u16,
10048 #[doc = "< The total round trip time of ping requests."]
10049 pub mTotalRoundTripTime: u32,
10050 #[doc = "< The min round trip time among ping requests."]
10051 pub mMinRoundTripTime: u16,
10052 #[doc = "< The max round trip time among ping requests."]
10053 pub mMaxRoundTripTime: u16,
10054 #[doc = "< Whether this is a multicast ping request."]
10055 pub mIsMulticast: bool,
10056}
10057#[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."]
10058pub type otPingSenderReplyCallback = ::std::option::Option<
10059 unsafe extern "C" fn(aReply: *const otPingSenderReply, aContext: *mut ::std::os::raw::c_void),
10060>;
10061#[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."]
10062pub type otPingSenderStatisticsCallback = ::std::option::Option<
10063 unsafe extern "C" fn(
10064 aStatistics: *const otPingSenderStatistics,
10065 aContext: *mut ::std::os::raw::c_void,
10066 ),
10067>;
10068#[doc = " Represents a ping request configuration."]
10069#[repr(C)]
10070#[derive(Copy, Clone)]
10071pub struct otPingSenderConfig {
10072 #[doc = "< Source address of the ping."]
10073 pub mSource: otIp6Address,
10074 #[doc = "< Destination address to ping."]
10075 pub mDestination: otIp6Address,
10076 #[doc = "< Callback function to report replies (can be NULL if not needed)."]
10077 pub mReplyCallback: otPingSenderReplyCallback,
10078 #[doc = "< Callback function to report statistics (can be NULL if not needed)."]
10079 pub mStatisticsCallback: otPingSenderStatisticsCallback,
10080 #[doc = "< A pointer to the callback application-specific context."]
10081 pub mCallbackContext: *mut ::std::os::raw::c_void,
10082 #[doc = "< Data size (# of bytes) excludes IPv6/ICMPv6 header. Zero for default."]
10083 pub mSize: u16,
10084 #[doc = "< Number of ping messages to send. Zero to use default."]
10085 pub mCount: u16,
10086 #[doc = "< Ping tx interval in milliseconds. Zero to use default."]
10087 pub mInterval: u32,
10088 #[doc = "< Time in milliseconds to wait for final reply after sending final request.\n< Zero to use default."]
10089 pub mTimeout: u16,
10090 #[doc = "< Hop limit (used if `mAllowZeroHopLimit` is false). Zero for default."]
10091 pub mHopLimit: u8,
10092 #[doc = "< Indicates whether hop limit is zero."]
10093 pub mAllowZeroHopLimit: bool,
10094 #[doc = "< Allow looping back pings to multicast address that device is subscribed to."]
10095 pub mMulticastLoop: bool,
10096}
10097impl Default for otPingSenderConfig {
10098 fn default() -> Self {
10099 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10100 unsafe {
10101 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10102 s.assume_init()
10103 }
10104 }
10105}
10106extern "C" {
10107 #[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"]
10108 pub fn otPingSenderPing(
10109 aInstance: *mut otInstance,
10110 aConfig: *const otPingSenderConfig,
10111 ) -> otError;
10112}
10113extern "C" {
10114 #[doc = " Stops an ongoing ping.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
10115 pub fn otPingSenderStop(aInstance: *mut otInstance);
10116}
10117extern "C" {
10118 #[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."]
10119 pub fn otPlatAlarmMicroStartAt(aInstance: *mut otInstance, aT0: u32, aDt: u32);
10120}
10121extern "C" {
10122 #[doc = " Stop the alarm.\n\n @param[in] aInstance The OpenThread instance structure."]
10123 pub fn otPlatAlarmMicroStop(aInstance: *mut otInstance);
10124}
10125extern "C" {
10126 #[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."]
10127 pub fn otPlatAlarmMicroGetNow() -> u32;
10128}
10129extern "C" {
10130 #[doc = " Signal that the alarm has fired.\n\n @param[in] aInstance The OpenThread instance structure."]
10131 pub fn otPlatAlarmMicroFired(aInstance: *mut otInstance);
10132}
10133extern "C" {
10134 #[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."]
10135 pub fn otPlatAlarmMilliStartAt(aInstance: *mut otInstance, aT0: u32, aDt: u32);
10136}
10137extern "C" {
10138 #[doc = " Stop the alarm.\n\n @param[in] aInstance The OpenThread instance structure."]
10139 pub fn otPlatAlarmMilliStop(aInstance: *mut otInstance);
10140}
10141extern "C" {
10142 #[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."]
10143 pub fn otPlatAlarmMilliGetNow() -> u32;
10144}
10145extern "C" {
10146 #[doc = " Signal that the alarm has fired.\n\n @param[in] aInstance The OpenThread instance structure."]
10147 pub fn otPlatAlarmMilliFired(aInstance: *mut otInstance);
10148}
10149extern "C" {
10150 #[doc = " Signal diagnostics module that the alarm has fired.\n\n @param[in] aInstance The OpenThread instance structure."]
10151 pub fn otPlatDiagAlarmFired(aInstance: *mut otInstance);
10152}
10153extern "C" {
10154 #[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."]
10155 pub fn otPlatBorderRoutingProcessIcmp6Ra(
10156 aInstance: *mut otInstance,
10157 aMessage: *const u8,
10158 aLength: u16,
10159 );
10160}
10161extern "C" {
10162 #[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"]
10163 pub fn otPlatBorderRoutingProcessDhcp6PdPrefix(
10164 aInstance: *mut otInstance,
10165 aPrefixInfo: *const otBorderRoutingPrefixTableEntry,
10166 );
10167}
10168extern "C" {
10169 #[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."]
10170 pub fn otPlatDebugUart_printf(fmt: *const ::std::os::raw::c_char, ...);
10171}
10172extern "C" {
10173 #[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."]
10174 pub fn otPlatDebugUart_vprintf(fmt: *const ::std::os::raw::c_char, ap: *mut __va_list_tag);
10175}
10176extern "C" {
10177 #[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"]
10178 pub fn otPlatDebugUart_putchar_raw(c: ::std::os::raw::c_int);
10179}
10180extern "C" {
10181 #[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."]
10182 pub fn otPlatDebugUart_kbhit() -> ::std::os::raw::c_int;
10183}
10184extern "C" {
10185 #[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"]
10186 pub fn otPlatDebugUart_getc() -> ::std::os::raw::c_int;
10187}
10188extern "C" {
10189 #[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"]
10190 pub fn otPlatDebugUart_putchar(c: ::std::os::raw::c_int);
10191}
10192extern "C" {
10193 #[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"]
10194 pub fn otPlatDebugUart_puts(s: *const ::std::os::raw::c_char);
10195}
10196extern "C" {
10197 #[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."]
10198 pub fn otPlatDebugUart_write_bytes(pBytes: *const u8, nBytes: ::std::os::raw::c_int);
10199}
10200extern "C" {
10201 #[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()"]
10202 pub fn otPlatDebugUart_puts_no_nl(s: *const ::std::os::raw::c_char);
10203}
10204extern "C" {
10205 #[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."]
10206 pub fn otPlatDebugUart_logfile(filename: *const ::std::os::raw::c_char) -> otError;
10207}
10208#[repr(C)]
10209#[derive(Debug, Copy, Clone)]
10210pub struct otPlatDnsUpstreamQuery {
10211 _unused: [u8; 0],
10212}
10213extern "C" {
10214 #[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."]
10215 pub fn otPlatDnsStartUpstreamQuery(
10216 aInstance: *mut otInstance,
10217 aTxn: *mut otPlatDnsUpstreamQuery,
10218 aQuery: *const otMessage,
10219 );
10220}
10221extern "C" {
10222 #[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."]
10223 pub fn otPlatDnsCancelUpstreamQuery(
10224 aInstance: *mut otInstance,
10225 aTxn: *mut otPlatDnsUpstreamQuery,
10226 );
10227}
10228extern "C" {
10229 #[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 NULL 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 NULL to close a transaction without a\n response."]
10230 pub fn otPlatDnsUpstreamQueryDone(
10231 aInstance: *mut otInstance,
10232 aTxn: *mut otPlatDnsUpstreamQuery,
10233 aResponse: *mut otMessage,
10234 );
10235}
10236extern "C" {
10237 #[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."]
10238 pub fn otPlatEntropyGet(aOutput: *mut u8, aOutputLength: u16) -> otError;
10239}
10240extern "C" {
10241 #[doc = " Initializes the flash driver.\n\n @param[in] aInstance The OpenThread instance structure."]
10242 pub fn otPlatFlashInit(aInstance: *mut otInstance);
10243}
10244extern "C" {
10245 #[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."]
10246 pub fn otPlatFlashGetSwapSize(aInstance: *mut otInstance) -> u32;
10247}
10248extern "C" {
10249 #[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."]
10250 pub fn otPlatFlashErase(aInstance: *mut otInstance, aSwapIndex: u8);
10251}
10252extern "C" {
10253 #[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."]
10254 pub fn otPlatFlashRead(
10255 aInstance: *mut otInstance,
10256 aSwapIndex: u8,
10257 aOffset: u32,
10258 aData: *mut ::std::os::raw::c_void,
10259 aSize: u32,
10260 );
10261}
10262extern "C" {
10263 #[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."]
10264 pub fn otPlatFlashWrite(
10265 aInstance: *mut otInstance,
10266 aSwapIndex: u8,
10267 aOffset: u32,
10268 aData: *const ::std::os::raw::c_void,
10269 aSize: u32,
10270 );
10271}
10272#[doc = " Represents an InfraIf Link-Layer Address."]
10273#[repr(C)]
10274#[derive(Debug, Default, Copy, Clone)]
10275pub struct otPlatInfraIfLinkLayerAddress {
10276 #[doc = "< The link-layer address bytes."]
10277 pub mAddress: [u8; 16usize],
10278 #[doc = "< The address length (number of bytes)."]
10279 pub mLength: u8,
10280}
10281extern "C" {
10282 #[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."]
10283 pub fn otPlatInfraIfHasAddress(aInfraIfIndex: u32, aAddress: *const otIp6Address) -> bool;
10284}
10285extern "C" {
10286 #[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."]
10287 pub fn otPlatInfraIfSendIcmp6Nd(
10288 aInfraIfIndex: u32,
10289 aDestAddress: *const otIp6Address,
10290 aBuffer: *const u8,
10291 aBufferLength: u16,
10292 ) -> otError;
10293}
10294extern "C" {
10295 #[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."]
10296 pub fn otPlatInfraIfRecvIcmp6Nd(
10297 aInstance: *mut otInstance,
10298 aInfraIfIndex: u32,
10299 aSrcAddress: *const otIp6Address,
10300 aBuffer: *const u8,
10301 aBufferLength: u16,
10302 );
10303}
10304extern "C" {
10305 #[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."]
10306 pub fn otPlatInfraIfStateChanged(
10307 aInstance: *mut otInstance,
10308 aInfraIfIndex: u32,
10309 aIsRunning: bool,
10310 ) -> otError;
10311}
10312extern "C" {
10313 #[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."]
10314 pub fn otPlatInfraIfDiscoverNat64Prefix(aInfraIfIndex: u32) -> otError;
10315}
10316extern "C" {
10317 #[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."]
10318 pub fn otPlatInfraIfDiscoverNat64PrefixDone(
10319 aInstance: *mut otInstance,
10320 aInfraIfIndex: u32,
10321 aIp6Prefix: *const otIp6Prefix,
10322 );
10323}
10324extern "C" {
10325 #[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."]
10326 pub fn otPlatGetInfraIfLinkLayerAddress(
10327 aInstance: *mut otInstance,
10328 aIfIndex: u32,
10329 aInfraIfLinkLayerAddress: *mut otPlatInfraIfLinkLayerAddress,
10330 ) -> otError;
10331}
10332extern "C" {
10333 #[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."]
10334 pub fn otPlatCAlloc(aNum: usize, aSize: usize) -> *mut ::std::os::raw::c_void;
10335}
10336extern "C" {
10337 #[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."]
10338 pub fn otPlatFree(aPtr: *mut ::std::os::raw::c_void);
10339}
10340#[doc = " Represents an OpenThread message buffer."]
10341#[repr(C)]
10342#[derive(Debug, Copy, Clone)]
10343pub struct otMessageBuffer {
10344 #[doc = "< Pointer to the next buffer."]
10345 pub mNext: *mut otMessageBuffer,
10346}
10347impl Default for otMessageBuffer {
10348 fn default() -> Self {
10349 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10350 unsafe {
10351 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10352 s.assume_init()
10353 }
10354 }
10355}
10356extern "C" {
10357 #[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."]
10358 pub fn otPlatMessagePoolInit(
10359 aInstance: *mut otInstance,
10360 aMinNumFreeBuffers: u16,
10361 aBufferSize: usize,
10362 );
10363}
10364extern "C" {
10365 #[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."]
10366 pub fn otPlatMessagePoolNew(aInstance: *mut otInstance) -> *mut otMessageBuffer;
10367}
10368extern "C" {
10369 #[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."]
10370 pub fn otPlatMessagePoolFree(aInstance: *mut otInstance, aBuffer: *mut otMessageBuffer);
10371}
10372extern "C" {
10373 #[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."]
10374 pub fn otPlatMessagePoolNumFreeBuffers(aInstance: *mut otInstance) -> u16;
10375}
10376extern "C" {
10377 #[doc = " Performs a software reset on the platform, if supported.\n\n @param[in] aInstance The OpenThread instance structure."]
10378 pub fn otPlatReset(aInstance: *mut otInstance);
10379}
10380extern "C" {
10381 #[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."]
10382 pub fn otPlatResetToBootloader(aInstance: *mut otInstance) -> otError;
10383}
10384pub const OT_PLAT_RESET_REASON_POWER_ON: otPlatResetReason = 0;
10385pub const OT_PLAT_RESET_REASON_EXTERNAL: otPlatResetReason = 1;
10386pub const OT_PLAT_RESET_REASON_SOFTWARE: otPlatResetReason = 2;
10387pub const OT_PLAT_RESET_REASON_FAULT: otPlatResetReason = 3;
10388pub const OT_PLAT_RESET_REASON_CRASH: otPlatResetReason = 4;
10389pub const OT_PLAT_RESET_REASON_ASSERT: otPlatResetReason = 5;
10390pub const OT_PLAT_RESET_REASON_OTHER: otPlatResetReason = 6;
10391pub const OT_PLAT_RESET_REASON_UNKNOWN: otPlatResetReason = 7;
10392pub const OT_PLAT_RESET_REASON_WATCHDOG: otPlatResetReason = 8;
10393pub const OT_PLAT_RESET_REASON_COUNT: otPlatResetReason = 9;
10394#[doc = " Enumeration of possible reset reason codes.\n\n These are in the same order as the Spinel reset reason codes."]
10395pub type otPlatResetReason = ::std::os::raw::c_uint;
10396extern "C" {
10397 #[doc = " Returns the reason for the last platform reset.\n\n @param[in] aInstance The OpenThread instance structure."]
10398 pub fn otPlatGetResetReason(aInstance: *mut otInstance) -> otPlatResetReason;
10399}
10400extern "C" {
10401 #[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."]
10402 pub fn otPlatAssertFail(
10403 aFilename: *const ::std::os::raw::c_char,
10404 aLineNumber: ::std::os::raw::c_int,
10405 );
10406}
10407extern "C" {
10408 #[doc = " Performs a platform specific operation to wake the host MCU.\n This is used only for NCP configurations."]
10409 pub fn otPlatWakeHost();
10410}
10411#[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."]
10412pub const OT_PLAT_MCU_POWER_STATE_ON: otPlatMcuPowerState = 0;
10413#[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."]
10414pub const OT_PLAT_MCU_POWER_STATE_LOW_POWER: otPlatMcuPowerState = 1;
10415#[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."]
10416pub const OT_PLAT_MCU_POWER_STATE_OFF: otPlatMcuPowerState = 2;
10417#[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`."]
10418pub type otPlatMcuPowerState = ::std::os::raw::c_uint;
10419extern "C" {
10420 #[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."]
10421 pub fn otPlatSetMcuPowerState(
10422 aInstance: *mut otInstance,
10423 aState: otPlatMcuPowerState,
10424 ) -> otError;
10425}
10426extern "C" {
10427 #[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."]
10428 pub fn otPlatGetMcuPowerState(aInstance: *mut otInstance) -> otPlatMcuPowerState;
10429}
10430extern "C" {
10431 #[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"]
10432 pub fn otPlatLogCrashDump() -> otError;
10433}
10434extern "C" {
10435 #[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."]
10436 pub fn otPlatOtnsStatus(aStatus: *const ::std::os::raw::c_char);
10437}
10438#[doc = "< Active Operational Dataset."]
10439pub const OT_SETTINGS_KEY_ACTIVE_DATASET: _bindgen_ty_10 = 1;
10440#[doc = "< Pending Operational Dataset."]
10441pub const OT_SETTINGS_KEY_PENDING_DATASET: _bindgen_ty_10 = 2;
10442#[doc = "< Thread network information."]
10443pub const OT_SETTINGS_KEY_NETWORK_INFO: _bindgen_ty_10 = 3;
10444#[doc = "< Parent information."]
10445pub const OT_SETTINGS_KEY_PARENT_INFO: _bindgen_ty_10 = 4;
10446#[doc = "< Child information."]
10447pub const OT_SETTINGS_KEY_CHILD_INFO: _bindgen_ty_10 = 5;
10448#[doc = "< SLAAC key to generate semantically opaque IID."]
10449pub const OT_SETTINGS_KEY_SLAAC_IID_SECRET_KEY: _bindgen_ty_10 = 7;
10450#[doc = "< Duplicate Address Detection (DAD) information."]
10451pub const OT_SETTINGS_KEY_DAD_INFO: _bindgen_ty_10 = 8;
10452#[doc = "< SRP client ECDSA public/private key pair."]
10453pub const OT_SETTINGS_KEY_SRP_ECDSA_KEY: _bindgen_ty_10 = 11;
10454#[doc = "< The SRP client info (selected SRP server address)."]
10455pub const OT_SETTINGS_KEY_SRP_CLIENT_INFO: _bindgen_ty_10 = 12;
10456#[doc = "< The SRP server info (UDP port)."]
10457pub const OT_SETTINGS_KEY_SRP_SERVER_INFO: _bindgen_ty_10 = 13;
10458#[doc = "< BR ULA prefix."]
10459pub const OT_SETTINGS_KEY_BR_ULA_PREFIX: _bindgen_ty_10 = 15;
10460#[doc = "< BR local on-link prefixes."]
10461pub const OT_SETTINGS_KEY_BR_ON_LINK_PREFIXES: _bindgen_ty_10 = 16;
10462#[doc = "< Unique Border Agent/Router ID."]
10463pub const OT_SETTINGS_KEY_BORDER_AGENT_ID: _bindgen_ty_10 = 17;
10464#[doc = "< TCAT Commissioner certificate"]
10465pub const OT_SETTINGS_KEY_TCAT_COMMR_CERT: _bindgen_ty_10 = 18;
10466pub const OT_SETTINGS_KEY_VENDOR_RESERVED_MIN: _bindgen_ty_10 = 32768;
10467pub const OT_SETTINGS_KEY_VENDOR_RESERVED_MAX: _bindgen_ty_10 = 65535;
10468#[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()`."]
10469pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
10470extern "C" {
10471 #[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."]
10472 pub fn otPlatSettingsInit(
10473 aInstance: *mut otInstance,
10474 aSensitiveKeys: *const u16,
10475 aSensitiveKeysLength: u16,
10476 );
10477}
10478extern "C" {
10479 #[doc = " Performs any de-initialization for the settings subsystem, if necessary.\n\n @param[in] aInstance The OpenThread instance structure."]
10480 pub fn otPlatSettingsDeinit(aInstance: *mut otInstance);
10481}
10482extern "C" {
10483 #[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."]
10484 pub fn otPlatSettingsGet(
10485 aInstance: *mut otInstance,
10486 aKey: u16,
10487 aIndex: ::std::os::raw::c_int,
10488 aValue: *mut u8,
10489 aValueLength: *mut u16,
10490 ) -> otError;
10491}
10492extern "C" {
10493 #[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."]
10494 pub fn otPlatSettingsSet(
10495 aInstance: *mut otInstance,
10496 aKey: u16,
10497 aValue: *const u8,
10498 aValueLength: u16,
10499 ) -> otError;
10500}
10501extern "C" {
10502 #[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."]
10503 pub fn otPlatSettingsAdd(
10504 aInstance: *mut otInstance,
10505 aKey: u16,
10506 aValue: *const u8,
10507 aValueLength: u16,
10508 ) -> otError;
10509}
10510extern "C" {
10511 #[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."]
10512 pub fn otPlatSettingsDelete(
10513 aInstance: *mut otInstance,
10514 aKey: u16,
10515 aIndex: ::std::os::raw::c_int,
10516 ) -> otError;
10517}
10518extern "C" {
10519 #[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."]
10520 pub fn otPlatSettingsWipe(aInstance: *mut otInstance);
10521}
10522#[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."]
10523pub type otPlatSpiSlaveTransactionCompleteCallback = ::std::option::Option<
10524 unsafe extern "C" fn(
10525 aContext: *mut ::std::os::raw::c_void,
10526 aOutputBuf: *mut u8,
10527 aOutputBufLen: u16,
10528 aInputBuf: *mut u8,
10529 aInputBufLen: u16,
10530 aTransactionLength: u16,
10531 ) -> bool,
10532>;
10533#[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()`."]
10534pub type otPlatSpiSlaveTransactionProcessCallback =
10535 ::std::option::Option<unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void)>;
10536extern "C" {
10537 #[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."]
10538 pub fn otPlatSpiSlaveEnable(
10539 aCompleteCallback: otPlatSpiSlaveTransactionCompleteCallback,
10540 aProcessCallback: otPlatSpiSlaveTransactionProcessCallback,
10541 aContext: *mut ::std::os::raw::c_void,
10542 ) -> otError;
10543}
10544extern "C" {
10545 #[doc = " Shutdown and disable the SPI slave interface."]
10546 pub fn otPlatSpiSlaveDisable();
10547}
10548extern "C" {
10549 #[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."]
10550 pub fn otPlatSpiSlavePrepareTransaction(
10551 aOutputBuf: *mut u8,
10552 aOutputBufLen: u16,
10553 aInputBuf: *mut u8,
10554 aInputBufLen: u16,
10555 aRequestTransactionFlag: bool,
10556 ) -> otError;
10557}
10558extern "C" {
10559 #[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."]
10560 pub fn otPlatTimeGet() -> u64;
10561}
10562extern "C" {
10563 #[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."]
10564 pub fn otPlatTimeGetXtalAccuracy() -> u16;
10565}
10566extern "C" {
10567 #[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."]
10568 pub fn otPlatTrelEnable(aInstance: *mut otInstance, aUdpPort: *mut u16);
10569}
10570extern "C" {
10571 #[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."]
10572 pub fn otPlatTrelDisable(aInstance: *mut otInstance);
10573}
10574#[doc = " Represents a TREL peer info discovered using DNS-SD browse on the service name \"_trel._udp\"."]
10575#[repr(C)]
10576#[derive(Copy, Clone)]
10577pub struct otPlatTrelPeerInfo {
10578 #[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."]
10579 pub mRemoved: bool,
10580 #[doc = " The TXT record data (encoded as specified by DNS-SD) from the SRV record of the discovered TREL peer service\n instance."]
10581 pub mTxtData: *const u8,
10582 #[doc = "< Number of bytes in @p mTxtData buffer."]
10583 pub mTxtLength: u16,
10584 #[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."]
10585 pub mSockAddr: otSockAddr,
10586}
10587impl Default for otPlatTrelPeerInfo {
10588 fn default() -> Self {
10589 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10590 unsafe {
10591 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10592 s.assume_init()
10593 }
10594 }
10595}
10596extern "C" {
10597 #[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."]
10598 pub fn otPlatTrelHandleDiscoveredPeerInfo(
10599 aInstance: *mut otInstance,
10600 aInfo: *const otPlatTrelPeerInfo,
10601 );
10602}
10603extern "C" {
10604 #[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)."]
10605 pub fn otPlatTrelNotifyPeerSocketAddressDifference(
10606 aInstance: *mut otInstance,
10607 aPeerSockAddr: *const otSockAddr,
10608 aRxSockAddr: *const otSockAddr,
10609 );
10610}
10611extern "C" {
10612 #[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)."]
10613 pub fn otPlatTrelRegisterService(
10614 aInstance: *mut otInstance,
10615 aPort: u16,
10616 aTxtData: *const u8,
10617 aTxtLength: u8,
10618 );
10619}
10620extern "C" {
10621 #[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."]
10622 pub fn otPlatTrelSend(
10623 aInstance: *mut otInstance,
10624 aUdpPayload: *const u8,
10625 aUdpPayloadLen: u16,
10626 aDestSockAddr: *const otSockAddr,
10627 );
10628}
10629extern "C" {
10630 #[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."]
10631 pub fn otPlatTrelHandleReceived(
10632 aInstance: *mut otInstance,
10633 aBuffer: *mut u8,
10634 aLength: u16,
10635 aSenderAddr: *const otSockAddr,
10636 );
10637}
10638#[doc = " Represents a group of TREL related counters in the platform layer."]
10639#[repr(C)]
10640#[derive(Debug, Default, Copy, Clone)]
10641pub struct otPlatTrelCounters {
10642 #[doc = "< Number of packets successfully transmitted through TREL."]
10643 pub mTxPackets: u64,
10644 #[doc = "< Sum of size of packets successfully transmitted through TREL."]
10645 pub mTxBytes: u64,
10646 #[doc = "< Number of packet transmission failures through TREL."]
10647 pub mTxFailure: u64,
10648 #[doc = "< Number of packets received through TREL."]
10649 pub mRxPackets: u64,
10650 #[doc = "< Sum of size of packets received through TREL."]
10651 pub mRxBytes: u64,
10652}
10653extern "C" {
10654 #[doc = " Gets the pointer to the TREL counters in the platform layer.\n\n @param[in] aInstance The OpenThread instance structure."]
10655 pub fn otPlatTrelGetCounters(aInstance: *mut otInstance) -> *const otPlatTrelCounters;
10656}
10657extern "C" {
10658 #[doc = " Resets the TREL counters in the platform layer.\n\n @param[in] aInstance The OpenThread instance structure."]
10659 pub fn otPlatTrelResetCounters(aInstance: *mut otInstance);
10660}
10661#[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."]
10662pub type otUdpHandler = ::std::option::Option<
10663 unsafe extern "C" fn(
10664 aContext: *mut ::std::os::raw::c_void,
10665 aMessage: *const otMessage,
10666 aMessageInfo: *const otMessageInfo,
10667 ) -> bool,
10668>;
10669#[doc = " Represents a UDP receiver."]
10670#[repr(C)]
10671#[derive(Debug, Copy, Clone)]
10672pub struct otUdpReceiver {
10673 #[doc = "< A pointer to the next UDP receiver (internal use only)."]
10674 pub mNext: *mut otUdpReceiver,
10675 #[doc = "< A function pointer to the receiver callback."]
10676 pub mHandler: otUdpHandler,
10677 #[doc = "< A pointer to application-specific context."]
10678 pub mContext: *mut ::std::os::raw::c_void,
10679}
10680impl Default for otUdpReceiver {
10681 fn default() -> Self {
10682 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10683 unsafe {
10684 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10685 s.assume_init()
10686 }
10687 }
10688}
10689extern "C" {
10690 #[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."]
10691 pub fn otUdpAddReceiver(
10692 aInstance: *mut otInstance,
10693 aUdpReceiver: *mut otUdpReceiver,
10694 ) -> otError;
10695}
10696extern "C" {
10697 #[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."]
10698 pub fn otUdpRemoveReceiver(
10699 aInstance: *mut otInstance,
10700 aUdpReceiver: *mut otUdpReceiver,
10701 ) -> otError;
10702}
10703extern "C" {
10704 #[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."]
10705 pub fn otUdpSendDatagram(
10706 aInstance: *mut otInstance,
10707 aMessage: *mut otMessage,
10708 aMessageInfo: *mut otMessageInfo,
10709 ) -> otError;
10710}
10711#[doc = " This callback allows OpenThread to inform the application of a received UDP message."]
10712pub type otUdpReceive = ::std::option::Option<
10713 unsafe extern "C" fn(
10714 aContext: *mut ::std::os::raw::c_void,
10715 aMessage: *mut otMessage,
10716 aMessageInfo: *const otMessageInfo,
10717 ),
10718>;
10719#[doc = "< Unspecified network interface."]
10720pub const OT_NETIF_UNSPECIFIED: otNetifIdentifier = 0;
10721#[doc = "< The host Thread interface - allow use of platform UDP."]
10722pub const OT_NETIF_THREAD_HOST: otNetifIdentifier = 1;
10723#[doc = "< The internal Thread interface (within OpenThread) - do not use platform UDP."]
10724pub const OT_NETIF_THREAD_INTERNAL: otNetifIdentifier = 2;
10725#[doc = "< The Backbone interface."]
10726pub const OT_NETIF_BACKBONE: otNetifIdentifier = 3;
10727#[doc = " Defines the OpenThread network interface identifiers."]
10728pub type otNetifIdentifier = ::std::os::raw::c_uint;
10729#[doc = " Represents a UDP socket."]
10730#[repr(C)]
10731#[derive(Copy, Clone)]
10732pub struct otUdpSocket {
10733 #[doc = "< The local IPv6 socket address."]
10734 pub mSockName: otSockAddr,
10735 #[doc = "< The peer IPv6 socket address."]
10736 pub mPeerName: otSockAddr,
10737 #[doc = "< A function pointer to the application callback."]
10738 pub mHandler: otUdpReceive,
10739 #[doc = "< A pointer to application-specific context."]
10740 pub mContext: *mut ::std::os::raw::c_void,
10741 #[doc = "< A handle to platform's UDP."]
10742 pub mHandle: *mut ::std::os::raw::c_void,
10743 #[doc = "< A pointer to the next UDP socket (internal use only)."]
10744 pub mNext: *mut otUdpSocket,
10745 #[doc = "< The network interface identifier."]
10746 pub mNetifId: otNetifIdentifier,
10747}
10748impl Default for otUdpSocket {
10749 fn default() -> Self {
10750 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10751 unsafe {
10752 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10753 s.assume_init()
10754 }
10755 }
10756}
10757extern "C" {
10758 #[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"]
10759 pub fn otUdpNewMessage(
10760 aInstance: *mut otInstance,
10761 aSettings: *const otMessageSettings,
10762 ) -> *mut otMessage;
10763}
10764extern "C" {
10765 #[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."]
10766 pub fn otUdpOpen(
10767 aInstance: *mut otInstance,
10768 aSocket: *mut otUdpSocket,
10769 aCallback: otUdpReceive,
10770 aContext: *mut ::std::os::raw::c_void,
10771 ) -> otError;
10772}
10773extern "C" {
10774 #[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."]
10775 pub fn otUdpIsOpen(aInstance: *mut otInstance, aSocket: *const otUdpSocket) -> bool;
10776}
10777extern "C" {
10778 #[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."]
10779 pub fn otUdpClose(aInstance: *mut otInstance, aSocket: *mut otUdpSocket) -> otError;
10780}
10781extern "C" {
10782 #[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."]
10783 pub fn otUdpBind(
10784 aInstance: *mut otInstance,
10785 aSocket: *mut otUdpSocket,
10786 aSockName: *const otSockAddr,
10787 aNetif: otNetifIdentifier,
10788 ) -> otError;
10789}
10790extern "C" {
10791 #[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."]
10792 pub fn otUdpConnect(
10793 aInstance: *mut otInstance,
10794 aSocket: *mut otUdpSocket,
10795 aSockName: *const otSockAddr,
10796 ) -> otError;
10797}
10798extern "C" {
10799 #[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."]
10800 pub fn otUdpSend(
10801 aInstance: *mut otInstance,
10802 aSocket: *mut otUdpSocket,
10803 aMessage: *mut otMessage,
10804 aMessageInfo: *const otMessageInfo,
10805 ) -> otError;
10806}
10807extern "C" {
10808 #[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."]
10809 pub fn otUdpGetSockets(aInstance: *mut otInstance) -> *mut otUdpSocket;
10810}
10811#[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."]
10812pub type otUdpForwarder = ::std::option::Option<
10813 unsafe extern "C" fn(
10814 aMessage: *mut otMessage,
10815 aPeerPort: u16,
10816 aPeerAddr: *mut otIp6Address,
10817 aSockPort: u16,
10818 aContext: *mut ::std::os::raw::c_void,
10819 ),
10820>;
10821extern "C" {
10822 #[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."]
10823 pub fn otUdpForwardSetForwarder(
10824 aInstance: *mut otInstance,
10825 aForwarder: otUdpForwarder,
10826 aContext: *mut ::std::os::raw::c_void,
10827 );
10828}
10829extern "C" {
10830 #[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."]
10831 pub fn otUdpForwardReceive(
10832 aInstance: *mut otInstance,
10833 aMessage: *mut otMessage,
10834 aPeerPort: u16,
10835 aPeerAddr: *const otIp6Address,
10836 aSockPort: u16,
10837 );
10838}
10839extern "C" {
10840 #[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)."]
10841 pub fn otUdpIsPortInUse(aInstance: *mut otInstance, port: u16) -> bool;
10842}
10843extern "C" {
10844 #[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."]
10845 pub fn otPlatUdpSocket(aUdpSocket: *mut otUdpSocket) -> otError;
10846}
10847extern "C" {
10848 #[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."]
10849 pub fn otPlatUdpClose(aUdpSocket: *mut otUdpSocket) -> otError;
10850}
10851extern "C" {
10852 #[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."]
10853 pub fn otPlatUdpBind(aUdpSocket: *mut otUdpSocket) -> otError;
10854}
10855extern "C" {
10856 #[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."]
10857 pub fn otPlatUdpBindToNetif(
10858 aUdpSocket: *mut otUdpSocket,
10859 aNetifIdentifier: otNetifIdentifier,
10860 ) -> otError;
10861}
10862extern "C" {
10863 #[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."]
10864 pub fn otPlatUdpConnect(aUdpSocket: *mut otUdpSocket) -> otError;
10865}
10866extern "C" {
10867 #[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."]
10868 pub fn otPlatUdpSend(
10869 aUdpSocket: *mut otUdpSocket,
10870 aMessage: *mut otMessage,
10871 aMessageInfo: *const otMessageInfo,
10872 ) -> otError;
10873}
10874extern "C" {
10875 #[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."]
10876 pub fn otPlatUdpJoinMulticastGroup(
10877 aUdpSocket: *mut otUdpSocket,
10878 aNetifIdentifier: otNetifIdentifier,
10879 aAddress: *const otIp6Address,
10880 ) -> otError;
10881}
10882extern "C" {
10883 #[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."]
10884 pub fn otPlatUdpLeaveMulticastGroup(
10885 aUdpSocket: *mut otUdpSocket,
10886 aNetifIdentifier: otNetifIdentifier,
10887 aAddress: *const otIp6Address,
10888 ) -> otError;
10889}
10890extern "C" {
10891 #[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)."]
10892 pub fn otRandomCryptoFillBuffer(aBuffer: *mut u8, aSize: u16) -> otError;
10893}
10894extern "C" {
10895 #[doc = " Generates and returns a random `uint32_t` value.\n\n @returns A random `uint32_t` value."]
10896 pub fn otRandomNonCryptoGetUint32() -> u32;
10897}
10898extern "C" {
10899 #[doc = " Generates and returns a random byte.\n\n @returns A random `uint8_t` value."]
10900 pub fn otRandomNonCryptoGetUint8() -> u8;
10901}
10902extern "C" {
10903 #[doc = " Generates and returns a random `uint16_t` value.\n\n @returns A random `uint16_t` value."]
10904 pub fn otRandomNonCryptoGetUint16() -> u16;
10905}
10906extern "C" {
10907 #[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)."]
10908 pub fn otRandomNonCryptoGetUint8InRange(aMin: u8, aMax: u8) -> u8;
10909}
10910extern "C" {
10911 #[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)."]
10912 pub fn otRandomNonCryptoGetUint16InRange(aMin: u16, aMax: u16) -> u16;
10913}
10914extern "C" {
10915 #[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)."]
10916 pub fn otRandomNonCryptoGetUint32InRange(aMin: u32, aMax: u32) -> u32;
10917}
10918extern "C" {
10919 #[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)."]
10920 pub fn otRandomNonCryptoFillBuffer(aBuffer: *mut u8, aSize: u16);
10921}
10922extern "C" {
10923 #[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."]
10924 pub fn otRandomNonCryptoAddJitter(aValue: u32, aJitter: u16) -> u32;
10925}
10926extern "C" {
10927 #[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."]
10928 pub fn otServerGetNetDataLocal(
10929 aInstance: *mut otInstance,
10930 aStable: bool,
10931 aData: *mut u8,
10932 aDataLength: *mut u8,
10933 ) -> otError;
10934}
10935extern "C" {
10936 #[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"]
10937 pub fn otServerAddService(
10938 aInstance: *mut otInstance,
10939 aConfig: *const otServiceConfig,
10940 ) -> otError;
10941}
10942extern "C" {
10943 #[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"]
10944 pub fn otServerRemoveService(
10945 aInstance: *mut otInstance,
10946 aEnterpriseNumber: u32,
10947 aServiceData: *const u8,
10948 aServiceDataLength: u8,
10949 ) -> otError;
10950}
10951extern "C" {
10952 #[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."]
10953 pub fn otServerGetNextService(
10954 aInstance: *mut otInstance,
10955 aIterator: *mut otNetworkDataIterator,
10956 aConfig: *mut otServiceConfig,
10957 ) -> otError;
10958}
10959extern "C" {
10960 #[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"]
10961 pub fn otServerRegister(aInstance: *mut otInstance) -> otError;
10962}
10963#[doc = " Implements SNTP Query parameters."]
10964#[repr(C)]
10965#[derive(Debug, Copy, Clone)]
10966pub struct otSntpQuery {
10967 #[doc = "< A reference to the message info related with SNTP Server."]
10968 pub mMessageInfo: *const otMessageInfo,
10969}
10970impl Default for otSntpQuery {
10971 fn default() -> Self {
10972 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
10973 unsafe {
10974 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
10975 s.assume_init()
10976 }
10977 }
10978}
10979#[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."]
10980pub type otSntpResponseHandler = ::std::option::Option<
10981 unsafe extern "C" fn(aContext: *mut ::std::os::raw::c_void, aTime: u64, aResult: otError),
10982>;
10983extern "C" {
10984 #[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."]
10985 pub fn otSntpClientQuery(
10986 aInstance: *mut otInstance,
10987 aQuery: *const otSntpQuery,
10988 aHandler: otSntpResponseHandler,
10989 aContext: *mut ::std::os::raw::c_void,
10990 ) -> otError;
10991}
10992extern "C" {
10993 #[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."]
10994 pub fn otSntpClientSetUnixEra(aInstance: *mut otInstance, aUnixEra: u32);
10995}
10996#[doc = "< Item to be added/registered."]
10997pub const OT_SRP_CLIENT_ITEM_STATE_TO_ADD: otSrpClientItemState = 0;
10998#[doc = "< Item is being added/registered."]
10999pub const OT_SRP_CLIENT_ITEM_STATE_ADDING: otSrpClientItemState = 1;
11000#[doc = "< Item to be refreshed (re-register to renew lease)."]
11001pub const OT_SRP_CLIENT_ITEM_STATE_TO_REFRESH: otSrpClientItemState = 2;
11002#[doc = "< Item is being refreshed."]
11003pub const OT_SRP_CLIENT_ITEM_STATE_REFRESHING: otSrpClientItemState = 3;
11004#[doc = "< Item to be removed."]
11005pub const OT_SRP_CLIENT_ITEM_STATE_TO_REMOVE: otSrpClientItemState = 4;
11006#[doc = "< Item is being removed."]
11007pub const OT_SRP_CLIENT_ITEM_STATE_REMOVING: otSrpClientItemState = 5;
11008#[doc = "< Item is registered with server."]
11009pub const OT_SRP_CLIENT_ITEM_STATE_REGISTERED: otSrpClientItemState = 6;
11010#[doc = "< Item is removed."]
11011pub const OT_SRP_CLIENT_ITEM_STATE_REMOVED: otSrpClientItemState = 7;
11012#[doc = " Specifies an SRP client item (service or host info) state."]
11013pub type otSrpClientItemState = ::std::os::raw::c_uint;
11014#[doc = " Represents an SRP client host info."]
11015#[repr(C)]
11016#[derive(Debug, Copy, Clone)]
11017pub struct otSrpClientHostInfo {
11018 #[doc = "< Host name (label) string (NULL if not yet set)."]
11019 pub mName: *const ::std::os::raw::c_char,
11020 #[doc = "< Array of host IPv6 addresses (NULL if not set or auto address is enabled)."]
11021 pub mAddresses: *const otIp6Address,
11022 #[doc = "< Number of IPv6 addresses in `mAddresses` array."]
11023 pub mNumAddresses: u8,
11024 #[doc = "< Indicates whether auto address mode is enabled or not."]
11025 pub mAutoAddress: bool,
11026 #[doc = "< Host info state."]
11027 pub mState: otSrpClientItemState,
11028}
11029impl Default for otSrpClientHostInfo {
11030 fn default() -> Self {
11031 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11032 unsafe {
11033 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11034 s.assume_init()
11035 }
11036 }
11037}
11038#[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."]
11039#[repr(C)]
11040#[derive(Debug, Copy, Clone)]
11041pub struct otSrpClientService {
11042 #[doc = "< The service labels (e.g., \"_mt._udp\", not the full domain name)."]
11043 pub mName: *const ::std::os::raw::c_char,
11044 #[doc = "< The service instance name label (not the full name)."]
11045 pub mInstanceName: *const ::std::os::raw::c_char,
11046 #[doc = "< Array of sub-type labels (must end with `NULL` or can be `NULL`)."]
11047 pub mSubTypeLabels: *const *const ::std::os::raw::c_char,
11048 #[doc = "< Array of TXT entries (`mNumTxtEntries` gives num of entries)."]
11049 pub mTxtEntries: *const otDnsTxtEntry,
11050 #[doc = "< The service port number."]
11051 pub mPort: u16,
11052 #[doc = "< The service priority."]
11053 pub mPriority: u16,
11054 #[doc = "< The service weight."]
11055 pub mWeight: u16,
11056 #[doc = "< Number of entries in the `mTxtEntries` array."]
11057 pub mNumTxtEntries: u8,
11058 #[doc = "< Service state (managed by OT core)."]
11059 pub mState: otSrpClientItemState,
11060 #[doc = "< Internal data (used by OT core)."]
11061 pub mData: u32,
11062 #[doc = "< Pointer to next entry in a linked-list (managed by OT core)."]
11063 pub mNext: *mut otSrpClientService,
11064 #[doc = "< Desired lease interval in sec - zero to use default."]
11065 pub mLease: u32,
11066 #[doc = "< Desired key lease interval in sec - zero to use default."]
11067 pub mKeyLease: u32,
11068}
11069impl Default for otSrpClientService {
11070 fn default() -> Self {
11071 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11072 unsafe {
11073 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11074 s.assume_init()
11075 }
11076 }
11077}
11078#[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)."]
11079pub type otSrpClientCallback = ::std::option::Option<
11080 unsafe extern "C" fn(
11081 aError: otError,
11082 aHostInfo: *const otSrpClientHostInfo,
11083 aServices: *const otSrpClientService,
11084 aRemovedServices: *const otSrpClientService,
11085 aContext: *mut ::std::os::raw::c_void,
11086 ),
11087>;
11088#[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)."]
11089pub type otSrpClientAutoStartCallback = ::std::option::Option<
11090 unsafe extern "C" fn(aServerSockAddr: *const otSockAddr, aContext: *mut ::std::os::raw::c_void),
11091>;
11092extern "C" {
11093 #[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."]
11094 pub fn otSrpClientStart(
11095 aInstance: *mut otInstance,
11096 aServerSockAddr: *const otSockAddr,
11097 ) -> otError;
11098}
11099extern "C" {
11100 #[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."]
11101 pub fn otSrpClientStop(aInstance: *mut otInstance);
11102}
11103extern "C" {
11104 #[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."]
11105 pub fn otSrpClientIsRunning(aInstance: *mut otInstance) -> bool;
11106}
11107extern "C" {
11108 #[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)."]
11109 pub fn otSrpClientGetServerAddress(aInstance: *mut otInstance) -> *const otSockAddr;
11110}
11111extern "C" {
11112 #[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."]
11113 pub fn otSrpClientSetCallback(
11114 aInstance: *mut otInstance,
11115 aCallback: otSrpClientCallback,
11116 aContext: *mut ::std::os::raw::c_void,
11117 );
11118}
11119extern "C" {
11120 #[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."]
11121 pub fn otSrpClientEnableAutoStartMode(
11122 aInstance: *mut otInstance,
11123 aCallback: otSrpClientAutoStartCallback,
11124 aContext: *mut ::std::os::raw::c_void,
11125 );
11126}
11127extern "C" {
11128 #[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."]
11129 pub fn otSrpClientDisableAutoStartMode(aInstance: *mut otInstance);
11130}
11131extern "C" {
11132 #[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."]
11133 pub fn otSrpClientIsAutoStartModeEnabled(aInstance: *mut otInstance) -> bool;
11134}
11135extern "C" {
11136 #[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)."]
11137 pub fn otSrpClientGetTtl(aInstance: *mut otInstance) -> u32;
11138}
11139extern "C" {
11140 #[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."]
11141 pub fn otSrpClientSetTtl(aInstance: *mut otInstance, aTtl: u32);
11142}
11143extern "C" {
11144 #[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)."]
11145 pub fn otSrpClientGetLeaseInterval(aInstance: *mut otInstance) -> u32;
11146}
11147extern "C" {
11148 #[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."]
11149 pub fn otSrpClientSetLeaseInterval(aInstance: *mut otInstance, aInterval: u32);
11150}
11151extern "C" {
11152 #[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)."]
11153 pub fn otSrpClientGetKeyLeaseInterval(aInstance: *mut otInstance) -> u32;
11154}
11155extern "C" {
11156 #[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."]
11157 pub fn otSrpClientSetKeyLeaseInterval(aInstance: *mut otInstance, aInterval: u32);
11158}
11159extern "C" {
11160 #[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."]
11161 pub fn otSrpClientGetHostInfo(aInstance: *mut otInstance) -> *const otSrpClientHostInfo;
11162}
11163extern "C" {
11164 #[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."]
11165 pub fn otSrpClientSetHostName(
11166 aInstance: *mut otInstance,
11167 aName: *const ::std::os::raw::c_char,
11168 ) -> otError;
11169}
11170extern "C" {
11171 #[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."]
11172 pub fn otSrpClientEnableAutoHostAddress(aInstance: *mut otInstance) -> otError;
11173}
11174extern "C" {
11175 #[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."]
11176 pub fn otSrpClientSetHostAddresses(
11177 aInstance: *mut otInstance,
11178 aIp6Addresses: *const otIp6Address,
11179 aNumAddresses: u8,
11180 ) -> otError;
11181}
11182extern "C" {
11183 #[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`)."]
11184 pub fn otSrpClientAddService(
11185 aInstance: *mut otInstance,
11186 aService: *mut otSrpClientService,
11187 ) -> otError;
11188}
11189extern "C" {
11190 #[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."]
11191 pub fn otSrpClientRemoveService(
11192 aInstance: *mut otInstance,
11193 aService: *mut otSrpClientService,
11194 ) -> otError;
11195}
11196extern "C" {
11197 #[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."]
11198 pub fn otSrpClientClearService(
11199 aInstance: *mut otInstance,
11200 aService: *mut otSrpClientService,
11201 ) -> otError;
11202}
11203extern "C" {
11204 #[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."]
11205 pub fn otSrpClientGetServices(aInstance: *mut otInstance) -> *const otSrpClientService;
11206}
11207extern "C" {
11208 #[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."]
11209 pub fn otSrpClientRemoveHostAndServices(
11210 aInstance: *mut otInstance,
11211 aRemoveKeyLease: bool,
11212 aSendUnregToServer: bool,
11213 ) -> otError;
11214}
11215extern "C" {
11216 #[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."]
11217 pub fn otSrpClientClearHostAndServices(aInstance: *mut otInstance);
11218}
11219extern "C" {
11220 #[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."]
11221 pub fn otSrpClientGetDomainName(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
11222}
11223extern "C" {
11224 #[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."]
11225 pub fn otSrpClientSetDomainName(
11226 aInstance: *mut otInstance,
11227 aName: *const ::std::os::raw::c_char,
11228 ) -> otError;
11229}
11230extern "C" {
11231 #[doc = " Converts a `otSrpClientItemState` to a string.\n\n @param[in] aItemState An item state.\n\n @returns A string representation of @p aItemState."]
11232 pub fn otSrpClientItemStateToString(
11233 aItemState: otSrpClientItemState,
11234 ) -> *const ::std::os::raw::c_char;
11235}
11236extern "C" {
11237 #[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."]
11238 pub fn otSrpClientSetServiceKeyRecordEnabled(aInstance: *mut otInstance, aEnabled: bool);
11239}
11240extern "C" {
11241 #[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."]
11242 pub fn otSrpClientIsServiceKeyRecordEnabled(aInstance: *mut otInstance) -> bool;
11243}
11244#[doc = " Represents a SRP client service pool entry."]
11245#[repr(C)]
11246#[derive(Debug, Copy, Clone)]
11247pub struct otSrpClientBuffersServiceEntry {
11248 #[doc = "< The SRP client service structure."]
11249 pub mService: otSrpClientService,
11250 #[doc = "< The SRP client TXT entry."]
11251 pub mTxtEntry: otDnsTxtEntry,
11252}
11253impl Default for otSrpClientBuffersServiceEntry {
11254 fn default() -> Self {
11255 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11256 unsafe {
11257 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11258 s.assume_init()
11259 }
11260 }
11261}
11262extern "C" {
11263 #[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."]
11264 pub fn otSrpClientBuffersGetHostNameString(
11265 aInstance: *mut otInstance,
11266 aSize: *mut u16,
11267 ) -> *mut ::std::os::raw::c_char;
11268}
11269extern "C" {
11270 #[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)."]
11271 pub fn otSrpClientBuffersGetHostAddressesArray(
11272 aInstance: *mut otInstance,
11273 aArrayLength: *mut u8,
11274 ) -> *mut otIp6Address;
11275}
11276extern "C" {
11277 #[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."]
11278 pub fn otSrpClientBuffersAllocateService(
11279 aInstance: *mut otInstance,
11280 ) -> *mut otSrpClientBuffersServiceEntry;
11281}
11282extern "C" {
11283 #[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)."]
11284 pub fn otSrpClientBuffersFreeService(
11285 aInstance: *mut otInstance,
11286 aService: *mut otSrpClientBuffersServiceEntry,
11287 );
11288}
11289extern "C" {
11290 #[doc = " Frees all previously allocated service entries.\n\n @param[in] aInstance A pointer to the OpenThread instance."]
11291 pub fn otSrpClientBuffersFreeAllServices(aInstance: *mut otInstance);
11292}
11293extern "C" {
11294 #[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."]
11295 pub fn otSrpClientBuffersGetServiceEntryServiceNameString(
11296 aEntry: *mut otSrpClientBuffersServiceEntry,
11297 aSize: *mut u16,
11298 ) -> *mut ::std::os::raw::c_char;
11299}
11300extern "C" {
11301 #[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."]
11302 pub fn otSrpClientBuffersGetServiceEntryInstanceNameString(
11303 aEntry: *mut otSrpClientBuffersServiceEntry,
11304 aSize: *mut u16,
11305 ) -> *mut ::std::os::raw::c_char;
11306}
11307extern "C" {
11308 #[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."]
11309 pub fn otSrpClientBuffersGetServiceEntryTxtBuffer(
11310 aEntry: *mut otSrpClientBuffersServiceEntry,
11311 aSize: *mut u16,
11312 ) -> *mut u8;
11313}
11314extern "C" {
11315 #[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."]
11316 pub fn otSrpClientBuffersGetSubTypeLabelsArray(
11317 aEntry: *mut otSrpClientBuffersServiceEntry,
11318 aArrayLength: *mut u16,
11319 ) -> *mut *const ::std::os::raw::c_char;
11320}
11321#[repr(C)]
11322#[derive(Debug, Copy, Clone)]
11323pub struct otSrpServerHost {
11324 _unused: [u8; 0],
11325}
11326#[repr(C)]
11327#[derive(Debug, Copy, Clone)]
11328pub struct otSrpServerService {
11329 _unused: [u8; 0],
11330}
11331#[doc = " The ID of a SRP service update transaction on the SRP Server."]
11332pub type otSrpServerServiceUpdateId = u32;
11333#[doc = "< The SRP server is disabled."]
11334pub const OT_SRP_SERVER_STATE_DISABLED: otSrpServerState = 0;
11335#[doc = "< The SRP server is enabled and running."]
11336pub const OT_SRP_SERVER_STATE_RUNNING: otSrpServerState = 1;
11337#[doc = "< The SRP server is enabled but stopped."]
11338pub const OT_SRP_SERVER_STATE_STOPPED: otSrpServerState = 2;
11339#[doc = " Represents the state of the SRP server."]
11340pub type otSrpServerState = ::std::os::raw::c_uint;
11341#[doc = "< Unicast address mode. Use Network Data publisher."]
11342pub const OT_SRP_SERVER_ADDRESS_MODE_UNICAST: otSrpServerAddressMode = 0;
11343#[doc = "< Anycast address mode. Use Network Data publisher"]
11344pub const OT_SRP_SERVER_ADDRESS_MODE_ANYCAST: otSrpServerAddressMode = 1;
11345#[doc = "< Unicast address mode. Immediately force add to Network Data."]
11346pub const OT_SRP_SERVER_ADDRESS_MODE_UNICAST_FORCE_ADD: otSrpServerAddressMode = 2;
11347#[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."]
11348pub type otSrpServerAddressMode = ::std::os::raw::c_uint;
11349#[doc = " Includes SRP server TTL configurations."]
11350#[repr(C)]
11351#[derive(Debug, Default, Copy, Clone)]
11352pub struct otSrpServerTtlConfig {
11353 #[doc = "< The minimum TTL in seconds."]
11354 pub mMinTtl: u32,
11355 #[doc = "< The maximum TTL in seconds."]
11356 pub mMaxTtl: u32,
11357}
11358#[doc = " Includes SRP server LEASE and KEY-LEASE configurations."]
11359#[repr(C)]
11360#[derive(Debug, Default, Copy, Clone)]
11361pub struct otSrpServerLeaseConfig {
11362 #[doc = "< The minimum LEASE interval in seconds."]
11363 pub mMinLease: u32,
11364 #[doc = "< The maximum LEASE interval in seconds."]
11365 pub mMaxLease: u32,
11366 #[doc = "< The minimum KEY-LEASE interval in seconds."]
11367 pub mMinKeyLease: u32,
11368 #[doc = "< The maximum KEY-LEASE interval in seconds."]
11369 pub mMaxKeyLease: u32,
11370}
11371#[doc = " Includes SRP server lease information of a host/service."]
11372#[repr(C)]
11373#[derive(Debug, Default, Copy, Clone)]
11374pub struct otSrpServerLeaseInfo {
11375 #[doc = "< The lease time of a host/service in milliseconds."]
11376 pub mLease: u32,
11377 #[doc = "< The key lease time of a host/service in milliseconds."]
11378 pub mKeyLease: u32,
11379 #[doc = "< The remaining lease time of the host/service in milliseconds."]
11380 pub mRemainingLease: u32,
11381 #[doc = "< The remaining key lease time of a host/service in milliseconds."]
11382 pub mRemainingKeyLease: u32,
11383}
11384#[doc = " Includes the statistics of SRP server responses."]
11385#[repr(C)]
11386#[derive(Debug, Default, Copy, Clone)]
11387pub struct otSrpServerResponseCounters {
11388 #[doc = "< The number of successful responses."]
11389 pub mSuccess: u32,
11390 #[doc = "< The number of server failure responses."]
11391 pub mServerFailure: u32,
11392 #[doc = "< The number of format error responses."]
11393 pub mFormatError: u32,
11394 #[doc = "< The number of 'name exists' responses."]
11395 pub mNameExists: u32,
11396 #[doc = "< The number of refused responses."]
11397 pub mRefused: u32,
11398 #[doc = "< The number of other responses."]
11399 pub mOther: u32,
11400}
11401extern "C" {
11402 #[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."]
11403 pub fn otSrpServerGetDomain(aInstance: *mut otInstance) -> *const ::std::os::raw::c_char;
11404}
11405extern "C" {
11406 #[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."]
11407 pub fn otSrpServerSetDomain(
11408 aInstance: *mut otInstance,
11409 aDomain: *const ::std::os::raw::c_char,
11410 ) -> otError;
11411}
11412extern "C" {
11413 #[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."]
11414 pub fn otSrpServerGetState(aInstance: *mut otInstance) -> otSrpServerState;
11415}
11416extern "C" {
11417 #[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."]
11418 pub fn otSrpServerGetPort(aInstance: *mut otInstance) -> u16;
11419}
11420extern "C" {
11421 #[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."]
11422 pub fn otSrpServerGetAddressMode(aInstance: *mut otInstance) -> otSrpServerAddressMode;
11423}
11424extern "C" {
11425 #[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."]
11426 pub fn otSrpServerSetAddressMode(
11427 aInstance: *mut otInstance,
11428 aMode: otSrpServerAddressMode,
11429 ) -> otError;
11430}
11431extern "C" {
11432 #[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."]
11433 pub fn otSrpServerGetAnycastModeSequenceNumber(aInstance: *mut otInstance) -> u8;
11434}
11435extern "C" {
11436 #[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."]
11437 pub fn otSrpServerSetAnycastModeSequenceNumber(
11438 aInstance: *mut otInstance,
11439 aSequenceNumber: u8,
11440 ) -> otError;
11441}
11442extern "C" {
11443 #[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."]
11444 pub fn otSrpServerSetEnabled(aInstance: *mut otInstance, aEnabled: bool);
11445}
11446extern "C" {
11447 #[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."]
11448 pub fn otSrpServerSetAutoEnableMode(aInstance: *mut otInstance, aEnabled: bool);
11449}
11450extern "C" {
11451 #[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."]
11452 pub fn otSrpServerIsAutoEnableMode(aInstance: *mut otInstance) -> bool;
11453}
11454extern "C" {
11455 #[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)."]
11456 pub fn otSrpServerEnableFastStartMode(aInstance: *mut otInstance) -> otError;
11457}
11458extern "C" {
11459 #[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."]
11460 pub fn otSrpServerIsFastStartModeEnabled(aInstance: *mut otInstance) -> bool;
11461}
11462extern "C" {
11463 #[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."]
11464 pub fn otSrpServerGetTtlConfig(
11465 aInstance: *mut otInstance,
11466 aTtlConfig: *mut otSrpServerTtlConfig,
11467 );
11468}
11469extern "C" {
11470 #[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."]
11471 pub fn otSrpServerSetTtlConfig(
11472 aInstance: *mut otInstance,
11473 aTtlConfig: *const otSrpServerTtlConfig,
11474 ) -> otError;
11475}
11476extern "C" {
11477 #[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."]
11478 pub fn otSrpServerGetLeaseConfig(
11479 aInstance: *mut otInstance,
11480 aLeaseConfig: *mut otSrpServerLeaseConfig,
11481 );
11482}
11483extern "C" {
11484 #[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."]
11485 pub fn otSrpServerSetLeaseConfig(
11486 aInstance: *mut otInstance,
11487 aLeaseConfig: *const otSrpServerLeaseConfig,
11488 ) -> otError;
11489}
11490#[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"]
11491pub type otSrpServerServiceUpdateHandler = ::std::option::Option<
11492 unsafe extern "C" fn(
11493 aId: otSrpServerServiceUpdateId,
11494 aHost: *const otSrpServerHost,
11495 aTimeout: u32,
11496 aContext: *mut ::std::os::raw::c_void,
11497 ),
11498>;
11499extern "C" {
11500 #[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."]
11501 pub fn otSrpServerSetServiceUpdateHandler(
11502 aInstance: *mut otInstance,
11503 aServiceHandler: otSrpServerServiceUpdateHandler,
11504 aContext: *mut ::std::os::raw::c_void,
11505 );
11506}
11507extern "C" {
11508 #[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."]
11509 pub fn otSrpServerHandleServiceUpdateResult(
11510 aInstance: *mut otInstance,
11511 aId: otSrpServerServiceUpdateId,
11512 aError: otError,
11513 );
11514}
11515extern "C" {
11516 #[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."]
11517 pub fn otSrpServerGetNextHost(
11518 aInstance: *mut otInstance,
11519 aHost: *const otSrpServerHost,
11520 ) -> *const otSrpServerHost;
11521}
11522extern "C" {
11523 #[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."]
11524 pub fn otSrpServerGetResponseCounters(
11525 aInstance: *mut otInstance,
11526 ) -> *const otSrpServerResponseCounters;
11527}
11528extern "C" {
11529 #[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."]
11530 pub fn otSrpServerHostIsDeleted(aHost: *const otSrpServerHost) -> bool;
11531}
11532extern "C" {
11533 #[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."]
11534 pub fn otSrpServerHostGetFullName(
11535 aHost: *const otSrpServerHost,
11536 ) -> *const ::std::os::raw::c_char;
11537}
11538extern "C" {
11539 #[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."]
11540 pub fn otSrpServerHostMatchesFullName(
11541 aHost: *const otSrpServerHost,
11542 aFullName: *const ::std::os::raw::c_char,
11543 ) -> bool;
11544}
11545extern "C" {
11546 #[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."]
11547 pub fn otSrpServerHostGetAddresses(
11548 aHost: *const otSrpServerHost,
11549 aAddressesNum: *mut u8,
11550 ) -> *const otIp6Address;
11551}
11552extern "C" {
11553 #[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."]
11554 pub fn otSrpServerHostGetLeaseInfo(
11555 aHost: *const otSrpServerHost,
11556 aLeaseInfo: *mut otSrpServerLeaseInfo,
11557 );
11558}
11559extern "C" {
11560 #[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."]
11561 pub fn otSrpServerHostGetNextService(
11562 aHost: *const otSrpServerHost,
11563 aService: *const otSrpServerService,
11564 ) -> *const otSrpServerService;
11565}
11566extern "C" {
11567 #[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."]
11568 pub fn otSrpServerServiceIsDeleted(aService: *const otSrpServerService) -> bool;
11569}
11570extern "C" {
11571 #[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."]
11572 pub fn otSrpServerServiceGetInstanceName(
11573 aService: *const otSrpServerService,
11574 ) -> *const ::std::os::raw::c_char;
11575}
11576extern "C" {
11577 #[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."]
11578 pub fn otSrpServerServiceMatchesInstanceName(
11579 aService: *const otSrpServerService,
11580 aInstanceName: *const ::std::os::raw::c_char,
11581 ) -> bool;
11582}
11583extern "C" {
11584 #[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.."]
11585 pub fn otSrpServerServiceGetInstanceLabel(
11586 aService: *const otSrpServerService,
11587 ) -> *const ::std::os::raw::c_char;
11588}
11589extern "C" {
11590 #[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."]
11591 pub fn otSrpServerServiceGetServiceName(
11592 aService: *const otSrpServerService,
11593 ) -> *const ::std::os::raw::c_char;
11594}
11595extern "C" {
11596 #[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."]
11597 pub fn otSrpServerServiceMatchesServiceName(
11598 aService: *const otSrpServerService,
11599 aServiceName: *const ::std::os::raw::c_char,
11600 ) -> bool;
11601}
11602extern "C" {
11603 #[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."]
11604 pub fn otSrpServerServiceGetNumberOfSubTypes(aService: *const otSrpServerService) -> u16;
11605}
11606extern "C" {
11607 #[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."]
11608 pub fn otSrpServerServiceGetSubTypeServiceNameAt(
11609 aService: *const otSrpServerService,
11610 aIndex: u16,
11611 ) -> *const ::std::os::raw::c_char;
11612}
11613extern "C" {
11614 #[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."]
11615 pub fn otSrpServerServiceHasSubTypeServiceName(
11616 aService: *const otSrpServerService,
11617 aSubTypeServiceName: *const ::std::os::raw::c_char,
11618 ) -> bool;
11619}
11620extern "C" {
11621 #[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."]
11622 pub fn otSrpServerParseSubTypeServiceName(
11623 aSubTypeServiceName: *const ::std::os::raw::c_char,
11624 aLabel: *mut ::std::os::raw::c_char,
11625 aLabelSize: u8,
11626 ) -> otError;
11627}
11628extern "C" {
11629 #[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."]
11630 pub fn otSrpServerServiceGetPort(aService: *const otSrpServerService) -> u16;
11631}
11632extern "C" {
11633 #[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."]
11634 pub fn otSrpServerServiceGetWeight(aService: *const otSrpServerService) -> u16;
11635}
11636extern "C" {
11637 #[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."]
11638 pub fn otSrpServerServiceGetPriority(aService: *const otSrpServerService) -> u16;
11639}
11640extern "C" {
11641 #[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.."]
11642 pub fn otSrpServerServiceGetTtl(aService: *const otSrpServerService) -> u32;
11643}
11644extern "C" {
11645 #[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)."]
11646 pub fn otSrpServerServiceGetTxtData(
11647 aService: *const otSrpServerService,
11648 aDataLength: *mut u16,
11649 ) -> *const u8;
11650}
11651extern "C" {
11652 #[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."]
11653 pub fn otSrpServerServiceGetHost(aService: *const otSrpServerService)
11654 -> *const otSrpServerHost;
11655}
11656extern "C" {
11657 #[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."]
11658 pub fn otSrpServerServiceGetLeaseInfo(
11659 aService: *const otSrpServerService,
11660 aLeaseInfo: *mut otSrpServerLeaseInfo,
11661 );
11662}
11663extern "C" {
11664 #[doc = " Run all queued OpenThread tasklets at the time this is called.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
11665 pub fn otTaskletsProcess(aInstance: *mut otInstance);
11666}
11667extern "C" {
11668 #[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."]
11669 pub fn otTaskletsArePending(aInstance: *mut otInstance) -> bool;
11670}
11671extern "C" {
11672 #[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."]
11673 pub fn otTaskletsSignalPending(aInstance: *mut otInstance);
11674}
11675#[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."]
11676#[repr(C)]
11677#[derive(Debug, Copy, Clone)]
11678pub struct otLinkedBuffer {
11679 #[doc = "< Pointer to the next linked buffer in the chain, or NULL if it is the end."]
11680 pub mNext: *mut otLinkedBuffer,
11681 #[doc = "< Pointer to data referenced by this linked buffer."]
11682 pub mData: *const u8,
11683 #[doc = "< Length of this linked buffer (number of bytes)."]
11684 pub mLength: usize,
11685}
11686impl Default for otLinkedBuffer {
11687 fn default() -> Self {
11688 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11689 unsafe {
11690 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11691 s.assume_init()
11692 }
11693 }
11694}
11695#[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."]
11696pub type otTcpEstablished =
11697 ::std::option::Option<unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint)>;
11698#[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."]
11699pub type otTcpSendDone = ::std::option::Option<
11700 unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aData: *mut otLinkedBuffer),
11701>;
11702#[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)."]
11703pub type otTcpForwardProgress = ::std::option::Option<
11704 unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aInSendBuffer: usize, aBacklog: usize),
11705>;
11706#[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."]
11707pub type otTcpReceiveAvailable = ::std::option::Option<
11708 unsafe extern "C" fn(
11709 aEndpoint: *mut otTcpEndpoint,
11710 aBytesAvailable: usize,
11711 aEndOfStream: bool,
11712 aBytesRemaining: usize,
11713 ),
11714>;
11715pub const OT_TCP_DISCONNECTED_REASON_NORMAL: otTcpDisconnectedReason = 0;
11716pub const OT_TCP_DISCONNECTED_REASON_REFUSED: otTcpDisconnectedReason = 1;
11717pub const OT_TCP_DISCONNECTED_REASON_RESET: otTcpDisconnectedReason = 2;
11718pub const OT_TCP_DISCONNECTED_REASON_TIME_WAIT: otTcpDisconnectedReason = 3;
11719pub const OT_TCP_DISCONNECTED_REASON_TIMED_OUT: otTcpDisconnectedReason = 4;
11720pub type otTcpDisconnectedReason = ::std::os::raw::c_uint;
11721#[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."]
11722pub type otTcpDisconnected = ::std::option::Option<
11723 unsafe extern "C" fn(aEndpoint: *mut otTcpEndpoint, aReason: otTcpDisconnectedReason),
11724>;
11725#[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."]
11726#[repr(C)]
11727#[derive(Copy, Clone)]
11728pub struct otTcpEndpoint {
11729 pub mTcb: otTcpEndpoint__bindgen_ty_1,
11730 #[doc = "< A pointer to the next TCP endpoint (internal use only)"]
11731 pub mNext: *mut otTcpEndpoint,
11732 #[doc = "< A pointer to application-specific context"]
11733 pub mContext: *mut ::std::os::raw::c_void,
11734 #[doc = "< \"Established\" callback function"]
11735 pub mEstablishedCallback: otTcpEstablished,
11736 #[doc = "< \"Send done\" callback function"]
11737 pub mSendDoneCallback: otTcpSendDone,
11738 #[doc = "< \"Forward progress\" callback function"]
11739 pub mForwardProgressCallback: otTcpForwardProgress,
11740 #[doc = "< \"Receive available\" callback function"]
11741 pub mReceiveAvailableCallback: otTcpReceiveAvailable,
11742 #[doc = "< \"Disconnected\" callback function"]
11743 pub mDisconnectedCallback: otTcpDisconnected,
11744 pub mTimers: [u32; 4usize],
11745 pub mReceiveLinks: [otLinkedBuffer; 2usize],
11746 pub mSockAddr: otSockAddr,
11747 pub mPendingCallbacks: u8,
11748}
11749#[repr(C)]
11750#[derive(Copy, Clone)]
11751pub union otTcpEndpoint__bindgen_ty_1 {
11752 pub mSize: [u8; 680usize],
11753 pub mAlign: u64,
11754}
11755impl Default for otTcpEndpoint__bindgen_ty_1 {
11756 fn default() -> Self {
11757 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11758 unsafe {
11759 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11760 s.assume_init()
11761 }
11762 }
11763}
11764impl Default for otTcpEndpoint {
11765 fn default() -> Self {
11766 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11767 unsafe {
11768 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11769 s.assume_init()
11770 }
11771 }
11772}
11773#[doc = " Contains arguments to the otTcpEndpointInitialize() function."]
11774#[repr(C)]
11775#[derive(Debug, Copy, Clone)]
11776pub struct otTcpEndpointInitializeArgs {
11777 #[doc = "< Pointer to application-specific context"]
11778 pub mContext: *mut ::std::os::raw::c_void,
11779 #[doc = "< \"Established\" callback function"]
11780 pub mEstablishedCallback: otTcpEstablished,
11781 #[doc = "< \"Send done\" callback function"]
11782 pub mSendDoneCallback: otTcpSendDone,
11783 #[doc = "< \"Forward progress\" callback function"]
11784 pub mForwardProgressCallback: otTcpForwardProgress,
11785 #[doc = "< \"Receive available\" callback function"]
11786 pub mReceiveAvailableCallback: otTcpReceiveAvailable,
11787 #[doc = "< \"Disconnected\" callback function"]
11788 pub mDisconnectedCallback: otTcpDisconnected,
11789 #[doc = "< Pointer to memory provided to the system for the TCP receive buffer"]
11790 pub mReceiveBuffer: *mut ::std::os::raw::c_void,
11791 #[doc = "< Size of memory provided to the system for the TCP receive buffer"]
11792 pub mReceiveBufferSize: usize,
11793}
11794impl Default for otTcpEndpointInitializeArgs {
11795 fn default() -> Self {
11796 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11797 unsafe {
11798 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11799 s.assume_init()
11800 }
11801 }
11802}
11803extern "C" {
11804 #[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."]
11805 pub fn otTcpEndpointInitialize(
11806 aInstance: *mut otInstance,
11807 aEndpoint: *mut otTcpEndpoint,
11808 aArgs: *const otTcpEndpointInitializeArgs,
11809 ) -> otError;
11810}
11811extern "C" {
11812 #[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."]
11813 pub fn otTcpEndpointGetInstance(aEndpoint: *mut otTcpEndpoint) -> *mut otInstance;
11814}
11815extern "C" {
11816 #[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."]
11817 pub fn otTcpEndpointGetContext(aEndpoint: *mut otTcpEndpoint) -> *mut ::std::os::raw::c_void;
11818}
11819extern "C" {
11820 #[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."]
11821 pub fn otTcpGetLocalAddress(aEndpoint: *const otTcpEndpoint) -> *const otSockAddr;
11822}
11823extern "C" {
11824 #[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."]
11825 pub fn otTcpGetPeerAddress(aEndpoint: *const otTcpEndpoint) -> *const otSockAddr;
11826}
11827extern "C" {
11828 #[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."]
11829 pub fn otTcpBind(aEndpoint: *mut otTcpEndpoint, aSockName: *const otSockAddr) -> otError;
11830}
11831pub const OT_TCP_CONNECT_NO_FAST_OPEN: _bindgen_ty_11 = 1;
11832#[doc = " Defines flags passed to otTcpConnect()."]
11833pub type _bindgen_ty_11 = ::std::os::raw::c_uint;
11834extern "C" {
11835 #[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."]
11836 pub fn otTcpConnect(
11837 aEndpoint: *mut otTcpEndpoint,
11838 aSockName: *const otSockAddr,
11839 aFlags: u32,
11840 ) -> otError;
11841}
11842pub const OT_TCP_SEND_MORE_TO_COME: _bindgen_ty_12 = 1;
11843#[doc = " Defines flags passed to @p otTcpSendByReference."]
11844pub type _bindgen_ty_12 = ::std::os::raw::c_uint;
11845extern "C" {
11846 #[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."]
11847 pub fn otTcpSendByReference(
11848 aEndpoint: *mut otTcpEndpoint,
11849 aBuffer: *mut otLinkedBuffer,
11850 aFlags: u32,
11851 ) -> otError;
11852}
11853extern "C" {
11854 #[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."]
11855 pub fn otTcpSendByExtension(
11856 aEndpoint: *mut otTcpEndpoint,
11857 aNumBytes: usize,
11858 aFlags: u32,
11859 ) -> otError;
11860}
11861extern "C" {
11862 #[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."]
11863 pub fn otTcpReceiveByReference(
11864 aEndpoint: *mut otTcpEndpoint,
11865 aBuffer: *mut *const otLinkedBuffer,
11866 ) -> otError;
11867}
11868extern "C" {
11869 #[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."]
11870 pub fn otTcpReceiveContiguify(aEndpoint: *mut otTcpEndpoint) -> otError;
11871}
11872extern "C" {
11873 #[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."]
11874 pub fn otTcpCommitReceive(
11875 aEndpoint: *mut otTcpEndpoint,
11876 aNumBytes: usize,
11877 aFlags: u32,
11878 ) -> otError;
11879}
11880extern "C" {
11881 #[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."]
11882 pub fn otTcpSendEndOfStream(aEndpoint: *mut otTcpEndpoint) -> otError;
11883}
11884extern "C" {
11885 #[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."]
11886 pub fn otTcpAbort(aEndpoint: *mut otTcpEndpoint) -> otError;
11887}
11888extern "C" {
11889 #[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."]
11890 pub fn otTcpEndpointDeinitialize(aEndpoint: *mut otTcpEndpoint) -> otError;
11891}
11892#[doc = "< Accept the incoming connection."]
11893pub const OT_TCP_INCOMING_CONNECTION_ACTION_ACCEPT: otTcpIncomingConnectionAction = 0;
11894#[doc = "< Defer (silently ignore) the incoming connection."]
11895pub const OT_TCP_INCOMING_CONNECTION_ACTION_DEFER: otTcpIncomingConnectionAction = 1;
11896#[doc = "< Refuse the incoming connection."]
11897pub const OT_TCP_INCOMING_CONNECTION_ACTION_REFUSE: otTcpIncomingConnectionAction = 2;
11898#[doc = " Defines incoming connection actions.\n\n This is used in otTcpAcceptReady() callback."]
11899pub type otTcpIncomingConnectionAction = ::std::os::raw::c_uint;
11900#[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."]
11901pub type otTcpAcceptReady = ::std::option::Option<
11902 unsafe extern "C" fn(
11903 aListener: *mut otTcpListener,
11904 aPeer: *const otSockAddr,
11905 aAcceptInto: *mut *mut otTcpEndpoint,
11906 ) -> otTcpIncomingConnectionAction,
11907>;
11908#[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."]
11909pub type otTcpAcceptDone = ::std::option::Option<
11910 unsafe extern "C" fn(
11911 aListener: *mut otTcpListener,
11912 aEndpoint: *mut otTcpEndpoint,
11913 aPeer: *const otSockAddr,
11914 ),
11915>;
11916#[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."]
11917#[repr(C)]
11918#[derive(Copy, Clone)]
11919pub struct otTcpListener {
11920 pub mTcbListen: otTcpListener__bindgen_ty_1,
11921 #[doc = "< A pointer to the next TCP listener (internal use only)"]
11922 pub mNext: *mut otTcpListener,
11923 #[doc = "< A pointer to application-specific context"]
11924 pub mContext: *mut ::std::os::raw::c_void,
11925 #[doc = "< \"Accept ready\" callback function"]
11926 pub mAcceptReadyCallback: otTcpAcceptReady,
11927 #[doc = "< \"Accept done\" callback function"]
11928 pub mAcceptDoneCallback: otTcpAcceptDone,
11929}
11930#[repr(C)]
11931#[derive(Copy, Clone)]
11932pub union otTcpListener__bindgen_ty_1 {
11933 pub mSize: [u8; 40usize],
11934 pub mAlign: *mut ::std::os::raw::c_void,
11935}
11936impl Default for otTcpListener__bindgen_ty_1 {
11937 fn default() -> Self {
11938 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11939 unsafe {
11940 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11941 s.assume_init()
11942 }
11943 }
11944}
11945impl Default for otTcpListener {
11946 fn default() -> Self {
11947 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11948 unsafe {
11949 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11950 s.assume_init()
11951 }
11952 }
11953}
11954#[doc = " Contains arguments to the otTcpListenerInitialize() function."]
11955#[repr(C)]
11956#[derive(Debug, Copy, Clone)]
11957pub struct otTcpListenerInitializeArgs {
11958 #[doc = "< Pointer to application-specific context"]
11959 pub mContext: *mut ::std::os::raw::c_void,
11960 #[doc = "< \"Accept ready\" callback function"]
11961 pub mAcceptReadyCallback: otTcpAcceptReady,
11962 #[doc = "< \"Accept done\" callback function"]
11963 pub mAcceptDoneCallback: otTcpAcceptDone,
11964}
11965impl Default for otTcpListenerInitializeArgs {
11966 fn default() -> Self {
11967 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
11968 unsafe {
11969 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
11970 s.assume_init()
11971 }
11972 }
11973}
11974extern "C" {
11975 #[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."]
11976 pub fn otTcpListenerInitialize(
11977 aInstance: *mut otInstance,
11978 aListener: *mut otTcpListener,
11979 aArgs: *const otTcpListenerInitializeArgs,
11980 ) -> otError;
11981}
11982extern "C" {
11983 #[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."]
11984 pub fn otTcpListenerGetInstance(aListener: *mut otTcpListener) -> *mut otInstance;
11985}
11986extern "C" {
11987 #[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."]
11988 pub fn otTcpListenerGetContext(aListener: *mut otTcpListener) -> *mut ::std::os::raw::c_void;
11989}
11990extern "C" {
11991 #[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."]
11992 pub fn otTcpListen(aListener: *mut otTcpListener, aSockName: *const otSockAddr) -> otError;
11993}
11994extern "C" {
11995 #[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."]
11996 pub fn otTcpStopListening(aListener: *mut otTcpListener) -> otError;
11997}
11998extern "C" {
11999 #[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."]
12000 pub fn otTcpListenerDeinitialize(aListener: *mut otTcpListener) -> otError;
12001}
12002#[doc = " Holds diagnostic information for a Thread Child"]
12003#[repr(C)]
12004#[derive(Debug, Default, Copy, Clone)]
12005pub struct otChildInfo {
12006 #[doc = "< IEEE 802.15.4 Extended Address"]
12007 pub mExtAddress: otExtAddress,
12008 #[doc = "< Timeout"]
12009 pub mTimeout: u32,
12010 #[doc = "< Seconds since last heard"]
12011 pub mAge: u32,
12012 #[doc = "< Seconds since attach"]
12013 pub mConnectionTime: u64,
12014 #[doc = "< RLOC16"]
12015 pub mRloc16: u16,
12016 #[doc = "< Child ID"]
12017 pub mChildId: u16,
12018 #[doc = "< Network Data Version"]
12019 pub mNetworkDataVersion: u8,
12020 #[doc = "< Link Quality In"]
12021 pub mLinkQualityIn: u8,
12022 #[doc = "< Average RSSI"]
12023 pub mAverageRssi: i8,
12024 #[doc = "< Last observed RSSI"]
12025 pub mLastRssi: i8,
12026 #[doc = "< Frame error rate (0xffff->100%). Requires error tracking feature."]
12027 pub mFrameErrorRate: u16,
12028 #[doc = "< (IPv6) msg error rate (0xffff->100%). Requires error tracking feature."]
12029 pub mMessageErrorRate: u16,
12030 #[doc = "< Number of queued messages for the child."]
12031 pub mQueuedMessageCnt: u16,
12032 #[doc = "< Supervision interval (in seconds)."]
12033 pub mSupervisionInterval: u16,
12034 #[doc = "< MLE version"]
12035 pub mVersion: u8,
12036 pub _bitfield_align_1: [u8; 0],
12037 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12038 pub __bindgen_padding_0: [u16; 3usize],
12039}
12040impl otChildInfo {
12041 #[inline]
12042 pub fn mRxOnWhenIdle(&self) -> bool {
12043 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
12044 }
12045 #[inline]
12046 pub fn set_mRxOnWhenIdle(&mut self, val: bool) {
12047 unsafe {
12048 let val: u8 = ::std::mem::transmute(val);
12049 self._bitfield_1.set(0usize, 1u8, val as u64)
12050 }
12051 }
12052 #[inline]
12053 pub fn mFullThreadDevice(&self) -> bool {
12054 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
12055 }
12056 #[inline]
12057 pub fn set_mFullThreadDevice(&mut self, val: bool) {
12058 unsafe {
12059 let val: u8 = ::std::mem::transmute(val);
12060 self._bitfield_1.set(1usize, 1u8, val as u64)
12061 }
12062 }
12063 #[inline]
12064 pub fn mFullNetworkData(&self) -> bool {
12065 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
12066 }
12067 #[inline]
12068 pub fn set_mFullNetworkData(&mut self, val: bool) {
12069 unsafe {
12070 let val: u8 = ::std::mem::transmute(val);
12071 self._bitfield_1.set(2usize, 1u8, val as u64)
12072 }
12073 }
12074 #[inline]
12075 pub fn mIsStateRestoring(&self) -> bool {
12076 unsafe { ::std::mem::transmute(self._bitfield_1.get(3usize, 1u8) as u8) }
12077 }
12078 #[inline]
12079 pub fn set_mIsStateRestoring(&mut self, val: bool) {
12080 unsafe {
12081 let val: u8 = ::std::mem::transmute(val);
12082 self._bitfield_1.set(3usize, 1u8, val as u64)
12083 }
12084 }
12085 #[inline]
12086 pub fn mIsCslSynced(&self) -> bool {
12087 unsafe { ::std::mem::transmute(self._bitfield_1.get(4usize, 1u8) as u8) }
12088 }
12089 #[inline]
12090 pub fn set_mIsCslSynced(&mut self, val: bool) {
12091 unsafe {
12092 let val: u8 = ::std::mem::transmute(val);
12093 self._bitfield_1.set(4usize, 1u8, val as u64)
12094 }
12095 }
12096 #[inline]
12097 pub fn new_bitfield_1(
12098 mRxOnWhenIdle: bool,
12099 mFullThreadDevice: bool,
12100 mFullNetworkData: bool,
12101 mIsStateRestoring: bool,
12102 mIsCslSynced: bool,
12103 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12104 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12105 __bindgen_bitfield_unit.set(0usize, 1u8, {
12106 let mRxOnWhenIdle: u8 = unsafe { ::std::mem::transmute(mRxOnWhenIdle) };
12107 mRxOnWhenIdle as u64
12108 });
12109 __bindgen_bitfield_unit.set(1usize, 1u8, {
12110 let mFullThreadDevice: u8 = unsafe { ::std::mem::transmute(mFullThreadDevice) };
12111 mFullThreadDevice as u64
12112 });
12113 __bindgen_bitfield_unit.set(2usize, 1u8, {
12114 let mFullNetworkData: u8 = unsafe { ::std::mem::transmute(mFullNetworkData) };
12115 mFullNetworkData as u64
12116 });
12117 __bindgen_bitfield_unit.set(3usize, 1u8, {
12118 let mIsStateRestoring: u8 = unsafe { ::std::mem::transmute(mIsStateRestoring) };
12119 mIsStateRestoring as u64
12120 });
12121 __bindgen_bitfield_unit.set(4usize, 1u8, {
12122 let mIsCslSynced: u8 = unsafe { ::std::mem::transmute(mIsCslSynced) };
12123 mIsCslSynced as u64
12124 });
12125 __bindgen_bitfield_unit
12126 }
12127}
12128pub type otChildIp6AddressIterator = u16;
12129pub const OT_CACHE_ENTRY_STATE_CACHED: otCacheEntryState = 0;
12130pub const OT_CACHE_ENTRY_STATE_SNOOPED: otCacheEntryState = 1;
12131pub const OT_CACHE_ENTRY_STATE_QUERY: otCacheEntryState = 2;
12132pub const OT_CACHE_ENTRY_STATE_RETRY_QUERY: otCacheEntryState = 3;
12133#[doc = " Defines the EID cache entry state."]
12134pub type otCacheEntryState = ::std::os::raw::c_uint;
12135#[doc = " Represents an EID cache entry."]
12136#[repr(C)]
12137#[derive(Copy, Clone)]
12138pub struct otCacheEntryInfo {
12139 #[doc = "< Target EID"]
12140 pub mTarget: otIp6Address,
12141 #[doc = "< RLOC16"]
12142 pub mRloc16: otShortAddress,
12143 #[doc = "< Entry state"]
12144 pub mState: otCacheEntryState,
12145 pub _bitfield_align_1: [u8; 0],
12146 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12147 #[doc = "< Last transaction time (applicable in cached state)."]
12148 pub mLastTransTime: u32,
12149 #[doc = "< Mesh Local EID (applicable if entry in cached state)."]
12150 pub mMeshLocalEid: otIp6Address,
12151 #[doc = "< Timeout in seconds (applicable if in snooped/query/retry-query states)."]
12152 pub mTimeout: u16,
12153 #[doc = "< Retry delay in seconds (applicable if in query-retry state)."]
12154 pub mRetryDelay: u16,
12155}
12156impl Default for otCacheEntryInfo {
12157 fn default() -> Self {
12158 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12159 unsafe {
12160 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12161 s.assume_init()
12162 }
12163 }
12164}
12165impl otCacheEntryInfo {
12166 #[inline]
12167 pub fn mCanEvict(&self) -> bool {
12168 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
12169 }
12170 #[inline]
12171 pub fn set_mCanEvict(&mut self, val: bool) {
12172 unsafe {
12173 let val: u8 = ::std::mem::transmute(val);
12174 self._bitfield_1.set(0usize, 1u8, val as u64)
12175 }
12176 }
12177 #[inline]
12178 pub fn mRampDown(&self) -> bool {
12179 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
12180 }
12181 #[inline]
12182 pub fn set_mRampDown(&mut self, val: bool) {
12183 unsafe {
12184 let val: u8 = ::std::mem::transmute(val);
12185 self._bitfield_1.set(1usize, 1u8, val as u64)
12186 }
12187 }
12188 #[inline]
12189 pub fn mValidLastTrans(&self) -> bool {
12190 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
12191 }
12192 #[inline]
12193 pub fn set_mValidLastTrans(&mut self, val: bool) {
12194 unsafe {
12195 let val: u8 = ::std::mem::transmute(val);
12196 self._bitfield_1.set(2usize, 1u8, val as u64)
12197 }
12198 }
12199 #[inline]
12200 pub fn new_bitfield_1(
12201 mCanEvict: bool,
12202 mRampDown: bool,
12203 mValidLastTrans: bool,
12204 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12205 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12206 __bindgen_bitfield_unit.set(0usize, 1u8, {
12207 let mCanEvict: u8 = unsafe { ::std::mem::transmute(mCanEvict) };
12208 mCanEvict as u64
12209 });
12210 __bindgen_bitfield_unit.set(1usize, 1u8, {
12211 let mRampDown: u8 = unsafe { ::std::mem::transmute(mRampDown) };
12212 mRampDown as u64
12213 });
12214 __bindgen_bitfield_unit.set(2usize, 1u8, {
12215 let mValidLastTrans: u8 = unsafe { ::std::mem::transmute(mValidLastTrans) };
12216 mValidLastTrans as u64
12217 });
12218 __bindgen_bitfield_unit
12219 }
12220}
12221#[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)."]
12222#[repr(C)]
12223#[derive(Debug, Copy, Clone)]
12224pub struct otCacheEntryIterator {
12225 #[doc = "< Opaque data used by the core implementation. Should not be changed by user."]
12226 pub mData: [*const ::std::os::raw::c_void; 2usize],
12227}
12228impl Default for otCacheEntryIterator {
12229 fn default() -> Self {
12230 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12231 unsafe {
12232 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12233 s.assume_init()
12234 }
12235 }
12236}
12237extern "C" {
12238 #[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"]
12239 pub fn otThreadGetMaxAllowedChildren(aInstance: *mut otInstance) -> u16;
12240}
12241extern "C" {
12242 #[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"]
12243 pub fn otThreadSetMaxAllowedChildren(aInstance: *mut otInstance, aMaxChildren: u16) -> otError;
12244}
12245extern "C" {
12246 #[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."]
12247 pub fn otThreadIsRouterEligible(aInstance: *mut otInstance) -> bool;
12248}
12249extern "C" {
12250 #[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."]
12251 pub fn otThreadSetRouterEligible(aInstance: *mut otInstance, aEligible: bool) -> otError;
12252}
12253extern "C" {
12254 #[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)"]
12255 pub fn otThreadSetPreferredRouterId(aInstance: *mut otInstance, aRouterId: u8) -> otError;
12256}
12257#[doc = "< Battery powered."]
12258pub const OT_POWER_SUPPLY_BATTERY: otPowerSupply = 0;
12259#[doc = "< Externally powered (mains-powered)."]
12260pub const OT_POWER_SUPPLY_EXTERNAL: otPowerSupply = 1;
12261#[doc = "< Stable external power with a battery backup or UPS."]
12262pub const OT_POWER_SUPPLY_EXTERNAL_STABLE: otPowerSupply = 2;
12263#[doc = "< Potentially unstable ext power (e.g. light bulb powered via a switch)."]
12264pub const OT_POWER_SUPPLY_EXTERNAL_UNSTABLE: otPowerSupply = 3;
12265#[doc = " Represents the power supply property on a device.\n\n This is used as a property in `otDeviceProperties` to calculate the leader weight."]
12266pub type otPowerSupply = ::std::os::raw::c_uint;
12267#[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."]
12268#[repr(C)]
12269#[derive(Debug, Copy, Clone)]
12270pub struct otDeviceProperties {
12271 #[doc = "< Power supply config."]
12272 pub mPowerSupply: otPowerSupply,
12273 pub _bitfield_align_1: [u8; 0],
12274 pub _bitfield_1: __BindgenBitfieldUnit<[u8; 1usize]>,
12275 #[doc = "< Weight adjustment. Should be -16 to +16 (clamped otherwise)."]
12276 pub mLeaderWeightAdjustment: i8,
12277}
12278impl Default for otDeviceProperties {
12279 fn default() -> Self {
12280 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12281 unsafe {
12282 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12283 s.assume_init()
12284 }
12285 }
12286}
12287impl otDeviceProperties {
12288 #[inline]
12289 pub fn mIsBorderRouter(&self) -> bool {
12290 unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u8) }
12291 }
12292 #[inline]
12293 pub fn set_mIsBorderRouter(&mut self, val: bool) {
12294 unsafe {
12295 let val: u8 = ::std::mem::transmute(val);
12296 self._bitfield_1.set(0usize, 1u8, val as u64)
12297 }
12298 }
12299 #[inline]
12300 pub fn mSupportsCcm(&self) -> bool {
12301 unsafe { ::std::mem::transmute(self._bitfield_1.get(1usize, 1u8) as u8) }
12302 }
12303 #[inline]
12304 pub fn set_mSupportsCcm(&mut self, val: bool) {
12305 unsafe {
12306 let val: u8 = ::std::mem::transmute(val);
12307 self._bitfield_1.set(1usize, 1u8, val as u64)
12308 }
12309 }
12310 #[inline]
12311 pub fn mIsUnstable(&self) -> bool {
12312 unsafe { ::std::mem::transmute(self._bitfield_1.get(2usize, 1u8) as u8) }
12313 }
12314 #[inline]
12315 pub fn set_mIsUnstable(&mut self, val: bool) {
12316 unsafe {
12317 let val: u8 = ::std::mem::transmute(val);
12318 self._bitfield_1.set(2usize, 1u8, val as u64)
12319 }
12320 }
12321 #[inline]
12322 pub fn new_bitfield_1(
12323 mIsBorderRouter: bool,
12324 mSupportsCcm: bool,
12325 mIsUnstable: bool,
12326 ) -> __BindgenBitfieldUnit<[u8; 1usize]> {
12327 let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 1usize]> = Default::default();
12328 __bindgen_bitfield_unit.set(0usize, 1u8, {
12329 let mIsBorderRouter: u8 = unsafe { ::std::mem::transmute(mIsBorderRouter) };
12330 mIsBorderRouter as u64
12331 });
12332 __bindgen_bitfield_unit.set(1usize, 1u8, {
12333 let mSupportsCcm: u8 = unsafe { ::std::mem::transmute(mSupportsCcm) };
12334 mSupportsCcm as u64
12335 });
12336 __bindgen_bitfield_unit.set(2usize, 1u8, {
12337 let mIsUnstable: u8 = unsafe { ::std::mem::transmute(mIsUnstable) };
12338 mIsUnstable as u64
12339 });
12340 __bindgen_bitfield_unit
12341 }
12342}
12343extern "C" {
12344 #[doc = " Get the current device properties.\n\n Requires `OPENTHREAD_CONFIG_MLE_DEVICE_PROPERTY_LEADER_WEIGHT_ENABLE`.\n\n @returns The device properties `otDeviceProperties`."]
12345 pub fn otThreadGetDeviceProperties(aInstance: *mut otInstance) -> *const otDeviceProperties;
12346}
12347extern "C" {
12348 #[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."]
12349 pub fn otThreadSetDeviceProperties(
12350 aInstance: *mut otInstance,
12351 aDeviceProperties: *const otDeviceProperties,
12352 );
12353}
12354extern "C" {
12355 #[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"]
12356 pub fn otThreadGetLocalLeaderWeight(aInstance: *mut otInstance) -> u8;
12357}
12358extern "C" {
12359 #[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"]
12360 pub fn otThreadSetLocalLeaderWeight(aInstance: *mut otInstance, aWeight: u8);
12361}
12362extern "C" {
12363 #[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."]
12364 pub fn otThreadGetPreferredLeaderPartitionId(aInstance: *mut otInstance) -> u32;
12365}
12366extern "C" {
12367 #[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."]
12368 pub fn otThreadSetPreferredLeaderPartitionId(aInstance: *mut otInstance, aPartitionId: u32);
12369}
12370extern "C" {
12371 #[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"]
12372 pub fn otThreadGetJoinerUdpPort(aInstance: *mut otInstance) -> u16;
12373}
12374extern "C" {
12375 #[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"]
12376 pub fn otThreadSetJoinerUdpPort(aInstance: *mut otInstance, aJoinerUdpPort: u16) -> otError;
12377}
12378extern "C" {
12379 #[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."]
12380 pub fn otThreadSetSteeringData(aInstance: *mut otInstance, aExtAddress: *const otExtAddress);
12381}
12382extern "C" {
12383 #[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"]
12384 pub fn otThreadGetContextIdReuseDelay(aInstance: *mut otInstance) -> u32;
12385}
12386extern "C" {
12387 #[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"]
12388 pub fn otThreadSetContextIdReuseDelay(aInstance: *mut otInstance, aDelay: u32);
12389}
12390extern "C" {
12391 #[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"]
12392 pub fn otThreadGetNetworkIdTimeout(aInstance: *mut otInstance) -> u8;
12393}
12394extern "C" {
12395 #[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"]
12396 pub fn otThreadSetNetworkIdTimeout(aInstance: *mut otInstance, aTimeout: u8);
12397}
12398extern "C" {
12399 #[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"]
12400 pub fn otThreadGetRouterUpgradeThreshold(aInstance: *mut otInstance) -> u8;
12401}
12402extern "C" {
12403 #[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"]
12404 pub fn otThreadSetRouterUpgradeThreshold(aInstance: *mut otInstance, aThreshold: u8);
12405}
12406extern "C" {
12407 #[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"]
12408 pub fn otThreadGetChildRouterLinks(aInstance: *mut otInstance) -> u8;
12409}
12410extern "C" {
12411 #[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"]
12412 pub fn otThreadSetChildRouterLinks(
12413 aInstance: *mut otInstance,
12414 aChildRouterLinks: u8,
12415 ) -> otError;
12416}
12417extern "C" {
12418 #[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."]
12419 pub fn otThreadReleaseRouterId(aInstance: *mut otInstance, aRouterId: u8) -> otError;
12420}
12421extern "C" {
12422 #[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."]
12423 pub fn otThreadBecomeRouter(aInstance: *mut otInstance) -> otError;
12424}
12425extern "C" {
12426 #[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."]
12427 pub fn otThreadBecomeLeader(aInstance: *mut otInstance) -> otError;
12428}
12429extern "C" {
12430 #[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"]
12431 pub fn otThreadGetRouterDowngradeThreshold(aInstance: *mut otInstance) -> u8;
12432}
12433extern "C" {
12434 #[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"]
12435 pub fn otThreadSetRouterDowngradeThreshold(aInstance: *mut otInstance, aThreshold: u8);
12436}
12437extern "C" {
12438 #[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"]
12439 pub fn otThreadGetRouterSelectionJitter(aInstance: *mut otInstance) -> u8;
12440}
12441extern "C" {
12442 #[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"]
12443 pub fn otThreadSetRouterSelectionJitter(aInstance: *mut otInstance, aRouterJitter: u8);
12444}
12445extern "C" {
12446 #[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."]
12447 pub fn otThreadGetChildInfoById(
12448 aInstance: *mut otInstance,
12449 aChildId: u16,
12450 aChildInfo: *mut otChildInfo,
12451 ) -> otError;
12452}
12453extern "C" {
12454 #[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"]
12455 pub fn otThreadGetChildInfoByIndex(
12456 aInstance: *mut otInstance,
12457 aChildIndex: u16,
12458 aChildInfo: *mut otChildInfo,
12459 ) -> otError;
12460}
12461extern "C" {
12462 #[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"]
12463 pub fn otThreadGetChildNextIp6Address(
12464 aInstance: *mut otInstance,
12465 aChildIndex: u16,
12466 aIterator: *mut otChildIp6AddressIterator,
12467 aAddress: *mut otIp6Address,
12468 ) -> otError;
12469}
12470extern "C" {
12471 #[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."]
12472 pub fn otThreadGetRouterIdSequence(aInstance: *mut otInstance) -> u8;
12473}
12474extern "C" {
12475 #[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."]
12476 pub fn otThreadGetMaxRouterId(aInstance: *mut otInstance) -> u8;
12477}
12478extern "C" {
12479 #[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."]
12480 pub fn otThreadGetRouterInfo(
12481 aInstance: *mut otInstance,
12482 aRouterId: u16,
12483 aRouterInfo: *mut otRouterInfo,
12484 ) -> otError;
12485}
12486extern "C" {
12487 #[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."]
12488 pub fn otThreadGetNextCacheEntry(
12489 aInstance: *mut otInstance,
12490 aEntryInfo: *mut otCacheEntryInfo,
12491 aIterator: *mut otCacheEntryIterator,
12492 ) -> otError;
12493}
12494extern "C" {
12495 #[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"]
12496 pub fn otThreadGetPskc(aInstance: *mut otInstance, aPskc: *mut otPskc);
12497}
12498extern "C" {
12499 #[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"]
12500 pub fn otThreadGetPskcRef(aInstance: *mut otInstance) -> otPskcRef;
12501}
12502extern "C" {
12503 #[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"]
12504 pub fn otThreadSetPskc(aInstance: *mut otInstance, aPskc: *const otPskc) -> otError;
12505}
12506extern "C" {
12507 #[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"]
12508 pub fn otThreadSetPskcRef(aInstance: *mut otInstance, aKeyRef: otPskcRef) -> otError;
12509}
12510extern "C" {
12511 #[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"]
12512 pub fn otThreadGetParentPriority(aInstance: *mut otInstance) -> i8;
12513}
12514extern "C" {
12515 #[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"]
12516 pub fn otThreadSetParentPriority(aInstance: *mut otInstance, aParentPriority: i8) -> otError;
12517}
12518extern "C" {
12519 #[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"]
12520 pub fn otThreadGetMaxChildIpAddresses(aInstance: *mut otInstance) -> u8;
12521}
12522extern "C" {
12523 #[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"]
12524 pub fn otThreadSetMaxChildIpAddresses(
12525 aInstance: *mut otInstance,
12526 aMaxIpAddresses: u8,
12527 ) -> otError;
12528}
12529#[doc = "< A child is being added."]
12530pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_ADDED: otNeighborTableEvent = 0;
12531#[doc = "< A child is being removed."]
12532pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_REMOVED: otNeighborTableEvent = 1;
12533#[doc = "< An existing child's mode is changed."]
12534pub const OT_NEIGHBOR_TABLE_EVENT_CHILD_MODE_CHANGED: otNeighborTableEvent = 2;
12535#[doc = "< A router is being added."]
12536pub const OT_NEIGHBOR_TABLE_EVENT_ROUTER_ADDED: otNeighborTableEvent = 3;
12537#[doc = "< A router is being removed."]
12538pub const OT_NEIGHBOR_TABLE_EVENT_ROUTER_REMOVED: otNeighborTableEvent = 4;
12539#[doc = " Defines the constants used in `otNeighborTableCallback` to indicate changes in neighbor table."]
12540pub type otNeighborTableEvent = ::std::os::raw::c_uint;
12541#[doc = " Represent a neighbor table entry info (child or router) and is used as a parameter in the neighbor table\n callback `otNeighborTableCallback`."]
12542#[repr(C)]
12543#[derive(Copy, Clone)]
12544pub struct otNeighborTableEntryInfo {
12545 #[doc = "< The OpenThread instance."]
12546 pub mInstance: *mut otInstance,
12547 pub mInfo: otNeighborTableEntryInfo__bindgen_ty_1,
12548}
12549#[repr(C)]
12550#[derive(Copy, Clone)]
12551pub union otNeighborTableEntryInfo__bindgen_ty_1 {
12552 #[doc = "< The child neighbor info."]
12553 pub mChild: otChildInfo,
12554 #[doc = "< The router neighbor info."]
12555 pub mRouter: otNeighborInfo,
12556}
12557impl Default for otNeighborTableEntryInfo__bindgen_ty_1 {
12558 fn default() -> Self {
12559 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12560 unsafe {
12561 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12562 s.assume_init()
12563 }
12564 }
12565}
12566impl Default for otNeighborTableEntryInfo {
12567 fn default() -> Self {
12568 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12569 unsafe {
12570 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12571 s.assume_init()
12572 }
12573 }
12574}
12575#[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."]
12576pub type otNeighborTableCallback = ::std::option::Option<
12577 unsafe extern "C" fn(aEvent: otNeighborTableEvent, aEntryInfo: *const otNeighborTableEntryInfo),
12578>;
12579extern "C" {
12580 #[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."]
12581 pub fn otThreadRegisterNeighborTableCallback(
12582 aInstance: *mut otInstance,
12583 aCallback: otNeighborTableCallback,
12584 );
12585}
12586extern "C" {
12587 #[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."]
12588 pub fn otThreadSetCcmEnabled(aInstance: *mut otInstance, aEnabled: bool);
12589}
12590extern "C" {
12591 #[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."]
12592 pub fn otThreadSetThreadVersionCheckEnabled(aInstance: *mut otInstance, aEnabled: bool);
12593}
12594extern "C" {
12595 #[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."]
12596 pub fn otThreadSetTmfOriginFilterEnabled(aInstance: *mut otInstance, aEnabled: bool);
12597}
12598extern "C" {
12599 #[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."]
12600 pub fn otThreadIsTmfOriginFilterEnabled(aInstance: *mut otInstance) -> bool;
12601}
12602extern "C" {
12603 #[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"]
12604 pub fn otThreadGetRouterIdRange(
12605 aInstance: *mut otInstance,
12606 aMinRouterId: *mut u8,
12607 aMaxRouterId: *mut u8,
12608 );
12609}
12610extern "C" {
12611 #[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"]
12612 pub fn otThreadSetRouterIdRange(
12613 aInstance: *mut otInstance,
12614 aMinRouterId: u8,
12615 aMaxRouterId: u8,
12616 ) -> otError;
12617}
12618extern "C" {
12619 #[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."]
12620 pub fn otThreadGetAdvertisementTrickleIntervalMax(aInstance: *mut otInstance) -> u32;
12621}
12622extern "C" {
12623 #[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."]
12624 pub fn otThreadIsRouterIdAllocated(aInstance: *mut otInstance, aRouterId: u8) -> bool;
12625}
12626extern "C" {
12627 #[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."]
12628 pub fn otThreadGetNextHopAndPathCost(
12629 aInstance: *mut otInstance,
12630 aDestRloc16: u16,
12631 aNextHopRloc16: *mut u16,
12632 aPathCost: *mut u8,
12633 );
12634}
12635#[doc = " Represents a TREL peer."]
12636#[repr(C)]
12637#[derive(Copy, Clone)]
12638pub struct otTrelPeer {
12639 #[doc = "< The Extended MAC Address of TREL peer."]
12640 pub mExtAddress: otExtAddress,
12641 #[doc = "< The Extended PAN Identifier of TREL peer."]
12642 pub mExtPanId: otExtendedPanId,
12643 #[doc = "< The IPv6 socket address of TREL peer."]
12644 pub mSockAddr: otSockAddr,
12645}
12646impl Default for otTrelPeer {
12647 fn default() -> Self {
12648 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12649 unsafe {
12650 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12651 s.assume_init()
12652 }
12653 }
12654}
12655#[doc = " Represents an iterator for iterating over TREL peer table entries."]
12656pub type otTrelPeerIterator = *const ::std::os::raw::c_void;
12657extern "C" {
12658 #[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."]
12659 pub fn otTrelSetEnabled(aInstance: *mut otInstance, aEnable: bool);
12660}
12661extern "C" {
12662 #[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."]
12663 pub fn otTrelIsEnabled(aInstance: *mut otInstance) -> bool;
12664}
12665extern "C" {
12666 #[doc = " Initializes a peer table iterator.\n\n @param[in] aInstance The OpenThread instance.\n @param[in] aIterator The iterator to initialize."]
12667 pub fn otTrelInitPeerIterator(aInstance: *mut otInstance, aIterator: *mut otTrelPeerIterator);
12668}
12669extern "C" {
12670 #[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."]
12671 pub fn otTrelGetNextPeer(
12672 aInstance: *mut otInstance,
12673 aIterator: *mut otTrelPeerIterator,
12674 ) -> *const otTrelPeer;
12675}
12676extern "C" {
12677 #[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."]
12678 pub fn otTrelGetNumberOfPeers(aInstance: *mut otInstance) -> u16;
12679}
12680extern "C" {
12681 #[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."]
12682 pub fn otTrelSetFilterEnabled(aInstance: *mut otInstance, aEnable: bool);
12683}
12684extern "C" {
12685 #[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."]
12686 pub fn otTrelIsFilterEnabled(aInstance: *mut otInstance) -> bool;
12687}
12688#[doc = " Represents a group of TREL related counters in the platform layer."]
12689pub type otTrelCounters = otPlatTrelCounters;
12690extern "C" {
12691 #[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."]
12692 pub fn otTrelGetCounters(aInstance: *mut otInstance) -> *const otTrelCounters;
12693}
12694extern "C" {
12695 #[doc = " Resets the TREL counters.\n\n @param[in] aInstance A pointer to an OpenThread instance."]
12696 pub fn otTrelResetCounters(aInstance: *mut otInstance);
12697}
12698extern "C" {
12699 #[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."]
12700 pub fn otTrelGetUdpPort(aInstance: *mut otInstance) -> u16;
12701}
12702extern "C" {
12703 #[doc = " Calculates the Verhoeff checksum for a given decimal string.\n\n Requires `OPENTHREAD_CONFIG_VERHOEFF_CHECKSUM_ENABLE`.\n\n @param[in] aDecimalString The string containing decimal digits.\n @param[out] aChecksum Pointer to a `char` to return the calculated checksum.\n\n @retval OT_ERROR_NONE Successfully calculated the checksum, @p aChecksum is updated.\n @retval OT_ERROR_INVALID_ARGS The @p aDecimalString is not valid, i.e. it either contains chars other than\n ['0'-'9'], or is longer than `OT_VERHOEFF_CHECKSUM_MAX_STRING_LENGTH`."]
12704 pub fn otVerhoeffChecksumCalculate(
12705 aDecimalString: *const ::std::os::raw::c_char,
12706 aChecksum: *mut ::std::os::raw::c_char,
12707 ) -> otError;
12708}
12709extern "C" {
12710 #[doc = " Validates the Verhoeff checksum for a given decimal string.\n\n Requires `OPENTHREAD_CONFIG_VERHOEFF_CHECKSUM_ENABLE`.\n\n @param[in] aDecimalString The string containing decimal digits (last char is treated as checksum).\n\n @retval OT_ERROR_NONE Successfully validated the checksum in @p aDecimalString.\n @retval OT_ERROR_FAILED Checksum validation failed.\n @retval OT_ERROR_INVALID_ARGS The @p aDecimalString is not valid, i.e. it either contains chars other than\n ['0'-'9'], or is longer than `OT_VERHOEFF_CHECKSUM_MAX_STRING_LENGTH`."]
12711 pub fn otVerhoeffChecksumValidate(aDecimalString: *const ::std::os::raw::c_char) -> otError;
12712}
12713pub type __builtin_va_list = [__va_list_tag; 1usize];
12714#[repr(C)]
12715#[derive(Debug, Copy, Clone)]
12716pub struct __va_list_tag {
12717 pub gp_offset: ::std::os::raw::c_uint,
12718 pub fp_offset: ::std::os::raw::c_uint,
12719 pub overflow_arg_area: *mut ::std::os::raw::c_void,
12720 pub reg_save_area: *mut ::std::os::raw::c_void,
12721}
12722impl Default for __va_list_tag {
12723 fn default() -> Self {
12724 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
12725 unsafe {
12726 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
12727 s.assume_init()
12728 }
12729 }
12730}