#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
pub const RTE_CACHE_LINE_SIZE: u32 = 64;
pub const RTE_LIBRTE_IP_FRAG_MAX_FRAG: u32 = 4;
pub const IP_LAST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_LAST_FRAG_IDX;
pub const IP_FIRST_FRAG_IDX: _bindgen_ty_1 = _bindgen_ty_1::IP_FIRST_FRAG_IDX;
pub const IP_MIN_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MIN_FRAG_NUM;
pub const IP_MAX_FRAG_NUM: _bindgen_ty_1 = _bindgen_ty_1::IP_MAX_FRAG_NUM;
#[repr(u32)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub enum _bindgen_ty_1 {
    ///< index of last fragment
    IP_LAST_FRAG_IDX = 0,
    ///< index of first fragment
    IP_FIRST_FRAG_IDX = 1,
    ///< minimum number of fragments
    IP_MIN_FRAG_NUM = 2,
    IP_MAX_FRAG_NUM = 4,
}
/// @internal fragmented mbuf
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ip_frag {
    ///< offset into the packet
    pub ofs: u16,
    ///< length of fragment
    pub len: u16,
    ///< fragment mbuf
    pub mb: *mut rte_mbuf,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ip_frag"][::std::mem::size_of::<ip_frag>() - 16usize];
    ["Alignment of ip_frag"][::std::mem::align_of::<ip_frag>() - 8usize];
    ["Offset of field: ip_frag::ofs"][::std::mem::offset_of!(ip_frag, ofs) - 0usize];
    ["Offset of field: ip_frag::len"][::std::mem::offset_of!(ip_frag, len) - 2usize];
    ["Offset of field: ip_frag::mb"][::std::mem::offset_of!(ip_frag, mb) - 8usize];
};
impl Default for ip_frag {
    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()
        }
    }
}
/// @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram.
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ip_frag_key {
    ///< src address, first 8 bytes used for IPv4
    pub src_dst: [u64; 4usize],
    ///< dst address
    pub id: u32,
    ///< src/dst key length
    pub key_len: u32,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ip_frag_key"][::std::mem::size_of::<ip_frag_key>() - 40usize];
    ["Alignment of ip_frag_key"][::std::mem::align_of::<ip_frag_key>() - 8usize];
    [
        "Offset of field: ip_frag_key::src_dst",
    ][::std::mem::offset_of!(ip_frag_key, src_dst) - 0usize];
    [
        "Offset of field: ip_frag_key::id",
    ][::std::mem::offset_of!(ip_frag_key, id) - 32usize];
    [
        "Offset of field: ip_frag_key::key_len",
    ][::std::mem::offset_of!(ip_frag_key, key_len) - 36usize];
};
/** @internal Fragmented packet to reassemble.
 First two entries in the frags[] array are for the last and first fragments.*/
#[repr(C)]
#[repr(align(64))]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ip_frag_pkt {
    ///< LRU list
    pub lru: ip_frag_pkt__bindgen_ty_1,
    ///< fragmentation key
    pub key: ip_frag_key,
    ///< creation timestamp
    pub start: u64,
    ///< expected reassembled size
    pub total_size: u32,
    ///< size of fragments received
    pub frag_size: u32,
    ///< index of next entry to fill
    pub last_idx: u32,
    ///< fragments
    pub frags: [ip_frag; 4usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
pub struct ip_frag_pkt__bindgen_ty_1 {
    pub tqe_next: *mut ip_frag_pkt,
    pub tqe_prev: *mut *mut ip_frag_pkt,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    [
        "Size of ip_frag_pkt__bindgen_ty_1",
    ][::std::mem::size_of::<ip_frag_pkt__bindgen_ty_1>() - 16usize];
    [
        "Alignment of ip_frag_pkt__bindgen_ty_1",
    ][::std::mem::align_of::<ip_frag_pkt__bindgen_ty_1>() - 8usize];
    [
        "Offset of field: ip_frag_pkt__bindgen_ty_1::tqe_next",
    ][::std::mem::offset_of!(ip_frag_pkt__bindgen_ty_1, tqe_next) - 0usize];
    [
        "Offset of field: ip_frag_pkt__bindgen_ty_1::tqe_prev",
    ][::std::mem::offset_of!(ip_frag_pkt__bindgen_ty_1, tqe_prev) - 8usize];
};
impl Default for ip_frag_pkt__bindgen_ty_1 {
    fn default() -> Self {
        let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
        unsafe {
            ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
            s.assume_init()
        }
    }
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of ip_frag_pkt"][::std::mem::size_of::<ip_frag_pkt>() - 192usize];
    ["Alignment of ip_frag_pkt"][::std::mem::align_of::<ip_frag_pkt>() - 64usize];
    [
        "Offset of field: ip_frag_pkt::lru",
    ][::std::mem::offset_of!(ip_frag_pkt, lru) - 0usize];
    [
        "Offset of field: ip_frag_pkt::key",
    ][::std::mem::offset_of!(ip_frag_pkt, key) - 16usize];
    [
        "Offset of field: ip_frag_pkt::start",
    ][::std::mem::offset_of!(ip_frag_pkt, start) - 56usize];
    [
        "Offset of field: ip_frag_pkt::total_size",
    ][::std::mem::offset_of!(ip_frag_pkt, total_size) - 64usize];
    [
        "Offset of field: ip_frag_pkt::frag_size",
    ][::std::mem::offset_of!(ip_frag_pkt, frag_size) - 68usize];
    [
        "Offset of field: ip_frag_pkt::last_idx",
    ][::std::mem::offset_of!(ip_frag_pkt, last_idx) - 72usize];
    [
        "Offset of field: ip_frag_pkt::frags",
    ][::std::mem::offset_of!(ip_frag_pkt, frags) - 80usize];
};
impl Default for ip_frag_pkt {
    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()
        }
    }
}
///< fragment mbuf
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, Hash, PartialEq, Eq)]
pub struct rte_mbuf {
    pub _address: u8,
}
