Struct pcap_file::writer::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 {

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

Fields

header: PcapHeader

Methods

impl<T: Write> PcapWriter<T>

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

Create a new PcapWriter from an existing writer.

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.

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.

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::PcapWriter;
use pcap_file::pcap_header::{PcapHeader, Datalink};

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<()>

Write 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<()>

Write 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.