#[repr(C)]
#[derive(Default)]
pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
impl<T> __IncompleteArrayField<T> {
#[inline]
pub const fn new() -> Self {
__IncompleteArrayField(::std::marker::PhantomData, [])
}
#[inline]
pub fn as_ptr(&self) -> *const T {
self as *const _ as *const T
}
#[inline]
pub fn as_mut_ptr(&mut self) -> *mut T {
self as *mut _ as *mut T
}
#[inline]
pub unsafe fn as_slice(&self, len: usize) -> &[T] {
::std::slice::from_raw_parts(self.as_ptr(), len)
}
#[inline]
pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
}
}
impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
fmt.write_str("__IncompleteArrayField")
}
}
pub const BLOB_COOKIE: u32 = 19088743;
pub const BLOB_ATTR_ID_MASK: u32 = 2130706432;
pub const BLOB_ATTR_ID_SHIFT: u32 = 24;
pub const BLOB_ATTR_LEN_MASK: u32 = 16777215;
pub const BLOB_ATTR_ALIGN: u32 = 4;
pub const BLOB_ATTR_EXTENDED: u32 = 2147483648;
pub const BLOBMSG_ALIGN: u32 = 2;
pub const ULOOP_READ: u32 = 1;
pub const ULOOP_WRITE: u32 = 2;
pub const ULOOP_EDGE_TRIGGER: u32 = 4;
pub const ULOOP_BLOCKING: u32 = 8;
pub const ULOOP_ERROR_CB: u32 = 64;
pub const ULOOP_PRIORITY: u32 = 128;
pub const ULOOP_EVENT_BUFFERED: u32 = 16;
pub const ULOOP_EVENT_MASK: u32 = 131;
pub const USOCK_TCP: u32 = 0;
pub const USOCK_UDP: u32 = 1;
pub const USOCK_SERVER: u32 = 256;
pub const USOCK_NOCLOEXEC: u32 = 512;
pub const USOCK_NONBLOCK: u32 = 1024;
pub const USOCK_NUMERIC: u32 = 2048;
pub const USOCK_IPV6ONLY: u32 = 8192;
pub const USOCK_IPV4ONLY: u32 = 16384;
pub const USOCK_UNIX: u32 = 32768;
pub type __pid_t = ::std::os::raw::c_int;
pub type pid_t = __pid_t;
pub type __gnuc_va_list = __builtin_va_list;
pub type va_list = __gnuc_va_list;
pub const BLOB_ATTR_UNSPEC: _bindgen_ty_4 = 0;
pub const BLOB_ATTR_NESTED: _bindgen_ty_4 = 1;
pub const BLOB_ATTR_BINARY: _bindgen_ty_4 = 2;
pub const BLOB_ATTR_STRING: _bindgen_ty_4 = 3;
pub const BLOB_ATTR_INT8: _bindgen_ty_4 = 4;
pub const BLOB_ATTR_INT16: _bindgen_ty_4 = 5;
pub const BLOB_ATTR_INT32: _bindgen_ty_4 = 6;
pub const BLOB_ATTR_INT64: _bindgen_ty_4 = 7;
pub const BLOB_ATTR_DOUBLE: _bindgen_ty_4 = 8;
pub const BLOB_ATTR_LAST: _bindgen_ty_4 = 9;
pub type _bindgen_ty_4 = ::std::os::raw::c_uint;
#[repr(C, packed)]
pub struct blob_attr {
pub id_len: u32,
pub data: __IncompleteArrayField<::std::os::raw::c_char>,
}
impl Default for blob_attr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct blob_attr_info {
pub type_: ::std::os::raw::c_uint,
pub minlen: ::std::os::raw::c_uint,
pub maxlen: ::std::os::raw::c_uint,
pub validate: ::std::option::Option<
unsafe extern "C" fn(arg1: *const blob_attr_info, arg2: *mut blob_attr) -> bool,
>,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct blob_buf {
pub head: *mut blob_attr,
pub grow: ::std::option::Option<
unsafe extern "C" fn(buf: *mut blob_buf, minlen: ::std::os::raw::c_int) -> bool,
>,
pub buflen: ::std::os::raw::c_int,
pub buf: *mut ::std::os::raw::c_void,
}
impl Default for blob_buf {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn blob_fill_pad(attr: *mut blob_attr);
}
extern "C" {
pub fn blob_set_raw_len(attr: *mut blob_attr, len: ::std::os::raw::c_uint);
}
extern "C" {
pub fn blob_attr_equal(a1: *const blob_attr, a2: *const blob_attr) -> bool;
}
extern "C" {
pub fn blob_buf_init(buf: *mut blob_buf, id: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blob_buf_free(buf: *mut blob_buf);
}
extern "C" {
pub fn blob_buf_grow(buf: *mut blob_buf, required: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn blob_new(
buf: *mut blob_buf,
id: ::std::os::raw::c_int,
payload: ::std::os::raw::c_int,
) -> *mut blob_attr;
}
extern "C" {
pub fn blob_nest_start(
buf: *mut blob_buf,
id: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn blob_nest_end(buf: *mut blob_buf, cookie: *mut ::std::os::raw::c_void);
}
extern "C" {
pub fn blob_put(
buf: *mut blob_buf,
id: ::std::os::raw::c_int,
ptr: *const ::std::os::raw::c_void,
len: ::std::os::raw::c_uint,
) -> *mut blob_attr;
}
extern "C" {
pub fn blob_check_type(
ptr: *const ::std::os::raw::c_void,
len: ::std::os::raw::c_uint,
type_: ::std::os::raw::c_int,
) -> bool;
}
extern "C" {
pub fn blob_parse(
attr: *mut blob_attr,
data: *mut *mut blob_attr,
info: *const blob_attr_info,
max: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blob_parse_untrusted(
attr: *mut blob_attr,
attr_len: usize,
data: *mut *mut blob_attr,
info: *const blob_attr_info,
max: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blob_memdup(attr: *const blob_attr) -> *mut blob_attr;
}
extern "C" {
pub fn blob_put_raw(
buf: *mut blob_buf,
ptr: *const ::std::os::raw::c_void,
len: ::std::os::raw::c_uint,
) -> *mut blob_attr;
}
pub const blobmsg_type_BLOBMSG_TYPE_UNSPEC: blobmsg_type = 0;
pub const blobmsg_type_BLOBMSG_TYPE_ARRAY: blobmsg_type = 1;
pub const blobmsg_type_BLOBMSG_TYPE_TABLE: blobmsg_type = 2;
pub const blobmsg_type_BLOBMSG_TYPE_STRING: blobmsg_type = 3;
pub const blobmsg_type_BLOBMSG_TYPE_INT64: blobmsg_type = 4;
pub const blobmsg_type_BLOBMSG_TYPE_INT32: blobmsg_type = 5;
pub const blobmsg_type_BLOBMSG_TYPE_INT16: blobmsg_type = 6;
pub const blobmsg_type_BLOBMSG_TYPE_INT8: blobmsg_type = 7;
pub const blobmsg_type_BLOBMSG_TYPE_BOOL: blobmsg_type = 7;
pub const blobmsg_type_BLOBMSG_TYPE_DOUBLE: blobmsg_type = 8;
pub const blobmsg_type___BLOBMSG_TYPE_LAST: blobmsg_type = 9;
pub const blobmsg_type_BLOBMSG_TYPE_LAST: blobmsg_type = 8;
pub const blobmsg_type_BLOBMSG_CAST_INT64: blobmsg_type = 9;
pub type blobmsg_type = ::std::os::raw::c_uint;
#[repr(C, packed)]
pub struct blobmsg_hdr {
pub namelen: u16,
pub name: __IncompleteArrayField<u8>,
}
impl Default for blobmsg_hdr {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct blobmsg_policy {
pub name: *const ::std::os::raw::c_char,
pub type_: blobmsg_type,
}
impl Default for blobmsg_policy {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn blobmsg_check_attr(attr: *const blob_attr, name: bool) -> bool;
}
extern "C" {
pub fn blobmsg_check_attr_len(attr: *const blob_attr, name: bool, len: usize) -> bool;
}
extern "C" {
pub fn blobmsg_check_attr_list(attr: *const blob_attr, type_: ::std::os::raw::c_int) -> bool;
}
extern "C" {
pub fn blobmsg_check_attr_list_len(
attr: *const blob_attr,
type_: ::std::os::raw::c_int,
len: usize,
) -> bool;
}
extern "C" {
pub fn blobmsg_check_array(
attr: *const blob_attr,
type_: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blobmsg_check_array_len(
attr: *const blob_attr,
type_: ::std::os::raw::c_int,
len: usize,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blobmsg_parse(
policy: *const blobmsg_policy,
policy_len: ::std::os::raw::c_int,
tb: *mut *mut blob_attr,
data: *mut ::std::os::raw::c_void,
len: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blobmsg_parse_array(
policy: *const blobmsg_policy,
policy_len: ::std::os::raw::c_int,
tb: *mut *mut blob_attr,
data: *mut ::std::os::raw::c_void,
len: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blobmsg_add_field(
buf: *mut blob_buf,
type_: ::std::os::raw::c_int,
name: *const ::std::os::raw::c_char,
data: *const ::std::os::raw::c_void,
len: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blobmsg_open_nested(
buf: *mut blob_buf,
name: *const ::std::os::raw::c_char,
array: bool,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn blobmsg_alloc_string_buffer(
buf: *mut blob_buf,
name: *const ::std::os::raw::c_char,
maxlen: ::std::os::raw::c_uint,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn blobmsg_realloc_string_buffer(
buf: *mut blob_buf,
maxlen: ::std::os::raw::c_uint,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn blobmsg_add_string_buffer(buf: *mut blob_buf);
}
extern "C" {
pub fn blobmsg_vprintf(
buf: *mut blob_buf,
name: *const ::std::os::raw::c_char,
format: *const ::std::os::raw::c_char,
arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn blobmsg_printf(
buf: *mut blob_buf,
name: *const ::std::os::raw::c_char,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct list_head {
pub next: *mut list_head,
pub prev: *mut list_head,
}
impl Default for list_head {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type uloop_fd_handler =
::std::option::Option<unsafe extern "C" fn(u: *mut uloop_fd, events: ::std::os::raw::c_uint)>;
pub type uloop_timeout_handler = ::std::option::Option<unsafe extern "C" fn(t: *mut uloop_timeout)>;
pub type uloop_process_handler =
::std::option::Option<unsafe extern "C" fn(c: *mut uloop_process, ret: ::std::os::raw::c_int)>;
pub type uloop_interval_handler =
::std::option::Option<unsafe extern "C" fn(t: *mut uloop_interval)>;
pub type uloop_signal_handler = ::std::option::Option<unsafe extern "C" fn(s: *mut uloop_signal)>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct uloop_fd {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct uloop_timeout {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct uloop_process {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct uloop_interval {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct uloop_signal {
pub _address: u8,
}
extern "C" {
pub fn uloop_fd_add(
sock: *mut uloop_fd,
flags: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_fd_delete(sock: *mut uloop_fd) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_get_next_timeout() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_timeout_add(timeout: *mut uloop_timeout) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_timeout_set(
timeout: *mut uloop_timeout,
msecs: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_timeout_cancel(timeout: *mut uloop_timeout) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_timeout_remaining(timeout: *mut uloop_timeout) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_timeout_remaining64(timeout: *mut uloop_timeout) -> i64;
}
extern "C" {
pub fn uloop_process_add(p: *mut uloop_process) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_process_delete(p: *mut uloop_process) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_interval_set(
timer: *mut uloop_interval,
msecs: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_interval_cancel(timer: *mut uloop_interval) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_interval_remaining(timer: *mut uloop_interval) -> i64;
}
extern "C" {
pub fn uloop_signal_add(s: *mut uloop_signal) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_signal_delete(s: *mut uloop_signal) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_cancelling() -> bool;
}
extern "C" {
pub fn uloop_init() -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_run_timeout(timeout: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn uloop_done();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct avl_node {
pub list: list_head,
pub parent: *mut avl_node,
pub left: *mut avl_node,
pub right: *mut avl_node,
pub key: *const ::std::os::raw::c_void,
pub balance: ::std::os::raw::c_schar,
pub leader: bool,
}
impl Default for avl_node {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type avl_tree_comp = ::std::option::Option<
unsafe extern "C" fn(
k1: *const ::std::os::raw::c_void,
k2: *const ::std::os::raw::c_void,
ptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct avl_tree {
pub list_head: list_head,
pub root: *mut avl_node,
pub count: ::std::os::raw::c_uint,
pub allow_dups: bool,
pub comp: avl_tree_comp,
pub cmp_ptr: *mut ::std::os::raw::c_void,
}
impl Default for avl_tree {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub const avl_find_mode_AVL_FIND_EQUAL: avl_find_mode = 0;
pub const avl_find_mode_AVL_FIND_LESSEQUAL: avl_find_mode = 1;
pub const avl_find_mode_AVL_FIND_GREATEREQUAL: avl_find_mode = 2;
pub type avl_find_mode = ::std::os::raw::c_uint;
extern "C" {
pub fn avl_init(
arg1: *mut avl_tree,
arg2: avl_tree_comp,
arg3: bool,
arg4: *mut ::std::os::raw::c_void,
);
}
extern "C" {
pub fn avl_find(arg1: *const avl_tree, arg2: *const ::std::os::raw::c_void) -> *mut avl_node;
}
extern "C" {
pub fn avl_find_greaterequal(
tree: *const avl_tree,
key: *const ::std::os::raw::c_void,
) -> *mut avl_node;
}
extern "C" {
pub fn avl_find_lessequal(
tree: *const avl_tree,
key: *const ::std::os::raw::c_void,
) -> *mut avl_node;
}
extern "C" {
pub fn avl_insert(arg1: *mut avl_tree, arg2: *mut avl_node) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn avl_delete(arg1: *mut avl_tree, arg2: *mut avl_node);
}
extern "C" {
pub fn avl_strcmp(
k1: *const ::std::os::raw::c_void,
k2: *const ::std::os::raw::c_void,
ptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn avl_blobcmp(
k1: *const ::std::os::raw::c_void,
k2: *const ::std::os::raw::c_void,
ptr: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
pub const udebug_format_UDEBUG_FORMAT_PACKET: udebug_format = 0;
pub const udebug_format_UDEBUG_FORMAT_STRING: udebug_format = 1;
pub const udebug_format_UDEBUG_FORMAT_BLOBMSG: udebug_format = 2;
pub type udebug_format = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct udebug_hdr {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct udebug_buf_flag {
pub name: *const ::std::os::raw::c_char,
pub mask: u64,
}
impl Default for udebug_buf_flag {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct udebug_buf_meta {
pub name: *const ::std::os::raw::c_char,
pub format: udebug_format,
pub sub_format: u32,
pub flags: *const udebug_buf_flag,
pub n_flags: ::std::os::raw::c_uint,
}
impl Default for udebug_buf_meta {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct udebug_buf {
pub ctx: *mut udebug,
pub meta: *const udebug_buf_meta,
pub id: u32,
pub list: list_head,
pub hdr: *mut udebug_hdr,
pub data: *mut ::std::os::raw::c_void,
pub data_size: usize,
pub head_size: usize,
pub ring_size: usize,
pub fd: ::std::os::raw::c_int,
}
impl Default for udebug_buf {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct udebug {
pub _address: u8,
}
pub const ULOG_KMSG: _bindgen_ty_15 = 1;
pub const ULOG_SYSLOG: _bindgen_ty_15 = 2;
pub const ULOG_STDIO: _bindgen_ty_15 = 4;
pub type _bindgen_ty_15 = ::std::os::raw::c_uint;
extern "C" {
pub fn ulog_open(
channels: ::std::os::raw::c_int,
facility: ::std::os::raw::c_int,
ident: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn ulog_udebug(udb: *mut udebug_buf);
}
extern "C" {
pub fn ulog_close();
}
extern "C" {
pub fn ulog_threshold(threshold: ::std::os::raw::c_int);
}
extern "C" {
pub fn ulog(priority: ::std::os::raw::c_int, fmt: *const ::std::os::raw::c_char, ...);
}
extern "C" {
pub fn usock_port(port: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn usock(
type_: ::std::os::raw::c_int,
host: *const ::std::os::raw::c_char,
service: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn usock_inet_timeout(
type_: ::std::os::raw::c_int,
host: *const ::std::os::raw::c_char,
service: *const ::std::os::raw::c_char,
addr: *mut ::std::os::raw::c_void,
timeout: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn usock_wait_ready(
fd: ::std::os::raw::c_int,
msecs: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct kvlist {
pub avl: avl_tree,
pub get_len: ::std::option::Option<
unsafe extern "C" fn(
kv: *mut kvlist,
data: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
}
impl Default for kvlist {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug)]
pub struct kvlist_node {
pub avl: avl_node,
pub data: __IncompleteArrayField<::std::os::raw::c_char>,
}
impl Default for kvlist_node {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
extern "C" {
pub fn kvlist_init(
kv: *mut kvlist,
get_len: ::std::option::Option<
unsafe extern "C" fn(
kv: *mut kvlist,
data: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int,
>,
);
}
extern "C" {
pub fn kvlist_free(kv: *mut kvlist);
}
extern "C" {
pub fn kvlist_get(
kv: *mut kvlist,
name: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn kvlist_set(
kv: *mut kvlist,
name: *const ::std::os::raw::c_char,
data: *const ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
pub fn kvlist_delete(kv: *mut kvlist, name: *const ::std::os::raw::c_char) -> bool;
}
extern "C" {
pub fn kvlist_strlen(
kv: *mut kvlist,
data: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn kvlist_blob_len(
kv: *mut kvlist,
data: *const ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
pub type vlist_update_cb = ::std::option::Option<
unsafe extern "C" fn(
tree: *mut vlist_tree,
node_new: *mut vlist_node,
node_old: *mut vlist_node,
),
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct vlist_tree {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct vlist_node {
pub _address: u8,
}
extern "C" {
pub fn vlist_init(tree: *mut vlist_tree, cmp: avl_tree_comp, update: vlist_update_cb);
}
extern "C" {
pub fn vlist_add(
tree: *mut vlist_tree,
node: *mut vlist_node,
key: *const ::std::os::raw::c_void,
);
}
extern "C" {
pub fn vlist_delete(tree: *mut vlist_tree, node: *mut vlist_node);
}
extern "C" {
pub fn vlist_flush(tree: *mut vlist_tree);
}
extern "C" {
pub fn vlist_flush_all(tree: *mut vlist_tree);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct safe_list_iterator {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct safe_list {
pub _address: u8,
}
extern "C" {
pub fn safe_list_for_each(
list: *mut safe_list,
cb: ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut ::std::os::raw::c_void,
list: *mut safe_list,
) -> ::std::os::raw::c_int,
>,
ctx: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn safe_list_add(list: *mut safe_list, head: *mut safe_list);
}
extern "C" {
pub fn safe_list_add_first(list: *mut safe_list, head: *mut safe_list);
}
extern "C" {
pub fn safe_list_del(list: *mut safe_list);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct runqueue {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct runqueue_task_type {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct runqueue_task {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct runqueue_process {
pub task: runqueue_task,
pub proc_: uloop_process,
}
extern "C" {
pub fn runqueue_init(q: *mut runqueue);
}
extern "C" {
pub fn runqueue_cancel(q: *mut runqueue);
}
extern "C" {
pub fn runqueue_cancel_active(q: *mut runqueue);
}
extern "C" {
pub fn runqueue_cancel_pending(q: *mut runqueue);
}
extern "C" {
pub fn runqueue_kill(q: *mut runqueue);
}
extern "C" {
pub fn runqueue_stop(q: *mut runqueue);
}
extern "C" {
pub fn runqueue_resume(q: *mut runqueue);
}
extern "C" {
pub fn runqueue_task_add(q: *mut runqueue, t: *mut runqueue_task, running: bool);
}
extern "C" {
pub fn runqueue_task_add_first(q: *mut runqueue, t: *mut runqueue_task, running: bool);
}
extern "C" {
pub fn runqueue_task_complete(t: *mut runqueue_task);
}
extern "C" {
pub fn runqueue_task_cancel(t: *mut runqueue_task, type_: ::std::os::raw::c_int);
}
extern "C" {
pub fn runqueue_task_kill(t: *mut runqueue_task);
}
extern "C" {
pub fn runqueue_process_add(q: *mut runqueue, p: *mut runqueue_process, pid: pid_t);
}
extern "C" {
pub fn runqueue_process_cancel_cb(
q: *mut runqueue,
t: *mut runqueue_task,
type_: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn runqueue_process_kill_cb(q: *mut runqueue, t: *mut runqueue_task);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct md5_ctx {
pub lo: u32,
pub hi: u32,
pub a: u32,
pub b: u32,
pub c: u32,
pub d: u32,
pub buffer: [::std::os::raw::c_uchar; 64usize],
}
impl Default for md5_ctx {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
pub type md5_ctx_t = md5_ctx;
extern "C" {
pub fn md5_begin(ctx: *mut md5_ctx_t);
}
extern "C" {
pub fn md5_hash(data: *const ::std::os::raw::c_void, length: usize, ctx: *mut md5_ctx_t);
}
extern "C" {
pub fn md5_end(resbuf: *mut ::std::os::raw::c_void, ctx: *mut md5_ctx_t);
}
extern "C" {
pub fn md5sum(
file: *const ::std::os::raw::c_char,
md5_buf: *mut ::std::os::raw::c_void,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ustream_buf_list {
pub head: *mut ustream_buf,
pub data_tail: *mut ustream_buf,
pub tail: *mut ustream_buf,
pub alloc: ::std::option::Option<
unsafe extern "C" fn(s: *mut ustream, l: *mut ustream_buf_list) -> ::std::os::raw::c_int,
>,
pub data_bytes: ::std::os::raw::c_int,
pub min_buffers: ::std::os::raw::c_int,
pub max_buffers: ::std::os::raw::c_int,
pub buffer_len: ::std::os::raw::c_int,
pub buffers: ::std::os::raw::c_int,
}
impl Default for ustream_buf_list {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ustream {
pub _address: u8,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ustream_fd {
pub stream: ustream,
pub fd: uloop_fd,
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct ustream_buf {
pub _address: u8,
}
extern "C" {
pub fn ustream_fd_init(s: *mut ustream_fd, fd: ::std::os::raw::c_int);
}
extern "C" {
pub fn ustream_free(s: *mut ustream);
}
extern "C" {
pub fn ustream_consume(s: *mut ustream, len: ::std::os::raw::c_int);
}
extern "C" {
pub fn ustream_read(
s: *mut ustream,
buf: *mut ::std::os::raw::c_char,
buflen: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ustream_write(
s: *mut ustream,
buf: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
more: bool,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ustream_printf(
s: *mut ustream,
format: *const ::std::os::raw::c_char,
...
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ustream_vprintf(
s: *mut ustream,
format: *const ::std::os::raw::c_char,
arg: *mut __va_list_tag,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn ustream_get_read_buf(
s: *mut ustream,
buflen: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ustream_set_read_blocked(s: *mut ustream, set: bool);
}
extern "C" {
pub fn ustream_init_defaults(s: *mut ustream);
}
extern "C" {
pub fn ustream_reserve(
s: *mut ustream,
len: ::std::os::raw::c_int,
maxlen: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn ustream_fill_read(s: *mut ustream, len: ::std::os::raw::c_int);
}
extern "C" {
pub fn ustream_write_pending(s: *mut ustream) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct json_object {
_unused: [u8; 0],
}
extern "C" {
pub fn blobmsg_add_object(b: *mut blob_buf, obj: *mut json_object) -> bool;
}
extern "C" {
pub fn blobmsg_add_json_element(
b: *mut blob_buf,
name: *const ::std::os::raw::c_char,
obj: *mut json_object,
) -> bool;
}
extern "C" {
pub fn blobmsg_add_json_from_string(
b: *mut blob_buf,
str_: *const ::std::os::raw::c_char,
) -> bool;
}
extern "C" {
pub fn blobmsg_add_json_from_file(
b: *mut blob_buf,
file: *const ::std::os::raw::c_char,
) -> bool;
}
pub type blobmsg_json_format_t = ::std::option::Option<
unsafe extern "C" fn(
priv_: *mut ::std::os::raw::c_void,
attr: *mut blob_attr,
) -> *const ::std::os::raw::c_char,
>;
extern "C" {
pub fn blobmsg_format_json_with_cb(
attr: *mut blob_attr,
list: bool,
cb: blobmsg_json_format_t,
priv_: *mut ::std::os::raw::c_void,
indent: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn blobmsg_format_json_value_with_cb(
attr: *mut blob_attr,
cb: blobmsg_json_format_t,
priv_: *mut ::std::os::raw::c_void,
indent: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct json_script_ctx {
pub files: avl_tree,
pub buf: blob_buf,
pub run_seq: u32,
pub abort: bool,
pub handle_command: ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut json_script_ctx,
name: *const ::std::os::raw::c_char,
cmd: *mut blob_attr,
vars: *mut blob_attr,
),
>,
pub handle_expr: ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut json_script_ctx,
name: *const ::std::os::raw::c_char,
expr: *mut blob_attr,
vars: *mut blob_attr,
) -> ::std::os::raw::c_int,
>,
pub handle_var: ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut json_script_ctx,
name: *const ::std::os::raw::c_char,
vars: *mut blob_attr,
) -> *const ::std::os::raw::c_char,
>,
pub handle_file: ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut json_script_ctx,
name: *const ::std::os::raw::c_char,
) -> *mut json_script_file,
>,
pub handle_error: ::std::option::Option<
unsafe extern "C" fn(
ctx: *mut json_script_ctx,
msg: *const ::std::os::raw::c_char,
context: *mut blob_attr,
),
>,
}
impl Default for json_script_ctx {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct json_script_file {
pub _address: u8,
}
extern "C" {
pub fn json_script_init(ctx: *mut json_script_ctx);
}
extern "C" {
pub fn json_script_free(ctx: *mut json_script_ctx);
}
extern "C" {
pub fn json_script_run(
ctx: *mut json_script_ctx,
filename: *const ::std::os::raw::c_char,
vars: *mut blob_attr,
);
}
extern "C" {
pub fn json_script_run_file(
ctx: *mut json_script_ctx,
file: *mut json_script_file,
vars: *mut blob_attr,
);
}
extern "C" {
pub fn json_script_eval_string(
ctx: *mut json_script_ctx,
vars: *mut blob_attr,
buf: *mut blob_buf,
name: *const ::std::os::raw::c_char,
pattern: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn json_script_file_from_blobmsg(
name: *const ::std::os::raw::c_char,
data: *mut ::std::os::raw::c_void,
len: ::std::os::raw::c_int,
) -> *mut json_script_file;
}
extern "C" {
pub fn json_script_find_var(
ctx: *mut json_script_ctx,
vars: *mut blob_attr,
name: *const ::std::os::raw::c_char,
) -> *const ::std::os::raw::c_char;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: ::std::os::raw::c_uint,
pub fp_offset: ::std::os::raw::c_uint,
pub overflow_arg_area: *mut ::std::os::raw::c_void,
pub reg_save_area: *mut ::std::os::raw::c_void,
}
impl Default for __va_list_tag {
fn default() -> Self {
let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
unsafe {
::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
s.assume_init()
}
}
}