Struct rawsock::pfring::dll::PFRingDll

pub struct PFRingDll { /* fields omitted */ }

Dynamic link library interface of pfring.so

Methods

impl PFRingDll

pub unsafe fn pfring_open(
    &self,
    device_name: *const c_char,
    caplen: u32,
    flags: u32
) -> *mut PFRing

pub unsafe fn pfring_open_multichannel(
    &self,
    device_name: *const c_char,
    caplen: u32,
    flags: u32,
    output: *mut [*mut PFRing; 64]
) -> u8

pub unsafe fn pfring_enable_ring(&self, ring: *const PFRing) -> c_int

pub unsafe fn pfring_disable_ring(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_shutdown(&self, ring: *mut PFRing)

pub unsafe fn pfring_close(&self, ring: *mut PFRing)

pub unsafe fn pfring_bind(
    &self,
    ring: *mut PFRing,
    device_name: *const c_char
) -> c_int

pub unsafe fn pfring_config(&self, cpu_percentage: c_ushort)

pub unsafe fn pfring_set_application_name(
    &self,
    ring: *mut PFRing,
    name: *const c_char
) -> c_int

pub unsafe fn pfring_set_channel_id(
    &self,
    ring: *mut PFRing,
    channel_id: u32
) -> c_int

pub unsafe fn pfring_set_channel_mask(
    &self,
    ring: *mut PFRing,
    channel_mask: u64
) -> c_int

pub unsafe fn pfring_set_vlan_id(
    &self,
    ring: *mut PFRing,
    vlan_id: u16
) -> c_int

pub unsafe fn pfring_set_sampling_rate(
    &self,
    ring: *mut PFRing,
    rate: u32
) -> c_int

pub unsafe fn pfring_set_filtering_sampling_rate(
    &self,
    ring: *mut PFRing,
    rate: u32
) -> c_int

pub unsafe fn pfring_set_direction(
    &self,
    ring: *mut PFRing,
    direction: PacketDirection
) -> c_int

pub unsafe fn pfring_set_promisc(
    &self,
    ring: *mut PFRing,
    set_promisc: c_int
) -> c_int

pub unsafe fn pfring_set_poll_watermark(
    &self,
    ring: *mut PFRing,
    watermark: u16
) -> c_int

pub unsafe fn pfring_set_poll_watermark_timeout(
    &self,
    ring: *mut PFRing,
    poll_watermark_timeout: u16
) -> c_int

pub unsafe fn pfring_set_poll_duration(
    &self,
    ring: *mut PFRing,
    duration: c_uint
) -> c_int

pub unsafe fn pfring_set_tx_watermark(
    &self,
    ring: *mut PFRing,
    watermark: u16
) -> c_int

pub unsafe fn pfring_get_appl_stats_file_name(
    &self,
    ring: PFRing,
    path: *mut c_char,
    path_len: c_uint
) -> c_int

pub unsafe fn pfring_set_packet_slicing(
    &self,
    ring: *mut PFRing,
    packet_level: PacketSlicingLevel,
    additional_bytes: u32
) -> c_int

pub unsafe fn pfring_set_socket_mode(
    &self,
    ring: *mut PFRing,
    mode: SocketMode
) -> c_int

pub unsafe fn pfring_set_cluster(
    &self,
    ring: *mut PFRing,
    cluster_idd: c_uint,
    the_type: ClusterType
) -> c_int

pub unsafe fn pfring_remove_from_cluster(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_set_master_id(
    &self,
    ring: *mut PFRing,
    master_id: u32
) -> c_int

pub unsafe fn pfring_set_master(
    &self,
    ring: *mut PFRing,
    master: *mut PFRing
) -> c_int

pub unsafe fn pfring_remove_hw_rule(
    &self,
    ring: *mut PFRing,
    rule_id: u16
) -> c_int

pub unsafe fn pfring_set_reflector_device(
    &self,
    ring: *mut PFRing,
    device_name: *mut c_char
) -> c_int

pub unsafe fn pfring_set_bound_dev_name(
    &self,
    ring: *mut PFRing,
    custom_dev_name: *mut c_char
) -> c_int

pub unsafe fn pfring_remove_filtering_rule(
    &self,
    ring: *mut PFRing,
    rule_id: u16
) -> c_int

pub unsafe fn pfring_set_application_stats(
    &self,
    ring: *mut PFRing,
    stats: *mut c_char
) -> c_int

pub unsafe fn pfring_purge_idle_hash_rules(
    &self,
    ring: *mut PFRing,
    inactivity_sec: u16
) -> c_int

pub unsafe fn pfring_purge_idle_rules(
    &self,
    ring: PFRing,
    inactivity_sec: u16
) -> c_int

pub unsafe fn pfring_get_filtering_rule_stats(
    &self,
    ring: *mut PFRing,
    rule_id: u16,
    stats: *mut char,
    stats_len: *mut c_uint
) -> c_int

pub unsafe fn pfring_toggle_filtering_policy(
    &self,
    ring: *mut PFRing,
    rules_default_accept_policy: u8
) -> c_int

pub unsafe fn pfring_remove_bpf_filter(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_stats(
    &self,
    ring: *mut PFRing,
    stats: *mut PFRingStat
) -> c_int

pub unsafe fn pfring_get_metadata(
    &self,
    ring: *mut PFRing,
    metadata: *mut *mut u8,
    metadata_len: *mut u32
) -> c_int

pub unsafe fn pfring_get_num_rx_channels(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_get_ring_id(&self, ring: *mut PFRing) -> u32

pub unsafe fn pfring_get_num_queued_pkts(&self, ring: *mut PFRing) -> u32

pub unsafe fn pfring_get_bound_device_address(
    &self,
    ring: *mut PFRing,
    mac_address: *mut c_uchar
) -> c_int

pub unsafe fn pfring_get_bound_device_ifindex(
    &self,
    ring: *mut PFRing,
    if_index: *mut c_int
) -> c_int

pub unsafe fn pfring_get_device_clock(
    &self,
    ring: *mut PFRing,
    ts: *mut timespec
) -> c_int

pub unsafe fn pfring_set_device_clock(
    &self,
    ring: *mut PFRing,
    ts: *mut timespec
) -> c_int

pub unsafe fn pfring_adjust_device_clock(
    &self,
    ring: *mut PFRing,
    offset: *mut timespec,
    sign: i8
) -> c_int

pub unsafe fn pfring_get_link_status(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_enable_rss_rehash(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_poll(
    &self,
    ring: *mut PFRing,
    wait_duration: c_uint
) -> c_int

pub unsafe fn pfring_is_pkt_available(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_next_pkt_time(
    &self,
    ring: *mut PFRing,
    ts: *mut timespec
) -> c_int

pub unsafe fn pfring_get_slot_header_len(&self, ring: *mut PFRing) -> u16

pub unsafe fn pfring_get_device_ifindex(
    &self,
    ring: *mut PFRing,
    device_name: *const c_char,
    if_index: *mut c_int
) -> c_int

pub unsafe fn pfring_get_selectable_fd(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_next_pkt_raw_timestamp(
    &self,
    ring: *mut PFRing,
    timestamp_ns: *mut u64
) -> c_int

pub unsafe fn pfring_loopback_test(
    &self,
    ring: *mut PFRing,
    buffer: *mut c_char,
    buffer_len: c_uint,
    test_len: c_uint
) -> c_int

pub unsafe fn pfring_recv(
    &self,
    ring: *const PFRing,
    buffer: *mut *mut u8,
    buffer_len: c_uint,
    hdr: *mut PFRingPacketHeader,
    wait_for_incoming_packet: u8
) -> c_int

pub unsafe fn pfring_recv_parsed(
    &self,
    ring: *const PFRing,
    buffer: *mut *mut u8,
    buffer_len: c_uint,
    hdr: *mut PFRingPacketHeader,
    wait_for_incoming_packet: u8,
    level: u8,
    add_timestamp: u8,
    add_hash: u8
) -> c_int

pub unsafe fn pfring_send(
    &self,
    ring: *const PFRing,
    pkt: *const u8,
    pkt_len: c_uint,
    flush_packet: u8
) -> c_int

pub unsafe fn pfring_send_get_time(
    &self,
    ring: *const PFRing,
    pkt: *const u8,
    pkt_len: c_uint,
    ts: *mut timespec
) -> c_int

pub unsafe fn pfring_flush_tx_packets(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_loop(
    &self,
    ring: *mut PFRing,
    looper: PFRingProcessPacket,
    user_bytes: *const c_uchar,
    wait_for_packet: u8
) -> c_int

pub unsafe fn pfring_breakloop(&self, ring: *mut PFRing)

pub unsafe fn pfring_send_last_rx_packet(
    &self,
    ring: *mut PFRing,
    tx_interface_id: c_int
) -> c_int

pub unsafe fn pfring_recv_chunk(
    &self,
    ring: *mut PFRing,
    chunk: *mut *mut (),
    chunk_info: *mut PFRingChunkInfo,
    wait_for_incoming_chunk: u8
) -> c_int

pub unsafe fn pfring_version_noring(&self, version: *mut u32)

pub unsafe fn pfring_version(
    &self,
    ring: *mut PFRing,
    version: *mut u32
) -> c_int

pub unsafe fn pfring_findalldevs(&self) -> *const PFRingInterface

pub unsafe fn pfring_freealldevs(&self, list: *const PFRingInterface)

pub unsafe fn pfring_sync_indexes_with_kernel(&self, ring: *mut PFRing)

pub unsafe fn pfring_search_payload(
    &self,
    ring: *mut PFRing,
    string_to_search: *mut c_char
) -> c_int

pub unsafe fn pfring_parse_pkt(
    &self,
    pkt: *mut c_uchar,
    hdr: *mut PFRingPacketHeader,
    level: u8,
    add_timestamp: u8,
    add_hash: u8
) -> c_int

pub unsafe fn pfring_set_if_promisc(
    &self,
    device: *const c_char,
    set_promisc: c_int
) -> c_int

pub unsafe fn pfring_format_numbers(
    &self,
    val: c_double,
    buf: *mut c_char,
    buf_len: c_uint,
    add_decimals: u8
) -> *mut c_char

pub unsafe fn pfring_enable_hw_timestamp(
    &self,
    ring: *mut PFRing,
    device_name: *mut c_char,
    enable_rx: u8,
    enable_tx: u8
) -> c_int

pub unsafe fn pfring_get_mtu_size(&self, ring: *mut PFRing) -> c_int

pub unsafe fn pfring_print_parsed_pkt(
    &self,
    buff: *mut c_char,
    buff_len: c_uint,
    p: *const c_uchar,
    h: *const PFRingPacketHeader
) -> c_int

pub unsafe fn pfring_print_pkt(
    &self,
    buff: *mut c_char,
    buff_len: c_uint,
    p: *const c_uchar,
    len: c_uint,
    caplen: c_uint
) -> c_int

pub unsafe fn pfring_read_ixia_hw_timestamp(
    &self,
    buffer: *mut c_uchar,
    buffer_len: u32,
    ts: *mut timespec
) -> c_int

pub unsafe fn pfring_handle_ixia_hw_timestamp(
    &self,
    buffer: *mut c_uchar,
    hdr: *mut PFRingPacketHeader
)

pub unsafe fn pfring_read_vss_apcon_hw_timestamp(
    &self,
    buffer: *mut c_uchar,
    buffer_len: u32,
    ts: *mut timespec
) -> c_int

pub unsafe fn pfring_handle_vss_apcon_hw_timestamp(
    &self,
    buffer: *mut c_uchar,
    hdr: *mut PFRingPacketHeader
)

pub unsafe fn pfring_get_interface_speed(&self, ring: *mut PFRing) -> u32

pub unsafe fn pfring_parse_bpf_filter(
    &self,
    filter_buffer: *mut c_char,
    caplen: c_uint,
    filter: *mut PFRingBpfProgram
) -> c_int

pub unsafe fn pfring_free_bpf_filter(&self, filter: *mut PFRingBpfProgram)

pub unsafe fn pfring_bpf_filter(
    &self,
    bpf_insn: *mut (),
    buffer: *mut c_uchar,
    caplen: u32,
    len: u32
) -> u32

pub unsafe fn pfring_thirdparty_lib_init(
    &self,
    thirdparty_lib_name: *const c_char,
    thirdparty_function_ptr: *mut ThirdpartyFunc
)

Trait Implementations

impl WrapperApi for PFRingDll

unsafe fn load(lib: &Library) -> Result<Self, Error>

Load symbols from provided library.