packet.h

Go to the documentation of this file.

#ifndef NDNDPDK_NDNI_PACKET_H
#define NDNDPDK_NDNI_PACKET_H

 
#include "data.h"
#include "nack.h"
#include "tlv-encoder.h"
 
extern const char* PktType_Strings_[];
 
__attribute__((returns_nonnull)) static inline const char*
PktType_ToString(PktType t) {
  return PktType_Strings_[t];
}

static __rte_always_inline PktType
PktType_ToFull(PktType t) {
  return (t & 0x03);
}

static __rte_always_inline PktType
PktType_ToSlim(PktType t) {
  return (t & 0x03) | 0x04;
}

typedef union PacketPriv {
  LpHeader lp;
  struct {
    LpL3 lpl3;
    union {
      PInterest interest;
      PData data;
    };
  };
  PNack nack;
} PacketPriv;
static_assert(offsetof(PacketPriv, lp.l3) == offsetof(PacketPriv, lpl3), "");
static_assert(offsetof(PacketPriv, nack.lpl3) == offsetof(PacketPriv, lpl3), "");
static_assert(offsetof(PacketPriv, nack.interest) == offsetof(PacketPriv, interest), "");

__attribute__((nonnull, returns_nonnull)) static __rte_always_inline Packet*
Packet_FromMbuf(struct rte_mbuf* pkt) {
  return (Packet*)pkt;
}

static __rte_always_inline struct rte_mbuf*
Packet_ToMbuf(const Packet* npkt) {
  return (struct rte_mbuf*)npkt;
}

__attribute__((nonnull)) static __rte_always_inline PktType
Packet_GetType(const Packet* npkt) {
  return Packet_ToMbuf(npkt)->inner_l3_type;
}

__attribute__((nonnull)) static __rte_always_inline void
Packet_SetType(Packet* npkt, PktType t) {
  Packet_ToMbuf(npkt)->inner_l3_type = t;
}
 
__attribute__((nonnull, returns_nonnull)) static __rte_always_inline PacketPriv*
Packet_GetPriv_(Packet* npkt) {
  return (PacketPriv*)rte_mbuf_to_priv(rte_mbuf_from_indirect(Packet_ToMbuf(npkt)));
}

__attribute__((nonnull, returns_nonnull)) static __rte_always_inline LpHeader*
Packet_GetLpHdr(Packet* npkt) {
  NDNDPDK_ASSERT(Packet_GetType(npkt) == PktFragment);
  return &Packet_GetPriv_(npkt)->lp;
}

__attribute__((nonnull, returns_nonnull)) static __rte_always_inline LpL3*
Packet_GetLpL3Hdr(Packet* npkt) {
  return &Packet_GetPriv_(npkt)->lpl3;
}

__attribute__((nonnull, returns_nonnull)) static __rte_always_inline PInterest*
Packet_GetInterestHdr(Packet* npkt) {
  NDNDPDK_ASSERT(Packet_GetType(npkt) == PktInterest);
  return &Packet_GetPriv_(npkt)->interest;
}

__attribute__((nonnull, returns_nonnull)) static __rte_always_inline PData*
Packet_GetDataHdr(Packet* npkt) {
  NDNDPDK_ASSERT(Packet_GetType(npkt) == PktData);
  return &Packet_GetPriv_(npkt)->data;
}

__attribute__((nonnull, returns_nonnull)) static __rte_always_inline PNack*
Packet_GetNackHdr(Packet* npkt) {
  NDNDPDK_ASSERT(Packet_GetType(npkt) == PktNack);
  return &Packet_GetPriv_(npkt)->nack;
}

__attribute__((nonnull, warn_unused_result)) bool
Packet_Parse(Packet* npkt, ParseFor parseFor);

__attribute__((nonnull, warn_unused_result)) bool
Packet_ParseL3(Packet* npkt, ParseFor parseFor);

__attribute__((nonnull)) static inline PName*
Packet_GetName(Packet* npkt) {
  switch (Packet_GetType(npkt)) {
    case PktInterest:
      return &Packet_GetInterestHdr(npkt)->name;
    case PktData:
      return &Packet_GetDataHdr(npkt)->name;
    case PktNack:
      return &Packet_GetNackHdr(npkt)->interest.name;
    default:
      return NULL;
  }
}

__attribute__((nonnull)) Packet*
Packet_Clone(Packet* npkt, PacketMempools* mp, PacketTxAlign align);

__attribute__((nonnull)) static inline void
Packet_Free(Packet* npkt) {
  if (Packet_GetType(npkt) == PktInterest) {
    PInterest* interest = Packet_GetInterestHdr(npkt);
    if (interest->diskData != NULL) {
      struct rte_mbuf* mbufs[2] = {Packet_ToMbuf(npkt), Packet_ToMbuf(interest->diskData)};
      rte_pktmbuf_free_bulk(mbufs, RTE_DIM(mbufs));
      return;
    }
  }
  rte_pktmbuf_free(Packet_ToMbuf(npkt));
}
 
__attribute__((nonnull, returns_nonnull)) static inline Packet*
Packet_EncodeFinish_(struct rte_mbuf* m, uint32_t type, PktType t) {
  TlvEncoder_PrependTL(m, type, m->pkt_len);
  Packet* output = Packet_FromMbuf(m);
  Packet_SetType(output, t);
  *Packet_GetLpL3Hdr(output) = (const LpL3){0};
  return output;
}
 
#endif // NDNDPDK_NDNI_PACKET_H