/// <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>
/// 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));
}
/// <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 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 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 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);
}
/// <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);
}
/// <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 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>
/// 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 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 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 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);
}