decoder.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Zhiyi Zhang, Tianyuan Yu
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v3.0. See the file LICENSE in the top level
 * directory for more details.
 */

#ifndef NDN_ENCODING_DECODER_H
#define NDN_ENCODING_DECODER_H

#include "encoder.h"

#ifdef __cplusplus
extern "C" {
#endif

typedef struct ndn_decoder {
  const uint8_t* input_value;
  uint32_t input_size;
  uint32_t offset;
} ndn_decoder_t;

static inline void
decoder_init(ndn_decoder_t* decoder, const uint8_t* block_value, uint32_t block_size)
{
  decoder->input_value = block_value;
  decoder->input_size = block_size;
  decoder->offset = 0;
}

static inline int
decoder_get_var(ndn_decoder_t* decoder, uint32_t* var)
{
  uint8_t first_bit = decoder->input_value[decoder->offset];
  uint32_t rest_size = decoder->input_size - decoder->offset;
  if (first_bit < 253) {
    *var = first_bit;
    decoder->offset += 1;
  }
  else if (first_bit == 253 && rest_size >= 3) {
    *var = ((uint32_t)decoder->input_value[decoder->offset + 1] << 8)
      + decoder->input_value[decoder->offset + 2];
    decoder->offset += 3;
  }
  else if (first_bit == 254 && rest_size >= 5) {
    *var = ((uint32_t)decoder->input_value[decoder->offset + 1] << 24)
      + ((uint32_t)decoder->input_value[decoder->offset + 2] << 16)
      + ((uint32_t)decoder->input_value[decoder->offset + 3] << 8)
      + decoder->input_value[decoder->offset + 4];
    decoder->offset += 5;
  }
  else {
    return NDN_OVERSIZE_VAR;
  }
  return 0;
}

static inline int
decoder_get_type(ndn_decoder_t* decoder, uint32_t* type)
{
  return decoder_get_var(decoder, type);
}

static inline int
decoder_get_length(ndn_decoder_t* decoder, uint32_t* length)
{
  return decoder_get_var(decoder, length);
}

static inline int
decoder_get_raw_buffer_value(ndn_decoder_t* decoder, uint8_t* value, uint32_t size)
{
  int rest_length = decoder->input_size - decoder->offset;
  if (rest_length < (int) size) {
    return NDN_OVERSIZE;
  }
  memcpy(value, decoder->input_value + decoder->offset, size);
  decoder->offset += size;
  return 0;
}

static inline int
decoder_get_byte_value(ndn_decoder_t* decoder, uint8_t* value)
{
  if (decoder->offset + 1 > decoder->input_size)
    return NDN_OVERSIZE;
  *value = decoder->input_value[decoder->offset];
  decoder->offset += 1;
  return 0;
}

static inline int
decoder_get_uint16_value(ndn_decoder_t* decoder, uint16_t* value)
{
  if (decoder->offset + 2 > decoder->input_size)
    return NDN_OVERSIZE;

  *value = ((uint16_t)decoder->input_value[decoder->offset] << 8)
    + decoder->input_value[decoder->offset + 1];
  decoder->offset += 2;
  return 0;
}

static inline int
decoder_get_uint32_value(ndn_decoder_t* decoder, uint32_t* value)
{
  if (decoder->offset + 4 > decoder->input_size)
    return NDN_OVERSIZE;
  *value = 0;
  for (int i = 0; i < 4; i++) {
    *value += (uint32_t)decoder->input_value[decoder->offset + i] << (8 * (3 - i));
  }
  decoder->offset += 4;
  return 0;
}

static inline int
decoder_get_uint64_value(ndn_decoder_t* decoder, uint64_t* value)
{
  if (decoder->offset + 8 > decoder->input_size)
    return NDN_OVERSIZE;
  *value = 0;
  for (int i = 0; i < 8; i++) {
    *value += (uint64_t)decoder->input_value[decoder->offset + i] << (8 * (7 - i));
  }
  decoder->offset += 8;
  return 0;
}

static inline int
decoder_get_uint_value(ndn_decoder_t* decoder, uint32_t length, uint64_t* value)
{
  if (length == 1) {
    uint8_t temp_value = 0;
    decoder_get_byte_value(decoder, &temp_value);
    *value = (uint64_t)temp_value;
  }
  else if (length == 2) {
    uint16_t temp_value = 0;
    decoder_get_uint16_value(decoder, &temp_value);
    *value = (uint64_t)temp_value;
  }
  else if (length == 4) {
    uint32_t temp_value = 0;
    decoder_get_uint32_value(decoder, &temp_value);
    *value = (uint64_t)temp_value;
  }
  else if (length == 8) {
    decoder_get_uint64_value(decoder, value);
  }
  else {
    return NDN_WRONG_TLV_LENGTH;
  }
  return 0;
}

static inline int
decoder_move_forward(ndn_decoder_t* decoder, uint32_t step)
{
  if (decoder->offset + step > decoder->input_size)
    return NDN_OVERSIZE;
  decoder->offset += step;
  return 0;
}

static inline int
decoder_move_backward(ndn_decoder_t* decoder, uint32_t step)
{
  int new_position = decoder->offset - step;
  if (new_position < 0)
    return NDN_OVERSIZE;
  decoder->offset -= step;
  return 0;
}

static inline uint32_t
decoder_get_offset(const ndn_decoder_t* decoder)
{
  return decoder->offset;
}

#ifdef __cplusplus
}
#endif
#endif // NDN_ENCODING_DECODER_H