홍길동 / onos

Go to a project
Toggle navigation Toggle navigation pinning
Priyanka B
Committed by Gerrit Code Review
85843956 1 parent 95bd85e9

[Emu] [ONOS-2601] Implement BGP Update protocol message and parse all basic path attributes. 

Change-Id: I85f912eeebacf46d699fdcf5549e06bae702823e
Inline Side-by-side
Showing 6 changed files with 922 additions and 0 deletions
/*
* 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
/*
* 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
/*
* 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
/*
* 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
/*
* 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
/*
* 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