[SCM] GNU gnutls branch, master, updated. gnutls-3_0_12-170-ga64a322

[Nikos Mavrogiannopoulos]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU gnutls".

http://git.savannah.gnu.org/cgit/gnutls.git/commit/?id=a64a322efe490dd63bbdd200223fbf109a74d003

The branch, master has been updated
       via  a64a322efe490dd63bbdd200223fbf109a74d003 (commit)
       via  da8d27b70f8de28c32db41e008c70845f8499b88 (commit)
       via  d178d1336a4716ff7ed563dbf1b4e020a97894fd (commit)
       via  5707888216f9f5f7af5e33e3b67890e85e5343ee (commit)
      from  6a5cd65eb414de857af984ed8fb6ad6b17d02cc1 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit a64a322efe490dd63bbdd200223fbf109a74d003
Author: Nikos Mavrogiannopoulos <address@hidden>
Date:   Fri Feb 10 01:05:18 2012 +0100

    More robust behavior against packet loss

commit da8d27b70f8de28c32db41e008c70845f8499b88
Author: Nikos Mavrogiannopoulos <address@hidden>
Date:   Thu Feb 9 18:51:41 2012 +0100

    removed unneeded function.

commit d178d1336a4716ff7ed563dbf1b4e020a97894fd
Author: Nikos Mavrogiannopoulos <address@hidden>
Date:   Thu Feb 9 08:23:14 2012 +0100

    updated example

commit 5707888216f9f5f7af5e33e3b67890e85e5343ee
Author: Nikos Mavrogiannopoulos <address@hidden>
Date:   Thu Feb 9 08:13:28 2012 +0100

    updated

-----------------------------------------------------------------------

Summary of changes:
 doc/examples/ex-client-srp.c |    2 +-
 lib/gnutls_dtls.c            |  125 ++++++++++++++++++++----------------------
 lib/gnutls_record.c          |   29 +++++++---
 lib/system.c                 |    6 --
 lib/system.h                 |    2 -
 5 files changed, 81 insertions(+), 83 deletions(-)

diff --git a/doc/examples/ex-client-srp.c b/doc/examples/ex-client-srp.c
index 2ec86d4..7784075 100644
--- a/doc/examples/ex-client-srp.c
+++ b/doc/examples/ex-client-srp.c
@@ -82,7 +82,7 @@ main (void)
   gnutls_record_send (session, MSG, strlen (MSG));
 
   ret = gnutls_record_recv (session, buffer, MAX_BUF);
-  if (gnutls_error_is_fatal (ret) == 1 || ret == 0)
+  if (gnutls_error_is_fatal (ret) != 0 || ret == 0)
     {
       if (ret == 0)
         {
diff --git a/lib/gnutls_dtls.c b/lib/gnutls_dtls.c
index f6dcfac..6669064 100644
--- a/lib/gnutls_dtls.c
+++ b/lib/gnutls_dtls.c
@@ -157,9 +157,13 @@ int ret;
 
 }
 
-#define UPDATE_TIMER \
+#define UPDATE_TIMER { \
       session->internals.dtls.actual_retrans_timeout_ms *= 2; \
-      session->internals.dtls.actual_retrans_timeout_ms %= MAX_DTLS_TIMEOUT
+      session->internals.dtls.actual_retrans_timeout_ms %= MAX_DTLS_TIMEOUT; \
+    }
+
+#define RESET_TIMER \
+      session->internals.dtls.actual_retrans_timeout_ms = 
session->internals.dtls.retrans_timeout_ms
 
 /* This function transmits the flight that has been previously
  * buffered.
@@ -172,6 +176,7 @@ _dtls_transmit (gnutls_session_t session)
 {
 int ret;
 uint8_t* buf = NULL;
+unsigned int timeout;
 
   /* PREPARING -> SENDING state transition */
   mbuffer_head_st *const send_buffer =
@@ -184,13 +189,17 @@ uint8_t* buf = NULL;
    * non blocking way, check if it is time to retransmit or just
    * return.
    */
-
   if (session->internals.dtls.flight_init != 0 && 
session->internals.dtls.blocking == 0)
     {
       /* just in case previous run was interrupted */
       ret = _gnutls_io_write_flush (session);
+      if (ret < 0)
+        {
+          gnutls_assert();
+          goto cleanup;
+        }
 
-      if (session->internals.dtls.last_flight == 0)
+      if (session->internals.dtls.last_flight == 0 || !_dtls_is_async(session))
         {
           /* check for ACK */
           ret = _gnutls_io_check_recv(session, 0);
@@ -198,8 +207,8 @@ uint8_t* buf = NULL;
             {
               /* if no retransmission is required yet just return 
                */
-              if (now-session->internals.dtls.handshake_start_time < 
-                  session->internals.dtls.actual_retrans_timeout_ms/1000)
+              if (1000*(now-session->internals.dtls.handshake_start_time) < 
+                  session->internals.dtls.actual_retrans_timeout_ms)
                 {
                   session->internals.dtls.handshake_last_call = now;
                   goto nb_timeout;
@@ -215,55 +224,49 @@ uint8_t* buf = NULL;
 
   do 
     {
-      if (now-session->internals.dtls.handshake_start_time >= 
session->internals.dtls.total_timeout_ms/1000) 
+      if (1000*(now-session->internals.dtls.handshake_start_time) >= 
session->internals.dtls.total_timeout_ms) 
         {
           ret = gnutls_assert_val(GNUTLS_E_TIMEDOUT);
           goto cleanup;
         }
-        
-      if ((session->internals.dtls.flight_init == 0) ||
-          (now - session->internals.dtls.last_retransmit > RETRANSMIT_WINDOW))
-        {
-          session->internals.dtls.last_retransmit = now;
 
-          _gnutls_dtls_log ("DTLS[%p]: %sStart of flight transmission.\n", 
session,  (session->internals.dtls.flight_init == 0)?"":"re-");
+      _gnutls_dtls_log ("DTLS[%p]: %sStart of flight transmission.\n", 
session,  (session->internals.dtls.flight_init == 0)?"":"re-");
 
-          for (cur = send_buffer->head;
-               cur != NULL; cur = cur->next)
+      for (cur = send_buffer->head;
+           cur != NULL; cur = cur->next)
+        {
+          ret = transmit_message (session, cur, &buf);
+          if (ret < 0)
             {
-              ret = transmit_message (session, cur, &buf);
-              if (ret < 0)
-                {
-                  gnutls_assert();
-                  goto cleanup;
-                }
-
-              last_type = cur->htype;
+              gnutls_assert();
+              goto cleanup;
             }
 
-          if (buf != NULL)
-            {
-              gnutls_free(buf);
-              buf = NULL;
-            }
+          last_type = cur->htype;
+        }
 
-          if (session->internals.dtls.flight_init == 0)
-            {
-              session->internals.dtls.flight_init = 1;
-              session->internals.dtls.handshake_last_call = now;
-              session->internals.dtls.actual_retrans_timeout_ms = 
session->internals.dtls.retrans_timeout_ms;
+      if (session->internals.dtls.flight_init == 0)
+        {
+          session->internals.dtls.flight_init = 1;
+          session->internals.dtls.handshake_last_call = now;
+          RESET_TIMER;
+          timeout = session->internals.dtls.actual_retrans_timeout_ms;
 
-              if (last_type == GNUTLS_HANDSHAKE_FINISHED)
-                {
-                  /* On the last flight we cannot ensure retransmission
-                   * from here. _dtls_wait_and_retransmit() is being called
-                   * by handshake.
-                   */
-                  session->internals.dtls.last_flight = 1;
-                }
-              else
-                session->internals.dtls.last_flight = 0;
-           }
+          if (last_type == GNUTLS_HANDSHAKE_FINISHED)
+            {
+              /* On the last flight we cannot ensure retransmission
+               * from here. _dtls_wait_and_retransmit() is being called
+               * by handshake.
+               */
+              session->internals.dtls.last_flight = 1;
+            }
+          else
+            session->internals.dtls.last_flight = 0;
+        }
+      else
+        {
+          timeout = session->internals.dtls.actual_retrans_timeout_ms;
+          UPDATE_TIMER;
         }
 
       ret = _gnutls_io_write_flush (session);
@@ -283,19 +286,17 @@ uint8_t* buf = NULL;
       else /* all other messages -> implicit ack (receive of next flight) */
         {
           if (session->internals.dtls.blocking != 0)
-            ret = _gnutls_io_check_recv(session, 
session->internals.dtls.actual_retrans_timeout_ms);
+            ret = _gnutls_io_check_recv(session, timeout);
           else
             {
               ret = _gnutls_io_check_recv(session, 0);
               if (ret == GNUTLS_E_TIMEDOUT)
                 {
-                  UPDATE_TIMER;
                   goto nb_timeout;
                 }
             }
         }
 
-      UPDATE_TIMER;
       now = gnutls_time (0);
     } while(ret == GNUTLS_E_TIMEDOUT);
 
@@ -320,6 +321,9 @@ cleanup:
   return ret;
 
 nb_timeout:
+  if (buf != NULL)
+    gnutls_free(buf);
+
   RETURN_DTLS_EAGAIN_OR_TIMEOUT(session);
 }
 
@@ -335,8 +339,6 @@ int ret;
   else
     ret = _gnutls_io_check_recv(session, 0);
 
-  UPDATE_TIMER;
-      
   if (ret == GNUTLS_E_TIMEDOUT)
     {
       ret = _dtls_retransmit(session);
@@ -344,6 +346,8 @@ int ret;
         {
           RETURN_DTLS_EAGAIN_OR_TIMEOUT(session);
         }
+      else
+        return gnutls_assert_val(ret);
     }
 
   return 0;
@@ -404,28 +408,19 @@ unsigned int i, offset = 0;
       if (diff >= window_size) 
         {
           /* Probably an epoch change. Check if we can fit it */
-          if (window_table[0] == 0)
+          if (window_table[0] == 0 || window_table[0]+1 == seq)
             {
               window_table[0] = seq;
               return 0;
             }
           
-          for (i=0;i<window_size-1;i++)
-            {
-              if (seq == window_table[i])
-                return -1;
-              if (seq == window_table[i] + 1)
-                {
-                  if (seq == window_table[i+1])
-                    return -1;
-                  window_table[i+1] = seq;
-                  return 0;
-                }
-            }
-          return -1;
-        }
+          if ((window_size-2)/2 < 2)
+            return -1;
 
-      offset = window_size-1-diff;
+          offset = 1 + seq % ((window_size-2)/2);
+        }
+      else
+        offset = window_size-1-diff;
 
       if (window_table[offset] == seq)
         return -1;
diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index a7008c0..d55fb04 100644
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -678,7 +678,11 @@ record_add_to_buffers (gnutls_session_t session,
               if (_dtls_is_async(session) && _dtls_async_timer_active(session))
                 {
                   ret = _dtls_retransmit(session);
-                  if (ret == 0) ret = GNUTLS_E_AGAIN;
+                  if (ret == 0) 
+                    {
+                      ret = gnutls_assert_val(GNUTLS_E_AGAIN);
+                      goto unexpected_packet;
+                    }
                   goto cleanup;
                 }
             }
@@ -861,9 +865,9 @@ gnutls_datum_t raw; /* raw headers */
     {
       if (_gnutls_epoch_is_valid(session, record->epoch) == 0)
         {
-          _gnutls_audit_log(session, "Discarded message[%u] with invalid epoch 
0x%.2x%.2x.\n",
-            (unsigned int)_gnutls_uint64touint32 (&record->sequence), 
(int)record->sequence.i[0], 
-            (int)record->sequence.i[1]);
+          _gnutls_audit_log(session, "Discarded message[%u] with invalid epoch 
%u.\n",
+            (unsigned int)_gnutls_uint64touint32 (&record->sequence), 
+            (unsigned int)record->sequence.i[0]*256+(unsigned 
int)record->sequence.i[1]);
           gnutls_assert();
           /* doesn't matter, just a fatal error */
           return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
@@ -1024,12 +1028,19 @@ begin:
             (unsigned int) _gnutls_uint64touint32 (packet_sequence), 
_gnutls_packet2str (record.type));
           goto sanity_check_error;
         }
+      _gnutls_record_log
+        ("REC[%p]: Decrypted Packet[%u.%u] %s(%d) with length: %d\n", session,
+        (unsigned int)record.sequence.i[0]*256 +(unsigned 
int)record.sequence.i[1],
+        (unsigned int) _gnutls_uint64touint32 (packet_sequence),
+        _gnutls_packet2str (record.type), record.type, 
(int)_mbuffer_get_udata_size(decrypted));
+    }
+  else
+    {
+      _gnutls_record_log
+        ("REC[%p]: Decrypted Packet[%u] %s(%d) with length: %d\n", session,
+        (unsigned int) _gnutls_uint64touint32 (packet_sequence),
+        _gnutls_packet2str (record.type), record.type, 
(int)_mbuffer_get_udata_size(decrypted));
     }
-
-  _gnutls_record_log
-    ("REC[%p]: Decrypted Packet[%d] %s(%d) with length: %d\n", session,
-     (int) _gnutls_uint64touint32 (packet_sequence),
-     _gnutls_packet2str (record.type), record.type, 
(int)_mbuffer_get_udata_size(decrypted));
 
   /* increase sequence number 
    */
diff --git a/lib/system.c b/lib/system.c
index 476b313..0829759 100644
--- a/lib/system.c
+++ b/lib/system.c
@@ -111,12 +111,6 @@ system_read (gnutls_transport_ptr_t ptr, void *data, 
size_t data_size)
   return recv (GNUTLS_POINTER_TO_INT (ptr), data, data_size, 0);
 }
 
-ssize_t
-system_read_peek (gnutls_transport_ptr_t ptr, void *data, size_t data_size)
-{
-  return recv (GNUTLS_POINTER_TO_INT (ptr), data, data_size, MSG_PEEK);
-}
-
 /* Wait for data to be received within a timeout period in milliseconds.
  * If data_size > 0 it will return the specified amount of data in
  * peek mode.
diff --git a/lib/system.h b/lib/system.h
index 0d2f5a5..0178bd5 100644
--- a/lib/system.h
+++ b/lib/system.h
@@ -43,8 +43,6 @@ ssize_t system_writev (gnutls_transport_ptr_t ptr, const 
giovec_t * iovec,
                        int iovec_cnt);
 #endif
 ssize_t system_read (gnutls_transport_ptr_t ptr, void *data, size_t data_size);
-ssize_t system_read_peek (gnutls_transport_ptr_t ptr, void *data,
-                          size_t data_size);
 
 #ifdef _WIN32
 #define HAVE_WIN32_LOCKS


hooks/post-receive
-- 
GNU gnutls