sd-device-sys 0.1.2

#![allow(non_camel_case_types)]

extern crate libc;

use libc::{c_char, c_int, c_uchar, c_void, dev_t, size_t};

/// Linux errno positive.
pub const EINVAL: c_int = 22;

#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct sd_device {
    _private: [u8; 0],
    _marker: core::marker::PhantomData<*mut c_void>,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct sd_device_enumerator {
    _private: [u8; 0],
    _marker: core::marker::PhantomData<*mut c_void>,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct sd_device_monitor {
    _private: [u8; 0],
    _marker: core::marker::PhantomData<*mut c_void>,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct sd_event {
    _private: [u8; 0],
    _marker: core::marker::PhantomData<*mut c_void>,
}

#[repr(C)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub struct sd_event_source {
    _private: [u8; 0],
    _marker: core::marker::PhantomData<*mut c_void>,
}

#[repr(C)]
pub union sd_id128 {
    pub bytes: [c_uchar; 16],
    pub qwords: [u64; 2],
}

pub type sd_id128_t = sd_id128;

#[repr(i64)]
#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
pub enum sd_device_action_t {
    SD_DEVICE_ADD = 0,
    SD_DEVICE_REMOVE = 1,
    SD_DEVICE_CHANGE = 2,
    SD_DEVICE_MOVE = 3,
    SD_DEVICE_ONLINE = 4,
    SD_DEVICE_OFFLINE = 5,
    SD_DEVICE_BIND = 6,
    SD_DEVICE_UNBIND = 7,
    _SD_DEVICE_ACTION_MAX = 8,
    _SD_DEVICE_ACTION_INVALID = -(EINVAL as i64),
    /// Used to force the underlying type size to 64-bit
    _SD_ENUM_FORCE_S64_DEVICE_ACTION = i64::MAX,
}

pub type sd_device_monitor_handler_t = Option<
    unsafe extern "C" fn(
        m: *mut sd_device_monitor,
        device: *mut sd_device,
        userdata: *mut c_void,
    ) -> c_int,
>;

unsafe extern "C" {
    pub fn sd_device_ref(device: *mut sd_device) -> *mut sd_device;
    pub fn sd_device_unref(device: *mut sd_device) -> *mut sd_device;

    pub fn sd_device_new_from_syspath(ret: *mut *mut sd_device, syspath: *const c_char) -> c_int;
    pub fn sd_device_new_from_devnum(
        ret: *mut *mut sd_device,
        type_: c_char,
        devnum: dev_t,
    ) -> c_int;
    pub fn sd_device_new_from_subsystem_sysname(
        ret: *mut *mut sd_device,
        subsystem: *const c_char,
        sysname: *const c_char,
    ) -> c_int;
    pub fn sd_device_new_from_device_id(ret: *mut *mut sd_device, id: *const c_char) -> c_int;
    pub fn sd_device_new_from_stat_rdev(ret: *mut *mut sd_device, st: *const libc::stat) -> c_int;
    pub fn sd_device_new_from_devname(ret: *mut *mut sd_device, devname: *const c_char) -> c_int;
    pub fn sd_device_new_from_path(ret: *mut *mut sd_device, path: *const c_char) -> c_int;
    pub fn sd_device_new_from_ifname(ret: *mut *mut sd_device, ifname: *const c_char) -> c_int;
    pub fn sd_device_new_from_ifindex(ret: *mut *mut sd_device, ifindex: c_int) -> c_int;

    pub fn sd_device_new_child(
        ret: *mut *mut sd_device,
        device: *mut sd_device,
        suffix: *const c_char,
    ) -> c_int;

    /* parent */
    pub fn sd_device_get_parent(device: *mut sd_device, ret: *mut *mut sd_device) -> c_int;
    pub fn sd_device_get_parent_with_subsystem_devtype(
        device: *mut sd_device,
        subsystem: *const c_char,
        devtype: *const c_char,
        ret: *mut *mut sd_device,
    ) -> c_int;

    /* getters */
    pub fn sd_device_get_syspath(device: *mut sd_device, ret: *mut *const c_char) -> c_int;
    pub fn sd_device_get_subsystem(device: *mut sd_device, ret: *mut *const c_char) -> c_int;
    pub fn sd_device_get_driver_subsystem(device: *mut sd_device, ret: *mut *const c_char)
    -> c_int;
    pub fn sd_device_get_devtype(device: *mut sd_device, ret: *mut *const c_char) -> c_int;
    pub fn sd_device_get_devnum(device: *mut sd_device, devnum: *mut dev_t) -> c_int;
    pub fn sd_device_get_ifindex(device: *mut sd_device, ifindex: *mut c_int) -> c_int;
    pub fn sd_device_get_driver(device: *mut sd_device, ret: *mut *const c_char) -> c_int;
    pub fn sd_device_get_devpath(device: *mut sd_device, ret: *mut *const c_char) -> c_int;
    pub fn sd_device_get_devname(device: *mut sd_device, ret: *mut *const c_char) -> c_int;
    pub fn sd_device_get_sysname(device: *mut sd_device, ret: *mut *const c_char) -> c_int;
    pub fn sd_device_get_sysnum(device: *mut sd_device, ret: *mut *const c_char) -> c_int;
    pub fn sd_device_get_action(device: *mut sd_device, ret: *mut sd_device_action_t) -> c_int;
    pub fn sd_device_get_seqnum(device: *mut sd_device, ret: *mut u64) -> c_int;
    pub fn sd_device_get_diskseq(device: *mut sd_device, ret: *mut u64) -> c_int;
    pub fn sd_device_get_device_id(device: *mut sd_device, ret: *mut *const c_char) -> c_int;

    pub fn sd_device_get_is_initialized(device: *mut sd_device) -> c_int;
    pub fn sd_device_get_usec_initialized(device: *mut sd_device, ret: *mut u64) -> c_int;
    pub fn sd_device_get_usec_since_initialized(device: *mut sd_device, ret: *mut u64) -> c_int;

    /* iterators */
    pub fn sd_device_get_tag_first(device: *mut sd_device) -> *const c_char;
    pub fn sd_device_get_tag_next(device: *mut sd_device) -> *const c_char;
    pub fn sd_device_get_current_tag_first(device: *mut sd_device) -> *const c_char;
    pub fn sd_device_get_current_tag_next(device: *mut sd_device) -> *const c_char;
    pub fn sd_device_get_devlink_first(device: *mut sd_device) -> *const c_char;
    pub fn sd_device_get_devlink_next(device: *mut sd_device) -> *const c_char;
    pub fn sd_device_get_property_first(
        device: *mut sd_device,
        value: *mut *const c_char,
    ) -> *const c_char;
    pub fn sd_device_get_property_next(
        device: *mut sd_device,
        value: *mut *const c_char,
    ) -> *const c_char;
    pub fn sd_device_get_sysattr_first(device: *mut sd_device) -> *const c_char;
    pub fn sd_device_get_sysattr_next(device: *mut sd_device) -> *const c_char;

    pub fn sd_device_get_child_first(
        device: *mut sd_device,
        ret_suffix: *mut *const c_char,
    ) -> *mut sd_device;
    pub fn sd_device_get_child_next(
        device: *mut sd_device,
        ret_suffix: *mut *const c_char,
    ) -> *mut sd_device;

    /* queries */
    pub fn sd_device_has_tag(device: *mut sd_device, tag: *const c_char) -> c_int;
    pub fn sd_device_has_current_tag(device: *mut sd_device, tag: *const c_char) -> c_int;
    pub fn sd_device_get_property_value(
        device: *mut sd_device,
        key: *const c_char,
        value: *mut *const c_char,
    ) -> c_int;

    pub fn sd_device_get_trigger_uuid(device: *mut sd_device, ret: *mut sd_id128_t) -> c_int;

    pub fn sd_device_get_sysattr_value_with_size(
        device: *mut sd_device,
        sysattr: *const c_char,
        ret_value: *mut *const c_char,
        ret_size: *mut size_t,
    ) -> c_int;

    pub fn sd_device_get_sysattr_value(
        device: *mut sd_device,
        sysattr: *const c_char,
        ret_value: *mut *const c_char,
    ) -> c_int;

    pub fn sd_device_set_sysattr_value(
        device: *mut sd_device,
        sysattr: *const c_char,
        value: *const c_char,
    ) -> c_int;

    pub fn sd_device_set_sysattr_valuef(
        device: *mut sd_device,
        sysattr: *const c_char,
        format: *const c_char,
        ...
    ) -> c_int;

    pub fn sd_device_trigger(device: *mut sd_device, action: sd_device_action_t) -> c_int;
    pub fn sd_device_trigger_with_uuid(
        device: *mut sd_device,
        action: sd_device_action_t,
        ret_uuid: *mut sd_id128_t,
    ) -> c_int;

    pub fn sd_device_open(device: *mut sd_device, flags: c_int) -> c_int;

    /* enumerator */
    pub fn sd_device_enumerator_new(ret: *mut *mut sd_device_enumerator) -> c_int;
    pub fn sd_device_enumerator_ref(e: *mut sd_device_enumerator) -> *mut sd_device_enumerator;
    pub fn sd_device_enumerator_unref(e: *mut sd_device_enumerator) -> *mut sd_device_enumerator;

    pub fn sd_device_enumerator_get_device_first(e: *mut sd_device_enumerator) -> *mut sd_device;
    pub fn sd_device_enumerator_get_device_next(e: *mut sd_device_enumerator) -> *mut sd_device;
    pub fn sd_device_enumerator_get_subsystem_first(e: *mut sd_device_enumerator)
    -> *mut sd_device;
    pub fn sd_device_enumerator_get_subsystem_next(e: *mut sd_device_enumerator) -> *mut sd_device;

    pub fn sd_device_enumerator_add_match_subsystem(
        e: *mut sd_device_enumerator,
        subsystem: *const c_char,
        match_: c_int,
    ) -> c_int;

    pub fn sd_device_enumerator_add_match_sysattr(
        e: *mut sd_device_enumerator,
        sysattr: *const c_char,
        value: *const c_char,
        match_: c_int,
    ) -> c_int;

    pub fn sd_device_enumerator_add_match_property(
        e: *mut sd_device_enumerator,
        property: *const c_char,
        value: *const c_char,
    ) -> c_int;

    pub fn sd_device_enumerator_add_match_property_required(
        e: *mut sd_device_enumerator,
        property: *const c_char,
        value: *const c_char,
    ) -> c_int;

    pub fn sd_device_enumerator_add_match_sysname(
        e: *mut sd_device_enumerator,
        sysname: *const c_char,
    ) -> c_int;
    pub fn sd_device_enumerator_add_nomatch_sysname(
        e: *mut sd_device_enumerator,
        sysname: *const c_char,
    ) -> c_int;
    pub fn sd_device_enumerator_add_match_tag(
        e: *mut sd_device_enumerator,
        tag: *const c_char,
    ) -> c_int;
    pub fn sd_device_enumerator_add_match_parent(
        e: *mut sd_device_enumerator,
        parent: *mut sd_device,
    ) -> c_int;
    pub fn sd_device_enumerator_allow_uninitialized(e: *mut sd_device_enumerator) -> c_int;
    pub fn sd_device_enumerator_add_all_parents(e: *mut sd_device_enumerator) -> c_int;

    /* monitor */
    pub fn sd_device_monitor_new(ret: *mut *mut sd_device_monitor) -> c_int;
    pub fn sd_device_monitor_ref(m: *mut sd_device_monitor) -> *mut sd_device_monitor;
    pub fn sd_device_monitor_unref(m: *mut sd_device_monitor) -> *mut sd_device_monitor;

    pub fn sd_device_monitor_get_fd(m: *mut sd_device_monitor) -> c_int;
    pub fn sd_device_monitor_get_events(m: *mut sd_device_monitor) -> c_int;
    pub fn sd_device_monitor_get_timeout(m: *mut sd_device_monitor, ret: *mut u64) -> c_int;
    pub fn sd_device_monitor_set_receive_buffer_size(
        m: *mut sd_device_monitor,
        size: size_t,
    ) -> c_int;

    pub fn sd_device_monitor_attach_event(m: *mut sd_device_monitor, event: *mut sd_event)
    -> c_int;
    pub fn sd_device_monitor_detach_event(m: *mut sd_device_monitor) -> c_int;
    pub fn sd_device_monitor_get_event(m: *mut sd_device_monitor) -> *mut sd_event;
    pub fn sd_device_monitor_get_event_source(m: *mut sd_device_monitor) -> *mut sd_event_source;

    pub fn sd_device_monitor_set_description(
        m: *mut sd_device_monitor,
        description: *const c_char,
    ) -> c_int;
    pub fn sd_device_monitor_get_description(
        m: *mut sd_device_monitor,
        ret: *mut *const c_char,
    ) -> c_int;

    pub fn sd_device_monitor_is_running(m: *mut sd_device_monitor) -> c_int;

    pub fn sd_device_monitor_start(
        m: *mut sd_device_monitor,
        callback: sd_device_monitor_handler_t,
        userdata: *mut c_void,
    ) -> c_int;

    pub fn sd_device_monitor_stop(m: *mut sd_device_monitor) -> c_int;
    pub fn sd_device_monitor_receive(m: *mut sd_device_monitor, ret: *mut *mut sd_device) -> c_int;

    pub fn sd_device_monitor_filter_add_match_subsystem_devtype(
        m: *mut sd_device_monitor,
        subsystem: *const c_char,
        devtype: *const c_char,
    ) -> c_int;

    pub fn sd_device_monitor_filter_add_match_tag(
        m: *mut sd_device_monitor,
        tag: *const c_char,
    ) -> c_int;

    pub fn sd_device_monitor_filter_add_match_sysattr(
        m: *mut sd_device_monitor,
        sysattr: *const c_char,
        value: *const c_char,
        match_: c_int,
    ) -> c_int;

    pub fn sd_device_monitor_filter_add_match_parent(
        m: *mut sd_device_monitor,
        device: *mut sd_device,
        match_: c_int,
    ) -> c_int;

    pub fn sd_device_monitor_filter_update(m: *mut sd_device_monitor) -> c_int;
    pub fn sd_device_monitor_filter_remove(m: *mut sd_device_monitor) -> c_int;
}