tlv-decoder.h

Go to the documentation of this file.

#ifndef NDNDPDK_NDNI_TLV_DECODER_H
#define NDNDPDK_NDNI_TLV_DECODER_H
 
#include "nni.h"
 
static __rte_always_inline bool
TlvDecoder_IsCriticalType(uint32_t type) {
  return type <= 0x1F || (type % 2) == 1;
}
 
typedef struct TlvDecoder {
  struct rte_mbuf* p; 
  struct rte_mbuf* m; 
  uint32_t length;    
  uint16_t offset;    
} TlvDecoder;
 
__attribute__((nonnull)) static inline TlvDecoder
TlvDecoder_Init(struct rte_mbuf* p) {
  return (TlvDecoder){
    .p = p,
    .m = p,
    .length = p->pkt_len,
  };
}
 
__attribute__((nonnull)) static inline void
TlvDecoder_Skip_(TlvDecoder* d, uint32_t count, struct rte_mbuf** last) {
  NDNDPDK_ASSERT(count <= d->length);
  for (uint32_t remain = count; remain > 0;) {
    *last = d->m;
    uint32_t here = d->m->data_len - d->offset;
    if (likely(remain < here)) {
      d->offset += remain;
      break;
    }
    remain -= here;
    d->m = d->m->next;
    d->offset = 0;
  }
  d->length -= count;
}
 
__attribute__((nonnull)) static inline void
TlvDecoder_Skip(TlvDecoder* d, uint32_t count) {
  struct rte_mbuf* unusedLast = NULL;
  TlvDecoder_Skip_(d, count, &unusedLast);
}
 
void
TlvDecoder_Truncate(TlvDecoder* d);
 
__attribute__((nonnull)) void
TlvDecoder_Copy_(TlvDecoder* d, uint8_t* output, uint16_t count);
 
__attribute__((nonnull)) static inline void
TlvDecoder_Copy(TlvDecoder* d, uint8_t* output, uint16_t count) {
  NDNDPDK_ASSERT(count <= d->length);
  if (unlikely(count == 0)) {
    return;
  }
 
  uint16_t here = d->m->data_len - d->offset;
  if (likely(count < here)) {
    rte_memcpy(output, rte_pktmbuf_mtod_offset(d->m, const uint8_t*, d->offset), count);
    d->offset += count;
    d->length -= count;
    return;
  }
 
  TlvDecoder_Copy_(d, output, count);
}
 
__attribute__((nonnull, returns_nonnull)) static inline const uint8_t*
TlvDecoder_Read_Contiguous_(TlvDecoder* d, uint16_t count) {
  uint16_t here = d->m->data_len - d->offset;
  const uint8_t* output = rte_pktmbuf_mtod_offset(d->m, const uint8_t*, d->offset);
 
  d->length -= count;
  if (likely(count < here)) {
    d->offset += count;
  } else {
    NDNDPDK_ASSERT(count == here);
    d->m = d->m->next;
    d->offset = 0;
  }
 
  return output;
}
 
__attribute__((nonnull, returns_nonnull)) static inline const uint8_t*
TlvDecoder_Read(TlvDecoder* d, uint8_t* scratch, uint16_t count) {
  NDNDPDK_ASSERT(count <= d->length);
  if (unlikely(count == 0)) {
    return scratch;
  }
  if (likely(count <= d->m->data_len - d->offset)) {
    return TlvDecoder_Read_Contiguous_(d, count);
  }
  TlvDecoder_Copy_(d, scratch, count);
  return scratch;
}
 
__attribute__((nonnull)) struct rte_mbuf*
TlvDecoder_Clone(TlvDecoder* d, uint32_t count, struct rte_mempool* indirectMp);
 
__attribute__((nonnull)) void
TlvDecoder_Fragment(TlvDecoder* d, uint32_t count, struct rte_mbuf* frames[], uint32_t* fragIndex,
                    uint32_t fragCount, uint16_t fragSize, uint16_t headroom);
 
__attribute__((nonnull)) const uint8_t*
TlvDecoder_Linearize_NonContiguous_(TlvDecoder* d, uint16_t count);
 
__attribute__((nonnull)) static inline const uint8_t*
TlvDecoder_Linearize(TlvDecoder* d, uint16_t count) {
  NDNDPDK_ASSERT(count <= d->length);
  if (unlikely(count == 0)) {
    return NULL;
  }
  if (likely(count < d->m->data_len - d->offset)) {
    return TlvDecoder_Read_Contiguous_(d, count);
  }
  return TlvDecoder_Linearize_NonContiguous_(d, count);
}
 
__attribute__((nonnull)) static inline bool
TlvDecoder_ReadVarNum(TlvDecoder* d, uint32_t* n) {
  if (unlikely(d->length < 1)) {
    return false;
  }
  uint8_t scratch[4];
  uint8_t first = *TlvDecoder_Read(d, scratch, 1);
  switch (first) {
    case 0xFD:
      if (likely(d->length >= 2)) {
        *n = rte_be_to_cpu_16(*(const unaligned_uint16_t*)TlvDecoder_Read(d, scratch, 2));
        return likely(*n >= 0xFD);
      }
      return false;
    case 0xFE:
      if (likely(d->length >= 4)) {
        *n = rte_be_to_cpu_32(*(const unaligned_uint32_t*)TlvDecoder_Read(d, scratch, 4));
        return likely(*n > UINT16_MAX);
      }
      return false;
    case 0xFF:
      return false;
    default:
      *n = first;
      return true;
  }
}
 
__attribute__((nonnull)) static __rte_always_inline uint32_t
TlvDecoder_ReadTL_MaybeTruncated(TlvDecoder* d, uint32_t* length) {
  *length = 0;
  uint32_t type;
  if (likely(TlvDecoder_ReadVarNum(d, &type)) && likely(TlvDecoder_ReadVarNum(d, length))) {
    return type;
  }
  return 0;
}
 
__attribute__((nonnull)) static inline uint32_t
TlvDecoder_ReadTL(TlvDecoder* d, uint32_t* length) {
  uint32_t type = TlvDecoder_ReadTL_MaybeTruncated(d, length);
  if (unlikely(*length > d->length)) {
    return 0;
  }
  return type;
}
 
#define TlvDecoder_EachTL(d, typeVar, lengthVar)                                                   \
  for (uint32_t lengthVar, typeVar = TlvDecoder_ReadTL((d), &lengthVar); typeVar != 0;             \
       typeVar = TlvDecoder_ReadTL((d), &lengthVar))
 
__attribute__((nonnull)) static inline TlvDecoder
TlvDecoder_MakeValueDecoder(TlvDecoder* d, uint32_t length) {
  TlvDecoder vd = *d;
  vd.length = length;
  TlvDecoder_Skip(d, length);
  return vd;
}
 
__attribute__((nonnull)) static __rte_always_inline bool
TlvDecoder_ReadNni(TlvDecoder* d, uint32_t length, uint64_t max, uint64_t* n) {
  uint8_t scratch[8];
  const uint8_t* value = TlvDecoder_Read(d, scratch, RTE_MIN(sizeof(scratch), length));
  return Nni_Decode(length, value, n) && *n <= max;
}
 
#define TlvDecoder_ReadNniToTypeMax_(sizeofValue)                                                  \
  (sizeofValue) == sizeof(uint8_t)    ? UINT8_MAX                                                  \
  : (sizeofValue) == sizeof(uint16_t) ? UINT16_MAX                                                 \
  : (sizeofValue) == sizeof(uint32_t) ? UINT32_MAX                                                 \
  : (sizeofValue) == sizeof(uint64_t) ? UINT64_MAX                                                 \
                                      : 0
#define TlvDecoder_ReadNniTo4_(d, length, max, ptr)                                                \
  __extension__({                                                                                  \
    static_assert(__builtin_constant_p(TlvDecoder_ReadNniToTypeMax_(sizeof(*(ptr)))), "");         \
    uint64_t value;                                                                                \
    bool ok = TlvDecoder_ReadNni(                                                                  \
      (d), (length), RTE_MIN((max), TlvDecoder_ReadNniToTypeMax_(sizeof(*(ptr)))), &value);        \
    *(ptr) = value;                                                                                \
    ok;                                                                                            \
  })
#define TlvDecoder_ReadNniTo3_(d, length, ptr)                                                     \
  TlvDecoder_ReadNniTo4_((d), (length), UINT64_MAX, (ptr))
#define TlvDecoder_ReadNniToArg5_(a1, a2, a3, a4, a5, ...) a5
#define TlvDecoder_ReadNniToChoose_(...)                                                           \
  TlvDecoder_ReadNniToArg5_(__VA_ARGS__, TlvDecoder_ReadNniTo4_, TlvDecoder_ReadNniTo3_, )
 
#define TlvDecoder_ReadNniTo(...) (TlvDecoder_ReadNniToChoose_(__VA_ARGS__)(__VA_ARGS__))
 
#endif // NDNDPDK_NDNI_TLV_DECODER_H