@Override public Ipv6SidTlv parseBgpPrefixSidTlv(final ByteBuf buffer) { buffer.readBytes(RESERVED); final boolean canProcessIpv6Header = BitArray.valueOf(buffer, FLAGS_SIZE).get(PROCESS_IPV6_HEADER_FLAG); return new Ipv6SidTlvBuilder().setProcessIpv6HeadAbility(canProcessIpv6Header).build(); }
@Override protected final Fragment parseFragment(final byte fragment) { final BitArray bs = BitArray.valueOf(fragment); return new Fragment(Boolean.FALSE, bs.get(FIRST_FRAGMENT), bs.get(IS_A_FRAGMENT), bs.get(LAST_FRAGMENT)); }
public static Ipv6EroCase parseIpv6EroCase(final ByteBuf buffer) { final Ipv6EroCaseBuilder builder = new Ipv6EroCaseBuilder(); final BitArray flags = BitArray.valueOf(buffer, Ipv4EroParser.FLAGS_SIZE); builder.setLoose(flags.get(Ipv4EroParser.LOOSE)); buffer.skipBytes(Ipv4EroParser.RESERVED_ERO); builder.setAddress(Ipv6Util.addressForByteBuf(buffer)); return builder.build(); }
static Ipv4EroCase parseIpv4EroCase(final ByteBuf buffer) { final Ipv4EroCaseBuilder builder = new Ipv4EroCaseBuilder(); final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE); builder.setLoose(flags.get(LOOSE)); buffer.skipBytes(RESERVED_ERO); builder.setAddress(Ipv4Util.addressForByteBuf(buffer)); return builder.build(); }
@Override protected final Fragment parseFragment(final byte fragment) { final BitArray bs = BitArray.valueOf(fragment); return new Fragment(bs.get(DONT_FRAGMENT), bs.get(FIRST_FRAGMENT), bs.get(IS_A_FRAGMENT), bs.get(LAST_FRAGMENT)); }
public static SrCapabilities parseSrCapabilities(final ByteBuf buffer, final ProtocolId protocol) { final SrCapabilitiesBuilder builder = new SrCapabilitiesBuilder(); final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE); setFlags(flags, protocol, builder); buffer.skipBytes(RESERVERED); builder.setRangeSize((long) buffer.readUnsignedMedium()); builder.setSidLabelIndex(SidLabelIndexParser.parseSidSubTlv(buffer)); return builder.build(); }
@Override public BitmaskOperand parse(final byte op) { final BitArray bs = BitArray.valueOf(op); return new BitmaskOperand(bs.get(AND_BIT), bs.get(END_OF_LIST), bs.get(MATCH), bs.get(NOT)); }
public static SrPrefix parseSrPrefix(final ByteBuf buffer, final ProtocolId protocol) { final SrPrefixBuilder builder = new SrPrefixBuilder(); builder.setFlags(parsePrefixFlags(BitArray.valueOf(buffer, FLAGS_SIZE), protocol)); builder.setAlgorithm(Algorithm.forValue(buffer.readUnsignedByte())); buffer.skipBytes(RESERVED_PREFIX); builder.setSidLabelIndex(SidLabelIndexParser.parseSidLabelIndex(Size.forValue(buffer.readableBytes()), buffer)); return builder.build(); }
static UnnumberedInterfaceIdEroCase parseUnnumberedEroCase(final ByteBuf buffer) { final UnnumberedInterfaceIdEroCaseBuilder builder = new UnnumberedInterfaceIdEroCaseBuilder(); final BitArray flags = BitArray.valueOf(buffer, Ipv4EroParser.FLAGS_SIZE); builder.setLoose(flags.get(Ipv4EroParser.LOOSE)); buffer.skipBytes(Ipv4EroParser.RESERVED_ERO); builder.setRouterId(buffer.readUnsignedInt()); builder.setInterfaceId(buffer.readUnsignedInt()); return builder.build(); }
@Override public final NumericOperand parse(final byte operand) { final BitArray operandValues = BitArray.valueOf(operand); return new NumericOperand(operandValues.get(AND_BIT), operandValues.get(END_OF_LIST), operandValues.get(EQUAL), operandValues.get(GREATER_THAN), operandValues.get(LESS_THAN)); }
@Override public ExtendedCommunity parseExtendedCommunity(final ByteBuf buffer) throws BGPDocumentedException, BGPParsingException { buffer.skipBytes(RESERVED); final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE); final boolean sample = flags.get(SAMPLE_BIT); final boolean terminal = flags.get(TERMINAL_BIT); return new TrafficActionExtendedCommunityCaseBuilder().setTrafficActionExtendedCommunity( new TrafficActionExtendedCommunityBuilder() .setSample(sample) .setTerminalAction(terminal) .build()).build(); }
@Override public Object parseObject(final ObjectHeader header, final ByteBuf buffer) throws PCEPDeserializerException { Preconditions.checkArgument(buffer != null && buffer.isReadable(), "Array of bytes is mandatory. Can't be null or empty."); final ProcTimeBuilder builder = new ProcTimeBuilder(); buffer.skipBytes(RESERVED); final BitArray flagBits = BitArray.valueOf(buffer, FLAGS); builder.setEstimated(flagBits.get(E_FLAG_POSITION)); builder.setCurrentProcTime(buffer.readUnsignedInt()); builder.setMinProcTime(buffer.readUnsignedInt()); builder.setMaxProcTime(buffer.readUnsignedInt()); builder.setAverageProcTime(buffer.readUnsignedInt()); builder.setVarianceProcTime(buffer.readUnsignedInt()); return builder.build(); }
@Override public NoPathVector parseTlv(final ByteBuf buffer) throws PCEPDeserializerException { if (buffer == null) { return null; } if (buffer.readableBytes() != FLAGS_SIZE / Byte.SIZE) { throw new PCEPDeserializerException("Wrong length of array of bytes. Passed: " + buffer.readableBytes() + "; Expected: >=" + FLAGS_SIZE / Byte.SIZE + "."); } final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE); return new NoPathVectorBuilder().setFlags( new Flags(flags.get(CHAIN_UNAVAILABLE), flags.get(NO_GCO_MIGRATION_PATH), flags.get(NO_GCO_SOLUTION), flags.get(REACHABLITY_PROBLEM), flags.get(PATH_KEY), flags.get(PCE_UNAVAILABLE), flags.get(UNKNOWN_DEST), flags.get(UNKNOWN_SRC))).build(); }
public static SrBindingSidLabels parseBindingSidLabel(final ByteBuf buffer, final ProtocolId protocolId) { final SrBindingSidLabelsBuilder bindingSid = new SrBindingSidLabelsBuilder(); bindingSid.setWeight(new Weight(buffer.readUnsignedByte())); final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE); bindingSid.setFlags(parseBindingSidFlags(flags, protocolId)); buffer.skipBytes(RESERVED_BINDING_SID); bindingSid.setBindingSubTlvs(SimpleBindingSubTlvsRegistry.getInstance().parseBindingSubTlvs(buffer, protocolId)); return bindingSid.build(); }
@Override public NoPath parseObject(final ObjectHeader header, final ByteBuf bytes) throws PCEPDeserializerException { Preconditions.checkArgument(bytes != null && bytes.isReadable(), "Array of bytes is mandatory. Can't be null or empty."); final NoPathBuilder builder = new NoPathBuilder(); builder.setIgnore(header.isIgnore()); builder.setProcessingRule(header.isProcessingRule()); builder.setNatureOfIssue(bytes.readUnsignedByte()); final BitArray flags = BitArray.valueOf(bytes, FLAGS_SIZE); builder.setUnsatisfiedConstraints(flags.get(C_FLAG_OFFSET)); bytes.skipBytes(RESERVED_F_LENGTH); final TlvsBuilder tlvsBuilder = new TlvsBuilder(); parseTlvs(tlvsBuilder, bytes.slice()); builder.setTlvs(tlvsBuilder.build()); return builder.build(); }
public static SrRange parseSrRange(final ByteBuf buffer, final ProtocolId protocolId) { final BitArray flags = BitArray.valueOf(buffer, FLAGS_SIZE); final SrRangeBuilder range = new SrRangeBuilder(); if (protocolId.equals(ProtocolId.Ospf)) { range.setInterArea(flags.get(INNER_AREA)); } else { range.setInterArea(Boolean.FALSE); } buffer.skipBytes(RESERVED); range.setRangeSize(buffer.readUnsignedShort()); range.setSubTlvs(parseRangeSubTlvs(buffer, protocolId)); return range.build(); }
@Override public Object parseObject(final ObjectHeader header, final ByteBuf buffer) throws PCEPDeserializerException { Preconditions.checkArgument(buffer != null && buffer.isReadable(), "Array of bytes is mandatory. Can't be null or empty."); final MonitoringBuilder builder = new MonitoringBuilder(); buffer.readBytes(RESERVED); final BitArray flagBits = BitArray.valueOf(buffer, FLAGS_SIZE); final Flags flags = new Flags(flagBits.get(G_FLAG_POS), flagBits.get(I_FLAG_POS), flagBits.get(L_FLAG_POS), flagBits.get(C_FLAG_POS), flagBits.get(P_FLAG_POS)); builder.setFlags(flags); builder.setMonitoringId(buffer.readUnsignedInt()); final TlvsBuilder tbuilder = new TlvsBuilder(); parseTlvs(tbuilder, buffer.slice()); builder.setTlvs(tbuilder.build()); return builder.build(); }
private static void parseNodeFlags(final ByteBuf value, final NodeAttributesBuilder builder) { final BitArray flags = BitArray.valueOf(value, FLAGS_SIZE); builder.setNodeFlags(new NodeFlagBits(flags.get(OVERLOAD_BIT), flags.get(ATTACHED_BIT), flags.get (EXTERNAL_BIT), flags.get(ABBR_BIT), flags.get(ROUTER_BIT), flags.get(V6_BIT))); LOG.debug("Parsed Overload bit: {}, attached bit: {}, external bit: {}, area border router: {}.", flags.get(OVERLOAD_BIT), flags.get(ATTACHED_BIT), flags.get(EXTERNAL_BIT), flags.get(ABBR_BIT)); }
private static void parseIgpFags(final PrefixAttributesBuilder builder, final ByteBuf value) { final BitArray flags = BitArray.valueOf(value, FLAGS_SIZE); final boolean upDownBit = flags.get(UP_DOWN_BIT); builder.setIgpBits(new IgpBitsBuilder().setUpDown(new UpDown(upDownBit)).setIsIsUpDown(upDownBit).setOspfNoUnicast(flags.get(OSPF_NO_UNICAST)) .setOspfLocalAddress(flags.get(OSPF_LOCAL_ADDRESS)).setOspfPropagateNssa(flags.get(OSPF_PROPAGATE_ADDRESS)).build()); LOG.debug("Parsed IGP flag (up/down bit) : {}", upDownBit); }
@Override public ExtendedCommunity parseExtendedCommunity(final ByteBuf body) throws BGPDocumentedException, BGPParsingException { final Layer2AttributesExtendedCommunityBuilder builder = new Layer2AttributesExtendedCommunityBuilder(); final BitArray flags = BitArray.valueOf(body, FLAGS_SIZE); builder.setPrimaryPe(flags.get(PRIMARY_PE_OFFSET)); builder.setBackupPe(flags.get(BACKUP_PE_OFFSET)); builder.setControlWord(flags.get(CONTROL_WORD_OFFSET)); builder.setL2Mtu(body.readUnsignedShort()); body.skipBytes(RESERVED); return new Layer2AttributesExtendedCommunityCaseBuilder().setLayer2AttributesExtendedCommunity(builder.build()).build(); }