示例#1
0
/**
 * This private function is called by ndn_TlvEncoder_writeNestedTlv to write the TLVs in the body of the Data value.
 * @param context This is the DataValueContext struct pointer which was passed to writeTlv.
 * @param encoder the ndn_TlvEncoder which is calling this.
 * @return 0 for success, else an error code.
 */
static ndn_Error
encodeDataValue(const void *context, struct ndn_TlvEncoder *encoder)
{
  const struct DataValueContext *dataValueContext = (const struct DataValueContext *)context;
  const struct ndn_Data *data = dataValueContext->data;
  ndn_Error error;
  size_t dummyBeginOffset, dummyEndOffset;

  *dataValueContext->signedPortionBeginOffset = encoder->offset;

  if ((error = ndn_encodeTlvName
       (&data->name, &dummyBeginOffset, &dummyEndOffset, encoder)))
    return error;
  if ((error = ndn_TlvEncoder_writeNestedTlv(encoder, ndn_Tlv_MetaInfo, encodeMetaInfoValue, &data->metaInfo, 0)))
    return error;
  if ((error = ndn_TlvEncoder_writeBlobTlv(encoder, ndn_Tlv_Content, &data->content)))
    return error;
  if ((error = ndn_encodeTlvSignatureInfo(&data->signature, encoder)))
    return error;

  *dataValueContext->signedPortionEndOffset = encoder->offset;

  if ((error = ndn_TlvEncoder_writeBlobTlv(encoder, ndn_Tlv_SignatureValue, &data->signature.signature)))
    return error;

  return NDN_ERROR_success;
}
示例#2
0
ndn_Error
ndn_Tlv0_2WireFormat_encodeName
(const struct ndn_Name *name, size_t *signedPortionBeginOffset,
 size_t *signedPortionEndOffset, struct ndn_DynamicUInt8Array *output,
 size_t *encodingLength)
{
    ndn_Error error;
    struct ndn_TlvEncoder encoder;
    ndn_TlvEncoder_initialize(&encoder, output);
    error = ndn_encodeTlvName
            (name, signedPortionBeginOffset, signedPortionEndOffset, &encoder);
    *encodingLength = encoder.offset;

    return error;
}
示例#3
0
/**
 * This private function is called by ndn_TlvEncoder_writeNestedTlv to write the TLVs
 * in the body of the Delegation value.
 * @param context This is the ndn_DelegationSet_Delegation struct pointer which
 * was passed to writeTlv.
 * @param encoder the ndn_TlvEncoder which is calling this.
 * @return 0 for success, else an error code.
 */
static ndn_Error
encodeDelegationValue(const void *context, struct ndn_TlvEncoder *encoder)
{
  struct ndn_DelegationSet_Delegation *delegation =
    (struct ndn_DelegationSet_Delegation *)context;
  ndn_Error error;
  size_t dummyBeginOffset, dummyEndOffset;

  if ((error = ndn_TlvEncoder_writeNonNegativeIntegerTlv
      (encoder, ndn_Tlv_Link_Preference, delegation->preference)))
    return error;
  if ((error = ndn_encodeTlvName
       (&delegation->name, &dummyBeginOffset, &dummyEndOffset, encoder)))
    return error;

  return NDN_ERROR_success;
}
示例#4
0
ndn_Error
ndn_encodeTlvKeyLocatorValue(const void *context, struct ndn_TlvEncoder *encoder)
{
  struct ndn_KeyLocator *keyLocator = (struct ndn_KeyLocator *)context;
  ndn_Error error;

  if ((int)keyLocator->type < 0)
    return NDN_ERROR_success;

  if (keyLocator->type == ndn_KeyLocatorType_KEYNAME) {
    size_t dummyBeginOffset, dummyEndOffset;
    if ((error = ndn_encodeTlvName
         (&keyLocator->keyName, &dummyBeginOffset, &dummyEndOffset, encoder)))
      return error;
  }
  else if (keyLocator->type == ndn_KeyLocatorType_KEY_LOCATOR_DIGEST && keyLocator->keyData.length > 0) {
    if ((error = ndn_TlvEncoder_writeBlobTlv(encoder, ndn_Tlv_KeyLocatorDigest, &keyLocator->keyData)))
      return error;
  }
  else
    return NDN_ERROR_unrecognized_ndn_KeyLocatorType;

  return NDN_ERROR_success;
}
示例#5
0
/**
 * This private function is called by ndn_TlvEncoder_writeNestedTlv to write the TLVs in the body of the Interest value.
 * @param context This is the InterestValueContext struct pointer which was passed to writeTlv.
 * @param encoder the ndn_TlvEncoder which is calling this.
 * @return 0 for success, else an error code.
 */
static ndn_Error
encodeInterestValue(const void *context, struct ndn_TlvEncoder *encoder)
{
  const struct InterestValueContext *interestValueContext =
    (const struct InterestValueContext *)context;
  const struct ndn_Interest *interest = interestValueContext->interest;
  ndn_Error error;
  uint8_t nonceBuffer[4];
  struct ndn_Blob nonceBlob;

  if ((error = ndn_encodeTlvName
       (&interest->name, interestValueContext->signedPortionBeginOffset,
        interestValueContext->signedPortionEndOffset, encoder)))
    return error;
  // For Selectors, set omitZeroLength true.
  if ((error = ndn_TlvEncoder_writeNestedTlv(encoder, ndn_Tlv_Selectors, encodeSelectorsValue, interest, 1)))
    return error;

  // Encode the Nonce as 4 bytes.
  nonceBlob.length = sizeof(nonceBuffer);
  if (interest->nonce.length == 0) {
    // Generate a random nonce.
    if ((error = ndn_generateRandomBytes(nonceBuffer, sizeof(nonceBuffer))))
      return error;
    nonceBlob.value = nonceBuffer;
  }
  else if (interest->nonce.length < 4) {
    // TLV encoding requires 4 bytes, so pad out to 4 using random bytes.
    ndn_memcpy(nonceBuffer, interest->nonce.value, interest->nonce.length);
    if ((error = ndn_generateRandomBytes
         (nonceBuffer + interest->nonce.length,
          sizeof(nonceBuffer) - interest->nonce.length)))
      return error;
    nonceBlob.value = nonceBuffer;
  }
  else
    // TLV encoding requires 4 bytes, so truncate to 4.
    nonceBlob.value = interest->nonce.value;
  if ((error = ndn_TlvEncoder_writeBlobTlv(encoder, ndn_Tlv_Nonce, &nonceBlob)))
    return error;

  if ((error = ndn_TlvEncoder_writeOptionalNonNegativeIntegerTlvFromDouble
      (encoder, ndn_Tlv_InterestLifetime, interest->interestLifetimeMilliseconds)))
    return error;

  if (interest->forwardingHintWireEncoding.value &&
      interest->forwardingHintWireEncoding.length > 0) {
    if (interest->selectedDelegationIndex >= 0)
      return NDN_ERROR_An_Interest_may_not_have_a_selected_delegation_when_encoding_a_forwarding_hint;
    if (interest->linkWireEncoding.value)
      return NDN_ERROR_An_Interest_may_not_have_a_link_object_when_encoding_a_forwarding_hint;

    // Add the encoded sequence of delegations as is.
    if ((error = ndn_TlvEncoder_writeBlobTlv
         (encoder, ndn_Tlv_ForwardingHint, &interest->forwardingHintWireEncoding)))
      return error;
  }

  if (interest->linkWireEncoding.value) {
    // Encode the entire link as is.
    if ((error = ndn_TlvEncoder_writeArray
        (encoder, interest->linkWireEncoding.value, interest->linkWireEncoding.length)))
      return error;
  }
  if ((error = ndn_TlvEncoder_writeOptionalNonNegativeIntegerTlv
      (encoder, ndn_Tlv_SelectedDelegation, interest->selectedDelegationIndex)))
    return error;

  return NDN_ERROR_success;
}