2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.protocol.bgp.parser.impl.message.open;
10 import java.util.Arrays;
11 import java.util.Map.Entry;
13 import org.opendaylight.protocol.bgp.parser.BGPParsingException;
14 import org.opendaylight.protocol.bgp.parser.BGPTableType;
15 import org.opendaylight.protocol.bgp.parser.impl.ParserUtil;
16 import org.opendaylight.protocol.bgp.parser.parameter.AS4BytesCapability;
17 import org.opendaylight.protocol.bgp.parser.parameter.CapabilityParameter;
18 import org.opendaylight.protocol.bgp.parser.parameter.GracefulCapability;
19 import org.opendaylight.protocol.bgp.parser.parameter.MultiprotocolCapability;
20 import org.opendaylight.protocol.util.ByteArray;
21 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber;
22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.AddressFamily;
23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.SubsequentAddressFamily;
24 import org.slf4j.Logger;
25 import org.slf4j.LoggerFactory;
27 import com.google.common.primitives.UnsignedBytes;
30 * Parser for BGP Capability Parameter.
32 public final class CapabilityParameterParser {
34 private static final Logger logger = LoggerFactory.getLogger(CapabilityParameterParser.class);
36 private static final int CODE_SIZE = 1; // bytes
37 private static final int LENGTH_SIZE = 1; // bytes
38 private static final int AFI_SIZE = 2; // bytes
39 private static final int SAFI_SIZE = 1; // bytes
41 private CapabilityParameterParser() {
46 * Serializes given BGP Capability Parameter to byte array.
48 * @param param BGP Capability to be serialized
49 * @return BGP Capability converted to byte array
51 public static byte[] put(final CapabilityParameter cap) {
53 throw new IllegalArgumentException("BGP Capability cannot be null");
55 logger.trace("Started serializing BGP Capability: {}", cap);
57 if (cap instanceof MultiprotocolCapability) {
58 value = putMultiProtocolParameterValue((MultiprotocolCapability) cap);
59 } else if (cap instanceof GracefulCapability) {
60 value = putGracefulParameterValue((GracefulCapability) cap);
61 } else if (cap instanceof AS4BytesCapability) {
62 value = putAS4BytesParameterValue((AS4BytesCapability) cap);
64 final byte[] bytes = new byte[CODE_SIZE + LENGTH_SIZE + value.length];
65 bytes[0] = ByteArray.intToBytes(cap.getCode())[Integer.SIZE / Byte.SIZE - 1];
66 bytes[1] = ByteArray.intToBytes(value.length)[Integer.SIZE / Byte.SIZE - 1];
67 System.arraycopy(value, 0, bytes, CODE_SIZE + LENGTH_SIZE, value.length);
68 logger.trace("BGP Parameter serialized to: {}", Arrays.toString(bytes));
73 * Parses given byte array to Capability Parameter. Only Multiprotocol capability is supported.
75 * @param bytes byte array representing BGP Parameters
76 * @return list of BGP Parameters
77 * @throws BGPParsingException if the parsing was unsuccessful
79 public static CapabilityParameter parse(final byte[] bytes) throws BGPParsingException {
80 if (bytes == null || bytes.length == 0) {
81 throw new IllegalArgumentException("Byte array cannot be null or empty.");
83 logger.trace("Started parsing of BGP Capability: {}", Arrays.toString(bytes));
85 final int capCode = UnsignedBytes.toInt(bytes[byteOffset++]);
86 final int capLength = UnsignedBytes.toInt(bytes[byteOffset++]);
87 if (capCode == MultiprotocolCapability.CODE) {
88 logger.trace("Parsed BGP Capability.");
89 return parseMultiProtocolParameterValue(ByteArray.subByte(bytes, byteOffset, capLength));
90 } else if (capCode == AS4BytesCapability.CODE) {
91 logger.trace("Parsed AS4B Capability.");
92 return parseAS4BParameterValue(ByteArray.subByte(bytes, byteOffset, capLength));
94 logger.debug("Only Multiprotocol Capability Parameter is supported. Received code {}", capCode);
99 private static byte[] putGracefulParameterValue(final GracefulCapability param) {
100 final int RESTART_FLAGS_SIZE = 4; // bits
101 final int TIMER_SIZE = 12; // bits
102 final int AFI_SIZE = 2; // bytes
103 final int SAFI_SIZE = 1; // bytes
104 final int AF_FLAGS_SIZE = 1; // bytes
105 final byte[] bytes = new byte[(RESTART_FLAGS_SIZE + TIMER_SIZE + (AFI_SIZE * Byte.SIZE + SAFI_SIZE * Byte.SIZE + AF_FLAGS_SIZE
107 * param.getTableTypes().size())
109 if (param.isRestartFlag()) {
110 bytes[0] = (byte) 0x80;
112 int index = (RESTART_FLAGS_SIZE + TIMER_SIZE) / Byte.SIZE;
113 for (final Entry<BGPTableType, Boolean> entry : param.getTableTypes().entrySet()) {
114 final byte[] a = putAfi(entry.getKey().getAddressFamily());
115 final byte s = putSafi(entry.getKey().getSubsequentAddressFamily());
116 final byte f = (entry.getValue()) ? (byte) 0x80 : (byte) 0x00;
117 System.arraycopy(a, 0, bytes, index, AFI_SIZE);
122 index += AF_FLAGS_SIZE;
127 private static byte[] putMultiProtocolParameterValue(final MultiprotocolCapability param) {
128 final byte[] a = putAfi(param.getAfi());
129 final byte s = putSafi(param.getSafi());
131 final byte[] bytes = new byte[AFI_SIZE + SAFI_SIZE + 1]; // 2 byte is reserved 2B AFI + 1B Reserved + 1B SAFI
132 System.arraycopy(a, 0, bytes, 0, AFI_SIZE);
133 bytes[AFI_SIZE + 1] = s; // +1 = reserved
137 private static byte[] putAS4BytesParameterValue(final AS4BytesCapability param) {
138 return ByteArray.subByte(ByteArray.longToBytes(param.getASNumber().getValue()), 4, 4);
141 private static MultiprotocolCapability parseMultiProtocolParameterValue(final byte[] bytes) throws BGPParsingException {
142 final Class<? extends AddressFamily> afi = ParserUtil.afiForValue(ByteArray.bytesToInt(ByteArray.subByte(bytes, 0, AFI_SIZE)));
144 throw new BGPParsingException("Address Family Identifier: '" + ByteArray.bytesToInt(ByteArray.subByte(bytes, 0, AFI_SIZE))
145 + "' not supported.");
147 final Class<? extends SubsequentAddressFamily> safi = ParserUtil.safiForValue(ByteArray.bytesToInt(ByteArray.subByte(bytes,
148 AFI_SIZE + 1, SAFI_SIZE)));
150 throw new BGPParsingException("Subsequent Address Family Identifier: '"
151 + ByteArray.bytesToInt(ByteArray.subByte(bytes, AFI_SIZE + 1, SAFI_SIZE)) + "' not supported.");
153 return new MultiprotocolCapability(new BGPTableType(afi, safi));
156 private static AS4BytesCapability parseAS4BParameterValue(final byte[] bytes) {
157 return new AS4BytesCapability(new AsNumber(ByteArray.bytesToLong(bytes)));
160 private static byte[] putAfi(final Class<? extends AddressFamily> afi) {
161 final byte[] a = ByteArray.intToBytes(ParserUtil.valueForAfi(afi));
162 return ByteArray.subByte(a, Integer.SIZE / Byte.SIZE - AFI_SIZE, AFI_SIZE);
165 private static byte putSafi(final Class<? extends SubsequentAddressFamily> safi) {
166 final byte[] a = ByteArray.intToBytes(ParserUtil.valueForSafi(safi));
167 return ByteArray.subByte(a, Integer.SIZE / Byte.SIZE - SAFI_SIZE, SAFI_SIZE)[0];