X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fsal%2Fapi%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Fpacket%2FIPv4Test.java;h=b98342831cdf9256a01ae98698ae91babf0c2e97;hb=34bc6ec632529a0dfe419aa7404bb42a456fbc96;hp=beeb7d13c06844b691ecb12fa36dbe1887805f90;hpb=42210c03b0a4c54706320ba9f55794c0abd4d201;p=controller.git diff --git a/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/IPv4Test.java b/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/IPv4Test.java index beeb7d13c0..b98342831c 100644 --- a/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/IPv4Test.java +++ b/opendaylight/sal/api/src/test/java/org/opendaylight/controller/sal/packet/IPv4Test.java @@ -1,6 +1,5 @@ - /* - * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved. + * Copyright (c) 2013-2014 Cisco Systems, Inc. and others. All rights reserved. * * This program and the accompanying materials are made available under the * terms of the Eclipse Public License v1.0 which accompanies this distribution, @@ -9,12 +8,18 @@ package org.opendaylight.controller.sal.packet; -import junit.framework.Assert; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.Arrays; +import org.junit.Assert; import org.junit.Test; -import org.opendaylight.controller.sal.packet.ICMP; -import org.opendaylight.controller.sal.packet.IPv4; -import org.opendaylight.controller.sal.packet.Packet; + +import org.opendaylight.controller.sal.match.Match; +import org.opendaylight.controller.sal.match.MatchType; +import org.opendaylight.controller.sal.utils.EtherTypes; +import org.opendaylight.controller.sal.utils.IPProtocols; +import org.opendaylight.controller.sal.utils.NetUtils; public class IPv4Test { @@ -51,7 +56,6 @@ public class IPv4Test { byte[] iptotLength = { 3, -24 }; ip.hdrFieldsMap.put("TotalLength", iptotLength); short totalLength = ip.getTotalLength(); - //System.out.println(totalLength); Assert.assertTrue(totalLength == 1000); } @@ -90,8 +94,7 @@ public class IPv4Test { byte protocol = ip.getProtocol(); Assert.assertTrue(protocol == 1); - Class clazz = ip.protocolClassMap.get(protocol); - System.out.printf("clazz = %s\n", clazz.getName()); + Class clazz = IPv4.protocolClassMap.get(protocol); Assert.assertTrue(clazz == ICMP.class); } @@ -157,6 +160,11 @@ public class IPv4Test { byte[] totalLength = ip.hdrFieldsMap.get("TotalLength"); Assert.assertTrue(totalLength[0] == 3); Assert.assertTrue(totalLength[1] == -24); + + ip.setTotalLength((short)84); + totalLength = ip.hdrFieldsMap.get("TotalLength"); + Assert.assertTrue(totalLength[0] == 0); + Assert.assertTrue(totalLength[1] == 84); } @Test @@ -206,7 +214,6 @@ public class IPv4Test { Assert.assertTrue(fragmentOffset[1] == -35); } - @Test public void testSetDestinationAddress() { IPv4 ip = new IPv4(); @@ -219,4 +226,455 @@ public class IPv4Test { Assert.assertTrue(destinationAddress[3] == 110); } + @Test + public void testOptions() throws Exception { + IPv4 ip = new IPv4(); + Assert.assertEquals(20, ip.getHeaderLen()); + Assert.assertEquals(160, ip.getHeaderSize()); + Assert.assertEquals(0, ip.getfieldnumBits("Options")); + + byte[][] options = { + new byte[] { + (byte)0x01, + }, + new byte[] { + (byte)0x01, (byte)0x02, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + }, + null, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + (byte)0x05, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + (byte)0x05, (byte)0x06, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + (byte)0x05, (byte)0x06, (byte)0x07, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + (byte)0x05, (byte)0x06, (byte)0x07, (byte)0x08, + }, + new byte[0], + }; + + byte[][] expected = { + new byte[] { + (byte)0x01, (byte)0x00, (byte)0x00, (byte)0x00, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x00, (byte)0x00, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x00, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + }, + null, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + (byte)0x05, (byte)0x00, (byte)0x00, (byte)0x00, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + (byte)0x05, (byte)0x06, (byte)0x00, (byte)0x00, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + (byte)0x05, (byte)0x06, (byte)0x07, (byte)0x00, + }, + new byte[] { + (byte)0x01, (byte)0x02, (byte)0x03, (byte)0x04, + (byte)0x05, (byte)0x06, (byte)0x07, (byte)0x08, + }, + null, + }; + + byte[] echo = { + (byte)0x11, (byte)0x22, (byte)0x33, (byte)0x44, + (byte)0x55, (byte)0x66, (byte)0x77, (byte)0x88, + (byte)0x99, (byte)0xaa, + }; + ICMP icmp = new ICMP(); + icmp.setType((byte)8); + icmp.setCode((byte)0); + icmp.setIdentifier((short)0xabcd); + icmp.setSequenceNumber((short)7777); + icmp.setRawPayload(echo); + + ip.setSourceAddress(InetAddress.getByName("192.168.10.20")); + ip.setDestinationAddress(InetAddress.getByName("192.168.30.40")); + ip.setProtocol(IPProtocols.ICMP.byteValue()); + + for (int i = 0; i < options.length; i++) { + byte[] opts = options[i]; + byte[] exp = expected[i]; + + // Set IPv4 options. + int hlen = 20; + int optlen; + if (exp != null) { + optlen = exp.length; + hlen += optlen; + } else { + optlen = 0; + } + ip.setOptions(opts); + Assert.assertTrue(Arrays.equals(exp, ip.getOptions())); + Assert.assertEquals(hlen, ip.getHeaderLen()); + Assert.assertEquals(hlen * 8, ip.getHeaderSize()); + Assert.assertEquals(optlen * 8, ip.getfieldnumBits("Options")); + + // Serialize/Deserialize test. + ip.setPayload(icmp); + + byte[] raw = ip.serialize(); + IPv4 newip = new IPv4(); + newip.deserialize(raw, 0, raw.length * 8); + Assert.assertEquals(ip, newip); + Assert.assertEquals(icmp, newip.getPayload()); + Assert.assertTrue(Arrays.equals(exp, newip.getOptions())); + } + } + + @Test + public void testChecksum() { + byte header[] = { (byte) 0x45, 00, 00, (byte) 0x3c, (byte) 0x1c, + (byte) 0x46, (byte) 0x40, 00, (byte) 0x40, 06, (byte) 0xb1, + (byte) 0xe6, (byte) 0xac, (byte) 0x10, (byte) 0x0a, + (byte) 0x63, (byte) 0xac, (byte) 0x10, (byte) 0x0a, (byte) 0x0c }; + byte header2[] = { (byte) 0x45, 00, 00, (byte) 0x73, 00, 00, + (byte) 0x40, 00, (byte) 0x40, (byte) 0x11, (byte) 0xb8, + (byte) 0x61, (byte) 0xc0, (byte) 0xa8, 00, 01, (byte) 0xc0, + (byte) 0xa8, 00, (byte) 0xc7 }; + byte header3[] = { (byte) 0x45, 00, 00, (byte) 0x47, (byte) 0x73, + (byte) 0x88, (byte) 0x40, 00, (byte) 0x40, 06, (byte) 0xA2, + (byte) 0xC4, (byte) 0x83, (byte) 0x9F, (byte) 0x0E, + (byte) 0x85, (byte) 0x83, (byte) 0x9F, (byte) 0x0E, (byte) 0xA1 }; + byte header4[] = { (byte) 0x45, 00, 00, (byte) 0x54, 00, 00, + (byte) 0x40, 00, (byte) 0x40, 01, (byte) 0xf0, (byte) 0x8e, + (byte) 0xc0, (byte) 0xa8, (byte) 0x64, (byte) 0x65, + (byte) 0xc0, (byte) 0xa8, (byte) 0x64, (byte) 0x64 }; + byte header5[] = { (byte) 0x45, 00, 00, (byte) 0x54, 00, 00, + (byte) 0x40, 00, (byte) 0x40, 01, (byte) 0xef, (byte) 0x8d, + (byte) 0xc0, (byte) 0xa8, (byte) 0x64, (byte) 0x65, + (byte) 0xc0, (byte) 0xa8, (byte) 0x65, (byte) 0x65 }; + byte header6[] = { (byte) 0x45, 00, 00, (byte) 0x54, 00, 00, + (byte) 0x40, 00, (byte) 0x40, 01, (byte) 0x0b, (byte) 0x92, + (byte) 0xc0, (byte) 0xa8, (byte) 0x64, (byte) 0x65, (byte) 0x9, + (byte) 0x9, (byte) 0x1, (byte) 0x1 }; + byte header7[] = { (byte) 0x45, 00, 00, (byte) 0x54, 00, 00, + (byte) 0x40, 00, (byte) 0x40, 01, (byte) 0, (byte) 0, + (byte) 0xc0, (byte) 0xa8, (byte) 0x64, (byte) 0x65, (byte) 0x9, + (byte) 0x9, (byte) 0x2, (byte) 0x2 }; + + IPv4 ip = new IPv4(); + + Assert.assertTrue(NetUtils.getUnsignedShort(ip.computeChecksum(header, + 0)) == 0xB1E6); + Assert.assertTrue(NetUtils.getUnsignedShort(ip.computeChecksum(header2, + 0)) == 0xb861); + Assert.assertTrue(NetUtils.getUnsignedShort(ip.computeChecksum(header3, + 0)) == 0xa2c4); + Assert.assertTrue(NetUtils.getUnsignedShort(ip.computeChecksum(header4, + 0)) == 0xf08e); + Assert.assertTrue(NetUtils.getUnsignedShort(ip.computeChecksum(header5, + 0)) == 0xef8d); + Assert.assertTrue(NetUtils.getUnsignedShort(ip.computeChecksum(header6, + 0)) == 0x0b92); + Assert.assertTrue(NetUtils.getUnsignedShort(ip.computeChecksum(header7, + 0)) == 0x0a91); + } + + @Test + public void testFullIP() throws UnknownHostException, PacketException { + byte[] icmpRawPayload = new byte[] { (byte) 0x38, (byte) 0x26, + (byte) 0x9e, (byte) 0x51, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x2e, (byte) 0x6a, + (byte) 0x08, (byte) 0x00, (byte) 0x00, (byte) 0x00, + (byte) 0x00, (byte) 0x00, (byte) 0x10, (byte) 0x11, + (byte) 0x12, (byte) 0x13, (byte) 0x14, (byte) 0x15, + (byte) 0x16, (byte) 0x17, (byte) 0x18, (byte) 0x19, + (byte) 0x1a, (byte) 0x1b, (byte) 0x1c, (byte) 0x1d, + (byte) 0x1e, (byte) 0x1f, (byte) 0x20, (byte) 0x21, + (byte) 0x22, (byte) 0x23, (byte) 0x24, (byte) 0x25, + (byte) 0x26, (byte) 0x27, (byte) 0x28, (byte) 0x29, + (byte) 0x2a, (byte) 0x2b, (byte) 0x2c, (byte) 0x2d, + (byte) 0x2e, (byte) 0x2f, (byte) 0x30, (byte) 0x31, + (byte) 0x32, (byte) 0x33, (byte) 0x34, (byte) 0x35, + (byte) 0x36, (byte) 0x37 }; + ICMP icmp = new ICMP(); + icmp.setType((byte) 8); + icmp.setCode((byte) 0); + icmp.setIdentifier((short) 0x46f5); + icmp.setSequenceNumber((short) 2); + icmp.setRawPayload(icmpRawPayload); + + IPv4 ip = new IPv4(); + ip.setVersion((byte) 4); + ip.setIdentification((short) 5); + ip.setDiffServ((byte) 0); + ip.setECN((byte) 0); + ip.setTotalLength((short) 84); + ip.setFlags((byte) 2); + ip.setFragmentOffset((short) 0); + ip.setTtl((byte) 64); + ip.setProtocol(IPProtocols.ICMP.byteValue()); + ip.setDestinationAddress(InetAddress.getByName("192.168.100.100")); + ip.setSourceAddress(InetAddress.getByName("192.168.100.101")); + ip.setPayload(icmp); + + Ethernet eth = new Ethernet(); + eth.setDestinationMACAddress(new byte[] { (byte) 0x98, (byte) 0xfc, + (byte) 0x11, (byte) 0x93, (byte) 0x5c, (byte) 0xb8 }); + eth.setSourceMACAddress(new byte[] { (byte) 0x00, (byte) 0x24, + (byte) 0xd7, (byte) 0xa9, (byte) 0xa3, (byte) 0x50 }); + eth.setEtherType(EtherTypes.IPv4.shortValue()); + eth.setPayload(ip); + + byte[] stream = eth.serialize(); + + Ethernet decEth = new Ethernet(); + decEth.deserialize(stream, 0, stream.length * NetUtils.NumBitsInAByte); + + IPv4 decIp = (IPv4) decEth.getPayload(); + Assert.assertFalse(decIp.isCorrupted()); + Assert.assertTrue(ip.equals(decIp)); + + ICMP decIcmp = (ICMP) decIp.getPayload(); + Assert.assertFalse(decIcmp.isCorrupted()); + Assert.assertTrue(Arrays.equals(icmpRawPayload, decIcmp.getRawPayload())); + } + + @Test + public void testGetMatch() throws Exception { + IPv4 ip = new IPv4(); + InetAddress sourceAddress = InetAddress.getByName("172.168.190.15"); + InetAddress destintationAddress = InetAddress.getByName("23.128.0.11"); + byte protocol = IPProtocols.TCP.byteValue(); + byte tos = 7; + ip.setVersion((byte) 4); + ip.setIdentification((short) 5); + ip.setDiffServ(tos); + ip.setECN((byte) 0); + ip.setTotalLength((short) 84); + ip.setFlags((byte) 2); + ip.setFragmentOffset((short) 0); + ip.setTtl((byte) 64); + ip.setProtocol(protocol); + ip.setDestinationAddress(destintationAddress); + ip.setSourceAddress(sourceAddress); + + Match match = ip.getMatch(); + + Assert.assertEquals(sourceAddress, match.getField(MatchType.NW_SRC).getValue()); + Assert.assertEquals(destintationAddress, match.getField(MatchType.NW_DST).getValue()); + Assert.assertEquals(protocol, (byte) match.getField(MatchType.NW_PROTO).getValue()); + Assert.assertEquals(tos, (byte) match.getField(MatchType.NW_TOS).getValue()); + } + + @Test + public void testFragment() throws Exception { + byte[] payload1 = new byte[0]; + byte[] payload2 = { + (byte)0x61, (byte)0xd1, (byte)0x3d, (byte)0x51, + (byte)0x1b, (byte)0x75, (byte)0xa7, (byte)0x83, + }; + byte[] payload3 = { + (byte)0xe7, (byte)0x0f, (byte)0x2d, (byte)0x7e, + (byte)0x15, (byte)0xba, (byte)0xe7, (byte)0x6d, + (byte)0xb5, (byte)0xc5, (byte)0xb5, (byte)0x37, + (byte)0x59, (byte)0xbc, (byte)0x91, (byte)0x43, + (byte)0xb5, (byte)0xb7, (byte)0xe4, (byte)0x28, + (byte)0xec, (byte)0x62, (byte)0x6b, (byte)0x6a, + (byte)0xd1, (byte)0xcb, (byte)0x79, (byte)0x1e, + (byte)0xfc, (byte)0x82, (byte)0xf5, (byte)0xb4, + }; + + // Ensure that the payload is not deserialized if the fragment offset + // is not zero. + byte proto = IPProtocols.TCP.byteValue(); + fragmentTest(payload1, proto, (short)0xf250); + fragmentTest(payload2, proto, (short)0xf248); + fragmentTest(payload3, proto, (short)0xf230); + + proto = IPProtocols.UDP.byteValue(); + fragmentTest(payload1, proto, (short)0xf245); + fragmentTest(payload2, proto, (short)0xf23d); + fragmentTest(payload3, proto, (short)0xf225); + + proto = IPProtocols.ICMP.byteValue(); + fragmentTest(payload1, proto, (short)0xf255); + fragmentTest(payload2, proto, (short)0xf24d); + fragmentTest(payload3, proto, (short)0xf235); + + // Ensure that the protocol header in the first fragment is + // deserialized. + proto = IPProtocols.TCP.byteValue(); + TCP tcp = new TCP(); + tcp.setSourcePort((short)1234).setDestinationPort((short)32000). + setSequenceNumber((int)0xd541f5f8).setAckNumber((int)0x58da787d). + setDataOffset((byte)5).setReserved((byte)0). + setHeaderLenFlags((short)0x18).setWindowSize((short)0x40e8). + setUrgentPointer((short)0x15f7).setChecksum((short)0x0d4e); + firstFragmentTest(tcp, payload1, proto, (short)0xdfe6); + tcp.setChecksum((short)0xab2a); + firstFragmentTest(tcp, payload2, proto, (short)0xdfde); + tcp.setChecksum((short)0x1c75); + firstFragmentTest(tcp, payload3, proto, (short)0xdfc6); + + proto = IPProtocols.UDP.byteValue(); + UDP udp = new UDP(); + udp.setSourcePort((short)53).setDestinationPort((short)45383). + setLength((short)(payload1.length + 8)).setChecksum((short)0); + firstFragmentTest(udp, payload1, proto, (short)0xdfe7); + udp.setLength((short)(payload2.length + 8)); + firstFragmentTest(udp, payload2, proto, (short)0xdfdf); + udp.setLength((short)(payload3.length + 8)); + firstFragmentTest(udp, payload3, proto, (short)0xdfc7); + + proto = IPProtocols.ICMP.byteValue(); + ICMP icmp = new ICMP(); + icmp.setType((byte)8).setCode((byte)0).setIdentifier((short)0x3d1e). + setSequenceNumber((short)1); + firstFragmentTest(icmp, payload1, proto, (short)0xdff7); + firstFragmentTest(icmp, payload2, proto, (short)0xdfef); + firstFragmentTest(icmp, payload3, proto, (short)0xdfd7); + } + + private void fragmentTest(byte[] payload, byte proto, short checksum) + throws Exception { + // Construct a fragmented raw IPv4 packet. + int ipv4Len = 20; + byte[] rawIp = new byte[ipv4Len + payload.length]; + + byte ipVersion = 4; + byte dscp = 35; + byte ecn = 2; + byte tos = (byte)((dscp << 2) | ecn); + short totalLen = (short)rawIp.length; + short id = 22143; + short offset = 0xb9; + byte ttl = 64; + byte[] srcIp = {(byte)0x0a, (byte)0x00, (byte)0x00, (byte)0x01}; + byte[] dstIp = {(byte)0xc0, (byte)0xa9, (byte)0x66, (byte)0x23}; + + rawIp[0] = (byte)((ipVersion << 4) | (ipv4Len >> 2)); + rawIp[1] = tos; + rawIp[2] = (byte)(totalLen >>> Byte.SIZE); + rawIp[3] = (byte)totalLen; + rawIp[4] = (byte)(id >>> Byte.SIZE); + rawIp[5] = (byte)id; + rawIp[6] = (byte)(offset >>> Byte.SIZE); + rawIp[7] = (byte)offset; + rawIp[8] = ttl; + rawIp[9] = proto; + rawIp[10] = (byte)(checksum >>> Byte.SIZE); + rawIp[11] = (byte)checksum; + System.arraycopy(srcIp, 0, rawIp, 12, srcIp.length); + System.arraycopy(dstIp, 0, rawIp, 16, srcIp.length); + System.arraycopy(payload, 0, rawIp, ipv4Len, payload.length); + + // Deserialize. + IPv4 ipv4 = new IPv4(); + ipv4.deserialize(rawIp, 0, rawIp.length * Byte.SIZE); + + Assert.assertEquals(ipVersion, ipv4.getVersion()); + Assert.assertEquals(ipv4Len, ipv4.getHeaderLen()); + Assert.assertEquals(dscp, ipv4.getDiffServ()); + Assert.assertEquals(ecn, ipv4.getECN()); + Assert.assertEquals(totalLen, ipv4.getTotalLength()); + Assert.assertEquals(id, ipv4.getIdentification()); + Assert.assertEquals((byte)0, ipv4.getFlags()); + Assert.assertEquals(offset, ipv4.getFragmentOffset()); + Assert.assertEquals(ttl, ipv4.getTtl()); + Assert.assertEquals(proto, ipv4.getProtocol()); + Assert.assertEquals(checksum, ipv4.getChecksum()); + Assert.assertEquals(NetUtils.byteArray4ToInt(srcIp), + ipv4.getSourceAddress()); + Assert.assertEquals(NetUtils.byteArray4ToInt(dstIp), + ipv4.getDestinationAddress()); + Assert.assertFalse(ipv4.isCorrupted()); + + // payloadClass should not be set if fragment offset is not zero. + Assert.assertEquals(null, ipv4.getPayload()); + Assert.assertArrayEquals(payload, ipv4.getRawPayload()); + } + + private void firstFragmentTest(Packet payload, byte[] rawPayload, + byte proto, short checksum) + throws Exception { + // Construct a raw IPv4 packet with MF flag. + int ipv4Len = 20; + payload.setRawPayload(rawPayload); + byte[] payloadBytes = payload.serialize(); + byte[] rawIp = new byte[ipv4Len + payloadBytes.length]; + + byte ipVersion = 4; + byte dscp = 13; + byte ecn = 1; + byte tos = (byte)((dscp << 2) | ecn); + short totalLen = (short)rawIp.length; + short id = 19834; + byte flags = 0x1; + short offset = 0; + short off = (short)(((short)flags << 13) | offset); + byte ttl = 64; + byte[] srcIp = {(byte)0xac, (byte)0x23, (byte)0x5b, (byte)0xfd}; + byte[] dstIp = {(byte)0xc0, (byte)0xa8, (byte)0x64, (byte)0x71}; + + rawIp[0] = (byte)((ipVersion << 4) | (ipv4Len >> 2)); + rawIp[1] = tos; + rawIp[2] = (byte)(totalLen >>> Byte.SIZE); + rawIp[3] = (byte)totalLen; + rawIp[4] = (byte)(id >>> Byte.SIZE); + rawIp[5] = (byte)id; + rawIp[6] = (byte)(off >>> Byte.SIZE); + rawIp[7] = (byte)off; + rawIp[8] = ttl; + rawIp[9] = proto; + rawIp[10] = (byte)(checksum >>> Byte.SIZE); + rawIp[11] = (byte)checksum; + System.arraycopy(srcIp, 0, rawIp, 12, srcIp.length); + System.arraycopy(dstIp, 0, rawIp, 16, srcIp.length); + System.arraycopy(payloadBytes, 0, rawIp, ipv4Len, payloadBytes.length); + + // Deserialize. + IPv4 ipv4 = new IPv4(); + ipv4.deserialize(rawIp, 0, rawIp.length * Byte.SIZE); + + Assert.assertEquals(ipVersion, ipv4.getVersion()); + Assert.assertEquals(ipv4Len, ipv4.getHeaderLen()); + Assert.assertEquals(dscp, ipv4.getDiffServ()); + Assert.assertEquals(ecn, ipv4.getECN()); + Assert.assertEquals(totalLen, ipv4.getTotalLength()); + Assert.assertEquals(id, ipv4.getIdentification()); + Assert.assertEquals(flags, ipv4.getFlags()); + Assert.assertEquals(offset, ipv4.getFragmentOffset()); + Assert.assertEquals(ttl, ipv4.getTtl()); + Assert.assertEquals(proto, ipv4.getProtocol()); + Assert.assertEquals(checksum, ipv4.getChecksum()); + Assert.assertEquals(NetUtils.byteArray4ToInt(srcIp), + ipv4.getSourceAddress()); + Assert.assertEquals(NetUtils.byteArray4ToInt(dstIp), + ipv4.getDestinationAddress()); + Assert.assertFalse(ipv4.isCorrupted()); + + // Protocol header in the first fragment should be deserialized. + Assert.assertEquals(null, ipv4.getRawPayload()); + + Packet desPayload = ipv4.getPayload(); + Assert.assertEquals(payload, desPayload); + Assert.assertFalse(desPayload.isCorrupted()); + Assert.assertArrayEquals(rawPayload, desPayload.getRawPayload()); + } }