Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2014 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : #include <string>
       6             : #include <boost/shared_ptr.hpp>
       7             : #include <pkt/packet_buffer.h>
       8             : #include <pkt/control_interface.h>
       9             : 
      10           2 : PacketBufferManager::PacketBufferManager(PktModule *pkt_module) :
      11           2 :     alloc_(0), free_(0), pkt_module_(pkt_module) {
      12           2 : }
      13             : 
      14           4 : PacketBufferManager::~PacketBufferManager() {
      15           4 : }
      16             : 
      17        2545 : PacketBufferPtr PacketBufferManager::Allocate(uint32_t module, uint16_t len,
      18             :                                               uint32_t mdata) {
      19        2545 :     PacketBufferPtr ptr(new PacketBuffer(this, module, len, mdata));
      20        2545 :     alloc_++;
      21        2545 :     return ptr;
      22             : }
      23             : 
      24          78 : PacketBufferPtr PacketBufferManager::Allocate(uint32_t module, uint8_t *buff,
      25             :                                               uint16_t len,
      26             :                                               uint16_t data_offset,
      27             :                                               uint16_t data_len,
      28             :                                               uint32_t mdata) {
      29             :     PacketBufferPtr ptr(new PacketBuffer(this, module, buff, len, data_offset,
      30          78 :                                          data_len, mdata));
      31          78 :     alloc_++;
      32          78 :     return ptr;
      33             : }
      34             : 
      35        2617 : void PacketBufferManager::FreeIndication(PacketBuffer *pkt) {
      36        2617 :     free_++;
      37        2617 : }
      38             : 
      39        2545 : PacketBuffer::PacketBuffer(PacketBufferManager *mgr, uint32_t module,
      40        2545 :                            uint16_t len, uint32_t mdata) :
      41        2545 :     buffer_(new uint8_t[len]), buffer_len_(len), data_(buffer_.get()),
      42        2545 :     data_len_(len), module_(module), mdata_(mdata), mgr_(mgr) {
      43        2545 : }
      44             : 
      45          78 : PacketBuffer::PacketBuffer(PacketBufferManager *mgr, uint32_t module,
      46             :                            uint8_t *buff, uint16_t len, uint16_t data_offset,
      47          78 :                            uint16_t data_len, uint32_t mdata) :
      48          78 :     buffer_(buff), buffer_len_(len), data_(buffer_.get() + data_offset),
      49          78 :     data_len_(data_len), module_(module), mdata_(mdata), mgr_(mgr) {
      50          78 : }
      51             : 
      52        5238 : PacketBuffer::~PacketBuffer() {
      53        2620 :     mgr_->FreeIndication(this);
      54        2619 :     data_ = NULL;
      55        5237 : }
      56             : 
      57        9385 : uint8_t *PacketBuffer::data() const {
      58        9385 :     return data_;
      59             : }
      60             : 
      61       13718 : uint16_t PacketBuffer::data_len() const {
      62       13718 :     return data_len_;
      63             : }
      64             : 
      65             : // Move data pointer to offset specified
      66          75 : bool PacketBuffer::SetOffset(uint16_t offset) {
      67          75 :     if (offset > data_len_)
      68           0 :         return false;
      69          75 :     data_ += offset;
      70          75 :     data_len_ -= offset;
      71          75 :     return true;
      72             : }
      73             : 
      74             : // Set data_len in packet buffer
      75        2204 : void PacketBuffer::set_len(uint32_t len) {
      76        2204 :     uint32_t offset = data_ - buffer_.get();
      77             : 
      78             :     // Check if there is enough space first
      79        2204 :     assert((buffer_len_ - offset) >= len);
      80        2204 :     data_len_ = len;
      81        2204 : }