BGP Controller test
Change-Id: I4bdafeec877d5fbfa79306717cf3033936e0fe59
diff --git a/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPKeepaliveMsgVer4.java b/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPKeepaliveMsgVer4.java
index 10e6bb9..0cf4ae5 100644
--- a/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPKeepaliveMsgVer4.java
+++ b/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPKeepaliveMsgVer4.java
@@ -31,7 +31,7 @@
/**
* Provides BGP keep alive message.
*/
-class BGPKeepaliveMsgVer4 implements BGPKeepaliveMsg {
+public class BGPKeepaliveMsgVer4 implements BGPKeepaliveMsg {
/*
<Keepalive Message>::= <Common Header>
@@ -88,7 +88,7 @@
/**
* Default constructor.
*/
- BGPKeepaliveMsgVer4() {
+ public BGPKeepaliveMsgVer4() {
}
/**
diff --git a/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/BGPControllerImpl.java b/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/BGPControllerImpl.java
index 35c31ab..042e2da 100755
--- a/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/BGPControllerImpl.java
+++ b/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/BGPControllerImpl.java
@@ -204,6 +204,15 @@
}
+ /**
+ * Returns controller.
+ *
+ * @return controller
+ */
+ public Controller controller() {
+ return this.ctrl;
+ }
+
@Override
public ConcurrentHashMap<BGPId, BGPPeer> connectedPeers() {
return connectedPeers;
diff --git a/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/Controller.java b/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/Controller.java
index 017c39e..95eebb4 100755
--- a/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/Controller.java
+++ b/bgp/ctl/src/main/java/org/onosproject/bgp/controller/impl/Controller.java
@@ -26,6 +26,7 @@
import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.bootstrap.ServerBootstrap;
+import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.group.ChannelGroup;
import org.jboss.netty.channel.group.DefaultChannelGroup;
@@ -49,9 +50,12 @@
private static final BGPFactory FACTORY4 = BGPFactories.getFactory(BGPVersion.BGP_4);
private ChannelGroup cg;
+ public Channel serverChannel;
// Configuration options
private static final short BGP_PORT_NUM = 179;
+ private static final short PORT_NUM_ZERO = 0;
+ private static boolean isPortNumSet = false;
private final int workerThreads = 16;
private final int peerWorkerThreads = 16;
@@ -119,7 +123,8 @@
bootstrap.setPipelineFactory(pfact);
InetSocketAddress sa = new InetSocketAddress(getBgpPortNum());
cg = new DefaultChannelGroup();
- cg.add(bootstrap.bind(sa));
+ serverChannel = bootstrap.bind(sa);
+ cg.add(serverChannel);
log.info("Listening for Peer connection on {}", sa);
} catch (Exception e) {
throw new RuntimeException(e);
@@ -234,6 +239,16 @@
* @return port number
*/
public static short getBgpPortNum() {
+ if (isPortNumSet) {
+ return PORT_NUM_ZERO;
+ }
return BGP_PORT_NUM;
}
+
+ /**
+ * sets the isPortNumSet as true.
+ */
+ public void setBgpPortNum() {
+ isPortNumSet = true;
+ }
}
\ No newline at end of file
diff --git a/bgp/ctl/src/test/java/org/onosproject/bgp/BGPControllerImplTest.java b/bgp/ctl/src/test/java/org/onosproject/bgp/BGPControllerImplTest.java
new file mode 100755
index 0000000..83583bb
--- /dev/null
+++ b/bgp/ctl/src/test/java/org/onosproject/bgp/BGPControllerImplTest.java
@@ -0,0 +1,300 @@
+/*
+ * Copyright 2014-2015 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.bgp;
+
+import com.google.common.net.InetAddresses;
+import org.jboss.netty.bootstrap.ClientBootstrap;
+import org.jboss.netty.channel.Channel;
+import org.jboss.netty.channel.ChannelFactory;
+import org.jboss.netty.channel.ChannelPipeline;
+import org.jboss.netty.channel.ChannelPipelineFactory;
+import org.jboss.netty.channel.Channels;
+import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.hamcrest.core.Is.is;
+import static org.junit.Assert.assertThat;
+
+import org.onlab.junit.TestUtils;
+
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.LinkedList;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.onosproject.bgp.controller.BGPCfg;
+import org.onosproject.bgp.controller.impl.BGPControllerImpl;
+import org.onosproject.bgpio.types.BGPValueType;
+import org.onosproject.bgpio.types.FourOctetAsNumCapabilityTlv;
+import org.onosproject.bgpio.types.MultiProtocolExtnCapabilityTlv;
+
+/**
+ * Test case for BGPControllerImpl.
+ */
+public class BGPControllerImplTest {
+
+ protected static final Logger log = LoggerFactory
+ .getLogger(BGPControllerImplTest.class);
+
+ private static final String IP_LOOPBACK_ID1 = "127.0.0.1";
+
+ private static final int MESSAGE_TIMEOUT_MS = 3000;
+ public byte version;
+ public short asNumber;
+ public short holdTime;
+ public int bgpId = InetAddresses.coerceToInteger(InetAddresses.forString(IP_LOOPBACK_ID1));
+ public boolean isLargeAsCapabilitySet = false;
+ public LinkedList<BGPValueType> capabilityTlv = new LinkedList<>();
+
+ @Before
+ public void setUp() throws Exception {
+ peer1 = new BgpPeerTest(version, asNumber,
+ holdTime, bgpId, isLargeAsCapabilitySet,
+ capabilityTlv);
+
+ bgpControllerImpl = new BGPControllerImpl();
+
+ // NOTE: We use port 0 to bind on any available port
+ bgpControllerImpl.controller().setBgpPortNum();
+ bgpControllerImpl.activate();
+
+ Channel serverChannel = TestUtils.getField(bgpControllerImpl.controller(),
+ "serverChannel");
+ SocketAddress socketAddress = serverChannel.getLocalAddress();
+ InetSocketAddress inetSocketAddress =
+ (InetSocketAddress) socketAddress;
+ InetAddress connectToAddress = InetAddresses.forString("127.0.0.1");
+ connectToSocket = new InetSocketAddress(connectToAddress,
+ inetSocketAddress.getPort());
+
+ bgpControllerImpl.getConfig().setRouterId("1.1.1.1");
+ bgpControllerImpl.getConfig().setAsNumber(200);
+ bgpControllerImpl.getConfig().setHoldTime((short) 120);
+ bgpControllerImpl.getConfig().setState(BGPCfg.State.IP_AS_CONFIGURED);
+
+ bgpControllerImpl.getConfig().addPeer("127.0.0.1", 200);
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ bgpControllerImpl.deactivate();
+ bgpControllerImpl = null;
+ }
+
+ private BGPControllerImpl bgpControllerImpl;
+
+ BgpPeerTest peer1;
+
+ // The socket that the remote peers should connect to
+ private InetSocketAddress connectToSocket;
+
+ @Test
+ public void bgpOpenMessageTest1() throws InterruptedException {
+ peer1.peerChannelHandler.asNumber = 200;
+ peer1.peerChannelHandler.version = 4;
+ peer1.peerChannelHandler.holdTime = 120;
+ peer1.connect(connectToSocket);
+ boolean result;
+ result = peer1.peerFrameDecoder.receivedOpenMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ result = peer1.peerFrameDecoder.receivedKeepaliveMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ }
+
+ @Test
+ public void bgpOpenMessageTest2() throws InterruptedException {
+ // Open message with as number which is not configured at peer
+ peer1.peerChannelHandler.asNumber = 500;
+ peer1.peerChannelHandler.version = 4;
+ peer1.peerChannelHandler.holdTime = 120;
+ peer1.connect(connectToSocket);
+
+ boolean result;
+ result = peer1.peerFrameDecoder.receivedNotificationMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ }
+
+ @Test
+ public void bgpOpenMessageTest3() throws InterruptedException {
+ // Open message with invalid hold time value
+ peer1.peerChannelHandler.asNumber = 200;
+ peer1.peerChannelHandler.version = 4;
+ peer1.peerChannelHandler.holdTime = 1;
+ peer1.connect(connectToSocket);
+
+ boolean result;
+ result = peer1.peerFrameDecoder.receivedNotificationMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ }
+
+ @Test
+ public void bgpOpenMessageTest4() throws InterruptedException {
+ // Open message with invalid as number
+ peer1.peerChannelHandler.asNumber = 200;
+ peer1.peerChannelHandler.version = 4;
+ peer1.peerChannelHandler.holdTime = 120;
+ peer1.peerChannelHandler.isLargeAsCapabilitySet = true;
+ BGPValueType tempTlv = new FourOctetAsNumCapabilityTlv(766545);
+ peer1.peerChannelHandler.capabilityTlv.add(tempTlv);
+ peer1.connect(connectToSocket);
+
+ boolean result;
+ result = peer1.peerFrameDecoder.receivedNotificationMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ }
+
+ @Test
+ public void bgpOpenMessageTest5() throws InterruptedException {
+ // Open message with LS capability
+ short afi = 16388;
+ byte res = 0;
+ byte safi = 71;
+ peer1.peerChannelHandler.asNumber = 200;
+ peer1.peerChannelHandler.version = 4;
+ peer1.peerChannelHandler.holdTime = 120;
+ bgpControllerImpl.getConfig().setLsCapability(true);
+ BGPValueType tempTlv1 = new MultiProtocolExtnCapabilityTlv(afi, res, safi);
+ peer1.peerChannelHandler.capabilityTlv.add(tempTlv1);
+ peer1.connect(connectToSocket);
+
+ boolean result;
+ result = peer1.peerFrameDecoder.receivedOpenMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ result = peer1.peerFrameDecoder.receivedKeepaliveMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ }
+
+ @Test
+ public void bgpOpenMessageTest6() throws InterruptedException {
+ // Open message with as4 capability
+ peer1.peerChannelHandler.asNumber = 200;
+ peer1.peerChannelHandler.version = 4;
+ peer1.peerChannelHandler.holdTime = 120;
+ peer1.peerChannelHandler.isLargeAsCapabilitySet = true;
+ bgpControllerImpl.getConfig().setLargeASCapability(true);
+ BGPValueType tempTlv = new FourOctetAsNumCapabilityTlv(200);
+ peer1.peerChannelHandler.capabilityTlv.add(tempTlv);
+ peer1.connect(connectToSocket);
+
+ boolean result;
+ result = peer1.peerFrameDecoder.receivedOpenMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ result = peer1.peerFrameDecoder.receivedKeepaliveMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+
+ result = peer1.peerFrameDecoder.receivedKeepaliveMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ }
+
+ @Test
+ public void bgpOpenMessageTest7() throws InterruptedException {
+ // Open message with both LS capability and as4 capability
+ short afi = 16388;
+ byte res = 0;
+ byte safi = 71;
+ peer1.peerChannelHandler.asNumber = 200;
+ peer1.peerChannelHandler.version = 4;
+ peer1.peerChannelHandler.holdTime = 120;
+
+ peer1.peerChannelHandler.isLargeAsCapabilitySet = true;
+ bgpControllerImpl.getConfig().setLargeASCapability(true);
+ BGPValueType tempTlv = new FourOctetAsNumCapabilityTlv(200);
+ peer1.peerChannelHandler.capabilityTlv.add(tempTlv);
+
+ bgpControllerImpl.getConfig().setLsCapability(true);
+ BGPValueType tempTlv1 = new MultiProtocolExtnCapabilityTlv(afi, res, safi);
+ peer1.peerChannelHandler.capabilityTlv.add(tempTlv1);
+ peer1.connect(connectToSocket);
+
+ boolean result;
+ result = peer1.peerFrameDecoder.receivedOpenMessageLatch.await(
+ MESSAGE_TIMEOUT_MS,
+ TimeUnit.MILLISECONDS);
+ assertThat(result, is(true));
+ }
+
+ /**
+ * A class to capture the state for a BGP peer.
+ */
+ private final class BgpPeerTest {
+ private ClientBootstrap peerBootstrap;
+ private BgpPeerFrameDecoderTest peerFrameDecoder =
+ new BgpPeerFrameDecoderTest();
+ private BgpPeerChannelHandlerTest peerChannelHandler;
+
+ private BgpPeerTest(byte version, short asNumber,
+ short holdTime, int bgpId, boolean isLargeAsCapabilitySet,
+ LinkedList<BGPValueType> capabilityTlv) {
+ peerChannelHandler = new BgpPeerChannelHandlerTest(version,
+ asNumber, holdTime, bgpId, isLargeAsCapabilitySet, capabilityTlv);
+ }
+
+ /**
+ * Starts the BGP peer.
+ *
+ * @param connectToSocket the socket to connect to
+ */
+ private void connect(InetSocketAddress connectToSocket)
+ throws InterruptedException {
+
+ ChannelFactory channelFactory =
+ new NioClientSocketChannelFactory(
+ Executors.newCachedThreadPool(),
+ Executors.newCachedThreadPool());
+ ChannelPipelineFactory pipelineFactory = () -> {
+ ChannelPipeline pipeline = Channels.pipeline();
+ pipeline.addLast("BgpPeerFrameDecoderTest",
+ peerFrameDecoder);
+ pipeline.addLast("BgpPeerChannelHandlerTest",
+ peerChannelHandler);
+ return pipeline;
+ };
+
+ peerBootstrap = new ClientBootstrap(channelFactory);
+ peerBootstrap.setOption("child.keepAlive", true);
+ peerBootstrap.setOption("child.tcpNoDelay", true);
+ peerBootstrap.setPipelineFactory(pipelineFactory);
+ peerBootstrap.connect(connectToSocket);
+ }
+ }
+}
\ No newline at end of file
diff --git a/bgp/ctl/src/test/java/org/onosproject/bgp/BgpPeerChannelHandlerTest.java b/bgp/ctl/src/test/java/org/onosproject/bgp/BgpPeerChannelHandlerTest.java
new file mode 100755
index 0000000..6f1828f
--- /dev/null
+++ b/bgp/ctl/src/test/java/org/onosproject/bgp/BgpPeerChannelHandlerTest.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2014-2015 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.bgp;
+
+import java.util.LinkedList;
+import java.util.concurrent.TimeUnit;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.jboss.netty.buffer.ChannelBuffers;
+import org.jboss.netty.channel.ChannelHandlerContext;
+import org.jboss.netty.channel.ChannelStateEvent;
+import org.jboss.netty.channel.SimpleChannelHandler;
+import org.onosproject.bgpio.protocol.ver4.BGPKeepaliveMsgVer4;
+import org.onosproject.bgpio.protocol.ver4.BGPOpenMsgVer4;
+import org.onosproject.bgpio.types.BGPHeader;
+import org.onosproject.bgpio.types.BGPValueType;
+
+public class BgpPeerChannelHandlerTest extends SimpleChannelHandler {
+ public static final int OPEN_MSG_MINIMUM_LENGTH = 29;
+ public static final byte[] MARKER = new byte[] {(byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+ (byte) 0xff, (byte) 0xff};
+ public static final BGPHeader DEFAULT_OPEN_HEADER = new BGPHeader(MARKER,
+ (short) OPEN_MSG_MINIMUM_LENGTH, (byte) 0X01);
+ LinkedList<BGPValueType> capabilityTlv = new LinkedList<>();
+ public byte version;
+ public short asNumber;
+ public short holdTime;
+ public int bgpId;
+ public boolean isLargeAsCapabilitySet;
+
+ final BGPOpenMsgVer4 openMessage = new BGPOpenMsgVer4();
+ ChannelHandlerContext savedCtx;
+
+ /**
+ * Constructor to initialize all variables of BGP Open message.
+ *
+ * @param version BGP version in open message
+ * @param asNumber AS number in open message
+ * @param holdTime hold time in open message
+ * @param bgpId BGP identifier in open message
+ * @param capabilityTlv capabilities in open message
+ */
+ public BgpPeerChannelHandlerTest(byte version,
+ short asNumber,
+ short holdTime,
+ int bgpId,
+ boolean isLargeAsCapabilitySet,
+ LinkedList<BGPValueType> capabilityTlv) {
+ this.version = version;
+ this.asNumber = asNumber;
+ this.holdTime = holdTime;
+ this.bgpId = bgpId;
+ this.isLargeAsCapabilitySet = isLargeAsCapabilitySet;
+ this.capabilityTlv = capabilityTlv;
+ }
+
+ /**
+ * closes the channel.
+ */
+ void closeChannel() {
+ savedCtx.getChannel().close();
+ }
+
+ @Override
+ public void channelConnected(ChannelHandlerContext ctx,
+ ChannelStateEvent channelEvent) throws InterruptedException {
+ this.savedCtx = ctx;
+
+ BGPOpenMsgVer4 openMsg = new BGPOpenMsgVer4(DEFAULT_OPEN_HEADER,
+ this.version,
+ this.asNumber,
+ this.holdTime,
+ this.bgpId,
+ this.capabilityTlv);
+ ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
+ openMsg.writeTo(buffer);
+ ctx.getChannel().write(buffer);
+
+ TimeUnit.MILLISECONDS.sleep(100);
+
+ BGPKeepaliveMsgVer4 keepaliveMsg = new BGPKeepaliveMsgVer4();
+ ChannelBuffer buffer1 = ChannelBuffers.dynamicBuffer();
+ keepaliveMsg.writeTo(buffer1);
+ ctx.getChannel().write(buffer1);
+ }
+
+ @Override
+ public void channelDisconnected(ChannelHandlerContext ctx,
+ ChannelStateEvent channelEvent) {
+ //Do Nothing
+ }
+}
diff --git a/bgp/ctl/src/test/java/org/onosproject/bgp/BgpPeerFrameDecoderTest.java b/bgp/ctl/src/test/java/org/onosproject/bgp/BgpPeerFrameDecoderTest.java
new file mode 100755
index 0000000..7767053
--- /dev/null
+++ b/bgp/ctl/src/test/java/org/onosproject/bgp/BgpPeerFrameDecoderTest.java
@@ -0,0 +1,168 @@
+/*
+ * Copyright 2014-2015 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.bgp;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.jboss.netty.channel.Channel;
+import org.jboss.netty.channel.ChannelHandlerContext;
+import org.jboss.netty.handler.codec.frame.FrameDecoder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * Class to decode the message received.
+ */
+public class BgpPeerFrameDecoderTest extends FrameDecoder {
+ static final byte OPEN_MSG_TYPE = 0x1;
+ static final byte KEEPALIVE_MSG_TYPE = 0x4;
+ static final byte UPDATE_MSG_TYPE = 0x2;
+ static final byte NOTIFICATION_MSG_TYPE = 0x3;
+ static final int MINIMUM_COMMON_HEADER_LENGTH = 19;
+ static final int MINIMUM_OPEN_MSG_LENGTH = 29;
+ static final int MINIMUM_HEADER_MARKER_LENGTH = 16;
+ static final int HEADER_AND_MSG_LEN = 18;
+
+ protected static final Logger log = LoggerFactory
+ .getLogger(BgpPeerFrameDecoderTest.class);
+ final CountDownLatch receivedOpenMessageLatch = new CountDownLatch(1);
+ final CountDownLatch receivedKeepaliveMessageLatch = new CountDownLatch(1);
+ final CountDownLatch receivedNotificationMessageLatch = new CountDownLatch(1);
+
+ @Override
+ protected Object decode(ChannelHandlerContext ctx,
+ Channel channel,
+ ChannelBuffer cb) throws Exception {
+
+ if (cb.readableBytes() < MINIMUM_COMMON_HEADER_LENGTH) {
+ log.debug("Error: Packet length is less then minimum length");
+ return null;
+ }
+
+ byte[] marker = new byte[MINIMUM_HEADER_MARKER_LENGTH];
+ cb.readBytes(marker);
+ for (int i = 0; i < marker.length; i++) {
+ if (marker[i] != (byte) 0xff) {
+ log.debug("Error: Marker must be set all ones");
+ ctx.getChannel().close();
+ return null;
+ }
+ }
+
+ short length = cb.readShort();
+ if (length < MINIMUM_COMMON_HEADER_LENGTH) {
+ log.debug("Error: Bad message length");
+ ctx.getChannel().close();
+ return null;
+ }
+
+ if (length != (cb.readableBytes() + HEADER_AND_MSG_LEN)) {
+ log.debug("Error: Bad message length");
+ ctx.getChannel().close();
+ return null;
+ }
+
+ byte type = cb.readByte();
+ int len = length - MINIMUM_COMMON_HEADER_LENGTH;
+
+ ChannelBuffer message = cb.readBytes(len);
+
+ switch (type) {
+ case OPEN_MSG_TYPE:
+ processBgpOpen(ctx, message);
+ break;
+ case UPDATE_MSG_TYPE:
+ break;
+ case NOTIFICATION_MSG_TYPE:
+ processBgpNotification(ctx, message);
+ break;
+ case KEEPALIVE_MSG_TYPE:
+ processBgpKeepalive(ctx, message);
+ break;
+ default:
+ ctx.getChannel().close();
+ return null;
+ }
+
+ return null;
+ }
+
+ /**
+ * Processes BGP open message.
+ *
+ * @param ctx Channel handler context
+ * @param message open message
+ */
+ private void processBgpOpen(ChannelHandlerContext ctx,
+ ChannelBuffer message) {
+ int minLength =
+ MINIMUM_OPEN_MSG_LENGTH - MINIMUM_COMMON_HEADER_LENGTH;
+ if (message.readableBytes() < minLength) {
+ log.debug("Error: Bad message length");
+ ctx.getChannel().close();
+ return;
+ }
+
+ message.readByte(); // read version
+ message.readShort(); // read AS number
+ message.readShort(); // read Hold timer
+ message.readInt(); // read BGP Identifier
+ // Optional Parameters
+ int optParamLen = message.readUnsignedByte();
+ if (message.readableBytes() < optParamLen) {
+ log.debug("Error: Bad message length");
+ ctx.getChannel().close();
+ return;
+ }
+ message.readBytes(optParamLen);
+
+ // Open message received
+ receivedOpenMessageLatch.countDown();
+ }
+
+ /**
+ * Processes BGP keepalive message.
+ *
+ * @param ctx Channel handler context
+ * @param message keepalive message
+ */
+ private void processBgpKeepalive(ChannelHandlerContext ctx,
+ ChannelBuffer message) {
+
+ // Keepalive message received
+ receivedKeepaliveMessageLatch.countDown();
+ }
+
+ /**
+ * Processes BGP notification message.
+ *
+ * @param ctx Channel handler context
+ * @param message notification message
+ */
+ private void processBgpNotification(ChannelHandlerContext ctx,
+ ChannelBuffer message) {
+ byte[] data;
+ message.readByte(); //read error code
+ message.readByte(); // read error sub code
+ if (message.readableBytes() > 0) {
+ data = new byte[message.readableBytes()];
+ message.readBytes(data, 0, message.readableBytes());
+ }
+
+ // Notification message received
+ receivedNotificationMessageLatch.countDown();
+ }
+}
\ No newline at end of file