linux-decnet-commit Mailing List for DECnet for Linux (Page 39)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/linux-decnet/latd
In directory usw-pr-cvs1:/tmp/cvs-serv11749

Modified Files:
	connection.cc connection.h 
Log Message:
Completely rewritten SEQ/ACK logic so it's readable and also works reliably -
even on bad networks.

Not quite finished yet but quite near.

Index: connection.cc
===================================================================
RCS file: /cvsroot/linux-decnet/latd/connection.cc,v
retrieving revision 1.40
retrieving revision 1.41
diff -C2 -r1.40 -r1.41
*** connection.cc	16 Feb 2002 16:27:47 -0000	1.40
--- connection.cc	28 Feb 2002 17:52:43 -0000	1.41
***************
*** 51,56 ****
      interface(_interface),
      keepalive_timer(0),
!     last_sequence_number(_ack),
!     last_ack_number(_seq),
      last_time(0L),
      queued_slave(false),
--- 51,58 ----
      interface(_interface),
      keepalive_timer(0),
!     last_sent_seq(0xff),
!     last_sent_ack(0),
!     last_recv_seq(_seq),
!     last_recv_ack(_ack),
      last_time(0L),
      queued_slave(false),
***************
*** 63,68 ****
      LAT_Start *msg = (LAT_Start *)buf;

!     debuglog(("New connection: (c: %x, s: %x)\n",
!              last_sequence_number, last_ack_number));

      get_string(buf, &ptr, servicename); // This is actually local nodename
--- 65,70 ----
      LAT_Start *msg = (LAT_Start *)buf;

!     debuglog(("New connection: (s: %x, a: %x)\n",
!              last_recv_seq, last_recv_ack));

      get_string(buf, &ptr, servicename); // This is actually local nodename
***************
*** 76,80 ****
      highest_session = 1;
      max_window_size = msg->exqueued+1;
!     max_window_size = 1; // All we can manage
      window_size = 0;
      lat_eco = msg->latver_eco;
--- 78,82 ----
      highest_session = 1;
      max_window_size = msg->exqueued+1;
!     max_window_size = 1; // PJC All we can manage
      window_size = 0;
      lat_eco = msg->latver_eco;
***************
*** 96,101 ****
      num(_num),
      keepalive_timer(0),
!     last_sequence_number(0xff),
!     last_ack_number(0xff),
      last_time(0L),
      queued(queued),
--- 98,105 ----
      num(_num),
      keepalive_timer(0),
!     last_sent_seq(0xff),
!     last_sent_ack(0),
!     last_recv_seq(0),
!     last_recv_ack(0xff),
      last_time(0L),
      queued(queued),
***************
*** 113,119 ****
      strcpy(lta_name, _lta);

!     max_slots_per_packet = 4; // TODO: Calculate // PJC Test
      max_window_size = 1;      // Gets overridden later on.
!     window_size = 0 ;
      next_session = 1;
      highest_session = 1;
--- 117,123 ----
      strcpy(lta_name, _lta);

!     max_slots_per_packet = 4;
      max_window_size = 1;      // Gets overridden later on.
!     window_size = 0;
      next_session = 1;
      highest_session = 1;
***************
*** 142,171 ****
  	reply[ri] = (LAT_SlotCmd *)replybuf[ri];

-     window_size--;
-     if (window_size < 0) window_size=0;
- 
-     // For duplicate checking
-     unsigned char saved_last_sequence_number = last_sequence_number;
-     unsigned char saved_last_message_acked   = last_message_acked;
- 
-     last_sequence_number = msg->header.ack_number;
-     last_message_acked   = msg->header.sequence_number;
- 
  #ifdef REALLY_VERBOSE_DEBUGLOG
!     debuglog(("MSG:      seq: %d,        ack: %d\n",
! 	      msg->header.sequence_number, msg->header.ack_number));

      debuglog(("PREV:last seq: %d,   last ack: %d\n",
! 	      last_sent_sequence, last_ack_number));
  #endif

      // Is this a duplicate?
!     if (saved_last_sequence_number == last_sequence_number &&
! 	saved_last_message_acked == last_message_acked)
      {
! 	debuglog(("Duplicate packet received...ignoring it\n"));
  	return false;
      }

      // No blocks? just ACK it (if we're a server)
      if (msg->header.num_slots == 0)
--- 146,191 ----
  	reply[ri] = (LAT_SlotCmd *)replybuf[ri];

  #ifdef REALLY_VERBOSE_DEBUGLOG
!     debuglog(("MSG:      seq: %d,        ack: %d (last sent seq = %d)\n",
! 	      msg->header.sequence_number, msg->header.ack_number, last_sent_seq));

      debuglog(("PREV:last seq: %d,   last ack: %d\n",
! 	      last_recv_seq, last_recv_ack));
  #endif

      // Is this a duplicate?
!     if (msg->header.ack_number == last_recv_ack &&
! 	msg->header.sequence_number == last_recv_seq)
      {
! 	debuglog(("Duplicate packet received...resending ACK\n"));
! 
!         // But still send an ACK as it could be the ACK that went missing
! 	last_ack_message.send(interface, macaddr);
! 
! 	// If the last DATA message wasn't seen either then resend that too
! 	if (last_message.get_seq() != msg->header.ack_number)
! 	    last_message.send(interface, macaddr);
  	return false;
      }

+     // PJC: Not sure about this
+     if (msg->header.ack_number != last_sent_seq)
+     {
+ 	debuglog(("Got ack for old message, resending ACK\n"));
+ 	last_ack_message.send(interface, macaddr);
+ 
+ 	// If the last DATA message wasn't seen either then resend that too
+ 	if (last_message.get_seq() != msg->header.ack_number)
+ 	    last_message.send(interface, macaddr);
+     }
+ 
+ 
+     window_size--;
+     if (window_size < 0) window_size = 0;
+ 
+     need_ack = false;
+     last_recv_ack = msg->header.ack_number;
+     last_recv_seq = msg->header.sequence_number;
+ 
      // No blocks? just ACK it (if we're a server)
      if (msg->header.num_slots == 0)
***************
*** 429,433 ****

      // Send any replies
-     last_ack_number = last_message_acked;
      if (replyhere || num_replies)
      {
--- 449,452 ----
***************
*** 448,452 ****
  	}

! 	send_message(replybuf, ptr, REPLY);
  	return true;
      }
--- 467,484 ----
  	}

! 	if (window_size < max_window_size)
! 	{
! 	    send_message(replybuf, ptr, REPLY);
! 	}
! 	else
! 	{
! 	    header->local_connid    = num;
! 	    header->remote_connid   = remote_connid;
! 	    header->sequence_number = ++last_sent_seq;
! 	    header->ack_number      = last_recv_seq;
! 
! 	    pending.push(pending_msg(replybuf, len, false));
! 	}
! 
  	return true;
      }
***************
*** 494,522 ****
      if (type == DATA)
      {
- 	retransmit_count = 0;
- 	window_size++;
- 	debuglog(("send_message, window_size now %d\n", window_size));
  	need_ack = true;
      }

-     if (type == REPLY)
-     {
- 	need_ack = false;
-     }
- 
-     last_sequence_number++;
-     last_sent_sequence = last_sequence_number;
- 
      response->local_connid    = num;
      response->remote_connid   = remote_connid;
!     response->sequence_number = last_sequence_number;
!     response->ack_number      = last_ack_number;

!     debuglog(("Sending message for connid %d (seq: %d, ack: %d, needack: %d)\n",
! 	      num, last_sequence_number, last_ack_number, (type==DATA) ));

      keepalive_timer = 0;

!     if (type == DATA) last_message = pending_msg(buf, len, (type==DATA) );
      return LATServer::Instance()->send_message(buf, len, interface, macaddr);
  }
--- 526,551 ----
      if (type == DATA)
      {
  	need_ack = true;
+ 	window_size++;
      }

      response->local_connid    = num;
      response->remote_connid   = remote_connid;
!     response->sequence_number = ++last_sent_seq;
!     response->ack_number      = last_recv_seq;
! 
!     retransmit_count = 0;
!     last_sent_ack = last_recv_seq;

!     debuglog(("Sending message for connid %d (seq: %d, ack: %d) window=%d\n",
! 	      num, last_sent_seq, last_sent_ack, window_size ));

      keepalive_timer = 0;

!     if (type == DATA)
! 	last_message = pending_msg(buf, len, true);
!     else
! 	last_ack_message =  pending_msg(buf, len, false);
! 
      return LATServer::Instance()->send_message(buf, len, interface, macaddr);
  }
***************
*** 530,535 ****
      response->local_connid    = num;
      response->remote_connid   = remote_connid;
!     response->sequence_number = last_sequence_number;
!     response->ack_number      = last_ack_number;

      debuglog(("Queued messsge for connid %d\n", num));
--- 559,563 ----
      response->local_connid    = num;
      response->remote_connid   = remote_connid;
!     // SEQ and ACK filled in when we send it

      debuglog(("Queued messsge for connid %d\n", num));
***************
*** 604,610 ****
  void LATConnection::circuit_timer(void)
  {

      // Increment keepalive timer and trigger it if we are getting too close.
!     // Keepalive time is help in milli-seconds.

      // Of course, we needn't send keepalive messages when we are a
--- 632,671 ----
  void LATConnection::circuit_timer(void)
  {
+     // Did we get an ACK for our last message?
+     if (need_ack && last_sent_seq != last_recv_ack)
+     {
+ 	if (++retransmit_count > LATServer::Instance()->get_retransmit_limit())
+ 	{
+ 	    debuglog(("hit retransmit limit on connection %d\n", num));
+ 
+ 	    unsigned char buf[1600];
+ 	    LAT_Header *header = (LAT_Header *)buf;
+ 	    int ptr = sizeof(LAT_Header);
+ 
+ 	    header->cmd             = LAT_CCMD_DISCON;
+ 	    header->num_slots       = 0;
+ 	    header->local_connid    = num;
+ 	    header->remote_connid   = remote_connid;
+ 	    header->sequence_number = ++last_sent_seq;
+ 	    header->ack_number      = last_recv_seq;
+ 	    buf[ptr++] = 0x06; // Retransmission limit reached.
+ 	    LATServer::Instance()->send_message(buf, ptr, interface, macaddr);
+ 
+ 	    // Set this connection pending deletion
+ 	    LATServer::Instance()->delete_connection(num);
+ 
+ 	    // Mark this node as unavailable in the service list
+ 	    LATServices::Instance()->remove_node(std::string((char *)remnode));
+ 	    return;
+ 	}
+ 	debuglog(("Last message not ACKed: RESEND\n"));
+ 	last_message.send(interface, macaddr);
+ 	return;
+     }
+ 
+     retransmit_count = 0;

      // Increment keepalive timer and trigger it if we are getting too close.
!     // Keepalive timer is held in milli-seconds.

      // Of course, we needn't send keepalive messages when we are a
***************
*** 651,655 ****

  	    if (role == CLIENT) reply->header.cmd = LAT_CCMD_SESSION | 2;
- 	    window_size = 0;
  	    send_message(replybuf, sizeof(LAT_SessionReply), DATA);
  	    return;
--- 712,715 ----
***************
*** 657,697 ****
      }

-     // Did we get an ACK for our last message?
-     if (need_ack && last_sequence_number != last_sent_sequence)
-     {
- 	if (++retransmit_count > LATServer::Instance()->get_retransmit_limit())
- 	{
- 	    debuglog(("hit retransmit limit on connection %d\n", num));
- 	    need_ack = false;
- 
- 	    unsigned char buf[1600];
- 	    LAT_Header *header = (LAT_Header *)buf;
- 	    int ptr=sizeof(LAT_Header);
- 
- 	    header->cmd             = LAT_CCMD_DISCON;
- 	    header->num_slots       = 0;
- 	    header->local_connid    = num;
- 	    header->remote_connid   = remote_connid;
- 	    header->sequence_number = last_sequence_number;
- 	    header->ack_number      = last_ack_number;
- 	    buf[ptr++] = 0x06; // Retransmission limit reached.
- 	    LATServer::Instance()->send_message(buf, ptr, interface, macaddr);
- 
- 	    LATServer::Instance()->delete_connection(num);
- 
- 	    // Mark this node as unavailable in the service list
- 	    LATServices::Instance()->remove_node(std::string((char *)remnode));
- 	    return;
- 	}
- 	debuglog(("Last message not ACKed: RESEND\n"));
- 	last_message.send(interface, macaddr);
- 	return;
-     }
-     else
-     {
- 	retransmit_count = 0;
- 	need_ack = false;
-     }
- 
      // Poll our sessions
      for (unsigned int i=0; i<=highest_session; i++)
--- 717,720 ----
***************
*** 707,711 ****
          unsigned char buf[1600];
          LAT_Header *header = (LAT_Header *)buf;
!         int len=sizeof(LAT_Header);
  	if (role == SERVER)
  	    header->cmd         = LAT_CCMD_SDATA;
--- 730,735 ----
          unsigned char buf[1600];
          LAT_Header *header = (LAT_Header *)buf;
!         int len = sizeof(LAT_Header);
! 
  	if (role == SERVER)
  	    header->cmd         = LAT_CCMD_SDATA;
***************
*** 713,720 ****
  	    header->cmd         = LAT_CCMD_SESSION;
          header->num_slots       = 0;
-         header->local_connid    = num;
-         header->remote_connid   = remote_connid;
-         header->sequence_number = last_sequence_number;
-         header->ack_number      = last_ack_number;

  	// Send as many slot data messages as we can
--- 737,740 ----
***************
*** 727,737 ****
              memcpy(buf+len, cmd.get_buf(), cmd.get_len());
              len += cmd.get_len();
!             if (len%2) len++;// Keep it on even boundary

              slots_pending.pop();
          }
  	if (header->num_slots)
  	{
! 	    debuglog(("Sending %d slots on circuit timer\n", header->num_slots));
  	    pending.push(pending_msg(buf, len, true));
  	}
--- 747,762 ----
              memcpy(buf+len, cmd.get_buf(), cmd.get_len());
              len += cmd.get_len();
!             if (len%2) len++;    // Keep it on even boundary

              slots_pending.pop();
          }
+ 
  	if (header->num_slots)
  	{
! 	    header->local_connid    = num;
! 	    header->remote_connid   = remote_connid;
! 	    // SEQ and ACK filled in when we send it
! 
! 	    debuglog(("Collected %d slots on circuit timer\n", header->num_slots));
  	    pending.push(pending_msg(buf, len, true));
  	}
***************
*** 741,770 ****
      if (!pending.empty())
      {
!       debuglog(("Window size: %d, max %d\n", window_size, max_window_size));
      }
  #endif

      //  Send a pending message (if we can)
!     if (!pending.empty() && window_size < max_window_size)
      {
          // Send the top message
          pending_msg &msg(pending.front());

-         last_sequence_number++;
-         last_sent_sequence = last_sequence_number;
-         need_ack = msg.needs_ack();
  	retransmit_count = 0;

          LAT_Header *header      = msg.get_header();
!         header->sequence_number = last_sequence_number;
!         header->ack_number      = last_ack_number;

!         debuglog(("Sending message on circuit timer: seq: %d, ack: %d (need_ack: %d)\n",
! 		  last_sequence_number, last_ack_number, need_ack));

          msg.send(interface, macaddr);
  	last_message = msg; // Save it in case it gets lost on the wire;
          pending.pop();
- 	window_size++;
  	keepalive_timer = 0;
      }
--- 766,794 ----
      if (!pending.empty())
      {
! 	debuglog(("Pending messages. Window size: %d, max %d. last_ack=%d, last_seq=%d\n",
! 		  window_size, max_window_size, last_recv_ack, last_sent_seq));
      }
  #endif

      //  Send a pending message (if we can)
!     if (!pending.empty() && window_size < max_window_size)// &&
! //	last_sent_seq - last_recv_ack < max_window_size)
      {
          // Send the top message
          pending_msg &msg(pending.front());

  	retransmit_count = 0;
+ 	need_ack = true;

          LAT_Header *header      = msg.get_header();
!         header->sequence_number = ++last_sent_seq;
!         header->ack_number      = last_recv_seq;

!         debuglog(("Sending message on circuit timer: seq: %d, ack: %d\n",
! 		  last_sent_seq, last_sent_ack));

          msg.send(interface, macaddr);
  	last_message = msg; // Save it in case it gets lost on the wire;
          pending.pop();
  	keepalive_timer = 0;
      }
***************
*** 863,868 ****

  	// Reset the sequence & ack numbers
! 	last_sequence_number = 0xff;
! 	last_ack_number = 0xff;
  	remote_connid = 0;
  	interface = this_int;
--- 887,894 ----

  	// Reset the sequence & ack numbers
! 	last_recv_seq = 0xff;
! 	last_recv_ack = 0;
! 	last_sent_seq = 0xff;
! 	last_sent_ack = 0;
  	remote_connid = 0;
  	interface = this_int;
***************
*** 999,1013 ****
      remote_connid = reply->header.local_connid;

!     last_sequence_number = reply->header.ack_number;
!     last_message_acked   = reply->header.sequence_number;
!     last_ack_number = last_message_acked;
      connected = true;
      connecting = false;

      max_window_size = reply->exqueued+1;
!     max_window_size = 1; // All we can manage

      debuglog(("got connect ack. seq: %d, ack: %d\n",
! 	      last_sequence_number, last_message_acked));

  // Start clientsessions
--- 1025,1041 ----
      remote_connid = reply->header.local_connid;

!     last_recv_ack = reply->header.ack_number;
!     last_recv_seq = reply->header.sequence_number;
! 
      connected = true;
      connecting = false;

      max_window_size = reply->exqueued+1;
!     max_window_size = 1; // PJC All we can manage
!     window_size = 0;
!     need_ack = false;

      debuglog(("got connect ack. seq: %d, ack: %d\n",
! 	      last_recv_seq, last_recv_ack));

  // Start clientsessions

Index: connection.h
===================================================================
RCS file: /cvsroot/linux-decnet/latd/connection.h,v
retrieving revision 1.22
retrieving revision 1.23
diff -C2 -r1.22 -r1.23
*** connection.h	15 Feb 2002 13:24:13 -0000	1.22
--- connection.h	28 Feb 2002 17:52:43 -0000	1.23
***************
*** 61,66 ****
      int            remote_connid; // Remote Connection ID
      int            keepalive_timer; // Counting up.
!     unsigned char  last_sequence_number;
!     unsigned char  last_ack_number;
      unsigned int   next_session;
      unsigned int   highest_session;
--- 61,68 ----
      int            remote_connid; // Remote Connection ID
      int            keepalive_timer; // Counting up.
!     unsigned char  last_sent_seq;
!     unsigned char  last_sent_ack;
!     unsigned char  last_recv_seq;
!     unsigned char  last_recv_ack;
      unsigned int   next_session;
      unsigned int   highest_session;
***************
*** 72,77 ****
      LATSession    *sessions[256];

-     unsigned char  last_sent_sequence; // Last sequence number we sent
-     unsigned char  last_message_acked;
      bool           need_ack;
      bool           queued;             // Client for queued connection.
--- 74,77 ----
***************
*** 95,112 ****
        pending_msg() {}
        pending_msg(unsigned char *_buf, int _len, bool _need_ack):
! 	len(_len),
!         need_ack(_need_ack)
  	{
  	    memcpy(buf, _buf, len);
  	}
        pending_msg(const pending_msg &msg):
! 	len(msg.len),
! 	need_ack(msg.need_ack)
! 	{
! 	    memcpy(buf, msg.buf, len);
! 	}
        ~pending_msg()
! 	{
! 	}

        pending_msg &operator=(const pending_msg &a)
--- 95,112 ----
        pending_msg() {}
        pending_msg(unsigned char *_buf, int _len, bool _need_ack):
! 	  len(_len),
! 	  need_ack(_need_ack)
  	{
  	    memcpy(buf, _buf, len);
  	}
        pending_msg(const pending_msg &msg):
! 	  len(msg.len),
! 	  need_ack(msg.need_ack)
!       {
! 	  memcpy(buf, msg.buf, len);
!       }
        ~pending_msg()
!        {
!        }

        pending_msg &operator=(const pending_msg &a)
***************
*** 130,133 ****
--- 130,134 ----
        LAT_Header *get_header() { return (LAT_Header *)buf;}
        bool needs_ack() { return need_ack;}
+       unsigned char get_seq() { LAT_Header *h=(LAT_Header *)buf; return h->sequence_number;}

      private:
***************
*** 175,178 ****
--- 176,180 ----
      int max_slots_per_packet;
      pending_msg last_message; // In case we need to resend it.
+     pending_msg last_ack_message; // In case we need to resend it.
      int retransmit_count;

2001	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct (15)	Nov (16)	Dec (6)
2002	Jan (20)	Feb (27)	Mar (25)	Apr (12)	May (2)	Jun (6)	Jul (36)	Aug (12)	Sep (12)	Oct (16)	Nov (5)	Dec (5)
2003	Jan (8)	Feb (9)	Mar (25)	Apr (18)	May (29)	Jun (4)	Jul (1)	Aug	Sep (10)	Oct (5)	Nov (3)	Dec (9)
2004	Jan (17)	Feb	Mar (9)	Apr	May (4)	Jun (1)	Jul (2)	Aug (21)	Sep	Oct	Nov	Dec (1)
2005	Jan (5)	Feb	Mar (13)	Apr	May (3)	Jun (1)	Jul	Aug	Sep (13)	Oct (83)	Nov (2)	Dec
2006	Jan (21)	Feb (1)	Mar (32)	Apr (31)	May (3)	Jun (1)	Jul	Aug (7)	Sep	Oct (1)	Nov (3)	Dec (13)
2007	Jan (1)	Feb (7)	Mar	Apr (2)	May	Jun (1)	Jul (2)	Aug (20)	Sep	Oct	Nov	Dec (7)
2008	Jan (4)	Feb (13)	Mar (24)	Apr (18)	May (10)	Jun	Jul	Aug (40)	Sep (72)	Oct (61)	Nov (9)	Dec (2)
2009	Jan (6)	Feb (1)	Mar	Apr	May	Jun (7)	Jul	Aug	Sep	Oct (8)	Nov	Dec (3)
2010	Jan	Feb	Mar	Apr (5)	May	Jun	Jul (41)	Aug (28)	Sep (2)	Oct (5)	Nov (4)	Dec
2011	Jan (7)	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

linux-decnet-commit Mailing List for DECnet for Linux (Page 39)

linux-decnet-commit — CVS commits to the DECnet project