More tests for Ivp6 defragmentation

pcap4j-core/src/main/java/org/pcap4j/util/IpV6Helper.java

@@ -13,13 +13,10 @@
 import org.pcap4j.packet.factory.PacketFactories;
 import org.pcap4j.packet.namednumber.IpNumber;
 
-/** @author tkunovsky */
 public final class IpV6Helper {
   private static final Comparator<IpV6Packet> comparator = new ComparatorImpl();
 
-  private IpV6Helper() {
-    throw new AssertionError();
-  }
+  private IpV6Helper() {}
 
   /**
    * @param ipV6Packet fragmented ivp6 packet
@@ -74,9 +71,6 @@ public static IpV6Packet defragment(List<IpV6Packet> list) {
     list.sort(comparator);
     IpV6Packet lastPacket = list.get(list.size() - 1);
     IpV6ExtFragmentPacket ipV6LastFragmentPacket = lastPacket.get(IpV6ExtFragmentPacket.class);
-    if (ipV6LastFragmentPacket == null) {
-      throw new IllegalArgumentException("Can't defragment: " + lastPacket);
-    }
 
     int payloadTotalLength =
         ipV6LastFragmentPacket.getHeader().getFragmentOffset() * 8

pcap4j-packettest/src/test/java/org/pcap4j/test/util/IpV6HelperTest.java

@@ -8,10 +8,10 @@
 package org.pcap4j.test.util;
 
 import static org.junit.Assert.*;
-
 import java.io.EOFException;
 import java.net.Inet6Address;
 import java.net.InetAddress;
+import java.net.UnknownHostException;
 import java.util.*;
 import java.util.concurrent.TimeoutException;
 import org.junit.Test;
@@ -32,8 +32,7 @@ public class IpV6HelperTest {
               + IpV6HelperTest.class.getSimpleName()
               + ".pcap");
 
-  @Test
-  public void testDefragment() throws Exception {
+  private EthernetPacket getPacket(boolean fragmented) throws UnknownHostException {
     UnknownPacket.Builder unknownb = new UnknownPacket.Builder();
     unknownb.rawData(new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07});
 
@@ -49,16 +48,23 @@ public void testDefragment() throws Exception {
         .srcAddr(srcIp)
         .dstAddr(dstIp);
 
+    IpV6ExtFragmentPacket.Builder fragHeadb = new IpV6ExtFragmentPacket.Builder();
+    fragHeadb
+        .fragmentOffset((short) 0)
+        .identification(123)
+        .nextHeader(IpNumber.UDP)
+        .payloadBuilder(udpb);
+
     IpV6Packet.Builder ipv6b = new IpV6Packet.Builder();
     ipv6b
         .version(IpVersion.IPV6)
         .hopLimit((byte) 100)
         .trafficClass(IpV6SimpleTrafficClass.newInstance((byte) 0x12))
         .flowLabel(IpV6SimpleFlowLabel.newInstance(0x12345))
-        .nextHeader(IpNumber.UDP)
+        .nextHeader(fragmented ? IpNumber.IPV6_FRAG : IpNumber.UDP)
         .srcAddr(srcIp)
         .dstAddr(dstIp)
-        .payloadBuilder(udpb)
+        .payloadBuilder(fragmented ? fragHeadb : udpb)
         .correctLengthAtBuild(true);
 
     EthernetPacket.Builder eb = new EthernetPacket.Builder();
@@ -68,15 +74,78 @@ public void testDefragment() throws Exception {
         .payloadBuilder(ipv6b)
         .paddingAtBuild(true);
 
-    EthernetPacket expectedPacket = eb.build();
+    return eb.build();
+  }
+
+  private Packet addExtRoutingHeader(Packet packet, boolean isFragmented)
+      throws IllegalRawDataException, UnknownHostException {
+
+    IpV6ExtRoutingPacket.Builder ipV6ExtRoutingPacketb = new IpV6ExtRoutingPacket.Builder();
+    ipV6ExtRoutingPacketb
+        .nextHeader(isFragmented ? IpNumber.IPV6_FRAG : IpNumber.UDP)
+        .correctLengthAtBuild(true)
+        .routingType(IpV6RoutingType.NIMROD)
+        .segmentsLeft((byte) 2)
+        .data(
+            new IpV6RoutingSourceRouteData(
+                0,
+                new ArrayList<Inet6Address>(
+                    Arrays.asList(
+                        new Inet6Address[] {
+                          (Inet6Address) InetAddress.getByName("2200::210:2:0:0:4")
+                        }))))
+        .payloadBuilder(
+            isFragmented
+                ? packet.get(IpV6ExtFragmentPacket.class).getBuilder()
+                : packet.get(UdpPacket.class).getBuilder());
+
+    Packet.Builder packetb = packet.getBuilder();
+    packetb
+        .get(IpV6Packet.Builder.class)
+        .correctLengthAtBuild(true)
+        .payloadBuilder(ipV6ExtRoutingPacketb)
+        .nextHeader(IpNumber.IPV6_ROUTE);
+
+    return packetb.build();
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void twoNoFragmentedPackets() throws UnknownHostException {
+    List<IpV6Packet> ipV6Packets = new ArrayList<IpV6Packet>();
+    IpV6Packet ipV6Packet = getPacket(false).get(IpV6Packet.class);
+    ipV6Packets.add(ipV6Packet);
+    ipV6Packets.add(ipV6Packet);
+    IpV6Helper.defragment(ipV6Packets);
+  }
+
+  @Test(expected = IllegalArgumentException.class)
+  public void oneNoFragmentedPacket() throws UnknownHostException {
+    List<IpV6Packet> ipV6Packets = new ArrayList<IpV6Packet>();
+    ipV6Packets.add(getPacket(true).get(IpV6Packet.class));
+    ipV6Packets.add(getPacket(false).get(IpV6Packet.class));
+    IpV6Helper.defragment(ipV6Packets);
+  }
+
+  private void testDefragment(boolean routingHeader) throws Exception {
+    EthernetPacket expectedPacket;
+    if (routingHeader) {
+      expectedPacket = (EthernetPacket) addExtRoutingHeader(getPacket(false), false);
+    } else {
+      expectedPacket = getPacket(false);
+    }
 
     PcapHandle handle = Pcaps.openOffline(PCAP_FILE);
     List<IpV6Packet> ipV6Packets = new ArrayList<IpV6Packet>();
     Packet firstPacket = null;
 
     while (true) {
       try {
-        Packet packet = handle.getNextPacketEx();
+        Packet packet;
+        if (routingHeader) {
+          packet = addExtRoutingHeader(handle.getNextPacketEx(), true);
+        } else {
+          packet = handle.getNextPacketEx();
+        }
         if (firstPacket == null) {
           firstPacket = packet;
         }
@@ -99,4 +168,14 @@ public void testDefragment() throws Exception {
 
     assertEquals(expectedPacket, actualb.build());
   }
+
+  @Test
+  public void testDefragmentWithRoutingHeader() throws Exception {
+    testDefragment(true);
+  }
+
+  @Test
+  public void testDefragmentWithoutExtHeaders() throws Exception {
+    testDefragment(false);
+  }
 }