| /* |
| * 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.pcepio.protocol.ver1; |
| |
| import java.util.LinkedList; |
| import java.util.ListIterator; |
| |
| import org.jboss.netty.buffer.ChannelBuffer; |
| import org.onosproject.pcepio.exceptions.PcepParseException; |
| import org.onosproject.pcepio.protocol.PcepTEObject; |
| import org.onosproject.pcepio.types.LocalTENodeDescriptorsTlv; |
| import org.onosproject.pcepio.types.PcepObjectHeader; |
| import org.onosproject.pcepio.types.PcepValueType; |
| import org.onosproject.pcepio.types.RemoteTENodeDescriptorsTlv; |
| import org.onosproject.pcepio.types.RoutingUniverseTlv; |
| import org.onosproject.pcepio.types.TELinkAttributesTlv; |
| import org.onosproject.pcepio.types.TELinkDescriptorsTlv; |
| import org.onosproject.pcepio.types.TENodeAttributesTlv; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| import com.google.common.base.MoreObjects; |
| |
| /** |
| * Provides PCEP TE Object. |
| */ |
| public class PcepTEObjectVer1 implements PcepTEObject { |
| /* |
| * |
| reference: PCEP Extension for Transporting TE Data draft-dhodylee-pce-pcep-te-data-extn-02. |
| TE Object-Class is [TBD6]. |
| |
| Two Object-Type values are defined for the TE object: |
| |
| o TE Node: TE Object-Type is 1. |
| |
| o TE Link: TE Object-Type is 2. |
| |
| The format of the TE object body is as follows: |
| |
| 0 1 2 3 |
| 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | Protocol-ID | Flag |R|S| |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| | TE-ID | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| // TLVs // |
| | | |
| +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ |
| */ |
| |
| protected static final Logger log = LoggerFactory.getLogger(PcepTEObjectVer1.class); |
| |
| public static final byte TE_OBJ_TYPE_NODE_VALUE = 1; |
| public static final byte TE_OBJ_TYPE_LINK_VALUE = 2; |
| |
| public static final byte TE_OBJ_CLASS = 101; //TBD6 in RFC. |
| public static final byte TE_OBJECT_VERSION = 1; |
| |
| // TE_OBJ_MINIMUM_LENGTH = TEObjectHeaderLen(4)+ TEObjectLen(8) |
| public static final short TE_OBJ_MINIMUM_LENGTH = 12; |
| |
| // Signaled ,all default values to be checked. |
| public static final byte DEFAULT_PROTOCOL_ID = 1; //IS-IS Level 1 |
| public static final boolean DEFAULT_R_FLAG = false; |
| public static final boolean DEFAULT_S_FLAG = false; |
| public static final int DEFAULT_TE_ID = 0; |
| |
| public static final int OBJECT_HEADER_LENGTH = 4; |
| public static final int RIGHT_SHIFT_ONE = 1; |
| public static final int RIGHT_FIRST_FLAG = 0x1; |
| public static final int FLAG_SET_R_FLAG = 0x2; |
| public static final int FLAG_SET_S_FLAG = 0x1; |
| public static final int MINIMUM_COMMON_HEADER_LENGTH = 4; |
| public static final int MINIMUM_TLV_HEADER_LENGTH = 4; |
| |
| public static final PcepObjectHeader DEFAULT_TE_OBJECT_HEADER = new PcepObjectHeader(TE_OBJ_CLASS, |
| TE_OBJ_TYPE_NODE_VALUE, PcepObjectHeader.REQ_OBJ_OPTIONAL_PROCESS, PcepObjectHeader.RSP_OBJ_PROCESSED, |
| TE_OBJ_MINIMUM_LENGTH); |
| |
| private PcepObjectHeader teObjHeader; |
| private byte yProtocolId; |
| // 2-flags |
| private boolean bRFlag; |
| private boolean bSFlag; |
| private int iTEId; |
| // Optional TLV |
| private LinkedList<PcepValueType> llOptionalTlv; |
| |
| /** |
| * Constructor to initialize variables. |
| * |
| * @param teObjHeader TE Object header |
| * @param yProtocolId Protocol-ID |
| * @param bRFlag R-flag |
| * @param bSFlag S-flag |
| * @param iTEId TE-ID |
| * @param llOptionalTlv linked list of Optional TLV |
| */ |
| public PcepTEObjectVer1(PcepObjectHeader teObjHeader, byte yProtocolId, boolean bRFlag, boolean bSFlag, int iTEId, |
| LinkedList<PcepValueType> llOptionalTlv) { |
| |
| this.teObjHeader = teObjHeader; |
| this.yProtocolId = yProtocolId; |
| this.bRFlag = bRFlag; |
| this.bSFlag = bSFlag; |
| this.iTEId = iTEId; |
| this.llOptionalTlv = llOptionalTlv; |
| } |
| |
| @Override |
| public PcepObjectHeader getTEObjHeader() { |
| return this.teObjHeader; |
| } |
| |
| @Override |
| public void setTEObjHeader(PcepObjectHeader obj) { |
| this.teObjHeader = obj; |
| } |
| |
| @Override |
| public byte getProtocolId() { |
| return this.yProtocolId; |
| } |
| |
| @Override |
| public void setProtocolId(byte yProtId) { |
| this.yProtocolId = yProtId; |
| } |
| |
| @Override |
| public boolean getRFlag() { |
| return this.bRFlag; |
| } |
| |
| @Override |
| public void setRFlag(boolean bRFlag) { |
| this.bRFlag = bRFlag; |
| } |
| |
| @Override |
| public boolean getSFlag() { |
| return this.bSFlag; |
| } |
| |
| @Override |
| public void setSFlag(boolean bSFlag) { |
| this.bSFlag = bSFlag; |
| } |
| |
| @Override |
| public int getTEId() { |
| return this.iTEId; |
| } |
| |
| @Override |
| public void setTEId(int iTEId) { |
| this.iTEId = iTEId; |
| } |
| |
| @Override |
| public LinkedList<PcepValueType> getOptionalTlv() { |
| return this.llOptionalTlv; |
| } |
| |
| @Override |
| public void setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { |
| this.llOptionalTlv = llOptionalTlv; |
| } |
| |
| /** |
| * Reads from the channel buffer and returns Object of PcepTEObject. |
| * |
| * @param cb of type channel buffer |
| * @return Object of PcepTEObject |
| * @throws PcepParseException if mandatory fields are missing |
| */ |
| public static PcepTEObject read(ChannelBuffer cb) throws PcepParseException { |
| log.debug("read"); |
| |
| PcepObjectHeader teObjHeader; |
| byte yProtocolId; |
| // 2-flags |
| boolean bRFlag; |
| boolean bSFlag; |
| int iTEId; |
| LinkedList<PcepValueType> llOptionalTlv; |
| |
| teObjHeader = PcepObjectHeader.read(cb); |
| |
| //take only TEObject buffer. |
| ChannelBuffer tempCb = cb.readBytes(teObjHeader.getObjLen() - OBJECT_HEADER_LENGTH); |
| |
| yProtocolId = tempCb.readByte(); |
| //ignore first two bytes of Flags |
| tempCb.readShort(); |
| |
| Integer iTemp = (int) tempCb.readByte(); //read 3rd byte Flag |
| bSFlag = (iTemp & FLAG_SET_S_FLAG) == FLAG_SET_S_FLAG; |
| bRFlag = (iTemp & FLAG_SET_R_FLAG) == FLAG_SET_R_FLAG; |
| |
| iTEId = tempCb.readInt(); |
| |
| // parse optional TLV |
| llOptionalTlv = parseOptionalTlv(tempCb); |
| |
| return new PcepTEObjectVer1(teObjHeader, yProtocolId, bRFlag, bSFlag, iTEId, llOptionalTlv); |
| } |
| |
| @Override |
| public int write(ChannelBuffer cb) throws PcepParseException { |
| |
| //write Object header |
| int objStartIndex = cb.writerIndex(); |
| int objLenIndex = teObjHeader.write(cb); |
| |
| if (objLenIndex <= 0) { |
| throw new PcepParseException("ObjectLength Index is " + objLenIndex); |
| } |
| |
| //write Protocol ID |
| cb.writeByte(this.yProtocolId); |
| |
| //write Flag |
| cb.writeShort(0); |
| |
| byte bTemp = 0; |
| if (bSFlag) { |
| bTemp = FLAG_SET_S_FLAG; |
| } |
| |
| if (bRFlag) { |
| bTemp = (byte) (bTemp | FLAG_SET_R_FLAG); |
| } |
| cb.writeByte(bTemp); |
| |
| //write TEId |
| cb.writeInt(iTEId); |
| |
| // Add optional TLV |
| packOptionalTlv(cb); |
| |
| //Update object length now |
| int length = cb.writerIndex() - objStartIndex; |
| |
| //will be helpful during print(). |
| teObjHeader.setObjLen((short) length); |
| |
| cb.setShort(objLenIndex, (short) length); |
| |
| return cb.writerIndex(); |
| } |
| |
| /** |
| * Returns Linked list of PCEP Value Type. |
| * |
| * @param cb of channel buffer |
| * @return Linked list of PCEP Value Type |
| * @throws PcepParseException if mandatory fields are missing |
| */ |
| protected static LinkedList<PcepValueType> parseOptionalTlv(ChannelBuffer cb) throws PcepParseException { |
| |
| LinkedList<PcepValueType> llOutOptionalTlv; |
| |
| llOutOptionalTlv = new LinkedList<>(); |
| |
| while (MINIMUM_TLV_HEADER_LENGTH <= cb.readableBytes()) { |
| |
| PcepValueType tlv; |
| short hType = cb.readShort(); |
| short hLength = cb.readShort(); |
| long lValue = 0; |
| |
| switch (hType) { |
| |
| case RoutingUniverseTlv.TYPE: |
| lValue = cb.readLong(); |
| tlv = new RoutingUniverseTlv(lValue); |
| break; |
| case LocalTENodeDescriptorsTlv.TYPE: |
| tlv = LocalTENodeDescriptorsTlv.read(cb, hLength); |
| break; |
| case RemoteTENodeDescriptorsTlv.TYPE: |
| tlv = RemoteTENodeDescriptorsTlv.read(cb, hLength); |
| break; |
| case TELinkDescriptorsTlv.TYPE: |
| tlv = TELinkDescriptorsTlv.read(cb, hLength); |
| break; |
| case TENodeAttributesTlv.TYPE: |
| tlv = TENodeAttributesTlv.read(cb, hLength); |
| break; |
| case TELinkAttributesTlv.TYPE: |
| tlv = TELinkAttributesTlv.read(cb, hLength); |
| break; |
| default: |
| throw new PcepParseException("Unsupported TLV type :" + hType); |
| } |
| |
| // Check for the padding |
| int pad = hLength % 4; |
| if (0 < pad) { |
| pad = 4 - pad; |
| if (pad <= cb.readableBytes()) { |
| cb.skipBytes(pad); |
| } |
| } |
| |
| llOutOptionalTlv.add(tlv); |
| } |
| |
| if (0 < cb.readableBytes()) { |
| |
| throw new PcepParseException("Optional Tlv parsing error. Extra bytes received."); |
| } |
| return llOutOptionalTlv; |
| } |
| |
| /** |
| * Returns the writer index. |
| * |
| * @param cb of type channel buffer |
| * @return the writer index. |
| */ |
| protected int packOptionalTlv(ChannelBuffer cb) { |
| |
| ListIterator<PcepValueType> listIterator = llOptionalTlv.listIterator(); |
| |
| while (listIterator.hasNext()) { |
| PcepValueType tlv = listIterator.next(); |
| |
| if (tlv == null) { |
| log.debug("TLV is null from OptionalTlv list"); |
| continue; |
| } |
| tlv.write(cb); |
| |
| // need to take care of padding |
| int pad = tlv.getLength() % 4; |
| |
| if (0 != pad) { |
| pad = 4 - pad; |
| for (int i = 0; i < pad; ++i) { |
| cb.writeByte((byte) 0); |
| } |
| } |
| } |
| return cb.writerIndex(); |
| } |
| |
| /** |
| * Builder class for PCEP te object. |
| */ |
| public static class Builder implements PcepTEObject.Builder { |
| private boolean bIsHeaderSet = false; |
| private boolean bIsProtocolIdSet = false; |
| private boolean bIsRFlagSet = false; |
| private boolean bIsSFlagSet = false; |
| private boolean bIsTEIdSet = false; |
| |
| private PcepObjectHeader teObjHeader; |
| private byte yProtocolId; |
| private boolean bRFlag; |
| private boolean bSFlag; |
| private int iTEId; |
| private LinkedList<PcepValueType> llOptionalTlv = new LinkedList<>(); |
| |
| private boolean bIsPFlagSet = false; |
| private boolean bPFlag; |
| |
| private boolean bIsIFlagSet = false; |
| private boolean bIFlag; |
| |
| @Override |
| public PcepTEObject build() { |
| PcepObjectHeader teObjHeader = this.bIsHeaderSet ? this.teObjHeader : DEFAULT_TE_OBJECT_HEADER; |
| |
| byte yProtocolId = this.bIsProtocolIdSet ? this.yProtocolId : DEFAULT_PROTOCOL_ID; |
| boolean bRFlag = this.bIsRFlagSet ? this.bRFlag : DEFAULT_R_FLAG; |
| boolean bSFlag = this.bIsSFlagSet ? this.bSFlag : DEFAULT_S_FLAG; |
| int iTEId = this.bIsTEIdSet ? this.iTEId : DEFAULT_TE_ID; |
| |
| if (bIsPFlagSet) { |
| teObjHeader.setPFlag(bPFlag); |
| } |
| |
| if (bIsIFlagSet) { |
| teObjHeader.setIFlag(bIFlag); |
| } |
| |
| return new PcepTEObjectVer1(teObjHeader, yProtocolId, bRFlag, bSFlag, iTEId, llOptionalTlv); |
| |
| } |
| |
| @Override |
| public PcepObjectHeader getTEObjHeader() { |
| return this.teObjHeader; |
| } |
| |
| @Override |
| public Builder setTEObjHeader(PcepObjectHeader obj) { |
| this.teObjHeader = obj; |
| this.bIsHeaderSet = true; |
| return this; |
| } |
| |
| @Override |
| public byte getProtocolId() { |
| return this.yProtocolId; |
| } |
| |
| @Override |
| public Builder setProtocolId(byte yProtId) { |
| this.yProtocolId = yProtId; |
| this.bIsProtocolIdSet = true; |
| return this; |
| } |
| |
| @Override |
| public boolean getRFlag() { |
| return this.bRFlag; |
| } |
| |
| @Override |
| public Builder setRFlag(boolean bRFlag) { |
| this.bRFlag = bRFlag; |
| this.bIsRFlagSet = true; |
| return this; |
| } |
| |
| @Override |
| public boolean getSFlag() { |
| return this.bSFlag; |
| } |
| |
| @Override |
| public Builder setSFlag(boolean bSFlag) { |
| this.bSFlag = bSFlag; |
| this.bIsSFlagSet = true; |
| return this; |
| } |
| |
| @Override |
| public int getTEId() { |
| return this.iTEId; |
| } |
| |
| @Override |
| public Builder setTEId(int iTEId) { |
| this.iTEId = iTEId; |
| this.bIsTEIdSet = true; |
| return this; |
| } |
| |
| @Override |
| public LinkedList<PcepValueType> getOptionalTlv() { |
| return this.llOptionalTlv; |
| } |
| |
| @Override |
| public Builder setOptionalTlv(LinkedList<PcepValueType> llOptionalTlv) { |
| this.llOptionalTlv = llOptionalTlv; |
| return this; |
| } |
| |
| @Override |
| public Builder setPFlag(boolean value) { |
| this.bPFlag = value; |
| this.bIsPFlagSet = true; |
| return this; |
| } |
| |
| @Override |
| public Builder setIFlag(boolean value) { |
| this.bIFlag = value; |
| this.bIsIFlagSet = true; |
| return this; |
| } |
| } |
| |
| @Override |
| public String toString() { |
| return MoreObjects.toStringHelper(getClass()) |
| .add("ObjectHeader", teObjHeader) |
| .add("ProtocolId", yProtocolId) |
| .add("RFlag", (bRFlag) ? 1 : 0) |
| .add("SFlag", (bSFlag) ? 1 : 0) |
| .add("TeId", iTEId) |
| .add("OptionalTlv", llOptionalTlv) |
| .toString(); |
| } |
| } |