Added gnutls_dtls_g/set_mtu() to allow setting and getting the DTLS mtu from application.

diff --git a/lib/gnutls_cipher.c b/lib/gnutls_cipher.c
index 0f569c3162ea4e4909f66aecae2cb3db4760e7e0..0e4e0f362d54e0bef8dbd1a81945e1e8f959e798 100644 (file)
--- a/lib/gnutls_cipher.c
+++ b/lib/gnutls_cipher.c
@@ -187,7 +187,7 @@ _gnutls_decrypt (gnutls_session_t session, opaque * ciphertext,
           return ret;
         }
 
-      if (gtxt.size > MAX_RECORD_RECV_SIZE)
+      if (gtxt.size > MAX_RECORD_RECV_SIZE(session))
         {
           _gnutls_free_datum (&gtxt);
           /* This shouldn't have happen and
@@ -197,7 +197,7 @@ _gnutls_decrypt (gnutls_session_t session, opaque * ciphertext,
         }
 
       /* This check is not really needed */
-      if (max_data_size < MAX_RECORD_RECV_SIZE)
+      if (max_data_size < MAX_RECORD_RECV_SIZE(session))
         {
           _gnutls_free_datum (&gtxt);
           return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);

diff --git a/lib/gnutls_compress.c b/lib/gnutls_compress.c
index 2520832edd9749a30b4b0c144f3e71e6f3e28855..b0f67ce5ed5ea07b2a4dd17e8e1fe63df7b2e92e 100644 (file)
--- a/lib/gnutls_compress.c
+++ b/lib/gnutls_compress.c
@@ -48,7 +48,7 @@ _gnutls_m_plaintext2compressed (gnutls_session_t session,
   size =
     _gnutls_compress (params->write.compression_state,
                       plaintext->data, plaintext->size, &data,
-                      MAX_RECORD_SEND_SIZE + EXTRA_COMP_SIZE);
+                      MAX_RECORD_SEND_SIZE(session) + EXTRA_COMP_SIZE);
   if (size < 0)
     {
       gnutls_assert ();
@@ -72,7 +72,7 @@ _gnutls_m_compressed2plaintext (gnutls_session_t session,
   size =
     _gnutls_decompress (params->read.compression_state,
                         compressed->data, compressed->size, &data,
-                        MAX_RECORD_RECV_SIZE);
+                        MAX_RECORD_RECV_SIZE(session));
   if (size < 0)
     {
       gnutls_assert ();

diff --git a/lib/gnutls_dtls.c b/lib/gnutls_dtls.c
index 43ce1e824c822cf87ffa1a63676e29aedd8cb03c..7c2ddfa7bf22c7e014690fdf3f67054dc8de8115 100644 (file)
--- a/lib/gnutls_dtls.c
+++ b/lib/gnutls_dtls.c
@@ -45,7 +45,7 @@ transmit_message (gnutls_session_t session,
   opaque *data, *mtu_data;
   int ret = 0;
   unsigned int offset, frag_len, data_size;
-  const uint mtu = session->internals.dtls.hsk_mtu;
+  const uint mtu = session->internals.dtls.mtu;
 
   if (bufel->htype == GNUTLS_HANDSHAKE_CHANGE_CIPHER_SPEC)
     {
@@ -235,3 +235,31 @@ void gnutls_dtls_set_timeouts (gnutls_session_t session, unsigned int retrans_ti
   session->internals.dtls.retrans_timeout  = retrans_timeout;
   session->internals.dtls.total_timeout  = total_timeout;
 }
+
+/**
+ * gnutls_dtls_set_mtu:
+ * @session: is a #gnutls_session_t structure.
+ * @mtu: The maximum transfer unit of the interface
+ *
+ * This function will set the maximum transfer unit of the interface
+ * that DTLS packets are expected to leave from.
+ *
+ **/
+void gnutls_dtls_set_mtu (gnutls_session_t session, unsigned int mtu)
+{
+  session->internals.dtls.mtu  = mtu;
+}
+
+/**
+ * gnutls_dtls_get_mtu:
+ * @session: is a #gnutls_session_t structure.
+ *
+ * This function will return the actual maximum transfer unit for
+ * application data. I.e. DTLS headers are subtracted from the
+ * actual MTU.
+ *
+ **/
+unsigned int gnutls_dtls_get_mtu (gnutls_session_t session)
+{
+  return session->internals.dtls.mtu - RECORD_HEADER_SIZE(session);
+}

diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index 45bfbeb2edec1ec4ab203f804b8de460efdd40b4..bcd18c55b11d4af752d0c1d5ba586e9fb7d63e94 100644 (file)
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -154,12 +154,12 @@ typedef enum transport_t
 #define RECORD_HEADER_SIZE(session) (IS_DTLS(session) ? DTLS_RECORD_HEADER_SIZE : TLS_RECORD_HEADER_SIZE)
 #define MAX_RECORD_HEADER_SIZE DTLS_RECORD_HEADER_SIZE
 
-#define MAX_RECORD_SEND_SIZE (size_t)session->security_parameters.max_record_send_size
-#define MAX_RECORD_RECV_SIZE (size_t)session->security_parameters.max_record_recv_size
+#define MAX_RECORD_SEND_SIZE(session) (IS_DTLS(session)?((size_t)session->internals.dtls.mtu-DTLS_RECORD_HEADER_SIZE):(size_t)session->security_parameters.max_record_send_size)
+#define MAX_RECORD_RECV_SIZE(session) (size_t)session->security_parameters.max_record_recv_size
 #define MAX_PAD_SIZE 255
 #define EXTRA_COMP_SIZE 2048
 #define MAX_RECORD_OVERHEAD (MAX_CIPHER_BLOCK_SIZE/*iv*/+MAX_PAD_SIZE+EXTRA_COMP_SIZE)
-#define MAX_RECV_SIZE(session) (MAX_RECORD_OVERHEAD+MAX_RECORD_RECV_SIZE+RECORD_HEADER_SIZE(session))
+#define MAX_RECV_SIZE(session) (MAX_RECORD_OVERHEAD+MAX_RECORD_RECV_SIZE(session)+RECORD_HEADER_SIZE(session))
 
 #define TLS_HANDSHAKE_HEADER_SIZE 4
 #define DTLS_HANDSHAKE_HEADER_SIZE (TLS_HANDSHAKE_HEADER_SIZE+8)
@@ -551,7 +551,7 @@ typedef struct
   /* For DTLS handshake fragmentation and reassembly. */
   uint16_t hsk_write_seq;
   uint16_t hsk_read_seq;
-  uint16_t hsk_mtu;
+  uint16_t mtu;
 
   unsigned int retrans_timeout;
   unsigned int total_timeout;

diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index d1ba96a1b1dddae6216641139d3a677c13b94845..9e18cdf983209a4d9ac97e4172ff73131778e006 100644 (file)
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -431,8 +431,8 @@ _gnutls_send_int (gnutls_session_t session, content_type_t type,
      (int) _gnutls_uint64touint32 (&record_state->sequence_number),
      _gnutls_packet2str (type), type, (int) sizeofdata);
 
-  if (sizeofdata > MAX_RECORD_SEND_SIZE)
-    data2send_size = MAX_RECORD_SEND_SIZE;
+  if (sizeofdata > MAX_RECORD_SEND_SIZE(session))
+    data2send_size = MAX_RECORD_SEND_SIZE(session);
   else
     data2send_size = sizeofdata;
 
@@ -849,9 +849,9 @@ get_temp_recv_buffer (gnutls_session_t session, gnutls_datum_t * tmp)
 
   if (gnutls_compression_get (session) != GNUTLS_COMP_NULL ||
       session->internals.priorities.allow_large_records != 0)
-    max_record_size = MAX_RECORD_RECV_SIZE + EXTRA_COMP_SIZE;
+    max_record_size = MAX_RECORD_RECV_SIZE(session) + EXTRA_COMP_SIZE;
   else
-    max_record_size = MAX_RECORD_RECV_SIZE;
+    max_record_size = MAX_RECORD_RECV_SIZE(session);
 
   /* We allocate MAX_RECORD_RECV_SIZE length
    * because we cannot predict the output data by the record

diff --git a/lib/gnutls_state.c b/lib/gnutls_state.c
index 4ab2c09b94ed2eeb7750c9e430ae89383a7e482b..41eeb2da690b33d3aab0cf03b45bec41e9d9ef66 100644 (file)
--- a/lib/gnutls_state.c
+++ b/lib/gnutls_state.c
@@ -402,7 +402,7 @@ gnutls_init_dtls (gnutls_session_t * session,
 
   /* Flags do nothing, so just copy them into the struct for now. */
   (*session)->internals.dtls.flags = flags;
-  (*session)->internals.dtls.hsk_mtu = DTLS_DEFAULT_MTU;
+  (*session)->internals.dtls.mtu = DTLS_DEFAULT_MTU;
   (*session)->internals.transport = GNUTLS_DGRAM;
 
   (*session)->internals.dtls.retrans_timeout = 1000;

diff --git a/lib/includes/gnutls/dtls.h b/lib/includes/gnutls/dtls.h
index db391d93a5a7dd0d3a57f1d41da4d605ff8d2cf5..27b0b4ce370dde599eaa725b4963c3f82e13272b 100644 (file)
--- a/lib/includes/gnutls/dtls.h
+++ b/lib/includes/gnutls/dtls.h
@@ -43,6 +43,9 @@ int gnutls_init_dtls (gnutls_session_t * session,
 void gnutls_dtls_set_timeouts (gnutls_session_t session, unsigned int retrans_timeout,
   unsigned int total_timeout);
 
+unsigned int gnutls_dtls_get_mtu (gnutls_session_t session);
+void gnutls_dtls_set_mtu (gnutls_session_t session, unsigned int mtu);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/lib/libgnutls.map b/lib/libgnutls.map
index 5576c5a953d1bf6661a2f25a6f2c1a82e2b0d772..90ba4b54954a352dc416235bcdc59b01b437a670 100644 (file)
--- a/lib/libgnutls.map
+++ b/lib/libgnutls.map
@@ -701,6 +701,8 @@ GNUTLS_3_0_0 {
        gnutls_cipher_add_auth;
        gnutls_dtls_set_timeouts;
        gnutls_transport_set_pull_timeout_function;
+       gnutls_dtls_get_mtu;
+       gnutls_dtls_set_mtu;
 } GNUTLS_2_12;
 
 GNUTLS_PRIVATE {