final byte typeBytes = buffer.readByte();
final int messageType = UnsignedBytes.toInt(typeBytes);
- final ByteBuf msgBody = buffer.slice(buffer.readerIndex(), messageLength - MessageUtil.COMMON_HEADER_LENGTH);
-
if (messageLength < MessageUtil.COMMON_HEADER_LENGTH) {
throw BGPDocumentedException.badMessageLength("Message length field not within valid range.", messageLength);
}
- if (msgBody.readableBytes() != messageLength - MessageUtil.COMMON_HEADER_LENGTH) {
- throw new BGPParsingException("Size doesn't match size specified in header. Passed: " + msgBody.readableBytes()
+
+ if (messageLength - MessageUtil.COMMON_HEADER_LENGTH != buffer.readableBytes()) {
+ throw new BGPParsingException("Size doesn't match size specified in header. Passed: " + buffer.readableBytes()
+ "; Expected: " + (messageLength - MessageUtil.COMMON_HEADER_LENGTH) + ". ");
}
+
+ final ByteBuf msgBody = buffer.slice(buffer.readerIndex(), messageLength - MessageUtil.COMMON_HEADER_LENGTH);
+
Notification msg = null;
try {
msg = parseBody(messageType, msgBody, messageLength);
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertTrue;
+
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
-
+import org.junit.Assert;
import org.junit.Test;
import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
import org.opendaylight.protocol.bgp.parser.BGPParsingException;
final Notification not = this.registry.parseMessage(Unpooled.copiedBuffer(keepAliveBMsg));
assertTrue(not instanceof Keepalive);
}
+
+ @Test
+ public void testIncompleteMarker() {
+ final byte[] testBytes = new byte[] { (byte) 0x00, (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) 0x00, (byte) 0x13, (byte) 0x04 };
+ try {
+ this.registry.parseMessage(Unpooled.copiedBuffer(testBytes));
+ Assert.fail();
+ } catch (BGPDocumentedException | BGPParsingException e) {
+ assertTrue(e instanceof BGPDocumentedException);
+ Assert.assertEquals("Marker not set to ones.", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testInvalidLength() {
+ final byte[] testBytes = 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, (byte) 0x00, (byte) 0x12, (byte) 0x04 };
+ try {
+ this.registry.parseMessage(Unpooled.copiedBuffer(testBytes));
+ Assert.fail();
+ } catch (BGPDocumentedException | BGPParsingException e) {
+ assertTrue(e instanceof BGPDocumentedException);
+ Assert.assertEquals("Message length field not within valid range.", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testInvalidSpecifiedSize() {
+ final byte[] testBytes = 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, (byte) 0x00, (byte) 0x13, (byte) 0x04, (byte) 0x04 };
+ try {
+ this.registry.parseMessage(Unpooled.copiedBuffer(testBytes));
+ Assert.fail();
+ } catch (BGPDocumentedException | BGPParsingException e) {
+ assertTrue(e instanceof BGPParsingException);
+ Assert.assertTrue(e.getMessage().startsWith("Size doesn't match size specified in header."));
+ }
+ }
}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.protocol.bgp.parser.spi.pojo;
+
+import com.google.common.collect.Lists;
+import io.netty.buffer.ByteBuf;
+import java.util.List;
+import org.junit.Assert;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
+import org.opendaylight.protocol.bgp.parser.BGPParsingException;
+import org.opendaylight.protocol.bgp.parser.spi.AbstractBGPExtensionProviderActivator;
+import org.opendaylight.protocol.bgp.parser.spi.AttributeParser;
+import org.opendaylight.protocol.bgp.parser.spi.AttributeSerializer;
+import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
+import org.opendaylight.protocol.bgp.parser.spi.CapabilityParser;
+import org.opendaylight.protocol.bgp.parser.spi.CapabilitySerializer;
+import org.opendaylight.protocol.bgp.parser.spi.MessageParser;
+import org.opendaylight.protocol.bgp.parser.spi.MessageSerializer;
+import org.opendaylight.protocol.bgp.parser.spi.NlriParser;
+import org.opendaylight.protocol.bgp.parser.spi.NlriSerializer;
+import org.opendaylight.protocol.bgp.parser.spi.ParameterParser;
+import org.opendaylight.protocol.bgp.parser.spi.ParameterSerializer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.open.BgpParameters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.open.bgp.parameters.CParameters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.update.PathAttributesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.path.attributes.MpReachNlriBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.path.attributes.MpUnreachNlriBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.Ipv4AddressFamily;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.UnicastSubsequentAddressFamily;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Notification;
+
+public class BgpTestActivator extends AbstractBGPExtensionProviderActivator {
+
+ protected static final int TYPE = 0;
+ private static final String EMPTY = "";
+
+ @Mock
+ protected AttributeSerializer attrSerializer;
+ @Mock
+ protected AttributeParser attrParser;
+
+ @Mock
+ protected ParameterParser paramParser;
+ @Mock
+ protected ParameterSerializer paramSerializer;
+
+ @Mock
+ protected CapabilityParser capaParser;
+ @Mock
+ protected CapabilitySerializer capaSerializer;
+
+ @Mock
+ protected MessageParser msgParser;
+ @Mock
+ protected MessageSerializer msgSerializer;
+
+ @Mock
+ protected NlriParser nlriParser;
+ @Mock
+ protected NlriSerializer nlriSerializer;
+
+ @Override
+ protected List<AutoCloseable> startImpl(BGPExtensionProviderContext context) {
+ initMock();
+ final List<AutoCloseable> regs = Lists.newArrayList();
+ regs.add(context.registerAttributeParser(TYPE, this.attrParser));
+ regs.add(context.registerAttributeSerializer(DataObject.class, this.attrSerializer));
+
+ regs.add(context.registerParameterParser(TYPE, this.paramParser));
+ regs.add(context.registerParameterSerializer(BgpParameters.class, this.paramSerializer));
+
+ regs.add(context.registerCapabilityParser(TYPE, this.capaParser));
+ regs.add(context.registerCapabilitySerializer(CParameters.class, this.capaSerializer));
+
+ regs.add(context.registerMessageParser(TYPE, this.msgParser));
+ regs.add(context.registerMessageSerializer(Notification.class, this.msgSerializer));
+
+ regs.add(context.registerAddressFamily(Ipv4AddressFamily.class, 1));
+ regs.add(context.registerSubsequentAddressFamily(UnicastSubsequentAddressFamily.class, 1));
+
+ regs.add(context.registerNlriParser(Ipv4AddressFamily.class, UnicastSubsequentAddressFamily.class, this.nlriParser));
+ regs.add(context.registerNlriSerializer(DataObject.class, this.nlriSerializer));
+
+ return regs;
+ }
+
+ private void initMock() {
+ MockitoAnnotations.initMocks(this);
+ try {
+ Mockito.doNothing().when(this.attrParser).parseAttribute(Mockito.any(ByteBuf.class), Mockito.any(PathAttributesBuilder.class));
+ Mockito.doReturn(EMPTY).when(this.attrParser).toString();
+ Mockito.doNothing().when(this.attrSerializer).serializeAttribute(Mockito.any(DataObject.class), Mockito.any(ByteBuf.class));
+ Mockito.doReturn(EMPTY).when(this.attrSerializer).toString();
+
+ Mockito.doReturn(null).when(this.paramParser).parseParameter(Mockito.any(ByteBuf.class));
+ Mockito.doReturn(EMPTY).when(this.paramParser).toString();
+ Mockito.doNothing().when(this.paramSerializer).serializeParameter(Mockito.any(BgpParameters.class), Mockito.any(ByteBuf.class));
+ Mockito.doReturn(EMPTY).when(this.paramSerializer).toString();
+
+ Mockito.doReturn(null).when(this.capaParser).parseCapability(Mockito.any(ByteBuf.class));
+ Mockito.doReturn(EMPTY).when(this.capaParser).toString();
+ Mockito.doNothing().when(this.capaSerializer).serializeCapability(Mockito.any(CParameters.class), Mockito.any(ByteBuf.class));
+ Mockito.doReturn(EMPTY).when(this.capaSerializer).toString();
+
+ Mockito.doReturn(Mockito.mock(Notification.class)).when(this.msgParser).parseMessageBody(Mockito.any(ByteBuf.class), Mockito.anyInt());
+ Mockito.doReturn(EMPTY).when(this.msgParser).toString();
+ Mockito.doNothing().when(this.msgSerializer).serializeMessage(Mockito.any(Notification.class), Mockito.any(ByteBuf.class));
+ Mockito.doReturn(EMPTY).when(this.msgSerializer).toString();
+
+ Mockito.doNothing().when(this.nlriParser).parseNlri(Mockito.any(ByteBuf.class), Mockito.any(MpUnreachNlriBuilder.class));
+ Mockito.doNothing().when(this.nlriParser).parseNlri(Mockito.any(ByteBuf.class), Mockito.any(MpReachNlriBuilder.class));
+ Mockito.doReturn(EMPTY).when(this.nlriParser).toString();
+ } catch (BGPDocumentedException | BGPParsingException e) {
+ Assert.fail();
+ }
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.protocol.bgp.parser.spi.pojo;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opendaylight.protocol.bgp.parser.BGPDocumentedException;
+import org.opendaylight.protocol.bgp.parser.BGPParsingException;
+import org.opendaylight.protocol.bgp.parser.spi.AddressFamilyRegistry;
+import org.opendaylight.protocol.bgp.parser.spi.AttributeRegistry;
+import org.opendaylight.protocol.bgp.parser.spi.BGPExtensionProviderContext;
+import org.opendaylight.protocol.bgp.parser.spi.CapabilityRegistry;
+import org.opendaylight.protocol.bgp.parser.spi.MessageRegistry;
+import org.opendaylight.protocol.bgp.parser.spi.NlriRegistry;
+import org.opendaylight.protocol.bgp.parser.spi.ParameterRegistry;
+import org.opendaylight.protocol.bgp.parser.spi.SubsequentAddressFamilyRegistry;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.open.BgpParameters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.open.bgp.parameters.CParameters;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.update.PathAttributesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.path.attributes.MpReachNlri;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.path.attributes.MpReachNlriBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.path.attributes.MpUnreachNlri;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.multiprotocol.rev130919.update.path.attributes.MpUnreachNlriBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.Ipv4AddressFamily;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.UnicastSubsequentAddressFamily;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.next.hop.c.next.hop.Ipv4NextHopCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.next.hop.c.next.hop.ipv4.next.hop._case.Ipv4NextHopBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.Notification;
+
+public class SimpleRegistryTest {
+
+ protected BGPExtensionProviderContext ctx;
+ private BgpTestActivator activator;
+
+ @Before
+ public void setUp() {
+ this.ctx = ServiceLoaderBGPExtensionProviderContext.getSingletonInstance();
+ this.activator = new BgpTestActivator();
+ this.activator.start(ctx);
+ }
+
+ @After
+ public void tearDown() {
+ this.activator.close();
+ }
+
+ @Test
+ public void testSimpleAttribute() throws BGPDocumentedException, BGPParsingException {
+ final AttributeRegistry attrReg = ctx.getAttributeRegistry();
+ final byte[] attributeBytes = {
+ 0x00, 0x00, 0x00
+ };
+ final ByteBuf byteAggregator = Unpooled.buffer(attributeBytes.length);
+ attrReg.serializeAttribute(Mockito.mock(DataObject.class), byteAggregator);
+ attrReg.parseAttributes(Unpooled.wrappedBuffer(attributeBytes));
+ verify(this.activator.attrParser, times(1)).parseAttribute(Mockito.any(ByteBuf.class), Mockito.any(PathAttributesBuilder.class));
+ verify(this.activator.attrSerializer, times(1)).serializeAttribute(Mockito.any(DataObject.class), Mockito.any(ByteBuf.class));
+ }
+
+ @Test
+ public void testSimpleParameter() throws Exception {
+ final ParameterRegistry paramReg = ctx.getParameterRegistry();
+ final BgpParameters param = Mockito.mock(BgpParameters.class);
+ Mockito.doReturn(BgpParameters.class).when(param).getImplementedInterface();
+ final byte[] paramBytes = {
+ 0x00, 0x00
+ };
+ final ByteBuf buffer = Unpooled.buffer(paramBytes.length);
+ paramReg.serializeParameter(param, buffer);
+ paramReg.parseParameter(0, Unpooled.wrappedBuffer(paramBytes));
+ verify(this.activator.paramParser, times(1)).parseParameter(Mockito.any(ByteBuf.class));
+ verify(this.activator.paramSerializer, times(1)).serializeParameter(Mockito.any(BgpParameters.class), Mockito.any(ByteBuf.class));
+ }
+
+ @Test
+ public void testSimpleCapability() throws Exception {
+ final CapabilityRegistry capaRegistry = ctx.getCapabilityRegistry();
+ final byte[] capabilityBytes = {
+ 0x0, 0x00
+ };
+ final CParameters capa = Mockito.mock(CParameters.class);
+ Mockito.doReturn(CParameters.class).when(capa).getImplementedInterface();
+ final ByteBuf buffer = Unpooled.buffer(capabilityBytes.length);
+ capaRegistry.serializeCapability(capa, buffer);
+ capaRegistry.parseCapability(BgpTestActivator.TYPE, Unpooled.wrappedBuffer(capabilityBytes));
+ verify(this.activator.capaParser, times(1)).parseCapability(Mockito.any(ByteBuf.class));
+ verify(this.activator.capaSerializer, times(1)).serializeCapability(Mockito.any(CParameters.class), Mockito.any(ByteBuf.class));
+ }
+
+ @Test
+ public void testSimpleMessageRegistry() throws Exception {
+ final MessageRegistry msgRegistry = ctx.getMessageRegistry();
+
+ final byte[] msgBytes = {
+ (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,
+ (byte) 0x00, (byte) 0x13, (byte) 0x00
+ };
+ final Notification msg = mock(Notification.class);
+ doReturn(Notification.class).when(msg).getImplementedInterface();
+
+ final ByteBuf buffer = Unpooled.buffer(msgBytes.length);
+ msgRegistry.serializeMessage(msg, buffer);
+ msgRegistry.parseMessage(Unpooled.wrappedBuffer(msgBytes));
+ verify(this.activator.msgParser, times(1)).parseMessageBody(Mockito.any(ByteBuf.class), Mockito.anyInt());
+ verify(this.activator.msgSerializer, times(1)).serializeMessage(Mockito.any(Notification.class), Mockito.any(ByteBuf.class));
+ }
+
+ @Test
+ public void testAfiRegistry() throws Exception {
+ final AddressFamilyRegistry afiRegistry = ctx.getAddressFamilyRegistry();
+ assertEquals(Ipv4AddressFamily.class, afiRegistry.classForFamily(1));
+ assertEquals(1, afiRegistry.numberForClass(Ipv4AddressFamily.class).intValue());
+ }
+
+ @Test
+ public void testSafiRegistry() throws Exception {
+ final SubsequentAddressFamilyRegistry safiRegistry = ctx.getSubsequentAddressFamilyRegistry();
+ assertEquals(UnicastSubsequentAddressFamily.class, safiRegistry.classForFamily(1));
+ assertEquals(1, safiRegistry.numberForClass(UnicastSubsequentAddressFamily.class).intValue());
+ }
+
+ @Test
+ public void testMpReachParser() throws BGPParsingException {
+ final NlriRegistry nlriReg = ctx.getNlriRegistry();
+ final byte[] mpReachBytes = {
+ 0x00, 0x01, 0x01, 0x04, 0x7f, 0x00, 0x00, 0x01, 0x00
+ };
+ final MpReachNlri mpReach = new MpReachNlriBuilder()
+ .setAfi(Ipv4AddressFamily.class)
+ .setSafi(UnicastSubsequentAddressFamily.class)
+ .setCNextHop(new Ipv4NextHopCaseBuilder().setIpv4NextHop(new Ipv4NextHopBuilder().setGlobal(new Ipv4Address("127.0.0.1")).build()).build())
+ .build();
+ final ByteBuf buffer = Unpooled.buffer(mpReachBytes.length);
+ nlriReg.serializeMpReach(mpReach, buffer);
+ assertArrayEquals(mpReachBytes, buffer.array());
+ assertEquals(mpReach, nlriReg.parseMpReach(Unpooled.wrappedBuffer(mpReachBytes)));
+ verify(this.activator.nlriParser, times(1)).parseNlri(Mockito.any(ByteBuf.class), Mockito.any(MpReachNlriBuilder.class));
+ }
+
+ @Test
+ public void testMpUnReachParser() throws BGPParsingException {
+ final NlriRegistry nlriReg = ctx.getNlriRegistry();
+ final byte[] mpUnreachBytes = {
+ 0x00, 0x01, 0x01
+ };
+ final MpUnreachNlri mpUnreach = new MpUnreachNlriBuilder().setAfi(Ipv4AddressFamily.class).setSafi(UnicastSubsequentAddressFamily.class).build();
+ final ByteBuf buffer = Unpooled.buffer(mpUnreachBytes.length);
+ nlriReg.serializeMpUnReach(mpUnreach, buffer);
+ assertArrayEquals(mpUnreachBytes, buffer.array());
+ assertEquals(mpUnreach, nlriReg.parseMpUnreach(Unpooled.wrappedBuffer(mpUnreachBytes)));
+ verify(this.activator.nlriParser, times(1)).parseNlri(Mockito.any(ByteBuf.class), Mockito.any(MpUnreachNlriBuilder.class));
+ }
+}
Code Review / bgpcep.git / commitdiff