Struct PcapNgWriter 

pub struct PcapNgWriter<W> { /* private fields */ }

Writes a PcapNg to a writer.

Examples

use std::fs::File;

use pcaparse::pcapng::{PcapNgReader, PcapNgWriter};

let file_in = File::open("test.pcapng").expect("Error opening file");
let mut pcapng_reader = PcapNgReader::new(file_in).unwrap();

let mut out = Vec::new();
let mut pcapng_writer = PcapNgWriter::new(out).unwrap();

// Read test.pcapng
while let Some(block) = pcapng_reader.next_block() {
    // Check if there is no error
    let block = block.unwrap();

    // Write back parsed Block
    pcapng_writer.write_block(&block).unwrap();
}

Implementations

impl<W> PcapNgWriter<W>

pub fn into_inner(self) -> W

Consumes Self, returning the wrapped writer.

pub fn get_ref(&self) -> &W

Gets a reference to the underlying writer.

pub fn get_mut(&mut self) -> &mut W

Gets a mutable reference to the underlying writer.

You should not be used unless you really know what you’re doing

pub fn section(&self) -> &SectionHeaderBlock<'static>

Returns the current SectionHeaderBlock.

pub fn interfaces(&self) -> &[InterfaceDescriptionBlock<'static>]

Returns all the current InterfaceDescriptionBlock.

impl<W: Write> PcapNgWriter<W>

pub fn new(writer: W) -> PcapResult<Self>

Creates a new PcapNgWriter from an existing writer.

Defaults to the native endianness of the CPU.

Writes this global pcapng header to the file:

Self {
    endianness: Endianness::Native,
    major_version: 1,
    minor_version: 0,
    section_length: -1,
    options: vec![]
}

Errors

The writer can’t be written to.

pub fn with_endianness(writer: W, endianness: Endianness) -> PcapResult<Self>

Creates a new PcapNgWriter from an existing writer with the given endianness.

pub fn with_section_header( writer: W, section: SectionHeaderBlock<'static>, ) -> PcapResult<Self>

Creates a new PcapNgWriter from an existing writer with the given section header.

pub fn write_block(&mut self, block: &Block<'_>) -> PcapResult<usize>

Writes a Block.

Example

use std::borrow::Cow;
use std::fs::File;
use std::time::Duration;

use pcaparse::pcapng::blocks::enhanced_packet::EnhancedPacketBlock;
use pcaparse::pcapng::blocks::interface_description::InterfaceDescriptionBlock;
use pcaparse::pcapng::{PcapNgBlock, PcapNgWriter};
use pcaparse::DataLink;

let data = [0u8; 10];

let interface = InterfaceDescriptionBlock {
    linktype: DataLink::ETHERNET,
    snaplen: 0xFFFF,
    options: vec![],
    ts_offset: None,
    ts_divide: None,
};

let packet = EnhancedPacketBlock {
    interface_id: 0,
    timestamp: Duration::from_secs(0),
    original_len: data.len() as u32,
    data: Cow::Borrowed(&data),
    options: vec![],
    timestamp_num: 0,
    linktype: DataLink::ETHERNET,
};

let file = File::create("out.pcap").expect("Error creating file");
let mut pcap_ng_writer = PcapNgWriter::new(file).unwrap();

pcap_ng_writer.write_block(&interface.into_block()).unwrap();
pcap_ng_writer.write_block(&packet.into_block()).unwrap();

pub fn write_pcapng_block<'a, B: PcapNgBlock<'a>>( &mut self, block: B, ) -> PcapResult<usize>

Writes a PcapNgBlock.

Example

use std::borrow::Cow;
use std::fs::File;
use std::time::Duration;

use pcaparse::pcapng::blocks::enhanced_packet::EnhancedPacketBlock;
use pcaparse::pcapng::blocks::interface_description::InterfaceDescriptionBlock;
use pcaparse::pcapng::{PcapNgBlock, PcapNgWriter};
use pcaparse::DataLink;

let data = [0u8; 10];

let interface = InterfaceDescriptionBlock {
    linktype: DataLink::ETHERNET,
    snaplen: 0xFFFF,
    options: vec![],
    ts_offset: None,
    ts_divide: None,
};

let packet = EnhancedPacketBlock {
    interface_id: 0,
    timestamp: Duration::from_secs(0),
    original_len: data.len() as u32,
    data: Cow::Borrowed(&data),
    options: vec![],
    timestamp_num: 0,
    linktype: DataLink::ETHERNET,
};

let file = File::create("out.pcap").expect("Error creating file");
let mut pcap_ng_writer = PcapNgWriter::new(file).unwrap();

pcap_ng_writer.write_pcapng_block(interface).unwrap();
pcap_ng_writer.write_pcapng_block(packet).unwrap();

pub fn write_raw_block(&mut self, block: &RawBlock<'_>) -> PcapResult<usize>

Writes a RawBlock.

Doesn’t check the validity of the written blocks.

impl<W: AsyncWrite + Unpin + Send> PcapNgWriter<W>

pub async fn async_new(writer: W) -> PcapResult<Self>

Creates a new PcapNgWriter from an existing writer.

Defaults to the native endianness of the CPU.

Writes this global pcapng header to the file:

Self {
    endianness: Endianness::Native,
    major_version: 1,
    minor_version: 0,
    section_length: -1,
    options: vec![]
}

Errors

The writer can’t be written to.

pub async fn async_with_endianness( writer: W, endianness: Endianness, ) -> PcapResult<Self>

Creates a new PcapNgWriter from an existing writer with the given endianness.

pub async fn async_with_section_header( writer: W, section: SectionHeaderBlock<'static>, ) -> PcapResult<Self>

Creates a new PcapNgWriter from an existing writer with the given section header.

pub async fn async_write_block( &mut self, block: &Block<'_>, ) -> PcapResult<usize>

Writes a Block.

Example

use std::borrow::Cow;
use std::time::Duration;
use tokio::fs::File;

use pcaparse::pcapng::blocks::enhanced_packet::EnhancedPacketBlock;
use pcaparse::pcapng::blocks::interface_description::InterfaceDescriptionBlock;
use pcaparse::pcapng::{PcapNgBlock, AsyncPcapNgBlock, PcapNgWriter};
use pcaparse::DataLink;

let data = [0u8; 10];

let interface = InterfaceDescriptionBlock {
    linktype: DataLink::ETHERNET,
    snaplen: 0xFFFF,
    options: vec![],
    ts_offset: None,
    ts_divide: None,
};

let packet = EnhancedPacketBlock {
    interface_id: 0,
    timestamp: Duration::from_secs(0),
    original_len: data.len() as u32,
    data: Cow::Borrowed(&data),
    timestamp_num: 0,
    linktype: DataLink::ETHERNET,
    options: vec![],
};

let file = File::create("out.pcap").await.expect("Error creating file");
let mut pcap_ng_writer = PcapNgWriter::async_new(file).await.unwrap();

pcap_ng_writer.async_write_block(&interface.into_block()).await.unwrap();
pcap_ng_writer.async_write_block(&packet.into_block()).await.unwrap();

pub async fn async_write_pcapng_block<'a, B: AsyncPcapNgBlock<'a> + PcapNgBlock<'a>>( &mut self, block: B, ) -> PcapResult<usize>

Writes a PcapNgBlock.

Example

use std::borrow::Cow;
use std::time::Duration;
use tokio::fs::File;

use pcaparse::pcapng::blocks::enhanced_packet::EnhancedPacketBlock;
use pcaparse::pcapng::blocks::interface_description::InterfaceDescriptionBlock;
use pcaparse::pcapng::{PcapNgBlock, AsyncPcapNgBlock, PcapNgWriter};
use pcaparse::DataLink;

let data = [0u8; 10];

let interface = InterfaceDescriptionBlock {
    linktype: DataLink::ETHERNET,
    snaplen: 0xFFFF,
    options: vec![],
    ts_offset: None,
    ts_divide: None,
};

let packet = EnhancedPacketBlock {
    interface_id: 0,
    timestamp: Duration::from_secs(0),
    original_len: data.len() as u32,
    data: Cow::Borrowed(&data),
    timestamp_num: 0,
    linktype: DataLink::ETHERNET,
    options: vec![],
};

let file = File::create("out.pcap").await.expect("Error creating file");
let mut pcap_ng_writer = PcapNgWriter::async_new(file).await.unwrap();

pcap_ng_writer.async_write_pcapng_block(interface).await.unwrap();
pcap_ng_writer.async_write_pcapng_block(packet).await.unwrap();

pub async fn async_write_raw_block( &mut self, block: &RawBlock<'_>, ) -> PcapResult<usize>

Writes a RawBlock.

Doesn’t check the validity of the written blocks.