ONOS-2739 - OSPF Basic Packet Structures , which includes encoding and decoding
Change-Id: Ifaaa4d3640c6a4fec4931db54a1f03100cc9d9e6
diff --git a/protocols/ospf/protocol/src/main/java/org/onosproject/ospf/protocol/util/ChecksumCalculator.java b/protocols/ospf/protocol/src/main/java/org/onosproject/ospf/protocol/util/ChecksumCalculator.java
new file mode 100644
index 0000000..306ad1b
--- /dev/null
+++ b/protocols/ospf/protocol/src/main/java/org/onosproject/ospf/protocol/util/ChecksumCalculator.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright 2016 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.onosproject.ospf.protocol.util;
+
+import org.onosproject.ospf.controller.OspfLsa;
+import org.onosproject.ospf.controller.OspfLsaType;
+import org.onosproject.ospf.protocol.lsa.types.AsbrSummaryLsa;
+import org.onosproject.ospf.protocol.lsa.types.ExternalLsa;
+import org.onosproject.ospf.protocol.lsa.types.NetworkLsa;
+import org.onosproject.ospf.protocol.lsa.types.OpaqueLsa10;
+import org.onosproject.ospf.protocol.lsa.types.OpaqueLsa11;
+import org.onosproject.ospf.protocol.lsa.types.OpaqueLsa9;
+import org.onosproject.ospf.protocol.lsa.types.RouterLsa;
+import org.onosproject.ospf.protocol.lsa.types.SummaryLsa;
+import org.onosproject.ospf.protocol.ospfpacket.OspfMessage;
+import org.onosproject.ospf.protocol.ospfpacket.types.DdPacket;
+import org.onosproject.ospf.protocol.ospfpacket.types.HelloPacket;
+import org.onosproject.ospf.protocol.ospfpacket.types.LsAcknowledge;
+import org.onosproject.ospf.protocol.ospfpacket.types.LsRequest;
+import org.onosproject.ospf.protocol.ospfpacket.types.LsUpdate;
+
+import java.util.Arrays;
+
+/**
+ * Calculates checksum for different types of OSPF packets.
+ */
+public class ChecksumCalculator {
+
+ /**
+ * Converts given string to sixteen bits integer.
+ * If hexasum is more than 16 bit value, needs to be reduced to 16 bit value.
+ *
+ * @param strToConvert hexasum value to convert
+ * @return 16 bit integer value
+ */
+ public static int convertToSixteenBits(String strToConvert) {
+ StringBuilder sb = new StringBuilder(strToConvert);
+ sb = sb.reverse();
+ StringBuilder s1 = new StringBuilder(sb.substring(0, 4));
+ s1 = s1.reverse();
+ StringBuilder s2 = new StringBuilder(sb.substring(4, sb.length()));
+ s2 = s2.reverse();
+ int num = Integer.parseInt(s1.toString(), 16) + Integer.parseInt(s2.toString(), 16);
+ return num;
+ }
+
+ /**
+ * Checks whether checksum is valid or not in the given OSPF message.
+ *
+ * @param ospfMessage ospf message instance
+ * @param checksumPos1 position of checksum bit in packet
+ * @param checksumPos2 position of checksum bit in packet
+ * @return true if valid else false
+ */
+ public boolean isValidOspfCheckSum(OspfMessage ospfMessage, int checksumPos1, int checksumPos2) {
+
+ switch (ospfMessage.ospfMessageType().value()) {
+ case OspfParameters.HELLO:
+ ospfMessage = (HelloPacket) ospfMessage;
+ break;
+ case OspfParameters.DD:
+ ospfMessage = (DdPacket) ospfMessage;
+ break;
+ case OspfParameters.LSREQUEST:
+ ospfMessage = (LsRequest) ospfMessage;
+ break;
+ case OspfParameters.LSUPDATE:
+ ospfMessage = (LsUpdate) ospfMessage;
+ break;
+ case OspfParameters.LSACK:
+ ospfMessage = (LsAcknowledge) ospfMessage;
+ break;
+ default:
+ break;
+ }
+
+ byte[] messageAsBytes = ospfMessage.asBytes();
+ return validateOspfCheckSum(messageAsBytes, checksumPos1, checksumPos2);
+ }
+
+ /**
+ * Checks whether checksum is valid or not in the given OSPF LSA.
+ *
+ * @param ospfLsa lsa instance
+ * @param lsType lsa type
+ * @param lsaChecksumPos1 lsa checksum position in packet
+ * @param lsaChecksumPos2 lsa checksum position in packet
+ * @return true if valid else false
+ * @throws Exception might throw exception while processing
+ */
+ public boolean isValidLsaCheckSum(OspfLsa ospfLsa, int lsType, int lsaChecksumPos1,
+ int lsaChecksumPos2) throws Exception {
+ if (lsType == OspfLsaType.ROUTER.value()) {
+ RouterLsa lsa = (RouterLsa) ospfLsa;
+ return validateLsaCheckSum(lsa.asBytes(), lsaChecksumPos1, lsaChecksumPos2);
+ } else if (lsType == OspfLsaType.NETWORK.value()) {
+ NetworkLsa lsa = (NetworkLsa) ospfLsa;
+ return validateLsaCheckSum(lsa.asBytes(), lsaChecksumPos1, lsaChecksumPos2);
+ } else if (lsType == OspfLsaType.SUMMARY.value()) {
+ SummaryLsa lsa = (SummaryLsa) ospfLsa;
+ return validateLsaCheckSum(lsa.asBytes(), lsaChecksumPos1, lsaChecksumPos2);
+ } else if (lsType == OspfLsaType.ASBR_SUMMARY.value()) {
+ AsbrSummaryLsa lsa = (AsbrSummaryLsa) ospfLsa;
+ return validateLsaCheckSum(lsa.asBytes(), lsaChecksumPos1, lsaChecksumPos2);
+ } else if (lsType == OspfLsaType.EXTERNAL_LSA.value()) {
+ ExternalLsa lsa = (ExternalLsa) ospfLsa;
+ return validateLsaCheckSum(lsa.asBytes(), lsaChecksumPos1, lsaChecksumPos2);
+ } else if (lsType == OspfLsaType.LINK_LOCAL_OPAQUE_LSA.value()) {
+ OpaqueLsa9 lsa = (OpaqueLsa9) ospfLsa;
+ return validateLsaCheckSum(lsa.asBytes(), lsaChecksumPos1, lsaChecksumPos2);
+ } else if (lsType == OspfLsaType.AREA_LOCAL_OPAQUE_LSA.value()) {
+ OpaqueLsa10 lsa = (OpaqueLsa10) ospfLsa;
+ return validateLsaCheckSum(lsa.asBytes(), lsaChecksumPos1, lsaChecksumPos2);
+ } else if (lsType == OspfLsaType.AS_OPAQUE_LSA.value()) {
+ OpaqueLsa11 lsa = (OpaqueLsa11) ospfLsa;
+ return validateLsaCheckSum(lsa.asBytes(), lsaChecksumPos1, lsaChecksumPos2);
+ }
+
+ return false;
+ }
+
+ /**
+ * Verifies the checksum is valid in given LSA packet bytes.
+ *
+ * @param lsaPacket lsa as byte array
+ * @param lsaChecksumPos1 position of checksum bit in packet
+ * @param lsaChecksumPos2 position of checksum bit in packet
+ * @return true if valid else false
+ */
+ public boolean validateLsaCheckSum(byte[] lsaPacket, int lsaChecksumPos1, int lsaChecksumPos2) {
+
+ byte[] checksum = calculateLsaChecksum(lsaPacket, lsaChecksumPos1, lsaChecksumPos2);
+
+ if (lsaPacket[lsaChecksumPos1] == checksum[0] && lsaPacket[lsaChecksumPos2] == checksum[1]) {
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Verifies the checksum is valid in given OSPF packet bytes.
+ *
+ * @param ospfPacket as byte array
+ * @param checksumPos1 position of checksum bit in packet
+ * @param checksumPos2 position of checksum bit in packet
+ * @return true if valid else false
+ */
+ public boolean validateOspfCheckSum(byte[] ospfPacket, int checksumPos1, int checksumPos2) {
+
+ byte[] checkSum = calculateOspfCheckSum(ospfPacket, checksumPos1, checksumPos2);
+
+ if (ospfPacket[checksumPos1] == checkSum[0] && ospfPacket[checksumPos2] == checkSum[1]) {
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Calculates the LSA checksum.
+ *
+ * @param lsaBytes as byte array
+ * @param lsaChecksumPos1 position of checksum bit in packet
+ * @param lsaChecksumPos2 position of checksum bit in packet
+ * @return checksum bytes
+ */
+ public byte[] calculateLsaChecksum(byte[] lsaBytes, int lsaChecksumPos1, int lsaChecksumPos2) {
+
+ byte[] tempLsaByte = Arrays.copyOf(lsaBytes, lsaBytes.length);
+
+ int[] checksumOut = {0, 0};
+ tempLsaByte[lsaChecksumPos1] = 0;
+ tempLsaByte[lsaChecksumPos2] = 0;
+ byte[] byteCheckSum = {0, 0};
+ if (lsaBytes != null) {
+ for (int i = 2; i < tempLsaByte.length; i++) {
+ checksumOut[0] = checksumOut[0] + ((int) tempLsaByte[i] & 0xFF);
+ checksumOut[1] = checksumOut[1] + checksumOut[0];
+ }
+ checksumOut[0] = checksumOut[0] % 255;
+ checksumOut[1] = checksumOut[1] % 255;
+ }
+ int byte1 = (int) ((tempLsaByte.length - lsaChecksumPos1 - 1) * checksumOut[0] - checksumOut[1]) % 255;
+ if (byte1 <= 0) {
+ byte1 += 255;
+ }
+ int byte2 = 510 - checksumOut[0] - byte1;
+ if (byte2 > 255) {
+ byte2 -= 255;
+ }
+
+ byteCheckSum[0] = (byte) byte1;
+ byteCheckSum[1] = (byte) byte2;
+
+ return byteCheckSum;
+ }
+
+ /**
+ * Calculate checksum from hexasum.
+ *
+ * @param hexasum total of 16 bits hexadecimal values
+ * @return checksum value
+ */
+ private int calculateChecksum(int hexasum) {
+
+ char[] tempZeros = {'0', '0', '0', '0'};
+ StringBuffer hexaAsBinaryStr = new StringBuffer(Integer.toBinaryString(hexasum));
+ int length = hexaAsBinaryStr.length();
+ while (length > 16) {
+ if (hexaAsBinaryStr.length() % 4 != 0) {
+ int offset = hexaAsBinaryStr.length() % 4;
+ hexaAsBinaryStr.insert(0, tempZeros, 0, 4 - offset);
+ }
+ StringBuffer hexaStr1 = new StringBuffer(hexaAsBinaryStr.reverse().substring(0, 16));
+ String revHexaStr1 = hexaStr1.reverse().toString();
+ StringBuffer hexaStr2 = new StringBuffer(hexaAsBinaryStr.reverse());
+ StringBuffer hexaStr3 = new StringBuffer(hexaStr2.reverse().substring(16, hexaStr2.length()));
+ String revHexaStr3 = hexaStr3.reverse().toString();
+ int lastSixteenHexaBits = Integer.parseInt(revHexaStr1, 2);
+ int remainingHexaBits = Integer.parseInt(revHexaStr3, 2);
+ int totalCheckSum = lastSixteenHexaBits + remainingHexaBits;
+ hexaAsBinaryStr = new StringBuffer(Integer.toBinaryString(totalCheckSum));
+ length = hexaAsBinaryStr.length();
+ }
+ if (hexaAsBinaryStr.length() < 16) {
+ int count = 16 - hexaAsBinaryStr.length();
+ String s = hexaAsBinaryStr.toString();
+ for (int i = 0; i < count; i++) {
+ s = "0" + s;
+ }
+
+ hexaAsBinaryStr = new StringBuffer(s);
+
+ }
+ StringBuffer checksum = negate(hexaAsBinaryStr);
+ return Integer.parseInt(checksum.toString(), 2);
+ }
+
+ /**
+ * Negates given hexasum.
+ *
+ * @param binaryString binary form of hexasum
+ * @return binary from of calculateChecksum
+ */
+ private StringBuffer negate(StringBuffer binaryString) {
+ for (int i = 0; i < binaryString.length(); i++) {
+ if (binaryString.charAt(i) == '1') {
+ binaryString.replace(i, i + 1, "0");
+ } else {
+ binaryString.replace(i, i + 1, "1");
+ }
+ }
+
+ return binaryString;
+ }
+
+ /**
+ * Calculates the OSPF checksum for the given packet.
+ *
+ * @param packet as byte array
+ * @param checksumPos1 position of checksum bit in packet
+ * @param checksumPos2 position of checksum bit in packet
+ * @return checksum bytes
+ */
+ public byte[] calculateOspfCheckSum(byte[] packet, int checksumPos1, int checksumPos2) {
+
+ int hexasum = 0;
+ for (int i = 0; i < packet.length; i = i + 2) {
+ if (i != 12) {
+ byte b1 = packet[i];
+ String s1 = String.format("%8s", Integer.toBinaryString(b1 & 0xFF)).replace(' ', '0');
+ b1 = packet[i + 1];
+ String s2 = String.format("%8s", Integer.toBinaryString(b1 & 0xFF)).replace(' ', '0');
+ String hexa = s1 + s2;
+ int num1 = Integer.parseInt(hexa, 2);
+ hexasum = hexasum + num1;
+ String convertTo16 = Integer.toHexString(hexasum);
+ if (convertTo16.length() > 4) {
+ hexasum = convertToSixteenBits(convertTo16);
+ }
+ }
+ }
+ StringBuilder sb = new StringBuilder(Integer.toHexString(hexasum));
+ if (sb.length() > 4) {
+ sb = sb.reverse();
+ StringBuilder s1 = new StringBuilder(sb.substring(0, 4));
+ s1 = s1.reverse();
+ StringBuilder s2 = new StringBuilder(sb.substring(4, sb.length()));
+ s2 = s2.reverse();
+ hexasum = Integer.parseInt(s1.toString(), 16) + Integer.parseInt(s2.toString(), 16);
+ }
+ int finalChecksum = calculateChecksum(hexasum);
+ return OspfUtil.convertToTwoBytes(finalChecksum);
+ }
+}
\ No newline at end of file