public static void formatLabel(final int type, final Boolean unidirectional, final Boolean global, final ByteBuf body, final ByteBuf buffer) { final BitArray reserved = new BitArray(FLAGS_SIZE); reserved.set(UNIDIRECTIONAL, unidirectional); reserved.set(GLOBAL, global); reserved.toByteBuf(buffer); buffer.writeByte(type); buffer.writeBytes(body); } }
public static void formatSubobject(final int objectType, final int objectClass, final Boolean processingRule, final Boolean ignore, final ByteBuf body, final ByteBuf out) { out.writeByte(objectClass); final BitArray flags = new BitArray(FLAGS_SIZE); flags.set(IGNORED, ignore); flags.set(PROCESSED, processingRule); final byte flagB = flags.toByte(); final int typeByte = objectType << FLAGS_SIZE | flagB; out.writeByte(typeByte); out.writeShort(body.writerIndex() + HEADER_SIZE); out.writeBytes(body); } }
private static BitArray serializeBindingSidFlags(final Flags flags) { final BitArray bitFlags = new BitArray(FLAGS_SIZE); if (flags instanceof IsisBindingFlagsCase) { final IsisBindingFlagsCase isisFlags = (IsisBindingFlagsCase) flags; bitFlags.set(AFI, isisFlags.isAddressFamily()); bitFlags.set(MIRROR_CONTEXT, isisFlags.isMirrorContext()); bitFlags.set(SPREAD_TLV, isisFlags.isSpreadTlv()); bitFlags.set(LEAKED, isisFlags.isLeakedFromLevel2()); bitFlags.set(ATTACHED, isisFlags.isAttachedFlag()); } else if (flags instanceof OspfBindingFlagsCase) { final OspfBindingFlagsCase ospfFlags = (OspfBindingFlagsCase) flags; bitFlags.set(MIRROR_CONTEXT_OSPF, ospfFlags.isMirroring()); } return bitFlags; } }
@Override public void serializeObject(final Object object, final ByteBuf buffer) { Preconditions.checkArgument(object instanceof Rp, "Wrong instance of PCEPObject. Passed %s. Needed RPObject.", object.getClass()); final ByteBuf body = Unpooled.buffer(); final Rp rpObj = (Rp) object; final BitArray flags = new BitArray(FLAGS_SIZE); flags.set(R_FLAG_OFFSET, rpObj.isReoptimization()); flags.set(B_FLAG_OFFSET, rpObj.isBiDirectional()); flags.set(O_FLAG_OFFSET, rpObj.isLoose()); flags.set(M_FLAG_OFFSET, rpObj.isMakeBeforeBreak()); flags.set(D_FLAG_OFFSET, rpObj.isOrder()); flags.set(P_FLAG_OFFSET, rpObj.isPathKey()); flags.set(S_FLAG_OFFSET, rpObj.isSupplyOf()); flags.set(F_FLAG_OFFSET, rpObj.isFragmentation()); flags.set(N_FLAG_OFFSET, rpObj.isP2mp()); flags.set(E_FLAG_OFFSET, rpObj.isEroCompression()); final byte[] res = flags.array(); if (rpObj.getPriority() != null) { final byte p = UnsignedBytes.checkedCast(rpObj.getPriority().shortValue()); res[res.length -1] = (byte) (res[res.length -1] | p); } body.writeBytes(res); Preconditions.checkArgument(rpObj.getRequestId() != null, "RequestId is mandatory"); writeUnsignedInt(rpObj.getRequestId().getValue(), body); serializeTlvs(rpObj.getTlvs(), body); ObjectUtil.formatSubobject(TYPE, CLASS, object.isProcessingRule(), object.isIgnore(), body, buffer); }
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(); }
private static Flags parseBindingSidFlags(final BitArray flags, final ProtocolId protocol) { switch (protocol) { case IsisLevel1: case IsisLevel2: return new IsisBindingFlagsCaseBuilder().setAddressFamily(flags.get(AFI)).setMirrorContext(flags.get(MIRROR_CONTEXT)) .setSpreadTlv(flags.get(SPREAD_TLV)).setLeakedFromLevel2(flags.get(LEAKED)).setAttachedFlag(flags.get(ATTACHED)).build(); case Ospf: case OspfV3: return new OspfBindingFlagsCaseBuilder().setMirroring(flags.get(MIRROR_CONTEXT_OSPF)).build(); default: return null; } }
public static void serializePrefixAttributes(final Flags flags, final Algorithm algorithm, final SidLabelIndex sidLabelIndex, final ByteBuf buffer) { final BitArray bitFlags = serializePrefixFlags(flags, sidLabelIndex); bitFlags.toByteBuf(buffer); buffer.writeByte(algorithm.getIntValue()); buffer.writeZero(RESERVED_PREFIX); buffer.writeBytes(SidLabelIndexParser.serializeSidValue(sidLabelIndex)); }
/** * Returns a new BitArray created from bytes from given ByteBuf. * * @param buffer ByteBuf, whose readerIndex will be moved by * minimum number of bytes required for the bit size. * @param size Number of bits to be allocated in BitArray * @return new BitArray */ public static BitArray valueOf(final ByteBuf buffer, final int size) { Preconditions.checkArgument(size >= 1, "Minimum size is 1 bit."); Preconditions.checkNotNull(buffer, "Byte Array cannot be null"); final byte[] b = new byte[calculateBytes(size)]; buffer.readBytes(b, 0, b.length); return new BitArray(b, size); }
/** * Returns a new BitArray with given byte array as backing * array. * * @param bytes byte array * @return new BitArray */ public static BitArray valueOf(final byte[] bytes) { return new BitArray(bytes, bytes.length); }
static void setFlags(final SidLabelIndex tlv, final BitArray flags, final int value, final int local) { if (tlv instanceof LocalLabelCase) { flags.set(value, Boolean.TRUE); flags.set(local, Boolean.TRUE); } else if (tlv instanceof SidCase) { flags.set(value, Boolean.FALSE); flags.set(local, Boolean.FALSE); } else if (tlv instanceof Ipv6AddressCase) { flags.set(value, Boolean.TRUE); flags.set(local, Boolean.FALSE); } }
private static BitArray serializePrefixFlags(final Flags flags, final SidLabelIndex sidLabelIndex) { final BitArray bitFlags = new BitArray(FLAGS_SIZE); SidLabelIndexParser.setFlags(sidLabelIndex, bitFlags, VALUE, LOCAL); if (flags instanceof OspfPrefixFlagsCase) { final OspfPrefixFlagsCase ospfFlags = (OspfPrefixFlagsCase) flags; bitFlags.set(NO_PHP_OSPF, ospfFlags.isNoPhp()); bitFlags.set(MAPPING_SERVER, ospfFlags.isMappingServer()); bitFlags.set(EXPLICIT_NULL, ospfFlags.isExplicitNull()); } else if (flags instanceof IsisPrefixFlagsCase) { final IsisPrefixFlagsCase isisFlags = (IsisPrefixFlagsCase) flags; bitFlags.set(RE_ADVERTISEMENT, isisFlags.isReadvertisement()); bitFlags.set(NODE_SID, isisFlags.isNodeSid()); bitFlags.set(NO_PHP, isisFlags.isNoPhp()); bitFlags.set(EXPLICIT_NULL, isisFlags.isExplicitNull()); } return bitFlags; }
static void serializePrefixAttributes(final PrefixAttributesCase prefixAttributesCase, final ByteBuf byteAggregator) { final PrefixAttributes prefixAtrributes = prefixAttributesCase.getPrefixAttributes(); if (prefixAtrributes.getIgpBits() != null) { final BitArray igpBit = new BitArray(FLAGS_SIZE); final IgpBits igpBits = prefixAtrributes.getIgpBits(); igpBit.set(UP_DOWN_BIT, igpBits.getUpDown().isUpDown() || igpBits.isIsIsUpDown()); igpBit.set(OSPF_NO_UNICAST, igpBits.isOspfNoUnicast()); igpBit.set(OSPF_LOCAL_ADDRESS, igpBits.isOspfLocalAddress()); igpBit.set(OSPF_PROPAGATE_ADDRESS, igpBits.isOspfPropagateNssa()); TlvUtil.writeTLV(IGP_FLAGS, Unpooled.wrappedBuffer(igpBit.array()), byteAggregator); } serializeRouteTags(prefixAtrributes.getRouteTags(), byteAggregator); serializeExtendedRouteTags(prefixAtrributes.getExtendedTags(), byteAggregator); serializePrefixMetric(prefixAtrributes.getPrefixMetric(), byteAggregator); serializeForwardingAddress(prefixAtrributes.getOspfForwardingAddress(), byteAggregator); serializeSrPrefix(prefixAtrributes.getSrPrefix(), byteAggregator); serializeIpv6SrPrefix(prefixAtrributes.getIpv6SrPrefix(), byteAggregator); serializeSrRange(prefixAtrributes.getSrRange(), byteAggregator); serializeSrBindingLabel(prefixAtrributes.getSrBindingSidLabels(), byteAggregator); }
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(); }
private static Flags parsePrefixFlags(final BitArray flags, final ProtocolId protocol) { switch (protocol) { case IsisLevel1: case IsisLevel2: return new IsisPrefixFlagsCaseBuilder().setReadvertisement(flags.get(RE_ADVERTISEMENT)) .setNodeSid(flags.get(NODE_SID)).setNoPhp(flags.get(NO_PHP)).setExplicitNull(flags.get(EXPLICIT_NULL)).build(); case Ospf: case OspfV3: return new OspfPrefixFlagsCaseBuilder().setExplicitNull(flags.get(EXPLICIT_NULL)) .setMappingServer(flags.get(MAPPING_SERVER)).setNoPhp(flags.get(NO_PHP_OSPF)).build(); default: return null; } }
public static void serializeBindingSidAttributes(final Weight weight, final Flags flags, final List<BindingSubTlvs> bindingSubTlvs, final ByteBuf aggregator) { aggregator.writeByte(weight.getValue()); final BitArray bitFlags = serializeBindingSidFlags(flags); bitFlags.toByteBuf(aggregator); aggregator.writeZero(RESERVED_BINDING_SID); SimpleBindingSubTlvsRegistry.getInstance().serializeBindingSubTlvs(bindingSubTlvs, aggregator); }
/** * Returns new BitArray with given byte as backing * array. * * @param b unsigned byte * @return new BitArray */ public static BitArray valueOf(final byte b) { return new BitArray(new byte[] {b}, Byte.SIZE); }
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)); }
@Override protected final byte serializeFragment(final Fragment fragment) { final BitArray bs = new BitArray(Byte.SIZE); bs.set(DONT_FRAGMENT, Boolean.FALSE); bs.set(FIRST_FRAGMENT, fragment.isFirst()); bs.set(IS_A_FRAGMENT, fragment.isIsA()); bs.set(LAST_FRAGMENT, fragment.isLast()); return bs.toByte(); } }