bytestreammaintainer.hh

/*
 * bytestreammaintainer.hh - Class used to manage a flow. Stores the modifications in the flow
 * (bytes removed or inserted) as well as information such as the MSS, ports, ips, last
 * ack received, last ack sent, ...
 *
 * This file also contains the declaration and definition of RBTManager
 * which is the RBTManager used by ByteStreamMaintainer to store the modifications in the flow.
 *
 * Romain Gaillard.
 */
 
 
#ifndef MIDDLEBOX_BYTESTREAMMAINTAINER_HH
#define MIDDLEBOX_BYTESTREAMMAINTAINER_HH
 
#include <click/config.h>
#include <click/glue.hh>
#include <clicknet/tcp.h>
#include "rbt.hh"
 
CLICK_DECLS
 
class ByteStreamMaintainer
{
    // ModificationList is the only one allowed to add nodes in the trees
    friend class ModificationList;
 
    public:
        ByteStreamMaintainer();
        ~ByteStreamMaintainer();
 
        inline void reinit() {
                this->~ByteStreamMaintainer();
                new (this) ByteStreamMaintainer();
        }
 
        uint32_t mapAck(uint32_t position);
 
        uint32_t mapSeq(uint32_t position);
 
        int lastOffsetInAckTree();
 
        void printTrees();
 
        void initialize(RBTManager *rbtManager, uint32_t flowStart);
 
        void prune(uint32_t position);
 
        inline void setLastAckSent(uint32_t ackNumber);
 
        inline uint32_t getLastAckSent();
 
        inline bool isLastAckSentSet();
 
        inline void setLastSeqSent(uint32_t seqNumber);
 
        inline void setLastPayloadLength(uint16_t payload);
 
        inline uint32_t getLastSeqSent();
 
        inline uint16_t getLastPayloadLength();
 
        inline bool isLastSeqSentSet();
 
        inline uint8_t getDupAcks();
 
        inline void setDupAcks(uint8_t dupAcks);
 
        inline void setWindowSize(uint16_t windowSize);
 
        inline uint16_t getWindowSize();
 
        inline void setWindowScale(uint16_t windowScale);
 
        inline uint16_t getWindowScale();
 
        inline void setUseWindowScale(bool useWindowScale);
 
        inline bool getUseWindowScale();
 
        inline uint16_t getMSS();
 
        inline void setMSS(uint16_t mss);
 
        inline uint64_t getCongestionWindowSize();
 
        inline void setCongestionWindowSize(uint64_t congestionWindow);
 
        inline void setSsthresh(uint64_t ssthresh);
 
        inline uint64_t getSsthresh();
 
        inline void setIpSrc(uint32_t ipSrc);
 
        inline uint32_t getIpSrc();
 
        inline void setIpDst(uint32_t ipDst);
 
        inline uint32_t getIpDst();
 
        inline void setPortSrc(uint16_t portSrc);
 
        inline uint16_t getPortSrc();
 
        inline void setPortDst(uint16_t portDst);
 
        inline uint16_t getPortDst();
 
    private:
        void insertInAckTree(uint32_t position, int offset);
 
        void insertInSeqTree(uint32_t position, int offset);
 
        void insertInTree(rb_red_blk_tree* tree, uint32_t position, int offset);
 
        rb_red_blk_tree* treeAck; // Tree used to map the ack numbers
        rb_red_blk_tree* treeSeq; // Tree used to map the sequence numbers
        RBTManager* rbtManager; // Manager of the trees (used to allocate memory among others)
        uint32_t pruneCounter; // Used to avoid pruning for each ack received
        bool initialized;
        bool lastAckSentSet; // Indicates whether the value lastAckSent is meaningful
        bool lastSeqSentSet; // Indicates whether the value lastSeqSent is meaningful
        bool lastAckReceivedSet; // Indicates whether the value lastAckReceived is meaningful
 
        uint32_t lastAckSent;     // /!\ mapped value (as sent)
        uint32_t lastSeqSent;     // /!\ mapped value (as sent)
        uint32_t lastAckReceived; // /!\ Unamapped value (as received)
        uint16_t windowSize; // Window size of the source
        uint16_t windowScale; // Window scale factor of the source
        uint8_t dupAcks;  // Number of consecutive duplicate acks currently observed
        bool useWindowScale; // Indicates if the Window Scale option is used
        uint64_t congestionWindow; // Congestion window for this side of the connection
        uint64_t ssthresh; // Slow start threshold
        uint16_t mss; // MSS of the source
        uint16_t lastPayloadLength;
        uint32_t ipSrc;
        uint32_t ipDst;
        uint16_t portSrc;
        uint16_t portDst;
};
 
void ByteStreamMaintainer::setLastAckSent(uint32_t ackNumber)
{
    // As the sequence and ack numbers may wrap, we cannot just set a default value (for instance
    // 0) for them and check that the given one is greater as we could have false negatives
    if(!lastAckSentSet || SEQ_GT(ackNumber, lastAckSent))
        lastAckSent = ackNumber;
 
    lastAckSentSet = true;
}
 
uint32_t ByteStreamMaintainer::getLastAckSent()
{
    if(!lastAckSentSet)
        click_chatter("Error: Last ack sent not defined");
 
    return lastAckSent;
}
 
void ByteStreamMaintainer::setLastSeqSent(uint32_t seqNumber)
{
    // As the sequence and ack numbers may wrap, we cannot just set a default value (for instance
    // 0) for them and check that the given one is greater as we could have false negatives
    if(!lastSeqSentSet || SEQ_GT(seqNumber, lastSeqSent))
        lastSeqSent = seqNumber;
 
    lastSeqSentSet = true;
}
 
void ByteStreamMaintainer::setLastPayloadLength(uint16_t payload)
{
    lastPayloadLength = payload;
}
 
uint32_t ByteStreamMaintainer::getLastSeqSent()
{
    if(!lastSeqSentSet)
        click_chatter("Error: Last sequence sent not defined");
 
    return lastSeqSent;
}
 
uint16_t ByteStreamMaintainer::getLastPayloadLength()
{
    return lastPayloadLength;
}
 
bool ByteStreamMaintainer::isLastAckSentSet()
{
    return lastAckSentSet;
}
 
bool ByteStreamMaintainer::isLastSeqSentSet()
{
    return lastSeqSentSet;
}
 
void ByteStreamMaintainer::setWindowSize(uint16_t windowSize)
{
    this->windowSize = windowSize;
}
 
uint16_t ByteStreamMaintainer::getWindowSize()
{
    return windowSize;
}
 
void ByteStreamMaintainer::setIpSrc(uint32_t ipSrc)
{
    this->ipSrc = ipSrc;
}
 
uint32_t ByteStreamMaintainer::getIpSrc()
{
    return ipSrc;
}
 
void ByteStreamMaintainer::setIpDst(uint32_t ipDst)
{
    this->ipDst = ipDst;
}
 
uint32_t ByteStreamMaintainer::getIpDst()
{
    return ipDst;
}
 
void ByteStreamMaintainer::setPortSrc(uint16_t portSrc)
{
    this->portSrc = portSrc;
}
 
uint16_t ByteStreamMaintainer::getPortSrc()
{
    return portSrc;
}
 
void ByteStreamMaintainer::setPortDst(uint16_t portDst)
{
    this->portDst = portDst;
}
 
uint16_t ByteStreamMaintainer::getPortDst()
{
    return portDst;
}
 
void ByteStreamMaintainer::setWindowScale(uint16_t windowScale)
{
    this->windowScale = windowScale;
}
 
uint16_t ByteStreamMaintainer::getWindowScale()
{
    return windowScale;
}
 
void ByteStreamMaintainer::setUseWindowScale(bool useWindowScale)
{
    this->useWindowScale = useWindowScale;
}
 
bool ByteStreamMaintainer::getUseWindowScale()
{
    return useWindowScale;
}
 
uint16_t ByteStreamMaintainer::getMSS()
{
    return mss;
}
 
void ByteStreamMaintainer::setMSS(uint16_t mss)
{
    this->mss = mss;
}
 
uint8_t ByteStreamMaintainer::getDupAcks()
{
    return dupAcks;
}
 
void ByteStreamMaintainer::setDupAcks(uint8_t dupAcks)
{
    this->dupAcks = dupAcks;
}
 
uint64_t ByteStreamMaintainer::getCongestionWindowSize()
{
    return congestionWindow;
}
 
void ByteStreamMaintainer::setCongestionWindowSize(uint64_t congestionWindow)
{
    this->congestionWindow = congestionWindow;
}
 
uint64_t ByteStreamMaintainer::getSsthresh()
{
    return ssthresh;
}
 
void ByteStreamMaintainer::setSsthresh(uint64_t ssthresh)
{
    this->ssthresh = ssthresh;
}
 
 
CLICK_ENDDECLS
#endif