/// <summary>
/// Decode input as a control parameters in NDN-TLV and set the fields of the
/// controlResponse object.
/// </summary>
///
/// <param name="controlResponse"></param>
/// <param name="input"></param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException">For invalid encoding</exception>
public override void decodeControlResponse(ControlResponse controlResponse,
ByteBuffer input, bool copy)
{
TlvDecoder decoder = new TlvDecoder(input);
int endOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_ControlResponse);
controlResponse.setStatusCode((int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_StatusCode));
// Set copy false since we just immediately get a string.
Blob statusText = new Blob(
decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_StatusText), false);
controlResponse.setStatusText(statusText.toString());
// Decode the body.
if (decoder
.peekType(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_ControlParameters, endOffset)) {
controlResponse.setBodyAsControlParameters(new ControlParameters());
// Decode into the existing ControlParameters to avoid copying.
decodeControlParameters(
controlResponse.getBodyAsControlParameters(), decoder, copy);
} else
controlResponse.setBodyAsControlParameters(null);
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// Decode the name as NDN-TLV and set the fields in name.
/// </summary>
///
/// <param name="name">The name object whose fields are set.</param>
/// <param name="signedPortionBeginOffset">name component and ends just before the final name component (which is assumed to be a signature for a signed interest). If you are not decoding in order to verify, you can ignore this returned value.</param>
/// <param name="signedPortionEndOffset">name component and ends just before the final name component (which is assumed to be a signature for a signed interest). If you are not decoding in order to verify, you can ignore this returned value.</param>
/// <param name="decoder">The decoder with the input to decode.</param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException"></exception>
private static void decodeName(Name name, int[] signedPortionBeginOffset,
int[] signedPortionEndOffset, TlvDecoder decoder, bool copy)
{
name.clear();
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Name);
signedPortionBeginOffset[0] = decoder.getOffset();
// In case there are no components, set signedPortionEndOffset arbitrarily.
signedPortionEndOffset[0] = signedPortionBeginOffset[0];
while (decoder.getOffset() < endOffset) {
signedPortionEndOffset[0] = decoder.getOffset();
name.append(decodeNameComponent(decoder, copy));
}
decoder.finishNestedTlvs(endOffset);
}
private static void decodeMetaInfo(MetaInfo metaInfo, TlvDecoder decoder,
bool copy)
{
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.MetaInfo);
// The ContentType enum is set up with the correct integer for each
// NDN-TLV ContentType.
int type = (int) decoder.readOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.ContentType, endOffset);
if (type < 0 || type == net.named_data.jndn.ContentType.BLOB.getNumericType())
// Default to BLOB if the value is omitted.
metaInfo.setType(net.named_data.jndn.ContentType.BLOB);
else if (type == net.named_data.jndn.ContentType.LINK.getNumericType())
metaInfo.setType(net.named_data.jndn.ContentType.LINK);
else if (type == net.named_data.jndn.ContentType.KEY.getNumericType())
metaInfo.setType(net.named_data.jndn.ContentType.KEY);
else if (type == net.named_data.jndn.ContentType.NACK.getNumericType())
metaInfo.setType(net.named_data.jndn.ContentType.NACK);
else {
// Unrecognized content type.
metaInfo.setType(net.named_data.jndn.ContentType.OTHER_CODE);
metaInfo.setOtherTypeCode(type);
}
metaInfo.setFreshnessPeriod(decoder.readOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.FreshnessPeriod, endOffset));
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.FinalBlockId, endOffset)) {
int finalBlockIdEndOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.FinalBlockId);
metaInfo.setFinalBlockId(decodeNameComponent(decoder, copy));
decoder.finishNestedTlvs(finalBlockIdEndOffset);
} else
metaInfo.setFinalBlockId(null);
decoder.finishNestedTlvs(endOffset);
}
private static void decodeKeyLocator(int expectedType,
KeyLocator keyLocator, TlvDecoder decoder, bool copy)
{
int endOffset = decoder.readNestedTlvsStart(expectedType);
keyLocator.clear();
if (decoder.getOffset() == endOffset)
// The KeyLocator is omitted, so leave the fields as none.
return;
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Name, endOffset)) {
// KeyLocator is a Name.
keyLocator.setType(net.named_data.jndn.KeyLocatorType.KEYNAME);
decodeName(keyLocator.getKeyName(), new int[1], new int[1],
decoder, copy);
} else if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.KeyLocatorDigest, endOffset)) {
// KeyLocator is a KeyLocatorDigest.
keyLocator.setType(net.named_data.jndn.KeyLocatorType.KEY_LOCATOR_DIGEST);
keyLocator.setKeyData(new Blob(decoder
.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.KeyLocatorDigest), copy));
} else
throw new EncodingException(
"decodeKeyLocator: Unrecognized key locator type");
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// Continue scanning input starting from offset_ to find the element end.
/// If the end of the element which started at offset 0 is found, this returns
/// true and getOffset() is the length of the element. Otherwise, this returns
/// false which means you should read more into input and call again.
/// </summary>
///
/// <param name="input">You have to pass in input each time because the buffer could be reallocated.</param>
/// <returns>true if found the element end, false if not.</returns>
public bool findElementEnd(ByteBuffer input)
{
if (gotElementEnd_)
// Someone is calling when we already got the end.
return true;
TlvDecoder decoder = new TlvDecoder(input);
while (true) {
if (offset_ >= input.limit())
// All the cases assume we have some input. Return and wait for more.
return false;
if (state_ == TlvStructureDecoder.READ_TYPE) {
int firstOctet = (int) input.get(offset_) & 0xff;
offset_ += 1;
if (firstOctet < 253)
// The value is simple, so we can skip straight to reading the length.
state_ = TlvStructureDecoder.READ_LENGTH;
else {
// Set up to skip the type bytes.
if (firstOctet == 253)
nBytesToRead_ = 2;
else if (firstOctet == 254)
nBytesToRead_ = 4;
else
// value == 255.
nBytesToRead_ = 8;
state_ = TlvStructureDecoder.READ_TYPE_BYTES;
}
} else if (state_ == TlvStructureDecoder.READ_TYPE_BYTES) {
int nRemainingBytes = input.limit() - offset_;
if (nRemainingBytes < nBytesToRead_) {
// Need more.
offset_ += nRemainingBytes;
nBytesToRead_ -= nRemainingBytes;
return false;
}
// Got the type bytes. Move on to read the length.
offset_ += nBytesToRead_;
state_ = TlvStructureDecoder.READ_LENGTH;
} else if (state_ == TlvStructureDecoder.READ_LENGTH) {
int firstOctet_0 = (int) input.get(offset_) & 0xff;
offset_ += 1;
if (firstOctet_0 < 253) {
// The value is simple, so we can skip straight to reading
// the value bytes.
nBytesToRead_ = firstOctet_0;
if (nBytesToRead_ == 0) {
// No value bytes to read. We're finished.
gotElementEnd_ = true;
return true;
}
state_ = TlvStructureDecoder.READ_VALUE_BYTES;
} else {
// We need to read the bytes in the extended encoding of
// the length.
if (firstOctet_0 == 253)
nBytesToRead_ = 2;
else if (firstOctet_0 == 254)
nBytesToRead_ = 4;
else
// value == 255.
nBytesToRead_ = 8;
// We need to use firstOctet in the next state.
firstOctet_ = firstOctet_0;
state_ = TlvStructureDecoder.READ_LENGTH_BYTES;
}
} else if (state_ == TlvStructureDecoder.READ_LENGTH_BYTES) {
int nRemainingBytes_1 = input.limit() - offset_;
if (!useHeaderBuffer_ && nRemainingBytes_1 >= nBytesToRead_) {
// We don't have to use the headerBuffer. Set nBytesToRead.
decoder.seek(offset_);
nBytesToRead_ = decoder.readExtendedVarNumber(firstOctet_);
// Update offset_ to the decoder's offset after reading.
offset_ = decoder.getOffset();
} else {
useHeaderBuffer_ = true;
int nNeededBytes = nBytesToRead_ - headerBuffer_.position();
if (nNeededBytes > nRemainingBytes_1) {
// We can't get all of the header bytes from this input.
// Save in headerBuffer.
if (headerBuffer_.position() + nRemainingBytes_1 > headerBuffer_
.limit())
// We don't expect this to happen.
throw new Exception(
"Cannot store more header bytes than the size of headerBuffer");
ByteBuffer remainingInput = input.duplicate();
remainingInput.position(offset_);
headerBuffer_.put(remainingInput);
offset_ += nRemainingBytes_1;
return false;
}
// Copy the remaining bytes into headerBuffer, read the
// length and set nBytesToRead.
if (headerBuffer_.position() + nNeededBytes > headerBuffer_
.limit())
// We don't expect this to happen.
throw new Exception(
"Cannot store more header bytes than the size of headerBuffer");
ByteBuffer remainingLengthBytes = input.duplicate();
remainingLengthBytes.position(offset_);
remainingLengthBytes.limit(offset_ + nNeededBytes);
headerBuffer_.put(remainingLengthBytes);
offset_ += nNeededBytes;
// Use a local decoder just for the headerBuffer.
headerBuffer_.flip();
TlvDecoder bufferDecoder = new TlvDecoder(headerBuffer_);
// Replace nBytesToRead with the length of the value.
nBytesToRead_ = bufferDecoder
.readExtendedVarNumber(firstOctet_);
}
if (nBytesToRead_ == 0) {
// No value bytes to read. We're finished.
gotElementEnd_ = true;
return true;
}
// Get ready to read the value bytes.
state_ = TlvStructureDecoder.READ_VALUE_BYTES;
} else if (state_ == TlvStructureDecoder.READ_VALUE_BYTES) {
int nRemainingBytes_2 = input.limit() - offset_;
if (nRemainingBytes_2 < nBytesToRead_) {
// Need more.
offset_ += nRemainingBytes_2;
nBytesToRead_ -= nRemainingBytes_2;
return false;
}
// Got the bytes. We're finished.
offset_ += nBytesToRead_;
gotElementEnd_ = true;
return true;
} else
// We don't expect this to happen.
throw new Exception("findElementEnd: unrecognized state");
}
}
/// <summary>
/// Decode the input as an NDN-TLV RepetitiveInterval.
/// </summary>
///
/// <param name="decoder">The decoder with the input to decode.</param>
/// <returns>A new RepetitiveInterval with the decoded result.</returns>
private static RepetitiveInterval decodeRepetitiveInterval(
TlvDecoder decoder)
{
int endOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_RepetitiveInterval);
// Use Blob to convert UTF8 to a string.
double startDate = fromIsoString(new Blob(
decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_StartDate), true).toString());
double endDate = fromIsoString(new Blob(
decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EndDate), true).toString());
int startHour = (int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_IntervalStartHour);
int endHour = (int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_IntervalEndHour);
int nRepeats = (int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_NRepeats);
int repeatUnitCode = (int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_RepeatUnit);
RepetitiveInterval.RepeatUnit repeatUnit;
if (repeatUnitCode == net.named_data.jndn.encoding.tlv.Tlv.Encrypt_RepeatUnit_NONE)
repeatUnit = net.named_data.jndn.encrypt.RepetitiveInterval.RepeatUnit.NONE;
else if (repeatUnitCode == net.named_data.jndn.encoding.tlv.Tlv.Encrypt_RepeatUnit_DAY)
repeatUnit = net.named_data.jndn.encrypt.RepetitiveInterval.RepeatUnit.DAY;
else if (repeatUnitCode == net.named_data.jndn.encoding.tlv.Tlv.Encrypt_RepeatUnit_MONTH)
repeatUnit = net.named_data.jndn.encrypt.RepetitiveInterval.RepeatUnit.MONTH;
else if (repeatUnitCode == net.named_data.jndn.encoding.tlv.Tlv.Encrypt_RepeatUnit_YEAR)
repeatUnit = net.named_data.jndn.encrypt.RepetitiveInterval.RepeatUnit.YEAR;
else
throw new EncodingException(
"Unrecognized RepetitiveInterval RepeatUnit code: "
+ repeatUnitCode);
decoder.finishNestedTlvs(endOffset);
return new RepetitiveInterval(startDate, endDate, startHour, endHour,
nRepeats, repeatUnit);
}
private static void decodeValidityPeriod(ValidityPeriod validityPeriod,
TlvDecoder decoder)
{
int endOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.ValidityPeriod_ValidityPeriod);
validityPeriod.clear();
// Set copy false since we just immediately get the string.
Blob isoString = new Blob(
decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.ValidityPeriod_NotBefore), false);
double notBefore = net.named_data.jndn.encrypt.Schedule.fromIsoString("" + isoString);
isoString = new Blob(decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.ValidityPeriod_NotAfter),
false);
double notAfter = net.named_data.jndn.encrypt.Schedule.fromIsoString("" + isoString);
validityPeriod.setPeriod(notBefore, notAfter);
decoder.finishNestedTlvs(endOffset);
}
private static void decodeSelectors(Interest interest, TlvDecoder decoder,
bool copy)
{
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Selectors);
interest.setMinSuffixComponents((int) decoder
.readOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.MinSuffixComponents,
endOffset));
interest.setMaxSuffixComponents((int) decoder
.readOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.MaxSuffixComponents,
endOffset));
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.PublisherPublicKeyLocator, endOffset))
decodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.PublisherPublicKeyLocator,
interest.getKeyLocator(), decoder, copy);
else
interest.getKeyLocator().clear();
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Exclude, endOffset))
decodeExclude(interest.getExclude(), decoder, copy);
else
interest.getExclude().clear();
interest.setChildSelector((int) decoder
.readOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.ChildSelector, endOffset));
interest.setMustBeFresh(decoder.readBooleanTlv(net.named_data.jndn.encoding.tlv.Tlv.MustBeFresh,
endOffset));
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// Decode input as a name in NDN-TLV and set the fields of the Name object.
/// </summary>
///
/// <param name="name">The Name object whose fields are updated.</param>
/// <param name="input">The input buffer to decode. This reads from position() to limit(), but does not change the position.</param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public override void decodeName(Name name, ByteBuffer input, bool copy)
{
TlvDecoder decoder = new TlvDecoder(input);
decodeName(name, new int[1], new int[1], decoder, copy);
}
/// <summary>
/// Decode input as an NDN-TLV LpPacket and set the fields of the lpPacket object.
/// </summary>
///
/// <param name="lpPacket">The LpPacket object whose fields are updated.</param>
/// <param name="input"></param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public override void decodeLpPacket(LpPacket lpPacket, ByteBuffer input, bool copy)
{
lpPacket.clear();
TlvDecoder decoder = new TlvDecoder(input);
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.LpPacket_LpPacket);
while (decoder.getOffset() < endOffset) {
// Imitate TlvDecoder.readTypeAndLength.
int fieldType = decoder.readVarNumber();
int fieldLength = decoder.readVarNumber();
int fieldEndOffset = decoder.getOffset() + fieldLength;
if (fieldEndOffset > input.limit())
throw new EncodingException(
"TLV length exceeds the buffer length");
if (fieldType == net.named_data.jndn.encoding.tlv.Tlv.LpPacket_Fragment) {
// Set the fragment to the bytes of the TLV value.
lpPacket.setFragmentWireEncoding(new Blob(decoder.getSlice(
decoder.getOffset(), fieldEndOffset), copy));
decoder.seek(fieldEndOffset);
// The fragment is supposed to be the last field.
break;
} else if (fieldType == net.named_data.jndn.encoding.tlv.Tlv.LpPacket_Nack) {
NetworkNack networkNack = new NetworkNack();
int code = (int) decoder.readOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.LpPacket_NackReason, fieldEndOffset);
// The enum numeric values are the same as this wire format, so use as is.
if (code < 0
|| code == net.named_data.jndn.NetworkNack.Reason.NONE.getNumericType())
// This includes an omitted NackReason.
networkNack.setReason(net.named_data.jndn.NetworkNack.Reason.NONE);
else if (code == net.named_data.jndn.NetworkNack.Reason.CONGESTION.getNumericType())
networkNack.setReason(net.named_data.jndn.NetworkNack.Reason.CONGESTION);
else if (code == net.named_data.jndn.NetworkNack.Reason.DUPLICATE.getNumericType())
networkNack.setReason(net.named_data.jndn.NetworkNack.Reason.DUPLICATE);
else if (code == net.named_data.jndn.NetworkNack.Reason.NO_ROUTE.getNumericType())
networkNack.setReason(net.named_data.jndn.NetworkNack.Reason.NO_ROUTE);
else {
// Unrecognized reason.
networkNack.setReason(net.named_data.jndn.NetworkNack.Reason.OTHER_CODE);
networkNack.setOtherReasonCode(code);
}
lpPacket.addHeaderField(networkNack);
} else if (fieldType == net.named_data.jndn.encoding.tlv.Tlv.LpPacket_IncomingFaceId) {
IncomingFaceId incomingFaceId = new IncomingFaceId();
incomingFaceId.setFaceId(decoder
.readNonNegativeInteger(fieldLength));
lpPacket.addHeaderField(incomingFaceId);
} else {
// Unrecognized field type. The conditions for ignoring are here:
// http://redmine.named-data.net/projects/nfd/wiki/NDNLPv2
bool canIgnore = (fieldType >= net.named_data.jndn.encoding.tlv.Tlv.LpPacket_IGNORE_MIN
&& fieldType <= net.named_data.jndn.encoding.tlv.Tlv.LpPacket_IGNORE_MAX && (fieldType & 0x01) == 1);
if (!canIgnore)
throw new EncodingException(
"Did not get the expected TLV type");
// Ignore.
decoder.seek(fieldEndOffset);
}
decoder.finishNestedTlvs(fieldEndOffset);
}
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// Decode input as an interest in NDN-TLV and set the fields of the interest
/// object.
/// </summary>
///
/// <param name="interest">The Interest object whose fields are updated.</param>
/// <param name="input"></param>
/// <param name="signedPortionBeginOffset">name component and ends just before the final name component (which is assumed to be a signature for a signed interest).</param>
/// <param name="signedPortionEndOffset">name component and ends just before the final name component (which is assumed to be a signature for a signed interest).</param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public override void decodeInterest(Interest interest, ByteBuffer input,
int[] signedPortionBeginOffset, int[] signedPortionEndOffset,
bool copy)
{
TlvDecoder decoder = new TlvDecoder(input);
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Interest);
decodeName(interest.getName(), signedPortionBeginOffset,
signedPortionEndOffset, decoder, copy);
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Selectors, endOffset))
decodeSelectors(interest, decoder, copy);
// Require a Nonce, but don't force it to be 4 bytes.
ByteBuffer nonce = decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce);
interest.setInterestLifetimeMilliseconds(decoder
.readOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.InterestLifetime,
endOffset));
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Data, endOffset)) {
// Get the bytes of the Link TLV.
int linkBeginOffset = decoder.getOffset();
int linkEndOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Data);
decoder.seek(linkEndOffset);
interest.setLinkWireEncoding(
new Blob(decoder.getSlice(linkBeginOffset, linkEndOffset),
copy), this);
} else
interest.unsetLink();
interest.setSelectedDelegationIndex((int) decoder
.readOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SelectedDelegation,
endOffset));
if (interest.getSelectedDelegationIndex() >= 0 && !interest.hasLink())
throw new EncodingException(
"Interest has a selected delegation, but no link object");
// Set the nonce last because setting other interest fields clears it.
interest.setNonce(new Blob(nonce, copy));
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// Decode input as a EncryptedContent in NDN-TLV and set the fields of the
/// encryptedContent object.
/// </summary>
///
/// <param name="encryptedContent"></param>
/// <param name="input"></param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException">For invalid encoding</exception>
public override void decodeEncryptedContent(EncryptedContent encryptedContent,
ByteBuffer input, bool copy)
{
TlvDecoder decoder = new TlvDecoder(input);
int endOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptedContent);
Tlv0_2WireFormat.decodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator,
encryptedContent.getKeyLocator(), decoder, copy);
int algorithmType = (int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptionAlgorithm);
if (algorithmType == net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesEcb.getNumericType())
encryptedContent.setAlgorithmType(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesEcb);
else if (algorithmType == net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc.getNumericType())
encryptedContent.setAlgorithmType(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.AesCbc);
else if (algorithmType == net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaPkcs.getNumericType())
encryptedContent.setAlgorithmType(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaPkcs);
else if (algorithmType == net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep.getNumericType())
encryptedContent.setAlgorithmType(net.named_data.jndn.encrypt.algo.EncryptAlgorithmType.RsaOaep);
else
throw new EncodingException(
"Unrecognized EncryptionAlgorithm code " + algorithmType);
encryptedContent.setInitialVector(new Blob(decoder.readOptionalBlobTlv(
net.named_data.jndn.encoding.tlv.Tlv.Encrypt_InitialVector, endOffset), copy));
encryptedContent.setPayload(new Blob(decoder
.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptedPayload), copy));
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// Decode input as a sequence of NDN-TLV Delegation and set the fields of the
/// delegationSet object. Note that the sequence of Delegation does not have an
/// outer TLV type and length because it is intended to use the type and length
/// of a Data packet's Content. This ignores any elements after the sequence
/// of Delegation and before input.limit().
/// </summary>
///
/// <param name="delegationSet">The DelegationSet object whose fields are updated.</param>
/// <param name="input"></param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public override void decodeDelegationSet(DelegationSet delegationSet,
ByteBuffer input, bool copy)
{
TlvDecoder decoder = new TlvDecoder(input);
int endOffset = input.limit();
delegationSet.clear();
while (decoder.getOffset() < endOffset) {
decoder.readTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Link_Delegation);
int preference = (int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Link_Preference);
Name name = new Name();
decodeName(name, new int[1], new int[1], decoder, copy);
// Add unsorted to preserve the order so that Interest selected delegation
// index will work.
delegationSet.addUnsorted(preference, name);
}
}
/// <summary>
/// Decode input as a data packet in NDN-TLV and set the fields in the data
/// object.
/// </summary>
///
/// <param name="data">The Data object whose fields are updated.</param>
/// <param name="input"></param>
/// <param name="signedPortionBeginOffset">If you are not decoding in order to verify, you can call decodeData(data, input) to ignore this returned value.</param>
/// <param name="signedPortionEndOffset">not decoding in order to verify, you can call decodeData(data, input) to ignore this returned value.</param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public override void decodeData(Data data, ByteBuffer input,
int[] signedPortionBeginOffset, int[] signedPortionEndOffset,
bool copy)
{
TlvDecoder decoder = new TlvDecoder(input);
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Data);
signedPortionBeginOffset[0] = decoder.getOffset();
decodeName(data.getName(), new int[1], new int[1], decoder, copy);
decodeMetaInfo(data.getMetaInfo(), decoder, copy);
data.setContent(new Blob(decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Content), copy));
decodeSignatureInfo(data, decoder, copy);
signedPortionEndOffset[0] = decoder.getOffset();
data.getSignature().setSignature(
new Blob(decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureValue), copy));
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// An internal method to encode signature as the appropriate form of
/// SignatureInfo in NDN-TLV.
/// </summary>
///
/// <param name="signature">An object of a subclass of Signature to encode.</param>
/// <param name="encoder">The TlvEncoder to receive the encoding.</param>
private void encodeSignatureInfo(Signature signature, TlvEncoder encoder)
{
if (signature is GenericSignature) {
// Handle GenericSignature separately since it has the entire encoding.
Blob encoding = ((GenericSignature) signature)
.getSignatureInfoEncoding();
// Do a test decoding to sanity check that it is valid TLV.
try {
TlvDecoder decoder = new TlvDecoder(encoding.buf());
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.SignatureInfo);
decoder.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureType);
decoder.finishNestedTlvs(endOffset);
} catch (EncodingException ex) {
throw new Exception(
"The GenericSignature encoding is not a valid NDN-TLV SignatureInfo: "
+ ex.Message);
}
encoder.writeBuffer(encoding.buf());
return;
}
int saveLength = encoder.getLength();
// Encode backwards.
if (signature is Sha256WithRsaSignature) {
if (((Sha256WithRsaSignature) signature).getValidityPeriod()
.hasPeriod())
encodeValidityPeriod(
((Sha256WithRsaSignature) signature)
.getValidityPeriod(),
encoder);
encodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator,
((Sha256WithRsaSignature) signature).getKeyLocator(),
encoder);
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureType,
net.named_data.jndn.encoding.tlv.Tlv.SignatureType_SignatureSha256WithRsa);
} else if (signature is Sha256WithEcdsaSignature) {
if (((Sha256WithEcdsaSignature) signature).getValidityPeriod()
.hasPeriod())
encodeValidityPeriod(
((Sha256WithEcdsaSignature) signature)
.getValidityPeriod(),
encoder);
encodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator,
((Sha256WithEcdsaSignature) signature).getKeyLocator(),
encoder);
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureType,
net.named_data.jndn.encoding.tlv.Tlv.SignatureType_SignatureSha256WithEcdsa);
} else if (signature is HmacWithSha256Signature) {
encodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator,
((HmacWithSha256Signature) signature).getKeyLocator(),
encoder);
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureType,
net.named_data.jndn.encoding.tlv.Tlv.SignatureType_SignatureHmacWithSha256);
} else if (signature is DigestSha256Signature)
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureType,
net.named_data.jndn.encoding.tlv.Tlv.SignatureType_DigestSha256);
else
throw new Exception(
"encodeSignatureInfo: Unrecognized Signature object type");
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.SignatureInfo, encoder.getLength()
- saveLength);
}
/// <summary>
/// Decode signatureInfo as an NDN-TLV signature info and signatureValue as the
/// related NDN-TLV SignatureValue, and return a new object which is a subclass
/// of Signature.
/// </summary>
///
/// <param name="signatureInfo"></param>
/// <param name="signatureValue"></param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <returns>A new object which is a subclass of Signature.</returns>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public override Signature decodeSignatureInfoAndValue(ByteBuffer signatureInfo,
ByteBuffer signatureValue, bool copy)
{
// Use a SignatureHolder to imitate a Data object for _decodeSignatureInfo.
Tlv0_2WireFormat.SimpleSignatureHolder signatureHolder = new Tlv0_2WireFormat.SimpleSignatureHolder ();
TlvDecoder decoder = new TlvDecoder(signatureInfo);
decodeSignatureInfo(signatureHolder, decoder, copy);
decoder = new TlvDecoder(signatureValue);
signatureHolder.getSignature().setSignature(
new Blob(decoder.readBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureValue), copy));
return signatureHolder.getSignature();
}
/// <summary>
/// Decode the name component as NDN-TLV and return the component. This handles
/// different component types such as ImplicitSha256DigestComponent.
/// </summary>
///
/// <param name="decoder">The decoder with the input to decode.</param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <returns>A new Name.Component.</returns>
/// <exception cref="EncodingException"></exception>
private static Name.Component decodeNameComponent(TlvDecoder decoder,
bool copy)
{
int savePosition = decoder.getOffset();
int type = decoder.readVarNumber();
// Restore the position.
decoder.seek(savePosition);
Blob value_ren = new Blob(decoder.readBlobTlv(type), copy);
if (type == net.named_data.jndn.encoding.tlv.Tlv.ImplicitSha256DigestComponent)
return net.named_data.jndn.Name.Component.fromImplicitSha256Digest(value_ren);
else
return new Name.Component(value_ren);
}
private static void decodeControlParameters(
ControlParameters controlParameters, TlvDecoder decoder,
bool copy)
{
controlParameters.clear();
int endOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_ControlParameters);
// decode name
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Name, endOffset)) {
Name name = new Name();
decodeName(name, new int[1], new int[1], decoder, copy);
controlParameters.setName(name);
}
// decode face ID
controlParameters.setFaceId((int) decoder
.readOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_FaceId, endOffset));
// decode URI
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Uri, endOffset)) {
// Set copy false since we just immediately get the string.
Blob uri = new Blob(decoder.readOptionalBlobTlv(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Uri, endOffset), false);
controlParameters.setUri("" + uri);
}
// decode integers
controlParameters.setLocalControlFeature((int) decoder
.readOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_LocalControlFeature, endOffset));
controlParameters.setOrigin((int) decoder
.readOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Origin, endOffset));
controlParameters.setCost((int) decoder
.readOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Cost,
endOffset));
// set forwarding flags
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Flags, endOffset)) {
ForwardingFlags flags = new ForwardingFlags();
flags.setNfdForwardingFlags((int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Flags));
controlParameters.setForwardingFlags(flags);
}
// decode strategy
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Strategy, endOffset)) {
int strategyEndOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Strategy);
decodeName(controlParameters.getStrategy(), new int[1], new int[1],
decoder, copy);
decoder.finishNestedTlvs(strategyEndOffset);
}
// decode expiration period
controlParameters.setExpirationPeriod(decoder
.readOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_ExpirationPeriod, endOffset));
decoder.finishNestedTlvs(endOffset);
}
private static void decodeSignatureInfo(SignatureHolder signatureHolder,
TlvDecoder decoder, bool copy)
{
int beginOffset = decoder.getOffset();
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.SignatureInfo);
int signatureType = (int) decoder
.readNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureType);
if (signatureType == net.named_data.jndn.encoding.tlv.Tlv.SignatureType_SignatureSha256WithRsa) {
signatureHolder.setSignature(new Sha256WithRsaSignature());
// Modify the holder's signature object because if we create an object
// and set it, then the holder will have to copy all the fields.
Sha256WithRsaSignature signatureInfo = (Sha256WithRsaSignature) signatureHolder
.getSignature();
decodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator, signatureInfo.getKeyLocator(),
decoder, copy);
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.ValidityPeriod_ValidityPeriod, endOffset))
decodeValidityPeriod(signatureInfo.getValidityPeriod(), decoder);
} else if (signatureType == net.named_data.jndn.encoding.tlv.Tlv.SignatureType_SignatureSha256WithEcdsa) {
signatureHolder.setSignature(new Sha256WithEcdsaSignature());
Sha256WithEcdsaSignature signatureInfo_0 = (Sha256WithEcdsaSignature) signatureHolder
.getSignature();
decodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator, signatureInfo_0.getKeyLocator(),
decoder, copy);
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.ValidityPeriod_ValidityPeriod, endOffset))
decodeValidityPeriod(signatureInfo_0.getValidityPeriod(), decoder);
} else if (signatureType == net.named_data.jndn.encoding.tlv.Tlv.SignatureType_SignatureHmacWithSha256) {
signatureHolder.setSignature(new HmacWithSha256Signature());
HmacWithSha256Signature signatureInfo_1 = (HmacWithSha256Signature) signatureHolder
.getSignature();
decodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator, signatureInfo_1.getKeyLocator(),
decoder, copy);
} else if (signatureType == net.named_data.jndn.encoding.tlv.Tlv.SignatureType_DigestSha256)
signatureHolder.setSignature(new DigestSha256Signature());
else {
signatureHolder.setSignature(new GenericSignature());
GenericSignature signatureInfo_2 = (GenericSignature) signatureHolder
.getSignature();
// Get the bytes of the SignatureInfo TLV.
signatureInfo_2.setSignatureInfoEncoding(
new Blob(decoder.getSlice(beginOffset, endOffset), copy),
signatureType);
}
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// Decode input as a control parameters in NDN-TLV and set the fields of the
/// controlParameters object.
/// </summary>
///
/// <param name="controlParameters"></param>
/// <param name="input"></param>
/// <param name="copy">unchanged while the Blob values are used.</param>
/// <exception cref="EncodingException">For invalid encoding</exception>
public override void decodeControlParameters(ControlParameters controlParameters,
ByteBuffer input, bool copy)
{
TlvDecoder decoder = new TlvDecoder(input);
decodeControlParameters(controlParameters, decoder, copy);
}
/// <summary>
/// Decode the input and update this Schedule object.
/// </summary>
///
/// <param name="input"></param>
/// <exception cref="EncodingException">For invalid encoding.</exception>
public void wireDecode(ByteBuffer input)
{
// For now, don't use WireFormat and hardcode to use TLV since the encoding
// doesn't go out over the wire, only into the local SQL database.
TlvDecoder decoder = new TlvDecoder(input);
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_Schedule);
// Decode the whiteIntervalList.
ILOG.J2CsMapping.Collections.Collections.Clear(whiteIntervalList_);
int listEndOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_WhiteIntervalList);
while (decoder.getOffset() < listEndOffset)
ILOG.J2CsMapping.Collections.Collections.Add(whiteIntervalList_,decodeRepetitiveInterval(decoder));
decoder.finishNestedTlvs(listEndOffset);
// Decode the blackIntervalList.
ILOG.J2CsMapping.Collections.Collections.Clear(blackIntervalList_);
listEndOffset = decoder
.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_BlackIntervalList);
while (decoder.getOffset() < listEndOffset)
ILOG.J2CsMapping.Collections.Collections.Add(blackIntervalList_,decodeRepetitiveInterval(decoder));
decoder.finishNestedTlvs(listEndOffset);
decoder.finishNestedTlvs(endOffset);
}
private static void decodeExclude(Exclude exclude, TlvDecoder decoder,
bool copy)
{
int endOffset = decoder.readNestedTlvsStart(net.named_data.jndn.encoding.tlv.Tlv.Exclude);
exclude.clear();
while (decoder.getOffset() < endOffset) {
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Any, endOffset)) {
// Read past the Any TLV.
decoder.readBooleanTlv(net.named_data.jndn.encoding.tlv.Tlv.Any, endOffset);
exclude.appendAny();
} else
exclude.appendComponent(decodeNameComponent(decoder, copy));
}
decoder.finishNestedTlvs(endOffset);
}
/// <summary>
/// Continue scanning input starting from offset_ to find the element end.
/// If the end of the element which started at offset 0 is found, this returns
/// true and getOffset() is the length of the element. Otherwise, this returns
/// false which means you should read more into input and call again.
/// </summary>
///
/// <param name="input">You have to pass in input each time because the buffer could be reallocated.</param>
/// <returns>true if found the element end, false if not.</returns>
public bool findElementEnd(ByteBuffer input)
{
if (gotElementEnd_)
{
// Someone is calling when we already got the end.
return(true);
}
TlvDecoder decoder = new TlvDecoder(input);
while (true)
{
if (offset_ >= input.limit())
{
// All the cases assume we have some input. Return and wait for more.
return(false);
}
if (state_ == TlvStructureDecoder.READ_TYPE)
{
int firstOctet = (int)input.get(offset_) & 0xff;
offset_ += 1;
if (firstOctet < 253)
{
// The value is simple, so we can skip straight to reading the length.
state_ = TlvStructureDecoder.READ_LENGTH;
}
else
{
// Set up to skip the type bytes.
if (firstOctet == 253)
{
nBytesToRead_ = 2;
}
else if (firstOctet == 254)
{
nBytesToRead_ = 4;
}
else
{
// value == 255.
nBytesToRead_ = 8;
}
state_ = TlvStructureDecoder.READ_TYPE_BYTES;
}
}
else if (state_ == TlvStructureDecoder.READ_TYPE_BYTES)
{
int nRemainingBytes = input.limit() - offset_;
if (nRemainingBytes < nBytesToRead_)
{
// Need more.
offset_ += nRemainingBytes;
nBytesToRead_ -= nRemainingBytes;
return(false);
}
// Got the type bytes. Move on to read the length.
offset_ += nBytesToRead_;
state_ = TlvStructureDecoder.READ_LENGTH;
}
else if (state_ == TlvStructureDecoder.READ_LENGTH)
{
int firstOctet_0 = (int)input.get(offset_) & 0xff;
offset_ += 1;
if (firstOctet_0 < 253)
{
// The value is simple, so we can skip straight to reading
// the value bytes.
nBytesToRead_ = firstOctet_0;
if (nBytesToRead_ == 0)
{
// No value bytes to read. We're finished.
gotElementEnd_ = true;
return(true);
}
state_ = TlvStructureDecoder.READ_VALUE_BYTES;
}
else
{
// We need to read the bytes in the extended encoding of
// the length.
if (firstOctet_0 == 253)
{
nBytesToRead_ = 2;
}
else if (firstOctet_0 == 254)
{
nBytesToRead_ = 4;
}
else
{
// value == 255.
nBytesToRead_ = 8;
}
// We need to use firstOctet in the next state.
firstOctet_ = firstOctet_0;
state_ = TlvStructureDecoder.READ_LENGTH_BYTES;
}
}
else if (state_ == TlvStructureDecoder.READ_LENGTH_BYTES)
{
int nRemainingBytes_1 = input.limit() - offset_;
if (!useHeaderBuffer_ && nRemainingBytes_1 >= nBytesToRead_)
{
// We don't have to use the headerBuffer. Set nBytesToRead.
decoder.seek(offset_);
nBytesToRead_ = decoder.readExtendedVarNumber(firstOctet_);
// Update offset_ to the decoder's offset after reading.
offset_ = decoder.getOffset();
}
else
{
useHeaderBuffer_ = true;
int nNeededBytes = nBytesToRead_ - headerBuffer_.position();
if (nNeededBytes > nRemainingBytes_1)
{
// We can't get all of the header bytes from this input.
// Save in headerBuffer.
if (headerBuffer_.position() + nRemainingBytes_1 > headerBuffer_
.limit())
{
// We don't expect this to happen.
throw new Exception(
"Cannot store more header bytes than the size of headerBuffer");
}
ByteBuffer remainingInput = input.duplicate();
remainingInput.position(offset_);
headerBuffer_.put(remainingInput);
offset_ += nRemainingBytes_1;
return(false);
}
// Copy the remaining bytes into headerBuffer, read the
// length and set nBytesToRead.
if (headerBuffer_.position() + nNeededBytes > headerBuffer_
.limit())
{
// We don't expect this to happen.
throw new Exception(
"Cannot store more header bytes than the size of headerBuffer");
}
ByteBuffer remainingLengthBytes = input.duplicate();
remainingLengthBytes.position(offset_);
remainingLengthBytes.limit(offset_ + nNeededBytes);
headerBuffer_.put(remainingLengthBytes);
offset_ += nNeededBytes;
// Use a local decoder just for the headerBuffer.
headerBuffer_.flip();
TlvDecoder bufferDecoder = new TlvDecoder(headerBuffer_);
// Replace nBytesToRead with the length of the value.
nBytesToRead_ = bufferDecoder
.readExtendedVarNumber(firstOctet_);
}
if (nBytesToRead_ == 0)
{
// No value bytes to read. We're finished.
gotElementEnd_ = true;
return(true);
}
// Get ready to read the value bytes.
state_ = TlvStructureDecoder.READ_VALUE_BYTES;
}
else if (state_ == TlvStructureDecoder.READ_VALUE_BYTES)
{
int nRemainingBytes_2 = input.limit() - offset_;
if (nRemainingBytes_2 < nBytesToRead_)
{
// Need more.
offset_ += nRemainingBytes_2;
nBytesToRead_ -= nRemainingBytes_2;
return(false);
}
// Got the bytes. We're finished.
offset_ += nBytesToRead_;
gotElementEnd_ = true;
return(true);
}
else
{
// We don't expect this to happen.
throw new Exception("findElementEnd: unrecognized state");
}
}
}
public void onReceivedElement(ByteBuffer element)
{
LpPacket lpPacket = null;
if (element.get(0) == net.named_data.jndn.encoding.tlv.Tlv.LpPacket_LpPacket) {
// Decode the LpPacket and replace element with the fragment.
lpPacket = new LpPacket();
// Set copy false so that the fragment is a slice which will be copied below.
// The header fields are all integers and don't need to be copied.
net.named_data.jndn.encoding.TlvWireFormat.get().decodeLpPacket(lpPacket, element, false);
element = lpPacket.getFragmentWireEncoding().buf();
}
// First, decode as Interest or Data.
Interest interest = null;
Data data = null;
if (element.get(0) == net.named_data.jndn.encoding.tlv.Tlv.Interest || element.get(0) == net.named_data.jndn.encoding.tlv.Tlv.Data) {
TlvDecoder decoder = new TlvDecoder(element);
if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Interest, element.remaining())) {
interest = new Interest();
interest.wireDecode(element, net.named_data.jndn.encoding.TlvWireFormat.get());
if (lpPacket != null)
interest.setLpPacket(lpPacket);
} else if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Data, element.remaining())) {
data = new Data();
data.wireDecode(element, net.named_data.jndn.encoding.TlvWireFormat.get());
if (lpPacket != null)
data.setLpPacket(lpPacket);
}
}
if (lpPacket != null) {
// We have decoded the fragment, so remove the wire encoding to save memory.
lpPacket.setFragmentWireEncoding(new Blob());
NetworkNack networkNack = net.named_data.jndn.NetworkNack.getFirstHeader(lpPacket);
if (networkNack != null) {
if (interest == null)
// We got a Nack but not for an Interest, so drop the packet.
return;
ArrayList<PendingInterestTable.Entry> pitEntries = new ArrayList<PendingInterestTable.Entry>();
pendingInterestTable_.extractEntriesForNackInterest(interest,
pitEntries);
for (int i = 0; i < pitEntries.Count; ++i) {
PendingInterestTable.Entry pendingInterest = pitEntries[i];
try {
pendingInterest.getOnNetworkNack().onNetworkNack(
pendingInterest.getInterest(), networkNack);
} catch (Exception ex) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onNack", ex);
}
}
// We have processed the network Nack packet.
return;
}
}
// Now process as Interest or Data.
if (interest != null) {
// Quickly lock and get all interest filter callbacks which match.
ArrayList matchedFilters = new ArrayList();
interestFilterTable_.getMatchedFilters(interest, matchedFilters);
// The lock on interestFilterTable_ is released, so call the callbacks.
for (int i_0 = 0; i_0 < matchedFilters.Count; ++i_0) {
InterestFilterTable.Entry entry = (InterestFilterTable.Entry) matchedFilters[i_0];
try {
entry.getOnInterest().onInterest(
entry.getFilter().getPrefix(), interest,
entry.getFace(), entry.getInterestFilterId(),
entry.getFilter());
} catch (Exception ex_1) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onInterest", ex_1);
}
}
} else if (data != null) {
ArrayList<PendingInterestTable.Entry> pitEntries_2 = new ArrayList<PendingInterestTable.Entry>();
pendingInterestTable_.extractEntriesForExpressedInterest(data,
pitEntries_2);
for (int i_3 = 0; i_3 < pitEntries_2.Count; ++i_3) {
PendingInterestTable.Entry pendingInterest_4 = pitEntries_2[i_3];
try {
pendingInterest_4.getOnData().onData(
pendingInterest_4.getInterest(), data);
} catch (Exception ex_5) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onData", ex_5);
}
}
}
}
