bool
ccnxCodecTlvUtilities_PutAsBuffer(CCNxCodecTlvDecoder *decoder, CCNxTlvDictionary *packetDictionary, uint16_t type, uint16_t length, int arrayKey)
{
PARCBuffer *buffer = ccnxCodecTlvDecoder_GetValue(decoder, length);
bool success = ccnxTlvDictionary_PutBuffer(packetDictionary, arrayKey, buffer);
parcBuffer_Release(&buffer);
return success;
}
static bool
_ccnxInterestFacadeV1_SetContentObjectHashRestriction(CCNxTlvDictionary *interestDictionary, const PARCBuffer *contentObjectHash)
{
_assertInvariants(interestDictionary);
return ccnxTlvDictionary_PutBuffer(interestDictionary,
CCNxCodecSchemaV1TlvDictionary_MessageFastArray_OBJHASH_RESTRICTION,
contentObjectHash);
}
bool
ccnxCodecSchemaV1FixedHeaderDecoder_Decode(CCNxCodecTlvDecoder *decoder, CCNxTlvDictionary *packetDictionary)
{
if (ccnxCodecTlvDecoder_EnsureRemaining(decoder, _fixedHeaderBytes)) {
PARCBuffer *buffer = ccnxCodecTlvDecoder_GetValue(decoder, _fixedHeaderBytes);
bool success = ccnxTlvDictionary_PutBuffer(packetDictionary, CCNxCodecSchemaV1TlvDictionary_HeadersFastArray_FixedHeader, buffer);
// validation
parcBuffer_SetPosition(buffer, _fixedHeader_VersionOffset);
uint8_t version = parcBuffer_GetUint8(buffer);
parcBuffer_SetPosition(buffer, _fixedHeader_PacketLengthOffset);
uint16_t packetLength = parcBuffer_GetUint16(buffer);
parcBuffer_SetPosition(buffer, _fixedHeader_HopLimitOffset);
uint8_t hopLimit = parcBuffer_GetUint8(buffer);
parcBuffer_SetPosition(buffer, _fixedHeader_HeaderLengthOffset);
uint8_t headerLength = parcBuffer_GetUint8(buffer);
if (version != 1) {
CCNxCodecError *error = ccnxCodecError_Create(TLV_ERR_VERSION, __func__, __LINE__, _fixedHeader_VersionOffset);
ccnxCodecTlvDecoder_SetError(decoder, error);
ccnxCodecError_Release(&error);
success = false;
} else if (packetLength < _fixedHeaderBytes) {
CCNxCodecError *error = ccnxCodecError_Create(TLV_ERR_PACKETLENGTH_TOO_SHORT, __func__, __LINE__, _fixedHeader_PacketTypeOffset);
ccnxCodecTlvDecoder_SetError(decoder, error);
ccnxCodecError_Release(&error);
success = false;
} else if (headerLength < _fixedHeaderBytes) {
CCNxCodecError *error = ccnxCodecError_Create(TLV_ERR_HEADERLENGTH_TOO_SHORT, __func__, __LINE__, _fixedHeader_HeaderLengthOffset);
ccnxCodecTlvDecoder_SetError(decoder, error);
ccnxCodecError_Release(&error);
success = false;
} else if (packetLength < headerLength) {
CCNxCodecError *error = ccnxCodecError_Create(TLV_ERR_PACKETLENGTHSHORTER, __func__, __LINE__, _fixedHeader_PacketTypeOffset);
ccnxCodecTlvDecoder_SetError(decoder, error);
ccnxCodecError_Release(&error);
success = false;
}
// decoder now points to just past the fixed header
parcBuffer_Release(&buffer);
// Set the hoplimit in the dictionary.
ccnxTlvDictionary_PutInteger(packetDictionary, CCNxCodecSchemaV1TlvDictionary_MessageFastArray_HOPLIMIT, hopLimit);
return success;
} else {
CCNxCodecError *error = ccnxCodecError_Create(TLV_ERR_DECODE, __func__, __LINE__, ccnxCodecTlvDecoder_Position(decoder));
ccnxCodecTlvDecoder_SetError(decoder, error);
ccnxCodecError_Release(&error);
return false;
}
}
bool
ccnxValidationRsaSha256_Set(CCNxTlvDictionary *message, const PARCBuffer *keyid, const CCNxKeyLocator *keyLocator)
{
bool success = true;
success &= ccnxTlvDictionary_PutInteger(message, CCNxCodecSchemaV1TlvDictionary_ValidationFastArray_CRYPTO_SUITE, PARCCryptoSuite_RSA_SHA256);
if (keyid) {
success &= ccnxTlvDictionary_PutBuffer(message, CCNxCodecSchemaV1TlvDictionary_ValidationFastArray_KEYID, keyid);
}
success &= ccnxValidationFacadeV1_SetKeyLocator(message, (CCNxKeyLocator *) keyLocator); // un-consting
return success;
}
static bool
_ccnxInterestFacadeV1_SetPayloadWithId(CCNxTlvDictionary *interestDictionary, const PARCBuffer *payload, const CCNxInterestPayloadId *payloadId)
{
bool result = false;
if (payload) {
result = ccnxTlvDictionary_PutBuffer(interestDictionary,
CCNxCodecSchemaV1TlvDictionary_MessageFastArray_PAYLOAD, payload);
if (payloadId != NULL) {
CCNxName *name = _ccnxInterestFacadeV1_GetName(interestDictionary);
ccnxName_Append(name, ccnxInterestPayloadId_GetNameSegment(payloadId));
}
}
return result;
}
/**
* Sets the Validation algorithm to HMAC with SHA-256 hash
*
* Sets the validation algorithm to be HMAC with a SHA-256 digest. Optionally includes
* a KeyId with the message.
*
* @param [in] message The message dictionary
* @param [in] keyid (Optional) The KEYID to include the the message
*
* @return <#value#> <#explanation#>
*
* Example:
* @code
* <#example#>
* @endcode
*/
bool
ccnxValidationHmacSha256_Set(CCNxTlvDictionary *message, const PARCBuffer *keyid)
{
bool success = true;
switch (ccnxTlvDictionary_GetSchemaVersion(message)) {
case CCNxTlvDictionary_SchemaVersion_V1: {
success &= ccnxTlvDictionary_PutInteger(message, CCNxCodecSchemaV1TlvDictionary_ValidationFastArray_CRYPTO_SUITE, PARCCryptoSuite_HMAC_SHA256);
if (keyid) {
success &= ccnxTlvDictionary_PutBuffer(message, CCNxCodecSchemaV1TlvDictionary_ValidationFastArray_KEYID, keyid);
}
break;
}
default:
trapIllegalValue(message, "Unknown schema version: %d", ccnxTlvDictionary_GetSchemaVersion(message));
}
return success;
}
static bool
_ccnxInterestFacadeV1_SetKeyIdRestriction(CCNxTlvDictionary *interestDictionary, const PARCBuffer *keyId)
{
_assertInvariants(interestDictionary);
return ccnxTlvDictionary_PutBuffer(interestDictionary, CCNxCodecSchemaV1TlvDictionary_MessageFastArray_KEYID_RESTRICTION, keyId);
}