diff options
Diffstat (limited to 'framework/src/onos/bgp/bgpio/src')
28 files changed, 2744 insertions, 88 deletions
diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPFactories.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPFactories.java new file mode 100755 index 00000000..71b9cbff --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPFactories.java @@ -0,0 +1,82 @@ +/*
+ * Copyright 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.bgpio.protocol;
+
+import org.jboss.netty.buffer.ChannelBuffer;
+import org.onosproject.bgpio.exceptions.BGPParseException;
+import org.onosproject.bgpio.protocol.ver4.BGPFactoryVer4;
+import org.onosproject.bgpio.types.BGPHeader;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Abstraction to provide the version for BGP.
+ */
+public final class BGPFactories {
+
+ protected static final Logger log = LoggerFactory.getLogger(BGPFactories.class);
+
+ private static final GenericReader GENERIC_READER = new GenericReader();
+
+ private BGPFactories() {
+ }
+
+ /**
+ * Returns the instance of BGP Version.
+ *
+ * @param version BGP version
+ * @return BGP version
+ */
+ public static BGPFactory getFactory(BGPVersion version) {
+ switch (version) {
+ case BGP_4:
+ return BGPFactoryVer4.INSTANCE;
+ default:
+ throw new IllegalArgumentException("[BGPFactory:]Unknown version: " + version);
+ }
+ }
+
+ /**
+ * Reader class for reading BGP messages from channel buffer.
+ *
+ */
+ private static class GenericReader implements BGPMessageReader<BGPMessage> {
+
+ @Override
+ public BGPMessage readFrom(ChannelBuffer bb, BGPHeader bgpHeader)
+ throws BGPParseException {
+ BGPFactory factory;
+
+ if (!bb.readable()) {
+ log.error("Empty message received");
+ throw new BGPParseException("Empty message received");
+ }
+ // TODO: Currently only BGP version 4 is supported
+ factory = org.onosproject.bgpio.protocol.ver4.BGPFactoryVer4.INSTANCE;
+ return factory.getReader().readFrom(bb, bgpHeader);
+ }
+ }
+
+ /**
+ * Returns BGP messsage generic reader.
+ *
+ * @return bgp message generic reader
+ */
+ public static BGPMessageReader<BGPMessage> getGenericReader() {
+ return GENERIC_READER;
+ }
+}
diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPFactory.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPFactory.java new file mode 100755 index 00000000..cf6bf008 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPFactory.java @@ -0,0 +1,60 @@ +/* + * Copyright 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.bgpio.protocol; + +/** + * Abstraction of an message factory providing builder functions to BGP messages + * and objects. + * + */ +public interface BGPFactory { + + /** + * Gets the builder object for a open message. + * + * @return builder object for open message + */ + BGPOpenMsg.Builder openMessageBuilder(); + + /** + * Gets the builder object for a keepalive message. + * + * @return builder object for keepalive message + */ + BGPKeepaliveMsg.Builder keepaliveMessageBuilder(); + + /** + * Gets the builder object for a notification message. + * + * @return builder object for notification message. + */ + BGPNotificationMsg.Builder notificationMessageBuilder(); + + /** + * Gets the BGP message reader. + * + * @return BGP message reader + */ + BGPMessageReader<BGPMessage> getReader(); + + /** + * Returns BGP version. + * + * @return BGP version + */ + BGPVersion getVersion(); +} diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPNotificationMsg.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPNotificationMsg.java index 56540dd3..a1d9d578 100644 --- a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPNotificationMsg.java +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/BGPNotificationMsg.java @@ -16,36 +16,34 @@ package org.onosproject.bgpio.protocol; import org.onosproject.bgpio.exceptions.BGPParseException; -import org.onosproject.bgpio.types.BGPHeader; /** - * Abstraction of an entity providing BGP Notification Message. + * Abstraction of an entity providing BGP notification message. */ public interface BGPNotificationMsg extends BGPMessage { /** - * Returns errorCode in Notification message. + * Returns errorCode in notification message. * - * @return errorCode in Notification message + * @return errorCode in notification message */ byte getErrorCode(); /** - * Returns error SubCode in Notification message. + * Returns error subCode in notification message. * - * @return error SubCode in Notification message + * @return error subCode in notification message */ byte getErrorSubCode(); /** - * Returns error data in Notification message. + * Returns error data in notification message. * - * @return error data in Notification message + * @return error data in notification message */ byte[] getData(); /** - * Builder interface with get and set functions to build Notification - * message. + * Builder interface with get and set functions to build notification message. */ public interface Builder extends BGPMessage.Builder { @@ -53,26 +51,18 @@ public interface BGPNotificationMsg extends BGPMessage { BGPNotificationMsg build() throws BGPParseException; /** - * Sets notification message header and returns its builder. - * - * @param header of notification message - * @return Builder by setting notification message header - */ - Builder setNotificationMsgHeader(BGPHeader header); - - /** * Sets errorCode in notification message and return its builder. * * @param errorCode in notification message - * @return builder by setting ErrorCode in notification message + * @return builder by setting errorCode in notification message */ Builder setErrorCode(byte errorCode); /** - * Sets error SubCode in notification message and return its builder. + * Sets error subCode in notification message and return its builder. * - * @param errorSubCode in notification Message - * @return builder by setting ErrorSubCode in notification Message + * @param errorSubCode in notification message + * @return builder by setting error subCode in notification message */ Builder setErrorSubCode(byte errorSubCode); diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPFactoryVer4.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPFactoryVer4.java new file mode 100755 index 00000000..32af3854 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPFactoryVer4.java @@ -0,0 +1,58 @@ +/* + * Copyright 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.bgpio.protocol.ver4; + +import org.onosproject.bgpio.protocol.BGPFactory; +import org.onosproject.bgpio.protocol.BGPKeepaliveMsg; +import org.onosproject.bgpio.protocol.BGPMessage; +import org.onosproject.bgpio.protocol.BGPMessageReader; +import org.onosproject.bgpio.protocol.BGPNotificationMsg; +import org.onosproject.bgpio.protocol.BGPOpenMsg; +import org.onosproject.bgpio.protocol.BGPVersion; + +/** + * Provides BGP Factory and returns builder classes for all objects and messages. + */ +public class BGPFactoryVer4 implements BGPFactory { + + public static final BGPFactoryVer4 INSTANCE = new BGPFactoryVer4(); + + @Override + public BGPOpenMsg.Builder openMessageBuilder() { + return new BGPOpenMsgVer4.Builder(); + } + + @Override + public BGPKeepaliveMsg.Builder keepaliveMessageBuilder() { + return new BGPKeepaliveMsgVer4.Builder(); + } + + @Override + public BGPNotificationMsg.Builder notificationMessageBuilder() { + return new BGPNotificationMsgVer4.Builder(); + } + + @Override + public BGPMessageReader<BGPMessage> getReader() { + return BGPMessageVer4.READER; + } + + @Override + public BGPVersion getVersion() { + return BGPVersion.BGP_4; + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPMessageVer4.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPMessageVer4.java new file mode 100755 index 00000000..d45e3de1 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPMessageVer4.java @@ -0,0 +1,109 @@ +/* + * Copyright 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.bgpio.protocol.ver4; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.protocol.BGPFactories; +import org.onosproject.bgpio.protocol.BGPMessage; +import org.onosproject.bgpio.protocol.BGPMessageReader; +import org.onosproject.bgpio.types.BGPErrorType; +import org.onosproject.bgpio.types.BGPHeader; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Provides BGP messages. + */ +public abstract class BGPMessageVer4 { + + protected static final Logger log = LoggerFactory.getLogger(BGPFactories.class); + + 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 HEADER_AND_MSG_LEN = 18; + static final int MAXIMUM_PACKET_LENGTH = 4096; + + public static final BGPMessageVer4.Reader READER = new Reader(); + + /** + * Reader class for reading BGP messages from channel buffer. + * + */ + static class Reader implements BGPMessageReader<BGPMessage> { + @Override + public BGPMessage readFrom(ChannelBuffer cb, BGPHeader bgpHeader) + throws BGPParseException { + + if (cb.readableBytes() < MINIMUM_COMMON_HEADER_LENGTH) { + log.error("Packet should have minimum length."); + Validation.validateLen(BGPErrorType.MESSAGE_HEADER_ERROR, BGPErrorType.BAD_MESSAGE_LENGTH, + cb.readableBytes()); + } + if (cb.readableBytes() > MAXIMUM_PACKET_LENGTH) { + log.error("Packet length should not exceed {}.", MAXIMUM_PACKET_LENGTH); + Validation.validateLen(BGPErrorType.MESSAGE_HEADER_ERROR, BGPErrorType.BAD_MESSAGE_LENGTH, + cb.readableBytes()); + } + try { + // fixed value property version == 4 + byte[] marker = new byte[BGPHeader.MARKER_LENGTH]; + cb.readBytes(marker, 0, BGPHeader.MARKER_LENGTH); + bgpHeader.setMarker(marker); + for (int i = 0; i < BGPHeader.MARKER_LENGTH; i++) { + if (marker[i] != (byte) 0xff) { + throw new BGPParseException(BGPErrorType.MESSAGE_HEADER_ERROR, + BGPErrorType.CONNECTION_NOT_SYNCHRONIZED, null); + } + } + short length = cb.readShort(); + if (length != (cb.readableBytes() + HEADER_AND_MSG_LEN)) { + Validation.validateLen(BGPErrorType.MESSAGE_HEADER_ERROR, BGPErrorType.BAD_MESSAGE_LENGTH, length); + } + bgpHeader.setLength(length); + byte type = cb.readByte(); + bgpHeader.setType(type); + log.debug("Reading update message of type " + type); + + int len = length - MINIMUM_COMMON_HEADER_LENGTH; + switch (type) { + case OPEN_MSG_TYPE: + log.debug("OPEN MESSAGE is received"); + return BGPOpenMsgVer4.READER.readFrom(cb.readBytes(len), bgpHeader); + case KEEPALIVE_MSG_TYPE: + log.debug("KEEPALIVE MESSAGE is received"); + return BGPKeepaliveMsgVer4.READER.readFrom(cb.readBytes(len), bgpHeader); + case UPDATE_MSG_TYPE: + log.debug("UPDATE MESSAGE is received"); + // TODO: Update message version 4 + case NOTIFICATION_MSG_TYPE: + log.debug("NOTIFICATION MESSAGE is received"); + return BGPNotificationMsgVer4.READER.readFrom(cb.readBytes(len), bgpHeader); + default: + Validation.validateType(BGPErrorType.MESSAGE_HEADER_ERROR, BGPErrorType.BAD_MESSAGE_TYPE, type); + return null; + } + } catch (IndexOutOfBoundsException e) { + throw new BGPParseException(BGPErrorType.MESSAGE_HEADER_ERROR, BGPErrorType.BAD_MESSAGE_LENGTH, null); + } + } + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPNotificationMsgVer4.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPNotificationMsgVer4.java index 064deada..3bddd375 100644 --- a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPNotificationMsgVer4.java +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BGPNotificationMsgVer4.java @@ -44,7 +44,7 @@ class BGPNotificationMsgVer4 implements BGPNotificationMsg { REFERENCE : RFC 4271 */ - protected static final Logger log = LoggerFactory.getLogger(BGPNotificationMsgVer4.class); + private static final Logger log = LoggerFactory.getLogger(BGPNotificationMsgVer4.class); static final byte PACKET_VERSION = 4; //BGPHeader(19) + Error code(1) + Error subcode(1) @@ -52,8 +52,10 @@ class BGPNotificationMsgVer4 implements BGPNotificationMsg { static final int PACKET_MINIMUM_LENGTH = 2; static final BGPType MSG_TYPE = BGPType.NOTIFICATION; static final byte DEFAULT_ERRORSUBCODE = 0; - static final byte[] MARKER = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, - 0x01, 0x01}; + static final byte[] MARKER = {(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 }; static final byte MESSAGE_TYPE = 3; static final BGPHeader DEFAULT_MESSAGE_HEADER = new BGPHeader(MARKER, BGPHeader.DEFAULT_HEADER_LENGTH, MESSAGE_TYPE); @@ -65,7 +67,7 @@ class BGPNotificationMsgVer4 implements BGPNotificationMsg { public static final BGPNotificationMsgVer4.Reader READER = new Reader(); /** - * Resets fields. + * Initialize fields. */ public BGPNotificationMsgVer4() { this.bgpHeader = null; @@ -154,13 +156,6 @@ class BGPNotificationMsgVer4 implements BGPNotificationMsg { } @Override - public Builder setNotificationMsgHeader(BGPHeader header) { - this.bgpHeader = header; - this.isBGPHeaderSet = true; - return this; - } - - @Override public Builder setHeader(BGPHeader bgpMsgHeader) { this.bgpHeader = bgpMsgHeader; return this; diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BgpPathAttributes.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BgpPathAttributes.java new file mode 100644 index 00000000..08fea4c6 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/protocol/ver4/BgpPathAttributes.java @@ -0,0 +1,190 @@ +/* + * Copyright 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.bgpio.protocol.ver4; + +import java.util.LinkedList; +import java.util.List; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.types.As4Path; +import org.onosproject.bgpio.types.AsPath; +import org.onosproject.bgpio.types.BGPErrorType; +import org.onosproject.bgpio.types.BGPValueType; +import org.onosproject.bgpio.types.LocalPref; +import org.onosproject.bgpio.types.Med; +import org.onosproject.bgpio.types.NextHop; +import org.onosproject.bgpio.types.Origin; +import org.onosproject.bgpio.util.UnSupportedAttribute; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Implementation of BGP Path Attribute. + */ +public class BgpPathAttributes { + + /* Path attribute: + <attribute type, attribute length, attribute value> + + 0 1 + 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + | Attr. Flags |Attr. Type Code| + +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + REFERENCE : RFC 4271 + */ + protected static final Logger log = LoggerFactory.getLogger(BgpPathAttributes.class); + + public static final int LINK_STATE_ATTRIBUTE_TYPE = 50; + public static final int MPREACHNLRI_TYPE = 14; + public static final int MPUNREACHNLRI_TYPE = 15; + + private final List<BGPValueType> pathAttribute; + + /** + * Initialize parameter. + */ + public BgpPathAttributes() { + this.pathAttribute = null; + } + + /** + * Constructor to initialize parameters for BGP path attributes. + * + * @param pathAttribute list of path attributes + */ + public BgpPathAttributes(List<BGPValueType> pathAttribute) { + this.pathAttribute = pathAttribute; + } + + /** + * Returns list of path attributes. + * + * @return list of path attributes + */ + public List<BGPValueType> pathAttributes() { + return this.pathAttribute; + } + + /** + * Reads from channelBuffer and parses BGP path attributes. + * + * @param cb channelBuffer + * @return object of BgpPathAttributes + * @throws BGPParseException while parsing BGP path attributes + */ + public static BgpPathAttributes read(ChannelBuffer cb) + throws BGPParseException { + + BGPValueType pathAttribute = null; + List<BGPValueType> pathAttributeList = new LinkedList<>(); + boolean isOrigin = false; + boolean isAsPath = false; + boolean isNextHop = false; + boolean isMpReach = false; + boolean isMpUnReach = false; + while (cb.readableBytes() > 0) { + cb.markReaderIndex(); + byte flags = cb.readByte(); + byte typeCode = cb.readByte(); + cb.resetReaderIndex(); + switch (typeCode) { + case Origin.ORIGIN_TYPE: + pathAttribute = Origin.read(cb); + isOrigin = ((Origin) pathAttribute).isOriginSet(); + break; + case AsPath.ASPATH_TYPE: + pathAttribute = AsPath.read(cb); + isAsPath = ((AsPath) pathAttribute).isaspathSet(); + break; + case As4Path.AS4PATH_TYPE: + pathAttribute = As4Path.read(cb); + break; + case NextHop.NEXTHOP_TYPE: + pathAttribute = NextHop.read(cb); + isNextHop = ((NextHop) pathAttribute).isNextHopSet(); + break; + case Med.MED_TYPE: + pathAttribute = Med.read(cb); + break; + case LocalPref.LOCAL_PREF_TYPE: + pathAttribute = LocalPref.read(cb); + break; + case MPREACHNLRI_TYPE: + //TODO: To be merged later + break; + case MPUNREACHNLRI_TYPE: + //TODO: To be merged later + break; + case LINK_STATE_ATTRIBUTE_TYPE: + //TODO: To be merged later + break; + default: + //skip bytes for unsupported attribute types + UnSupportedAttribute.read(cb); + } + pathAttributeList.add(pathAttribute); + } + + checkMandatoryAttr(isOrigin, isAsPath, isNextHop, isMpReach, isMpUnReach); + //TODO:if mp_reach or mp_unreach not present ignore the packet + return new BgpPathAttributes(pathAttributeList); + } + + /** + * Checks mandatory attributes are presents, if not present throws exception. + * + * @param isOrigin say whether origin attribute is present + * @param isAsPath say whether aspath attribute is present + * @param isNextHop say whether nexthop attribute is present + * @param isMpReach say whether mpreach attribute is present + * @param isMpUnReach say whether mpunreach attribute is present + * @throws BGPParseException if mandatory path attribute is not present + */ + public static void checkMandatoryAttr(boolean isOrigin, boolean isAsPath, + boolean isNextHop, boolean isMpReach, boolean isMpUnReach) + throws BGPParseException { + if (!isOrigin) { + log.debug("Mandatory Attributes not Present"); + Validation.validateType(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.MISSING_WELLKNOWN_ATTRIBUTE, + Origin.ORIGIN_TYPE); + } + if (!isAsPath) { + log.debug("Mandatory Attributes not Present"); + Validation.validateType(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.MISSING_WELLKNOWN_ATTRIBUTE, + AsPath.ASPATH_TYPE); + } + if (!isMpUnReach && !isMpReach && !isNextHop) { + log.debug("Mandatory Attributes not Present"); + Validation.validateType(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.MISSING_WELLKNOWN_ATTRIBUTE, + NextHop.NEXTHOP_TYPE); + } + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("pathAttribute", pathAttribute) + .toString(); + } +} diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/As4Path.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/As4Path.java new file mode 100644 index 00000000..90e94e88 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/As4Path.java @@ -0,0 +1,170 @@ +/* + * Copyright 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.bgpio.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Implementation of As4Path BGP Path Attribute. + */ +public class As4Path implements BGPValueType { + private static final Logger log = LoggerFactory.getLogger(AsPath.class); + public static final byte AS4PATH_TYPE = 17; + public static final byte ASNUM_SIZE = 4; + public static final int TYPE_AND_LEN_AS_SHORT = 4; + public static final int TYPE_AND_LEN_AS_BYTE = 3; + + private List<Integer> as4pathSet; + private List<Integer> as4pathSeq; + + /** + * Initialize fields. + */ + public As4Path() { + this.as4pathSeq = null; + this.as4pathSet = null; + } + + /** + * Constructor to initialize parameters. + * + * @param as4pathSet AS4path Set + * @param as4pathSeq AS4path Sequence + */ + public As4Path(List<Integer> as4pathSet, List<Integer> as4pathSeq) { + this.as4pathSeq = as4pathSeq; + this.as4pathSet = as4pathSet; + } + + /** + * Reads from the channel buffer and parses As4Path. + * + * @param cb ChannelBuffer + * @return object of As4Path + * @throws BGPParseException while parsing As4Path + */ + public static As4Path read(ChannelBuffer cb) throws BGPParseException { + List<Integer> as4pathSet = new ArrayList<>(); + List<Integer> as4pathSeq = new ArrayList<>(); + ChannelBuffer tempCb = cb.copy(); + Validation validation = Validation.parseAttributeHeader(cb); + + if (cb.readableBytes() < validation.getLength()) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + validation.getLength()); + } + //if fourth bit is set length is read as short otherwise as byte , len includes type, length and value + int len = validation.isShort() ? validation.getLength() + TYPE_AND_LEN_AS_SHORT : validation + .getLength() + TYPE_AND_LEN_AS_BYTE; + ChannelBuffer data = tempCb.readBytes(len); + if (validation.getFirstBit() && !validation.getSecondBit() && validation.getThirdBit()) { + throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_FLAGS_ERROR, data); + } + + ChannelBuffer tempBuf = cb.readBytes(validation.getLength()); + while (tempBuf.readableBytes() > 0) { + byte pathSegType = tempBuf.readByte(); + //no of ASes + byte pathSegLen = tempBuf.readByte(); + //length = no of Ases * ASnum size (4 bytes) + int length = pathSegLen * ASNUM_SIZE; + if (tempBuf.readableBytes() < length) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.ATTRIBUTE_LENGTH_ERROR, length); + } + ChannelBuffer aspathBuf = tempBuf.readBytes(length); + while (aspathBuf.readableBytes() > 0) { + int asNum; + asNum = aspathBuf.readInt(); + switch (pathSegType) { + case AsPath.ASPATH_SET_TYPE: + as4pathSet.add(asNum); + break; + case AsPath.ASPATH_SEQ_TYPE: + as4pathSeq.add(asNum); + break; + default: log.debug("Other type Not Supported:" + pathSegType); + } + } + } + return new As4Path(as4pathSet, as4pathSeq); + } + + @Override + public short getType() { + return AS4PATH_TYPE; + } + + /** + * Returns list of ASNum in AS4path Sequence. + * + * @return list of ASNum in AS4path Sequence + */ + public List<Integer> as4PathSEQ() { + return this.as4pathSeq; + } + + /** + * Returns list of ASNum in AS4path Set. + * + * @return list of ASNum in AS4path Set + */ + public List<Integer> as4PathSET() { + return this.as4pathSet; + } + + @Override + public int hashCode() { + return Objects.hash(as4pathSet, as4pathSeq); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof As4Path) { + As4Path other = (As4Path) obj; + return Objects.equals(as4pathSet, other.as4pathSet) && Objects.equals(as4pathSeq, other.as4pathSeq); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("as4pathSet", as4pathSet) + .add("as4pathSeq", as4pathSeq) + .toString(); + } + + @Override + public int write(ChannelBuffer cb) { + //Not required to Implement as of now + return 0; + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/AsPath.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/AsPath.java new file mode 100644 index 00000000..100e14d7 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/AsPath.java @@ -0,0 +1,209 @@ +/* + * Copyright 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.bgpio.types; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Implementation of AsPath mandatory BGP Path Attribute. + */ +public class AsPath implements BGPValueType { + /** + * Enum to provide AS types. + */ + public enum ASTYPE { + AS_SET(1), AS_SEQUENCE(2), AS_CONFED_SEQUENCE(3), AS_CONFED_SET(4); + int value; + + /** + * Assign val with the value as the AS type. + * + * @param val AS type + */ + ASTYPE(int val) { + value = val; + } + + /** + * Returns value of AS type. + * + * @return AS type + */ + public byte getType() { + return (byte) value; + } + } + + private static final Logger log = LoggerFactory.getLogger(AsPath.class); + public static final byte ASPATH_TYPE = 2; + public static final byte ASPATH_SET_TYPE = 1; + public static final byte ASPATH_SEQ_TYPE = 2; + public static final byte ASNUM_SIZE = 2; + public static final int TYPE_AND_LEN_AS_SHORT = 4; + public static final int TYPE_AND_LEN_AS_BYTE = 3; + + private boolean isAsPath = false; + private List<Short> aspathSet; + private List<Short> aspathSeq; + + /** + * Initialize Fields. + */ + public AsPath() { + this.aspathSeq = null; + this.aspathSet = null; + } + + /** + * Constructor to initialize parameters. + * + * @param aspathSet ASpath Set type + * @param aspathSeq ASpath Sequence type + */ + public AsPath(List<Short> aspathSet, List<Short> aspathSeq) { + this.aspathSeq = aspathSeq; + this.aspathSet = aspathSet; + this.isAsPath = true; + } + + /** + * Reads from the channel buffer and parses AsPath. + * + * @param cb ChannelBuffer + * @return object of AsPath + * @throws BGPParseException while parsing AsPath + */ + public static AsPath read(ChannelBuffer cb) throws BGPParseException { + List<Short> aspathSet = new ArrayList<>(); + List<Short> aspathSeq = new ArrayList<>(); + ChannelBuffer tempCb = cb.copy(); + Validation validation = Validation.parseAttributeHeader(cb); + + if (cb.readableBytes() < validation.getLength()) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + validation.getLength()); + } + //if fourth bit is set, length is read as short otherwise as byte , len includes type, length and value + int len = validation.isShort() ? validation.getLength() + TYPE_AND_LEN_AS_SHORT : validation + .getLength() + TYPE_AND_LEN_AS_BYTE; + ChannelBuffer data = tempCb.readBytes(len); + if (validation.getFirstBit() && !validation.getSecondBit() && validation.getThirdBit()) { + throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_FLAGS_ERROR, data); + } + + ChannelBuffer tempBuf = cb.readBytes(validation.getLength()); + while (tempBuf.readableBytes() > 0) { + byte pathSegType = tempBuf.readByte(); + //no of ASes + byte pathSegLen = tempBuf.readByte(); + int length = pathSegLen * ASNUM_SIZE; + if (tempBuf.readableBytes() < length) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.ATTRIBUTE_LENGTH_ERROR, length); + } + ChannelBuffer aspathBuf = tempBuf.readBytes(length); + while (aspathBuf.readableBytes() > 0) { + short asNum; + asNum = aspathBuf.readShort(); + switch (pathSegType) { + case ASPATH_SET_TYPE: + aspathSet.add(asNum); + break; + case ASPATH_SEQ_TYPE: + aspathSeq.add(asNum); + break; + default: log.debug("Other type Not Supported:" + pathSegType); + } + } + } + return new AsPath(aspathSet, aspathSeq); + } + + @Override + public short getType() { + return ASPATH_TYPE; + } + + /** + * Returns whether ASpath path attribute is present. + * + * @return whether ASpath path attribute is present + */ + public boolean isaspathSet() { + return this.isAsPath; + } + + /** + * Returns list of ASNum in ASpath Sequence. + * + * @return list of ASNum in ASpath Sequence + */ + public List<Short> asPathSeq() { + return this.aspathSeq; + } + + /** + * Returns list of ASNum in ASpath SET. + * + * @return list of ASNum in ASpath SET + */ + public List<Short> asPathSet() { + return this.aspathSet; + } + + @Override + public int hashCode() { + return Objects.hash(aspathSet, aspathSeq); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof AsPath) { + AsPath other = (AsPath) obj; + return Objects.equals(aspathSet, other.aspathSet) && Objects.equals(aspathSeq, other.aspathSeq); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .omitNullValues() + .add("aspathSet", aspathSet) + .add("aspathSeq", aspathSeq) + .toString(); + } + + @Override + public int write(ChannelBuffer cb) { + //Not required to Implement as of now + return 0; + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/LocalPref.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/LocalPref.java new file mode 100644 index 00000000..048d81ee --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/LocalPref.java @@ -0,0 +1,120 @@ +/* + * Copyright 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.bgpio.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides implementation of LocalPref BGP Path Attribute. + */ +public class LocalPref implements BGPValueType { + + private static final Logger log = LoggerFactory.getLogger(LocalPref.class); + public static final byte LOCAL_PREF_TYPE = 5; + public static final int TYPE_AND_LEN_AS_SHORT = 4; + public static final int TYPE_AND_LEN_AS_BYTE = 3; + public static final byte LOCAL_PREF_MAX_LEN = 4; + + private int localPref; + + /** + * Constructor to initialize LocalPref. + * + * @param localPref local preference + */ + public LocalPref(int localPref) { + this.localPref = localPref; + } + + /** + * Returns local preference value. + * + * @return local preference value + */ + public int localPref() { + return this.localPref; + } + + /** + * Reads the channel buffer and returns object of LocalPref. + * + * @param cb channelBuffer + * @return object of LocalPref + * @throws BGPParseException while parsing localPref attribute + */ + public static LocalPref read(ChannelBuffer cb) throws BGPParseException { + int localPref; + ChannelBuffer tempCb = cb.copy(); + Validation parseFlags = Validation.parseAttributeHeader(cb); + if ((parseFlags.getLength() > LOCAL_PREF_MAX_LEN) || cb.readableBytes() < parseFlags.getLength()) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + parseFlags.getLength()); + } + + int len = parseFlags.isShort() ? parseFlags.getLength() + TYPE_AND_LEN_AS_SHORT : parseFlags.getLength() + + TYPE_AND_LEN_AS_BYTE; + ChannelBuffer data = tempCb.readBytes(len); + if (parseFlags.getFirstBit()) { + throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_FLAGS_ERROR, data); + } + + localPref = cb.readInt(); + return new LocalPref(localPref); + } + + @Override + public short getType() { + return LOCAL_PREF_TYPE; + } + + @Override + public int hashCode() { + return Objects.hash(localPref); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof LocalPref) { + LocalPref other = (LocalPref) obj; + return Objects.equals(localPref, other.localPref); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("localPref", localPref) + .toString(); + } + + @Override + public int write(ChannelBuffer cb) { + //Not to implement as of now + return 0; + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/Med.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/Med.java new file mode 100644 index 00000000..49e1fc5a --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/Med.java @@ -0,0 +1,119 @@ +/* + * Copyright 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.bgpio.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Implementation of Med BGP Path Attribute. + */ +public class Med implements BGPValueType { + private static final Logger log = LoggerFactory.getLogger(Med.class); + public static final byte MED_TYPE = 4; + public static final int TYPE_AND_LEN_AS_SHORT = 4; + public static final int TYPE_AND_LEN_AS_BYTE = 3; + public static final byte MED_MAX_LEN = 4; + + private int med; + + /** + * Constructor to initialize med. + * + * @param med MULTI_EXIT_DISC value + */ + public Med(int med) { + this.med = med; + } + + /** + * Returns Med value. + * + * @return Med value + */ + public int med() { + return this.med; + } + + /** + * Reads the channel buffer and returns object of Med. + * + * @param cb ChannelBuffer + * @return object of Med + * @throws BGPParseException while parsing Med path attribute + */ + public static Med read(ChannelBuffer cb) throws BGPParseException { + int med; + ChannelBuffer tempCb = cb.copy(); + Validation parseFlags = Validation.parseAttributeHeader(cb); + + if ((parseFlags.getLength() > MED_MAX_LEN) || cb.readableBytes() < parseFlags.getLength()) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + parseFlags.getLength()); + } + int len = parseFlags.isShort() ? parseFlags.getLength() + TYPE_AND_LEN_AS_SHORT : parseFlags + .getLength() + TYPE_AND_LEN_AS_BYTE; + ChannelBuffer data = tempCb.readBytes(len); + if (!parseFlags.getFirstBit() && parseFlags.getSecondBit() && parseFlags.getThirdBit()) { + throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_FLAGS_ERROR, data); + } + + med = cb.readInt(); + return new Med(med); + } + + @Override + public short getType() { + return MED_TYPE; + } + + @Override + public int hashCode() { + return Objects.hash(med); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof Med) { + Med other = (Med) obj; + return Objects.equals(med, other.med); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("med", med) + .toString(); + } + + @Override + public int write(ChannelBuffer cb) { + //Not to implement as of now + return 0; + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/NextHop.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/NextHop.java new file mode 100644 index 00000000..353ec3d5 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/NextHop.java @@ -0,0 +1,138 @@ +/* + * Copyright 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.bgpio.types; + +import java.net.InetAddress; +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onlab.packet.Ip4Address; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; +import com.google.common.base.Preconditions; + +/** + * Implementation of NextHop BGP Path Attribute. + */ +public class NextHop implements BGPValueType { + private static final Logger log = LoggerFactory.getLogger(NextHop.class); + public static final byte NEXTHOP_TYPE = 3; + public static final int TYPE_AND_LEN_AS_SHORT = 4; + public static final int TYPE_AND_LEN_AS_BYTE = 3; + + private boolean isNextHop = false; + private Ip4Address nextHop; + + /** + * Constructor to initialize parameters. + * + * @param nextHop nextHop address + */ + public NextHop(Ip4Address nextHop) { + this.nextHop = Preconditions.checkNotNull(nextHop); + this.isNextHop = true; + } + + /** + * Returns whether next hop is present. + * + * @return whether next hop is present + */ + public boolean isNextHopSet() { + return this.isNextHop; + } + + /** + * Reads from ChannelBuffer and parses NextHop. + * + * @param cb ChannelBuffer + * @return object of NextHop + * @throws BGPParseException while parsing nexthop attribute + */ + public static NextHop read(ChannelBuffer cb) throws BGPParseException { + Ip4Address nextHop; + ChannelBuffer tempCb = cb.copy(); + Validation parseFlags = Validation.parseAttributeHeader(cb); + + if (cb.readableBytes() < parseFlags.getLength()) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + parseFlags.getLength()); + } + int len = parseFlags.isShort() ? parseFlags.getLength() + TYPE_AND_LEN_AS_SHORT : parseFlags + .getLength() + TYPE_AND_LEN_AS_BYTE; + ChannelBuffer data = tempCb.readBytes(len); + if (parseFlags.getFirstBit() && !parseFlags.getSecondBit() && parseFlags.getThirdBit()) { + throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_FLAGS_ERROR, data); + } + + //TODO: use Validation.toInetAddress once Validation is merged + InetAddress ipAddress = (InetAddress) cb.readBytes(parseFlags.getLength()); + if (ipAddress.isMulticastAddress()) { + throw new BGPParseException("Multicast address is not supported"); + } + + nextHop = Ip4Address.valueOf(ipAddress); + return new NextHop(nextHop); + } + + /** + * Return nexthop address. + * + * @return nexthop address + */ + public Ip4Address nextHop() { + return nextHop; + } + + @Override + public short getType() { + return NEXTHOP_TYPE; + } + + @Override + public int write(ChannelBuffer cb) { + //Not required to be implemented now + return 0; + } + + @Override + public int hashCode() { + return Objects.hash(nextHop); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof NextHop) { + NextHop other = (NextHop) obj; + return Objects.equals(nextHop, other.nextHop); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("nextHop", nextHop) + .toString(); + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/Origin.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/Origin.java new file mode 100644 index 00000000..3b2070de --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/Origin.java @@ -0,0 +1,166 @@ +/* + * Copyright 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.bgpio.types; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Provides Implementation of mandatory BGP Origin path attribute. + */ +public class Origin implements BGPValueType { + private static final Logger log = LoggerFactory.getLogger(Origin.class); + + /** + * Enum to provide ORIGIN types. + */ + public enum ORIGINTYPE { + IGP(0), EGP(1), INCOMPLETE(2); + int value; + /** + * Assign val with the value as the ORIGIN type. + * + * @param val ORIGIN type + */ + ORIGINTYPE(int val) { + value = val; + } + + /** + * Returns value of ORIGIN type. + * + * @return ORIGIN type + */ + public byte getType() { + return (byte) value; + } + } + + public static final byte ORIGIN_TYPE = 1; + public static final byte ORIGIN_VALUE_LEN = 1; + public static final int TYPE_AND_LEN_AS_SHORT = 4; + public static final int TYPE_AND_LEN_AS_BYTE = 3; + + private boolean isOrigin = false; + private byte origin; + + /** + * Constructor to initialize parameters. + * + * @param origin origin value + */ + public Origin(byte origin) { + this.origin = origin; + this.isOrigin = true; + } + + /** + * Returns true if origin attribute is present otherwise false. + * + * @return whether origin is present or not + */ + public boolean isOriginSet() { + return this.isOrigin; + } + + /** + * Returns type of Origin in Enum values. + * + * @return type of Origin in Enum values + */ + public ORIGINTYPE origin() { + if (this.origin == 0) { + return ORIGINTYPE.IGP; + } else if (this.origin == 1) { + return ORIGINTYPE.EGP; + } else { + return ORIGINTYPE.INCOMPLETE; + } + } + + /** + * Reads from ChannelBuffer and parses Origin. + * + * @param cb ChannelBuffer + * @return object of Origin + * @throws BGPParseException while parsing Origin path attribute + */ + public static Origin read(ChannelBuffer cb) throws BGPParseException { + ChannelBuffer tempCb = cb.copy(); + Validation parseFlags = Validation.parseAttributeHeader(cb); + + int len = parseFlags.isShort() ? parseFlags.getLength() + TYPE_AND_LEN_AS_SHORT : parseFlags + .getLength() + TYPE_AND_LEN_AS_BYTE; + ChannelBuffer data = tempCb.readBytes(len); + if ((parseFlags.getLength() > ORIGIN_VALUE_LEN) || (cb.readableBytes() < parseFlags.getLength())) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + parseFlags.getLength()); + } + if (parseFlags.getFirstBit() && !parseFlags.getSecondBit() && parseFlags.getThirdBit()) { + throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_FLAGS_ERROR, data); + } + + byte originValue; + originValue = cb.readByte(); + if ((originValue != ORIGINTYPE.INCOMPLETE.value) || (originValue != ORIGINTYPE.IGP.value) || + (originValue != ORIGINTYPE.EGP.value)) { + throw new BGPParseException(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.INVALID_ORIGIN_ATTRIBUTE, data); + } + return new Origin(originValue); + } + + @Override + public short getType() { + return ORIGIN_TYPE; + } + + @Override + public int write(ChannelBuffer cb) { + //Not required to Implement as of now + return 0; + } + + @Override + public int hashCode() { + return Objects.hash(origin); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj instanceof Origin) { + Origin other = (Origin) obj; + return Objects.equals(origin, other.origin); + } + return false; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("origin", origin) + .toString(); + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrNodeFlagBitTlv.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrNodeFlagBitTlv.java index ba02f6d1..e7f4a4c0 100755 --- a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrNodeFlagBitTlv.java +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrNodeFlagBitTlv.java @@ -30,7 +30,7 @@ import com.google.common.base.MoreObjects; /** * Implements BGP attribute node flag. */ -public class BgpAttrNodeFlagBitTlv implements BGPValueType { +public final class BgpAttrNodeFlagBitTlv implements BGPValueType { protected static final Logger log = LoggerFactory .getLogger(BgpAttrNodeFlagBitTlv.class); @@ -38,16 +38,15 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { public static final int ATTRNODE_FLAGBIT = 1024; /* Node flag bit TLV */ - private boolean bOverloadBit; - private boolean bAttachedBit; - private boolean bExternalBit; - private boolean bABRBit; + private final boolean bOverloadBit; + private final boolean bAttachedBit; + private final boolean bExternalBit; + private final boolean bAbrBit; - public static final int BIT_SET = 1; - public static final int FIRST_BIT = 0x80; - public static final int SECOND_BIT = 0x40; - public static final int THIRD_BIT = 0x20; - public static final int FOURTH_BIT = 0x01; + public static final byte FIRST_BIT = (byte) 0x80; + public static final byte SECOND_BIT = 0x40; + public static final byte THIRD_BIT = 0x20; + public static final byte FOURTH_BIT = 0x01; /** * Constructor to initialize parameters. @@ -55,14 +54,31 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { * @param bOverloadBit Overload bit * @param bAttachedBit Attached bit * @param bExternalBit External bit - * @param bABRBit ABR Bit + * @param bAbrBit ABR Bit */ - BgpAttrNodeFlagBitTlv(boolean bOverloadBit, boolean bAttachedBit, - boolean bExternalBit, boolean bABRBit) { + private BgpAttrNodeFlagBitTlv(boolean bOverloadBit, boolean bAttachedBit, + boolean bExternalBit, boolean bAbrBit) { this.bOverloadBit = bOverloadBit; this.bAttachedBit = bAttachedBit; this.bExternalBit = bExternalBit; - this.bABRBit = bABRBit; + this.bAbrBit = bAbrBit; + } + + /** + * Returns object of this class with specified values. + * + * @param bOverloadBit Overload bit + * @param bAttachedBit Attached bit + * @param bExternalBit External bit + * @param bAbrBit ABR Bit + * @return object of BgpAttrNodeFlagBitTlv + */ + public static BgpAttrNodeFlagBitTlv of(final boolean bOverloadBit, + final boolean bAttachedBit, + final boolean bExternalBit, + final boolean bAbrBit) { + return new BgpAttrNodeFlagBitTlv(bOverloadBit, bAttachedBit, + bExternalBit, bAbrBit); } /** @@ -77,11 +93,11 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { boolean bOverloadBit = false; boolean bAttachedBit = false; boolean bExternalBit = false; - boolean bABRBit = false; + boolean bAbrBit = false; short lsAttrLength = cb.readShort(); - if (lsAttrLength != 1) { + if ((lsAttrLength != 1) || (cb.readableBytes() < lsAttrLength)) { Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, lsAttrLength); @@ -89,13 +105,13 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { byte nodeFlagBits = cb.readByte(); - bOverloadBit = ((nodeFlagBits & (byte) FIRST_BIT) == FIRST_BIT); - bAttachedBit = ((nodeFlagBits & (byte) SECOND_BIT) == SECOND_BIT); - bExternalBit = ((nodeFlagBits & (byte) THIRD_BIT) == THIRD_BIT); - bABRBit = ((nodeFlagBits & (byte) FOURTH_BIT) == FOURTH_BIT); + bOverloadBit = ((nodeFlagBits & FIRST_BIT) == FIRST_BIT); + bAttachedBit = ((nodeFlagBits & SECOND_BIT) == SECOND_BIT); + bExternalBit = ((nodeFlagBits & THIRD_BIT) == THIRD_BIT); + bAbrBit = ((nodeFlagBits & FOURTH_BIT) == FOURTH_BIT); - return new BgpAttrNodeFlagBitTlv(bOverloadBit, bAttachedBit, - bExternalBit, bABRBit); + return BgpAttrNodeFlagBitTlv.of(bOverloadBit, bAttachedBit, + bExternalBit, bAbrBit); } /** @@ -103,7 +119,7 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { * * @return Overload Bit */ - boolean getOverLoadBit() { + public boolean overLoadBit() { return bOverloadBit; } @@ -112,7 +128,7 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { * * @return Attached Bit */ - boolean getAttachedBit() { + public boolean attachedBit() { return bAttachedBit; } @@ -121,7 +137,7 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { * * @return External Bit */ - boolean getExternalBit() { + public boolean externalBit() { return bExternalBit; } @@ -130,8 +146,8 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { * * @return ABR Bit */ - boolean getABRBit() { - return bABRBit; + public boolean abrBit() { + return bAbrBit; } @Override @@ -141,13 +157,13 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { @Override public int write(ChannelBuffer cb) { - // TODO will be implementing it later + // TODO This will be implemented in the next version return 0; } @Override public int hashCode() { - return Objects.hash(bOverloadBit, bAttachedBit, bExternalBit, bABRBit); + return Objects.hash(bOverloadBit, bAttachedBit, bExternalBit, bAbrBit); } @Override @@ -161,7 +177,7 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { return Objects.equals(bOverloadBit, other.bOverloadBit) && Objects.equals(bAttachedBit, other.bAttachedBit) && Objects.equals(bExternalBit, other.bExternalBit) - && Objects.equals(bABRBit, other.bABRBit); + && Objects.equals(bAbrBit, other.bAbrBit); } return false; } @@ -171,7 +187,7 @@ public class BgpAttrNodeFlagBitTlv implements BGPValueType { return MoreObjects.toStringHelper(getClass()) .add("bOverloadBit", bOverloadBit) .add("bAttachedBit", bAttachedBit) - .add("bExternalBit", bExternalBit).add("bABRBit", bABRBit) + .add("bExternalBit", bExternalBit).add("bAbrBit", bAbrBit) .toString(); } } diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrRouterIdV4.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrRouterIdV4.java index 00dffb58..a10d167a 100755 --- a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrRouterIdV4.java +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrRouterIdV4.java @@ -31,15 +31,15 @@ import com.google.common.base.MoreObjects; /** * Implements BGP attribute node router ID. */ -public class BgpAttrRouterIdV4 implements BGPValueType { +public final class BgpAttrRouterIdV4 implements BGPValueType { protected static final Logger log = LoggerFactory .getLogger(BgpAttrRouterIdV4.class); - public short sType; + private final short sType; /* IPv4 Router-ID of Node */ - private Ip4Address ip4RouterId; + private final Ip4Address ip4RouterId; /** * Constructor to initialize the value. @@ -47,35 +47,45 @@ public class BgpAttrRouterIdV4 implements BGPValueType { * @param ip4RouterId IPV4 address of router * @param sType TLV type */ - BgpAttrRouterIdV4(Ip4Address ip4RouterId, short sType) { + private BgpAttrRouterIdV4(Ip4Address ip4RouterId, short sType) { this.ip4RouterId = ip4RouterId; this.sType = sType; } /** + * Returns object of this class with specified values. + * + * @param ip4RouterId IPv4 address + * @param sType Type of this TLV + * @return object of BgpAttrRouterIdV4 + */ + public static BgpAttrRouterIdV4 of(final Ip4Address ip4RouterId, + final short sType) { + return new BgpAttrRouterIdV4(ip4RouterId, sType); + } + + /** * Reads the IPv4 Router-ID. * * @param cb ChannelBuffer + * @param sType tag type * @return object of BgpAttrRouterIdV4 - * @throws BGPParseException while parsing BgpAttrNodeRouterId + * @throws BGPParseException while parsing BgpAttrRouterIdV4 */ public static BgpAttrRouterIdV4 read(ChannelBuffer cb, short sType) throws BGPParseException { - byte[] ipBytes; - Ip4Address ip4RouterId; - short lsAttrLength = cb.readShort(); - if (4 != lsAttrLength) { + if ((lsAttrLength != 4) || (cb.readableBytes() < lsAttrLength)) { Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, lsAttrLength); } - ipBytes = new byte[lsAttrLength]; - cb.readBytes(ipBytes); - ip4RouterId = Ip4Address.valueOf(ipBytes); - return new BgpAttrRouterIdV4(ip4RouterId, sType); + byte[] ipBytes = new byte[lsAttrLength]; + cb.readBytes(ipBytes, 0, lsAttrLength); + Ip4Address ip4RouterId = Ip4Address.valueOf(ipBytes); + return BgpAttrRouterIdV4.of(ip4RouterId, sType); } /** @@ -83,7 +93,7 @@ public class BgpAttrRouterIdV4 implements BGPValueType { * * @return Router ID */ - Ip4Address getAttrRouterId() { + public Ip4Address attrRouterId() { return ip4RouterId; } @@ -112,7 +122,7 @@ public class BgpAttrRouterIdV4 implements BGPValueType { @Override public int write(ChannelBuffer cb) { - // TODO Auto-generated method stub + // TODO This will be implemented in the next version return 0; } diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrRouterIdV6.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrRouterIdV6.java index 561c3d4c..ea63c379 100755 --- a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrRouterIdV6.java +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpAttrRouterIdV6.java @@ -31,15 +31,15 @@ import com.google.common.base.MoreObjects; /** * Implements BGP attribute IPv6 router ID. */ -public class BgpAttrRouterIdV6 implements BGPValueType { +public final class BgpAttrRouterIdV6 implements BGPValueType { protected static final Logger log = LoggerFactory .getLogger(BgpAttrRouterIdV6.class); - public short sType; + private final short sType; /* IPv4 Router-ID of Node */ - private Ip6Address ip6RouterId; + private final Ip6Address ip6RouterId; /** * Constructor to initialize the value. @@ -47,15 +47,28 @@ public class BgpAttrRouterIdV6 implements BGPValueType { * @param ip6RouterId IPV6 address of the router ID * @param sType TLV type */ - BgpAttrRouterIdV6(Ip6Address ip6RouterId, short sType) { + private BgpAttrRouterIdV6(Ip6Address ip6RouterId, short sType) { this.ip6RouterId = ip6RouterId; this.sType = sType; } /** + * Returns object of this class with specified values. + * + * @param ip6RouterId IPV6 address of the router ID + * @param sType TLV type + * @return object of BgpAttrRouterIdV6 + */ + public static BgpAttrRouterIdV6 of(final Ip6Address ip6RouterId, + final short sType) { + return new BgpAttrRouterIdV6(ip6RouterId, sType); + } + + /** * Reads the IPv6 Router-ID. * * @param cb ChannelBuffer + * @param sType TLV type * @return object of BgpAttrRouterIdV6 * @throws BGPParseException while parsing BgpAttrRouterIdV6 */ @@ -66,7 +79,7 @@ public class BgpAttrRouterIdV6 implements BGPValueType { short lsAttrLength = cb.readShort(); - if (16 != lsAttrLength) { + if ((lsAttrLength != 16) || (cb.readableBytes() < lsAttrLength)) { Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, BGPErrorType.ATTRIBUTE_LENGTH_ERROR, lsAttrLength); @@ -75,7 +88,7 @@ public class BgpAttrRouterIdV6 implements BGPValueType { ipBytes = new byte[lsAttrLength]; cb.readBytes(ipBytes); ip6RouterId = Ip6Address.valueOf(ipBytes); - return new BgpAttrRouterIdV6(ip6RouterId, sType); + return BgpAttrRouterIdV6.of(ip6RouterId, sType); } /** @@ -83,7 +96,7 @@ public class BgpAttrRouterIdV6 implements BGPValueType { * * @return Router ID */ - Ip6Address getAttrRouterId() { + public Ip6Address attrRouterId() { return ip6RouterId; } @@ -112,7 +125,7 @@ public class BgpAttrRouterIdV6 implements BGPValueType { @Override public int write(ChannelBuffer cb) { - // TODO Auto-generated method stub + // TODO This will be implemented in the next version return 0; } diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrIgpMetric.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrIgpMetric.java new file mode 100755 index 00000000..c1cb299c --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrIgpMetric.java @@ -0,0 +1,172 @@ +/* + * Copyright 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.bgpio.types.attr; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.types.BGPErrorType; +import org.onosproject.bgpio.types.BGPValueType; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Implements BGP link IGP metric attribute. + */ +public class BgpLinkAttrIgpMetric implements BGPValueType { + + protected static final Logger log = LoggerFactory + .getLogger(BgpLinkAttrIgpMetric.class); + + public static final int ATTRLINK_IGPMETRIC = 1095; + public static final int ATTRLINK_MAX_LEN = 3; + + /* Variable metric length based on protocol */ + public static final int ISIS_SMALL_METRIC = 1; + public static final int OSPF_LINK_METRIC = 2; + public static final int ISIS_WIDE_METRIC = 3; + + /* IGP Metric */ + private final int igpMetric; + private final int igpMetricLen; + + /** + * Constructor to initialize the value. + * + * @param igpMetric 3 byte IGP metric data. + * @param igpMetricLen length of IGP metric data. + */ + public BgpLinkAttrIgpMetric(final int igpMetric, final int igpMetricLen) { + this.igpMetric = igpMetric; + this.igpMetricLen = igpMetricLen; + } + + /** + * Returns object of this class with specified values. + * + * @param igpMetric 3 byte IGP metric data. + * @param igpMetricLen length of IGP metric data. + * @return object of BgpLinkAttrIgpMetric + */ + public static BgpLinkAttrIgpMetric of(final int igpMetric, + final int igpMetricLen) { + return new BgpLinkAttrIgpMetric(igpMetric, igpMetricLen); + } + + /** + * Reads the BGP link attributes IGP Metric. + * + * @param cb Channel buffer + * @return object of type BgpLinkAttrIgpMetric + * @throws BGPParseException while parsing BgpLinkAttrIgpMetric + */ + public static BgpLinkAttrIgpMetric read(ChannelBuffer cb) + throws BGPParseException { + + short linkigp; + int igpMetric = 0; + int igpMetricLen = 0; + + short lsAttrLength = cb.readShort(); + + if (cb.readableBytes() < lsAttrLength + || lsAttrLength > ATTRLINK_MAX_LEN) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + lsAttrLength); + } + + switch (lsAttrLength) { + case ISIS_SMALL_METRIC: + igpMetric = cb.readByte(); + igpMetricLen = ISIS_SMALL_METRIC; + break; + case OSPF_LINK_METRIC: + igpMetric = cb.readShort(); + igpMetricLen = OSPF_LINK_METRIC; + break; + case ISIS_WIDE_METRIC: + linkigp = cb.readShort(); + igpMetric = cb.readByte(); + igpMetric = (igpMetric << 16) | linkigp; + igpMetricLen = ISIS_WIDE_METRIC; + break; + default: // validation is already in place + break; + } + + return BgpLinkAttrIgpMetric.of(igpMetric, igpMetricLen); + } + + /** + * Returns the variable length IGP metric data. + * + * @return IGP metric data + */ + public int attrLinkIgpMetric() { + return igpMetric; + } + + /** + * Returns IGP metric data length. + * + * @return IGP metric length + */ + public int attrLinkIgpMetricLength() { + return igpMetricLen; + } + + @Override + public short getType() { + return ATTRLINK_IGPMETRIC; + } + + @Override + public int hashCode() { + return Objects.hash(igpMetric, igpMetricLen); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + + if (obj instanceof BgpLinkAttrIgpMetric) { + BgpLinkAttrIgpMetric other = (BgpLinkAttrIgpMetric) obj; + return Objects.equals(igpMetric, other.igpMetric) + && Objects.equals(igpMetricLen, other.igpMetricLen); + } + return false; + } + + @Override + public int write(ChannelBuffer cb) { + // TODO This will be implemented in the next version + return 0; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("igpMetric", igpMetric).add("igpMetricLen", igpMetricLen) + .toString(); + } +} diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrMplsProtocolMask.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrMplsProtocolMask.java new file mode 100755 index 00000000..61143fae --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrMplsProtocolMask.java @@ -0,0 +1,152 @@ +/* + * Copyright 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.bgpio.types.attr; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.types.BGPErrorType; +import org.onosproject.bgpio.types.BGPValueType; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Implements BGP MPLS protocol mask attribute. + */ +public class BgpLinkAttrMplsProtocolMask implements BGPValueType { + + protected static final Logger log = LoggerFactory + .getLogger(BgpLinkAttrMplsProtocolMask.class); + + public static final int ATTRLINK_MPLSPROTOMASK = 1094; + public static final int MASK_BYTE_LEN = 1; + + private final boolean bLdp; + private final boolean bRsvpTe; + + public static final byte FIRST_BIT = (byte) 0x80; + public static final byte SECOND_BIT = 0x40; + + /** + * Constructor to initialize the values. + * + * @param bLdp boolean value true if LDP flag is available + * @param bRsvpTe boolean value true if RSVP TE information is available + */ + public BgpLinkAttrMplsProtocolMask(boolean bLdp, boolean bRsvpTe) { + this.bLdp = bLdp; + this.bRsvpTe = bRsvpTe; + } + + /** + * Returns object of this class with specified values. + * + * @param bLdp boolean value true if LDP flag is available + * @param bRsvpTe boolean value true if RSVP TE information is available + * @return object of BgpLinkAttrMplsProtocolMask + */ + public static BgpLinkAttrMplsProtocolMask of(final boolean bLdp, + final boolean bRsvpTe) { + return new BgpLinkAttrMplsProtocolMask(bLdp, bRsvpTe); + } + + /** + * Reads the BGP link attributes MPLS protocol mask. + * + * @param cb Channel buffer + * @return object of type BgpLinkAttrMPLSProtocolMask + * @throws BGPParseException while parsing BgpLinkAttrMplsProtocolMask + */ + public static BgpLinkAttrMplsProtocolMask read(ChannelBuffer cb) + throws BGPParseException { + boolean bLdp = false; + boolean bRsvpTe = false; + + short lsAttrLength = cb.readShort(); + + if ((lsAttrLength != MASK_BYTE_LEN) + || (cb.readableBytes() < lsAttrLength)) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + lsAttrLength); + } + + byte flags = cb.readByte(); + + bLdp = ((flags & (byte) FIRST_BIT) == FIRST_BIT); + bRsvpTe = ((flags & (byte) SECOND_BIT) == SECOND_BIT); + + return BgpLinkAttrMplsProtocolMask.of(bLdp, bRsvpTe); + } + + /** + * Returns true if LDP bit is set. + * + * @return True if LDP information is set else false. + */ + public boolean ldpBit() { + return bLdp; + } + + /** + * Returns RSVP TE information. + * + * @return True if RSVP TE information is set else false. + */ + public boolean rsvpBit() { + return bRsvpTe; + } + + @Override + public short getType() { + return ATTRLINK_MPLSPROTOMASK; + } + + @Override + public int hashCode() { + return Objects.hash(bLdp, bRsvpTe); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + + if (obj instanceof BgpLinkAttrMplsProtocolMask) { + BgpLinkAttrMplsProtocolMask other = (BgpLinkAttrMplsProtocolMask) obj; + return Objects.equals(bLdp, other.bLdp) + && Objects.equals(bRsvpTe, other.bRsvpTe); + } + return false; + } + + @Override + public int write(ChannelBuffer cb) { + // TODO This will be implemented in the next version + return 0; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("bLdp", bLdp).add("bRsvpTe", bRsvpTe).toString(); + } +} diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrProtectionType.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrProtectionType.java new file mode 100755 index 00000000..b45d95b8 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpLinkAttrProtectionType.java @@ -0,0 +1,240 @@ +/* + * Copyright 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.bgpio.types.attr; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.types.BGPErrorType; +import org.onosproject.bgpio.types.BGPValueType; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Implements BGP link protection type attribute. + */ +public final class BgpLinkAttrProtectionType implements BGPValueType { + + protected static final Logger log = LoggerFactory + .getLogger(BgpLinkAttrProtectionType.class); + + public static final int ATTRLINK_PROTECTIONTYPE = 1093; + public static final int LINK_PROTECTION_LEN = 2; + + public static final int EXTRA_TRAFFIC = 0x01; + public static final int UNPROTECTED = 0x02; + public static final int SHARED = 0x04; + public static final int DEDICATED_ONE_ISTO_ONE = 0x08; + public static final int DEDICATED_ONE_PLUS_ONE = 0x10; + public static final int ENHANCED = 0x20; + + /* Link Protection type flags */ + private final boolean bExtraTraffic; + private final boolean bUnprotected; + private final boolean bShared; + private final boolean bDedOneIstoOne; + private final boolean bDedOnePlusOne; + private final boolean bEnhanced; + + /** + * Constructor to initialize the value. + * + * @param bExtraTraffic Extra Traffic + * @param bUnprotected Unprotected + * @param bShared Shared + * @param bDedOneIstoOne Dedicated 1:1 + * @param bDedOnePlusOne Dedicated 1+1 + * @param bEnhanced Enhanced + */ + private BgpLinkAttrProtectionType(boolean bExtraTraffic, + boolean bUnprotected, + boolean bShared, boolean bDedOneIstoOne, + boolean bDedOnePlusOne, boolean bEnhanced) { + this.bExtraTraffic = bExtraTraffic; + this.bUnprotected = bUnprotected; + this.bShared = bShared; + this.bDedOneIstoOne = bDedOneIstoOne; + this.bDedOnePlusOne = bDedOnePlusOne; + this.bEnhanced = bEnhanced; + } + + /** + * Returns object of this class with specified values. + * + * @param bExtraTraffic Extra Traffic + * @param bUnprotected Unprotected + * @param bShared Shared + * @param bDedOneIstoOne Dedicated 1:1 + * @param bDedOnePlusOne Dedicated 1+1 + * @param bEnhanced Enhanced + * @return object of BgpLinkAttrProtectionType + */ + public static BgpLinkAttrProtectionType of(boolean bExtraTraffic, + boolean bUnprotected, + boolean bShared, + boolean bDedOneIstoOne, + boolean bDedOnePlusOne, + boolean bEnhanced) { + return new BgpLinkAttrProtectionType(bExtraTraffic, bUnprotected, + bShared, bDedOneIstoOne, + bDedOnePlusOne, bEnhanced); + } + + /** + * Reads the BGP link attributes protection type. + * + * @param cb Channel buffer + * @return object of type BgpLinkAttrProtectionType + * @throws BGPParseException while parsing BgpLinkAttrProtectionType + */ + public static BgpLinkAttrProtectionType read(ChannelBuffer cb) + throws BGPParseException { + short linkProtectionType; + byte higherByte; + short lsAttrLength = cb.readShort(); + + boolean bExtraTraffic; + boolean bUnprotected; + boolean bShared; + boolean bDedOneIstoOne; + boolean bDedOnePlusOne; + boolean bEnhanced; + + if ((lsAttrLength != LINK_PROTECTION_LEN) + || (cb.readableBytes() < lsAttrLength)) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + lsAttrLength); + } + + linkProtectionType = cb.readShort(); + higherByte = (byte) (linkProtectionType >> 8); + + bExtraTraffic = ((higherByte & (byte) EXTRA_TRAFFIC) == EXTRA_TRAFFIC); + bUnprotected = ((higherByte & (byte) UNPROTECTED) == UNPROTECTED); + bShared = ((higherByte & (byte) SHARED) == SHARED); + bDedOneIstoOne = ((higherByte & (byte) DEDICATED_ONE_ISTO_ONE) == DEDICATED_ONE_ISTO_ONE); + bDedOnePlusOne = ((higherByte & (byte) DEDICATED_ONE_PLUS_ONE) == DEDICATED_ONE_PLUS_ONE); + bEnhanced = ((higherByte & (byte) ENHANCED) == ENHANCED); + + return BgpLinkAttrProtectionType.of(bExtraTraffic, bUnprotected, + bShared, bDedOneIstoOne, + bDedOnePlusOne, bEnhanced); + } + + /** + * Returns ExtraTraffic Bit. + * + * @return ExtraTraffic Bit + */ + public boolean extraTraffic() { + return bExtraTraffic; + } + + /** + * Returns Unprotected Bit. + * + * @return Unprotected Bit + */ + public boolean unprotected() { + return bUnprotected; + } + + /** + * Returns Shared Bit. + * + * @return Shared Bit + */ + public boolean shared() { + return bShared; + } + + /** + * Returns DedOneIstoOne Bit. + * + * @return DedOneIstoOne Bit + */ + public boolean dedOneIstoOne() { + return bDedOneIstoOne; + } + + /** + * Returns DedOnePlusOne Bit. + * + * @return DedOnePlusOne Bit + */ + public boolean dedOnePlusOne() { + return bDedOnePlusOne; + } + + /** + * Returns Enhanced Bit. + * + * @return Enhanced Bit + */ + public boolean enhanced() { + return bEnhanced; + } + + @Override + public short getType() { + return ATTRLINK_PROTECTIONTYPE; + } + + @Override + public int hashCode() { + return Objects.hash(bExtraTraffic, bUnprotected, bShared, + bDedOneIstoOne, bDedOnePlusOne, bEnhanced); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + + if (obj instanceof BgpLinkAttrProtectionType) { + BgpLinkAttrProtectionType other = (BgpLinkAttrProtectionType) obj; + return Objects.equals(bExtraTraffic, other.bExtraTraffic) + && Objects.equals(bUnprotected, other.bUnprotected) + && Objects.equals(bShared, other.bShared) + && Objects.equals(bDedOneIstoOne, other.bDedOneIstoOne) + && Objects.equals(bDedOnePlusOne, other.bDedOnePlusOne) + && Objects.equals(bEnhanced, other.bEnhanced); + } + return false; + } + + @Override + public int write(ChannelBuffer cb) { + // TODO This will be implemented in the next version + return 0; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("bExtraTraffic", bExtraTraffic) + .add("bUnprotected", bUnprotected).add("bShared", bShared) + .add("bDedOneIstoOne", bDedOneIstoOne) + .add("bDedOnePlusOne", bDedOnePlusOne) + .add("bEnhanced", bEnhanced).toString(); + } +} diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpPrefixAttrMetric.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpPrefixAttrMetric.java new file mode 100755 index 00000000..0678b81f --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpPrefixAttrMetric.java @@ -0,0 +1,131 @@ +/* + * Copyright 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.bgpio.types.attr; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.types.BGPErrorType; +import org.onosproject.bgpio.types.BGPValueType; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Implements BGP prefix metric attribute. + */ +public class BgpPrefixAttrMetric implements BGPValueType { + + protected static final Logger log = LoggerFactory + .getLogger(BgpPrefixAttrMetric.class); + + public static final int ATTR_PREFIX_METRIC = 1155; + public static final int ATTR_PREFIX_LEN = 4; + + /* TE Default Metric */ + private final int linkPfxMetric; + + /** + * Constructor to initialize value. + * + * @param linkPfxMetric Prefix Metric + */ + public BgpPrefixAttrMetric(int linkPfxMetric) { + this.linkPfxMetric = linkPfxMetric; + } + + /** + * Returns object of this class with specified values. + * + * @param linkPfxMetric Prefix Metric + * @return object of BgpPrefixAttrMetric + */ + public static BgpPrefixAttrMetric of(final int linkPfxMetric) { + return new BgpPrefixAttrMetric(linkPfxMetric); + } + + /** + * Reads the Prefix Metric. + * + * @param cb ChannelBuffer + * @return object of BgpPrefixAttrMetric + * @throws BGPParseException while parsing BgpPrefixAttrMetric + */ + public static BgpPrefixAttrMetric read(ChannelBuffer cb) + throws BGPParseException { + int linkPfxMetric; + + short lsAttrLength = cb.readShort(); // 4 Bytes + + if ((lsAttrLength != ATTR_PREFIX_LEN) + || (cb.readableBytes() < lsAttrLength)) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + lsAttrLength); + } + + linkPfxMetric = cb.readInt(); + + return BgpPrefixAttrMetric.of(linkPfxMetric); + } + + /** + * Returns the Prefix Metric. + * + * @return Prefix Metric + */ + public int attrPfxMetric() { + return linkPfxMetric; + } + + @Override + public short getType() { + return ATTR_PREFIX_METRIC; + } + + @Override + public int hashCode() { + return Objects.hash(linkPfxMetric); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + + if (obj instanceof BgpPrefixAttrMetric) { + BgpPrefixAttrMetric other = (BgpPrefixAttrMetric) obj; + return Objects.equals(linkPfxMetric, other.linkPfxMetric); + } + return false; + } + + @Override + public int write(ChannelBuffer cb) { + // TODO This will be implemented in the next version + return 0; + } + + @Override + public String toString() { + return MoreObjects.toStringHelper(getClass()) + .add("linkPfxMetric", linkPfxMetric).toString(); + } +} diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpPrefixAttrOspfFwdAddr.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpPrefixAttrOspfFwdAddr.java new file mode 100755 index 00000000..cf043046 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/types/attr/BgpPrefixAttrOspfFwdAddr.java @@ -0,0 +1,187 @@ +/* + * Copyright 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.bgpio.types.attr; + +import java.util.Objects; + +import org.jboss.netty.buffer.ChannelBuffer; +import org.onlab.packet.Ip4Address; +import org.onlab.packet.Ip6Address; +import org.onosproject.bgpio.exceptions.BGPParseException; +import org.onosproject.bgpio.types.BGPErrorType; +import org.onosproject.bgpio.types.BGPValueType; +import org.onosproject.bgpio.util.Validation; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.base.MoreObjects; + +/** + * Implements BGP prefix OSPF Forwarding address attribute. + */ +public class BgpPrefixAttrOspfFwdAddr implements BGPValueType { + + protected static final Logger log = LoggerFactory + .getLogger(BgpPrefixAttrOspfFwdAddr.class); + + public static final int ATTR_PREFIX_OSPFFWDADDR = 1156; + public static final int IPV4_LEN = 4; + public static final int IPV6_LEN = 16; + + /* OSPF Forwarding Address */ + private final short lsAttrLength; + private final Ip4Address ip4RouterId; + private final Ip6Address ip6RouterId; + + /** + * Constructor to initialize the value. + * + * @param lsAttrLength length of the IP address + * @param ip4RouterId Valid IPV4 address if length is 4 else null + * @param ip6RouterId Valid IPV6 address if length is 16 else null + */ + public BgpPrefixAttrOspfFwdAddr(short lsAttrLength, Ip4Address ip4RouterId, + Ip6Address ip6RouterId) { + this.lsAttrLength = lsAttrLength; + this.ip4RouterId = ip4RouterId; + this.ip6RouterId = ip6RouterId; + } + + /** + * Returns object of this class with specified values. + * + * @param lsAttrLength length of the IP address + * @param ip4RouterId Valid IPV4 address if length is 4 else null + * @param ip6RouterId Valid IPV6 address if length is 16 else null + * @return object of BgpPrefixAttrOspfFwdAddr + */ + public static BgpPrefixAttrOspfFwdAddr of(final short lsAttrLength, + final Ip4Address ip4RouterId, + final Ip6Address ip6RouterId) { + return new BgpPrefixAttrOspfFwdAddr(lsAttrLength, ip4RouterId, + ip6RouterId); + } + + /** + * Reads the OSPF Forwarding Address. + * + * @param cb ChannelBuffer + * @return object of BgpPrefixAttrOSPFFwdAddr + * @throws BGPParseException while parsing BgpPrefixAttrOspfFwdAddr + */ + public static BgpPrefixAttrOspfFwdAddr read(ChannelBuffer cb) + throws BGPParseException { + short lsAttrLength; + byte[] ipBytes; + Ip4Address ip4RouterId = null; + Ip6Address ip6RouterId = null; + + lsAttrLength = cb.readShort(); + ipBytes = new byte[lsAttrLength]; + + if ((cb.readableBytes() < lsAttrLength)) { + Validation.validateLen(BGPErrorType.UPDATE_MESSAGE_ERROR, + BGPErrorType.ATTRIBUTE_LENGTH_ERROR, + lsAttrLength); + } + + cb.readBytes(ipBytes); + + if (IPV4_LEN == lsAttrLength) { + ip4RouterId = Ip4Address.valueOf(ipBytes); + } else if (IPV6_LEN == lsAttrLength) { + ip6RouterId = Ip6Address.valueOf(ipBytes); + } + + return BgpPrefixAttrOspfFwdAddr.of(lsAttrLength, ip4RouterId, + ip6RouterId); + } + + /** + * Returns IPV4 Address of OSPF forwarding address. + * + * @return IPV4 address + */ + public Ip4Address ospfv4FwdAddr() { + return ip4RouterId; + } + + /** + * Returns IPV6 Address of OSPF forwarding address. + * + * @return IPV6 address + */ + public Ip6Address ospfv6FwdAddr() { + return ip6RouterId; + } + + /** + * Returns OSPF forwarding address length. + * + * @return length of the ip address + */ + public short ospfFwdAddrLen() { + return lsAttrLength; + } + + @Override + public short getType() { + return ATTR_PREFIX_OSPFFWDADDR; + } + + @Override + public int hashCode() { + if (IPV4_LEN == lsAttrLength) { + return Objects.hash(ip4RouterId); + } else { + return Objects.hash(ip6RouterId); + } + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + + if (obj instanceof BgpPrefixAttrOspfFwdAddr) { + BgpPrefixAttrOspfFwdAddr other = (BgpPrefixAttrOspfFwdAddr) obj; + if (IPV4_LEN == lsAttrLength) { + return Objects.equals(ip4RouterId, other.ip4RouterId); + } else { + return Objects.equals(ip6RouterId, other.ip6RouterId); + } + } + return false; + } + + @Override + public int write(ChannelBuffer cb) { + // TODO This will be implemented in the next version + return 0; + } + + @Override + public String toString() { + if (IPV4_LEN == lsAttrLength) { + return MoreObjects.toStringHelper(getClass()).omitNullValues() + .add("ip4RouterId", ip4RouterId).toString(); + } else { + return MoreObjects.toStringHelper(getClass()).omitNullValues() + .add("ip6RouterId", ip6RouterId).toString(); + } + } +} diff --git a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/util/Validation.java b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/util/Validation.java index 915aa580..bc131893 100644 --- a/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/util/Validation.java +++ b/framework/src/onos/bgp/bgpio/src/main/java/org/onosproject/bgpio/util/Validation.java @@ -16,6 +16,8 @@ package org.onosproject.bgpio.util; +import java.net.InetAddress; +import java.net.UnknownHostException; import java.util.Arrays; import org.jboss.netty.buffer.ChannelBuffer; @@ -23,6 +25,8 @@ import org.jboss.netty.buffer.ChannelBuffers; import org.onlab.packet.IpAddress; import org.onlab.packet.IpPrefix; import org.onosproject.bgpio.exceptions.BGPParseException; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import com.google.common.primitives.Ints; @@ -30,10 +34,11 @@ import com.google.common.primitives.Ints; * Provides methods to parse attribute header, validate length and type. */ public class Validation { + private static final Logger log = LoggerFactory.getLogger(Validation.class); public static final byte FIRST_BIT = (byte) 0x80; public static final byte SECOND_BIT = 0x40; public static final byte THIRD_BIT = 0x20; - public static final byte FOURTH_BIT = 0x01; + public static final byte FOURTH_BIT = (byte) 0x10; public static final byte IPV4_SIZE = 4; private boolean firstBit; private boolean secondBit; @@ -42,6 +47,16 @@ public class Validation { private int len; private boolean isShort; + /** + * Constructor to initialize parameter. + * + * @param firstBit in AttributeFlags + * @param secondBit in AttributeFlags + * @param thirdBit in AttributeFlags + * @param fourthBit in AttributeFlags + * @param len length + * @param isShort true if length is read as short otherwise false + */ Validation(boolean firstBit, boolean secondBit, boolean thirdBit, boolean fourthBit, int len, boolean isShort) { this.firstBit = firstBit; this.secondBit = secondBit; @@ -119,6 +134,25 @@ public class Validation { } /** + * Convert byte array to InetAddress. + * + * @param length of IpAddress + * @param cb channelBuffer + * @return InetAddress + */ + public static InetAddress toInetAddress(int length, ChannelBuffer cb) { + byte[] address = new byte[length]; + cb.readBytes(address, 0, length); + InetAddress ipAddress = null; + try { + ipAddress = InetAddress.getByAddress(address); + } catch (UnknownHostException e) { + log.info("InetAddress convertion failed"); + } + return ipAddress; + } + + /** * Returns first bit in type flags. * * @return first bit in type flags diff --git a/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpAttrNodeFlagBitTlvTest.java b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpAttrNodeFlagBitTlvTest.java new file mode 100644 index 00000000..5f1411ff --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpAttrNodeFlagBitTlvTest.java @@ -0,0 +1,51 @@ +/* + * Copyright 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.junit.Test; +import org.onosproject.bgpio.types.attr.BgpAttrNodeFlagBitTlv; + +import com.google.common.testing.EqualsTester; + +/** + * Test for BGP attribute node flag. + */ +public class BgpAttrNodeFlagBitTlvTest { + + private final boolean bOverloadBit = true; + private final boolean bAttachedBit = true; + private final boolean bExternalBit = true; + private final boolean bABRBit = true; + + private final boolean bOverloadBit1 = false; + private final boolean bAttachedBit1 = false; + private final boolean bExternalBit1 = false; + private final boolean bABRBit1 = false; + + private final BgpAttrNodeFlagBitTlv data = BgpAttrNodeFlagBitTlv + .of(bOverloadBit, bAttachedBit, bExternalBit, bABRBit); + private final BgpAttrNodeFlagBitTlv sameAsData = BgpAttrNodeFlagBitTlv + .of(bOverloadBit, bAttachedBit, bExternalBit, bABRBit); + private final BgpAttrNodeFlagBitTlv diffData = BgpAttrNodeFlagBitTlv + .of(bOverloadBit1, bAttachedBit1, bExternalBit1, bABRBit1); + + @Test + public void basics() { + + new EqualsTester().addEqualityGroup(data, sameAsData) + .addEqualityGroup(diffData).testEquals(); + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpAttrRouterIdV6Test.java b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpAttrRouterIdV6Test.java new file mode 100644 index 00000000..72ca5dbf --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpAttrRouterIdV6Test.java @@ -0,0 +1,50 @@ +/* + * Copyright 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.junit.Test; +import org.onlab.packet.Ip6Address; +import org.onosproject.bgpio.types.attr.BgpAttrRouterIdV6; + +import com.google.common.testing.EqualsTester; + +/** + * Test for BGP attribute node router ID. + */ +public class BgpAttrRouterIdV6Test { + + private final short sType = 1; + private final Ip6Address ip6RouterId = Ip6Address + .valueOf("2001:0db8:0a0b:12f0:0000:0000:0000:0001"); + + private final short sType1 = 2; + private final Ip6Address ip6RouterId1 = Ip6Address + .valueOf("2004:0db8:0a0b:12f0:0000:0000:0000:0004"); + + private final BgpAttrRouterIdV6 data = BgpAttrRouterIdV6.of(ip6RouterId, + sType); + private final BgpAttrRouterIdV6 sameAsData = BgpAttrRouterIdV6 + .of(ip6RouterId, sType); + private final BgpAttrRouterIdV6 diffData = BgpAttrRouterIdV6 + .of(ip6RouterId1, sType1); + + @Test + public void basics() { + + new EqualsTester().addEqualityGroup(data, sameAsData) + .addEqualityGroup(diffData).testEquals(); + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpLinkAttrIgpMetricTest.java b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpLinkAttrIgpMetricTest.java new file mode 100644 index 00000000..32280a79 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpLinkAttrIgpMetricTest.java @@ -0,0 +1,44 @@ +/* + * Copyright 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.junit.Test; +import org.onosproject.bgpio.types.attr.BgpLinkAttrIgpMetric; + +import com.google.common.testing.EqualsTester; + +/** + * Test for BGP link IGP metric attribute. + */ +public class BgpLinkAttrIgpMetricTest { + private final int val = 0x010203; + private final int valLen = 3; + private final int val1 = 0x01020304; + private final int val1Len = 4; + + private final BgpLinkAttrIgpMetric data = BgpLinkAttrIgpMetric.of(val, + valLen); + private final BgpLinkAttrIgpMetric sameAsData = BgpLinkAttrIgpMetric + .of(val, valLen); + private final BgpLinkAttrIgpMetric diffData = BgpLinkAttrIgpMetric + .of(val1, val1Len); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(data, sameAsData) + .addEqualityGroup(diffData).testEquals(); + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpLinkAttrProtectionTypeTest.java b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpLinkAttrProtectionTypeTest.java new file mode 100644 index 00000000..89f97a83 --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpLinkAttrProtectionTypeTest.java @@ -0,0 +1,57 @@ +/* + * Copyright 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.junit.Test; +import org.onosproject.bgpio.types.attr.BgpLinkAttrProtectionType; + +import com.google.common.testing.EqualsTester; + +/** + * Test for MPLS protocol mask attribute. + */ +public class BgpLinkAttrProtectionTypeTest { + boolean bExtraTraffic = true; + boolean bUnprotected = true; + boolean bShared = true; + boolean bDedOneIstoOne = true; + boolean bDedOnePlusOne = true; + boolean bEnhanced = true; + + boolean bExtraTraffic1 = false; + boolean bUnprotected1 = false; + boolean bShared1 = false; + boolean bDedOneIstoOne1 = false; + boolean bDedOnePlusOne1 = false; + boolean bEnhanced1 = false; + + private final BgpLinkAttrProtectionType data = BgpLinkAttrProtectionType + .of(bExtraTraffic, bUnprotected, bShared, bDedOneIstoOne, + bDedOnePlusOne, bEnhanced); + private final BgpLinkAttrProtectionType sameAsData = BgpLinkAttrProtectionType + .of(bExtraTraffic, bUnprotected, bShared, bDedOneIstoOne, + bDedOnePlusOne, bEnhanced); + private final BgpLinkAttrProtectionType diffData = BgpLinkAttrProtectionType + .of(bExtraTraffic1, bUnprotected1, bShared1, bDedOneIstoOne1, + bDedOnePlusOne1, bEnhanced1); + + @Test + public void basics() { + + new EqualsTester().addEqualityGroup(data, sameAsData) + .addEqualityGroup(diffData).testEquals(); + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpPrefixAttrOspfFwdAddrTest.java b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpPrefixAttrOspfFwdAddrTest.java new file mode 100644 index 00000000..f736bead --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/BgpPrefixAttrOspfFwdAddrTest.java @@ -0,0 +1,52 @@ +/* + * Copyright 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.junit.Test; +import org.onlab.packet.Ip4Address; +import org.onlab.packet.Ip6Address; +import org.onosproject.bgpio.types.attr.BgpPrefixAttrOspfFwdAddr; + +import com.google.common.testing.EqualsTester; + +/** + * Test for BGP prefix metric attribute. + */ +public class BgpPrefixAttrOspfFwdAddrTest { + + private final short lsAttrLength = 4; + private final Ip4Address ip4RouterId = Ip4Address.valueOf("192.168.1.1"); + private final Ip6Address ip6RouterId = Ip6Address + .valueOf("2001:0db8:0a0b:12f0:0000:0000:0000:0001"); + + private final short lsAttrLength1 = 16; + private final Ip4Address ip4RouterId1 = Ip4Address.valueOf("192.168.1.2"); + private final Ip6Address ip6RouterId1 = Ip6Address + .valueOf("1002:0db8:0a0b:12f0:0000:0000:0000:0002"); + + private final BgpPrefixAttrOspfFwdAddr data = BgpPrefixAttrOspfFwdAddr + .of(lsAttrLength, ip4RouterId, ip6RouterId); + private final BgpPrefixAttrOspfFwdAddr sameAsData = BgpPrefixAttrOspfFwdAddr + .of(lsAttrLength, ip4RouterId, ip6RouterId); + private final BgpPrefixAttrOspfFwdAddr diffData = BgpPrefixAttrOspfFwdAddr + .of(lsAttrLength1, ip4RouterId1, ip6RouterId1); + + @Test + public void basics() { + new EqualsTester().addEqualityGroup(data, sameAsData) + .addEqualityGroup(diffData).testEquals(); + } +}
\ No newline at end of file diff --git a/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/NextHopTest.java b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/NextHopTest.java new file mode 100755 index 00000000..109197bb --- /dev/null +++ b/framework/src/onos/bgp/bgpio/src/test/java/org/onosproject/bgp/NextHopTest.java @@ -0,0 +1,41 @@ +/* + * Copyright 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.junit.Test; +import org.onlab.packet.Ip4Address; +import org.onosproject.bgpio.types.NextHop; + +import com.google.common.testing.EqualsTester; + +/** + * Test for NextHop BGP Path Attribute. + */ +public class NextHopTest { + private final Ip4Address value1 = Ip4Address.valueOf("12.12.12.12"); + private final Ip4Address value2 = Ip4Address.valueOf("12.12.12.13"); + private final NextHop attr1 = new NextHop(value1); + private final NextHop sameAsAttr1 = new NextHop(value1); + private final NextHop attr2 = new NextHop(value2); + + @Test + public void basics() { + new EqualsTester() + .addEqualityGroup(attr1, sameAsAttr1) + .addEqualityGroup(attr2) + .testEquals(); + } +}
\ No newline at end of file |