/// <summary>
/// Append a timestamp component and a random value component to interest's
/// name. This ensures that the timestamp is greater than the timestamp used in
/// the previous call. Then use keyChain to sign the interest which appends a
/// SignatureInfo component and a component with the signature bits. If the
/// interest lifetime is not set, this sets it.
/// </summary>
///
/// <param name="interest">The interest whose name is append with components.</param>
/// <param name="keyChain">The KeyChain for calling sign.</param>
/// <param name="certificateName">The certificate name of the key to use for signing.</param>
/// <param name="wireFormat"></param>
public void generate(Interest interest, KeyChain keyChain,
Name certificateName, WireFormat wireFormat)
{
double timestamp;
lock (lastTimestampLock_) {
timestamp = Math.Round(net.named_data.jndn.util.Common.getNowMilliseconds(),MidpointRounding.AwayFromZero);
while (timestamp <= lastTimestamp_)
timestamp += 1.0d;
// Update the timestamp now while it is locked. In the small chance that
// signing fails, it just means that we have bumped the timestamp.
lastTimestamp_ = timestamp;
}
// The timestamp is encoded as a TLV nonNegativeInteger.
TlvEncoder encoder = new TlvEncoder(8);
encoder.writeNonNegativeInteger((long) timestamp);
interest.getName().append(new Blob(encoder.getOutput(), false));
// The random value is a TLV nonNegativeInteger too, but we know it is 8 bytes,
// so we don't need to call the nonNegativeInteger encoder.
ByteBuffer randomBuffer = ILOG.J2CsMapping.NIO.ByteBuffer.allocate(8);
// Note: SecureRandom is thread safe.
net.named_data.jndn.util.Common.getRandom().nextBytes(randomBuffer.array());
interest.getName().append(new Blob(randomBuffer, false));
keyChain.sign(interest, certificateName, wireFormat);
if (interest.getInterestLifetimeMilliseconds() < 0)
// The caller has not set the interest lifetime, so set it here.
interest.setInterestLifetimeMilliseconds(1000.0d);
}
/// <summary>
/// Encode signature as a SignatureInfo in NDN-TLV and return the encoding.
/// </summary>
///
/// <param name="signature">An object of a subclass of Signature to encode.</param>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeSignatureInfo(Signature signature)
{
TlvEncoder encoder = new TlvEncoder(256);
encodeSignatureInfo(signature, encoder);
return new Blob(encoder.getOutput(), false);
}
/// <summary>
/// Encode name in NDN-TLV and return the encoding.
/// </summary>
///
/// <param name="name">The Name object to encode.</param>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeName(Name name)
{
TlvEncoder encoder = new TlvEncoder();
encodeName(name, new int[1], new int[1], encoder);
return new Blob(encoder.getOutput(), false);
}
/// <summary>
/// Encode interest using NDN-TLV and return the encoding.
/// </summary>
///
/// <param name="interest">The Interest object to encode.</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>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeInterest(Interest interest,
int[] signedPortionBeginOffset, int[] signedPortionEndOffset)
{
TlvEncoder encoder = new TlvEncoder();
int saveLength = encoder.getLength();
// Encode backwards.
encoder.writeOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.SelectedDelegation,
interest.getSelectedDelegationIndex());
try {
Blob linkWireEncoding = interest.getLinkWireEncoding(this);
if (!linkWireEncoding.isNull())
// Encode the entire link as is.
encoder.writeBuffer(linkWireEncoding.buf());
} catch (EncodingException ex) {
throw new Exception(ex.Message);
}
encoder.writeOptionalNonNegativeIntegerTlvFromDouble(
net.named_data.jndn.encoding.tlv.Tlv.InterestLifetime,
interest.getInterestLifetimeMilliseconds());
// Encode the Nonce as 4 bytes.
if (interest.getNonce().size() == 0) {
// This is the most common case. Generate a nonce.
ByteBuffer nonce = ILOG.J2CsMapping.NIO.ByteBuffer.allocate(4);
random_.nextBytes(nonce.array());
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce, nonce);
} else if (interest.getNonce().size() < 4) {
ByteBuffer nonce_0 = ILOG.J2CsMapping.NIO.ByteBuffer.allocate(4);
// Copy existing nonce bytes.
nonce_0.put(interest.getNonce().buf());
// Generate random bytes for remaining bytes in the nonce.
for (int i = 0; i < 4 - interest.getNonce().size(); ++i)
nonce_0.put((byte) random_.Next());
nonce_0.flip();
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce, nonce_0);
} else if (interest.getNonce().size() == 4)
// Use the nonce as-is.
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce, interest.getNonce().buf());
else {
// Truncate.
ByteBuffer nonce_1 = interest.getNonce().buf();
// buf() returns a new ByteBuffer, so we can change its limit.
nonce_1.limit(nonce_1.position() + 4);
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Nonce, nonce_1);
}
encodeSelectors(interest, encoder);
int[] tempSignedPortionBeginOffset = new int[1];
int[] tempSignedPortionEndOffset = new int[1];
encodeName(interest.getName(), tempSignedPortionBeginOffset,
tempSignedPortionEndOffset, encoder);
int signedPortionBeginOffsetFromBack = encoder.getLength()
- tempSignedPortionBeginOffset[0];
int signedPortionEndOffsetFromBack = encoder.getLength()
- tempSignedPortionEndOffset[0];
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Interest, encoder.getLength()
- saveLength);
signedPortionBeginOffset[0] = encoder.getLength()
- signedPortionBeginOffsetFromBack;
signedPortionEndOffset[0] = encoder.getLength()
- signedPortionEndOffsetFromBack;
return new Blob(encoder.getOutput(), false);
}
private static void encodeMetaInfo(MetaInfo metaInfo, TlvEncoder encoder)
{
int saveLength = encoder.getLength();
// Encode backwards.
ByteBuffer finalBlockIdBuf = metaInfo.getFinalBlockId().getValue()
.buf();
if (finalBlockIdBuf != null && finalBlockIdBuf.remaining() > 0) {
// FinalBlockId has an inner NameComponent.
int finalBlockIdSaveLength = encoder.getLength();
encodeNameComponent(metaInfo.getFinalBlockId(), encoder);
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.FinalBlockId, encoder.getLength()
- finalBlockIdSaveLength);
}
encoder.writeOptionalNonNegativeIntegerTlvFromDouble(
net.named_data.jndn.encoding.tlv.Tlv.FreshnessPeriod, metaInfo.getFreshnessPeriod());
if (!(metaInfo.getType() == net.named_data.jndn.ContentType.BLOB)) {
// Not the default, so we need to encode the type.
if (metaInfo.getType() == net.named_data.jndn.ContentType.LINK
|| metaInfo.getType() == net.named_data.jndn.ContentType.KEY
|| metaInfo.getType() == net.named_data.jndn.ContentType.NACK)
// The ContentType enum is set up with the correct integer for
// each NDN-TLV ContentType.
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.ContentType, metaInfo
.getType().getNumericType());
else if (metaInfo.getType() == net.named_data.jndn.ContentType.OTHER_CODE)
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.ContentType,
metaInfo.getOtherTypeCode());
else
// We don't expect this to happen.
throw new Exception("unrecognized TLV ContentType");
}
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.MetaInfo, encoder.getLength()
- saveLength);
}
/// <summary>
/// Create a component whose value is the nonNegativeInteger encoding of the
/// number.
/// </summary>
///
/// <param name="number">The number to be encoded.</param>
/// <returns>The component value.</returns>
public static Name.Component fromNumber(long number)
{
if (number < 0)
number = 0;
TlvEncoder encoder = new TlvEncoder(8);
encoder.writeNonNegativeInteger(number);
return new Name.Component (new Blob(encoder.getOutput(), false));
}
/// <summary>
/// Encode the RepetitiveInterval as NDN-TLV to the encoder.
/// </summary>
///
/// <param name="repetitiveInterval">The RepetitiveInterval to encode.</param>
/// <param name="encoder">The TlvEncoder to receive the encoding.</param>
private static void encodeRepetitiveInterval(
RepetitiveInterval repetitiveInterval, TlvEncoder encoder)
{
int saveLength = encoder.getLength();
// Encode backwards.
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_RepeatUnit,
net.named_data.jndn.encrypt.RepetitiveInterval.getRepeatUnitNumericType(repetitiveInterval
.getRepeatUnit()));
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_NRepeats,
repetitiveInterval.getNRepeats());
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_IntervalEndHour,
repetitiveInterval.getIntervalEndHour());
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_IntervalStartHour,
repetitiveInterval.getIntervalStartHour());
// Use Blob to convert the string to UTF8 encoding.
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EndDate, new Blob(
toIsoString(repetitiveInterval.getEndDate())).buf());
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_StartDate, new Blob(
toIsoString(repetitiveInterval.getStartDate())).buf());
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_RepetitiveInterval,
encoder.getLength() - saveLength);
}
private static void encodeExclude(Exclude exclude, TlvEncoder encoder)
{
int saveLength = encoder.getLength();
// TODO: Do we want to order the components (except for ANY)?
// Encode the entries backwards.
for (int i = exclude.size() - 1; i >= 0; --i) {
Exclude.Entry entry = exclude.get(i);
if (entry.getType() == net.named_data.jndn.Exclude.Type.ANY)
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Any, 0);
else
encodeNameComponent(entry.getComponent(), encoder);
}
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Exclude, encoder.getLength()
- saveLength);
}
/// <summary>
/// Encode controlParameters in NDN-TLV and return the encoding.
/// </summary>
///
/// <param name="controlParameters">The ControlParameters object to encode.</param>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeControlParameters(ControlParameters controlParameters)
{
TlvEncoder encoder = new TlvEncoder(256);
encodeControlParameters(controlParameters, encoder);
return new Blob(encoder.getOutput(), false);
}
/// <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);
}
private static void encodeValidityPeriod(ValidityPeriod validityPeriod,
TlvEncoder encoder)
{
int saveLength = encoder.getLength();
// Encode backwards.
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.ValidityPeriod_NotAfter,
new Blob(net.named_data.jndn.encrypt.Schedule.toIsoString(validityPeriod.getNotAfter()))
.buf());
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.ValidityPeriod_NotBefore,
new Blob(net.named_data.jndn.encrypt.Schedule.toIsoString(validityPeriod.getNotBefore()))
.buf());
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.ValidityPeriod_ValidityPeriod,
encoder.getLength() - saveLength);
}
/// <summary>
/// Encode the interest selectors. If no selectors are written, do not output
/// a Selectors TLV.
/// </summary>
///
private static void encodeSelectors(Interest interest, TlvEncoder encoder)
{
int saveLength = encoder.getLength();
// Encode backwards.
if (interest.getMustBeFresh())
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.MustBeFresh, 0);
encoder.writeOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.ChildSelector,
interest.getChildSelector());
if (interest.getExclude().size() > 0)
encodeExclude(interest.getExclude(), encoder);
if (interest.getKeyLocator().getType() != net.named_data.jndn.KeyLocatorType.NONE)
encodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.PublisherPublicKeyLocator,
interest.getKeyLocator(), encoder);
encoder.writeOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.MaxSuffixComponents,
interest.getMaxSuffixComponents());
encoder.writeOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.MinSuffixComponents,
interest.getMinSuffixComponents());
// Only output the type and length if values were written.
if (encoder.getLength() != saveLength)
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Selectors, encoder.getLength()
- saveLength);
}
/// <summary>
/// Encode the name component to the encoder as NDN-TLV. This handles different
/// component types such as ImplicitSha256DigestComponent.
/// </summary>
///
/// <param name="component">The name component to encode.</param>
/// <param name="encoder">The TlvEncoder to receive the encoding.</param>
private static void encodeNameComponent(Name.Component component,
TlvEncoder encoder)
{
int type = (component.isImplicitSha256Digest()) ? net.named_data.jndn.encoding.tlv.Tlv.ImplicitSha256DigestComponent
: net.named_data.jndn.encoding.tlv.Tlv.NameComponent;
encoder.writeBlobTlv(type, component.getValue().buf());
}
/// <summary>
/// Encode the name as NDN-TLV to the encoder.
/// </summary>
///
/// <param name="name">The name to encode.</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="encoder">The TlvEncoder to receive the encoding.</param>
private static void encodeName(Name name, int[] signedPortionBeginOffset,
int[] signedPortionEndOffset, TlvEncoder encoder)
{
int saveLength = encoder.getLength();
// Encode the components backwards.
int signedPortionEndOffsetFromBack = 0;
for (int i = name.size() - 1; i >= 0; --i) {
encodeNameComponent(name.get(i), encoder);
if (i == name.size() - 1)
signedPortionEndOffsetFromBack = encoder.getLength();
}
int signedPortionBeginOffsetFromBack = encoder.getLength();
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Name, encoder.getLength() - saveLength);
signedPortionBeginOffset[0] = encoder.getLength()
- signedPortionBeginOffsetFromBack;
if (name.size() == 0)
// There is no "final component", so set signedPortionEndOffset
// arbitrarily.
signedPortionEndOffset[0] = signedPortionBeginOffset[0];
else
signedPortionEndOffset[0] = encoder.getLength()
- signedPortionEndOffsetFromBack;
}
/// <summary>
/// Encode the signatureValue in the Signature object as a SignatureValue (the
/// signature bits) in NDN-TLV and return the encoding.
/// </summary>
///
/// <param name="signature"></param>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeSignatureValue(Signature signature)
{
TlvEncoder encoder = new TlvEncoder(256);
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureValue, signature.getSignature().buf());
return new Blob(encoder.getOutput(), false);
}
private static void encodeControlParameters(
ControlParameters controlParameters, TlvEncoder encoder)
{
int saveLength = encoder.getLength();
// Encode backwards.
encoder.writeOptionalNonNegativeIntegerTlvFromDouble(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_ExpirationPeriod,
controlParameters.getExpirationPeriod());
// Encode strategy
if (controlParameters.getStrategy().size() != 0) {
int strategySaveLength = encoder.getLength();
encodeName(controlParameters.getStrategy(), new int[1], new int[1],
encoder);
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Strategy,
encoder.getLength() - strategySaveLength);
}
// Encode ForwardingFlags
int flags = controlParameters.getForwardingFlags()
.getNfdForwardingFlags();
if (flags != new ForwardingFlags().getNfdForwardingFlags())
// The flags are not the default value.
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Flags,
flags);
encoder.writeOptionalNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Cost,
controlParameters.getCost());
encoder.writeOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Origin, controlParameters.getOrigin());
encoder.writeOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_LocalControlFeature,
controlParameters.getLocalControlFeature());
// Encode URI
if (controlParameters.getUri().Length != 0) {
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_Uri, new Blob(
controlParameters.getUri()).buf());
}
encoder.writeOptionalNonNegativeIntegerTlv(
net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_FaceId, controlParameters.getFaceId());
// Encode name
if (controlParameters.getName() != null) {
encodeName(controlParameters.getName(), new int[1], new int[1],
encoder);
}
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.ControlParameters_ControlParameters,
encoder.getLength() - saveLength);
}
/// <summary>
/// Encode controlResponse in NDN-TLV and return the encoding.
/// </summary>
///
/// <param name="controlResponse">The ControlResponse object to encode.</param>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeControlResponse(ControlResponse controlResponse)
{
TlvEncoder encoder = new TlvEncoder(256);
int saveLength = encoder.getLength();
// Encode backwards.
// Encode the body.
if (controlResponse.getBodyAsControlParameters() != null)
encodeControlParameters(
controlResponse.getBodyAsControlParameters(), encoder);
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_StatusText, new Blob(
controlResponse.getStatusText()).buf());
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_StatusCode,
controlResponse.getStatusCode());
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.NfdCommand_ControlResponse,
encoder.getLength() - saveLength);
return new Blob(encoder.getOutput(), false);
}
/// <summary>
/// Encode this Schedule.
/// </summary>
///
/// <returns>The encoded buffer.</returns>
public Blob wireEncode()
{
// 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.
TlvEncoder encoder = new TlvEncoder(256);
int saveLength = encoder.getLength();
// Encode backwards.
// Encode the blackIntervalList.
int saveLengthForList = encoder.getLength();
Object[] array = ILOG.J2CsMapping.Collections.Collections.ToArray(blackIntervalList_);
System.Array.Sort(array);
for (int i = array.Length - 1; i >= 0; --i) {
RepetitiveInterval element = (RepetitiveInterval) array[i];
encodeRepetitiveInterval(element, encoder);
}
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_BlackIntervalList,
encoder.getLength() - saveLengthForList);
// Encode the whiteIntervalList.
saveLengthForList = encoder.getLength();
array = ILOG.J2CsMapping.Collections.Collections.ToArray(whiteIntervalList_);
System.Array.Sort(array);
for (int i_0 = array.Length - 1; i_0 >= 0; --i_0) {
RepetitiveInterval element_1 = (RepetitiveInterval) array[i_0];
encodeRepetitiveInterval(element_1, encoder);
}
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_WhiteIntervalList,
encoder.getLength() - saveLengthForList);
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_Schedule, encoder.getLength()
- saveLength);
return new Blob(encoder.getOutput(), false);
}
/// <summary>
/// Encode data in NDN-TLV and return the encoding.
/// </summary>
///
/// <param name="data">The Data object to encode.</param>
/// <param name="signedPortionBeginOffset">If you are not encoding in order to sign, you can call encodeData(data) to ignore this returned value.</param>
/// <param name="signedPortionEndOffset">If you are not encoding in order to sign, you can call encodeData(data) to ignore this returned value.</param>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeData(Data data, int[] signedPortionBeginOffset,
int[] signedPortionEndOffset)
{
TlvEncoder encoder = new TlvEncoder(1500);
int saveLength = encoder.getLength();
// Encode backwards.
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.SignatureValue, (data.getSignature())
.getSignature().buf());
int signedPortionEndOffsetFromBack = encoder.getLength();
encodeSignatureInfo(data.getSignature(), encoder);
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Content, data.getContent().buf());
encodeMetaInfo(data.getMetaInfo(), encoder);
encodeName(data.getName(), new int[1], new int[1], encoder);
int signedPortionBeginOffsetFromBack = encoder.getLength();
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Data, encoder.getLength() - saveLength);
signedPortionBeginOffset[0] = encoder.getLength()
- signedPortionBeginOffsetFromBack;
signedPortionEndOffset[0] = encoder.getLength()
- signedPortionEndOffsetFromBack;
return new Blob(encoder.getOutput(), false);
}
/// <summary>
/// Encode delegationSet as a sequence of NDN-TLV Delegation, and return the
/// encoding. 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.
/// </summary>
///
/// <param name="delegationSet">The DelegationSet object to encode.</param>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeDelegationSet(DelegationSet delegationSet)
{
TlvEncoder encoder = new TlvEncoder(256);
// Encode backwards.
for (int i = delegationSet.size() - 1; i >= 0; --i) {
int saveLength = encoder.getLength();
encodeName(delegationSet.get(i).getName(), new int[1], new int[1],
encoder);
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Link_Preference,
delegationSet.get(i).getPreference());
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Link_Delegation, encoder.getLength()
- saveLength);
}
return new Blob(encoder.getOutput(), false);
}
/// <summary>
/// Encode the EncryptedContent in NDN-TLV and return the encoding.
/// </summary>
///
/// <param name="encryptedContent">The EncryptedContent object to encode.</param>
/// <returns>A Blob containing the encoding.</returns>
public override Blob encodeEncryptedContent(EncryptedContent encryptedContent)
{
TlvEncoder encoder = new TlvEncoder(256);
int saveLength = encoder.getLength();
// Encode backwards.
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptedPayload, encryptedContent
.getPayload().buf());
encoder.writeOptionalBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_InitialVector,
encryptedContent.getInitialVector().buf());
// Assume the algorithmType value is the same as the TLV type.
encoder.writeNonNegativeIntegerTlv(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptionAlgorithm,
encryptedContent.getAlgorithmType().getNumericType());
Tlv0_2WireFormat.encodeKeyLocator(net.named_data.jndn.encoding.tlv.Tlv.KeyLocator,
encryptedContent.getKeyLocator(), encoder);
encoder.writeTypeAndLength(net.named_data.jndn.encoding.tlv.Tlv.Encrypt_EncryptedContent,
encoder.getLength() - saveLength);
return new Blob(encoder.getOutput(), false);
}
/// <summary>
/// Create a component whose value is the marker appended with the
/// nonNegativeInteger encoding of the number.
/// </summary>
///
/// <param name="number">The number to be encoded.</param>
/// <param name="marker">The marker to use as the first byte of the component.</param>
/// <returns>The component value.</returns>
public static Name.Component fromNumberWithMarker(long number, int marker)
{
if (number < 0)
number = 0;
TlvEncoder encoder = new TlvEncoder(9);
// Encode backwards.
encoder.writeNonNegativeInteger(number);
encoder.writeNonNegativeInteger((long) marker);
return new Name.Component (new Blob(encoder.getOutput(), false));
}
private static void encodeKeyLocator(int type, KeyLocator keyLocator,
TlvEncoder encoder)
{
int saveLength = encoder.getLength();
// Encode backwards.
if (keyLocator.getType() != net.named_data.jndn.KeyLocatorType.NONE) {
if (keyLocator.getType() == net.named_data.jndn.KeyLocatorType.KEYNAME)
encodeName(keyLocator.getKeyName(), new int[1], new int[1],
encoder);
else if (keyLocator.getType() == net.named_data.jndn.KeyLocatorType.KEY_LOCATOR_DIGEST
&& keyLocator.getKeyData().size() > 0)
encoder.writeBlobTlv(net.named_data.jndn.encoding.tlv.Tlv.KeyLocatorDigest, keyLocator
.getKeyData().buf());
else
throw new Exception("Unrecognized KeyLocatorType "
+ keyLocator.getType());
}
encoder.writeTypeAndLength(type, encoder.getLength() - saveLength);
}