Struct pcap_file::pcap::PcapWriter

pub struct PcapWriter<W: Write> { /* private fields */ }

Writes a pcap to a writer.

Example

use std::fs::File;

use pcap_file::pcap::{PcapReader, PcapWriter};

let file_in = File::open("test.pcap").expect("Error opening file");
let mut pcap_reader = PcapReader::new(file_in).unwrap();

let file_out = File::create("out.pcap").expect("Error creating file out");
let mut pcap_writer = PcapWriter::new(file_out).expect("Error writing file");

// Read test.pcap
while let Some(pkt) = pcap_reader.next_packet() {
    //Check if there is no error
    let pkt = pkt.unwrap();

    //Write each packet of test.pcap in out.pcap
    pcap_writer.write_packet(&pkt).unwrap();
}

Implementations

impl<W: Write> PcapWriter<W>

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

Creates a new PcapWriter from an existing writer.

Defaults to the native endianness of the CPU.

Writes this default global pcap header to the file:

PcapHeader {
    version_major: 2,
    version_minor: 4,
    ts_correction: 0,
    ts_accuracy: 0,
    snaplen: 65535,
    datalink: DataLink::ETHERNET,
    ts_resolution: TsResolution::MicroSecond,
    endianness: Endianness::Native
};

Errors

The writer can’t be written to.

pub fn with_header(writer: W, header: PcapHeader) -> PcapResult<PcapWriter<W>>

Creates a new PcapWriter from an existing writer with a user defined PcapHeader.

It also writes the pcap header to the file.

Errors

The writer can’t be written to.

pub fn into_writer(self) -> W

Consumes Self, returning the wrapped writer.

pub fn write_packet(&mut self, packet: &PcapPacket<'_>) -> PcapResult<usize>

Writes a PcapPacket.

pub fn write_raw_packet(
    &mut self,
    packet: &RawPcapPacket<'_>
) -> PcapResult<usize>

Writes a RawPcapPacket.

Trait Implementations

impl<W: Debug + Write> Debug for PcapWriter<W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.