1 use etherparse::*;
2 
main()3 fn main() {
4     // setup some network data to parse
5     let builder = PacketBuilder::ethernet2(
6         // source mac
7         [1, 2, 3, 4, 5, 6],
8         // destination mac
9         [7, 8, 9, 10, 11, 12],
10     )
11     .ip(IpHeaders::Ipv4(
12         Ipv4Header {
13             total_len: 0, // will be overwritten by builder
14             identification: 1234,
15             dont_fragment: false,
16             more_fragments: true,
17             fragment_offset: IpFragOffset::try_new(1024 / 8).unwrap(),
18             time_to_live: 20,
19             protocol: IpNumber::UDP,
20             header_checksum: 0, // will be overwritten by builder
21             source: [1, 2, 3, 4],
22             destination: [2, 3, 4, 5],
23             ..Default::default()
24         },
25         Default::default(),
26     ))
27     .udp(
28         21,   // source port
29         1234, // desitnation port
30     );
31 
32     // payload of the udp packet
33     let payload = [1, 2, 3, 4, 5, 6, 7, 8];
34 
35     // get some memory to store the serialized data
36     let mut serialized = Vec::<u8>::with_capacity(builder.size(payload.len()));
37     builder.write(&mut serialized, &payload).unwrap();
38 
39     // pool that manages the different fragmented packets & the different memory buffers for re-assembly
40     let mut ip_defrag_pool = defrag::IpDefragPool::<(), ()>::new();
41 
42     // slice the packet into the different header components
43     let sliced_packet = match SlicedPacket::from_ethernet(&serialized) {
44         Err(err) => {
45             println!("Err {:?}", err);
46             return;
47         }
48         Ok(v) => v,
49     };
50 
51     // constructed
52     if sliced_packet.is_ip_payload_fragmented() {
53         let defrag_result = ip_defrag_pool.process_sliced_packet(&sliced_packet, (), ());
54         match defrag_result {
55             Ok(Some(finished)) => {
56                 println!(
57                     "Successfully reconstructed fragmented IP packet ({} bytes, protocol {:?})",
58                     finished.payload.len(),
59                     finished.ip_number,
60                 );
61 
62                 // continue parsing the payload
63                 // ... fill in your code here
64 
65                 // IMPORTANT: After done return the finished packet buffer to avoid unneeded allocations
66                 ip_defrag_pool.return_buf(finished);
67             }
68             Ok(None) => {
69                 println!(
70                     "Received a fragmented packet, but the reconstruction was not yet finished"
71                 );
72             }
73             Err(err) => {
74                 println!("Error reconstructing fragmented IPv4 packet: {err}");
75             }
76         }
77     }
78 }
79