Thread-safety fixes

[oweals/openssl.git] / ssl / d1_both.c

diff --git a/ssl/d1_both.c b/ssl/d1_both.c
index 40d71e29d278f63448f830a27e0b8ccb94f105e3..b746a50dd718d2a8104160ce2c25af3f877ff88b 100644 (file)
--- a/ssl/d1_both.c
+++ b/ssl/d1_both.c
@@ -222,7 +222,7 @@ int dtls1_do_write(SSL *s, int type)
 
        if ( s->init_off == 0  && type == SSL3_RT_HANDSHAKE)
                OPENSSL_assert(s->init_num == 
-                       s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH);
+                       (int)s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH);
 
        frag_off = 0;
        while( s->init_num)
@@ -289,7 +289,7 @@ int dtls1_do_write(SSL *s, int type)
                        
                        /* bad if this assert fails, only part of the handshake
                         * message got sent.  but why would this happen? */
-                       OPENSSL_assert(len == ret); 
+                       OPENSSL_assert(len == (unsigned int)ret); 
                        
                        if (type == SSL3_RT_HANDSHAKE && ! s->d1->retransmitting)
                                /* should not be done for 'Hello Request's, but in that case
@@ -360,7 +360,7 @@ long dtls1_get_message(SSL *s, int st1, int stn, int mt, long max, int *ok)
                else if ( i <= 0 && !*ok)
                        return i;
 
-               if (s->d1->r_msg_hdr.msg_len == s->init_num - DTLS1_HM_HEADER_LENGTH)
+               if (s->d1->r_msg_hdr.msg_len == (unsigned int)s->init_num - DTLS1_HM_HEADER_LENGTH)
                        {
                        memset(&(s->d1->r_msg_hdr), 0x00, sizeof(struct hm_header_st));
 
@@ -413,7 +413,7 @@ dtls1_retrieve_buffered_fragment(SSL *s, unsigned long *copied)
     frag = (hm_fragment *)item->data;
     
     if ( s->d1->handshake_read_seq == frag->msg_header.seq &&
-        frag->msg_header.frag_off <= s->init_num - DTLS1_HM_HEADER_LENGTH)
+        frag->msg_header.frag_off <= (unsigned int)s->init_num - DTLS1_HM_HEADER_LENGTH)
         {
         pqueue_pop(s->d1->buffered_messages);
         overlap = s->init_num - DTLS1_HM_HEADER_LENGTH 
@@ -442,6 +442,7 @@ dtls1_buffer_handshake_fragment(SSL *s, struct hm_header_st* msg_hdr)
 {
     hm_fragment *frag = NULL;
     pitem *item = NULL;
+       PQ_64BIT seq64;
 
     frag = dtls1_hm_fragment_new(msg_hdr->frag_len);
     if ( frag == NULL)
@@ -452,10 +453,15 @@ dtls1_buffer_handshake_fragment(SSL *s, struct hm_header_st* msg_hdr)
 
     memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr));
 
-    item = pitem_new(msg_hdr->seq, frag);
+    pq_64bit_init(&seq64);
+    pq_64bit_assign_word(&seq64, msg_hdr->seq);
+
+    item = pitem_new(seq64, frag);
     if ( item == NULL)
         goto err;
 
+    pq_64bit_free(&seq64);
+
     pqueue_insert(s->d1->buffered_messages, item);
     return 1;
 
@@ -685,7 +691,7 @@ dtls1_get_message_fragment(SSL *s, int st1, int stn, long max, int *ok)
 
     /* XDTLS:  an incorrectly formatted fragment should cause the 
      * handshake to fail */
-       OPENSSL_assert(i == frag_len);
+       OPENSSL_assert(i == (int)frag_len);
 
 #if 0
     /* Successfully read a fragment.
@@ -1037,6 +1043,7 @@ dtls1_buffer_message(SSL *s, int is_ccs)
     {
     pitem *item;
     hm_fragment *frag;
+       PQ_64BIT seq64;
 
     /* this function is called immediately after a message has 
      * been serialized */
@@ -1049,12 +1056,12 @@ dtls1_buffer_message(SSL *s, int is_ccs)
     if ( is_ccs)
         {
         OPENSSL_assert(s->d1->w_msg_hdr.msg_len + 
-            DTLS1_CCS_HEADER_LENGTH == s->init_num);
+            DTLS1_CCS_HEADER_LENGTH == (unsigned int)s->init_num);
         }
     else
         {
         OPENSSL_assert(s->d1->w_msg_hdr.msg_len + 
-            DTLS1_HM_HEADER_LENGTH == s->init_num);
+            DTLS1_HM_HEADER_LENGTH == (unsigned int)s->init_num);
         }
 
     frag->msg_header.msg_len = s->d1->w_msg_hdr.msg_len;
@@ -1064,7 +1071,11 @@ dtls1_buffer_message(SSL *s, int is_ccs)
     frag->msg_header.frag_len = s->d1->w_msg_hdr.msg_len;
     frag->msg_header.is_ccs = is_ccs;
 
-    item = pitem_new(frag->msg_header.seq, frag);
+    pq_64bit_init(&seq64);
+    pq_64bit_assign_word(&seq64, frag->msg_header.seq);
+
+    item = pitem_new(seq64, frag);
+    pq_64bit_free(&seq64);
     if ( item == NULL)
         {
         dtls1_hm_fragment_free(frag);
@@ -1090,6 +1101,7 @@ dtls1_retransmit_message(SSL *s, unsigned short seq, unsigned long frag_off,
     pitem *item;
     hm_fragment *frag ;
     unsigned long header_length;
+       PQ_64BIT seq64;
 
     /*
       OPENSSL_assert(s->init_num == 0);
@@ -1097,7 +1109,11 @@ dtls1_retransmit_message(SSL *s, unsigned short seq, unsigned long frag_off,
      */
 
     /* XDTLS:  the requested message ought to be found, otherwise error */
-    item = pqueue_find(s->d1->sent_messages, seq);
+    pq_64bit_init(&seq64);
+    pq_64bit_assign_word(&seq64, seq);
+
+    item = pqueue_find(s->d1->sent_messages, seq64);
+    pq_64bit_free(&seq64);
     if ( item == NULL)
         {
         fprintf(stderr, "retransmit:  message %d non-existant\n", seq);
@@ -1213,7 +1229,7 @@ dtls1_min_mtu(void)
 static unsigned int 
 dtls1_guess_mtu(unsigned int curr_mtu)
        {
-       int i;
+       size_t i;
 
        if ( curr_mtu == 0 )
                return g_probable_mtu[0] ;