NS2.26SourcesOriginal: BayFullTcpAgent class Reference

00135                                  : flags_(0),
00136         state_(TCPS_CLOSED), rq_(rcv_nxt_), last_ack_sent_(0), app_(0),
00137         delack_timer_(this)
00138 {
00139         bind("segsperack_", &segs_per_ack_);
00140         bind("segsize_", &maxseg_);
00141         bind("tcprexmtthresh_", &tcprexmtthresh_);
00142         bind("iss_", &iss_);
00143         bind_bool("nodelay_", &nodelay_);
00144         bind_bool("data_on_syn_",&data_on_syn_);
00145         bind_bool("dupseg_fix_", &dupseg_fix_);
00146         bind_bool("dupack_reset_", &dupack_reset_);
00147         bind("interval_", &delack_interval_);
00148 }

00225 {
00226   /*
00227    * not required any more
00228         register i;
00229         for (i = 0; i < NTIMER; i++)
00230                 if (pending_[i])
00231                         cancel(i);
00232   */
00233         rq_.clear();
00234 }

00327 {
00328         char wrk[256];
00329         int n;
00330         double curTime = (&Scheduler::instance() == NULL ? 0 : 
00331                           Scheduler::instance().clock());
00332         
00333         sprintf(wrk, "a -t "TIME_FORMAT" -s %d -d %d -n %s",
00334                 curTime, here_.addr_, dst_.addr_, name);
00335         n = strlen(wrk);
00336         wrk[n] = '\n';
00337         wrk[n+1] = 0;
00338         if (channel_)
00339                 (void)Tcl_Write(channel_, wrk, n+1);
00340         // keep agent trace name
00341         if (traceName_ != NULL)
00342                 delete[] traceName_;
00343         traceName_ = new char[strlen(name)+1];
00344         strcpy(traceName_, name);
00345 }

00096 { return here_.addr_; }

00281 {
00282         close_on_empty_ = close_flag;
00283 
00284         //
00285         // state-specific operations:
00286         //      if CLOSED, do an active open/connect
00287         //      if ESTABLISHED, just try to send more
00288         //      if above ESTABLISHED, we are closing, so don't allow
00289         //      if anything else (establishing), do nothing here
00290         //
00291         if (state_ > TCPS_ESTABLISHED) {
00292                 return 0;       //try again later, please
00293         } else if (state_ == TCPS_CLOSED)       {
00294                 curseq_ = iss_ + n;
00295                 reinit();
00296                 connect();              // initiate new connection
00297         }
00298         else if (state_ == TCPS_ESTABLISHED)
00299                 curseq_ += n;   
00300         else
00301                 return 0;
00302         return 1;
00303 }

00247 {
00248         // XXX hack:
00249         //      because np is in packets and a data source
00250         //      may pass a *huge* number as a way to tell us
00251         //      to go forever, just look for the huge number
00252         //      and if it's there, pre-divide it
00253         if (np >= 0x10000000)
00254                 np /= maxseg_;
00255 
00256         curseq_ += (np * maxseg_);
00257 
00258         //
00259         // state-specific operations:
00260         //      if CLOSED, do an active open/connect
00261         //      if ESTABLISHED, just try to send more
00262         //      if above ESTABLISHED, we are closing, so don't allow
00263         //      if anything else (establishing), do nothing here
00264         //
00265         if (state_ > TCPS_ESTABLISHED) {
00266                 fprintf(stderr,
00267                  "%f: BayFullTcpAgent::advance(%s): cannot advance while in state %d\n",
00268                  now(), name(), state_);
00269                 return;
00270         } else if (state_ == TCPS_CLOSED)       {
00271                 connect();              // initiate new connection
00272         } else if (state_ == TCPS_ESTABLISHED)
00273                 send_much(0, REASON_NORMAL, 0);
00274         return;
00275 }

00684 {
00685   curseq_ += delta;
00686         if (delta > 0)
00687                 closed_ = 0;
00688         send_much(0, 0, maxburst_); 
00689 }

00518 {
00519         Packet* p = allocpkt();
00520 
00521         if (n > 0)
00522                 p->allocdata(n);
00523 
00524         return(p);
00525 }

00507 {
00508         Packet* p = Packet::alloc();
00509         initpkt(p);
00510         return (p);
00511 }

00373 {
00374         app_ = app;
00375 }

00521 {
00522         if (rtx_timer_.status() == TIMER_PENDING) {
00523                 rtx_timer_.cancel();
00524         }
00525 }

00242                                         {
00243                 rtx_timer_.force_cancel();
00244         }

01650 {   
01651         static int first_time = 1;
01652         if (first_time == 1) {
01653                 fprintf(stderr, "the TcpAgent::closecwnd() function is now deprecated, please use the function slowdown() instead\n");
01654         }
01655         switch (how) {
01656         case 0:
01657                 /* timeouts */
01658                 ssthresh_ = int( window() / 2 );
01659                 if (ssthresh_ < 2)
01660                         ssthresh_ = 2;
01661                 cwnd_ = int(wnd_restart_);
01662                 break;
01663 
01664         case 1:
01665                 /* Reno dup acks, or after a recent congestion indication. */
01666                 // cwnd_ = window()/2;
01667                 cwnd_ = decrease_num_ * window();
01668                 ssthresh_ = int(cwnd_);
01669                 if (ssthresh_ < 2)
01670                         ssthresh_ = 2;          
01671                 break;
01672 
01673         case 2:
01674                 /* Tahoe dup acks               
01675                  * after a recent congestion indication */
01676                 cwnd_ = wnd_init_;
01677                 break;
01678 
01679         case 3:
01680                 /* Retransmit timeout, but no outstanding data. */ 
01681                 cwnd_ = int(wnd_init_);
01682                 break;
01683         case 4:
01684                 /* Tahoe dup acks */
01685                 ssthresh_ = int( window() / 2 );
01686                 if (ssthresh_ < 2)
01687                         ssthresh_ = 2;
01688                 cwnd_ = 1;
01689                 break;
01690 
01691         default:
01692                 abort();
01693         }
01694         fcnt_ = 0.;
01695         count_ = 0;
01696 }

01240 {
01241         // would like to have some "connect" primitive
01242         // here, but the problem is that we get called before
01243         // the simulation is running and we want to send a SYN.
01244         // Because no routing exists yet, this fails.
01245         // Instead, see code in advance() above.
01246         //
01247         // listen can happen any time because it just changes state_
01248         //
01249         // close is designed to happen at some point after the
01250         // simulation is running (using an ns 'at' command)
01251 
01252          Tcl& tcl = Tcl::instance();
01253 
01254         if (argc == 2) {
01255                 if (strcmp(argv[1], "listen") == 0) {
01256                         // just a state transition
01257                         listen();
01258                         return (TCL_OK);
01259                 }
01260                 if (strcmp(argv[1], "close") == 0) {
01261                         usrclosed();
01262                         return (TCL_OK);
01263                 }
01264         }
01265         if (argc == 3) {
01266                 if (strcmp(argv[1], "advance") == 0) {
01267                         advance(atoi(argv[2]));
01268                         return (TCL_OK);
01269                 }
01270                 //added 7/31/97 by kmn to work with apps, specifically www
01271                 //      probably should use a special type of agent...
01272                 if (strcmp(argv[1], "attach-application") == 0) { 
01273                         app_ = (BayTcpAppAgent *)TclObject::lookup(argv[2]); 
01274                         if (app_ == 0) {
01275                                 tcl.resultf("no such agent %s", argv[2]);
01276                                 return(TCL_ERROR);
01277                         }
01278                         return(TCL_OK);
01279                 }
01280                 //added by kmn 8/12/97
01281                 if (strcmp(argv[1], "initial-window") == 0) { 
01282                         wnd_init_ = atoi(argv[2]); 
01283                         cwnd_ = wnd_init_;
01284                         awnd_ = wnd_init_ /2.0;
01285                         return(TCL_OK);
01286                 }
01287 
01288         }
01289         return (TcpAgent::command(argc, argv));
01290 }

00898 {
00899         double p;
00900         double low_p = 1.5/(low_window_*low_window_);
00901         p = exp(linear(log(cwnd_), log(low_window_), log(low_p), log(high_window_), log(high_p_)));
00902         return p;
00903 }

00390 {
00391 /*
00392         dst_ = dst;
00393 */
00394 }

01190 {
01191         state_ = TCPS_SYN_SENT; // sending a SYN now
01192 
01193         if (!data_on_syn_) {
01194                 // force no data in this segment
01195                 int cur = curseq_;
01196                 curseq_ = iss_;
01197                 output(iss_, REASON_NORMAL);
01198                 curseq_ = cur + 1;      //think I have to add in the syn here
01199                 return;
01200         }
01201         output(iss_, REASON_NORMAL);
01202         return;
01203 }

00098 { return dst_.addr_; }

00103 {
00104         if (!debug_)
00105                 return;
00106         va_list ap;
00107         va_start(ap, fmt);
00108         vprintf(fmt, ap);
00109 }

00909 {
00910         double decrease;
00911         decrease = linear(log(cwnd_), log(low_window_), 0.5, log(high_window_), high_decrease_);
00912         return decrease;
00913 }

00159 {
00160         return TcpAgent::delay_bind_dispatch(varName, localName, tracer);
00161 }

00152 {
00153         TcpAgent::delay_bind_init_all();
00154         reset();
00155 }

00223 {
00224         char wrk[256];
00225 
00226         // XXX we don't know InstVar outside of Tcl! Is there any
00227         // tracedvars hidden in InstVar? If so, shall we have a tclclInt.h?
00228         TracedVar* var = tracedvar_;
00229         for ( ;  var != 0;  var = var->next_) 
00230                 flushAVar(var);
00231 
00232         // we need to flush all var values to trace file, 
00233         // so nam can do backtracing
00234         sprintf(wrk, "a -t "TIME_FORMAT" -s %d -d %d -n %s -x",
00235                 Scheduler::instance().clock(), here_.addr_,
00236                 dst_.addr_, traceName_); 
00237         if (traceName_ != NULL)
00238                 delete[] traceName_;
00239         traceName_ = NULL;
00240 }

00099 { return dst_.port_; }

00115 {
00116         if (drop_ != 0)
00117                 drop_->recv(p, s);
00118         else
00119                 Packet::free(p);
00120 }

00107 {
00108         if (drop_ != 0)
00109                 drop_->recv(p);
00110         else
00111                 Packet::free(p);
00112 }

01365 {
01366         int recovered = (highest_ack_ > recover_);
01367         if (recovered || (!bug_fix_ && !ecn_)) {
01368                 goto tahoe_action;
01369         }
01370 
01371         if (ecn_ && last_cwnd_action_ == CWND_ACTION_ECN) {
01372                 last_cwnd_action_ = CWND_ACTION_DUPACK;
01373                 slowdown(CLOSE_CWND_ONE);
01374                 reset_rtx_timer(0,0);
01375                 return;
01376         }
01377 
01378         if (bug_fix_) {
01379                 /*
01380                  * The line below, for "bug_fix_" true, avoids
01381                  * problems with multiple fast retransmits in one
01382                  * window of data. 
01383                  */
01384                 return;
01385         }
01386 
01387 tahoe_action:
01388         // we are now going to fast-retransmit and willtrace that event
01389         trace_event("FAST_RETX");
01390 
01391         recover_ = maxseq_;
01392         last_cwnd_action_ = CWND_ACTION_DUPACK;
01393         slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_ONE);
01394         reset_rtx_timer(0,0);
01395         return;
01396 }

01233 {
01234         if (seqno > recover_ || 
01235               last_cwnd_action_ == CWND_ACTION_TIMEOUT) {
01236                 recover_ =  maxseq_;
01237                 last_cwnd_action_ = CWND_ACTION_ECN;
01238                 if (cwnd_ <= 1.0) {
01239                         if (ecn_backoff_) 
01240                                 rtt_backoff();
01241                         else ecn_backoff_ = 1;
01242                 } else ecn_backoff_ = 0;
01243                 slowdown(CLOSE_CWND_HALF|CLOSE_SSTHRESH_HALF);
01244                 ++necnresponses_ ;
01245                 // added by sylvia to count number of ecn responses 
01246         }
01247 }

01403 {
01404         qs_approved_ = 0;
01405         int new_cwnd = maxseq_ - last_ack_;
01406         if (new_cwnd > 1 && new_cwnd < cwnd_) {
01407                 cwnd_ = new_cwnd;
01408                 if (cwnd_ < initial_window()) 
01409                         cwnd_ = initial_window();
01410         }
01411 }

00590 {       
00591         rtt_backoff();                  // bug fix by van to avoid spurious rtx
00592         int onxt = t_seqno_;            // output() changes t_seqno_
00593         recover_ = maxseq_;             // keep a copy of highest sent
00594         recover_cause_ = REASON_DUPACK; // why we started this recovery period
00595         output(seq, REASON_DUPACK);     // send one pkt
00596         t_seqno_ = onxt;
00597 }

01604 {
01605         Tcl::instance().evalf("%s done", this->name());
01606 }

00101 { return type_; }

00092 {
00093         recv((Packet*)e);
00094 }

00216 {
00217         return (TCPIP_BASE_PKTSIZE);
00218 }

00364 {
00365         if (app_)
00366                 app_->resume();
00367 }

00919 {
00920         double increase, decrease, p, answer;
00921         /* extending the slow-start for high-speed TCP */
00922 
00923         /* for highspeed TCP -- from Sylvia Ratnasamy, */
00924         /* modifications by Sally Floyd and Evandro de Souza */
00925         // p ranges from 1.5/W^2 at congestion window low_window_, to
00926         //    high_p_ at congestion window high_window_, on a log-log scale.
00927         // The decrease factor ranges from 0.5 to high_decrease
00928         //  as the window ranges from low_window to high_window, 
00929         //  as the log of the window. 
00930         // For an efficient implementation, this would just be looked up
00931         //   in a table, with the increase and decrease being a function of the
00932         //   congestion window.
00933 
00934        if (cwnd_ <= low_window_) { 
00935                 answer = 1 / cwnd_;
00936                 return answer; 
00937        } else if (cwnd_ >= cwnd_last_ && cwnd_ < cwnd_frac_ * cwnd_last_ ) {
00938                 answer = increase_last_ / cwnd_;
00939                 return answer;
00940        } else { 
00941                 p = compute_p();
00942                 decrease = decrease_param();
00943                 increase = (cwnd_ * cwnd_ *2.0* decrease * p)/(2.0 - decrease); 
00944                 //      double max_increase = 157.8;
00945                 //      if (increase > max_increase) { 
00946                 //              increase = max_increase;
00947                 //      } 
00948                 answer = increase / cwnd_;
00949                 cwnd_last_ = cwnd_;
00950                 increase_last_ = increase;
00951                 return answer;
00952         }       
00953 }

01302 {
01303         //
01304         // init_option = 1: static iw of wnd_init_
01305         //
01306         if (wnd_init_option_ == 1) {
01307                 return (wnd_init_);
01308         }
01309         else if (wnd_init_option_ == 2) {
01310                 // do iw according to Internet draft
01311                 if (size_ <= 1095) {
01312                         return (4.0);
01313                 } else if (size_ < 2190) {
01314                         return (3.0);
01315                 } else {
01316                         return (2.0);
01317                 }
01318         }
01319         // XXX what should we return here???
01320         fprintf(stderr, "Wrong number of wnd_init_option_ %d\n", 
01321                 wnd_init_option_);
01322         abort();
01323         return (2.0); // XXX make msvc happy.
01324 }

00447 {
00448         hdr_cmn* ch = hdr_cmn::access(p);
00449         ch->uid() = uidcnt_++;
00450         ch->ptype() = type_;
00451         ch->size() = size_;
00452         ch->timestamp() = Scheduler::instance().clock();
00453         ch->iface() = UNKN_IFACE.value(); // from packet.h (agent is local)
00454         ch->direction() = hdr_cmn::NONE;
00455 
00456         ch->error() = 0;        /* pkt not corrupt to start with */
00457 
00458         hdr_ip* iph = hdr_ip::access(p);
00459         iph->saddr() = here_.addr_;
00460         iph->sport() = here_.port_;
00461         iph->daddr() = dst_.addr_;
00462         iph->dport() = dst_.port_;
00463         
00464         //DEBUG
00465         //if (dst_ != -1)
00466         //  printf("pl break\n");
00467         
00468         iph->flowid() = fid_;
00469         iph->prio() = prio_;
00470         iph->ttl() = defttl_;
00471 
00472         hdr_flags* hf = hdr_flags::access(p);
00473         hf->ecn_capable_ = 0;
00474         hf->ecn_ = 0;
00475         hf->eln_ = 0;
00476         hf->ecn_to_echo_ = 0;
00477         hf->fs_ = 0;
00478         hf->no_ts_ = 0;
00479         hf->pri_ = 0;
00480         hf->cong_action_ = 0;
00481 #ifdef HAVE_STL
00482 
00483         hdr_nv* nv = hdr_nv::access(p);
00484         if (0)
00485                 printf("Off hdr_nv %d, ip_hdr %d myaddr %ld\n",
00486                        hdr_nv::offset(), hdr_ip::offset(), here_.addr_);
00487         NixNode* pNixNode = NixNode::GetNodeObject(here_.addr_);
00488         if (0)
00489                 printf("Node Object %p\n", pNixNode);
00490         if (pNixNode) { 
00491                 // If we get non-null, indicates nixvector routing in use
00492                 // Delete any left over nv in the packet
00493                 // Get a nixvector to the target (may create new)
00494                 NixVec* pNv = pNixNode->GetNixVector(dst_.addr_);
00495                 pNv->Reset();
00496                 nv->nv() = pNv; // And set the nixvec in the packet
00497                 nv->h_used = 0; // And reset used portion to 0
00498         }
00499 #endif //HAVE_STL
00500 }

00251 {
00252         OldValue *p = new OldValue;
00253         assert(p != NULL);
00254         strncpy(p->val_, value, min(strlen(value)+1, TRACEVAR_MAXVALUELENGTH));
00255         p->var_ = v;
00256         p->next_ = NULL;
00257         if (oldValueList_ == NULL) 
00258                 oldValueList_ = p;
00259         else {
00260                 p->next_ = oldValueList_;
00261                 oldValueList_ = p;
00262         }
00263 }

00061 { return debug_; }

00873 {
00874         int round = int(cwnd / (double(max_ssthresh)/2.0));
00875         double increment1 = 1.0/(double(round)); 
00876         if (increment < increment1)
00877                 increment = increment1;
00878         return increment;
00879 }

00861 {
00862         // The y coordinate factor ranges from y_1 to y_2
00863         //  as the x coordinate ranges from x_1 to x_2.
00864         double y = y_1 + ((y_2 - y_1) * ((x - x_1)/(x_2-x_1)));
00865         return y;
00866 }

01211 {
01212         state_ = TCPS_LISTEN;
01213         type_ = PT_TCP; //  changed by kmn 8/6/97
01214         //type_ = PT_ACK;       // instead of PT_TCP
01215 }

00243 {
00244         OldValue *p = oldValueList_;
00245         while ((p != NULL) && (p->var_ != v))
00246                 p = p->next_;
00247         return p;
00248 }

00311 {
00312         char wrk[256];
00313         int n;
00314         double curTime = (&Scheduler::instance() == NULL ? 0 : 
00315                           Scheduler::instance().clock());
00316         
00317         sprintf(wrk, "v -t "TIME_FORMAT" -e monitor_agent %d %s",
00318                 curTime, here_.addr_, traceName_);
00319         n = strlen(wrk);
00320         wrk[n] = '\n';
00321         wrk[n+1] = 0;
00322         if (channel_)
00323                 (void)Tcl_Write(channel_, wrk, n+1);
00324 }

00611 {
00612         //first cut, send if anything to ack. Might need maxseg_
00613         if(flags_ & TF_ACKNOW)
00614                 return 1;
00615         if(rcv_nxt_ < switch_spa_thresh_)
00616                 return ((rcv_nxt_ - last_ack_sent_) >= 1);
00617         return ((rcv_nxt_ - last_ack_sent_) >= (segs_per_ack_ * maxseg_));
00618 }

01253                               {
01254         int win = window () ;
01255         if (t_seqno_ > (prev_highest_ack_ + win))
01256                 return 1;
01257         else
01258                 return 0;
01259 }

00541 {
00542     hdr_tcp *tcph = hdr_tcp::access(pkt);
00543 
00544         register int ackno = tcph->ackno();
00545 
00546         // we were timing the segment and we
00547         // got an ACK for it
00548         if (rtt_active_ && ackno >= rtt_seq_) {
00549                 /* got a rtt sample */
00550                 rtt_active_ = FALSE;    // no longer timing
00551                 t_backoff_ = 1;         // stop exp backoff
00552         }
00553 
00554         /* always with timestamp option */
00555         double tao = now() - tcph->ts();
00556         rtt_update(tao);
00557 
00558         if (ackno >= maxseq_)
00559                 cancel_rtx_timeout();
00560         else {
00561                 if (ackno > highest_ack_) {
00562                         set_rtx_timer();
00563                 }
00564         }
00565 
00566         // advance the ack number if this is for new data
00567         if (ackno > highest_ack_)
00568                 highest_ack_ = ackno;
00569         // set up the next packet to send
00570         if (t_seqno_ < highest_ack_)
00571                 t_seqno_ = highest_ack_;        // thing to send next
00572 }

00839 {
00840         hdr_tcp *tcph = hdr_tcp::access(pkt);
00841         /*
00842          * t_seqno_, the next packet to send, is reset (decreased) 
00843          *   to highest_ack_ + 1 after a timeout,
00844          *   so we also have to check maxseq_, the highest seqno sent.
00845          * In addition, if the packet sent after the timeout has
00846          *   the ECN bit set, then the returning ACK caused cwnd_ to
00847          *   be decreased to less than one, and we can't send another
00848          *   packet until the retransmit timer again expires.
00849          *   So we have to check for "cwnd_ < 1" as well.
00850          */
00851         if (t_seqno_ > tcph->seqno() || tcph->seqno() < maxseq_ || cwnd_ < 1) 
00852                 set_rtx_timer();
00853         else
00854                 cancel_rtx_timer();
00855 }

00161 { return Scheduler::instance().clock(); }

00885 {
00886         int cwndfraction = (int) cwnd/numdupacksFrac_;
00887         if (numdupacks_ > cwndfraction) {
00888                 return numdupacks_;
00889         } else {
00890                 return cwndfraction;
00891         }
00892 }

00959 {
00960         double increment;
00961         if (cwnd_ < ssthresh_) {
00962                 /* slow-start (exponential) */
00963                 cwnd_ += 1;
00964         } else {
00965                 /* linear */
00966                 double f;
00967                 switch (wnd_option_) {
00968                 case 0:
00969                         if (++count_ >= cwnd_) {
00970                                 count_ = 0;
00971                                 ++cwnd_;
00972                         }
00973                         break;
00974 
00975                 case 1:
00976                         /* This is the standard algorithm. */
00977                         increment = increase_num_ / cwnd_;
00978                         if ((last_cwnd_action_ == 0 ||
00979                           last_cwnd_action_ == CWND_ACTION_TIMEOUT) 
00980                           && max_ssthresh_ > 0) {
00981                                 increment = limited_slow_start(cwnd_,
00982                                   max_ssthresh_, increment);
00983                         }
00984                         cwnd_ += increment;
00985                         break;
00986 
00987                 case 2:
00988                         /* These are window increase algorithms
00989                          * for experimental purposes only. */
00990                         f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
00991                         f *= f;
00992                         f *= wnd_const_;
00993                         f += fcnt_;
00994                         if (f > cwnd_) {
00995                                 fcnt_ = 0;
00996                                 ++cwnd_;
00997                         } else
00998                                 fcnt_ = f;
00999                         break;
01000 
01001                 case 3:
01002                         f = awnd_;
01003                         f *= f;
01004                         f *= wnd_const_;
01005                         f += fcnt_;
01006                         if (f > cwnd_) {
01007                                 fcnt_ = 0;
01008                                 ++cwnd_;
01009                         } else
01010                                 fcnt_ = f;
01011                         break;
01012 
01013                 case 4:
01014                         f = awnd_;
01015                         f *= wnd_const_;
01016                         f += fcnt_;
01017                         if (f > cwnd_) {
01018                                 fcnt_ = 0;
01019                                 ++cwnd_;
01020                         } else
01021                                 fcnt_ = f;
01022                         break;
01023                 case 5:
01024                         f = (t_srtt_ >> T_SRTT_BITS) * tcp_tick_;
01025                         f *= wnd_const_;
01026                         f += fcnt_;
01027                         if (f > cwnd_) {
01028                                 fcnt_ = 0;
01029                                 ++cwnd_;
01030                         } else
01031                                 fcnt_ = f;
01032                         break;
01033                 case 6:
01034                         /* binomial controls */ 
01035                         cwnd_ += increase_num_ / (cwnd_*pow(cwnd_,k_parameter_));                
01036                         break; 
01037                 case 8: 
01038                         /* high-speed TCP */
01039                         increment = increase_param();
01040                         if ((last_cwnd_action_ == 0 ||
01041                           last_cwnd_action_ == CWND_ACTION_TIMEOUT) 
01042                           && max_ssthresh_ > 0) {
01043                                 increment = limited_slow_start(cwnd_,
01044                                   max_ssthresh_, increment);
01045                         }
01046                         cwnd_ += increment;
01047                         break;
01048                 default:
01049 #ifdef notdef
01050                         /*XXX*/
01051                         error("illegal window option %d", wnd_option_);
01052 #endif
01053                         abort();
01054                 }
01055         }
01056         // if maxcwnd_ is set (nonzero), make it the cwnd limit
01057         if (maxcwnd_ && (int(cwnd_) > maxcwnd_))
01058                 cwnd_ = maxcwnd_;
01059 
01060         return;
01061 }

00309 {
00310         int flags = 0;
00311         if ((state_ != TCPS_LISTEN) && (state_ != TCPS_SYN_SENT))
00312                 flags |= TH_ACK;
00313 
00314         if ((state_ == TCPS_SYN_SENT) || (state_ == TCPS_SYN_RECEIVED))
00315                 flags |= TH_SYN;
00316 
00317         if ((state_ == TCPS_FIN_WAIT_1) || (state_ == TCPS_LAST_ACK))
00318                 flags |= TH_FIN;
00319 
00320         return (flags);
00321 }

00365 {
00366         int is_retransmit = (seqno < maxseq_);
00367         int idle = (highest_ack_ == maxseq_);
00368 
00369         //kmn - changing all this for clarity 8/7/97
00370         int buffered_bytes = (curseq_ + iss_) - seqno;
00371         int datalen = min(buffered_bytes, (highest_ack_ + (window() * maxseg_)) - seqno);
00372         int pflags = outflags();
00373         int emptying_buffer = 0;
00374 
00375         if((pflags & TH_SYN) || datalen <= 0)
00376                 datalen = 0;
00377         else if(datalen > maxseg_)      {
00378                 datalen = maxseg_;
00379         } else if(datalen == buffered_bytes)    {
00380                 emptying_buffer = 1;
00381                 pflags |= TH_PUSH;
00382                 //usrclosed() causes nested calls to output()
00383                 if(close_on_empty_)     {
00384                         pflags |= TH_FIN;
00385                         state_ = TCPS_FIN_WAIT_1;
00386                 }
00387         }
00388 
00389         //end of kmn changes
00390 
00391         /* turn off FIN if there's really more to send */
00392         if (datalen > 0 && !emptying_buffer)
00393                 pflags &= ~TH_FIN;
00394 
00395         /* sender SWS avoidance (Nagle) */
00396 
00397         if (datalen > 0) {
00398                 // if full-sized segment, ok
00399                 if (datalen == maxseg_)
00400                         goto send;
00401                 // if Nagle disabled and buffer clearing, ok
00402                 if ((idle || nodelay_)  && emptying_buffer)
00403                         goto send;
00404                 // if a retransmission
00405                 if (is_retransmit)
00406                         goto send;
00407                 // if big "enough", ok...
00408                 //      (this is not a likely case, and would
00409                 //      only happen for tiny windows)
00410                 if (datalen >= ((wnd_ * maxseg_) / 2.0))
00411                         goto send;
00412         }
00413 
00414         if (need_send())
00415                 goto send;
00416 
00417         /*
00418          * send now if a SYN or special flag "TF_ACKNOW" is set.
00419          * TF_ACKNOW can be set during connection establishment and
00420          * to generate acks for out-of-order data
00421          * kmn 8/28 need to send if there's a push
00422          */
00423         if ((flags_ & TF_ACKNOW) || (pflags & (TH_SYN|TH_FIN|TH_PUSH)))
00424                 goto send;
00425 
00426         return;         // no reason to send now
00427 
00428 send:
00429         //these changed by vj and kmn
00430         if (pflags & TH_FIN) {
00431                 if (flags_ & TF_SENTFIN) {
00432                         // don't allow seqno to advance past fin
00433                         // (the ack generated by a discarded duplicate
00434                         // may attempt to do this)
00435                         if (seqno >= maxseq_)
00436                                 --seqno;
00437                 } else {
00438                         flags_ |= TF_SENTFIN;
00439                         ++t_seqno_;
00440                 }
00441         }
00442 
00443         if((pflags & TH_SYN))   {
00444                 if ((flags_ & TF_SENTSYN) == 0) {
00445                         flags_ |= TF_SENTSYN;
00446                         ++t_seqno_;
00447                 }
00448         }
00449 
00450         /*
00451          * fill in packet fields.  Agent::allocpkt()
00452          * has already filled most of the network layer
00453          * fields for us.   So fill in tcp hdr and adjust
00454          * the packet size.
00455          */
00456         sendpacket(seqno, rcv_nxt_, pflags, datalen, reason);
00457         last_ack_sent_ = rcv_nxt_;
00458         flags_ &= ~(TF_ACKNOW|TF_DELACK);
00459 
00460         t_seqno_ += datalen;            // update snd_nxt (t_seqno_)
00461         if (t_seqno_ > maxseq_) {
00462                 maxseq_ = t_seqno_;     // largest seq# we've sent
00463                 /*
00464                  * Time this transmission if not a retransmission and
00465                  * not currently timing anything.
00466                  */
00467                 if (rtt_active_ == FALSE) {
00468                         rtt_active_ = TRUE;     // set timer
00469                         rtt_seq_ = seqno;       // timed seq #
00470                 }
00471         }
00472         /*
00473          * Set retransmit timer if not currently set,
00474          * and not doing an ack or a keep-alive probe.
00475          * Initial value for retransmit timer is smoothed
00476          * round-trip time + 2 * round-trip time variance.
00477          * Future values are rtt + 4 * rttvar.
00478          */
00479         if (!(rtx_timer_.status() == TIMER_PENDING) && (t_seqno_ > highest_ack_)) {
00480                 set_rtx_timer();  // no timer pending, schedule one
00481         }
00482 }

00097 { return here_.port_; }

00578 {
00579         return 0;
00580 }

01807 {
01808         if (F_counting == 1) {
01809                 if (seqno >= W_timed) {
01810                         RTT_count ++ ; 
01811                         F_counting = 0 ; 
01812                 }
01813                 else {
01814                         if (dupacks_ == numdupacks_)
01815                                 RTT_count ++ ;
01816                 }
01817         }
01818 }

01703 {
01704         int tcp_now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
01705         int rto = (int)(t_rtxcur_/tcp_tick_) ; 
01706         /*double ct = Scheduler::instance().clock();*/
01707 
01708         if (!EnblRTTCtr_) {
01709                 if (tcp_now - T_last >= rto) {
01710                         // The sender has been idle.
01711                         slowdown(THREE_QUARTER_SSTHRESH) ;
01712                         for (int i = 0 ; i < (tcp_now - T_last)/rto; i ++) {
01713                                 slowdown(CWND_HALF_WITH_MIN);
01714                         }
01715                         T_prev = tcp_now ;
01716                         W_used = 0 ;
01717                 }
01718                 T_last = tcp_now ;
01719                 if (t_seqno_ == highest_ack_+ window()) {
01720                         T_prev = tcp_now ; 
01721                         W_used = 0 ; 
01722                 }
01723                 else if (t_seqno_ == curseq_-1) {
01724                         // The sender has no more data to send.
01725                         int tmp = t_seqno_ - highest_ack_ ;
01726                         if (tmp > W_used)
01727                                 W_used = tmp ;
01728                         if (tcp_now - T_prev >= rto) {
01729                                 // The sender has been application-limited.
01730                                 slowdown(THREE_QUARTER_SSTHRESH);
01731                                 slowdown(CLOSE_CWND_HALF_WAY);
01732                                 T_prev = tcp_now ;
01733                                 W_used = 0 ;
01734                         }
01735                 }
01736         } else {
01737                 rtt_counting();
01738         }
01739 }

01414 {
01415         // QuickStart code from Srikanth Sundarrajan.
01416         hdr_tcp *tcph = hdr_tcp::access(pkt);
01417         hdr_qs *qsh = hdr_qs::access(pkt);
01418         double now = Scheduler::instance().clock();
01419         int app_rate;
01420 
01421         // printf("flag: %d ttl: %d ttl_diff: %d rate: %d\n", qsh->flag(),
01422         //     qsh->ttl(), ttl_diff_, qsh->rate());
01423         qs_requested_ = 0;
01424         qs_approved_ = 0;
01425         if (qsh->flag() == QS_RESPONSE && qsh->ttl() == ttl_diff_ && 
01426             qsh->rate() > 0) {
01427                 app_rate = (int) (qsh->rate() * (now - tcph->ts_echo())) ;
01428                 printf("Quick Start approved, rate %d, window %d\n", 
01429                                      qsh->rate(), app_rate);
01430                 if (app_rate > initial_window()) {
01431                         wnd_init_option_ = 1;
01432                         wnd_init_ = app_rate;
01433                         qs_approved_ = 1;
01434                 }
01435         } else { // Quick Start rejected
01436                 printf("Quick Start rejected\n");
01437         }
01438 
01439 }

01638 {
01639         if (highest_ack_ >= recover_) {
01640                 recover_ =  maxseq_;
01641                 last_cwnd_action_ = CWND_ACTION_ECN;
01642                 closecwnd(how);
01643         }
01644 }

00097 {
00098         Packet::free(p);
00099 }

00689 {
00690         hdr_tcp *tcph = hdr_tcp::access(pkt);
00691         hdr_cmn *th = hdr_cmn::access(pkt);
00692         hdr_ip *iph = hdr_ip::access(pkt);
00693         int needoutput = 0;
00694         int ourfinisacked = 0;
00695         int todrop = 0;
00696         int dupseg = FALSE;
00697 
00698 #ifdef notdef
00699         if (trace_)
00700                 plot();
00701 #endif
00702 
00703         //
00704         // if no delayed-ACK timer is set, set one
00705         // they are set to fire every 'interval_' secs, starting
00706         // at time t0 = (0.0 + k * interval_) for some k such
00707         // that t0 > now
00708         //
00709         /*
00710         if (!pending_[TCP_TIMER_DELACK]) {
00711         */
00712         if (!(delack_timer_.status() == TIMER_PENDING)) {
00713                 double now = Scheduler::instance().clock();
00714                 int last = int(now / delack_interval_);
00715                 delack_timer_.resched(delack_interval_ * (last + 1.0) - now);
00716 
00717         }
00718 
00719         int datalen = th->size() - tcph->hlen();
00720         int ackno = tcph->ackno();      // ack # from packet
00721 
00722         // nuked header prediction code that was here - kmn 8/5/97
00723 
00724         int tiflags = tcph->flags() ; // tcp flags from packet
00725 
00726         switch (state_) {
00727         case TCPS_LISTEN:       /* awaiting peer's SYN */
00728                 if (tiflags & TH_ACK) {
00729                         if (tiflags & TH_FIN) {
00730                                 sendpacket(tcph->ackno(), tcph->seqno()+1,
00731                                            TH_ACK, 0, REASON_NORMAL);
00732                                 goto drop;
00733                         }
00734                         // ACK shouldn't be on here
00735         // kmn - this can be from previous connection if reusing
00736         //              fprintf(stderr,
00737         //                  "%f: BayFullTcpAgent::recv(%s): got ACK(%d) while in LISTEN\n",
00738         //                      now(), name(), ackno);
00739                         goto drop;
00740                 }
00741                 if ((tiflags & TH_SYN) == 0) {
00742                         // we're looking for a SYN in return
00743                         fprintf(stderr,
00744                             "%f: BayFullTcpAgent::recv(%s): got a non-SYN while in LISTEN\n",
00745                                 now(), name());
00746                         goto drop;
00747                 }
00748                 flags_ |= TF_ACKNOW;
00749                 state_ = TCPS_SYN_RECEIVED;
00750                 rcv_nxt_ = tcph->seqno() + 1;   //kmn
00751                 t_seqno_ = iss_;
00752                 //kmn - switch from one to set segs per ack
00753                 switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
00754                 goto step6;
00755         case TCPS_SYN_SENT:     /* we sent SYN, expecting SYN+ACK */
00756                 if ((tiflags & TH_ACK) && (ackno > maxseq_)) {
00757                         // not an ACK for our SYN, discard
00758 //                      fprintf(stderr,
00759 //                          "%f: BayFullTcpAgent::recv(%s): bad ACK (%d) for our SYN(%d)\n",
00760 //                              now(), name(), int(ackno), int(maxseq_));
00761                         goto drop;
00762                 }
00763                 if ((tiflags & TH_SYN) == 0) {
00764                         // we're looking for a SYN in return
00765                         fprintf(stderr,
00766                             "%f: BayFullTcpAgent::recv(%s): no SYN for our SYN(%d)\n",
00767                                 now(), name(), int(maxseq_));
00768                         goto drop;
00769                 }
00770                 rcv_nxt_ = tcph->seqno()+1;     // initial expected seq#
00771                 //kmn - switch from one to set segs per ack
00772                 switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
00773                 cancel_rtx_timeout();   // cancel timer on our 1st SYN
00774                 flags_ |= TF_ACKNOW;    // ACK peer's SYN
00775                 if (tiflags & TH_ACK) {
00776                         // got SYN+ACK (what we're expecting)
00777                         // set up to ACK peer's SYN+ACK
00778                         newack(pkt);
00779                         state_ = TCPS_ESTABLISHED;
00780                 } else {
00781                         // simultaneous active opens
00782                         state_ = TCPS_SYN_RECEIVED;
00783                 }
00784                 goto step6;
00785         }
00786 
00787         // check for redundant data at head/tail of segment
00788         //      note that the 4.4bsd [Net/3] code has
00789         //      a bug here which can cause us to ignore the
00790         //      perfectly good ACKs on duplicate segments.  The
00791         //      fix is described in (Stevens, Vol2, p. 959-960).
00792         //      This code is based on that correction.
00793         //
00794         // In addition, it has a modification so that duplicate segments
00795         // with dup acks don't trigger a fast retransmit when dupseg_fix_
00796         // is enabled.
00797         //
00798         todrop = rcv_nxt_ - tcph->seqno();  // how much overlap?
00799         if (todrop > 0) {
00800                 // segment is something we've seen (perhaps partially)
00801                 if (tiflags & TH_SYN) {
00802                         t_seqno_ = highest_ack_;
00803                         if ((tiflags & TH_ACK) == 0)
00804                                 goto dropafterack;
00805                         tiflags &= ~TH_SYN;
00806                 }
00807                 if (todrop > datalen ||
00808                     (todrop == datalen && ((tiflags & TH_FIN) == 0))) {
00809                         /*
00810                          * Any valid FIN must be to the left of the window.
00811                          * At this point the FIN must be a duplicate or out
00812                          * of sequence; drop it.
00813                          */
00814                         tiflags &= ~TH_FIN;
00815 
00816                         /*
00817                          * Send an ACK to resynchronize and drop any data.
00818                          * But keep on processing for RST or ACK.
00819                          */
00820                         flags_ |= TF_ACKNOW;
00821                         todrop = datalen;
00822                         dupseg = TRUE;
00823                 }
00824                 tcph->seqno() += todrop;
00825                 datalen -= todrop;
00826         }
00827 
00828         if (tiflags & TH_SYN) {
00829                 fprintf(stderr,
00830                     "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) received unexpected SYN (state:%d)\n",
00831                         now(),
00832                         iph->saddr(), iph->sport(),
00833                         iph->daddr(), iph->dport(),
00834                         name(), state_);
00835                 goto drop;
00836         }
00837 
00838         if ((tiflags & (TH_SYN|TH_ACK)) == 0) {
00839                 fprintf(stderr, "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) got packet lacking ACK (seq %d)\n",
00840                         now(),
00841                         iph->saddr(), iph->sport(),
00842                         iph->daddr(), iph->dport(),
00843                         name(), tcph->seqno());
00844                 goto drop;
00845         }
00846 
00847         /*
00848          * ACK processing
00849          */
00850 
00851         switch (state_) {
00852         case TCPS_SYN_RECEIVED: /* got ACK for our SYN+ACK */
00853                 if (ackno < highest_ack_ || ackno > maxseq_) {
00854                         // not in useful range
00855                         goto drop;
00856                 }
00857                 state_ = TCPS_ESTABLISHED;
00858                 /* fall into ... */
00859 
00860         /*
00861          * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
00862          * ACKs.  If the ack is in the range
00863          *      tp->snd_una < ti->ti_ack <= tp->snd_max
00864          * then advance tp->snd_una to ti->ti_ack and drop
00865          * data from the retransmission queue.
00866          *
00867          * note that states CLOSE_WAIT and TIME_WAIT aren't used
00868          * in the simulator
00869          */
00870 
00871         case TCPS_ESTABLISHED:
00872         case TCPS_FIN_WAIT_1:
00873         case TCPS_FIN_WAIT_2:
00874         case TCPS_CLOSING:
00875         case TCPS_LAST_ACK:
00876 
00877                 // look for dup ACKs (dup ack numbers, no data)
00878                 //
00879                 // do fast retransmit/recovery if at/past thresh
00880                 if (ackno <= highest_ack_) {
00881                         // an ACK which doesn't advance highest_ack_
00882                         if (datalen == 0 && (!dupseg_fix_ || !dupseg)) {
00883                                 /*
00884                                  * If we have outstanding data
00885                                  * this is a completely
00886                                  * duplicate ack,
00887                                  * the ack is the biggest we've
00888                                  * seen and we've seen exactly our rexmt
00889                                  * threshhold of them, assume a packet
00890                                  * has been dropped and retransmit it.
00891                                  *
00892                                  * We know we're losing at the current
00893                                  * window size so do congestion avoidance.
00894                                  *
00895                                  * Dup acks mean that packets have left the
00896                                  * network (they're now cached at the receiver)
00897                                  * so bump cwnd by the amount in the receiver
00898                                  * to keep a constant cwnd packets in the
00899                                  * network.
00900                                  */
00901 
00902                                 if (!(rtx_timer_.status() == TIMER_PENDING) ||
00903                                     ackno != highest_ack_) {
00904                                         // not timed, or re-ordered ACK
00905                                         dupacks_ = 0;
00906                                 } else if (bug_fix_ &&
00907                                            highest_ack_ == recover_ &&
00908                                            recover_cause_ == REASON_TIMEOUT) {
00909                                         // doing timeout recovery not fastrxmit
00910                                         dupacks_ = 0;
00911                                 } else if (++dupacks_ == tcprexmtthresh_) {
00912                                                 slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_HALF);
00913                                                 cancel_rtx_timeout();
00914                                                 rtt_active_ = FALSE;
00915                                                 fast_retransmit(ackno);
00916                                                 // we measure cwnd in packets,
00917                                                 // so don't scale by maxseg_
00918                                                 // as real TCP does
00919                                                 cwnd_ = ssthresh_ + dupacks_;
00920                                                 goto drop;
00921                                 } else if (dupacks_ > tcprexmtthresh_) {
00922                                         // we just measure cwnd in packets,
00923                                         // so don't scale by maxset_ as real
00924                                         // tcp does
00925                                         cwnd_++;        // fast recovery
00926                                         send_much(0, REASON_NORMAL, 0);
00927                                         goto drop;
00928                                 }
00929                         } else {
00930                                 // non-zero length segment
00931                                 // (or window changed in real TCP).
00932                                 if (dupack_reset_)
00933                                         dupacks_ = 0;
00934                         }
00935                         break;  /* take us to "step6" */
00936                 }
00937 
00938                 /*
00939                  * we've finished the fast retransmit/recovery period
00940                  * (i.e. received an ACK which advances highest_ack_)
00941                  */
00942 
00943                 /*
00944                  * If the congestion window was inflated to account
00945                  * for the other side's cached packets, retract it.
00946                  */
00947                 if (dupacks_ >= tcprexmtthresh_ && cwnd_ > ssthresh_) {
00948                         /*
00949                          * make sure we send at most 2 packets due to this ack
00950                          */
00951                         cwnd_ = (maxseq_ - ackno + maxseg_ - 1)
00952                                   / maxseg_ + 2;
00953                 }
00954                 dupacks_ = 0;
00955                 if (ackno > maxseq_) {
00956                         // ack more than we sent(!?)
00957                         fprintf(stderr,
00958                             "%f: BayFullTcpAgent::recv(%s) too-big ACK (ack: %d, maxseq:%d)\n",
00959                                 now(), name(), int(ackno), int(maxseq_));
00960                         goto dropafterack;
00961                 }
00962 
00963                 /*
00964                  * If we have a timestamp reply, update smoothed
00965                  * round trip time.  If no timestamp is present but
00966                  * transmit timer is running and timed sequence
00967                  * number was acked, update smoothed round trip time.
00968                  * Since we now have an rtt measurement, cancel the
00969                  * timer backoff (cf., Phil Karn's retransmit alg.).
00970                  * Recompute the initial retransmit timer.
00971                  *
00972                  * If all outstanding data is acked, stop retransmit
00973                  * If there is more data to be acked, restart retransmit
00974                  * timer, using current (possibly backed-off) value.
00975                  */
00976                 newack(pkt);
00977                 if (state_ == TCPS_ESTABLISHED && ackno < maxseq_)
00978                         needoutput = 1;
00979                 /* kmn - 8/12/97: don't want to do this on first
00980                  * data send, especially to compare IWs
00981                  * So added test.
00982                  */
00983                 if(first_data_)
00984                         opencwnd();
00985                 // kmn - 8/15 added second test that is acking fin
00986                 if ((state_ == TCPS_FIN_WAIT_1 || state_ == TCPS_FIN_WAIT_2
00987                         || state_ == TCPS_LAST_ACK || state_ == TCPS_CLOSING)
00988                         && ackno >= (curseq_ + iss_)) // && ackno == maxseq_)
00989                         ourfinisacked = 1;
00990                 else
00991                         ourfinisacked = 0;
00992                 // additional processing when we're in special states
00993 
00994                 switch (state_) {
00995                 /*
00996                  * In FIN_WAIT_1 STATE in addition to the processing
00997                  * for the ESTABLISHED state if our FIN is now acknowledged
00998                  * then enter FIN_WAIT_2.
00999                  */
01000                 case TCPS_FIN_WAIT_1:   /* doing active close */
01001                         if (ourfinisacked)
01002                                 state_ = TCPS_FIN_WAIT_2;
01003                         break;
01004 
01005                 /*
01006                  * In CLOSING STATE in addition to the processing for
01007                  * the ESTABLISHED state if the ACK acknowledges our FIN
01008                  * then enter the TIME-WAIT state, otherwise ignore
01009                  * the segment.
01010                  */
01011                 case TCPS_CLOSING:      /* simultaneous active close */;
01012                         if (ourfinisacked)
01013                                 state_ = TCPS_CLOSED;
01014                         break;
01015                 /*
01016                  * In LAST_ACK, we may still be waiting for data to drain
01017                  * and/or to be acked, as well as for the ack of our FIN.
01018                  * If our FIN is now acknowledged,
01019                  * enter the closed state and return.
01020                  */
01021                 case TCPS_LAST_ACK:     /* passive close */
01022                         if (ourfinisacked)      {
01023                                 state_ = TCPS_CLOSED;   //kmn added 2 lines
01024                                 /*
01025                                 for(int i =0; i < NTIMER; i++)  {
01026                                         cancel(i);
01027                                 }
01028                                 */
01029                                 goto drop;
01030                         } else {                //should be a FIN we've seen
01031                                 fprintf(stderr,
01032                                 "%f: %d.%d>%d.%d BayFullTcpAgent::recv(%s) received non-ACK (state:%d)\n",
01033                                         now(),
01034                                         iph->saddr(), iph->sport(),
01035                                         iph->daddr(), iph->dport(),
01036                                         name(), state_);
01037                         }
01038 
01039                 /* no case for TIME_WAIT in simulator */
01040                 } // inner switch
01041         } // outer switch
01042 
01043 step6:
01044         /* real TCP handles window updates and URG data here */
01045 /* dodata: this label is in the "real" code.. here only for reference */
01046         /*
01047          * DATA processing
01048          * kmn - several changes here to talk to application agent
01049          */
01050 
01051         if (datalen > 0 || (tiflags & TH_FIN)) {
01052                 first_data_ = 1;        //now seen first data
01053                 // see the "TCP_REASS" macro for this code
01054                 if (tcph->seqno() == rcv_nxt_ && rq_.empty()) {
01055                         // got the in-order packet we were looking
01056                         // for, nobody is in the reassembly queue,
01057                         // so this is the common case...
01058                         // note: in "real" TCP we must also be in
01059                         // ESTABLISHED state to come here, because
01060                         // data arriving before ESTABLISHED is
01061                         // queued in the reassembly queue.  Since we
01062                         // don't really have a process anyhow, just
01063                         // accept the data here as-is (i.e. don't
01064                         // require being in ESTABLISHED state)
01065                         tiflags &= TH_FIN;
01066                         if (tiflags) {
01067                                 ++rcv_nxt_;
01068                         }
01069                         flags_ |= TF_DELACK;
01070                         rcv_nxt_ += datalen;
01071                         // give to "application" here
01072                         // added 7/30/97 by kmn to call application with
01073                         //      number of bytes since last push (if any)
01074                         // the server is going to call advance before this
01075                         //      completes, so changed advance to not call
01076                         //      send_much if ESTABLISHED. curseq gets
01077                         //      checked below.
01078                         //
01079                         if(datalen && app_ && (tcph->flags() & TH_PUSH)) {
01080                                 //rcv_nxt_ - last_upcalled_bytes_;
01081                                 app_->recv(pkt,this,DATA_PUSH);
01082                                 //last_upcalled_bytes_ = rcv_nxt_;
01083                         }
01084                         needoutput = need_send();
01085                 } else {
01086                         // not the one we want next (or it
01087                         // is but there's stuff on the reass queue);
01088                         // do whatever we need to do for out-of-order
01089                         // segments or hole-fills.  Also,
01090                         // send an ACK to the other side right now.
01091                         tiflags = rq_.add(pkt);
01092                         if (tiflags & TH_PUSH) {
01093                           if (app_ != NULL )
01094                             app_->recv(pkt,this,DATA_PUSH);
01095                           needoutput = need_send();
01096                         } else
01097                                 flags_ |= TF_ACKNOW;
01098                         //reset for losses
01099                         switch_spa_thresh_ = rcv_nxt_ + (16 * 1024);
01100                 }
01101         }
01102 
01103         /*
01104          * if FIN is received, ACK the FIN
01105          * (let user know if we could do so)
01106          */
01107 
01108         if (tiflags & TH_FIN) {
01109                 flags_ |= TF_ACKNOW;
01110                 rq_.clear();    // other side shutting down
01111                 switch (state_) {
01112                 /*
01113                  * In SYN_RECEIVED and ESTABLISHED STATES
01114                  * enter the CLOSE_WAIT state.
01115                  * (in the simulator, go to LAST_ACK)
01116                  * (passive close)
01117                  */
01118                 case TCPS_SYN_RECEIVED:
01119                 case TCPS_ESTABLISHED:
01120                         state_ = TCPS_LAST_ACK;
01121                         break;
01122 
01123                 /*
01124                  * If still in FIN_WAIT_1 STATE FIN has not been acked so
01125                  * enter the CLOSING state.
01126                  * (simultaneous close)
01127                  */
01128                 case TCPS_FIN_WAIT_1:
01129                         state_ = TCPS_CLOSING;
01130                         break;
01131                 /*
01132                  * In FIN_WAIT_2 state enter the TIME_WAIT state,
01133                  * starting the time-wait timer, turning off the other
01134                  * standard timers.
01135                  * (in the simulator, just go to CLOSED)
01136                  * (active close)
01137                  */
01138                 case TCPS_FIN_WAIT_2:
01139                         state_ = TCPS_CLOSED;
01140                         cancel_rtx_timeout();
01141                         break;
01142                 }
01143         }
01144 
01145         if (needoutput || (flags_ & TF_ACKNOW))
01146                 send_much(1, REASON_NORMAL, 0);
01147         else if ((curseq_ + iss_) > highest_ack_)
01148                 send_much(0, REASON_NORMAL, 0);
01149 
01150         /* kmn -  ugh, egregious hack. Can tell it's a server
01151          * so it goes to listen state. Do something
01152          * else if this becomes more stable
01153          */
01154         if(state_ == TCPS_CLOSED)       {
01155                 if(close_on_empty_) {
01156                         reinit();
01157                         curseq_ = iss_;
01158                         state_ = TCPS_LISTEN;
01159                 } else {        /*"something else" - kmn 6/00 */
01160                   if (app_ != NULL )
01161                     app_->recv(pkt,this,CONNECTION_END);
01162                 }
01163         }
01164         Packet::free(pkt);
01165         return;
01166 
01167 dropafterack:
01168         flags_ |= TF_ACKNOW;
01169         send_much(1, REASON_NORMAL, 0);
01170 drop:
01171         Packet::free(pkt);
01172         return;
01173 }

01261                                              {
01262         //hdr_tcp *tcph = hdr_tcp::access(pkt);
01263         newack(pkt);
01264         if (!ect_ || !hdr_flags::access(pkt)->ecnecho() ||
01265                 (old_ecn_ && ecn_burst_)) {
01266                 /* If "old_ecn", this is not the first ACK carrying ECN-Echo
01267                  * after a period of ACKs without ECN-Echo.
01268                  * Therefore, open the congestion window. */
01269                 /* if control option is set, and the sender is not
01270                          window limited, then do not increase the window size */
01271                 
01272                 if (!control_increase_ || 
01273                    (control_increase_ && (network_limited() == 1))) 
01274                         opencwnd();
01275         }
01276         if (ect_) {
01277                 if (!hdr_flags::access(pkt)->ecnecho())
01278                         ecn_backoff_ = 0;
01279                 if (!ecn_burst_ && hdr_flags::access(pkt)->ecnecho())
01280                         ecn_burst_ = TRUE;
01281                 else if (ecn_burst_ && ! hdr_flags::access(pkt)->ecnecho())
01282                         ecn_burst_ = FALSE;
01283         }
01284         if (!ect_ && hdr_flags::access(pkt)->ecnecho() &&
01285                 !hdr_flags::access(pkt)->cong_action())
01286                 ect_ = 1;
01287         /* if the connection is done, call finish() */
01288         if ((highest_ack_ >= curseq_-1) && !closed_) {
01289                 closed_ = 1;
01290                 finish();
01291         }
01292         if (QOption_ && curseq_ == highest_ack_ +1) {
01293                 cancel_rtx_timer();
01294         }
01295 }

00355 {
00356         if (app_)
00357                 app_->recv(nbytes);     
00358 }

00184 {
00185         cancel_rtx_timeout();
00186         rtt_init();
00187         cwnd_ = wnd_init_;
00188         last_ack_ = highest_ack_ = 0;
00189         ssthresh_ = int(wnd_);
00190         awnd_ = wnd_init_ / 2.0;
00191         recover_ = 0;
00192         recover_cause_ = 0;
00193 
00194         last_ack_sent_ = 0;
00195         rcv_nxt_ = 0;           //kmn
00196         flags_ = 0;
00197         t_seqno_ = maxseq_ = iss_;
00198         switch_spa_thresh_ = 0;
00199         /*
00200         for(int i =0; i < NTIMER; i++)  {
00201                 cancel(i);
00202         }
00203         */
00204         rq_.clear();
00205         first_data_ = 0;                //don't open cwnd too early
00206 }

00170 {
00171         TcpAgent::reset();
00172         highest_ack_ = 0;
00173         last_ack_sent_ = 0;
00174         rcv_nxt_ = 0;           //kmn
00175         flags_ = 0;
00176         t_seqno_ = iss_;
00177         close_on_empty_ = 0;    //added 7/30/97 by kmn
00178         switch_spa_thresh_ = 0;
00179         first_data_ = 0;                //don't open cwnd too early
00180 }

00396 {
00397         int now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
00398 
00399         T_start = now ; 
00400         RTT_count = 0 ; 
00401         RTT_prev = 0 ; 
00402         RTT_goodcount = 1 ; 
00403         F_counting = 0 ; 
00404         W_timed = -1 ; 
00405         F_full = 0 ;
00406         Backoffs = 0 ; 
00407 }

00814 {
00815         if (backoff)
00816                 rtt_backoff();
00817         set_rtx_timer();
00818         if (!mild)
00819                 t_seqno_ = highest_ack_ + 1;
00820         rtt_active_ = 0;
00821 }

01176 {
01177         // cancel old timer,
01178         // set a new one
01179         rtt_backoff();          // double current timeout
01180         set_rtx_timer();        // set new timer
01181         rtt_active_ = FALSE;
01182 }

00553 {
00554         if (t_backoff_ < 64)
00555                 t_backoff_ <<= 1;
00556 
00557         if (t_backoff_ > 8) {
00558                 /*
00559                  * If backed off this far, clobber the srtt
00560                  * value, storing it in the mean deviation
00561                  * instead.
00562                  */
00563                 t_rttvar_ += (t_srtt_ >> T_SRTT_BITS);
00564                 t_srtt_ = 0;
00565         }
00566 }

01749 {
01750         int tcp_now = (int)(Scheduler::instance().clock()/tcp_tick_ + 0.5);
01751         int rtt = (int(t_srtt_) >> T_SRTT_BITS) ;
01752 
01753         if (rtt < 1) 
01754                 rtt = 1 ;
01755         if (tcp_now - T_last >= 2*rtt) {
01756                 // The sender has been idle.
01757                 int RTTs ; 
01758                 RTTs = (tcp_now -T_last)*RTT_goodcount/(rtt*2) ; 
01759                 RTTs = RTTs - Backoffs ; 
01760                 Backoffs = 0 ; 
01761                 if (RTTs > 0) {
01762                         slowdown(THREE_QUARTER_SSTHRESH) ;
01763                         for (int i = 0 ; i < RTTs ; i ++) {
01764                                 slowdown(CWND_HALF_WITH_MIN);
01765                                 RTT_prev = RTT_count ; 
01766                                 W_used = 0 ;
01767                         }
01768                 }
01769         }
01770         T_last = tcp_now ;
01771         if (tcp_now - T_start >= 2*rtt) {
01772                 if ((RTT_count > RTT_goodcount) || (F_full == 1)) {
01773                         RTT_goodcount = RTT_count ; 
01774                         if (RTT_goodcount < 1) RTT_goodcount = 1 ; 
01775                 }
01776                 RTT_prev = RTT_prev - RTT_count ;
01777                 RTT_count = 0 ; 
01778                 T_start  = tcp_now ;
01779                 F_full = 0;
01780         }
01781         if (t_seqno_ == highest_ack_ + window()) {
01782                 W_used = 0 ; 
01783                 F_full = 1 ; 
01784                 RTT_prev = RTT_count ;
01785         }
01786         else if (t_seqno_ == curseq_-1) {
01787                 // The sender has no more data to send.
01788                 int tmp = t_seqno_ - highest_ack_ ;
01789                 if (tmp > W_used)
01790                         W_used = tmp ;
01791                 if (RTT_count - RTT_prev >= 2) {
01792                         // The sender has been application-limited.
01793                         slowdown(THREE_QUARTER_SSTHRESH) ;
01794                         slowdown(CLOSE_CWND_HALF_WAY);
01795                         RTT_prev = RTT_count ; 
01796                         Backoffs ++ ; 
01797                         W_used = 0;
01798                 }
01799         }
01800         if (F_counting == 0) {
01801                 W_timed = t_seqno_  ;
01802                 F_counting = 1 ;
01803         }
01804 }

00469 {
00470         t_rtt_ = 0;
00471         t_srtt_ = int(srtt_init_ / tcp_tick_) << T_SRTT_BITS;
00472         t_rttvar_ = int(rttvar_init_ / tcp_tick_) << T_RTTVAR_BITS;
00473         t_rtxcur_ = rtxcur_init_;
00474         t_backoff_ = 1;
00475 }

00478 {
00479         double timeout;
00480         if (rfc2988_) {
00481         // Correction from Tom Kelly to be RFC2988-compliant, by
00482         // clamping minrto_ before applying t_backoff_.
00483                 if (t_rtxcur_ < minrto_)
00484                         timeout = minrto_ * t_backoff_;
00485                 else
00486                         timeout = t_rtxcur_ * t_backoff_;
00487         } else {
00488                 timeout = t_rtxcur_ * t_backoff_;
00489                 if (timeout < minrto_)
00490                         timeout = minrto_;
00491         }
00492 
00493         if (timeout > maxrto_)
00494                 timeout = maxrto_;
00495 
00496         if (timeout < 2.0 * tcp_tick_) {
00497                 if (timeout < 0) {
00498                         fprintf(stderr, "TcpAgent: negative RTO!  (%f)\n",
00499                                 timeout);
00500                         exit(1);
00501                 }
00502                 timeout = 2.0 * tcp_tick_;
00503         }
00504         return (timeout);
00505 }

00510 {
00511         double now = Scheduler::instance().clock();
00512         if (ts_option_)
00513                 t_rtt_ = int(tao /tcp_tick_ + 0.5);
00514         else {
00515                 double sendtime = now - tao;
00516                 sendtime += boot_time_;
00517                 double tickoff = fmod(sendtime, tcp_tick_);
00518                 t_rtt_ = int((tao + tickoff) / tcp_tick_);
00519         }
00520         if (t_rtt_ < 1)
00521                 t_rtt_ = 1;
00522 
00523         //
00524         // srtt has 3 bits to the right of the binary point
00525         // rttvar has 2
00526         //
00527         if (t_srtt_ != 0) {
00528                 register short delta;
00529                 delta = t_rtt_ - (t_srtt_ >> T_SRTT_BITS);      // d = (m - a0)
00530                 if ((t_srtt_ += delta) <= 0)    // a1 = 7/8 a0 + 1/8 m
00531                         t_srtt_ = 1;
00532                 if (delta < 0)
00533                         delta = -delta;
00534                 delta -= (t_rttvar_ >> T_RTTVAR_BITS);
00535                 if ((t_rttvar_ += delta) <= 0)  // var1 = 3/4 var0 + 1/4 |d|
00536                         t_rttvar_ = 1;
00537         } else {
00538                 t_srtt_ = t_rtt_ << T_SRTT_BITS;                // srtt = rtt
00539                 t_rttvar_ = t_rtt_ << (T_RTTVAR_BITS-1);        // rttvar = rtt / 2
00540         }
00541         //
00542         // Current retransmit value is 
00543         //    (unscaled) smoothed round trip estimate
00544         //    plus 2^rttvar_exp_ times (unscaled) rttvar. 
00545         //
00546         t_rtxcur_ = (((t_rttvar_ << (rttvar_exp_ + (T_SRTT_BITS - T_RTTVAR_BITS))) +
00547                 t_srtt_)  >> T_SRTT_BITS ) * tcp_tick_;
00548 
00549         return;
00550 }

00089 { sendmsg(nbytes); }

00084 { sendmsg(sz, data, 0); }

00080 { target_->recv(p, h); }

00489 {
00490 
00491         /*
00492          * highest_ack is essentially "snd_una" in real TCP
00493          *
00494          * loop while we are in-window (seqno <= (highest_ack + win))
00495          * and there is something to send (t_seqno_ < curseq_+iss_)
00496          */
00497         int win = window() * maxseg_;   // window() in pkts
00498         int npackets = 0;
00499         int topwin = curseq_ + iss_;
00500         if (topwin > highest_ack_ + win)
00501                 topwin = highest_ack_ + win;
00502 
00503         if (!force && (delsnd_timer_.status() == TIMER_PENDING))
00504                 return;
00505 
00506         while (force || (t_seqno_ < topwin)) {
00507                 if (overhead_ != 0 && !(delsnd_timer_.status() == TIMER_PENDING)) {
00508                         delsnd_timer_.resched(Random::uniform(overhead_));
00509                         return;
00510                 }
00511                 output(t_seqno_, reason);       // updates seqno for us
00512                 force = 0;
00513                 if (outflags() & TH_SYN)
00514                         break;
00515                 if (maxburst && ++npackets >= maxburst)
00516                         break;
00517         }
00518 }

01351 {
01352         if (t_seqno_ <= highest_ack_ + wnd_ && t_seqno_ < curseq_ &&
01353                 t_seqno_ <= highest_ack_ + cwnd_ + dupacks_ ) {
01354                 output(t_seqno_, 0);
01355                 if (QOption_)
01356                         process_qoption_after_send () ;
01357                 t_seqno_ ++ ;
01358                 // send_helper(); ??
01359         }
01360         return;
01361 }

00401 {
00402         fprintf(stderr, 
00403         "Agent::sendmsg(int, AppData*, const char*) not implemented\n");
00404         abort();
00405 }

00675 {
00676         if (nbytes == -1 && curseq_ <= TCP_MAXSEQ)
00677                 curseq_ = TCP_MAXSEQ; 
00678         else
00679                 curseq_ += (nbytes/size_ + (nbytes%size_ ? 1 : 0));
00680         send_much(0, 0, maxburst_);
00681 }

00325 {
00326         Packet* p = allocpkt();
00327         hdr_tcp *tcph = hdr_tcp::access(p);
00328         hdr_cmn *th = hdr_cmn::access(p);
00329         tcph->seqno() = seqno;
00330         tcph->ackno() = ackno;
00331         tcph->flags() = pflags;
00332         tcph->hlen() = headersize();
00333         tcph->ts() = now();
00334     /* Open issue:  should tcph->reason map to pkt->flags_ as in ns-1?? */
00335         tcph->reason() |= reason;
00336         th->size() = datalen + headersize();
00337         if (datalen <= 0)
00338                 ++nackpack_;
00339         else {
00340                 ++ndatapack_;
00341                 ndatabytes_ += datalen;
00342         }
00343         if (reason == REASON_TIMEOUT || reason == REASON_DUPACK) {
00344                 ++nrexmitpack_;
00345                 nrexmitbytes_ += datalen;
00346         }
00347         send(p, 0);
00348 }

00409 {
00410         fprintf(stderr, 
00411         "Agent::sendmsg(int, AppData*, const char*) not implemented\n");
00412         abort();
00413 }

00387 {
00388         if (syn_ && delay_growth_)
00389                 cwnd_ = 1.0; 
00390         else
00391                 cwnd_ = initial_window();
00392 }

00100 { type_ = pkttype; }

00828 {
00829         rtx_timer_.resched(rtt_timeout());
00830 }

00095 { return size_; }

01065 {
01066         double decrease;  /* added for highspeed - sylvia */
01067         double win, halfwin, decreasewin;
01068         int slowstart = 0;
01069         ++ncwndcuts_; 
01070         // we are in slowstart for sure if cwnd < ssthresh
01071         if (cwnd_ < ssthresh_) 
01072                 slowstart = 1;
01073         if (precision_reduce_) {
01074                 halfwin = windowd() / 2;
01075                 if (wnd_option_ == 6) {         
01076                         /* binomial controls */
01077                         decreasewin = windowd() - (1.0-decrease_num_)*pow(windowd(),l_parameter_);
01078                 } else if (wnd_option_ == 8 && (cwnd_ > low_window_)) { 
01079                         /* experimental highspeed TCP */
01080                         decrease = decrease_param();
01081                         //if (decrease < 0.1) 
01082                         //      decrease = 0.1;
01083                         decrease_num_ = decrease;
01084                         decreasewin = windowd() - (decrease * windowd());
01085                 } else {
01086                         decreasewin = decrease_num_ * windowd();
01087                 }
01088                 win = windowd();
01089         } else  {
01090                 int temp;
01091                 temp = (int)(window() / 2);
01092                 halfwin = (double) temp;
01093                 if (wnd_option_ == 6) {
01094                         /* binomial controls */
01095                         temp = (int)(window() - (1.0-decrease_num_)*pow(window(),l_parameter_));
01096                 } else if ((wnd_option_ == 8) && (cwnd_ > low_window_)) { 
01097                         /* experimental highspeed TCP */
01098                         decrease = decrease_param();
01099                         //if (decrease < 0.1)
01100                         //       decrease = 0.1;                
01101                         decrease_num_ = decrease;
01102                         temp = (int)(windowd() - (decrease * windowd()));
01103                 } else {
01104                         temp = (int)(decrease_num_ * window());
01105                 }
01106                 decreasewin = (double) temp;
01107                 win = (double) window();
01108         }
01109         if (how & CLOSE_SSTHRESH_HALF)
01110                 // For the first decrease, decrease by half
01111                 // even for non-standard values of decrease_num_.
01112                 if (first_decrease_ == 1 || slowstart ||
01113                         last_cwnd_action_ == CWND_ACTION_TIMEOUT) {
01114                         // Do we really want halfwin instead of decreasewin
01115                 // after a timeout?
01116                         ssthresh_ = (int) halfwin;
01117                 } else {
01118                         ssthresh_ = (int) decreasewin;
01119                 }
01120         else if (how & THREE_QUARTER_SSTHRESH)
01121                 if (ssthresh_ < 3*cwnd_/4)
01122                         ssthresh_  = (int)(3*cwnd_/4);
01123         if (how & CLOSE_CWND_HALF)
01124                 // For the first decrease, decrease by half
01125                 // even for non-standard values of decrease_num_.
01126                 if (first_decrease_ == 1 || slowstart || decrease_num_ == 0.5) {
01127                         cwnd_ = halfwin;
01128                 } else cwnd_ = decreasewin;
01129         else if (how & CWND_HALF_WITH_MIN) {
01130                 // We have not thought about how non-standard TCPs, with
01131                 // non-standard values of decrease_num_, should respond
01132                 // after quiescent periods.
01133                 cwnd_ = decreasewin;
01134                 if (cwnd_ < 1)
01135                         cwnd_ = 1;
01136         }
01137         else if (how & CLOSE_CWND_RESTART) 
01138                 cwnd_ = int(wnd_restart_);
01139         else if (how & CLOSE_CWND_INIT)
01140                 cwnd_ = int(wnd_init_);
01141         else if (how & CLOSE_CWND_ONE)
01142                 cwnd_ = 1;
01143         else if (how & CLOSE_CWND_HALF_WAY) {
01144                 // cwnd_ = win - (win - W_used)/2 ;
01145                 cwnd_ = W_used + decrease_num_ * (win - W_used);
01146                 if (cwnd_ < 1)
01147                         cwnd_ = 1;
01148         }
01149         if (ssthresh_ < 2)
01150                 ssthresh_ = 2;
01151         if (how & (CLOSE_CWND_HALF|CLOSE_CWND_RESTART|CLOSE_CWND_INIT|CLOSE_CWND_ONE))
01152                 cong_action_ = TRUE;
01153 
01154         fcnt_ = count_ = 0;
01155         if (first_decrease_ == 1)
01156                 first_decrease_ = 0;
01157         // for event tracing slow start
01158         if (cwnd_ == 1 || slowstart) 
01159                 // Not sure if this is best way to capture slow_start
01160                 // This is probably tracing a superset of slowdowns of
01161                 // which all may not be slow_start's --Padma, 07/'01.
01162                 trace_event("SLOW_START");
01163         
01164 
01165 
01166         
01167 }

00144 { return state_; }

00048 { return target_; }

01583 {
01584         //int eln_rxmit;
01585         hdr_tcp *tcph = hdr_tcp::access(pkt);
01586         int ack = tcph->seqno();
01587 
01588         if (++dupacks_ == eln_rxmit_thresh_ && ack > eln_last_rxmit_) {
01589                 /* Retransmit this packet */
01590                 output(last_ack_ + 1, TCP_REASON_DUPACK);
01591                 eln_last_rxmit_ = last_ack_+1;
01592         } else
01593                 send_much(0, 0, maxburst_);
01594 
01595         Packet::free(pkt);
01596         return;
01597 }

00636 {
00637         if(state_ == TCPS_CLOSED || state_ == TCPS_LISTEN)
00638                 return;
00639         /* retransmit timer */
00640         if (tno == TCP_TIMER_RTX) {
00641                 ++nrexmit_;
00642                 recover_ = maxseq_;
00643                 recover_cause_ = REASON_TIMEOUT;
00644                 slowdown(CLOSE_SSTHRESH_HALF|CLOSE_CWND_RESTART);
00645                 //changed 6/10/00 to look at rtx problem -kmn
00646 /*              if(highest_ack_ == maxseq_)
00647                         reset_rtx_timer(0,0);
00648                 else
00649                         reset_rtx_timer(0,1);
00650 */
00651                 reset_rtx_timer(1);
00652                 t_seqno_ = highest_ack_;
00653                 dupacks_ = 0;
00654                 send_much(1, REASON_TIMEOUT);
00655         } else if (tno == TCP_TIMER_DELSND) {
00656                 /*
00657                  * delayed-send timer, with random overhead
00658                  * to avoid phase effects
00659                  */
00660                 send_much(1, PF_TIMEOUT);
00661         } else if (tno == TCP_TIMER_DELACK) {
00662                 if (flags_ & TF_DELACK) {
00663                         flags_ &= ~TF_DELACK;
00664                         flags_ |= TF_ACKNOW;
00665                         send_much(1, REASON_NORMAL, 0);
00666                 }
00667                 delack_timer_.resched(delack_interval_);
00668         } else {
00669                 fprintf(stderr, "%f: (%s) UNKNOWN TIMEOUT %d\n",
00670                         now(), name(), tno);
00671         }
00672 }

01506 {
01507         if (tno == TCP_TIMER_DELSND)  {
01508          /*
01509                 * delayed-send timer, with random overhead
01510                 * to avoid phase effects
01511                 */
01512                 send_much(1, TCP_REASON_TIMEOUT, maxburst_);
01513         }
01514 }

00368 {
00369         if (nam_tracevar_) {
00370                 Agent::trace(v);
00371         } else if (trace_all_oneline_)
00372                 traceAll();
00373         else 
00374                 traceVar(v);
00375 }

01821 {
01822         if (et_ == NULL) return;
01823         int seqno = t_seqno_;
01824         char *wrk = et_->buffer();
01825         char *nwrk = et_->nbuffer();
01826         if (wrk != 0)
01827                 sprintf(wrk,
01828                         "E "TIME_FORMAT" %d %d TCP %s %d %d %d",
01829                         et_->round(Scheduler::instance().clock()),   // time
01830                         addr(),                       // owner (src) node id
01831                         daddr(),                      // dst node id
01832                         eventtype,                    // event type
01833                         fid_,                         // flow-id
01834                         seqno,                        // current seqno
01835                         int(cwnd_)                         //cong. window
01836                         );
01837         
01838         if (nwrk != 0)
01839                 sprintf(nwrk,
01840                         "E -t "TIME_FORMAT" -o TCP -e %s -s %d.%d -d %d.%d",
01841                         et_->round(Scheduler::instance().clock()),   // time
01842                         eventtype,                    // event type
01843                         addr(),                       // owner (src) node id
01844                         port(),                       // owner (src) port id
01845                         daddr(),                      // dst node id
01846                         dport()                       // dst port id
01847                         );
01848         et_->trace();
01849 }

00296                    {
00297         double curtime;
00298         Scheduler& s = Scheduler::instance();
00299         char wrk[500];
00300         int n;
00301 
00302         curtime = &s ? s.clock() : 0;
00303         sprintf(wrk,"time: %-8.5f saddr: %-2d sport: %-2d daddr: %-2d dport:"
00304                 " %-2d maxseq: %-4d hiack: %-4d seqno: %-4d cwnd: %-6.3f"
00305                 " ssthresh: %-3d dupacks: %-2d rtt: %-6.3f srtt: %-6.3f"
00306                 " rttvar: %-6.3f bkoff: %-d", curtime, addr(), port(),
00307                 daddr(), dport(), int(maxseq_), int(highest_ack_),
00308                 int(t_seqno_), double(cwnd_), int(ssthresh_),
00309                 int(dupacks_), int(t_rtt_)*tcp_tick_, 
00310                 (int(t_srtt_) >> T_SRTT_BITS)*tcp_tick_, 
00311                 int(t_rttvar_)*tcp_tick_/4.0, int(t_backoff_)); 
00312         n = strlen(wrk);
00313         wrk[n] = '\n';
00314         wrk[n+1] = 0;
00315         if (channel_)
00316                 (void)Tcl_Write(channel_, wrk, n+1);
00317         wrk[n] = 0;
00318         return;
00319 }

00324 {
00325         double curtime;
00326         Scheduler& s = Scheduler::instance();
00327         char wrk[500];
00328         int n;
00329 
00330         curtime = &s ? s.clock() : 0;
00331         if (!strcmp(v->name(), "cwnd_") || !strcmp(v->name(), "maxrto_")) 
00332                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00333                         curtime, addr(), port(), daddr(), dport(),
00334                         v->name(), double(*((TracedDouble*) v))); 
00335         else if (!strcmp(v->name(), "minrto_")) 
00336                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00337                         curtime, addr(), port(), daddr(), dport(),
00338                         v->name(), double(*((TracedDouble*) v))); 
00339         else if (!strcmp(v->name(), "rtt_"))
00340                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00341                         curtime, addr(), port(), daddr(), dport(),
00342                         v->name(), int(*((TracedInt*) v))*tcp_tick_); 
00343         else if (!strcmp(v->name(), "srtt_")) 
00344                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00345                         curtime, addr(), port(), daddr(), dport(),
00346                         v->name(), 
00347                         (int(*((TracedInt*) v)) >> T_SRTT_BITS)*tcp_tick_); 
00348         else if (!strcmp(v->name(), "rttvar_"))
00349                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %-6.3f",
00350                         curtime, addr(), port(), daddr(), dport(),
00351                         v->name(), 
00352                         int(*((TracedInt*) v))*tcp_tick_/4.0); 
00353         else
00354                 sprintf(wrk,"%-8.5f %-2d %-2d %-2d %-2d %s %d",
00355                         curtime, addr(), port(), daddr(), dport(),
00356                         v->name(), int(*((TracedInt*) v))); 
00357         n = strlen(wrk);
00358         wrk[n] = '\n';
00359         wrk[n+1] = 0;
00360         if (channel_)
00361                 (void)Tcl_Write(channel_, wrk, n+1);
00362         wrk[n] = 0;
00363         return;
00364 }

01222 {
01223 
01224         switch (state_) {
01225         case TCPS_CLOSED:
01226         case TCPS_LISTEN:
01227         case TCPS_SYN_SENT:
01228                 state_ = TCPS_CLOSED;
01229                 break;
01230         case TCPS_SYN_RECEIVED:
01231         case TCPS_ESTABLISHED:
01232                 state_ = TCPS_FIN_WAIT_1;
01233                 send_much(1, REASON_NORMAL, 0);
01234                 break;
01235         }
01236         return;
01237 }

00752 {
00753         return (cwnd_ < wnd_ ? (int)cwnd_ : (int)wnd_);
00754 }

00757 {
00758         return (cwnd_ < wnd_ ? (double)cwnd_ : (double)wnd_);
00759 }

BayFullTcpAgent Class Reference

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation


Public Member Functions
	BayFullTcpAgent ()
	~BayFullTcpAgent ()
void	delay_bind_init_all ()
int	delay_bind_dispatch (const char varName, const char localName, TclObject *tracer)
virtual void	recv (Packet pkt, Handler )
virtual void	timeout (int tno)
void	advance (int)
int	advance (int, int)
int	command (int argc, const char const argv)
int	state ()
virtual void	recv (Packet p, const char s)
virtual void	timeout_nonrtx (int tno)
virtual void	sendmsg (int nbytes, const char *flags=0)
virtual void	sendmsg (int sz, AppData , const char flags=0)
void	trace (TracedVar *v)
virtual void	advanceby (int delta)
void	recvOnly (Packet *)
void	send (Packet p, Handler h)
virtual void	send (int sz, AppData *data)
virtual void	send (int nbytes)
virtual void	sendto (int sz, AppData , const char flags, nsaddr_t dst)
virtual void	sendto (int nbytes, const char *flags, nsaddr_t dst)
virtual void	connect (nsaddr_t dst)
virtual void	close ()
virtual void	attachApp (Application *app)
virtual int &	size ()
nsaddr_t &	addr ()
nsaddr_t &	port ()
nsaddr_t &	daddr ()
nsaddr_t &	dport ()
void	set_pkttype (packet_t pkttype)
packet_t	get_pkttype ()
NsObject *	target ()
virtual void	drop (Packet *p)
int	isdebug () const
virtual void	debug (const char *fmt,...)
Protected Member Functions
int	headersize ()
int	outflags ()
int	predict_ok (Packet *)
void	fast_retransmit (int)
double	now ()
void	reset_rtx_timer (int)
void	reset ()
void	reinit ()
void	connect ()
void	listen ()
void	usrclosed ()
int	need_send ()
void	sendpacket (int seqno, int ackno, int pflags, int datalen, int reason)
void	output (int seqno, int reason=0)
void	send_much (int force, int reason, int maxburst=0)
void	newack (Packet *pkt)
void	cancel_rtx_timeout ()
virtual int	window ()
virtual double	windowd ()
void	print_if_needed (double memb_time)
void	traceAll ()
virtual void	traceVar (TracedVar *v)
virtual void	rtt_init ()
virtual double	rtt_timeout ()
virtual void	rtt_update (double tao)
virtual void	rtt_backoff ()
virtual void	newtimer (Packet *)
virtual void	dupack_action ()
virtual void	send_one ()
double	linear (double x, double x_1, double y_1, double x_2, double y_2)
void	opencwnd ()
void	slowdown (int how)
void	ecn (int seqno)
virtual void	set_initial_window ()
double	initial_window ()
void	tcp_eln (Packet *pkt)
void	finish ()
void	reset_qoption ()
void	rtt_counting ()
int	network_limited ()
double	limited_slow_start (double cwnd, double max_ssthresh, double increment)
virtual int	numdupacks (double cwnd)
virtual void	processQuickStart (Packet *pkt)
virtual void	endQuickStart ()
virtual void	output_helper (Packet *)
virtual void	send_helper (int)
virtual void	send_idle_helper ()
virtual void	recv_helper (Packet *)
virtual void	recv_newack_helper (Packet *)
virtual void	partialnewack_helper (Packet *)
virtual void	cancel_timers ()
virtual void	cancel_rtx_timer ()
virtual void	set_rtx_timer ()
void	reset_rtx_timer (int mild, int backoff=1)
double	increase_param ()
double	decrease_param ()
double	compute_p ()
void	trace_event (char *eventtype)
void	closecwnd (int how)
void	quench (int how)
void	process_qoption_after_send ()
void	process_qoption_after_ack (int seqno)
virtual void	recvBytes (int bytes)
virtual void	idle ()
Packet *	allocpkt () const
Packet *	allocpkt (int) const
void	initpkt (Packet *) const
void	deleteAgentTrace ()
void	addAgentTrace (const char *name)
void	monitorAgentTrace ()
OldValue *	lookupOldValue (TracedVar *v)
void	insertOldValue (TracedVar v, const char value)
void	dumpTracedVars ()
virtual void	drop (Packet p, const char s)
void	handle (Event *)
Protected Attributes
int	segs_per_ack_
int	nodelay_
int	data_on_syn_
int	tcprexmtthresh_
int	iss_
int	dupseg_fix_
int	dupack_reset_
double	delack_interval_
int	maxseg_
int	flags_
int	state_
int	rcv_nxt_
BayReassemblyQueue	rq_
int	last_ack_sent_
int	close_on_empty_
BayTcpAppAgent *	app_
int	switch_spa_thresh_
int	first_data_
int	recover_cause_
BayDelAckTimer	delack_timer_
TracedInt	t_seqno_
TracedInt	t_rtt_
int	T_SRTT_BITS
TracedInt	t_srtt_
int	srtt_init_
int	T_RTTVAR_BITS
int	rttvar_exp_
TracedInt	t_rttvar_
int	rttvar_init_
double	t_rtxcur_
double	rtxcur_init_
TracedInt	t_backoff_
double	ts_peer_
RtxTimer	rtx_timer_
DelSndTimer	delsnd_timer_
BurstSndTimer	burstsnd_timer_
int	timerfix_
int	rfc2988_
double	boot_time_
double	overhead_
double	wnd_
double	wnd_const_
double	wnd_th_
double	wnd_init_
double	wnd_restart_
double	tcp_tick_
int	wnd_option_
int	wnd_init_option_
double	decrease_num_
double	increase_num_
double	k_parameter_
double	l_parameter_
int	precision_reduce_
int	syn_
int	delay_growth_
int	tcpip_base_hdr_size_
int	ts_option_size_
int	bug_fix_
int	less_careful_
int	ts_option_
int	maxburst_
int	maxcwnd_
int	numdupacks_
int	numdupacksFrac_
double	maxrto_
double	minrto_
int	old_ecn_
FILE *	plotfile_
TracedInt	dupacks_
TracedInt	curseq_
int	last_ack_
TracedInt	highest_ack_
int	recover_
int	last_cwnd_action_
TracedDouble	cwnd_
double	base_cwnd_
double	awnd_
TracedInt	ssthresh_
int	count_
double	fcnt_
int	rtt_active_
int	rtt_seq_
double	rtt_ts_
TracedInt	maxseq_
int	ecn_
int	cong_action_
int	ecn_burst_
int	ecn_backoff_
int	ect_
int	eln_
int	eln_rxmit_thresh_
int	eln_last_rxmit_
double	firstsent_
double	lastreset_
int	slow_start_restart_
int	restart_bugfix_
int	closed_
TracedInt	ndatapack_
TracedInt	ndatabytes_
TracedInt	nackpack_
TracedInt	nrexmit_
TracedInt	nrexmitpack_
TracedInt	nrexmitbytes_
TracedInt	necnresponses_
TracedInt	ncwndcuts_
int	trace_all_oneline_
int	nam_tracevar_
int	first_decrease_
TracedInt	singledup_
int	noFastRetrans_
int	oldCode_
int	useHeaders_
int	low_window_
int	high_window_
double	high_p_
double	high_decrease_
int	max_ssthresh_
double	cwnd_last_
double	increase_last_
double	cwnd_frac_
int	rate_request_
int	qs_enabled_
int	qs_requested_
int	qs_approved_
int	ttl_diff_
int	QOption_
int	EnblRTTCtr_
int	T_full
int	T_last
int	T_prev
int	T_start
int	RTT_count
int	RTT_prev
int	RTT_goodcount
int	F_counting
int	W_used
int	W_timed
int	F_full
int	Backoffs
int	control_increase_
int	prev_highest_ack_
ns_addr_t	here_
ns_addr_t	dst_
int	size_
packet_t	type_
int	fid_
int	prio_
int	defttl_
Tcl_Channel	channel_
char *	traceName_
OldValue *	oldValueList_
EventTrace *	et_
NsObject *	target_
NsObject *	drop_
int	debug_
Static Protected Attributes
int	uidcnt_