Struct pako_core::PluginRegistry

pub struct PluginRegistry { /* private fields */ }

Implementations

impl PluginRegistry

pub fn new() -> Self

Examples found in repository

src/plugins/mod.rs (line 50)

    pub fn build_plugins(&self, config: &Config) -> Result<PluginRegistry, PluginBuilderError> {
        let mut registry = PluginRegistry::new();

        for b in &self.list {
            b.build(&mut registry, config)?;
        }

        Ok(registry)
    }

    /// Instantiate plugins if they match predicate
    pub fn build_filter_plugins<P>(
        &self,
        predicate: P,
        config: &Config,
    ) -> Result<PluginRegistry, PluginBuilderError>
    where
        P: Fn(&str) -> bool,
    {
        let mut registry = PluginRegistry::new();

        for b in &self.list {
            if predicate(b.name()) {
                b.build(&mut registry, config)?;
            }
        }

        Ok(registry)
    }

pub fn num_plugins(&self) -> usize

Return the count of different plugins

A plugin can be registered for several layers, but it will count as one.

pub fn add_plugin(&mut self, plugin: SafePlugin) -> PluginID

Add a plugin to the registry, and return the identifier

pub fn run_plugins<F, P>(&self, predicate: P, f: F)where
    F: FnMut(&mut dyn Plugin),
    P: FnMut(&dyn Plugin) -> bool,

Run function F on all known plugins (registered or not) matching P

Examples found in repository

src/threaded_analyzer.rs (line 170)

    fn init(&mut self) -> Result<(), Error> {
        self.registry.run_plugins(|_| true, |p| p.pre_process());

        Ok(())
    }

    fn handle_packet(&mut self, packet: &Packet, ctx: &ParseContext) -> Result<(), Error> {
        // NOTE: remove packet from lifetime management, it must be made 'static
        // to be sent to threads
        let packet: Packet<'static> = unsafe { ::std::mem::transmute(packet.clone()) };
        self.dispatch(packet, ctx)?;
        Ok(())
    }

    fn teardown(&mut self) {
        debug!("main: exit");
        self.wait_for_empty_jobs();
        for job in self.local_jobs.iter() {
            // XXX expire flows?
            job.send(Job::PrintDebug).expect("Error while sending job");
            job.send(Job::Exit).expect("Error while sending job");
        }
        while let Some(w) = self.workers.pop() {
            w.handler.join().expect("panic occurred in a thread");
        }
        self.local_jobs.clear();
        debug!("main: all workers ended");

        self.registry.run_plugins(|_| true, |p| p.post_process());
    }

src/analyzer.rs (lines 1159-1162)

pub(crate) fn gen_event_new_flow(flow: &Flow, registry: &PluginRegistry) {
    // let start = ::std::time::Instant::now();
    registry.run_plugins(
        |p| p.plugin_type() & PLUGIN_FLOW_NEW != 0,
        |p| p.flow_created(flow),
    );
    // let elapsed = start.elapsed();
    // debug!("Time to run flow_created: {}.{}", elapsed.as_secs(), elapsed.as_millis());
}

impl PcapAnalyzer for Analyzer {
    /// Initialize all plugins
    fn init(&mut self) -> Result<(), Error> {
        self.registry.run_plugins(|_| true, |p| p.pre_process());
        Ok(())
    }

    /// Dispatch function: given a packet, use link type to get the real data, and
    /// call the matching handling function (some pcap blocks encode ethernet, or IPv4 etc.)
    fn handle_packet(&mut self, packet: &Packet, ctx: &ParseContext) -> Result<(), Error> {
        if ctx.pcap_index < self.skip_index {
            return Ok(());
        }
        match packet.data {
            PacketData::L2(data) => self.handle_l2(packet, ctx, data),
            PacketData::L3(ethertype, data) => {
                handle_l3(packet, ctx, data, EtherType(ethertype), self)
            }
            PacketData::L4(_, _) => unimplemented!(), // XXX
            PacketData::Unsupported(raw) => {
                // fixups
                if packet.link_type == Linktype(12) {
                    // defined as DLT_RAW in libpcap/dlt.h
                    if let Some(PacketData::L3(ethertype, packet_data)) =
                        get_packetdata_raw(raw, packet.caplen as usize)
                    {
                        return handle_l3(packet, ctx, packet_data, EtherType(ethertype), self);
                    }
                }
                warn!(
                    "Unsupported data format (unknown linktype {}) idx={}",
                    packet.link_type, ctx.pcap_index
                );
                Ok(())
            }
        }
    }

    /// Finalize analysis and notify plugins
    fn teardown(&mut self) {
        {
            // expire all TCP connections in reassembly engine
            finalize_tcp_streams(self);
            // expire remaining flows
            let flows = &self.flows;
            trace!("{} flows remaining in table", flows.len());
            // let start = ::std::time::Instant::now();
            self.registry.run_plugins(
                |p| p.plugin_type() & PLUGIN_FLOW_DEL != 0,
                |p| {
                    flows.values().for_each(|flow| {
                        p.flow_destroyed(flow);
                    });
                },
            );
            // let elapsed = start.elapsed();
            // debug!("Time to run flow_destroyed {}.{}", elapsed.as_secs(), elapsed.as_millis());
            self.flows.clear();

            self.registry.run_plugins(|_| true, |p| p.post_process());

            if let Some(output_dir) = &self.output_dir {
                self.registry.run_plugins(
                    |_| true,
                    |p| {
                        let res = p.save_results(output_dir);
                        if let Err(e) = res {
                            warn!("error while saving results for {}: {}", p.name(), e);
                        }
                    },
                );
            }
        };
    }

pub fn register_layer(
    &mut self,
    layer: u8,
    layer_filter: u16,
    plugin_id: PluginID
) -> Result<(), PluginBuilderError>

Register a layer for analysis, for the identified plugin

layer_filter is a filter on the value relative to the layer: for L3, use for ex. ETHERNET_IPV4, for L4, TRANSPORT_TCP, etc. Special value 0 for layer_filter means all possible values.

pub fn get_plugins_for_layer(
    &self,
    layer: u8,
    layer_filter: u16
) -> Option<&Vec<SafePlugin>>

Get plugins matching the given layer and layer_filter

Examples found in repository

src/analyzer.rs (line 1060)

fn run_plugins_v2<'i, F>(
    packet: &Packet,
    ctx: &ParseContext,
    layer: u8,
    layer_filter: u16,
    cb: F,
    analyzer: &mut Analyzer,
) -> Result<(), Error>
where
    F: for<'p> Fn(&'p mut dyn Plugin) -> PluginResult<'i>,
{
    trace!(
        "running plugins for layer={} filter=0x{:04x}",
        layer,
        layer_filter
    );
    // clone the registry (which is an Arc)
    // so analyzer is not borrowed for the plugins loop
    let registry = analyzer.registry.clone();
    let empty_vec = vec![];
    // get plugins for this specific filter
    let l1 = registry
        .get_plugins_for_layer(layer, layer_filter)
        .unwrap_or(&empty_vec)
        .as_slice();
    // get catch-all plugins (filter == 0)
    let l2 = registry
        .get_plugins_for_layer(layer, 0)
        .unwrap_or(&empty_vec)
        .as_slice();
    for plugin in l1.iter().chain(l2) {
        let r = {
            // limit duration of lock to vallback
            let mut p = plugin.lock().expect("locking plugin failed (recursion ?)");
            cb(p.deref_mut())
        };
        match r {
            PluginResult::None => continue,
            PluginResult::Error(e) => {
                // XXX ignore error in plugins ? just log ?
                warn!("Plugin returned error {:?}", e);
                continue;
            }
            PluginResult::L2(e, payload) => {
                handle_l3(packet, ctx, payload, EtherType(e), analyzer)?
            }
            PluginResult::L3(l3, payload) => handle_l3_common(packet, ctx, payload, l3, analyzer)?,
            PluginResult::L4(t5, payload) => {
                let l3_info = L3Info::default(); // XXX
                handle_l4_common(
                    packet,
                    ctx,
                    &[],
                    &l3_info,
                    t5.src_port,
                    t5.dst_port,
                    Some(payload),
                    analyzer,
                )?;
            }
        }
    }
    Ok(())
}

pub fn iter_registered_plugins(
    &self
) -> impl Iterator<Item = (&PluginInfo, &SafePlugin)>

Return an iterator on registered plugins

The same plugin instance can be present multiple times, if registered with different PluginInfo (for ex. layer filters).

pub fn iter_plugins(&self) -> impl Iterator<Item = &SafePlugin>

Return an iterator on all known plugins

Known plugins are plugins present in the registry (registered or not for layers)

Trait Implementations

impl Default for PluginRegistry

fn default() -> PluginRegistry

Returns the “default value” for a type.