ONOS-508: Implement IPv6, ICMP6 and NeighborAdvertisement class
Create ICMP6 class, which is mostly like ICMP
Change-Id: I11d7abec4a8f1fd202e5dfb0a500f621773c2c3a
Create IPv6 class, which is mostly like IPv4
Change-Id: I7a301a0f94263df5d6d30f73050332ec7acfe611
Register handler class of IPv6 to Ethernet
Change-Id: Iccdef1680664520f9d66360a289809710982ce54
Fix FIXED_HEADER_LENGTH
Change-Id: Iff4fb22638416595f2865ff46b682a0579ba33d5
Fix payloadLength
Change-Id: I8dea4dd52f0bb5926fbff0d9e74fdd19404cabff
Add unittest for serialize
Change-Id: If194aa2530ce517a33b36b97b8478b0a4c463954
Add unittest for deserialize. Fix assertArrayEquals. Refine test structure.
Change-Id: I94f2a348b2be2f5907d8bac6b9029b37eb31456d
Payload length should be handled during serializing/deserializing procedure
Change-Id: Ib079bf939a01a38356c824ed972793293ed8ca1e
Add unittest for comparator
Change-Id: I937dd9330d7c23a81ecd8434ac0fcf7345cc5c00
Fix typo. Fix checkstyle error
Change-Id: I2fe1af81c65416b0fddaa0fb9ae206b87b889628
Add implementation and unittest for NeighborAdvertisement
Change-Id: I7610462a5712f9fee5be0416c08e1de302e0780d
Register handler class of NeighborAdvertisement to ICMP6
Change-Id: I3a7a9cf044cfdcd8908579942c159c2f0aad198d
diff --git a/utils/misc/src/main/java/org/onlab/packet/Ethernet.java b/utils/misc/src/main/java/org/onlab/packet/Ethernet.java
index 6354d18..2a69ffa 100644
--- a/utils/misc/src/main/java/org/onlab/packet/Ethernet.java
+++ b/utils/misc/src/main/java/org/onlab/packet/Ethernet.java
@@ -49,6 +49,7 @@
Ethernet.ETHER_TYPE_CLASS_MAP.put(Ethernet.TYPE_ARP, ARP.class);
Ethernet.ETHER_TYPE_CLASS_MAP.put(Ethernet.TYPE_RARP, ARP.class);
Ethernet.ETHER_TYPE_CLASS_MAP.put(Ethernet.TYPE_IPV4, IPv4.class);
+ Ethernet.ETHER_TYPE_CLASS_MAP.put(Ethernet.TYPE_IPV6, IPv6.class);
Ethernet.ETHER_TYPE_CLASS_MAP.put(Ethernet.TYPE_LLDP, LLDP.class);
Ethernet.ETHER_TYPE_CLASS_MAP.put(Ethernet.TYPE_BSN, LLDP.class);
}
diff --git a/utils/misc/src/main/java/org/onlab/packet/ICMP6.java b/utils/misc/src/main/java/org/onlab/packet/ICMP6.java
new file mode 100644
index 0000000..6d2455a
--- /dev/null
+++ b/utils/misc/src/main/java/org/onlab/packet/ICMP6.java
@@ -0,0 +1,219 @@
+/*
+ * Copyright 2014 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+package org.onlab.packet;
+
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Implements ICMPv6 packet format.
+ *
+ */
+public class ICMP6 extends BasePacket {
+ public static final byte HEADER_LENGTH = 4; // bytes
+
+ public static final byte ROUTER_SOLICITATION = (byte) 0x85;
+ public static final byte ROUTER_ADVERTISEMENT = (byte) 0x86;
+ public static final byte NEIGHBOR_SOLICITATION = (byte) 0x87;
+ public static final byte NEIGHBOR_ADVERTISEMENT = (byte) 0x88;
+ public static final Map<Byte, Class<? extends IPacket>> PROTOCOL_CLASS_MAP =
+ new HashMap<>();
+
+ static {
+ ICMP6.PROTOCOL_CLASS_MAP.put(ICMP6.NEIGHBOR_ADVERTISEMENT, NeighborAdvertisement.class);
+ }
+
+ protected byte icmpType;
+ protected byte icmpCode;
+ protected short checksum;
+
+ /**
+ * @return the icmpType
+ */
+ public byte getIcmpType() {
+ return this.icmpType;
+ }
+
+ /**
+ * @param icmpType
+ * to set
+ * @return this
+ */
+ public ICMP6 setIcmpType(final byte icmpType) {
+ this.icmpType = icmpType;
+ return this;
+ }
+
+ /**
+ * @return the icmp code
+ */
+ public byte getIcmpCode() {
+ return this.icmpCode;
+ }
+
+ /**
+ * @param icmpCode
+ * code to set
+ * @return this
+ */
+ public ICMP6 setIcmpCode(final byte icmpCode) {
+ this.icmpCode = icmpCode;
+ return this;
+ }
+
+ /**
+ * @return the checksum
+ */
+ public short getChecksum() {
+ return this.checksum;
+ }
+
+ /**
+ * @param checksum
+ * the checksum to set
+ * @return this
+ */
+ public ICMP6 setChecksum(final short checksum) {
+ this.checksum = checksum;
+ return this;
+ }
+
+ /**
+ * Serializes the packet. Will compute and set the following fields if they
+ * are set to specific values at the time serialize is called: -checksum : 0
+ * -length : 0
+ */
+ @Override
+ public byte[] serialize() {
+ byte[] payloadData = null;
+ if (this.payload != null) {
+ this.payload.setParent(this);
+ payloadData = this.payload.serialize();
+ }
+
+ int payloadLength = payloadData == null ? 0 : (short) payloadData.length;
+
+ final byte[] data = new byte[HEADER_LENGTH + payloadLength];
+ final ByteBuffer bb = ByteBuffer.wrap(data);
+
+ bb.put(this.icmpType);
+ bb.put(this.icmpCode);
+ bb.putShort(this.checksum);
+ if (payloadData != null) {
+ bb.put(payloadData);
+ }
+
+ if (this.parent != null && this.parent instanceof IPv6) {
+ ((IPv6) this.parent).setNextHeader(IPv6.PROTOCOL_ICMP6);
+ }
+
+ // compute checksum if needed
+ if (this.checksum == 0) {
+ bb.rewind();
+ int accumulation = 0;
+
+ for (int i = 0; i < data.length / 2; ++i) {
+ accumulation += 0xffff & bb.getShort();
+ }
+ // pad to an even number of shorts
+ if (data.length % 2 > 0) {
+ accumulation += (bb.get() & 0xff) << 8;
+ }
+
+ accumulation = (accumulation >> 16 & 0xffff)
+ + (accumulation & 0xffff);
+ this.checksum = (short) (~accumulation & 0xffff);
+ bb.putShort(2, this.checksum);
+ }
+ return data;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ final int prime = 5807;
+ int result = super.hashCode();
+ result = prime * result + this.icmpType;
+ result = prime * result + this.icmpCode;
+ result = prime * result + this.checksum;
+ return result;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!super.equals(obj)) {
+ return false;
+ }
+ if (!(obj instanceof ICMP6)) {
+ return false;
+ }
+ final ICMP6 other = (ICMP6) obj;
+ if (this.icmpType != other.icmpType) {
+ return false;
+ }
+ if (this.icmpCode != other.icmpCode) {
+ return false;
+ }
+ if (this.checksum != other.checksum) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public IPacket deserialize(final byte[] data, final int offset,
+ final int length) {
+ final ByteBuffer bb = ByteBuffer.wrap(data, offset, length);
+ this.icmpType = bb.get();
+ this.icmpCode = bb.get();
+ this.checksum = bb.getShort();
+
+ IPacket payload;
+ if (ICMP6.PROTOCOL_CLASS_MAP.containsKey(this.icmpType)) {
+ final Class<? extends IPacket> clazz = ICMP6.PROTOCOL_CLASS_MAP
+ .get(this.icmpType);
+ try {
+ payload = clazz.newInstance();
+ } catch (final Exception e) {
+ throw new RuntimeException(
+ "Error parsing payload for ICMP6 packet", e);
+ }
+ } else {
+ payload = new Data();
+ }
+ this.payload = payload.deserialize(data, bb.position(),
+ bb.limit() - bb.position());
+ this.payload.setParent(this);
+
+ return this;
+ }
+}
diff --git a/utils/misc/src/main/java/org/onlab/packet/IPv6.java b/utils/misc/src/main/java/org/onlab/packet/IPv6.java
new file mode 100644
index 0000000..aec3c2a
--- /dev/null
+++ b/utils/misc/src/main/java/org/onlab/packet/IPv6.java
@@ -0,0 +1,311 @@
+/*
+ * Copyright 2014 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+package org.onlab.packet;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ *
+ */
+public class IPv6 extends BasePacket {
+ public static final byte FIXED_HEADER_LENGTH = 40; // bytes
+
+ // TODO: Implement extension header.
+ public static final byte PROTOCOL_TCP = 0x6;
+ public static final byte PROTOCOL_UDP = 0x11;
+ public static final byte PROTOCOL_ICMP6 = 0x3A;
+ public static final Map<Byte, Class<? extends IPacket>> PROTOCOL_CLASS_MAP =
+ new HashMap<>();
+
+ static {
+ IPv6.PROTOCOL_CLASS_MAP.put(IPv6.PROTOCOL_ICMP6, ICMP6.class);
+ IPv6.PROTOCOL_CLASS_MAP.put(IPv6.PROTOCOL_TCP, TCP.class);
+ IPv6.PROTOCOL_CLASS_MAP.put(IPv6.PROTOCOL_UDP, UDP.class);
+ }
+
+ protected byte version;
+ protected byte diffServ;
+ protected int flowLabel;
+ protected short payloadLength;
+ protected byte nextHeader;
+ protected byte hopLimit;
+ protected byte[] sourceAddress = new byte[Ip6Address.BYTE_LENGTH];
+ protected byte[] destinationAddress = new byte[Ip6Address.BYTE_LENGTH];
+
+ /**
+ * Default constructor that sets the version to 4.
+ */
+ public IPv6() {
+ super();
+ this.version = 6;
+ }
+
+ /**
+ * @return the version
+ */
+ public byte getVersion() {
+ return this.version;
+ }
+
+ /**
+ * @param version
+ * the version to set
+ * @return this
+ */
+ public IPv6 setVersion(final byte version) {
+ this.version = version;
+ return this;
+ }
+
+ /**
+ * @return the diffServ
+ */
+ public byte getDiffServ() {
+ return this.diffServ;
+ }
+
+ /**
+ * @param diffServ
+ * the diffServ to set
+ * @return this
+ */
+ public IPv6 setDiffServ(final byte diffServ) {
+ this.diffServ = diffServ;
+ return this;
+ }
+
+ /**
+ * @return the flowLabel
+ */
+ public int getFlowLabel() {
+ return this.flowLabel;
+ }
+
+ /**
+ * @param flowLabel
+ * the flowLabel to set
+ * @return this
+ */
+ public IPv6 setFlowLabel(final int flowLabel) {
+ this.flowLabel = flowLabel;
+ return this;
+ }
+
+ /**
+ * @return the nextHeader
+ */
+ public byte getNextHeader() {
+ return this.nextHeader;
+ }
+
+ /**
+ * @param nextHeader
+ * the nextHeader to set
+ * @return this
+ */
+ public IPv6 setNextHeader(final byte nextHeader) {
+ this.nextHeader = nextHeader;
+ return this;
+ }
+
+ /**
+ * @return the hopLimit
+ */
+ public byte getHopLimit() {
+ return this.hopLimit;
+ }
+
+ /**
+ * @param hopLimit
+ * the hopLimit to set
+ * @return this
+ */
+ public IPv6 setHopLimit(final byte hopLimit) {
+ this.hopLimit = hopLimit;
+ return this;
+ }
+
+ /**
+ * @return the sourceAddress
+ */
+ public byte[] getSourceAddress() {
+ return this.sourceAddress;
+ }
+
+ /**
+ * @param sourceAddress
+ * the sourceAddress to set
+ * @return this
+ */
+ public IPv6 setSourceAddress(final byte[] sourceAddress) {
+ this.sourceAddress = Arrays.copyOfRange(sourceAddress, 0, Ip6Address.BYTE_LENGTH);
+ return this;
+ }
+
+ /**
+ * @return the destinationAddress
+ */
+ public byte[] getDestinationAddress() {
+ return this.destinationAddress;
+ }
+
+ /**
+ * @param destinationAddress
+ * the destinationAddress to set
+ * @return this
+ */
+ public IPv6 setDestinationAddress(final byte[] destinationAddress) {
+ this.destinationAddress = Arrays.copyOfRange(destinationAddress, 0, Ip6Address.BYTE_LENGTH);
+ return this;
+ }
+
+ @Override
+ public byte[] serialize() {
+ byte[] payloadData = null;
+ if (this.payload != null) {
+ this.payload.setParent(this);
+ payloadData = this.payload.serialize();
+ }
+
+ this.payloadLength = payloadData == null ? 0 : (short) payloadData.length;
+
+ final byte[] data = new byte[FIXED_HEADER_LENGTH + payloadLength];
+ final ByteBuffer bb = ByteBuffer.wrap(data);
+
+ bb.putInt((this.version & 0xf) << 28 | (this.diffServ & 0xff) << 20 | this.flowLabel & 0xfffff);
+ bb.putShort(this.payloadLength);
+ bb.put(this.nextHeader);
+ bb.put(this.hopLimit);
+ bb.put(this.sourceAddress, 0, Ip6Address.BYTE_LENGTH);
+ bb.put(this.destinationAddress, 0, Ip6Address.BYTE_LENGTH);
+
+ if (payloadData != null) {
+ bb.put(payloadData);
+ }
+
+ return data;
+ }
+
+ @Override
+ public IPacket deserialize(final byte[] data, final int offset,
+ final int length) {
+ final ByteBuffer bb = ByteBuffer.wrap(data, offset, length);
+ int iscratch;
+
+ iscratch = bb.getInt();
+ this.version = (byte) (iscratch >> 28 & 0xf);
+ this.diffServ = (byte) (iscratch >> 20 & 0xff);
+ this.flowLabel = iscratch & 0xfffff;
+ this.payloadLength = bb.getShort();
+ this.nextHeader = bb.get();
+ this.hopLimit = bb.get();
+ bb.get(this.sourceAddress, 0, Ip6Address.BYTE_LENGTH);
+ bb.get(this.destinationAddress, 0, Ip6Address.BYTE_LENGTH);
+
+ IPacket payload;
+ if (IPv6.PROTOCOL_CLASS_MAP.containsKey(this.nextHeader)) {
+ final Class<? extends IPacket> clazz = IPv6.PROTOCOL_CLASS_MAP
+ .get(this.nextHeader);
+ try {
+ payload = clazz.newInstance();
+ } catch (final Exception e) {
+ throw new RuntimeException(
+ "Error parsing payload for IPv6 packet", e);
+ }
+ } else {
+ payload = new Data();
+ }
+ this.payload = payload.deserialize(data, bb.position(),
+ bb.limit() - bb.position());
+ this.payload.setParent(this);
+
+ return this;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ final int prime = 2521;
+ int result = super.hashCode();
+ ByteBuffer bb;
+ bb = ByteBuffer.wrap(this.destinationAddress);
+ for (int i = 0; i < 4; i++) {
+ result = prime * result + bb.getInt();
+ }
+ result = prime * result + this.diffServ;
+ result = prime * result + this.flowLabel;
+ result = prime * result + this.hopLimit;
+ result = prime * result + this.nextHeader;
+ result = prime * result + this.payloadLength;
+ bb = ByteBuffer.wrap(this.sourceAddress);
+ for (int i = 0; i < 4; i++) {
+ result = prime * result + bb.getInt();
+ }
+ result = prime * result + this.version;
+ return result;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!super.equals(obj)) {
+ return false;
+ }
+ if (!(obj instanceof IPv6)) {
+ return false;
+ }
+ final IPv6 other = (IPv6) obj;
+ if (!Arrays.equals(this.destinationAddress, other.destinationAddress)) {
+ return false;
+ }
+ if (this.diffServ != other.diffServ) {
+ return false;
+ }
+ if (this.flowLabel != other.flowLabel) {
+ return false;
+ }
+ if (this.hopLimit != other.hopLimit) {
+ return false;
+ }
+ if (this.nextHeader != other.nextHeader) {
+ return false;
+ }
+ if (this.payloadLength != other.payloadLength) {
+ return false;
+ }
+ if (!Arrays.equals(this.sourceAddress, other.sourceAddress)) {
+ return false;
+ }
+ return true;
+ }
+}
diff --git a/utils/misc/src/main/java/org/onlab/packet/NeighborAdvertisement.java b/utils/misc/src/main/java/org/onlab/packet/NeighborAdvertisement.java
new file mode 100644
index 0000000..82776e2
--- /dev/null
+++ b/utils/misc/src/main/java/org/onlab/packet/NeighborAdvertisement.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2014 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+package org.onlab.packet;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+
+/**
+ * Implements ICMPv6 Neighbor Solicitation packet format.
+ */
+public class NeighborAdvertisement extends BasePacket {
+ public static final byte HEADER_LENGTH = 20; // bytes
+
+ protected byte routerFlag;
+ protected byte solicitedFlag;
+ protected byte overrideFlag;
+ protected byte[] targetAddress = new byte[Ip6Address.BYTE_LENGTH];
+
+ /**
+ *
+ * @return true if router flag is set
+ */
+ public byte getRouterFlag() {
+ return this.routerFlag;
+ }
+
+ /**
+ * @param routerFlag
+ * the routerFlag to set
+ * @return this
+ */
+ public NeighborAdvertisement setRouterFlag(final byte routerFlag) {
+ this.routerFlag = routerFlag;
+ return this;
+ }
+
+ /**
+ *
+ * @return true if solicited flag is set
+ */
+ public byte getSolicitedFlag() {
+ return this.solicitedFlag;
+ }
+
+ /**
+ * @param solicitedFlag
+ * the routerFlag to set
+ * @return this
+ */
+ public NeighborAdvertisement setSolicitedFlag(final byte solicitedFlag) {
+ this.solicitedFlag = solicitedFlag;
+ return this;
+ }
+
+ /**
+ *
+ * @return true if override flag is set
+ */
+ public byte getOverrideFlag() {
+ return this.overrideFlag;
+ }
+
+ /**
+ * @param overrideFlag
+ * the routerFlag to set
+ * @return this
+ */
+ public NeighborAdvertisement setOverrideFlag(final byte overrideFlag) {
+ this.overrideFlag = overrideFlag;
+ return this;
+ }
+
+ /**
+ *
+ * @return the target IPv6 address
+ */
+ public byte[] getTargetAddress() {
+ return this.targetAddress;
+ }
+
+ /**
+ * @param targetAddress
+ * the sourceAddress to set
+ * @return this
+ */
+ public NeighborAdvertisement setTargetAddress(final byte[] targetAddress) {
+ this.targetAddress = Arrays.copyOfRange(targetAddress, 0, Ip6Address.BYTE_LENGTH);
+ return this;
+ }
+
+ /**
+ * Serializes the packet. Will compute and set the following fields if they
+ * are set to specific values at the time serialize is called: -routerFlag : 0
+ * -solicitedFlag : 0 -overrideFlag : 0
+ */
+ @Override
+ public byte[] serialize() {
+ byte[] payloadData = null;
+ if (this.payload != null) {
+ this.payload.setParent(this);
+ payloadData = this.payload.serialize();
+ }
+
+ int payloadLength = payloadData == null ? 0 : (short) payloadData.length;
+
+ final byte[] data = new byte[HEADER_LENGTH + payloadLength];
+ final ByteBuffer bb = ByteBuffer.wrap(data);
+
+ bb.putInt((this.routerFlag & 0x1) << 31 | (this.solicitedFlag & 0x1) << 30 | (this.overrideFlag & 0x1) << 29);
+ bb.put(this.targetAddress, 0, Ip6Address.BYTE_LENGTH);
+ if (payloadData != null) {
+ bb.put(payloadData);
+ }
+
+ return data;
+ }
+
+ @Override
+ public IPacket deserialize(byte[] data, int offset, int length) {
+ final ByteBuffer bb = ByteBuffer.wrap(data, offset, length);
+ int iscratch;
+
+ iscratch = bb.getInt();
+ this.routerFlag = (byte) (iscratch >> 31 & 0x1);
+ this.solicitedFlag = (byte) (iscratch >> 30 & 0x1);
+ this.overrideFlag = (byte) (iscratch >> 29 & 0x1);
+ bb.get(this.targetAddress, 0, Ip6Address.BYTE_LENGTH);
+
+ this.payload = new Data();
+ this.payload = this.payload.deserialize(data, bb.position(), bb.limit()
+ - bb.position());
+ this.payload.setParent(this);
+
+ return this;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#hashCode()
+ */
+ @Override
+ public int hashCode() {
+ final int prime = 5807;
+ int result = super.hashCode();
+ ByteBuffer bb;
+ result = prime * result + this.routerFlag;
+ result = prime * result + this.solicitedFlag;
+ result = prime * result + this.overrideFlag;
+ bb = ByteBuffer.wrap(this.targetAddress);
+ for (int i = 0; i < 4; i++) {
+ result = prime * result + bb.getInt();
+ }
+ return result;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#equals(java.lang.Object)
+ */
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!super.equals(obj)) {
+ return false;
+ }
+ if (!(obj instanceof NeighborAdvertisement)) {
+ return false;
+ }
+ final NeighborAdvertisement other = (NeighborAdvertisement) obj;
+ if (this.routerFlag != other.routerFlag) {
+ return false;
+ }
+ if (this.solicitedFlag != other.solicitedFlag) {
+ return false;
+ }
+ if (this.overrideFlag != other.overrideFlag) {
+ return false;
+ }
+ if (!Arrays.equals(this.targetAddress, other.targetAddress)) {
+ return false;
+ }
+ return true;
+ }
+}
diff --git a/utils/misc/src/test/java/org/onlab/packet/IPv6Test.java b/utils/misc/src/test/java/org/onlab/packet/IPv6Test.java
new file mode 100644
index 0000000..0c14fea
--- /dev/null
+++ b/utils/misc/src/test/java/org/onlab/packet/IPv6Test.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2014 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+package org.onlab.packet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * Tests for class {@link IPv6}.
+ */
+public class IPv6Test {
+ private static final byte[] SOURCE_ADDRESS = {
+ (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15,
+ (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce
+ };
+ private static final byte[] DESTINATION_ADDRESS = {
+ (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15,
+ (byte) 0xe6, (byte) 0xce, (byte) 0x8f, (byte) 0xff, (byte) 0xfe, (byte) 0x54, (byte) 0x37, (byte) 0xc8
+ };
+ private static Data data;
+ private static UDP udp;
+ private static byte[] bytePacket;
+
+ @BeforeClass
+ public static void setUpBeforeClass() throws Exception {
+ data = new Data();
+ data.setData("testSerialize".getBytes());
+ udp = new UDP();
+ udp.setPayload(data);
+
+ byte[] bytePayload = udp.serialize();
+ byte[] byteHeader = {
+ (byte) 0x69, (byte) 0x31, (byte) 0x35, (byte) 0x79,
+ (byte) (bytePayload.length >> 8 & 0xff), (byte) (bytePayload.length & 0xff),
+ (byte) 0x11, (byte) 0x20,
+ (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15,
+ (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce,
+ (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15,
+ (byte) 0xe6, (byte) 0xce, (byte) 0x8f, (byte) 0xff, (byte) 0xfe, (byte) 0x54, (byte) 0x37, (byte) 0xc8,
+ };
+ bytePacket = new byte[byteHeader.length + bytePayload.length];
+ System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length);
+ System.arraycopy(bytePayload, 0, bytePacket, byteHeader.length, bytePayload.length);
+ }
+
+ /**
+ * Tests serialize and setters.
+ */
+ @Test
+ public void testSerialize() {
+ IPv6 ipv6 = new IPv6();
+ ipv6.setPayload(udp);
+ ipv6.setVersion((byte) 6);
+ ipv6.setDiffServ((byte) 0x93);
+ ipv6.setFlowLabel(0x13579);
+ ipv6.setNextHeader(IPv6.PROTOCOL_UDP);
+ ipv6.setHopLimit((byte) 32);
+ ipv6.setSourceAddress(SOURCE_ADDRESS);
+ ipv6.setDestinationAddress(DESTINATION_ADDRESS);
+
+ assertArrayEquals(ipv6.serialize(), bytePacket);
+ }
+
+ /**
+ * Tests deserialize and getters.
+ */
+ @Test
+ public void testDeserialize() {
+ IPv6 ipv6 = new IPv6();
+ ipv6.deserialize(bytePacket, 0, bytePacket.length);
+
+ assertThat(ipv6.getVersion(), is((byte) 6));
+ assertThat(ipv6.getDiffServ(), is((byte) 0x93));
+ assertThat(ipv6.getFlowLabel(), is(0x13579));
+ assertThat(ipv6.getNextHeader(), is(IPv6.PROTOCOL_UDP));
+ assertThat(ipv6.getHopLimit(), is((byte) 32));
+ assertArrayEquals(ipv6.getSourceAddress(), SOURCE_ADDRESS);
+ assertArrayEquals(ipv6.getDestinationAddress(), DESTINATION_ADDRESS);
+ }
+
+ /**
+ * Tests comparator.
+ */
+ @Test
+ public void testEqual() {
+ IPv6 packet1 = new IPv6();
+ packet1.setPayload(udp);
+ packet1.setVersion((byte) 6);
+ packet1.setDiffServ((byte) 0x93);
+ packet1.setFlowLabel(0x13579);
+ packet1.setNextHeader(IPv6.PROTOCOL_UDP);
+ packet1.setHopLimit((byte) 32);
+ packet1.setSourceAddress(SOURCE_ADDRESS);
+ packet1.setDestinationAddress(DESTINATION_ADDRESS);
+
+ IPv6 packet2 = new IPv6();
+ packet2.setPayload(udp);
+ packet2.setVersion((byte) 6);
+ packet2.setDiffServ((byte) 0x93);
+ packet2.setFlowLabel(0x13579);
+ packet2.setNextHeader(IPv6.PROTOCOL_UDP);
+ packet2.setHopLimit((byte) 32);
+ packet2.setSourceAddress(DESTINATION_ADDRESS);
+ packet2.setDestinationAddress(SOURCE_ADDRESS);
+
+ assertTrue(packet1.equals(packet1));
+ assertFalse(packet1.equals(packet2));
+ }
+}
diff --git a/utils/misc/src/test/java/org/onlab/packet/NeighborAdvertisementTest.java b/utils/misc/src/test/java/org/onlab/packet/NeighborAdvertisementTest.java
new file mode 100644
index 0000000..8627a9b
--- /dev/null
+++ b/utils/misc/src/test/java/org/onlab/packet/NeighborAdvertisementTest.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2014 Open Networking Laboratory
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+
+package org.onlab.packet;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.*;
+
+/**
+ * Tests for class {@link NeighborAdvertisement}.
+ */
+public class NeighborAdvertisementTest {
+ private static final byte[] TARGET_ADDRESS = {
+ (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15,
+ (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce
+ };
+ private static Data data;
+ private static byte[] bytePacket;
+
+ @BeforeClass
+ public static void setUpBeforeClass() throws Exception {
+ data = new Data();
+ data.setData("".getBytes());
+
+ byte[] bytePayload = data.serialize();
+ byte[] byteHeader = {
+ (byte) 0xe0, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+ (byte) 0x20, (byte) 0x01, (byte) 0x0f, (byte) 0x18, (byte) 0x01, (byte) 0x13, (byte) 0x02, (byte) 0x15,
+ (byte) 0xca, (byte) 0x2a, (byte) 0x14, (byte) 0xff, (byte) 0xfe, (byte) 0x35, (byte) 0x26, (byte) 0xce
+ };
+ bytePacket = new byte[byteHeader.length + bytePayload.length];
+ System.arraycopy(byteHeader, 0, bytePacket, 0, byteHeader.length);
+ System.arraycopy(bytePayload, 0, bytePacket, byteHeader.length, bytePayload.length);
+ }
+
+ /**
+ * Tests serialize and setters.
+ */
+ @Test
+ public void testSerialize() {
+ NeighborAdvertisement na = new NeighborAdvertisement();
+ na.setRouterFlag((byte) 1);
+ na.setSolicitedFlag((byte) 1);
+ na.setOverrideFlag((byte) 1);
+ na.setTargetAddress(TARGET_ADDRESS);
+
+ assertArrayEquals(na.serialize(), bytePacket);
+ }
+
+ /**
+ * Tests deserialize and getters.
+ */
+ @Test
+ public void testDeserialize() {
+ NeighborAdvertisement na = new NeighborAdvertisement();
+ na.deserialize(bytePacket, 0, bytePacket.length);
+
+ assertThat(na.getRouterFlag(), is((byte) 1));
+ assertThat(na.getSolicitedFlag(), is((byte) 1));
+ assertThat(na.getOverrideFlag(), is((byte) 1));
+ assertArrayEquals(na.getTargetAddress(), TARGET_ADDRESS);
+ }
+
+ /**
+ * Tests comparator.
+ */
+ @Test
+ public void testEqual() {
+ NeighborAdvertisement na1 = new NeighborAdvertisement();
+ na1.setRouterFlag((byte) 1);
+ na1.setSolicitedFlag((byte) 1);
+ na1.setOverrideFlag((byte) 1);
+ na1.setTargetAddress(TARGET_ADDRESS);
+
+ NeighborAdvertisement na2 = new NeighborAdvertisement();
+ na2.setRouterFlag((byte) 1);
+ na2.setSolicitedFlag((byte) 1);
+ na2.setOverrideFlag((byte) 0);
+ na2.setTargetAddress(TARGET_ADDRESS);
+
+ assertTrue(na1.equals(na1));
+ assertFalse(na1.equals(na2));
+ }
+}