/// <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);
}
public ValidationRequest checkVerificationPolicy(Interest interest,
int stepCount, OnVerifiedInterest onVerified,
OnInterestValidationFailed onValidationFailed)
{
return checkVerificationPolicy(interest, stepCount, onVerified,
onValidationFailed, net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details.
/// </summary>
///
public override long expressInterest(Interest interest_0, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat_1)
{
long pendingInterestId_2 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_3 = onData;
OnData onDataSubmit_4 = new ThreadPoolFace.Anonymous_C14 (this, finalOnData_3);
OnTimeout finalOnTimeout_5 = onTimeout;
OnTimeout onTimeoutSubmit_6 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C13 (this, finalOnTimeout_5);
OnNetworkNack finalOnNetworkNack_7 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_8 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C12 (this, finalOnNetworkNack_7);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_9 = new Interest(interest_0);
threadPool_.submit(new ThreadPoolFace.Anonymous_C11 (this, onNetworkNackSubmit_8, onDataSubmit_4,
interestCopy_9, onTimeoutSubmit_6, pendingInterestId_2, wireFormat_1));
return pendingInterestId_2;
}
public void testMaxNdnPacketSize()
{
// Construct an interest whose encoding is one byte larger than getMaxNdnPacketSize.
int targetSize = net.named_data.jndn.Face.getMaxNdnPacketSize() + 1;
// Start with an interest which is almost the right size.
Interest interest = new Interest();
interest.getName().append(new byte[targetSize]);
int initialSize = interest.wireEncode().size();
// Now replace the component with the desired size which trims off the extra encoding.
interest.setName(new Name().append(new byte[targetSize
- (initialSize - targetSize)]));
int interestSize = interest.wireEncode().size();
AssertEquals("Wrong interest size for MaxNdnPacketSize", targetSize,
interestSize);
CallbackCounter counter = new CallbackCounter();
bool gotError = true;
try {
face.expressInterest(interest, counter, counter);
gotError = false;
} catch (Exception ex) {
}
if (!gotError)
Fail("expressInterest didn't throw an exception when the interest size exceeds getMaxNdnPacketSize()");
}
public ValidationRequest(Interest interest, OnVerified onVerified,
OnDataValidationFailed onValidationFailed, int retry, int stepCount)
{
interest_ = interest;
onVerified_ = onVerified;
onValidationFailed_ = onValidationFailed;
retry_ = retry;
stepCount_ = stepCount;
}
public void getMatchedFilters(Interest interest,
ArrayList matchedFilters)
{
for (int i = 0; i < table_.Count; ++i) {
InterestFilterTable.Entry entry = table_[i];
if (entry.getFilter().doesMatch(interest.getName()))
ILOG.J2CsMapping.Collections.Collections.Add(matchedFilters,entry);
}
}
public void setUp()
{
referenceInterest = new Interest();
try {
referenceInterest.wireDecode(new Blob(codedInterest, false));
} catch (EncodingException ex) {
// We don't expect this to happen.
referenceInterest = null;
}
}
/// <summary>
/// Override to call onVerified.onVerifiedInterest(interest) and to indicate no
/// further verification step.
/// </summary>
///
/// <param name="interest">The interest with the signature (to ignore).</param>
/// <param name="stepCount"></param>
/// <param name="onVerified">better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onValidationFailed">Override to ignore this.</param>
/// <returns>null for no further step.</returns>
public override sealed ValidationRequest checkVerificationPolicy(Interest interest,
int stepCount, OnVerifiedInterest onVerified,
OnInterestValidationFailed onValidationFailed, WireFormat wireFormat)
{
try {
onVerified.onVerifiedInterest(interest);
} catch (Exception ex) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onVerifiedInterest", ex);
}
return null;
}
public PendingInterestTable.Entry add(long pendingInterestId,
Interest interestCopy, OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack)
{
int removeRequestIndex = removeRequests_.indexOf(pendingInterestId);
if (removeRequestIndex >= 0) {
// removePendingInterest was called with the pendingInterestId returned by
// expressInterest before we got here, so don't add a PIT entry.
ILOG.J2CsMapping.Collections.Collections.RemoveAt(removeRequests_,removeRequestIndex);
return null;
}
PendingInterestTable.Entry entry = new PendingInterestTable.Entry (pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack);
ILOG.J2CsMapping.Collections.Collections.Add(table_,entry);
return entry;
}
/// <summary>
/// Do the work of expressInterest once we know we are connected. Add the entry
/// to the PIT, encode and send the interest.
/// </summary>
///
/// <param name="pendingInterestId"></param>
/// <param name="interestCopy"></param>
/// <param name="onData"></param>
/// <param name="onTimeout"></param>
/// <param name="onNetworkNack"></param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <param name="face"></param>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
internal void expressInterestHelper(long pendingInterestId,
Interest interestCopy, OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack, WireFormat wireFormat, Face face)
{
PendingInterestTable.Entry pendingInterest = pendingInterestTable_
.add(pendingInterestId, interestCopy, onData, onTimeout,
onNetworkNack);
if (pendingInterest == null)
{
// removePendingInterest was already called with the pendingInterestId.
return;
}
if (onTimeout != null ||
interestCopy.getInterestLifetimeMilliseconds() >= 0.0d)
{
// Set up the timeout.
double delayMilliseconds = interestCopy
.getInterestLifetimeMilliseconds();
if (delayMilliseconds < 0.0d)
{
// Use a default timeout delay.
delayMilliseconds = 4000.0d;
}
face.callLater(delayMilliseconds, new Node.Anonymous_C0(this, pendingInterest));
}
// Special case: For timeoutPrefix_ we don't actually send the interest.
if (!timeoutPrefix_.match(interestCopy.getName()))
{
Blob encoding = interestCopy.wireEncode(wireFormat);
if (encoding.size() > getMaxNdnPacketSize())
{
throw new Exception(
"The encoded interest size exceeds the maximum limit getMaxNdnPacketSize()");
}
transport_.send(encoding.buf());
}
}
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();
net.named_data.jndn.encoding.TlvWireFormat.get().decodeLpPacket(lpPacket, element);
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 process 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.getName(), 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);
}
}
}
}
public void onData(Interest localInterest_0, Data data_1)
{
outer_ThreadPoolFace.threadPool_.submit(new net.named_data.jndn.ThreadPoolFace.Anonymous_C14.Anonymous_C24(this, localInterest_0, data_1));
}
public void onTimeout(Interest localInterest_0)
{
outer_ThreadPoolFace.threadPool_.submit(new net.named_data.jndn.ThreadPoolFace.Anonymous_C9.Anonymous_C20(this, localInterest_0));
}
/// <summary>
/// Never skip verification.
/// </summary>
///
/// <param name="interest">The received interest.</param>
/// <returns>false.</returns>
public override bool skipVerifyAndTrust(Interest interest)
{
return false;
}
/// <summary>
/// Use wireFormat.decodeSignatureInfoAndValue to decode the last two name
/// components of the signed interest. Look in the IdentityStorage for the
/// public key with the name in the KeyLocator (if available) and use it to
/// verify the interest. If the public key can't be found, call onVerifyFailed.
/// </summary>
///
/// <param name="interest">The interest with the signature to check.</param>
/// <param name="stepCount"></param>
/// <param name="onVerified">NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onValidationFailed">onValidationFailed.onInterestValidationFailed(interest, reason). NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>null for no further step for looking up a certificate chain.</returns>
public override ValidationRequest checkVerificationPolicy(Interest interest,
int stepCount, OnVerifiedInterest onVerified,
OnInterestValidationFailed onValidationFailed, WireFormat wireFormat)
{
if (interest.getName().size() < 2) {
try {
onValidationFailed.onInterestValidationFailed(interest,
"The signed interest has less than 2 components: "
+ interest.getName().toUri());
} catch (Exception exception) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE,
"Error in onInterestValidationFailed", exception);
}
return null;
}
// Decode the last two name components of the signed interest
Signature signature;
try {
signature = wireFormat.decodeSignatureInfoAndValue(interest
.getName().get(-2).getValue().buf(), interest.getName()
.get(-1).getValue().buf(), false);
} catch (EncodingException ex) {
logger_.log(
ILOG.J2CsMapping.Util.Logging.Level.INFO,
"Cannot decode the signed interest SignatureInfo and value",
ex);
try {
onValidationFailed.onInterestValidationFailed(interest,
"Error decoding the signed interest signature: " + ex);
} catch (Exception exception_0) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE,
"Error in onInterestValidationFailed", exception_0);
}
return null;
}
String[] failureReason = new String[] { "unknown" };
// wireEncode returns the cached encoding if available.
if (verify(signature, interest.wireEncode(wireFormat), failureReason)) {
try {
onVerified.onVerifiedInterest(interest);
} catch (Exception ex_1) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onVerifiedInterest", ex_1);
}
} else {
try {
onValidationFailed.onInterestValidationFailed(interest,
failureReason[0]);
} catch (Exception ex_2) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE,
"Error in onInterestValidationFailed", ex_2);
}
}
// No more steps, so return a null ValidationRequest.
return null;
}
public void onInterestValidationFailed(Interest interest, string reason)
{
Console.Out.WriteLine
(prefix_ + " signature verification: FAILED. Reason: " + reason);
}
static void dumpInterest(Interest interest)
{
Console.Out.WriteLine("name: " + interest.getName().toUri());
Console.Out.WriteLine("minSuffixComponents: " +
(interest.getMinSuffixComponents() >= 0 ?
"" + interest.getMinSuffixComponents() : "<none>"));
Console.Out.WriteLine("maxSuffixComponents: " +
(interest.getMaxSuffixComponents() >= 0 ?
"" + interest.getMaxSuffixComponents() : "<none>"));
Console.Out.Write("keyLocator: ");
if (interest.getKeyLocator().getType() == KeyLocatorType.NONE)
Console.Out.WriteLine("<none>");
else if (interest.getKeyLocator().getType() ==KeyLocatorType.KEY_LOCATOR_DIGEST)
Console.Out.WriteLine("KeyLocatorDigest: " + interest.getKeyLocator().getKeyData().toHex());
else if (interest.getKeyLocator().getType() == KeyLocatorType.KEYNAME)
Console.Out.WriteLine("KeyName: " + interest.getKeyLocator().getKeyName().toUri());
else
Console.Out.WriteLine("<unrecognized ndn_KeyLocatorType>");
Console.Out.WriteLine
("exclude: " + (interest.getExclude().size() > 0 ?
interest.getExclude().toUri() : "<none>"));
Console.Out.WriteLine("lifetimeMilliseconds: " +
(interest.getInterestLifetimeMilliseconds() >= 0 ?
"" + interest.getInterestLifetimeMilliseconds() : "<none>"));
Console.Out.WriteLine("childSelector: " +
(interest.getChildSelector() >= 0 ?
"" + interest.getChildSelector() : "<none>"));
Console.Out.WriteLine("mustBeFresh: " + interest.getMustBeFresh());
Console.Out.WriteLine("nonce: " +
(interest.getNonce().size() > 0 ?
"" + interest.getNonce().toHex() : "<none>"));
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="interest">The Interest to send. This copies the Interest.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public virtual long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
long pendingInterestId = node_.getNextEntryId();
// This copies the interest as required by Node.expressInterest.
node_.expressInterest(pendingInterestId, interest, onData, onTimeout,
onNetworkNack, wireFormat, this);
return pendingInterestId;
}
/// <summary>
/// Do the work of registerPrefix to register with NFD.
/// </summary>
///
/// <param name="registeredPrefixId">registeredPrefixTable_ (assuming it has already been done).</param>
/// <param name="prefix"></param>
/// <param name="onInterest"></param>
/// <param name="onRegisterFailed"></param>
/// <param name="onRegisterSuccess"></param>
/// <param name="flags"></param>
/// <param name="commandKeyChain"></param>
/// <param name="commandCertificateName"></param>
/// <param name="wireFormat_0"></param>
/// <param name="face_1"></param>
/// <exception cref="System.Security.SecurityException">If cannot find the private key for thecertificateName.</exception>
private void nfdRegisterPrefix(long registeredPrefixId, Name prefix,
OnInterestCallback onInterest, OnRegisterFailed onRegisterFailed,
OnRegisterSuccess onRegisterSuccess, ForwardingFlags flags,
KeyChain commandKeyChain, Name commandCertificateName,
WireFormat wireFormat_0, Face face_1)
{
if (commandKeyChain == null)
{
throw new Exception(
"registerPrefix: The command KeyChain has not been set. You must call setCommandSigningInfo.");
}
if (commandCertificateName.size() == 0)
{
throw new Exception(
"registerPrefix: The command certificate name has not been set. You must call setCommandSigningInfo.");
}
ControlParameters controlParameters = new ControlParameters();
controlParameters.setName(prefix);
controlParameters.setForwardingFlags(flags);
Interest commandInterest = new Interest();
// Determine whether to use remote prefix registration.
bool faceIsLocal;
try {
faceIsLocal = isLocal();
} catch (IOException ex) {
logger_.log(
ILOG.J2CsMapping.Util.Logging.Level.INFO,
"Register prefix failed: Error attempting to determine if the face is local: {0}",
ex);
try {
onRegisterFailed.onRegisterFailed(prefix);
} catch (Exception exception) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onRegisterFailed",
exception);
}
return;
}
if (faceIsLocal)
{
commandInterest.setName(new Name("/localhost/nfd/rib/register"));
// The interest is answered by the local host, so set a short timeout.
commandInterest.setInterestLifetimeMilliseconds(2000.0d);
}
else
{
commandInterest.setName(new Name("/localhop/nfd/rib/register"));
// The host is remote, so set a longer timeout.
commandInterest.setInterestLifetimeMilliseconds(4000.0d);
}
// NFD only accepts TlvWireFormat packets.
commandInterest.getName().append(
controlParameters.wireEncode(net.named_data.jndn.encoding.TlvWireFormat.get()));
makeCommandInterest(commandInterest, commandKeyChain,
commandCertificateName, net.named_data.jndn.encoding.TlvWireFormat.get());
// Send the registration interest.
Node.RegisterResponse response = new Node.RegisterResponse(
new RegisterResponse.Info(prefix, onRegisterFailed,
onRegisterSuccess, registeredPrefixId, onInterest, face_1),
this);
try {
expressInterest(getNextEntryId(), commandInterest, response,
response, null, wireFormat_0, face_1);
} catch (IOException ex_2) {
// Can't send the interest. Call onRegisterFailed.
logger_.log(
ILOG.J2CsMapping.Util.Logging.Level.INFO,
"Register prefix failed: Error sending the register prefix interest to the forwarder: {0}",
ex_2);
try {
onRegisterFailed.onRegisterFailed(prefix);
} catch (Exception exception_3) {
logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onRegisterFailed",
exception_3);
}
}
}
/// <summary>
/// We received the response.
/// </summary>
///
/// <param name="interest"></param>
/// <param name="responseData"></param>
public virtual void onData(Interest interest, Data responseData)
{
// Decode responseData.getContent() and check for a success code.
ControlResponse controlResponse = new ControlResponse();
try {
controlResponse.wireDecode(responseData.getContent(),
net.named_data.jndn.encoding.TlvWireFormat.get());
} catch (EncodingException ex) {
net.named_data.jndn.Node.logger_.log(
ILOG.J2CsMapping.Util.Logging.Level.INFO,
"Register prefix failed: Error decoding the NFD response: {0}",
ex);
try {
info_.onRegisterFailed_.onRegisterFailed(info_.prefix_);
} catch (Exception exception) {
net.named_data.jndn.Node.logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onRegisterFailed",
exception);
}
return;
}
// Status code 200 is "OK".
if (controlResponse.getStatusCode() != 200)
{
net.named_data.jndn.Node.logger_.log(
ILOG.J2CsMapping.Util.Logging.Level.INFO,
"Register prefix failed: Expected NFD status code 200, got: {0}",
controlResponse.getStatusCode());
try {
info_.onRegisterFailed_.onRegisterFailed(info_.prefix_);
} catch (Exception ex_0) {
net.named_data.jndn.Node.logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onRegisterFailed", ex_0);
}
return;
}
// Success, so we can add to the registered prefix table.
if (info_.registeredPrefixId_ != 0)
{
long interestFilterId = 0;
if (info_.onInterest_ != null)
{
// registerPrefix was called with the "combined" form that includes the
// callback, so add an InterestFilterEntry.
interestFilterId = parent_.getNextEntryId();
parent_.setInterestFilter(interestFilterId,
new InterestFilter(info_.prefix_),
info_.onInterest_, info_.face_);
}
if (!parent_.registeredPrefixTable_.add(
info_.registeredPrefixId_, info_.prefix_,
interestFilterId))
{
// removeRegisteredPrefix was already called with the registeredPrefixId.
if (interestFilterId > 0)
{
// Remove the related interest filter we just added.
parent_.unsetInterestFilter(interestFilterId);
}
return;
}
}
net.named_data.jndn.Node.logger_.log(
ILOG.J2CsMapping.Util.Logging.Level.INFO,
"Register prefix succeeded with the NFD forwarder for prefix {0}",
info_.prefix_.toUri());
if (info_.onRegisterSuccess_ != null)
{
try {
info_.onRegisterSuccess_.onRegisterSuccess(info_.prefix_,
info_.registeredPrefixId_);
} catch (Exception ex_1) {
net.named_data.jndn.Node.logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onRegisterSuccess", ex_1);
}
}
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="pendingInterestId"></param>
/// <param name="interestCopy">to use.</param>
/// <param name="onData">expressInterest and data is the received Data object.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <param name="face"></param>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public void expressInterest(long pendingInterestId,
Interest interestCopy, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat, Face face)
{
// Set the nonce in our copy of the Interest so it is saved in the PIT.
interestCopy.setNonce(nonceTemplate_);
interestCopy.refreshNonce();
if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE)
{
// We are connected. Simply send the interest without synchronizing.
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
return;
}
lock (onConnectedCallbacks_) {
// TODO: Properly check if we are already connected to the expected host.
if (!transport_.isAsync())
{
// The simple case: Just do a blocking connect and express.
transport_.connect(connectionInfo_, this, null);
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
// Make future calls to expressInterest send directly to the Transport.
connectStatus_ = net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE;
return;
}
// Handle the async case.
if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.UNCONNECTED)
{
connectStatus_ = net.named_data.jndn.Node.ConnectStatus.CONNECT_REQUESTED;
// expressInterestHelper will be called by onConnected.
ILOG.J2CsMapping.Collections.Collections.Add(onConnectedCallbacks_, new Node.Anonymous_C3(this, interestCopy, onData, wireFormat,
onTimeout, pendingInterestId, face, onNetworkNack));
IRunnable onConnected = new Node.Anonymous_C2(this);
transport_.connect(connectionInfo_, this, onConnected);
}
else if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_REQUESTED)
{
// Still connecting. add to the interests to express by onConnected.
ILOG.J2CsMapping.Collections.Collections.Add(onConnectedCallbacks_, new Node.Anonymous_C1(this, onData, pendingInterestId, wireFormat,
face, onNetworkNack, interestCopy, onTimeout));
}
else if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE)
{
// We have to repeat this check for CONNECT_COMPLETE in case the
// onConnected callback was called while we were waiting to enter this
// synchronized block.
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
}
else
{
// Don't expect this to happen.
throw new Exception("Node: Unrecognized _connectStatus "
+ connectStatus_);
}
}
}
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)
{
dispatchInterest(interest);
}
else if (data != null)
{
satisfyPendingInterests(data);
}
}
/// <summary>
/// Append a timestamp component and a random value component to interest's
/// name. Then use the keyChain and certificateName to sign the interest. 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 object for signing interests.</param>
/// <param name="certificateName">The certificate name for signing interests.</param>
/// <param name="wireFormat"></param>
/// <exception cref="System.Security.SecurityException">If cannot find the private key for thecertificateName.</exception>
internal void makeCommandInterest(Interest interest, KeyChain keyChain,
Name certificateName, WireFormat wireFormat)
{
commandInterestGenerator_.generate(interest, keyChain, certificateName,
wireFormat);
}
/// <summary>
/// Append a timestamp component and a random value component to interest's
/// name. Then use the keyChain and certificateName from setCommandSigningInfo
/// to sign the interest. If the interest lifetime is not set, this sets it.
/// Use the default WireFormat to encode the SignatureInfo and to encode the
/// interest name for signing.
/// </summary>
///
/// <param name="interest">The interest whose name is appended with components.</param>
/// <exception cref="System.Security.SecurityException">If cannot find the private key for thecertificateName.</exception>
/// @note This method is an experimental feature. See the API docs for more detail at
/// http://named-data.net/doc/ndn-ccl-api/face.html#face-makecommandinterest-method .
public void makeCommandInterest(Interest interest)
{
makeCommandInterest(interest, net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Do the work of expressInterest to make an Interest based on name and
/// interestTemplate.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <returns>The Interest, suitable for Node.expressInterest.</returns>
protected internal static Interest getInterestCopy(Name name,
Interest interestTemplate)
{
if (interestTemplate != null) {
// Copy the interestTemplate.
Interest interestCopy = new Interest(interestTemplate);
interestCopy.setName(name);
return interestCopy;
} else {
Interest interestCopy_0 = new Interest(name);
interestCopy_0.setInterestLifetimeMilliseconds(4000.0d);
return interestCopy_0;
}
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData as described below.
/// Ignore if the interest times out.
/// </summary>
///
/// <param name="interest">The Interest to send. This copies the Interest.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Interest interest, OnData onData,
WireFormat wireFormat)
{
return expressInterest(interest, onData, null, wireFormat);
}
static void Main(string[] args)
{
var interest = new Interest();
interest.wireDecode(new Blob(TlvInterest));
Console.Out.WriteLine("Interest:");
dumpInterest(interest);
// Set the name again to clear the cached encoding so we encode again.
interest.setName(interest.getName());
var encoding = interest.wireEncode();
Console.Out.WriteLine("");
Console.Out.WriteLine("Re-encoded interest " + encoding.toHex());
var reDecodedInterest = new Interest();
reDecodedInterest.wireDecode(encoding);
Console.Out.WriteLine("");
Console.Out.WriteLine("Re-decoded Interest:");
dumpInterest(reDecodedInterest);
var freshInterest = new Interest(new Name("/ndn/abc"));
freshInterest.setMinSuffixComponents(4);
freshInterest.setMaxSuffixComponents(6);
freshInterest.setInterestLifetimeMilliseconds(30000);
freshInterest.setChildSelector(1);
freshInterest.setMustBeFresh(true);
freshInterest.getKeyLocator().setType(KeyLocatorType.KEY_LOCATOR_DIGEST);
freshInterest.getKeyLocator().setKeyData
(new Blob(new byte[] {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F }));
freshInterest.getExclude().appendComponent(new Name("abc").get(0)).appendAny();
var identityStorage = new MemoryIdentityStorage();
var privateKeyStorage = new MemoryPrivateKeyStorage();
var keyChain = new KeyChain
(new IdentityManager(identityStorage, privateKeyStorage),
new SelfVerifyPolicyManager(identityStorage));
// Initialize the storage.
var keyName = new Name("/testname/DSK-123");
var certificateName = keyName.getSubName(0, keyName.size() - 1).append
("KEY").append(keyName.get(-1)).append("ID-CERT").append("0");
identityStorage.addKey(keyName, KeyType.RSA, new Blob(DEFAULT_RSA_PUBLIC_KEY_DER));
privateKeyStorage.setKeyPairForKeyName
(keyName, KeyType.RSA, new ByteBuffer(DEFAULT_RSA_PUBLIC_KEY_DER),
new ByteBuffer(DEFAULT_RSA_PRIVATE_KEY_DER));
// Make a Face just so that we can sign the interest.
var face = new Face("localhost");
face.setCommandSigningInfo(keyChain, certificateName);
face.makeCommandInterest(freshInterest);
Interest reDecodedFreshInterest = new Interest();
reDecodedFreshInterest.wireDecode(freshInterest.wireEncode());
Console.Out.WriteLine("");
Console.Out.WriteLine("Re-decoded fresh Interest:");
dumpInterest(reDecodedFreshInterest);
VerifyCallbacks callbacks = new VerifyCallbacks("Freshly-signed Interest");
keyChain.verifyInterest(reDecodedFreshInterest, callbacks, callbacks);
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData as described below.
/// Ignore if the interest times out.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="interest">The Interest to send. This copies the Interest.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Interest interest, OnData onData)
{
return expressInterest(interest, onData, null,
net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
public void onVerifiedInterest(Interest interest)
{
Console.Out.WriteLine(prefix_ + " signature verification: VERIFIED");
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public virtual long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
long pendingInterestId = node_.getNextEntryId();
// This copies the name object as required by Node.expressInterest.
node_.expressInterest(pendingInterestId,
getInterestCopy(name, interestTemplate), onData, onTimeout,
onNetworkNack, wireFormat, this);
return pendingInterestId;
}
/// <summary>
/// Always return true to use the self-verification rule for the received interest.
/// </summary>
///
/// <param name="interest">The received interest.</param>
/// <returns>true.</returns>
public override bool requireVerify(Interest interest)
{
return true;
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
return expressInterest(name, interestTemplate, onData, onTimeout,
onNetworkNack, net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
public Anonymous_C20(ThreadPoolFace.Anonymous_C9 paramouter_Anonymous_C9,
Interest localInterest_0)
{
this.localInterest = localInterest_0;
this.outer_Anonymous_C9 = paramouter_Anonymous_C9;
}
public virtual void onData(Interest interest, Data data)
{
interest_ = interest;
data_ = data;
++onDataCallCount_;
}
public void onNetworkNack(Interest localInterest_0,
NetworkNack networkNack_1)
{
outer_ThreadPoolFace.threadPool_.submit(new net.named_data.jndn.ThreadPoolFace.Anonymous_C8.Anonymous_C19(this, localInterest_0, networkNack_1));
}
public virtual void onTimeout(Interest interest)
{
interest_ = interest;
++onTimeoutCallCount_;
}
public Anonymous_C23(ThreadPoolFace.Anonymous_C13 paramouter_Anonymous_C13,
Interest localInterest_0)
{
this.localInterest = localInterest_0;
this.outer_Anonymous_C13 = paramouter_Anonymous_C13;
}
/// <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. Use the default WireFormat to
/// encode the SignatureInfo and to encode interest name for signing.
/// </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>
public void generate(Interest interest, KeyChain keyChain,
Name certificateName)
{
generate(interest, keyChain, certificateName,
net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
public virtual void onNetworkNack(Interest interest, NetworkNack networkNack)
{
networkNack_ = networkNack;
++onNetworkNackCallCount_;
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData as described below.
/// Ignore if the interest times out.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, Interest interestTemplate,
OnData onData)
{
return expressInterest(name, interestTemplate, onData, null,
net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData as described below.
/// Ignore if the interest times out.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, Interest interestTemplate,
OnData onData, WireFormat wireFormat)
{
return expressInterest(name, interestTemplate, onData, null, wireFormat);
}
/// <summary>
/// Append a timestamp component and a random value component to interest's
/// name. Then use the keyChain and certificateName from setCommandSigningInfo
/// to sign the interest. If the interest lifetime is not set, this sets it.
/// </summary>
///
/// <param name="interest">The interest whose name is appended with components.</param>
/// <param name="wireFormat"></param>
/// <exception cref="System.Security.SecurityException">If cannot find the private key for thecertificateName.</exception>
/// @note This method is an experimental feature. See the API docs for more detail at
/// http://named-data.net/doc/ndn-ccl-api/face.html#face-makecommandinterest-method .
public void makeCommandInterest(Interest interest, WireFormat wireFormat)
{
node_.makeCommandInterest(interest, commandKeyChain_,
commandCertificateName_, wireFormat);
}
