flowbuffer.hh

/*
 * flowbuffer.hh - Class used to buffer the packets of a flow in order to be able to
 * search, replace or remove data in them as in a contiguous flow.
 * This file also declares the iterators used to achieve this goal.
 *
 * Romain Gaillard.
 */
 
#ifndef MIDDLEBOX_FLOWBUFFER_HH
#define MIDDLEBOX_FLOWBUFFER_HH
 
#include <clicknet/tcp.h>
#include "memorypool.hh"
#include <click/packet.hh>
 
CLICK_DECLS
 
class CTXElement;
 
struct flowBufferEntry
{
        WritablePacket *packet;
        struct flowBufferEntry *prev;
        struct flowBufferEntry *next;
};
 
class FlowBufferContentIter;
class FlowBufferChunkIter;
class FlowBufferIter;
class CTXElement;
struct fcb;
 
class FlowBuffer
{
public:
    friend class FlowBufferIter;
 
    FlowBuffer();
 
    ~FlowBuffer();
 
    MemoryPool<struct flowBufferEntry>* getMemoryPool();
 
    void enqueue(Packet *packet);
 
    Packet* dequeue();
 
    PacketBatch* dequeueAll();
 
    PacketBatch* dequeueUpTo(Packet*);
 
    int getSize();
 
    FlowBufferIter begin();
 
    FlowBufferIter end();
 
    int searchInFlow(const char *pattern);
 
    int removeInFlow(const char* pattern, const int pattern_length, CTXElement* remove);
 
    int replaceInFlow(FlowBufferContentIter pos, const int pattern_length, const char *replacement, const int replacement_length, const bool repeat, CTXElement* owner);
 
    FlowBufferContentIter contentBegin(int posInFirstPacket = 0);
 
    FlowBufferContentIter contentEnd();
 
 
    void enqueueAll(PacketBatch* batch);
 
 
    FlowBufferContentIter enqueueAllIter(PacketBatch* batch);
    FlowBufferChunkIter enqueueAllChunkIter(PacketBatch* batch);
 
    FlowBufferContentIter search(FlowBufferContentIter start, const char* pattern, int *feedback);
    FlowBufferContentIter isearch(FlowBufferContentIter start, const char* pattern, int *feedback);
    FlowBufferContentIter searchSSE(FlowBufferContentIter start, const char* pattern, const int pattern_length, int *feedback);
 
    void remove(const FlowBufferContentIter start, uint32_t length, CTXElement* owner);
 
 
private:
    inline bool isInitialized() {
        return head != 0;
    }
 
 
 
    PacketBatch *head;
};
 
class FlowBufferIter
{
public:
    inline FlowBufferIter(FlowBuffer *_flowBuffer, Packet* _entry);
 
    inline bool operator==(const FlowBufferIter& other) const;
 
    inline bool operator!=(const FlowBufferIter& other) const;
 
    inline WritablePacket*& operator*();
 
    inline FlowBufferIter& operator++();
 
private:
    FlowBuffer *flowBuffer;
    WritablePacket* entry; // Current entry
};
 
class FlowBufferContentIter
{
public:
    friend class FlowBuffer;
 
    inline FlowBufferContentIter() {}; //Invalid placeholder
 
    inline FlowBufferContentIter(FlowBuffer *_flowBuffer, Packet* packet, int posInFirstPacket=0);
 
    inline bool operator==(const FlowBufferContentIter& other) const;
 
    inline bool operator!=(const FlowBufferContentIter& other) const;
 
    inline unsigned char& operator*();
 
    inline unsigned char* get_ptr();
 
    inline FlowBufferContentIter& operator++();
 
    inline FlowBufferContentIter& operator+=(int p);
 
    inline operator bool() const {
        return entry != 0;
    }
 
    inline PacketBatch* flush();
 
    inline Packet* current() {
        return entry;
    }
 
    inline bool lastChunk() {
        return entry->next() == 0;
    }
 
    inline void moveToNextChunk() {
        entry = entry->next();
        offsetInPacket = 0;
    }
 
    inline int leftInChunk() {
        if (!entry)
            return 0;
        return entry->length() - (entry->getContentOffset() + offsetInPacket);
    }
 
    void print_ascii() {
        FlowBufferContentIter n = *this;
        while (n) {
            char buf[n.leftInChunk() + 1];
            memcpy(buf, n.get_ptr(), n.leftInChunk());
            buf[n.leftInChunk()] = '\0';
            click_chatter("'%s'",buf);
            n.moveToNextChunk();
        }
 
    }
 
private:
    void repair();
 
    FlowBuffer *flowBuffer;
    Packet* entry;
    uint32_t offsetInPacket; // Current offset in the current packet content
};
 
class Chunk { public:
    const unsigned char* bytes;
    const unsigned length;
};
 
class FlowBufferChunkIter
{
public:
    friend class FlowBuffer;
 
    inline FlowBufferChunkIter(FlowBuffer *_flowBuffer, Packet* packet);
 
    inline bool operator==(const FlowBufferChunkIter& other) const;
 
    inline bool operator!=(const FlowBufferChunkIter& other) const;
 
    inline Chunk operator*();
 
    inline FlowBufferChunkIter& operator++();
 
    inline operator bool() const {
        return entry != 0;
    }
 
    inline PacketBatch* flush();
 
    inline Packet* current() {
        return entry;
    }
 
private:
 
    FlowBuffer *flowBuffer;
    Packet* entry;
};
 
 
// FlowBuffer Iterator
inline FlowBufferIter::FlowBufferIter(FlowBuffer *_flowBuffer,
    Packet* _entry) : flowBuffer(_flowBuffer)
{
    entry = static_cast<WritablePacket*>(_entry);
}
 
inline WritablePacket*& FlowBufferIter::operator*()
{
    assert(entry != NULL);
 
    return entry;
}
 
inline FlowBufferIter& FlowBufferIter::operator++()
{
    assert(entry != NULL);
 
    entry = static_cast<WritablePacket*>(entry->next());
 
    return *this;
}
 
 
inline bool FlowBufferIter::operator==(const FlowBufferIter& other) const
{
    if(this->flowBuffer != other.flowBuffer)
        return false;
 
    if(this->entry == NULL && other.entry == NULL)
        return true;
 
    if(this->entry != other.entry)
        return false;
 
    return true;
}
 
inline bool FlowBufferIter::operator!=(const FlowBufferIter& other) const
{
    return !(*this == other);
}
 
// FlowBufferContent Iterator
inline FlowBufferContentIter::FlowBufferContentIter(FlowBuffer *_flowBuffer,
    Packet* _entry, int posInFirstPacket) : flowBuffer(_flowBuffer), entry(_entry), offsetInPacket(posInFirstPacket)
{
    //The offset at first start must be valid
    while (entry && entry->getContentOffset() + offsetInPacket >=
        entry->length())
    {
        offsetInPacket = 0;
        entry = entry->next();
    }
}
 
inline bool FlowBufferContentIter::operator==(const FlowBufferContentIter& other) const
{
    if(this->flowBuffer != other.flowBuffer)
        return false;
 
    if(this->entry == NULL && other.entry == NULL)
        return true;
 
    if(this->entry != other.entry)
        return false;
 
    if(this->offsetInPacket != other.offsetInPacket)
        return false;
 
    return true;
}
 
inline bool FlowBufferContentIter::operator!=(const FlowBufferContentIter& other) const
{
    return !(*this == other);
}
 
inline unsigned char& FlowBufferContentIter::operator*()
{
    unsigned char* content = static_cast<WritablePacket*>(entry)->getPacketContent();
 
    return *(content + offsetInPacket);
}
 
 
inline unsigned char* FlowBufferContentIter::get_ptr()
{
    unsigned char* content = static_cast<WritablePacket*>(entry)->getPacketContent();
 
    return content + offsetInPacket;
}
 
 
inline FlowBufferContentIter& FlowBufferContentIter::operator++()
{
    assert(entry != NULL);
 
    offsetInPacket++;
 
    // Check if we are at the end of the packet and must therefore switch to
    // the next one. We may have multiple empty packet
    while (entry && entry->getContentOffset() + offsetInPacket >=
        entry->length())
    {
        offsetInPacket = 0;
        entry = entry->next();
    }
 
    return *this;
}
 
inline FlowBufferContentIter& FlowBufferContentIter::operator+=(int p)
{
    assert(entry != NULL);
 
    while (entry->getContentOffset() + offsetInPacket + p >= entry->length()) {
        p -= entry->length() - entry->getContentOffset() + offsetInPacket; //Remove from p what was left in packet
        offsetInPacket = 0;
        entry = entry->next();
        if (!entry)
            return *this;
    }
 
    offsetInPacket += p;
 
    return *this;
}
 
 
inline PacketBatch* FlowBufferContentIter::flush() {
    if (entry == 0) {
        return this->flowBuffer->dequeueAll();
    } else {
 
        return this->flowBuffer->dequeueUpTo(entry);
    }
}
 
 
//FlowBufferChunkIter
inline FlowBufferChunkIter::FlowBufferChunkIter(FlowBuffer *_flowBuffer,
    Packet* _entry) : flowBuffer(_flowBuffer), entry(_entry)
{
    //The offset at first start must be valid
    while (entry && entry->getContentOffset() == entry->length())
    {
        entry = entry->next();
    }
}
 
inline bool FlowBufferChunkIter::operator==(const FlowBufferChunkIter& other) const
{
    if(this->flowBuffer != other.flowBuffer)
        return false;
 
    if(this->entry == NULL && other.entry == NULL)
        return true;
 
    if(this->entry != other.entry)
        return false;
 
    return true;
}
 
inline bool FlowBufferChunkIter::operator!=(const FlowBufferChunkIter& other) const
{
    return !(*this == other);
}
 
inline Chunk FlowBufferChunkIter::operator*()
{
    assert(entry != NULL);
 
    WritablePacket* wp = static_cast<WritablePacket*>(entry);
    int off = wp->getContentOffset();
    unsigned char* content = wp->data() + off;
 
    return Chunk{content, wp->length() - off};
}
 
 
inline FlowBufferChunkIter& FlowBufferChunkIter::operator++()
{
    assert(entry != NULL);
 
    entry = entry->next();
    //Advance while the entry have no content
    while (entry && entry->getContentOffset() == entry->length())
    {
        entry = entry->next();
    }
 
    return *this;
}
 
 
inline PacketBatch* FlowBufferChunkIter::flush() {
    if (entry == 0) {
        return this->flowBuffer->dequeueAll();
    } else {
 
        return this->flowBuffer->dequeueUpTo(entry);
    }
}
 
 
CLICK_ENDDECLS
 
#endif