tlv-decoder.h

#ifndef NDN_TLV_DECODER_H
#define NDN_TLV_DECODER_H

#include <ndn-cpp/c/common.h>
#include <ndn-cpp/c/errors.h>
#include "../../util/blob.h"
#include "tlv.h"

#ifdef  __cplusplus
extern "C" {
#endif

struct ndn_TlvDecoder {
  const uint8_t *input;
  size_t inputLength;
  size_t offset;
};

static __inline void
ndn_TlvDecoder_initialize(struct ndn_TlvDecoder *self, const uint8_t *input, size_t inputLength)
{
  self->input = input;
  self->inputLength = inputLength;
  self->offset = 0;
}

ndn_Error
ndn_TlvDecoder_readExtendedVarNumber(struct ndn_TlvDecoder *self, unsigned int firstOctet, uint64_t *varNumber);

static __inline ndn_Error
ndn_TlvDecoder_readVarNumber(struct ndn_TlvDecoder *self, uint64_t *varNumber)
{
  unsigned int firstOctet;

  // Read the first octet inline.
  if (self->offset >= self->inputLength)
    return NDN_ERROR_read_past_the_end_of_the_input;

  firstOctet = (unsigned int)self->input[self->offset++];
  if (firstOctet < 253) {
    // The value is simple, so we can return it inline.
    *varNumber = (uint64_t)firstOctet;
    return NDN_ERROR_success;
  }
  else
    return ndn_TlvDecoder_readExtendedVarNumber(self, firstOctet, varNumber);
}

static __inline ndn_Error
ndn_TlvDecoder_readTypeAndLength
  (struct ndn_TlvDecoder *self, unsigned int expectedType, size_t *length)
{
  ndn_Error error;
  uint64_t type;
  uint64_t lengthVarNumber;

  if ((error = ndn_TlvDecoder_readVarNumber(self, &type)))
    return error;

  if (type != (uint64_t)expectedType)
    return NDN_ERROR_did_not_get_the_expected_TLV_type;

  if ((error = ndn_TlvDecoder_readVarNumber(self, &lengthVarNumber)))
    return error;

  // Silently ignore if the length is larger than size_t.
  *length = (size_t)lengthVarNumber;
  if (self->offset + *length > self->inputLength)
    return NDN_ERROR_TLV_length_exceeds_buffer_length;

  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvDecoder_readNestedTlvsStart(struct ndn_TlvDecoder *self, unsigned int expectedType, size_t *endOffset)
{
  ndn_Error error;
  size_t length;
  if ((error = ndn_TlvDecoder_readTypeAndLength(self, expectedType, &length)))
    return error;
  *endOffset = self->offset + length;

  return NDN_ERROR_success;
}

ndn_Error
ndn_TlvDecoder_skipRemainingNestedTlvs
  (struct ndn_TlvDecoder *self, size_t endOffset);

static __inline ndn_Error
ndn_TlvDecoder_finishNestedTlvs(struct ndn_TlvDecoder *self, size_t endOffset)
{
  // Check the simple, expected case inline.
  if (self->offset != endOffset)
    return ndn_TlvDecoder_skipRemainingNestedTlvs(self, endOffset);

  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvDecoder_peekType(struct ndn_TlvDecoder *self, unsigned int expectedType, size_t endOffset, int *gotExpectedType)
{
  if (self->offset >= endOffset)
    // No more sub TLVs to look at.
    *gotExpectedType = 0;
  else {
    size_t saveOffset = self->offset;
    uint64_t type;
    ndn_Error error = ndn_TlvDecoder_readVarNumber(self, &type);
    // Restore offset.
    self->offset = saveOffset;
    if (error)
      return error;

    *gotExpectedType = (type == expectedType ? 1 : 0);
  }

  return NDN_ERROR_success;
}

ndn_Error
ndn_TlvDecoder_readExtendedNonNegativeInteger(struct ndn_TlvDecoder *self, size_t length, uint64_t *value);

static __inline ndn_Error
ndn_TlvDecoder_readNonNegativeInteger(struct ndn_TlvDecoder *self, size_t length, uint64_t *value)
{
  if (length == 1) {
    // Read the simple integer inline.
    if (self->offset >= self->inputLength)
      return NDN_ERROR_read_past_the_end_of_the_input;

    *value = (uint64_t)self->input[self->offset++];
    return NDN_ERROR_success;
  }
  else
    return ndn_TlvDecoder_readExtendedNonNegativeInteger(self, length, value);
}

static __inline ndn_Error
ndn_TlvDecoder_readNonNegativeIntegerTlv(struct ndn_TlvDecoder *self, unsigned int expectedType, uint64_t *value)
{
  ndn_Error error;
  size_t length;
  if ((error = ndn_TlvDecoder_readTypeAndLength(self, expectedType, &length)))
    return error;
  if ((error = ndn_TlvDecoder_readNonNegativeInteger(self, length, value)))
    return error;

  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvDecoder_readOptionalNonNegativeIntegerTlv
  (struct ndn_TlvDecoder *self, unsigned int expectedType, size_t endOffset,
   int *value)
{
  int gotExpectedType;
  ndn_Error error;
  uint64_t unsignedValue;

  if ((error = ndn_TlvDecoder_peekType
       (self, expectedType, endOffset, &gotExpectedType)))
    return error;

  if (!gotExpectedType) {
    *value = -1;
    return NDN_ERROR_success;
  }

  if ((error = ndn_TlvDecoder_readNonNegativeIntegerTlv
       (self, expectedType, &unsignedValue)))
    return error;

  *value = (int)unsignedValue;
  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvDecoder_readOptionalNonNegativeIntegerTlvAsDouble
  (struct ndn_TlvDecoder *self, unsigned int expectedType, size_t endOffset,
   double *value)
{
  int gotExpectedType;
  ndn_Error error;
  uint64_t unsignedValue;

  if ((error = ndn_TlvDecoder_peekType
       (self, expectedType, endOffset, &gotExpectedType)))
    return error;

  if (!gotExpectedType) {
    *value = -1;
    return NDN_ERROR_success;
  }

  if ((error = ndn_TlvDecoder_readNonNegativeIntegerTlv
       (self, expectedType, &unsignedValue)))
    return error;

  *value = (double)unsignedValue;
  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvDecoder_readBlobTlv
  (struct ndn_TlvDecoder *self, unsigned int expectedType, struct ndn_Blob *value)
{
  ndn_Error error;
  if ((error = ndn_TlvDecoder_readTypeAndLength(self, expectedType, &value->length)))
    return error;

  // ndn_TlvDecoder_readTypeAndLength already checked if the value->length exceeds the input buffer.
  value->value = self->input + self->offset;
  self->offset += value->length;

  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvDecoder_readOptionalBlobTlv
  (struct ndn_TlvDecoder *self, unsigned int expectedType, size_t endOffset,
   struct ndn_Blob *value)
{
  int gotExpectedType;
  ndn_Error error;

  if ((error = ndn_TlvDecoder_peekType
       (self, expectedType, endOffset, &gotExpectedType)))
    return error;

  if (!gotExpectedType) {
    value->value = 0;
    value->length = 0;
    return NDN_ERROR_success;
  }

  if ((error = ndn_TlvDecoder_readBlobTlv(self, expectedType, value)))
    return error;

  return NDN_ERROR_success;
}

static __inline ndn_Error
ndn_TlvDecoder_readBooleanTlv
  (struct ndn_TlvDecoder *self, unsigned int expectedType, size_t endOffset, int *value)
{
  int gotExpectedType;
  ndn_Error error;
  if ((error = ndn_TlvDecoder_peekType(self, expectedType, endOffset, &gotExpectedType)))
    return error;

  if (!gotExpectedType)
    *value = 0;
  else {
    size_t length;
    if ((error = ndn_TlvDecoder_readTypeAndLength(self, expectedType, &length)))
      return error;
    // We expect the length to be 0, but update offset anyway.
    self->offset += length;

    *value = 1;
  }

  return NDN_ERROR_success;
}

static __inline void ndn_TlvDecoder_seek(struct ndn_TlvDecoder *self, size_t offset)
{
  self->offset = offset;
}

static __inline ndn_Error
ndn_TlvDecoder_getSlice
  (struct ndn_TlvDecoder *self, size_t beginOffset, size_t endOffset,
   struct ndn_Blob *slice)
{
  if (beginOffset > self->inputLength || endOffset > self->inputLength)
    return NDN_ERROR_read_past_the_end_of_the_input;

  slice->value = self->input + beginOffset;
  if (beginOffset > endOffset)
    // We don't expect this to happen.
    slice->length = 0;
  else
    slice->length = endOffset - beginOffset;

  return NDN_ERROR_success;
}

#ifdef  __cplusplus
}
#endif

#endif