/*
 * Copyright (c) 1999  International Computer Science Institute
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by ACIRI, the AT&T
 *      Center for Internet Research at ICSI (the International Computer
 *      Science Institute).
 * 4. Neither the name of ACIRI nor of ICSI may be used
 *    to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY ICSI AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL ICSI OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <math.h>


#include "ip.h"
#include "tcp-rfc793edu.h"
#include "flags.h"

// Original code contributed by Fernando Cela Diaz,
// <fcela@ce.chalmers.se>.
// For more information, see the following:
// URL "http://www.ce.chalmers.se/~fcela/tcp-tour.html"

static class  RFC793eduTcpClass : public TclClass {
public:
	RFC793eduTcpClass() : TclClass("Agent/TCP/RFC793edu") {}
	TclObject* create(int, const char*const*) {
		return (new RFC793eduTcpAgent());
	}
} class_rfc793edu;


RFC793eduTcpAgent::RFC793eduTcpAgent() : TcpAgent() 
{
}

void
RFC793eduTcpAgent::delay_bind_init_all()
{
	delay_bind_init_one("add793expbackoff_");
	delay_bind_init_one("add793jacobsonrtt_");
	delay_bind_init_one("add793fastrtx_");
	delay_bind_init_one("add793slowstart_");
	delay_bind_init_one("add793additiveinc_");
	delay_bind_init_one("add793karnrtt_");
	delay_bind_init_one("add793exponinc_"); 
	delay_bind_init_one("rto_");
	TcpAgent::delay_bind_init_all();
        reset();
}

int
RFC793eduTcpAgent::delay_bind_dispatch(const char *varName, 
				       const char *localName,TclObject *tracer)
{
        if (delay_bind_bool(varName, localName, "add793expbackoff_", 
			    &add793expbackoff_, tracer)) 
		return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793jacobsonrtt_", 
			    &add793jacobsonrtt_, tracer)) 
		return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793fastrtx_", 
			    &add793fastrtx_, tracer)) 
		return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793slowstart_", 
			    &add793slowstart_, tracer)) 
		return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793slowstart_", 
			    &add793slowstart_, tracer)) 
		return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793additiveinc_", 
			    &add793additiveinc_, tracer)) 
		return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793karnrtt_", 
			    &add793karnrtt_, tracer)) 
		return TCL_OK;
        if (delay_bind_bool(varName, localName, "add793exponinc_", 
			    &add793exponinc_, tracer)) 
		return TCL_OK;
        if (delay_bind(varName, localName, "rto_", 
		       &rto_, tracer)) 
		return TCL_OK;
        return TcpAgent::delay_bind_dispatch(varName, localName, tracer);
}

void RFC793eduTcpAgent::reset()
{
  //Reset here protected vars. 

  rto_ = rtxcur_init_ / tcp_tick_;
  TcpAgent::reset();
}


void RFC793eduTcpAgent::rtt_update(double tao)
{
  double now = Scheduler::instance().clock();
  if (ts_option_)
    t_rtt_ = int(tao /tcp_tick_ + 0.5);
  else {
    double sendtime = now - tao;
    sendtime += boot_time_;
    double tickoff = fmod(sendtime, tcp_tick_);
    t_rtt_ = int((tao + tickoff) / tcp_tick_);
  }
  if (t_rtt_ < 1)
    t_rtt_ = 1;
  
      // Jacobson/Karels RTT estimation as implemented in tcp.cc
      //
      // Diference    = SampleRTT - EstimatedRTT
      // EstimatedRTT = EstimatedRTT + (delta * Difference)
      // Deviation    = Deviation + delta * (|Difference| - Deviation)
      // TimeOut      = EstimatedRTT + 4 * Deviation

      // srtt has 3 bits to the right of the binary point
      // rttvar has 2
      if (t_srtt_ != 0) {
	register short delta;
	delta = t_rtt_ - (t_srtt_ >> T_SRTT_BITS);	// d = (m - a0)
	if ((t_srtt_ += delta) <= 0)	// a1 = 7/8 a0 + 1/8 m
	  t_srtt_ = 1;
	if (delta < 0)
	  delta = -delta;
	delta -= (t_rttvar_ >> T_RTTVAR_BITS);
	if ((t_rttvar_ += delta) <= 0)	// var1 = 3/4 var0 + 1/4 |d|
	  t_rttvar_ = 1;
      } else {
	t_srtt_ = t_rtt_ << T_SRTT_BITS;		// srtt = rtt
	t_rttvar_ = t_rtt_ << (T_RTTVAR_BITS-1);	// rttvar = rtt / 2
      }

   if (add793jacobsonrtt_) 
    {
      //
      // Current retransmit value is 
      //    (unscaled) smoothed round trip estimate
      //    plus 2^rttvar_exp_ times (unscaled) rttvar. 
      //
      rto_ = (((t_rttvar_ << (rttvar_exp_ + (T_SRTT_BITS - T_RTTVAR_BITS)))                   + t_srtt_)  >> T_SRTT_BITS );
    }
   else { 
     // RFC 793
     rto_ = (t_srtt_ >> ( T_SRTT_BITS - 1) );
   }
      t_rtxcur_ = rto_  * tcp_tick_;
  return;
}


void RFC793eduTcpAgent::rtt_backoff()
{
  if (add793expbackoff_) {
    // Standard Tahoe Code

	if (t_backoff_ < 64)
		t_backoff_ <<= 1;

	if (t_backoff_ > 8) {
		/*
		 * If backed off this far, clobber the srtt
		 * value, storing it in the mean deviation
		 * instead.
		 */
		t_rttvar_ += (t_srtt_ >> T_SRTT_BITS);
		t_srtt_ = 0;
	}
  }
  // safe paranoia
  else 
    t_backoff_ = 1;
}


void RFC793eduTcpAgent::recv(Packet *pkt, Handler*)
{
	hdr_tcp *tcph = hdr_tcp::access(pkt);
#ifdef notdef
	if (pkt->type_ != PT_ACK) {
		Tcl::instance().evalf("%s error \"received non-ack\"",
				      name());
		Packet::free(pkt);
		return;
	}
#endif
	++nackpack_;
	ts_peer_ = tcph->ts();
	int ecnecho = hdr_flags::access(pkt)->ecnecho();
	if (ecnecho && ecn_)
		ecn(tcph->seqno());
	recv_helper(pkt);
	/* grow cwnd and check if the connection is done */ 
	if (tcph->seqno() > last_ack_) {
		recv_newack_helper(pkt);
		if (last_ack_ == 0 && delay_growth_) { 
			cwnd_ = initial_window();
		}
	} else if (tcph->seqno() == last_ack_) {
                if (hdr_flags::access(pkt)->eln_ && eln_) {
                        tcp_eln(pkt);
                        return;
                }
		// fast retransmission
		if ( (++dupacks_ == numdupacks_) && add793fastrtx_ ) {
			dupack_action();
		}
	}
	Packet::free(pkt);
	/*
	 * Try to send more data.
	 */
	send_much(0, 0, maxburst_);
}



void RFC793eduTcpAgent::opencwnd()
{
        if ( !(add793slowstart_ || add793exponinc_ || add793additiveinc_)) {
	  cwnd_ = wnd_;
        } else if (((cwnd_ < ssthresh_) && (!add793additiveinc_)) 
		   || add793exponinc_)
	  {
		/* slow-start (exponential) */
	        if (add793exponinc_ && (cwnd_ < ssthresh_))
		  cwnd_ = ssthresh_;
		else cwnd_ += 1;
	} else {
		/* linear */
		double f;

		if (add793additiveinc_ && (cwnd_ < ssthresh_))
		  cwnd_ = ssthresh_;
		else {
		  switch (wnd_option_) {
		  case 0:
		    if (++count_ >= cwnd_) {
		      count_ = 0;
		      ++cwnd_;
		    }
		    break;
		    
		  case 1:
			/* This is the standard algorithm. */
		    cwnd_ += 1 / cwnd_;
		    break;
		    
		  case 2:
		    /* These are window increase algorithms
		     * for experimental purposes only. */
		    f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
		    f *= f;
		    f *= wnd_const_;
		    f += fcnt_;
		    if (f > cwnd_) {
		      fcnt_ = 0;
		      ++cwnd_;
		    } else
		      fcnt_ = f;
		    break;
			
		  case 3:
		    f = awnd_;
		    f *= f;
		    f *= wnd_const_;
		    f += fcnt_;
		    if (f > cwnd_) {
		      fcnt_ = 0;
		      ++cwnd_;
		    } else
		      fcnt_ = f;
		    break;
		    
		  case 4:
		    f = awnd_;
		    f *= wnd_const_;
		    f += fcnt_;
		    if (f > cwnd_) {
		      fcnt_ = 0;
		      ++cwnd_;
		    } else
                                fcnt_ = f;
		    break;
		  case 5:
		    f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
		    f *= wnd_const_;
		    f += fcnt_;
		    if (f > cwnd_) {
		      fcnt_ = 0;
		      ++cwnd_;
		    } else
		      fcnt_ = f;
		    break;
		    
		  default:
#ifdef notdef
		    /*XXX*/
		    error("illegal window option %d", wnd_option_);
#endif
		    abort();
		  }
		}
	}
	// if maxcwnd_ is set (nonzero), make it the cwnd limit
	if (maxcwnd_ && (int(cwnd_) > maxcwnd_))
	  cwnd_ = maxcwnd_;
	
	return;
}


void  RFC793eduTcpAgent::output(int seqno, int reason)
{
	int force_set_rtx_timer = 0;
	Packet* p = allocpkt();
	hdr_tcp *tcph = hdr_tcp::access(p);
	hdr_flags* hf = hdr_flags::access(p);
	tcph->seqno() = seqno;
	tcph->ts() = Scheduler::instance().clock();
	tcph->ts_echo() = ts_peer_;
	tcph->reason() = reason;
	if (ecn_) {
		hf->ect() = 1;	// ECN-capable transport
	}
	if (cong_action_) {
		hf->cong_action() = TRUE;  // Congestion action.
		cong_action_ = FALSE;
        }
	/* Check if this is the initial SYN packet. */
	if (seqno == 0) {
		if (syn_) {
			hdr_cmn::access(p)->size() = tcpip_base_hdr_size_;
		}
		if (ecn_) {
			hf->ecnecho() = 1;
//			hf->cong_action() = 1;
			hf->ect() = 0;
		}
	}
        int bytes = hdr_cmn::access(p)->size();

	/* if no outstanding data, be sure to set rtx timer again */
	if (highest_ack_ == maxseq_)
		force_set_rtx_timer = 1;
	/* call helper function to fill in additional fields */
	output_helper(p);

        ++ndatapack_;
        ndatabytes_ += bytes;
	send(p, 0);
	if (seqno == curseq_ && seqno > maxseq_)
		idle();  // Tell application I have sent everything so far
	if (seqno > maxseq_) {
		maxseq_ = seqno;
		if (!rtt_active_) {
			rtt_active_ = 1;			
			if (seqno > rtt_seq_) {
				rtt_seq_ = seqno;			
				rtt_ts_ = Scheduler::instance().clock();
			}
					
		}
	} else {
	  if (!add793karnrtt_) {
	        rtt_active_ = 1;
		rtt_seq_ = seqno;			
		rtt_ts_ = Scheduler::instance().clock();
	  }	
        	++nrexmitpack_;
        	nrexmitbytes_ += bytes;
	}
	if (!(rtx_timer_.status() == TIMER_PENDING) || force_set_rtx_timer)
		/* No timer pending.  Schedule one. */
		set_rtx_timer();
}

void RFC793eduTcpAgent::recv_newack_helper(Packet *pkt) {
	//hdr_tcp *tcph = hdr_tcp::access(pkt);
	newack(pkt);
	if (!ect_ || !hdr_flags::access(pkt)->ecnecho() ||
		(old_ecn_ && ecn_burst_)) 
		/* If "old_ecn", this is not the first ACK carrying ECN-Echo
		 * after a period of ACKs without ECN-Echo.
		 * Therefore, open the congestion window. */
	        opencwnd();
	if (ect_) {
		if (!hdr_flags::access(pkt)->ecnecho())
			ecn_backoff_ = 0;
		if (!ecn_burst_ && hdr_flags::access(pkt)->ecnecho())
			ecn_burst_ = TRUE;
		else if (ecn_burst_ && ! hdr_flags::access(pkt)->ecnecho())
			ecn_burst_ = FALSE;
	}
	if (!ect_ && hdr_flags::access(pkt)->ecnecho() &&
		!hdr_flags::access(pkt)->cong_action())
		ect_ = 1;
	/* if the connection is done, call finish() */
	if ((highest_ack_ >= curseq_-1) && !closed_) {
		closed_ = 1;
		finish();
	}
}

void RFC793eduTcpAgent::newack(Packet* pkt)
{
	double now = Scheduler::instance().clock();
	hdr_tcp *tcph = hdr_tcp::access(pkt);
	/* 
	 * Wouldn't it be better to set the timer *after*
	 * updating the RTT, instead of *before*? 
	 */
	newtimer(pkt);
	dupacks_ = 0;
	last_ack_ = tcph->seqno();
	highest_ack_ = last_ack_;

	if (t_seqno_ < last_ack_ + 1)
		t_seqno_ = last_ack_ + 1;
	/* 
	 * Update RTT only if it's OK to do so from info in the flags header.
	 * This is needed for protocols in which intermediate agents
	 * in the network intersperse acks (e.g., ack-reconstructors) for
	 * various reasons (without violating e2e semantics).
	 */	
	hdr_flags *fh = hdr_flags::access(pkt);
	if (!fh->no_ts_) {
		if (ts_option_)
			rtt_update(now - tcph->ts_echo());

		if (rtt_active_ && tcph->seqno() >= rtt_seq_) {
			if (!ect_ || !ecn_backoff_ || 
				!hdr_flags::access(pkt)->ecnecho()) {
				/* 
				 * Don't end backoff if still in ECN-Echo with
			 	 * a congestion window of 1 packet. 
				 */
				t_backoff_ = 1;
				ecn_backoff_ = 0;
			}
			rtt_active_ = 0;
			if (!ts_option_)
				rtt_update(now - rtt_ts_);
		}
	}
	/* update average window */
	awnd_ *= 1.0 - wnd_th_;
	awnd_ += wnd_th_ * cwnd_;
}