tcp.h

Go to the documentation of this file.

#ifndef TCP_H
#define TCP_H

#include <itpp/base/vec.h>

#if (defined(_MSC_VER) && defined(ITPP_SHARED_LIB) && !(defined(itpp_EXPORTS) || defined(itpp_debug_EXPORTS)))

#ifndef ITPP_PROTOCOL_EXCLUDED
#define ITPP_PROTOCOL_EXCLUDED
#pragma message( "PROTOCOL definitions are not available for MSVC shared builds" )
#endif

#else

#include <itpp/base/converters.h>
#include <itpp/protocol/packet.h>
#include <itpp/protocol/events.h>


namespace itpp
{



class Sequence_Number
{
public:
  Sequence_Number() : seq(0) { }
  Sequence_Number(const Sequence_Number &n) : seq(n.seq) { }
  Sequence_Number &operator=(const Sequence_Number &n) { seq = n.seq; return *this; }
  Sequence_Number &operator=(const int &rep) { seq = rep; return *this; }

  //relational operators
  bool operator==(const Sequence_Number &n) const { return seq == n.seq; }
  bool operator!=(const Sequence_Number &n) const { return seq != n.seq; }
  bool operator>(const Sequence_Number &n) const { return (seq - n.seq) > 0; }
  bool operator>=(const Sequence_Number &n) const { return (seq - n.seq) >= 0; }
  bool operator<(const Sequence_Number &n) const { return (seq - n.seq) < 0; }
  bool operator<=(const Sequence_Number &n) const { return (seq - n.seq) <= 0; }

  //addition and subtraction
  Sequence_Number operator+(const int n) const { return Sequence_Number(seq + n); }
  Sequence_Number &operator+=(const int n) { seq += n; return *this; }
  Sequence_Number operator-(const int n) const { return Sequence_Number(seq - n); }
  Sequence_Number &operator-=(const int n) { seq -= n; return *this; }
  int operator-(const Sequence_Number &n) const { return seq - n.seq; }

  int value() const { return seq; }

  friend Sequence_Number operator+(const int n1, const Sequence_Number &n2) { return Sequence_Number(n1 + n2.seq); }
  friend std::ostream &operator<<(std::ostream &os, const Sequence_Number &n) { os << n.seq; return os; }

protected:
  Sequence_Number(int n) : seq(n) {}
  int seq;
};

inline const Sequence_Number & min(const Sequence_Number &n1, const Sequence_Number &n2) { return (n1 < n2) ? n1 : n2; }
inline const Sequence_Number & max(const Sequence_Number &n1, const Sequence_Number &n2) { return (n1 > n2) ? n1 : n2; }



class TCP_Segment
{
public:
  TCP_Segment();
  TCP_Segment(const Sequence_Number &sn_begin, const Sequence_Number &sn_end);
  TCP_Segment(const TCP_Segment &segment);

  //modification
  TCP_Segment &operator=(const TCP_Segment &segment);
  void set_begin(const Sequence_Number &sn);
  void set_end(const Sequence_Number &sn);
  void combine(const TCP_Segment &segment);

  //query
  bool operator==(const TCP_Segment &segment) const;
  bool operator!=(const TCP_Segment &segment) const;
  bool can_be_combined(const TCP_Segment &segment) const;
  bool is_contained(const TCP_Segment &segment) const;
  unsigned length() const;
  Sequence_Number begin() const { return seq_begin; }
  Sequence_Number end() const { return seq_end; }

  friend std::ostream & operator<<(std::ostream &os, const TCP_Segment &segment);

protected:
  Sequence_Number  seq_begin; 
  Sequence_Number  seq_end;   
};


class TCP_Packet : public itpp::Packet
{
public:
  TCP_Packet();
  TCP_Packet(const TCP_Packet &packet);
  virtual ~TCP_Packet();
  virtual TCP_Packet &clone() const;

  //TCP window mechanism
  void set_segment(const TCP_Segment &seg) {  fSegment = seg; }
  TCP_Segment get_segment() const { return fSegment; }
  void set_wnd(unsigned val) { fWnd = val; }
  unsigned get_wnd() const { return fWnd; }
  void set_ACK(Sequence_Number val) { fACK = val; }
  Sequence_Number get_ACK() const { return fACK; }

  //session control
  void set_session_id(int val) { fSessionId = val; }
  int get_session_id() const {  return fSessionId; }

  //debugging support
  void set_destination_port(unsigned val) { fDestinationPort = val; }
  unsigned get_destination_port() const { return fDestinationPort; }
  void set_source_port(unsigned val) { fSourcePort = val; }
  unsigned get_source_port() const { return fSourcePort; }
  void set_info(unsigned ssThresh, unsigned recWnd, unsigned cWnd, double estRTT, Sequence_Number sndUna, Sequence_Number sndNxt, bool isRtx);
  virtual void print_header(std::ostream &) const;

protected:
  unsigned             fDestinationPort;
  unsigned             fSourcePort;

  TCP_Segment   fSegment;     
  Sequence_Number   fACK;           
  unsigned         fWnd;           
  int    fSessionId;     
  //Tracing

  struct TDebugInfo {
    unsigned   fSSThresh; 
    unsigned   fRecWnd; 
    unsigned   fCWnd; 
    double     fRTTEstimate; 
    Sequence_Number   fSndUna; 
    Sequence_Number   fSndNxt; 
    bool   fRtxFlag; 
  };

  TDebugInfo  *fInfo;

  friend std::ostream & operator<<(std::ostream &, TCP_Packet &);
};


class TCP_Sender
{
public:
  TCP_Sender(int label);

  virtual ~TCP_Sender();

  //connection control
  virtual void setup();
  virtual void release(std::string trace_filename = "");

  virtual void print_item(std::ostream &, const std::string &);

  virtual void set_debug(const bool enable_debug = true);
  virtual void set_debug(bool enable_debug, bool enable_signal_debug);
  virtual void set_trace(const bool enable_trace = true);
  virtual void save_trace(std::string filename);

  Signal<itpp::Packet*> tcp_send;
  Slot<TCP_Sender, itpp::Packet*> tcp_receive_ack;
  Slot<TCP_Sender, itpp::Packet*> tcp_socket_write;
  Slot<TCP_Sender, std::string> tcp_release;


  //Signal<itpp::Packet*> TcpSendSignal;
  //Slot<TCP_Sender, itpp::Packet*> TcpRecvAckSlot;
  //Slot<TCP_Sender, itpp::Packet*> SocketWriteSlot;
  //Slot<TCP_Sender, string> ReleaseSlot;

private:
  std::queue<itpp::Packet*> SocketWriteQueue;

  virtual void InitStatistics();       
  virtual void HandleACK(TCP_Packet &);      
  virtual void SendNewData(bool skipSWSA = false); 
  virtual void UnaRetransmit();       
  virtual void FinishFastRecovery();       
  virtual void ReduceSSThresh();       
  virtual void SendMsg(TCP_Packet & msg);    
  virtual void HandleRtxTimeout(Ttype);       
  virtual void IdleCheck();       
  virtual void HandleSWSATimeout(Ttype);      
  virtual unsigned GetNextSegmentSize(const Sequence_Number & begin);
  virtual unsigned SendWindow() const;   
  virtual double CalcRTOValue() const;   
  virtual void SetRtxTimer();
  virtual void UpdateRTTVariables(double sampleRTT); 
  virtual void TraceCWnd();
  virtual void TraceSentSeqNo(const Sequence_Number sn);
  virtual void TraceACKedSeqNo(const Sequence_Number sn);
  virtual void TraceRTTVariables(double sampleRTT);
  virtual void TraceSSThresh();
  virtual std::string GenerateFilename();

  void StopTransientPhase(); 
  enum eTCPVersion {kTahoe, kReno, kNewReno};

  virtual void set_label(int label);

  //socket variables
  unsigned fLabel; // end point identification also used at receiver

  //message handling
  virtual void HandleUserMessageIndication(itpp::Packet *user_data);
  virtual void ReceiveMessageFromNet(itpp::Packet *msg);

  //parameters parsed from input file
  eTCPVersion  fTCPVersion;     // one of Reno, Tahoe, NewReno
  unsigned  fMSS;             // maximum segment size
  unsigned  fTCPIPHeaderLength; 
  double       fInitialRTT;        
  unsigned  fInitialCWnd;       
  unsigned  fInitialSSThresh;   
  unsigned   fMaxCWnd;           
  unsigned  fDupACKThreshold;   
  double  fTimerGranularity;  
  double  fMaxRTO;     // max value of retransmission TO
  unsigned  fMaxBackoff;        
  bool  fImmediateBackoffReset; 
  bool  fKarn;              
  bool  fGoBackN;           
  bool  fFlightSizeRecovery;// use flight size on fast rec. exit
  bool  fRenoConservation;  
  bool  fCarefulSSThreshReduction; 
  bool  fIgnoreDupACKOnTORecovery; 
  bool  fCarefulMulFastRtxAvoidance; 
  bool         fNagle;             
  double       fSWSATimerValue;    
  bool  fRestartAfterIdle;  
  bool  fTraceCWnd;     // print CWnd trace to cout
  bool  fTraceSentSeqNo;    
  bool  fTraceACKedSeqNo;   
  bool   fDebug;      // print additional information to cout
  bool   fTrace;      // store trace info in vectors

  //session identification
  int fSessionId;  
  //TCP flow control (RFC 793)
  Sequence_Number fSndUna;       // lowest unacknowledged sn
  Sequence_Number fSndNxt;       // next byte to be sent
  Sequence_Number fSndMax;           
  unsigned        fRecWnd;       // receiver advertised window
  unsigned        fMaxRecWnd;        
  Sequence_Number fUserNxt;       // next byte to be received from user

  //TCP congestion avoidance (RFC 2581, RFC 2001, RFC 2582)
  unsigned  fCWnd;       // congestion window
  unsigned  fSSThresh;      
  unsigned fDupACKCnt;     
  Sequence_Number  fRecoveryDupACK;  
  Sequence_Number  fRecoveryTO;  
  //TCP timers
  TTimer<TCP_Sender>   fRtxTimer;     
  Sequence_Number      fTimUna;       
  TTimer<TCP_Sender>   fSWSATimer;    
  int           fBackoff;               
  bool          fPendingBackoffReset;  
  Ttype   fLastSendTime; 
  //round trip time measurement (RTTM)
  double          fSRTT;               
  double          fRTTVar;             
  double          fRTTEstimate;        
  Sequence_Number fRTTMByte;           
  bool            fRTTMPending;        
  double          fRTTMStartTime;      
  //statistic counters
  unsigned long       fNumberOfTimeouts;
  unsigned long       fNumberOfFastRetransmits;
  unsigned long       fNumberOfRTTMeasurements;
  unsigned long       fNumberOfReceivedACKs;
  unsigned long       fNumberOfIdleTimeouts;

  vec CWnd_val;
  vec CWnd_time;
  int CWnd_index;

  vec SSThresh_val;
  vec SSThresh_time;
  int SSThresh_index;

  ivec sent_seq_num_val;
  vec sent_seq_num_time;
  int sent_seq_num_index;

  ivec sender_recv_ack_seq_num_val;
  vec sender_recv_ack_seq_num_time;
  int sender_recv_ack_seq_num_index;

  vec RTTEstimate_val;
  vec RTTEstimate_time;
  int RTTEstimate_index;

  vec RTTsample_val;
  vec RTTsample_time;
  int RTTsample_index;
};


class TCP_Receiver_Buffer
{
public:
  TCP_Receiver_Buffer();
  TCP_Receiver_Buffer(const TCP_Receiver_Buffer &);
  ~TCP_Receiver_Buffer();

  void reset(); 
  void write(TCP_Segment newBlock);  
  void read(unsigned noOfBytes); 
  unsigned first_block_size() const;        
  Sequence_Number first_byte() const;      
  Sequence_Number last_byte() const;       
  Sequence_Number next_expected() const;   

  unsigned window() const;

  std::ostream &info(std::ostream &os, int detail = 0) const; 
protected:
  Sequence_Number fFirstByte;         

  std::list <TCP_Segment> fBufList;
};




class TCP_Receiver
{
public:

  TCP_Receiver(int label);
  virtual ~TCP_Receiver();

  //name  connection control
  virtual void setup();
  virtual void release(std::string trace_filename = "");

  //message handling
  itpp::Packet & get_user_message(); 
  bool is_user_message_available(); 

  virtual void set_debug(const bool enable_debug = true);
  virtual void set_debug(bool enable_debug, bool enable_signal_debug);
  virtual void set_trace(const bool enable_trace = true);
  virtual void save_trace(std::string filename);

  Signal<itpp::Packet*> tcp_send_ack;
  Slot<TCP_Receiver, itpp::Packet*> tcp_receive;
  Signal<int> tcp_new_data; 

  Slot<TCP_Receiver, std::string> tcp_release;

private:
  void IndicateUserMessage(); 
  virtual void ReceiveMessageFromNet(itpp::Packet* msg); 
  virtual void ReceiveDataPacket(TCP_Packet & packet); 
  virtual void SendACK(bool);        
  virtual void ScheduleACKMessage(); 
  virtual void SendACKMessage(Ttype); 
  virtual void DelayedACKHandler(Ttype);    
  virtual void PeriodicACKHandler(Ttype);   
  virtual void HandleEndOfProcessing(Ttype); 
  virtual void TraceReceivedSeqNo(const Sequence_Number &sn);
  virtual std::string GenerateFilename();

  //basic variables
  TCP_Receiver_Buffer  fReceiverBuffer;
  unsigned              fLabel;

  //parameters read by the parser
  unsigned     fTCPIPHeaderLength;  
  unsigned     fMSS;            
  unsigned  fBufferSize;       
  bool         fDelayedACK;         
  Ttype  fACKDelayTime;       
  bool  fSendPeriodicACKs;   
  bool  fStrictPeriodicACKs; 
  Ttype  fPeriodicACKInterval;// interval after which an ACK is repeated
  Ttype  fACKSchedulingDelay; 
  bool  fACKOnBufferWrite;   
  bool  fACKOnBufferRead;    
  unsigned  fMaxUserBlockSize;   
  unsigned  fMinUserBlockSize;   
  double  fUserBlockProcDelay; 
  bool  fTrace;              
  bool         fDebug;              
  //specific TCP variables
  Sequence_Number fAdvRcvNxt;       
  unsigned        fAdvRcvWnd;       
  //session management
  int fSessionId;  
  //ACK timers
  TTimer<TCP_Receiver> fDelayedACKTimer; 
  TTimer<TCP_Receiver> fPeriodicACKTimer; 
  TTimer<TCP_Receiver> fACKSchedulingTimer;
  TCP_Packet *  fWaitingACKMsg;

  //user data delivery
  Packet * fUserMessage;
  TTimer<TCP_Receiver> fUserBlockProcTimer;


  //statistic counters
  ivec received_seq_num_val;
  vec received_seq_num_time;
  int received_seq_num_index;

};



// ------------------------------- Inline definitions ---------------------------------------------



inline Sequence_Number TCP_Receiver_Buffer::first_byte() const
{
  return fFirstByte;
}


inline Sequence_Number TCP_Receiver_Buffer::last_byte() const
{
  if (fBufList.empty()) {
    return fFirstByte;
  }
  else {
    return fBufList.back().end();
  }
}


inline Sequence_Number TCP_Receiver_Buffer::next_expected() const
{
  return fFirstByte + first_block_size();
}


inline void TCP_Segment::set_begin(const Sequence_Number &sn)
{
  seq_begin = sn;

  it_assert(seq_begin <= seq_end, "TCP_Segment::begin, end byte " + to_str(seq_end.value()) + " < begin byte " + to_str(seq_begin.value()));
}


inline void TCP_Segment::set_end(const Sequence_Number &sn)
{
  seq_end = sn;

  it_assert(seq_begin <= seq_end, "TCP_Segment::set_begin, end byte " + to_str(seq_end.value()) + " < begin byte " + to_str(seq_begin.value()));
}


inline bool TCP_Segment::operator==(const TCP_Segment &segment) const
{
  return (this->seq_begin == segment.seq_begin) && (this->seq_end == segment.seq_end);
}


inline bool TCP_Segment::operator!=(const TCP_Segment &segment) const
{
  return (this->seq_begin != segment.seq_begin) || (this->seq_end != segment.seq_end);
}


inline bool TCP_Segment::can_be_combined(const TCP_Segment &segment) const
{
  return (this->seq_begin <= segment.seq_end) && (segment.seq_begin <= this->seq_end);
}


inline bool TCP_Segment::is_contained(const TCP_Segment &segment) const
{
  return (segment.seq_begin <= this->seq_begin) && (this->seq_end <= segment.seq_end);
}


inline unsigned TCP_Segment::length() const
{
  return seq_end - seq_begin;
}



} // namespace itpp

#endif

#endif // #ifndef TCP_H