| /* |
| * Copyright 2016-present 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.isis.io.util; |
| |
| import com.google.common.primitives.Bytes; |
| import org.onlab.packet.Ip4Address; |
| import org.onlab.packet.MacAddress; |
| import org.onosproject.isis.controller.IsisInterface; |
| import org.onosproject.isis.controller.IsisInterfaceState; |
| import org.onosproject.isis.controller.IsisNeighbor; |
| import org.onosproject.isis.controller.IsisPduType; |
| import org.onosproject.isis.io.isispacket.IsisHeader; |
| import org.onosproject.isis.io.isispacket.pdu.L1L2HelloPdu; |
| import org.onosproject.isis.io.isispacket.pdu.P2PHelloPdu; |
| import org.onosproject.isis.io.isispacket.tlv.AdjacencyStateTlv; |
| import org.onosproject.isis.io.isispacket.tlv.AreaAddressTlv; |
| import org.onosproject.isis.io.isispacket.tlv.IpInterfaceAddressTlv; |
| import org.onosproject.isis.io.isispacket.tlv.IsisNeighborTlv; |
| import org.onosproject.isis.io.isispacket.tlv.PaddingTlv; |
| import org.onosproject.isis.io.isispacket.tlv.ProtocolSupportedTlv; |
| import org.onosproject.isis.io.isispacket.tlv.TlvHeader; |
| import org.onosproject.isis.io.isispacket.tlv.TlvType; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import javax.xml.bind.DatatypeConverter; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Set; |
| import java.util.StringTokenizer; |
| |
| /** |
| * Representation of ISIS utils. |
| */ |
| public final class IsisUtil { |
| public static final int ETHER_HEADER_LEN = 17; |
| public static final int ID_SIX_BYTES = 6; |
| public static final int ID_PLUS_ONE_BYTE = 7; |
| public static final int ID_PLUS_TWO_BYTE = 8; |
| public static final int THREE_BYTES = 3; |
| public static final int TWO_BYTES = 2; |
| public static final int SIX_BYTES = 6; |
| public static final int EIGHT_BYTES = 8; |
| public static final int FOUR_BYTES = 4; |
| public static final int PADDING_FIXED_LENGTH = 255; |
| public static final int TLVHEADERLENGTH = 2; |
| public static final int INITIAL_BANDWIDTH = 12500000; |
| private static final Logger log = LoggerFactory.getLogger(IsisUtil.class); |
| |
| /** |
| * Creates an instance. |
| */ |
| private IsisUtil() { |
| |
| } |
| |
| /** |
| * Checks given IPs are in same network or not. |
| * |
| * @param ip1 IP address |
| * @param ip2 IP address |
| * @param mask network mask |
| * @return true if both are in same network else false |
| */ |
| public static boolean sameNetwork(Ip4Address ip1, Ip4Address ip2, byte[] mask) { |
| try { |
| byte[] a1 = ip1.toOctets(); |
| byte[] a2 = ip2.toOctets(); |
| for (int i = 0; i < a1.length; i++) { |
| if ((a1[i] & mask[i]) != (a2[i] & mask[i])) { |
| return false; |
| } |
| } |
| } catch (Exception e) { |
| log.debug("Exception::IsisUtil::sameNetwork:: {}", e.getMessage()); |
| } |
| return true; |
| } |
| |
| /** |
| * Parse byte array to string system ID. |
| * |
| * @param bytes system ID |
| * @return systemId system ID |
| */ |
| public static String systemId(byte[] bytes) { |
| String systemId = ""; |
| for (Byte byt : bytes) { |
| String hexa = Integer.toHexString(Byte.toUnsignedInt(byt)); |
| if (hexa.length() % 2 != 0) { |
| hexa = "0" + hexa; |
| } |
| systemId = systemId + hexa; |
| if (systemId.length() == 4 || systemId.length() == 9) { |
| systemId = systemId + "."; |
| } |
| } |
| return systemId; |
| } |
| |
| /** |
| * Parse byte array to LAN ID. |
| * |
| * @param bytes LAN ID |
| * @return systemIdPlus system ID |
| */ |
| public static String systemIdPlus(byte[] bytes) { |
| int count = 1; |
| String systemId = ""; |
| for (Byte byt : bytes) { |
| String hexa = Integer.toHexString(Byte.toUnsignedInt(byt)); |
| if (hexa.length() % 2 != 0) { |
| hexa = "0" + hexa; |
| } |
| if (count == 7 && bytes.length == 8) { |
| systemId = systemId + hexa + "-"; |
| } else { |
| systemId = systemId + hexa; |
| } |
| if (systemId.length() == 4 || systemId.length() == 9 |
| || systemId.length() == 14) { |
| systemId = systemId + "."; |
| } |
| count++; |
| } |
| return systemId; |
| } |
| |
| /** |
| * Parse byte array to area address. |
| * |
| * @param bytes area address |
| * @return areaAddres area address |
| */ |
| public static String areaAddres(byte[] bytes) { |
| String areaAddres = ""; |
| for (Byte byt : bytes) { |
| String hexa = Integer.toHexString(Byte.toUnsignedInt(byt)); |
| if (hexa.length() % 2 != 0) { |
| hexa = "0" + hexa; |
| } |
| areaAddres = areaAddres + hexa; |
| } |
| return areaAddres; |
| } |
| |
| /** |
| * Parse area address to bytes. |
| * |
| * @param address area address |
| * @return areaAddress area address |
| */ |
| public static List<Byte> areaAddressToBytes(String address) { |
| List<Byte> idList = new ArrayList<>(); |
| for (int i = 0; i < address.length(); i = i + 2) { |
| Character c1 = address.charAt(i); |
| Character c2 = address.charAt(i + 1); |
| String str = c1.toString() + c2.toString(); |
| idList.add((byte) Integer.parseInt(str, 16)); |
| } |
| return idList; |
| } |
| |
| /** |
| * Returns PDU headaer length. |
| * |
| * @param pduType PDU type |
| * @return headerLength header length |
| */ |
| public static int getPduHeaderLength(int pduType) { |
| int headerLength = 0; |
| switch (IsisPduType.get(pduType)) { |
| case L1HELLOPDU: |
| case L2HELLOPDU: |
| case L1LSPDU: |
| case L2LSPDU: |
| headerLength = IsisConstants.HELLOHEADERLENGTH; |
| break; |
| case P2PHELLOPDU: |
| headerLength = IsisConstants.P2PHELLOHEADERLENGTH; |
| break; |
| case L1PSNP: |
| case L2PSNP: |
| headerLength = IsisConstants.PSNPDUHEADERLENGTH; |
| break; |
| case L1CSNP: |
| case L2CSNP: |
| headerLength = IsisConstants.CSNPDUHEADERLENGTH; |
| break; |
| default: |
| break; |
| } |
| return headerLength; |
| } |
| |
| /** |
| * Adds the PDU length in packet. |
| * |
| * @param isisPacket ISIS packet |
| * @param lengthBytePos1 length byte position |
| * @param lengthBytePos2 length byte position |
| * @param reservedBytePos reserved byte position |
| * @return byte array with PDU length |
| */ |
| public static byte[] addLengthAndMarkItInReserved(byte[] isisPacket, int lengthBytePos1, |
| int lengthBytePos2, int reservedBytePos) { |
| //Set the length of the packet |
| //Get the total length of the packet |
| int length = isisPacket.length; |
| //Convert the lenth to two bytes as the length field is 2 bytes |
| byte[] lenthInTwoBytes = IsisUtil.convertToTwoBytes(length); |
| //isis header 3rd and 4th position represents length |
| isisPacket[lengthBytePos1] = lenthInTwoBytes[0]; //assign 1st byte in lengthBytePos1 |
| isisPacket[lengthBytePos2] = lenthInTwoBytes[1]; //assign 2st byte in lengthBytePos2 |
| isisPacket[reservedBytePos] = (byte) lengthBytePos1; |
| return isisPacket; |
| } |
| |
| /** |
| * Adds the checksum in packet. |
| * |
| * @param isisPacket ISIS packet |
| * @param checksumBytePos1 checksum byte position |
| * @param checksumBytePos2 checksum byte position |
| * @return byte array with PDU length |
| */ |
| public static byte[] addChecksum(byte[] isisPacket, int checksumBytePos1, int checksumBytePos2) { |
| //Set the checksum for the packet |
| //Convert the length to two bytes as the length field is 2 bytes |
| byte[] checksumInTwoBytes = new ChecksumCalculator().calculateLspChecksum( |
| isisPacket, checksumBytePos1, checksumBytePos2); |
| //isis header 3rd and 4th position represents length |
| isisPacket[checksumBytePos1] = checksumInTwoBytes[0]; |
| isisPacket[checksumBytePos2] = checksumInTwoBytes[1]; |
| return isisPacket; |
| } |
| |
| /** |
| * Adds frame a packet of 1498 of size. |
| * |
| * @param isisPacket ISIS packet |
| * @param interfaceIndex interface index |
| * @return byte array with 1498 is the length |
| */ |
| public static byte[] framePacket(byte[] isisPacket, int interfaceIndex) { |
| //Set the length of the packet |
| //Get the total length of the packet |
| int length = isisPacket.length; |
| //PDU_LENGTH + 1 byte for interface index |
| if (length < IsisConstants.PDU_LENGTH + 1) { |
| byte[] bytes = new byte[IsisConstants.PDU_LENGTH + 1]; |
| System.arraycopy(isisPacket, 0, bytes, 0, length); |
| bytes[IsisConstants.PDU_LENGTH] = (byte) interfaceIndex; |
| return bytes; |
| } |
| return isisPacket; |
| } |
| |
| /** |
| * Parse source and LAN ID. |
| * |
| * @param id source and LAN ID |
| * @return source and LAN ID |
| */ |
| public static List<Byte> sourceAndLanIdToBytes(String id) { |
| List<Byte> idList = new ArrayList<>(); |
| StringTokenizer tokenizer = new StringTokenizer(id, "." + "-"); |
| while (tokenizer.hasMoreElements()) { |
| int i = 0; |
| String str = tokenizer.nextToken(); |
| idList.add((byte) Integer.parseInt(str.substring(0, i + 2), 16)); |
| if (str.length() > 2) { |
| idList.add((byte) Integer.parseInt(str.substring(i + 2, str.length()), 16)); |
| } |
| } |
| return idList; |
| } |
| |
| /** |
| * Parse padding for PDU based on current length. |
| * |
| * @param currentLength current length |
| * @return byteArray padding array |
| */ |
| public static byte[] getPaddingTlvs(int currentLength) { |
| List<Byte> bytes = new ArrayList<>(); |
| while (IsisConstants.PDU_LENGTH > currentLength) { |
| int length = IsisConstants.PDU_LENGTH - currentLength; |
| TlvHeader tlvHeader = new TlvHeader(); |
| tlvHeader.setTlvType(TlvType.PADDING.value()); |
| if (length >= PADDING_FIXED_LENGTH) { |
| tlvHeader.setTlvLength(PADDING_FIXED_LENGTH); |
| } else { |
| tlvHeader.setTlvLength(IsisConstants.PDU_LENGTH - (currentLength + TLVHEADERLENGTH)); |
| } |
| PaddingTlv tlv = new PaddingTlv(tlvHeader); |
| bytes.addAll(Bytes.asList(tlv.asBytes())); |
| currentLength = currentLength + tlv.tlvLength() + TLVHEADERLENGTH; |
| } |
| byte[] byteArray = new byte[bytes.size()]; |
| int i = 0; |
| for (byte byt : bytes) { |
| byteArray[i++] = byt; |
| } |
| return byteArray; |
| } |
| |
| /** |
| * Converts an integer to two bytes. |
| * |
| * @param numberToConvert number to convert |
| * @return numInBytes given number as bytes |
| */ |
| public static byte[] convertToTwoBytes(int numberToConvert) { |
| |
| byte[] numInBytes = new byte[2]; |
| String s1 = Integer.toHexString(numberToConvert); |
| if (s1.length() % 2 != 0) { |
| s1 = "0" + s1; |
| } |
| byte[] hexas = DatatypeConverter.parseHexBinary(s1); |
| if (hexas.length == 1) { |
| numInBytes[0] = 0; |
| numInBytes[1] = hexas[0]; |
| } else { |
| numInBytes[0] = hexas[0]; |
| numInBytes[1] = hexas[1]; |
| } |
| return numInBytes; |
| } |
| |
| /** |
| * Converts a number to four bytes. |
| * |
| * @param numberToConvert number to convert |
| * @return numInBytes given number as bytes |
| */ |
| public static byte[] convertToFourBytes(int numberToConvert) { |
| byte[] numInBytes = new byte[4]; |
| String s1 = Integer.toHexString(numberToConvert); |
| if (s1.length() % 2 != 0) { |
| s1 = "0" + s1; |
| } |
| byte[] hexas = DatatypeConverter.parseHexBinary(s1); |
| if (hexas.length == 1) { |
| numInBytes[0] = 0; |
| numInBytes[1] = 0; |
| numInBytes[2] = 0; |
| numInBytes[3] = hexas[0]; |
| } else if (hexas.length == 2) { |
| numInBytes[0] = 0; |
| numInBytes[1] = 0; |
| numInBytes[2] = hexas[0]; |
| numInBytes[3] = hexas[1]; |
| } else if (hexas.length == 3) { |
| numInBytes[0] = 0; |
| numInBytes[1] = hexas[0]; |
| numInBytes[2] = hexas[1]; |
| numInBytes[3] = hexas[2]; |
| } else { |
| numInBytes[0] = hexas[0]; |
| numInBytes[1] = hexas[1]; |
| numInBytes[2] = hexas[2]; |
| numInBytes[3] = hexas[3]; |
| } |
| return numInBytes; |
| } |
| |
| /** |
| * Returns the P2P hello PDU. |
| * |
| * @param isisInterface ISIS interface instance |
| * @param paddingEnabled padding enabled or not |
| * @return hello PDU |
| */ |
| public static byte[] getP2pHelloPdu(IsisInterface isisInterface, boolean paddingEnabled) { |
| IsisHeader isisHeader = new IsisHeader(); |
| isisHeader.setIrpDiscriminator((byte) IsisConstants.IRPDISCRIMINATOR); |
| isisHeader.setPduHeaderLength((byte) IsisConstants.P2PHELLOHEADERLENGTH); |
| isisHeader.setVersion((byte) IsisConstants.ISISVERSION); |
| isisHeader.setIdLength((byte) IsisConstants.IDLENGTH); |
| isisHeader.setIsisPduType(IsisPduType.P2PHELLOPDU.value()); |
| isisHeader.setVersion2((byte) IsisConstants.ISISVERSION); |
| //isisHeader.setReserved((byte) IsisConstants.RESERVED); |
| isisHeader.setReserved((byte) IsisConstants.PDULENGTHPOSITION); |
| isisHeader.setMaximumAreaAddresses((byte) IsisConstants.MAXAREAADDRESS); |
| P2PHelloPdu p2pHelloPdu = new P2PHelloPdu(isisHeader); |
| p2pHelloPdu.setCircuitType((byte) isisInterface.reservedPacketCircuitType()); |
| p2pHelloPdu.setSourceId(isisInterface.systemId()); |
| p2pHelloPdu.setHoldingTime(isisInterface.holdingTime()); |
| p2pHelloPdu.setPduLength(IsisConstants.PDU_LENGTH); |
| p2pHelloPdu.setLocalCircuitId((byte) IsisConstants.LOCALCIRCUITIDFORP2P); |
| |
| TlvHeader tlvHeader = new TlvHeader(); |
| tlvHeader.setTlvType(TlvType.AREAADDRESS.value()); |
| tlvHeader.setTlvLength(0); |
| AreaAddressTlv areaAddressTlv = new AreaAddressTlv(tlvHeader); |
| areaAddressTlv.addAddress(isisInterface.areaAddress()); |
| p2pHelloPdu.addTlv(areaAddressTlv); |
| |
| tlvHeader.setTlvType(TlvType.PROTOCOLSUPPORTED.value()); |
| tlvHeader.setTlvLength(0); |
| ProtocolSupportedTlv protocolSupportedTlv = new ProtocolSupportedTlv(tlvHeader); |
| protocolSupportedTlv.addProtocolSupported((byte) IsisConstants.PROTOCOLSUPPORTED); |
| p2pHelloPdu.addTlv(protocolSupportedTlv); |
| |
| tlvHeader.setTlvType(TlvType.ADJACENCYSTATE.value()); |
| tlvHeader.setTlvLength(0); |
| AdjacencyStateTlv adjacencyStateTlv = new AdjacencyStateTlv(tlvHeader); |
| adjacencyStateTlv.setAdjacencyType((byte) IsisInterfaceState.DOWN.value()); |
| adjacencyStateTlv.setLocalCircuitId(Integer.parseInt(isisInterface.circuitId())); |
| Set<MacAddress> neighbors = isisInterface.neighbors(); |
| if (neighbors.size() > 0) { |
| IsisNeighbor neighbor = isisInterface.lookup(neighbors.iterator().next()); |
| adjacencyStateTlv.setAdjacencyType((byte) neighbor.interfaceState().value()); |
| adjacencyStateTlv.setNeighborSystemId(neighbor.neighborSystemId()); |
| adjacencyStateTlv.setNeighborLocalCircuitId(neighbor.localExtendedCircuitId()); |
| } |
| p2pHelloPdu.addTlv(adjacencyStateTlv); |
| |
| tlvHeader.setTlvType(TlvType.IPINTERFACEADDRESS.value()); |
| tlvHeader.setTlvLength(0); |
| IpInterfaceAddressTlv ipInterfaceAddressTlv = new IpInterfaceAddressTlv(tlvHeader); |
| ipInterfaceAddressTlv.addInterfaceAddres(isisInterface.interfaceIpAddress()); |
| p2pHelloPdu.addTlv(ipInterfaceAddressTlv); |
| |
| byte[] beforePadding = p2pHelloPdu.asBytes(); |
| byte[] helloMessage; |
| if (paddingEnabled) { |
| byte[] paddingTlvs = getPaddingTlvs(beforePadding.length); |
| helloMessage = Bytes.concat(beforePadding, paddingTlvs); |
| } else { |
| helloMessage = beforePadding; |
| } |
| return helloMessage; |
| } |
| |
| /** |
| * Returns the L1 hello PDU. |
| * |
| * @param isisInterface ISIS interface instance |
| * @param paddingEnabled padding enabled or not |
| * @return helloMessage hello PDU |
| */ |
| public static byte[] getL1HelloPdu(IsisInterface isisInterface, boolean paddingEnabled) { |
| return getL1OrL2HelloPdu(isisInterface, IsisPduType.L1HELLOPDU, paddingEnabled); |
| } |
| |
| /** |
| * Returns the L2 hello PDU. |
| * |
| * @param isisInterface ISIS interface instance |
| * @param paddingEnabled padding enabled or not |
| * @return helloMessage hello PDU |
| */ |
| public static byte[] getL2HelloPdu(IsisInterface isisInterface, boolean paddingEnabled) { |
| return getL1OrL2HelloPdu(isisInterface, IsisPduType.L2HELLOPDU, paddingEnabled); |
| } |
| |
| /** |
| * Returns the hello PDU. |
| * |
| * @param isisInterface ISIS interface instance |
| * @param paddingEnabled padding enabled or not |
| * @return helloMessage hello PDU |
| */ |
| private static byte[] getL1OrL2HelloPdu(IsisInterface isisInterface, IsisPduType isisPduType, |
| boolean paddingEnabled) { |
| String lanId = ""; |
| IsisHeader isisHeader = new IsisHeader(); |
| isisHeader.setIrpDiscriminator((byte) IsisConstants.IRPDISCRIMINATOR); |
| isisHeader.setPduHeaderLength((byte) IsisConstants.HELLOHEADERLENGTH); |
| isisHeader.setVersion((byte) IsisConstants.ISISVERSION); |
| isisHeader.setIdLength((byte) IsisConstants.IDLENGTH); |
| if (isisPduType == IsisPduType.L1HELLOPDU) { |
| isisHeader.setIsisPduType(IsisPduType.L1HELLOPDU.value()); |
| lanId = isisInterface.l1LanId(); |
| } else if (isisPduType == IsisPduType.L2HELLOPDU) { |
| isisHeader.setIsisPduType(IsisPduType.L2HELLOPDU.value()); |
| lanId = isisInterface.l2LanId(); |
| } |
| isisHeader.setVersion2((byte) IsisConstants.ISISVERSION); |
| isisHeader.setReserved((byte) IsisConstants.PDULENGTHPOSITION); |
| isisHeader.setMaximumAreaAddresses((byte) IsisConstants.MAXAREAADDRESS); |
| L1L2HelloPdu l1L2HelloPdu = new L1L2HelloPdu(isisHeader); |
| l1L2HelloPdu.setCircuitType((byte) isisInterface.reservedPacketCircuitType()); |
| l1L2HelloPdu.setSourceId(isisInterface.systemId()); |
| l1L2HelloPdu.setHoldingTime(isisInterface.holdingTime()); |
| l1L2HelloPdu.setPduLength(IsisConstants.PDU_LENGTH); |
| l1L2HelloPdu.setPriority((byte) isisInterface.priority()); |
| l1L2HelloPdu.setLanId(lanId); |
| TlvHeader tlvHeader = new TlvHeader(); |
| tlvHeader.setTlvType(TlvType.AREAADDRESS.value()); |
| tlvHeader.setTlvLength(0); |
| AreaAddressTlv areaAddressTlv = new AreaAddressTlv(tlvHeader); |
| areaAddressTlv.addAddress(isisInterface.areaAddress()); |
| l1L2HelloPdu.addTlv(areaAddressTlv); |
| Set<MacAddress> neighbors = isisInterface.neighbors(); |
| if (neighbors.size() > 0) { |
| tlvHeader.setTlvType(TlvType.ISNEIGHBORS.value()); |
| tlvHeader.setTlvLength(0); |
| IsisNeighborTlv isisNeighborTlv = new IsisNeighborTlv(tlvHeader); |
| for (MacAddress neighbor : neighbors) { |
| isisNeighborTlv.addNeighbor(neighbor); |
| } |
| l1L2HelloPdu.addTlv(isisNeighborTlv); |
| } |
| tlvHeader.setTlvType(TlvType.PROTOCOLSUPPORTED.value()); |
| tlvHeader.setTlvLength(0); |
| ProtocolSupportedTlv protocolSupportedTlv = new ProtocolSupportedTlv(tlvHeader); |
| protocolSupportedTlv.addProtocolSupported((byte) IsisConstants.PROTOCOLSUPPORTED); |
| l1L2HelloPdu.addTlv(protocolSupportedTlv); |
| |
| tlvHeader.setTlvType(TlvType.IPINTERFACEADDRESS.value()); |
| tlvHeader.setTlvLength(0); |
| IpInterfaceAddressTlv ipInterfaceAddressTlv = new IpInterfaceAddressTlv(tlvHeader); |
| ipInterfaceAddressTlv.addInterfaceAddres(isisInterface.interfaceIpAddress()); |
| l1L2HelloPdu.addTlv(ipInterfaceAddressTlv); |
| |
| byte[] beforePadding = l1L2HelloPdu.asBytes(); |
| byte[] helloMessage; |
| if (paddingEnabled) { |
| byte[] paddingTlvs = getPaddingTlvs(beforePadding.length); |
| helloMessage = Bytes.concat(beforePadding, paddingTlvs); |
| } else { |
| helloMessage = beforePadding; |
| } |
| return helloMessage; |
| } |
| |
| /** |
| * Converts a byte to integer variable. |
| * |
| * @param bytesToConvert bytes to convert |
| * @return integer representation of bytes |
| */ |
| public static int byteToInteger(byte[] bytesToConvert) { |
| final StringBuilder builder = new StringBuilder(); |
| for (byte eachByte : bytesToConvert) { |
| builder.append(String.format("%02x", eachByte)); |
| } |
| int number = Integer.parseInt(builder.toString(), 16); |
| return number; |
| } |
| |
| /** |
| * Converts a byte to long variable. |
| * |
| * @param bytesToConvert bytes to convert |
| * @return long representation of bytes |
| */ |
| public static long byteToLong(byte[] bytesToConvert) { |
| final StringBuilder builder = new StringBuilder(); |
| for (byte eachByte : bytesToConvert) { |
| builder.append(String.format("%02x", eachByte)); |
| } |
| long number = Long.parseLong(builder.toString(), 16); |
| return number; |
| } |
| |
| /** |
| * Converts a number to four bytes. |
| * |
| * @param numberToConvert number to convert |
| * @return numInBytes given number as bytes |
| */ |
| public static byte[] convertToFourBytes(long numberToConvert) { |
| byte[] numInBytes = new byte[4]; |
| String s1 = Long.toHexString(numberToConvert); |
| if (s1.length() % 2 != 0) { |
| s1 = "0" + s1; |
| } |
| if (s1.length() == 16) { |
| s1 = s1.substring(8, s1.length()); |
| } |
| byte[] hexas = DatatypeConverter.parseHexBinary(s1); |
| if (hexas.length == 1) { |
| numInBytes[0] = 0; |
| numInBytes[1] = 0; |
| numInBytes[2] = 0; |
| numInBytes[3] = hexas[0]; |
| } else if (hexas.length == 2) { |
| numInBytes[0] = 0; |
| numInBytes[1] = 0; |
| numInBytes[2] = hexas[0]; |
| numInBytes[3] = hexas[1]; |
| } else if (hexas.length == 3) { |
| numInBytes[0] = 0; |
| numInBytes[1] = hexas[0]; |
| numInBytes[2] = hexas[1]; |
| numInBytes[3] = hexas[2]; |
| } else { |
| numInBytes[0] = hexas[0]; |
| numInBytes[1] = hexas[1]; |
| numInBytes[2] = hexas[2]; |
| numInBytes[3] = hexas[3]; |
| } |
| return numInBytes; |
| } |
| |
| /** |
| * Converts a number to eight bit binary. |
| * |
| * @param binaryString string to binary |
| * @return numInBytes given number as bytes |
| */ |
| public static String toEightBitBinary(String binaryString) { |
| String eightBit = binaryString; |
| if (eightBit.length() % 8 != 0) { |
| int numOfZero = 8 - eightBit.length(); |
| while (numOfZero > 0) { |
| eightBit = "0" + eightBit; |
| numOfZero--; |
| } |
| } |
| return eightBit; |
| } |
| |
| /** |
| * Converts a number to four bit binary. |
| * |
| * @param binaryString string to binary |
| * @return numInBytes given number as bytes |
| */ |
| public static String toFourBitBinary(String binaryString) { |
| String fourBit = binaryString; |
| if (fourBit.length() % 4 != 0) { |
| int numOfZero = 4 - fourBit.length(); |
| while (numOfZero > 0) { |
| fourBit = "0" + fourBit; |
| numOfZero--; |
| } |
| } |
| return fourBit; |
| } |
| |
| /** |
| * Converts a number to three bytes. |
| * |
| * @param numberToConvert number to convert |
| * @return given number as bytes |
| */ |
| public static byte[] convertToThreeBytes(int numberToConvert) { |
| byte[] numInBytes = new byte[4]; |
| String s1 = Integer.toHexString(numberToConvert); |
| if (s1.length() % 2 != 0) { |
| s1 = "0" + s1; |
| } |
| byte[] hexas = DatatypeConverter.parseHexBinary(s1); |
| if (hexas.length == 1) { |
| numInBytes[0] = 0; |
| numInBytes[1] = 0; |
| numInBytes[2] = hexas[0]; |
| } else if (hexas.length == 2) { |
| numInBytes[0] = 0; |
| numInBytes[1] = hexas[0]; |
| numInBytes[2] = hexas[1]; |
| } else { |
| numInBytes[0] = hexas[0]; |
| numInBytes[1] = hexas[1]; |
| numInBytes[2] = hexas[2]; |
| } |
| return numInBytes; |
| } |
| |
| /** |
| * Converts the bytes of prefix to string type value. |
| * |
| * @param bytes array of prefix |
| * @return string value of prefix |
| */ |
| public static String prefixConversion(byte[] bytes) { |
| String prefix = ""; |
| for (int i = 0; i < bytes.length; i++) { |
| if (i < (bytes.length - 1)) { |
| prefix = prefix + bytes[i] + "."; |
| } else { |
| prefix = prefix + bytes[i]; |
| } |
| } |
| return prefix; |
| } |
| } |