Line data    Source code

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