Struct etherparse::PacketBuilder

pub struct PacketBuilder {}

Available on crate feature std only.

Helper for building packets.

The packet builder allows the easy construction of a packet from the ethernet II layer downwards including ipv6, ipv4, the udp header and the actual payload. The packet builder automatically calculates lengths & checksums for ip & udp and set type identifiers for ethernetII and ip. This makes it easy and less error prone to construct custom packets.

Example:

Generating a packet that starts with an Ethernet II header:

use etherparse::PacketBuilder;

let builder = PacketBuilder::
    ethernet2([1,2,3,4,5,6],     //source mac
              [7,8,9,10,11,12]) //destination mac
   .ipv4([192,168,1,1], //source ip
         [192,168,1,2], //destination ip
         20)            //time to life
   .udp(21,    //source port
        1234); //destination port

//payload of the udp packet
let payload = [1,2,3,4,5,6,7,8];

//get some memory to store the result
let mut result = Vec::<u8>::with_capacity(
                    builder.size(payload.len()));

//serialize
builder.write(&mut result, &payload).unwrap();
println!("{:?}", result);

Options

• Starting Options:
  • PacketBuilder::ethernet2
  • PacketBuilder::ip
  • PacketBuilder::ipv4
  • PacketBuilder::ipv6
• Options after an Ethernet2 header was added:
  • PacketBuilderStep<Ethernet2Header>::vlan
  • PacketBuilderStep<Ethernet2Header>::single_vlan
  • PacketBuilderStep<Ethernet2Header>::double_vlan
  • PacketBuilderStep<Ethernet2Header>::ip
  • PacketBuilderStep<Ethernet2Header>::ipv4
  • PacketBuilderStep<Ethernet2Header>::ipv6
• Options after an Vlan header was added:
  • PacketBuilderStep<VlanHeader>::ip
  • PacketBuilderStep<VlanHeader>::ipv4
  • PacketBuilderStep<VlanHeader>::ipv6
• Options after an IP header was added:
  • PacketBuilderStep<IpHeaders>::write
  • PacketBuilderStep<IpHeaders>::tcp
  • PacketBuilderStep<IpHeaders>::udp
  • PacketBuilderStep<IpHeaders>::icmpv4
  • PacketBuilderStep<IpHeaders>::icmpv4_raw
  • PacketBuilderStep<IpHeaders>::icmpv4_echo_request
  • PacketBuilderStep<IpHeaders>::icmpv4_echo_reply
  • PacketBuilderStep<IpHeaders>::icmpv6
  • PacketBuilderStep<IpHeaders>::icmpv6_raw
  • PacketBuilderStep<IpHeaders>::icmpv6_echo_request
  • PacketBuilderStep<IpHeaders>::icmpv6_echo_reply
• Options after an TCP header was added:
  • PacketBuilderStep<TcpHeader>::write
  • PacketBuilderStep<TcpHeader>::size
  • PacketBuilderStep<TcpHeader>::ns
  • PacketBuilderStep<TcpHeader>::fin
  • PacketBuilderStep<TcpHeader>::syn
  • PacketBuilderStep<TcpHeader>::rst
  • PacketBuilderStep<TcpHeader>::psh
  • PacketBuilderStep<TcpHeader>::ack
  • PacketBuilderStep<TcpHeader>::urg
  • PacketBuilderStep<TcpHeader>::ece
  • PacketBuilderStep<TcpHeader>::cwr
  • PacketBuilderStep<TcpHeader>::options
  • PacketBuilderStep<TcpHeader>::options_raw
• Options after an UDP header was added:
  • PacketBuilderStep<UdpHeader>::write
  • PacketBuilderStep<UdpHeader>::size
• Options after an ICMPv4 header was added:
  • PacketBuilderStep<Icmpv4Header>::write
  • PacketBuilderStep<Icmpv4Header>::size
• Options after an ICMPv6 header was added:
  • PacketBuilderStep<Icmpv6Header>::write
  • PacketBuilderStep<Icmpv6Header>::size

Implementations

impl PacketBuilder

pub fn ethernet2( source: [u8; 6], destination: [u8; 6] ) -> PacketBuilderStep<Ethernet2Header>

Start an packet with an ethernetII header.

Example

Basic usage:

let builder = PacketBuilder::
    ethernet2([1,2,3,4,5,6],     //source mac
              [7,8,9,10,11,12]) //destination mac
   .ipv4([192,168,1,1], //source ip
         [192,168,1,2], //destination ip
         20)            //time to life
   .udp(21,    //source port
        1234); //destination port

//payload of the udp packet
let payload = [1,2,3,4,5,6,7,8];

//get some memory to store the result
let mut result = Vec::<u8>::with_capacity(
                    builder.size(payload.len()));

//serialize
builder.write(&mut result, &payload).unwrap();

pub fn ipv4( source: [u8; 4], destination: [u8; 4], time_to_live: u8 ) -> PacketBuilderStep<IpHeaders>

Starts a packet with an IPv4 header.

Example

Basic usage:

let builder = PacketBuilder::
   ipv4([192,168,1,1],  //source ip
         [192,168,1,2], //destination ip
         20)            //time to life
   .udp(21,    //source port
        1234); //destination port

//payload of the udp packet
let payload = [1,2,3,4,5,6,7,8];
     
//get some memory to store the result
let mut result = Vec::<u8>::with_capacity(
                    builder.size(payload.len()));

//serialize
builder.write(&mut result, &payload).unwrap();

pub fn ipv6( source: [u8; 16], destination: [u8; 16], hop_limit: u8 ) -> PacketBuilderStep<IpHeaders>

Start a packet with an IPv6 header.

Example

Basic usage:

let builder = PacketBuilder::
    ipv6(
        //source
        [11,12,13,14,15,16,17,18,19,10,21,22,23,24,25,26],
        //destination
        [31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46],
        //hop_limit
        47)
   .udp(21,    //source port
        1234); //destination port

//payload of the udp packet
let payload = [1,2,3,4,5,6,7,8];

//get some memory to store the result
let mut result = Vec::<u8>::with_capacity(
                    builder.size(payload.len()));

//serialize
builder.write(&mut result, &payload).unwrap();

pub fn ip(ip_header: IpHeaders) -> PacketBuilderStep<IpHeaders>

Starts a packet with an arbitrary IP header (length, protocol/next_header & checksum fields will be overwritten based on the rest of the packet).

Examples

With an IPv4 header:

let builder = PacketBuilder::
   //payload_len, protocol & checksum will be replaced during write
   ip(IpHeaders::Ipv4(
       Ipv4Header::new(
           0, //payload_len will be replaced during write
           12, //time_to_live
           ip_number::UDP, //will be replaced during write
           [0,1,2,3], //source
           [4,5,6,7] //destination
       ).unwrap(),
       Default::default()))
   .udp(21,    //source port
        1234); //destination port

//payload of the udp packet
let payload = [1,2,3,4,5,6,7,8];

//get some memory to store the result
let mut result = Vec::<u8>::with_capacity(
                    builder.size(payload.len()));

//serialize
builder.write(&mut result, &payload).unwrap();

With an IPv6 header:

let builder = PacketBuilder::
   ip(IpHeaders::Ipv6(
        Ipv6Header{
            traffic_class: 0,
            flow_label: 0.try_into().unwrap(),
            hop_limit: 4.try_into().unwrap(),
            source: [0;16],
            destination: [0;16],
            // payload_length & next_header will be replaced during write
            ..Default::default()
        },
        Default::default()))
   .udp(21,    //source port
        1234); //destination port

//payload of the udp packet
let payload = [1,2,3,4,5,6,7,8];
     
//get some memory to store the result
let mut result = Vec::<u8>::with_capacity(
                    builder.size(payload.len()));

//serialize
builder.write(&mut result, &payload).unwrap();