Struct pcap_file::PcapWriter

pub struct PcapWriter<T: Write> {
    pub header: PcapHeader,
    // some fields omitted
}

This struct wraps another writer and enables it to write a Pcap formated stream.

Examples

use std::fs::File;
use pcap_file::{PcapReader, PcapWriter};


let file_in = File::open("test.pcap").expect("Error opening file");
let 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
for pcap in pcap_reader {

    //Check if there is no error
    let pcap = pcap.unwrap();

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

Fields

header: PcapHeader

Methods

impl<T: Write> PcapWriter<T>

fn new(writer: T) -> ResultChain<PcapWriter<T>>

Create a new PcapWriter from an existing writer in BigEndian.

It Automatically writes this default global pcap header to the file:

PcapHeader {

    magic_number : 0xa1b2c3d4,
    version_major : 2,
    version_minor : 4,
    ts_correction : 0,
    ts_accuracy : 0,
    snaplen : 65535,
    datalink : DataLink::ETHERNET
};

Errors

Return an error if the writer can't be written to.

Examples

use std::fs::File;
use pcap_file::PcapWriter;

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

fn with_endianness(
    endianness: Endianness,
    writer: T
) -> ResultChain<PcapWriter<T>>

Create a new PcapWriter from an existing writer with the given endianness.

It Automatically writes this default global pcap header to the file:

PcapHeader {

    magic_number : 0xa1b2c3d4,
    version_major : 2,
    version_minor : 4,
    ts_correction : 0,
    ts_accuracy : 0,
    snaplen : 65535,
    datalink : DataLink::ETHERNET
};

Errors

Return an error if the writer can't be written to.

Examples

use std::fs::File;
use pcap_file::PcapWriter;

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

fn with_header(header: PcapHeader, writer: T) -> ResultChain<PcapWriter<T>>

Create a new PcapWriter from an existing writer with a user defined global pcap header. The endianness is chosen by the magic number of the header.

Automatically write the global pcap header to the file.

Errors

Return an error if the writer can't be written to.

Examples

use std::fs::File;
use pcap_file::{DataLink, PcapHeader, PcapWriter};

let file = File::create("out.pcap").expect("Error creating file");

let header = PcapHeader {

    magic_number : 0xa1b2c3d4,
    version_major : 2,
    version_minor : 4,
    ts_correction : 0,
    ts_accuracy : 0,
    snaplen : 65535,
    datalink : DataLink::ETHERNET
};

let mut pcap_writer = PcapWriter::with_header(header, file);

fn into_writer(self) -> T

Consumes the PcapWriter, returning the wrapped writer.

Examples

use std::fs::File;
use pcap_file::PcapWriter;

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

let file2 = pcap_writer.into_writer();

fn get_ref(&self) -> &T

Gets a reference to the underlying writer.

Examples

use std::fs::File;
use pcap_file::PcapWriter;

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

let file_ref = pcap_writer.get_ref();

fn get_mut(&mut self) -> &mut T

Gets a mutable reference to the underlying writer.

It is inadvisable to directly write to the underlying writer.

Examples

use std::fs::File;
use pcap_file::PcapWriter;

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

let file_mut = pcap_writer.get_mut();

fn write(&mut self, ts_sec: u32, ts_usec: u32, data: &[u8]) -> ResultChain<()>

Writes some raw data, converting it to the pcap file format.

Examples

use std::fs::File;
use pcap_file::PcapWriter;

let data = [0u8; 10];
let file = File::create("out.pcap").expect("Error creating file");
let mut pcap_writer = PcapWriter::new(file).unwrap();

pcap_writer.write(0, 0, &data).unwrap();

fn write_packet(&mut self, packet: &Packet) -> ResultChain<()>

Writes a Packet.

Examples

use std::fs::File;
use pcap_file::{Packet, PcapWriter};

let data = [0u8; 10];
let packet = Packet::new(0, 0, 10, &data);

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

pcap_writer.write_packet(&packet).unwrap();

Trait Implementations

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

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.