Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2014 Juniper Networks, Inc. All rights reserved.
       3             :  * Copyright Contributors to the OpenSDN project
       4             :  */
       5             : 
       6             : #ifndef vnsw_agent_pkt_packet_buffer_hpp
       7             : #define vnsw_agent_pkt_packet_buffer_hpp
       8             : 
       9             : #include <string>
      10             : #include <stdint.h>
      11             : #include <boost/shared_ptr.hpp>
      12             : #include <boost/shared_array.hpp>
      13             : #include <base/util.h>
      14             : 
      15             : class PacketBuffer;
      16             : class PacketBufferManager;
      17             : struct AgentHdr;
      18             : class PktHandler;
      19             : class PktModule;
      20             : 
      21             : typedef boost::shared_ptr<PacketBuffer> PacketBufferPtr;
      22             : class PacketBuffer {
      23             : public:
      24             :     static const uint32_t kDefaultBufferLen = 1024;
      25             :     virtual ~PacketBuffer();
      26             : 
      27             :     uint8_t *buffer() const { return buffer_.get(); }
      28        2623 :     uint16_t buffer_len() const { return buffer_len_; }
      29             : 
      30             :     uint8_t *data() const;
      31             :     uint16_t data_len() const;
      32             : 
      33        4408 :     uint32_t module() const { return module_; }
      34          75 :     void set_module(uint32_t module) { module_ = module; }
      35             : 
      36             :     void set_len(uint32_t len);
      37             :     bool SetOffset(uint16_t offset);
      38             : private:
      39             :     friend class PacketBufferManager;
      40             :     PacketBuffer(PacketBufferManager *mgr, uint32_t module, uint16_t len,
      41             :                  uint32_t mdata);
      42             : 
      43             :     // Create PacketBuffer from existing memory
      44             :     PacketBuffer(PacketBufferManager *mgr, uint32_t module, uint8_t *buff,
      45             :                  uint16_t len, uint16_t data_offset, uint16_t data_len,
      46             :                  uint32_t mdata);
      47             : 
      48             :     boost::shared_array<uint8_t> buffer_;
      49             :     uint16_t buffer_len_;
      50             : 
      51             :     uint8_t *data_;
      52             :     uint16_t data_len_;
      53             : 
      54             :     uint32_t module_;
      55             :     uint32_t mdata_;
      56             :     PacketBufferManager *mgr_;
      57             :     DISALLOW_COPY_AND_ASSIGN(PacketBuffer);
      58             : };
      59             : 
      60             : class PacketBufferManager {
      61             : public:
      62             :     PacketBufferManager(PktModule *pkt_module);
      63             :     virtual ~PacketBufferManager();
      64             : 
      65             :     PacketBufferPtr Allocate(uint32_t module, uint16_t len, uint32_t mdata);
      66             : 
      67             :     PacketBufferPtr Allocate(uint32_t module, uint8_t *buff, uint16_t len,
      68             :                              uint16_t data_offset, uint16_t data_len,
      69             :                              uint32_t mdata);
      70             : private:
      71             :     friend class PacketBuffer;
      72             :     void FreeIndication(PacketBuffer *);
      73             : 
      74             :     uint64_t alloc_;
      75             :     uint64_t free_;
      76             :     PktModule *pkt_module_;
      77             : 
      78             :     DISALLOW_COPY_AND_ASSIGN(PacketBufferManager);
      79             : };
      80             : 
      81             : #endif // vnsw_agent_pkt_packet_buffer_hpp