def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
# First, decode as Interest or Data.
interest = None
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Interest, len(element)):
interest = Interest()
interest.wireDecode(element, TlvWireFormat.get())
elif decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
# Now process as Interest or Data.
if interest != None:
# Call all interest filter callbacks which match.
for i in range(len(self._interestFilterTable)):
entry = self._interestFilterTable[i]
if entry.getFilter().doesMatch(interest.getName()):
includeFilter = True
# Use getcallargs to test if onInterest accepts 5 args.
try:
inspect.getcallargs(entry.getOnInterest(),
None, None, None, None, None)
except TypeError:
# Assume onInterest is old-style with 4 arguments.
includeFilter = False
if includeFilter:
try:
entry.getOnInterest()(
entry.getFilter().getPrefix(), interest,
entry.getFace(), entry.getInterestFilterId(),
entry.getFilter())
except:
logging.exception("Error in onInterest")
else:
# Old-style onInterest without the filter argument. We
# still pass a Face instead of Transport since Face also
# has a send method.
try:
entry.getOnInterest()(
entry.getFilter().getPrefix(), interest,
entry.getFace(), entry.getInterestFilterId())
except:
logging.exception("Error in onInterest")
elif data != None:
pendingInterests = self._extractEntriesForExpressedInterest(
data.getName())
for pendingInterest in pendingInterests:
try:
pendingInterest.getOnData()(pendingInterest.getInterest(), data)
except:
logging.exception("Error in onData")
def onData(self, interest, responseData):
"""
We received the response. Do a quick check of expected name
components.
"""
if self._isNfdCommand:
# Decode responseData->getContent() and check for a success code.
# TODO: Move this into the TLV code.
statusCode = None
try:
decoder = TlvDecoder(responseData.getContent().buf())
decoder.readNestedTlvsStart(Tlv.NfdCommand_ControlResponse)
statusCode = decoder.readNonNegativeIntegerTlv(Tlv.NfdCommand_StatusCode)
except ValueError:
# Error decoding the ControlResponse.
self._onRegisterFailed_(self._prefix)
return
# Status code 200 is "OK".
if statusCode != 200:
self._onRegisterFailed_(self._prefix)
# Otherwise, silently succeed.
else:
expectedName = Name("/ndnx/.../selfreg")
if (responseData.getName().size() < 4 or
responseData.getName()[0] != expectedName[0] or
responseData.getName()[2] != expectedName[2]):
self._onRegisterFailed(self._prefix)
return
def decodeSignatureInfoAndValue(self, signatureInfo, signatureValue):
"""
Decode signatureInfo as a signature info and signatureValue as the
related SignatureValue, and return a new object which is a subclass of
Signature.
:param signatureInfo: The array with the signature info input buffer to
decode.
:type signatureInfo: An array type with int elements
:param signatureValue: The array with the signature value input buffer
to decode.
:type signatureValue: An array type with int elements
:return: A new object which is a subclass of Signature.
:rtype: a subclass of Signature
"""
# Use a SignatureHolder to imitate a Data object for _decodeSignatureInfo.
signatureHolder = self.SignatureHolder()
decoder = TlvDecoder(signatureInfo)
self._decodeSignatureInfo(signatureHolder, decoder)
decoder = TlvDecoder(signatureValue)
signatureHolder.getSignature().setSignature(
Blob(decoder.readBlobTlv(Tlv.SignatureValue)))
return signatureHolder.getSignature()
def onData(self, interest, responseData):
"""
We received the response. Do a quick check of expected name
components.
"""
if self._isNfdCommand:
# Decode responseData->getContent() and check for a success code.
# TODO: Move this into the TLV code.
statusCode = None
try:
decoder = TlvDecoder(responseData.getContent().buf())
decoder.readNestedTlvsStart(Tlv.NfdCommand_ControlResponse)
statusCode = decoder.readNonNegativeIntegerTlv(
Tlv.NfdCommand_StatusCode)
except ValueError:
# Error decoding the ControlResponse.
self._onRegisterFailed_(self._prefix)
return
# Status code 200 is "OK".
if statusCode != 200:
self._onRegisterFailed_(self._prefix)
# Otherwise, silently succeed.
else:
expectedName = Name("/ndnx/.../selfreg")
if (responseData.getName().size() < 4
or responseData.getName()[0] != expectedName[0]
or responseData.getName()[2] != expectedName[2]):
self._onRegisterFailed(self._prefix)
return
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
lpPacket = None
if element[0] == Tlv.LpPacket_LpPacket:
# Decode the LpPacket and replace element with the fragment.
lpPacket = 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.
TlvWireFormat.get().decodeLpPacket(lpPacket, element, False)
element = lpPacket.getFragmentWireEncoding().buf()
# First, decode as Interest or Data.
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
data.setLpPacket(lpPacket)
# Now process as Interest or Data.
if data != None:
if self._onBtleData:
self._onBtleData(data)
def wireDecode(self, input):
"""
Decode the input as an NDN-TLV SafeBag and update this object.
:param input: The array with the bytes to decode.
:type input: A Blob or an array type with int elements
"""
if isinstance(input, Blob):
input = input.buf()
# Decode directly as TLV. We don't support the WireFormat abstraction
# because this isn't meant to go directly on the wire.
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.SafeBag_SafeBag)
# Get the bytes of the certificate and decode.
certificateBeginOffset = decoder.getOffset()
certificateEndOffset = decoder.readNestedTlvsStart(Tlv.Data)
decoder.seek(certificateEndOffset)
self._certificate = Data()
self._certificate.wireDecode(
decoder.getSlice(certificateBeginOffset, certificateEndOffset),
TlvWireFormat.get())
self._privateKeyBag = Blob(
decoder.readBlobTlv(Tlv.SafeBag_EncryptedKeyBag), True)
decoder.finishNestedTlvs(endOffset)
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
lpPacket = None
if element[0] == Tlv.LpPacket_LpPacket:
# Decode the LpPacket and replace element with the fragment.
lpPacket = 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.
TlvWireFormat.get().decodeLpPacket(lpPacket, element, False)
element = lpPacket.getFragmentWireEncoding().buf()
# First, decode as Interest or Data.
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
data.setLpPacket(lpPacket)
# Now process as Interest or Data.
if data != None:
if self._onBtleData:
self._onBtleData(data)
def decodeSignatureInfoAndValue(self, signatureInfo, signatureValue):
"""
Decode signatureInfo as a signature info and signatureValue as the
related SignatureValue, and return a new object which is a subclass of
Signature.
:param signatureInfo: The array with the signature info input buffer to
decode.
:type signatureInfo: An array type with int elements
:param signatureValue: The array with the signature value input buffer
to decode.
:type signatureValue: An array type with int elements
:return: A new object which is a subclass of Signature.
:rtype: a subclass of Signature
"""
# Use a SignatureHolder to imitate a Data object for _decodeSignatureInfo.
signatureHolder = self.SignatureHolder()
decoder = TlvDecoder(signatureInfo)
self._decodeSignatureInfo(signatureHolder, decoder)
decoder = TlvDecoder(signatureValue)
# TODO: The library needs to handle other signature types than
# SignatureSha256WithRsa.
signatureHolder.getSignature().setSignature(
Blob(decoder.readBlobTlv(Tlv.SignatureValue)))
return signatureHolder.getSignature()
def decodeDelegationSet(self, delegationSet, input):
"""
Decode input as a DelegationSet in NDN-TLV 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.
:param DelegationSet delegationSet: The DelegationSet object
whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
decoder = TlvDecoder(input)
endOffset = len(input)
delegationSet.clear()
while decoder.getOffset() < endOffset:
decoder.readTypeAndLength(Tlv.Link_Delegation)
preference = decoder.readNonNegativeIntegerTlv(Tlv.Link_Preference)
name = Name()
Tlv0_1_1WireFormat._decodeName(name, decoder)
# Add unsorted to preserve the order so that Interest selected
# delegation index will work.
delegationSet.addUnsorted(preference, name)
def decodeData(self, data, input):
"""
Decode input as an NDN-TLV data packet, set the fields in the data
object, and return the signed offsets.
:param Data data: The Data object whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
:return: A Tuple of (signedPortionBeginOffset, signedPortionEndOffset)
where signedPortionBeginOffset is the offset in the encoding of
the beginning of the signed portion, and signedPortionEndOffset is
the offset in the encoding of the end of the signed portion.
:rtype: (int, int)
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.Data)
signedPortionBeginOffset = decoder.getOffset()
self._decodeName(data.getName(), decoder)
self._decodeMetaInfo(data.getMetaInfo(), decoder)
data.setContent(Blob(decoder.readBlobTlv(Tlv.Content)))
self._decodeSignatureInfo(data, decoder)
signedPortionEndOffset = decoder.getOffset()
data.getSignature().setSignature(
Blob(decoder.readBlobTlv(Tlv.SignatureValue)))
decoder.finishNestedTlvs(endOffset)
return (signedPortionBeginOffset, signedPortionEndOffset)
def decodeInterest(self, interest, input):
"""
Decode input as an NDN-TLV interest and set the fields of the interest
object.
:param Interest interest: The Interest object whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
:return: A Tuple of (signedPortionBeginOffset, signedPortionEndOffset)
where signedPortionBeginOffset is the offset in the encoding of
the beginning of the signed portion, and signedPortionEndOffset is
the offset in the encoding of the end of the signed portion. The
signed portion starts from the first name component and ends just
before the final name component (which is assumed to be a signature
for a signed interest).
:rtype: (int, int)
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.Interest)
self._decodeName(interest.getName(), decoder)
if decoder.peekType(Tlv.Selectors, endOffset):
self._decodeSelectors(interest, decoder)
# Require a Nonce, but don't force it to be 4 bytes.
nonce = Blob(decoder.readBlobTlv(Tlv.Nonce))
interest.setScope(
decoder.readOptionalNonNegativeIntegerTlv(Tlv.Scope, endOffset))
interest.setInterestLifetimeMilliseconds(
decoder.readOptionalNonNegativeIntegerTlvAsFloat(
Tlv.InterestLifetime, endOffset))
# Set the nonce last because setting other interest fields clears it.
interest.setNonce(nonce)
decoder.finishNestedTlvs(endOffset)
def decodeData(self, data, input):
"""
Decode input as an NDN-TLV data packet, set the fields in the data
object, and return the signed offsets.
:param Data data: The Data object whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
:return: A Tuple of (signedPortionBeginOffset, signedPortionEndOffset)
where signedPortionBeginOffset is the offset in the encoding of
the beginning of the signed portion, and signedPortionEndOffset is
the offset in the encoding of the end of the signed portion.
:rtype: (int, int)
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.Data)
signedPortionBeginOffset = decoder.getOffset()
self._decodeName(data.getName(), decoder)
self._decodeMetaInfo(data.getMetaInfo(), decoder)
data.setContent(Blob(decoder.readBlobTlv(Tlv.Content)))
self._decodeSignatureInfo(data, decoder)
signedPortionEndOffset = decoder.getOffset()
# TODO: The library needs to handle other signature types than
# SignatureSha256WithRsa.
data.getSignature().setSignature(Blob(decoder.readBlobTlv(Tlv.SignatureValue)))
decoder.finishNestedTlvs(endOffset)
return (signedPortionBeginOffset, signedPortionEndOffset)
def decodeInterest(self, interest, input):
"""
Decode input as an NDN-TLV interest and set the fields of the interest
object.
:param Interest interest: The Interest object whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
:return: A Tuple of (signedPortionBeginOffset, signedPortionEndOffset)
where signedPortionBeginOffset is the offset in the encoding of
the beginning of the signed portion, and signedPortionEndOffset is
the offset in the encoding of the end of the signed portion. The
signed portion starts from the first name component and ends just
before the final name component (which is assumed to be a signature
for a signed interest).
:rtype: (int, int)
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.Interest)
self._decodeName(interest.getName(), decoder)
if decoder.peekType(Tlv.Selectors, endOffset):
self._decodeSelectors(interest, decoder)
# Require a Nonce, but don't force it to be 4 bytes.
nonce = Blob(decoder.readBlobTlv(Tlv.Nonce))
interest.setScope(decoder.readOptionalNonNegativeIntegerTlv(
Tlv.Scope, endOffset))
interest.setInterestLifetimeMilliseconds(
decoder.readOptionalNonNegativeIntegerTlvAsFloat
(Tlv.InterestLifetime, endOffset))
# Set the nonce last because setting other interest fields clears it.
interest.setNonce(nonce)
decoder.finishNestedTlvs(endOffset)
def decodeInterest(self, interest, input):
"""
Decode input as an NDN-TLV interest and set the fields of the interest
object.
:param Interest interest: The Interest object whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.Interest)
self._decodeName(interest.getName(), decoder)
if decoder.peekType(Tlv.Selectors, endOffset):
self._decodeSelectors(interest, decoder)
# Require a Nonce, but don't force it to be 4 bytes.
nonce = Blob(decoder.readBlobTlv(Tlv.Nonce))
interest.setScope(decoder.readOptionalNonNegativeIntegerTlv(
Tlv.Scope, endOffset))
interest.setInterestLifetimeMilliseconds(
decoder.readOptionalNonNegativeIntegerTlvAsFloat
(Tlv.InterestLifetime, endOffset))
# Set the nonce last because setting other interest fields clears it.
interest.setNonce(nonce)
decoder.finishNestedTlvs(endOffset)
def onData(self, interest, responseData):
"""
We received the response. Do a quick check of expected name
components.
"""
if self._isNfdCommand:
# Decode responseData->getContent() and check for a success code.
# TODO: Move this into the TLV code.
statusCode = None
try:
decoder = TlvDecoder(responseData.getContent().buf())
decoder.readNestedTlvsStart(Tlv.NfdCommand_ControlResponse)
statusCode = decoder.readNonNegativeIntegerTlv(Tlv.NfdCommand_StatusCode)
except ValueError as ex:
logging.getLogger(__name__).info(
"Register prefix failed: Error decoding the NFD response: %s",
str(ex))
self._onRegisterFailed(self._prefix)
return
# Status code 200 is "OK".
if statusCode != 200:
logging.getLogger(__name__).info(
"Register prefix failed: Expected NFD status code 200, got: %d",
statusCode)
self._onRegisterFailed(self._prefix)
return
logging.getLogger(__name__).info(
"Register prefix succeeded with the NFD forwarder for prefix %s",
self._prefix.toUri())
else:
expectedName = Name("/ndnx/.../selfreg")
if (responseData.getName().size() < 4 or
responseData.getName()[0] != expectedName[0] or
responseData.getName()[2] != expectedName[2]):
logging.getLogger(__name__).info(
"Register prefix failed: Unexpected name in NDNx response: %s",
responseData.getName().toUri())
self._onRegisterFailed(self._prefix)
return
logging.getLogger(__name__).info(
"Register prefix succeeded with the NDNx forwarder for prefix %s",
self._prefix.toUri())
def decodeControlResponse(self, controlResponse, input):
"""
Decode input as an NDN-TLV ControlResponse and set the fields of the
controlResponse object.
:param ControlResponse controlResponse: The ControlResponse object
whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
controlResponse.clear()
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(
Tlv.NfdCommand_ControlResponse)
# decode face ID
controlResponse.setStatusCode(decoder.readNonNegativeIntegerTlv
(Tlv.NfdCommand_StatusCode))
statusText = Blob(
decoder.readBlobTlv(Tlv.NfdCommand_StatusText), False)
controlResponse.setStatusText(str(statusText))
# Decode the body.
if decoder.peekType(Tlv.ControlParameters_ControlParameters, endOffset):
controlResponse.setBodyAsControlParameters(ControlParameters())
# Decode into the existing ControlParameters to avoid copying.
self._decodeControlParameters(
controlResponse.getBodyAsControlParameters(), decoder)
decoder.finishNestedTlvs(endOffset)
def decodeForwardingEntry(self, forwardingEntry, input):
"""
Decode input as an forwardingEntry and set the fields of the
forwardingEntry object.
:param forwardingEntry: The ForwardingEntry object whose fields are
updated.
:type forwardingEntry: ForwardingEntry
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.ForwardingEntry)
actionBytes = decoder.readOptionalBlobTlv(Tlv.Action, endOffset)
if actionBytes != None:
# Convert bytes to a str.
forwardingEntry.setAction("".join(map(chr, actionBytes)))
else:
forwardingEntry.setAction(None)
if decoder.peekType(Tlv.Name, endOffset):
self._decodeName(forwardingEntry.getPrefix(), decoder)
else:
forwardingEntry.getPrefix().clear()
forwardingEntry.setFaceId(
decoder.readOptionalNonNegativeIntegerTlv(Tlv.FaceID, endOffset))
forwardingEntryFlags = decoder.readOptionalNonNegativeIntegerTlv(
Tlv.ForwardingFlags, endOffset)
if forwardingEntryFlags != None:
forwardingEntry.getForwardingFlags().setForwardingEntryFlags(
forwardingEntryFlags)
else:
# This sets the default flags.
forwardingEntry.setForwardingFlags(ForwardingFlags())
forwardingEntry.setFreshnessPeriod(
decoder.readOptionalNonNegativeIntegerTlvAsFloat(
Tlv.FreshnessPeriod, endOffset))
decoder.finishNestedTlvs(endOffset)
def decodeName(self, name, input):
"""
Decode input as an NDN-TLV name and set the fields of the Name
object.
:param Name name: The Name object whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
decoder = TlvDecoder(input)
self._decodeName(name, decoder)
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
# The type codes for TLV Interest and Data packets are chosen to not
# conflict with the first byte of a binary XML packet, so we canjust
# look at the first byte.
if not (element[0] == Tlv.Interest or element[0] == Tlv.Data):
# Ignore non-TLV elements.
return
# First, decode as Interest or Data.
interest = None
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Interest, len(element)):
interest = Interest()
interest.wireDecode(element, TlvWireFormat.get())
elif decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
# Now process as Interest or Data.
if interest != None:
entry = self._getEntryForRegisteredPrefix(interest.getName())
if entry != None:
entry.getOnInterest()(entry.getPrefix(), interest,
self._transport,
entry.getRegisteredPrefixId())
elif data != None:
pendingInterests = self._extractEntriesForExpressedInterest(
data.getName())
for pendingInterest in pendingInterests:
pendingInterest.getOnData()(pendingInterest.getInterest(),
data)
def decodeForwardingEntry(self, forwardingEntry, input):
"""
Decode input as an forwardingEntry and set the fields of the
forwardingEntry object.
:param forwardingEntry: The ForwardingEntry object whose fields are
updated.
:type forwardingEntry: ForwardingEntry
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.ForwardingEntry)
actionBytes = decoder.readOptionalBlobTlv(Tlv.Action, endOffset)
if actionBytes != None:
# Convert bytes to a str.
forwardingEntry.setAction("".join(map(chr, actionBytes)))
else:
forwardingEntry.setAction(None)
if decoder.peekType(Tlv.Name, endOffset):
self._decodeName(forwardingEntry.getPrefix(), decoder)
else:
forwardingEntry.getPrefix().clear()
forwardingEntry.setFaceId(
decoder.readOptionalNonNegativeIntegerTlv(Tlv.FaceID, endOffset))
forwardingEntryFlags = decoder.readOptionalNonNegativeIntegerTlv(
Tlv.ForwardingFlags, endOffset)
if forwardingEntryFlags != None:
forwardingEntry.getForwardingFlags().setForwardingEntryFlags(
forwardingEntryFlags)
else:
# This sets the default flags.
forwardingEntry.setForwardingFlags(ForwardingFlags())
forwardingEntry.setFreshnessPeriod(
decoder.readOptionalNonNegativeIntegerTlvAsFloat(
Tlv.FreshnessPeriod, endOffset))
decoder.finishNestedTlvs(endOffset)
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
# The type codes for TLV Interest and Data packets are chosen to not
# conflict with the first byte of a binary XML packet, so we canjust
# look at the first byte.
if not (element[0] == Tlv.Interest or element[0] == Tlv.Data):
# Ignore non-TLV elements.
return
# First, decode as Interest or Data.
interest = None
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Interest, len(element)):
interest = Interest()
interest.wireDecode(element, TlvWireFormat.get())
elif decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
# Now process as Interest or Data.
if interest != None:
entry = self._getEntryForRegisteredPrefix(interest.getName())
if entry != None:
entry.getOnInterest()(
entry.getPrefix(), interest, self._transport,
entry.getRegisteredPrefixId())
elif data != None:
pendingInterests = self._extractEntriesForExpressedInterest(
data.getName())
for pendingInterest in pendingInterests:
pendingInterest.getOnData()(pendingInterest.getInterest(), data)
def decode(message, input):
"""
Decode the input as NDN-TLV and update the fields of the Protobuf
message object.
:param google.protobuf.message message: The Protobuf message object.
This does not first clear the object.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
# If input is a blob, get its buf().
decodeBuffer = input.buf() if isinstance(input, Blob) else input
decoder = TlvDecoder(decodeBuffer)
ProtobufTlv._decodeMessageValue(message, decoder, len(input))
def _encodeSignatureInfo(signature, encoder):
"""
An internal method to encode signature as the appropriate form of
SignatureInfo in NDN-TLV.
:param Signature signature: An object of a subclass of Signature to encode.
:param TlvEncoder encoder: The TlvEncoder to receive the encoding.
"""
if isinstance(signature, GenericSignature):
# Handle GenericSignature separately since it has the entire encoding.
encoding = signature.getSignatureInfoEncoding()
# Do a test decoding to sanity check that it is valid TLV.
try:
decoder = TlvDecoder(encoding.buf())
endOffset = decoder.readNestedTlvsStart(Tlv.SignatureInfo)
decoder.readNonNegativeIntegerTlv(Tlv.SignatureType)
decoder.finishNestedTlvs(endOffset)
except ValueError as ex:
raise ValueError(
"The GenericSignature encoding is not a valid NDN-TLV SignatureInfo: " +
ex)
encoder.writeBuffer(encoding.buf())
return
saveLength = len(encoder)
if isinstance(signature, Sha256WithRsaSignature):
# Encode backwards.
Tlv0_1_1WireFormat._encodeKeyLocator(
Tlv.KeyLocator, signature.getKeyLocator(), encoder)
encoder.writeNonNegativeIntegerTlv(
Tlv.SignatureType, Tlv.SignatureType_SignatureSha256WithRsa)
elif isinstance(signature, Sha256WithEcdsaSignature):
# Encode backwards.
Tlv0_1_1WireFormat._encodeKeyLocator(
Tlv.KeyLocator, signature.getKeyLocator(), encoder)
encoder.writeNonNegativeIntegerTlv(
Tlv.SignatureType, Tlv.SignatureType_SignatureSha256WithEcdsa)
elif isinstance(signature, HmacWithSha256Signature):
Tlv0_1_1WireFormat._encodeKeyLocator(
Tlv.KeyLocator, signature.getKeyLocator(), encoder)
encoder.writeNonNegativeIntegerTlv(
Tlv.SignatureType, Tlv.SignatureType_SignatureHmacWithSha256)
elif isinstance(signature, DigestSha256Signature):
encoder.writeNonNegativeIntegerTlv(
Tlv.SignatureType, Tlv.SignatureType_DigestSha256)
else:
raise RuntimeError(
"encodeSignatureInfo: Unrecognized Signature object type")
encoder.writeTypeAndLength(Tlv.SignatureInfo, len(encoder) - saveLength)
def wireDecode(self, wire):
decoder = TlvDecoder(wire)
beginOffset = decoder.getOffset()
endOffset = decoder.readNestedTlvsStart(Tlv.SignatureInfo)
signatureType = decoder.readNonNegativeIntegerTlv(Tlv.SignatureType)
if signatureType != Tlv.SignatureType_Sha256WithAbsSignature:
raise RuntimeError("Invalid SignatureType code: expected %d, got %d" % (Tlv.SignatureType_Sha256WithAbsSignature, signatureType))
keyLocator = KeyLocator()
Tlv0_2WireFormat._decodeKeyLocator(Tlv.KeyLocator, keyLocator, decoder, True)
self._keyLocator = ChangeCounter(keyLocator)
# if decoder.peekType(Tlv.ValidityPeriod_ValidityPeriod, endOffset):
# Tlv0_2WireFormat._decodeValidityPeriod(
# signatureInfo.getValidityPeriod(), decoder)
decoder.finishNestedTlvs(endOffset)
def decodeEncryptedContent(self, encryptedContent, input):
"""
Decode input as an EncryptedContent in NDN-TLV and set the fields of the
encryptedContent object.
:param EncryptedContent encryptedContent: The EncryptedContent object
whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.Encrypt_EncryptedContent)
Tlv0_1_1WireFormat._decodeKeyLocator(
Tlv.KeyLocator, encryptedContent.getKeyLocator(), decoder)
encryptedContent.setAlgorithmType(
decoder.readNonNegativeIntegerTlv(Tlv.Encrypt_EncryptionAlgorithm))
encryptedContent.setInitialVector(
Blob(decoder.readOptionalBlobTlv
(Tlv.Encrypt_InitialVector, endOffset), True))
encryptedContent.setPayload(
Blob(decoder.readBlobTlv(Tlv.Encrypt_EncryptedPayload), True))
decoder.finishNestedTlvs(endOffset)
def wireDecode(self, input):
"""
Decode the input as an NDN-TLV PSyncContent and update this object.
:param input: The array with the bytes to decode.
:type input: Blob or an array type with int elements
"""
# If input is a blob, get its buf().
decodeBuffer = input.buf() if isinstance(input, Blob) else input
self.clear()
# Decode directly as TLV. We don't support the WireFormat abstraction
# because this isn't meant to go directly on the wire.
decoder = TlvDecoder(decodeBuffer)
endOffset = decoder.readNestedTlvsStart(PSyncState.Tlv_PSyncContent)
# Decode a sequence of Name.
while decoder.getOffset() < len(decodeBuffer):
name = Name()
Tlv0_3WireFormat._decodeName(name, decoder, True)
self._content.append(name)
decoder.finishNestedTlvs(endOffset)
def decodeControlParameters(self, controlParameters, input):
"""
Decode input as an NDN-TLV ControlParameters and set the fields of the
controlParameters object.
:param ControlParameters controlParameters: The ControlParameters object
whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
"""
controlParameters.clear()
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(
Tlv.ControlParameters_ControlParameters)
# decode name
if decoder.peekType(Tlv.Name, endOffset):
name = Name()
self._decodeName(name, decoder)
controlParameters.setName(name)
# decode face ID
controlParameters.setFaceId(
decoder.readOptionalNonNegativeIntegerTlv(
Tlv.ControlParameters_FaceId, endOffset))
# decode URI
if decoder.peekType(Tlv.ControlParameters_Uri, endOffset):
uri = Blob(
decoder.readOptionalBlobTlv(Tlv.ControlParameters_Uri,
endOffset), False)
controlParameters.setUri(str(uri))
# decode integers
controlParameters.setLocalControlFeature(
decoder.readOptionalNonNegativeIntegerTlv(
Tlv.ControlParameters_LocalControlFeature, endOffset))
controlParameters.setOrigin(
decoder.readOptionalNonNegativeIntegerTlv(
Tlv.ControlParameters_Origin, endOffset))
controlParameters.setCost(
decoder.readOptionalNonNegativeIntegerTlv(
Tlv.ControlParameters_Cost, endOffset))
# set forwarding flags
if decoder.peekType(Tlv.ControlParameters_Flags, endOffset):
flags = ForwardingFlags()
flags.setNfdForwardingFlags(
decoder.readNonNegativeIntegerTlv(Tlv.ControlParameters_Flags))
controlParameters.setForwardingFlags(flags)
# decode strategy
if decoder.peekType(Tlv.ControlParameters_Strategy, endOffset):
strategyEndOffset = decoder.readNestedTlvsStart(
Tlv.ControlParameters_Strategy)
self._decodeName(controlParameters.getStrategy(), decoder)
decoder.finishNestedTlvs(strategyEndOffset)
# decode expiration period
controlParameters.setExpirationPeriod(
decoder.readOptionalNonNegativeIntegerTlv(
Tlv.ControlParameters_ExpirationPeriod, endOffset))
decoder.finishNestedTlvs(endOffset)
def wireDecode(self, input):
"""
Decode the input as an NDN-TLV SafeBag and update this object.
:param input: The array with the bytes to decode.
:type input: A Blob or an array type with int elements
"""
if isinstance(input, Blob):
input = input.buf()
# Decode directly as TLV. We don't support the WireFormat abstraction
# because this isn't meant to go directly on the wire.
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.SafeBag_SafeBag)
# Get the bytes of the certificate and decode.
certificateBeginOffset = decoder.getOffset()
certificateEndOffset = decoder.readNestedTlvsStart(Tlv.Data)
decoder.seek(certificateEndOffset)
self._certificate = Data()
self._certificate.wireDecode(
decoder.getSlice(certificateBeginOffset, certificateEndOffset),
TlvWireFormat.get())
self._privateKeyBag = Blob(
decoder.readBlobTlv(Tlv.SafeBag_EncryptedKeyBag), True)
decoder.finishNestedTlvs(endOffset)
def wireDecode(self, wire):
self.m_hasName = False
self.m_hasStartBlockId = False
self.m_hasEndBlockId = False
self.m_hasProcessId = False
self.m_hasMaxInterestNum = False
self.m_hasWatchTimeout = False
self.m_hasInterestLifetime = False
#self.m_wire = wire
decoder = TlvDecoder(wire)
endOffset = decoder.readNestedTlvsStart(repoTlv.RepoCommandParameter)
# Name
if (decoder.peekType(Tlv.Name)):
self.m_hasName = True
Tlv0_1WireFormat._decodeName(self.m_name, decoder)
# Selectors
if (decoder.peekType(Tlv.Selectors)):
Tlv0_1WireFormat._decodeSelectors(self.m_selector, decoder)
self.m_selectors.wireDecode(*val)
# StartBlockId
if (decoder.peekType(repoTlv.StartBlockId)):
self.m_hasStartBlockId = True
self.m_startBlockId = decoder.readNonNegativeIntegerTlv(repoTlv.StartBlockId)
# EndBlockId
if (decoder.peekType(repoTlv.EndBlockId)):
self.m_hasEndBlockId = True
self.m_endBlockId = decoder.readNonNegativeIntegerTlv(repoTlv.EndBlockId)
# ProcessId
if (decoder.peekType(repoTlv.ProcessId)):
self.m_hasProcessId = True
self.m_processId = decoder.readNonNegativeInteger(repoTlv.ProcessId)
# MaxInterestNum
if (decoder.peekType(repoTlv.MaxInterestNum)):
self.m_hasMaxInterestNum = True
self.m_maxInterestNum = decoder.readNonNegativeInteger(repoTlv.MaxInterestNum)
# WatchTimeout
if (decoder.peekType(repoTlv.WatchTimeout)):
self.m_hasWatchTimeout = True
self.m_watchTimeout = milliseconds(decoder.readNonNegativeInteger(repoTlv.WatchTimeout))
# InterestLifeTime
if (decoder.peekType(Tlv.InterestLifetime)):
self.m_hasInterestLifetime = True
self.m_interestLifetime = milliseconds(decoder.readNonNegativeInteger(Tlv.InterestLifetime))
def wireDecode(self, input):
"""
Decode the input and update this Schedule object.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
:raises ValueError: For invalid encoding.
"""
# If input is a blob, get its buf().
decodeBuffer = input.buf() if isinstance(input, Blob) else 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.
decoder = TlvDecoder(decodeBuffer)
endOffset = decoder.readNestedTlvsStart(Tlv.Encrypt_Schedule)
# Decode the whiteIntervalList.
self._whiteIntervalList = []
listEndOffset = decoder.readNestedTlvsStart(Tlv.Encrypt_WhiteIntervalList)
while decoder.getOffset() < listEndOffset:
Schedule._sortedSetAdd(self._whiteIntervalList, Schedule._decodeRepetitiveInterval(decoder))
decoder.finishNestedTlvs(listEndOffset)
# Decode the blackIntervalList.
self._blackIntervalList = []
listEndOffset = decoder.readNestedTlvsStart(Tlv.Encrypt_BlackIntervalList)
while decoder.getOffset() < listEndOffset:
Schedule._sortedSetAdd(self._blackIntervalList, Schedule._decodeRepetitiveInterval(decoder))
decoder.finishNestedTlvs(listEndOffset)
decoder.finishNestedTlvs(endOffset)
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
lpPacket = None
if element[0] == Tlv.LpPacket_LpPacket:
# Decode the LpPacket and replace element with the fragment.
lpPacket = 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.
TlvWireFormat.get().decodeLpPacket(lpPacket, element, False)
element = lpPacket.getFragmentWireEncoding().buf()
# First, decode as Interest or Data.
interest = None
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Interest, len(element)):
interest = Interest()
interest.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
interest.setLpPacket(lpPacket)
elif decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
data.setLpPacket(lpPacket)
if lpPacket != None:
# We have decoded the fragment, so remove the wire encoding to save
# memory.
lpPacket.setFragmentWireEncoding(Blob())
networkNack = NetworkNack.getFirstHeader(lpPacket)
if networkNack != None:
if interest == None:
# We got a Nack but not for an Interest, so drop the packet.
return
pendingInterests = []
self._pendingInterestTable.extractEntriesForNackInterest(
interest, pendingInterests)
for pendingInterest in pendingInterests:
try:
pendingInterest.getOnNetworkNack()(
pendingInterest.getInterest(), networkNack)
except:
logging.exception("Error in onNetworkNack")
# We have processed the network Nack packet.
return
# Now process as Interest or Data.
if interest != None:
self._dispatchInterest(interest)
elif data != None:
self._satisfyPendingInterests(data)
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
lpPacket = None
if element[0] == Tlv.LpPacket_LpPacket:
# Decode the LpPacket and replace element with the fragment.
lpPacket = 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.
TlvWireFormat.get().decodeLpPacket(lpPacket, element, False)
element = lpPacket.getFragmentWireEncoding().buf()
# First, decode as Interest or Data.
interest = None
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Interest, len(element)):
interest = Interest()
interest.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
interest.setLpPacket(lpPacket)
elif decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
data.setLpPacket(lpPacket)
if lpPacket != None:
# We have decoded the fragment, so remove the wire encoding to save
# memory.
lpPacket.setFragmentWireEncoding(Blob())
networkNack = NetworkNack.getFirstHeader(lpPacket)
if networkNack != None:
if interest == None:
# We got a Nack but not for an Interest, so drop the packet.
return
pendingInterests = []
self._pendingInterestTable.extractEntriesForNackInterest(
interest, pendingInterests)
for pendingInterest in pendingInterests:
try:
pendingInterest.getOnNetworkNack()(
pendingInterest.getInterest(), networkNack)
except:
logging.exception("Error in onNetworkNack")
# We have processed the network Nack packet.
return
# Now process as Interest or Data.
if interest != None:
self._dispatchInterest(interest)
elif data != None:
self._satisfyPendingInterests(data)
def decodeInterest(self, interest, input):
"""
Decode input as an NDN-TLV interest and set the fields of the interest
object.
:param Interest interest: The Interest object whose fields are updated.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
:return: A Tuple of (signedPortionBeginOffset, signedPortionEndOffset)
where signedPortionBeginOffset is the offset in the encoding of
the beginning of the signed portion, and signedPortionEndOffset is
the offset in the encoding of the end of the signed portion. The
signed portion starts from the first name component and ends just
before the final name component (which is assumed to be a signature
for a signed interest).
:rtype: (int, int)
"""
decoder = TlvDecoder(input)
endOffset = decoder.readNestedTlvsStart(Tlv.Interest)
offsets = self._decodeName(interest.getName(), decoder)
if decoder.peekType(Tlv.Selectors, endOffset):
self._decodeSelectors(interest, decoder)
# Require a Nonce, but don't force it to be 4 bytes.
nonce = Blob(decoder.readBlobTlv(Tlv.Nonce))
interest.setInterestLifetimeMilliseconds(
decoder.readOptionalNonNegativeIntegerTlvAsFloat
(Tlv.InterestLifetime, endOffset))
if decoder.peekType(Tlv.Data, endOffset):
# Get the bytes of the Link TLV.
linkBeginOffset = decoder.getOffset()
linkEndOffset = decoder.readNestedTlvsStart(Tlv.Data)
decoder.seek(linkEndOffset)
interest.setLinkWireEncoding(
Blob(decoder.getSlice(linkBeginOffset, linkEndOffset), True), self)
else:
interest.unsetLink()
interest.setSelectedDelegationIndex(
decoder.readOptionalNonNegativeIntegerTlv(
Tlv.SelectedDelegation, endOffset))
if (interest.getSelectedDelegationIndex() != None and
interest.getSelectedDelegationIndex() >= 0 and not interest.hasLink()):
raise RuntimeError(
"Interest has a selected delegation, but no link object")
# Set the nonce last because setting other interest fields clears it.
interest.setNonce(nonce)
decoder.finishNestedTlvs(endOffset)
return offsets
def wireDecode(self, wire):
self.m_hasName = False
self.m_hasStartBlockId = False
self.m_hasEndBlockId = False
self.m_hasProcessId = False
self.m_hasMaxInterestNum = False
self.m_hasWatchTimeout = False
self.m_hasInterestLifetime = False
#self.m_wire = wire
decoder = TlvDecoder(wire)
endOffset = decoder.readNestedTlvsStart(repoTlv.RepoCommandParameter)
# Name
if (decoder.peekType(Tlv.Name)):
self.m_hasName = True
Tlv0_1WireFormat._decodeName(self.m_name, decoder)
# Selectors
if (decoder.peekType(Tlv.Selectors)):
Tlv0_1WireFormat._decodeSelectors(self.m_selector, decoder)
self.m_selectors.wireDecode(*val)
# StartBlockId
if (decoder.peekType(repoTlv.StartBlockId)):
self.m_hasStartBlockId = True
self.m_startBlockId = decoder.readNonNegativeIntegerTlv(
repoTlv.StartBlockId)
# EndBlockId
if (decoder.peekType(repoTlv.EndBlockId)):
self.m_hasEndBlockId = True
self.m_endBlockId = decoder.readNonNegativeIntegerTlv(
repoTlv.EndBlockId)
# ProcessId
if (decoder.peekType(repoTlv.ProcessId)):
self.m_hasProcessId = True
self.m_processId = decoder.readNonNegativeInteger(
repoTlv.ProcessId)
# MaxInterestNum
if (decoder.peekType(repoTlv.MaxInterestNum)):
self.m_hasMaxInterestNum = True
self.m_maxInterestNum = decoder.readNonNegativeInteger(
repoTlv.MaxInterestNum)
# WatchTimeout
if (decoder.peekType(repoTlv.WatchTimeout)):
self.m_hasWatchTimeout = True
self.m_watchTimeout = milliseconds(
decoder.readNonNegativeInteger(repoTlv.WatchTimeout))
# InterestLifeTime
if (decoder.peekType(Tlv.InterestLifetime)):
self.m_hasInterestLifetime = True
self.m_interestLifetime = milliseconds(
decoder.readNonNegativeInteger(Tlv.InterestLifetime))
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
lpPacket = None
if element[0] == Tlv.LpPacket_LpPacket:
# Decode the LpPacket and replace element with the fragment.
lpPacket = 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.
TlvWireFormat.get().decodeLpPacket(lpPacket, element, False)
element = lpPacket.getFragmentWireEncoding().buf()
# First, decode as Interest or Data.
interest = None
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Interest, len(element)):
interest = Interest()
interest.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
interest.setLpPacket(lpPacket)
elif decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
data.setLpPacket(lpPacket)
if lpPacket != None:
# We have decoded the fragment, so remove the wire encoding to save
# memory.
lpPacket.setFragmentWireEncoding(Blob())
networkNack = NetworkNack.getFirstHeader(lpPacket)
if networkNack != None:
if interest == None:
# We got a Nack but not for an Interest, so drop the packet.
return
pendingInterests = []
self._pendingInterestTable.extractEntriesForNackInterest(
interest, pendingInterests)
for pendingInterest in pendingInterests:
try:
pendingInterest.getOnNetworkNack()(
pendingInterest.getInterest(), networkNack)
except:
logging.exception("Error in onNetworkNack")
# We have processed the network Nack packet.
return
# Now process as Interest or Data.
if interest != None:
# Call all interest filter callbacks which match.
matchedFilters = []
self._interestFilterTable.getMatchedFilters(
interest, matchedFilters)
for i in range(len(matchedFilters)):
entry = matchedFilters[i]
includeFilter = True
onInterestCall = entry.getOnInterest()
# If onInterest is not a function nor a method assumes it is a
# calleable object
if (not inspect.isfunction(onInterestCall)
and not inspect.ismethod(onInterestCall)):
onInterestCall = onInterestCall.__call__
# Use getcallargs to test if onInterest accepts 5 args.
try:
inspect.getcallargs(onInterestCall, None, None, None, None,
None)
except TypeError:
# Assume onInterest is old-style with 4 arguments.
includeFilter = False
if includeFilter:
try:
entry.getOnInterest()(entry.getFilter().getPrefix(),
interest, entry.getFace(),
entry.getInterestFilterId(),
entry.getFilter())
except:
logging.exception("Error in onInterest")
else:
# Old-style onInterest without the filter argument. We
# still pass a Face instead of Transport since Face also
# has a send method.
try:
entry.getOnInterest()(entry.getFilter().getPrefix(),
interest, entry.getFace(),
entry.getInterestFilterId())
except:
logging.exception("Error in onInterest")
elif data != None:
pendingInterests = []
self._pendingInterestTable.extractEntriesForExpressedInterest(
data, pendingInterests)
for pendingInterest in pendingInterests:
try:
pendingInterest.getOnData()(pendingInterest.getInterest(),
data)
except:
logging.exception("Error in onData")
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
lpPacket = None
if element[0] == Tlv.LpPacket_LpPacket:
# Decode the LpPacket and replace element with the fragment.
lpPacket = 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.
TlvWireFormat.get().decodeLpPacket(lpPacket, element, False)
element = lpPacket.getFragmentWireEncoding().buf()
# First, decode as Interest or Data.
interest = None
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Interest, len(element)):
interest = Interest()
interest.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
interest.setLpPacket(lpPacket)
elif decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
if lpPacket != None:
data.setLpPacket(lpPacket)
if lpPacket != None:
# We have decoded the fragment, so remove the wire encoding to save
# memory.
lpPacket.setFragmentWireEncoding(Blob())
networkNack = NetworkNack.getFirstHeader(lpPacket)
if networkNack != None:
if interest == None:
# We got a Nack but not for an Interest, so drop the packet.
return
pendingInterests = []
self._pendingInterestTable.extractEntriesForNackInterest(
interest, pendingInterests)
for pendingInterest in pendingInterests:
try:
pendingInterest.getOnNetworkNack()(
pendingInterest.getInterest(), networkNack)
except:
logging.exception("Error in onNetworkNack")
# We have processed the network Nack packet.
return
# Now process as Interest or Data.
if interest != None:
# Call all interest filter callbacks which match.
matchedFilters = []
self._interestFilterTable.getMatchedFilters(interest, matchedFilters)
for i in range(len(matchedFilters)):
entry = matchedFilters[i]
includeFilter = True
onInterestCall = entry.getOnInterest()
# If onInterest is not a function nor a method assumes it is a
# calleable object
if (not inspect.isfunction(onInterestCall) and
not inspect.ismethod(onInterestCall)):
onInterestCall = onInterestCall.__call__
# Use getcallargs to test if onInterest accepts 5 args.
try:
inspect.getcallargs(onInterestCall,
None, None, None, None, None)
except TypeError:
# Assume onInterest is old-style with 4 arguments.
includeFilter = False
if includeFilter:
try:
entry.getOnInterest()(
entry.getFilter().getPrefix(), interest,
entry.getFace(), entry.getInterestFilterId(),
entry.getFilter())
except:
logging.exception("Error in onInterest")
else:
# Old-style onInterest without the filter argument. We
# still pass a Face instead of Transport since Face also
# has a send method.
try:
entry.getOnInterest()(
entry.getFilter().getPrefix(), interest,
entry.getFace(), entry.getInterestFilterId())
except:
logging.exception("Error in onInterest")
elif data != None:
pendingInterests = []
self._pendingInterestTable.extractEntriesForExpressedInterest(
data, pendingInterests)
for pendingInterest in pendingInterests:
try:
pendingInterest.getOnData()(pendingInterest.getInterest(), data)
except:
logging.exception("Error in onData")
def findElementEnd(self, input):
"""
Continue scanning input starting from self._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.
:param input: The input buffer. You have to pass in input each time
because the buffer could be reallocated.
:type input: An array type with int elements
:return: True if found the element end, False if not.
:rtype: bool
"""
if self._gotElementEnd:
# Someone is calling when we already got the end.
return True
decoder = TlvDecoder(input)
while True:
if self._offset >= len(input):
# All the cases assume we have some input. Return and wait
# for more.
return False
if self._state == self.READ_TYPE:
firstOctet = input[self._offset]
self._offset += 1
if firstOctet < 253:
# The value is simple, so we can skip straight to reading
# the length.
self._state = self.READ_LENGTH
else:
# Set up to skip the type bytes.
if firstOctet == 253:
self._nBytesToRead = 2
elif firstOctet == 254:
self._nBytesToRead = 4
else:
# value == 255.
self._nBytesToRead = 8
self._state = self.READ_TYPE_BYTES
elif self._state == self.READ_TYPE_BYTES:
nRemainingBytes = len(input) - self._offset
if nRemainingBytes < self._nBytesToRead:
# Need more.
self._offset += nRemainingBytes
self._nBytesToRead -= nRemainingBytes
return False
# Got the type bytes. Move on to read the length.
self._offset += self._nBytesToRead
self._state = self.READ_LENGTH
elif self._state == self.READ_LENGTH:
firstOctet = input[self._offset]
self._offset += 1
if firstOctet < 253:
# The value is simple, so we can skip straight to reading
# the value bytes.
self._nBytesToRead = firstOctet
if self._nBytesToRead == 0:
# No value bytes to read. We're finished.
self._gotElementEnd = True
return True
self._state = self.READ_VALUE_BYTES
else:
# We need to read the bytes in the extended encoding of
# the length.
if firstOctet == 253:
self._nBytesToRead = 2
elif firstOctet == 254:
self._nBytesToRead = 4
else:
# value == 255.
self._nBytesToRead = 8
# We need to use firstOctet in the next state.
self._firstOctet = firstOctet
self._state = self.READ_LENGTH_BYTES
elif self._state == self.READ_LENGTH_BYTES:
nRemainingBytes = len(input) - self._offset
if (not self._useHeaderBuffer and
nRemainingBytes >= self._nBytesToRead):
# We don't have to use the headerBuffer. Set nBytesToRead.
decoder.seek(self._offset)
self._nBytesToRead = decoder.readExtendedVarNumber(
self._firstOctet)
# Update self._offset to the decoder's offset after reading.
self._offset = decoder.getOffset()
else:
self._useHeaderBuffer = True
nNeededBytes = self._nBytesToRead - self._headerLength
if nNeededBytes > nRemainingBytes:
# We can't get all of the header bytes from this input.
# Save in headerBuffer.
if (self._headerLength + nRemainingBytes >
len(self._headerBuffer)):
# We don't expect this to happen.
raise RuntimeError(
"Cannot store more header bytes than the size of headerBuffer")
self._headerBuffer[
self._headerLength:self._headerLength + nRemainingBytes] = \
input[self._offset:self._offset + nRemainingBytes]
self._offset += nRemainingBytes
self._headerLength += nRemainingBytes
return False
# Copy the remaining bytes into headerBuffer, read the
# length and set nBytesToRead.
if (self._headerLength + nNeededBytes >
len(self._headerBuffer)):
# We don't expect this to happen.
raise RuntimeError(
"Cannot store more header bytes than the size of headerBuffer")
self._headerBuffer[
self._headerLength:self._headerLength + nNeededBytes] = \
input[self._offset:self._offset + nNeededBytes]
self._offset += nNeededBytes
# Use a local decoder just for the headerBuffer.
bufferDecoder = TlvDecoder(self._headerBuffer)
# Replace nBytesToRead with the length of the value.
self._nBytesToRead = bufferDecoder.readExtendedVarNumber(
self._firstOctet)
if self._nBytesToRead == 0:
# No value bytes to read. We're finished.
self._gotElementEnd = True
return True
# Get ready to read the value bytes.
self._state = self.READ_VALUE_BYTES
elif self._state == self.READ_VALUE_BYTES:
nRemainingBytes = len(input) - self._offset
if nRemainingBytes < self._nBytesToRead:
# Need more.
self._offset += nRemainingBytes
self._nBytesToRead -= nRemainingBytes
return False
# Got the bytes. We're finished.
self._offset += self._nBytesToRead
self._gotElementEnd = True
return True
else:
# We don't expect this to happen.
raise RuntimeError("findElementEnd: unrecognized state")
def onReceivedElement(self, element):
"""
This is called by the transport's ElementReader to process an
entire received Data or Interest element.
:param element: The bytes of the incoming element.
:type element: An array type with int elements
"""
# The type codes for TLV Interest and Data packets are chosen to not
# conflict with the first byte of a binary XML packet, so we canjust
# look at the first byte.
if not (element[0] == Tlv.Interest or element[0] == Tlv.Data):
# Ignore non-TLV elements.
# Assume it is Binary XML.
if not WireFormat.ENABLE_NDNX:
raise RuntimeError(
"BinaryXmlWireFormat (NDNx) is deprecated. To enable while you upgrade your network to use NDN-TLV, set WireFormat.ENABLE_NDNX = True")
return
# First, decode as Interest or Data.
interest = None
data = None
decoder = TlvDecoder(element)
if decoder.peekType(Tlv.Interest, len(element)):
interest = Interest()
interest.wireDecode(element, TlvWireFormat.get())
elif decoder.peekType(Tlv.Data, len(element)):
data = Data()
data.wireDecode(element, TlvWireFormat.get())
# Now process as Interest or Data.
if interest != None:
# Call all interest filter callbacks which match.
for i in range(len(self._interestFilterTable)):
entry = self._interestFilterTable[i]
if entry.getFilter().doesMatch(interest.getName()):
includeFilter = True
# Use getcallargs to test if onInterest accepts 5 args.
try:
inspect.getcallargs(entry.getOnInterest(),
None, None, None, None, None)
except TypeError:
# Assume onInterest is old-style with 4 arguments.
includeFilter = False
if includeFilter:
entry.getOnInterest()(
entry.getFilter().getPrefix(), interest,
entry.getFace(), entry.getInterestFilterId(),
entry.getFilter())
else:
# Old-style onInterest without the filter argument. We
# still pass a Face instead of Transport since Face also
# has a send method.
entry.getOnInterest()(
entry.getFilter().getPrefix(), interest,
entry.getFace(), entry.getInterestFilterId())
elif data != None:
pendingInterests = self._extractEntriesForExpressedInterest(
data.getName())
for pendingInterest in pendingInterests:
pendingInterest.getOnData()(pendingInterest.getInterest(), data)
def wireDecode(self, input):
"""
Decode the input and update this Schedule object.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
:raises ValueError: For invalid encoding.
"""
# If input is a blob, get its buf().
decodeBuffer = input.buf() if isinstance(input, Blob) else 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.
decoder = TlvDecoder(decodeBuffer)
endOffset = decoder.readNestedTlvsStart(Tlv.Encrypt_Schedule)
# Decode the whiteIntervalList.
self._whiteIntervalList = []
listEndOffset = decoder.readNestedTlvsStart(
Tlv.Encrypt_WhiteIntervalList)
while decoder.getOffset() < listEndOffset:
Schedule._sortedSetAdd(self._whiteIntervalList,
Schedule._decodeRepetitiveInterval(decoder))
decoder.finishNestedTlvs(listEndOffset)
# Decode the blackIntervalList.
self._blackIntervalList = []
listEndOffset = decoder.readNestedTlvsStart(
Tlv.Encrypt_BlackIntervalList)
while decoder.getOffset() < listEndOffset:
Schedule._sortedSetAdd(self._blackIntervalList,
Schedule._decodeRepetitiveInterval(decoder))
decoder.finishNestedTlvs(listEndOffset)
decoder.finishNestedTlvs(endOffset)
def decodeStateVector(input):
"""
Decode the input as a TLV state vector.
:param input: The array with the bytes to decode.
:type input: An array type with int elements
:return: A new dictionary where the key is the member ID string and the
value is the sequence number. If the input encoding has repeated
entries with the same member ID, this uses only the last entry.
:rtype: dict<str,int>
:raises ValueError: For invalid encoding.
"""
stateVector = {}
# If input is a blob, get its buf().
decodeBuffer = input.buf() if isinstance(input, Blob) else input
decoder = TlvDecoder(decodeBuffer)
endOffset = decoder.readNestedTlvsStart(
StateVectorSync2018.TLV_StateVector)
while decoder.getOffset() < endOffset:
entryEndOffset = decoder.readNestedTlvsStart(
StateVectorSync2018.TLV_StateVectorEntry)
memberIdBlob = Blob(
decoder.readBlobTlv(
StateVectorSync2018.TLV_StateVector_MemberId), False)
stateVector[str(memberIdBlob)] = decoder.readNonNegativeIntegerTlv(
StateVectorSync2018.TLV_StateVector_SequenceNumber)
decoder.finishNestedTlvs(entryEndOffset)
decoder.finishNestedTlvs(endOffset)
return stateVector
