Upgrade chrome's OpenSSL to same version Android ships with.

openssl/ssl/d1_both.c

 /* ssl/d1_both.c */
 /* 
  * DTLS implementation written by Nagendra Modadugu
  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.  
  */
 /* ====================================================================
  * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ skipping 135 matching lines @@
 
 #if 0
 #define RSMBLY_BITMASK_PRINT(bitmask, msg_len) { \
                         long ii; \
                         printf("bitmask: "); for (ii = 0; ii < (msg_len); ii++) \
                         printf("%d ", (bitmask[ii >> 3] & (1 << (ii & 7))) >> (ii & 7)); \
                         printf("\n"); }
 #endif
 
 static unsigned char bitmask_start_values[] = {0xff, 0xfe, 0xfc, 0xf8, 0xf0, 0xe0, 0xc0, 0x80};
-static unsigned char bitmask_end_values[]   = {0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f};
+static unsigned char bitmask_end_values[]   = {0xff, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f};
 
 /* XDTLS:  figure out the right values */
 static unsigned int g_probable_mtu[] = {1500 - 28, 512 - 28, 256 - 28};
 
-static unsigned int dtls1_min_mtu(void);
 static unsigned int dtls1_guess_mtu(unsigned int curr_mtu);
 static void dtls1_fix_message_header(SSL *s, unsigned long frag_off, 
         unsigned long frag_len);
 static unsigned char *dtls1_write_message_header(SSL *s,
         unsigned char *p);
 static void dtls1_set_message_header_int(SSL *s, unsigned char mt,
         unsigned long len, unsigned short seq_num, unsigned long frag_off, 
         unsigned long frag_len);
 static long dtls1_get_message_fragment(SSL *s, int st1, int stn, 
         long max, int *ok);
@@ skipping 85 matching lines @@
         else if ( ( ret = BIO_flush(SSL_get_wbio(s))) <= 0)
                 return ret;
 
         if ( BIO_wpending(SSL_get_wbio(s)) + s->init_num >= mtu)
                 {
                 ret = BIO_flush(SSL_get_wbio(s));
                 if ( ret <= 0)
                         return ret;
                 mtu = s->d1->mtu - (DTLS1_HM_HEADER_LENGTH + DTLS1_RT_HEADER_LENGTH);
                 }
+#endif
 
-        OPENSSL_assert(mtu > 0);  /* should have something reasonable now */
-
-#endif
+        OPENSSL_assert(s->d1->mtu >= dtls1_min_mtu());  /* should have something reasonable now */
 
         if ( s->init_off == 0  && type == SSL3_RT_HANDSHAKE)
                 OPENSSL_assert(s->init_num == 
                         (int)s->d1->w_msg_hdr.msg_len + DTLS1_HM_HEADER_LENGTH);
 
         if (s->write_hash)
-                mac_size = EVP_MD_size(s->write_hash);
+                mac_size = EVP_MD_CTX_size(s->write_hash);
         else
                 mac_size = 0;
 
         if (s->enc_write_ctx && 
                 (EVP_CIPHER_mode( s->enc_write_ctx->cipher) & EVP_CIPH_CBC_MODE))
                 blocksize = 2 * EVP_CIPHER_block_size(s->enc_write_ctx->cipher);
         else
                 blocksize = 0;
 
         frag_off = 0;
@@ skipping 65 matching lines @@
                         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
                                  * we'll ignore the result anyway */
                                 unsigned char *p = (unsigned char *)&s->init_buf->data[s->init_off];
                                 const struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
                                 int xlen;
 
-                                if (frag_off == 0 && s->client_version != DTLS1_BAD_VER)
+                                if (frag_off == 0 && s->version != DTLS1_BAD_VER)
                                         {
                                         /* reconstruct message header is if it
                                          * is being sent in single fragment */
                                         *p++ = msg_hdr->type;
                                         l2n3(msg_hdr->msg_len,p);
                                         s2n (msg_hdr->seq,p);
                                         l2n3(0,p);
                                         l2n3(msg_hdr->msg_len,p);
                                         p  -= DTLS1_HM_HEADER_LENGTH;
                                         xlen = ret;
@@ skipping 83 matching lines @@
         }
 
         ssl3_finish_mac(s, p, msg_len);
         if (s->msg_callback)
                 s->msg_callback(0, s->version, SSL3_RT_HANDSHAKE,
                         p, msg_len,
                         s, s->msg_callback_arg);
 
         memset(msg_hdr, 0x00, sizeof(struct hm_header_st));
 
-        s->d1->handshake_read_seq++;
-        /* we just read a handshake message from the other side:
-         * this means that we don't need to retransmit of the
-         * buffered messages.  
-         * XDTLS: may be able clear out this
-         * buffer a little sooner (i.e if an out-of-order
-         * handshake message/record is received at the record
-         * layer.  
-         * XDTLS: exception is that the server needs to
-         * know that change cipher spec and finished messages
-         * have been received by the client before clearing this
-         * buffer.  this can simply be done by waiting for the
-         * first data  segment, but is there a better way?  */
-        dtls1_clear_record_buffer(s);
+        /* Don't change sequence numbers while listening */
+        if (!s->d1->listen)
+                s->d1->handshake_read_seq++;
 
         s->init_msg = s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
         return s->init_num;
 
 f_err:
         ssl3_send_alert(s,SSL3_AL_FATAL,al);
         *ok = 0;
         return -1;
         }
 
@@ skipping 16 matching lines @@
         if ( (frag_off+frag_len) > (unsigned long)max)
                 {
                 SSLerr(SSL_F_DTLS1_PREPROCESS_FRAGMENT,SSL_R_EXCESSIVE_MESSAGE_SIZE);
                 return SSL_AD_ILLEGAL_PARAMETER;
                 }
 
         if ( s->d1->r_msg_hdr.frag_off == 0) /* first fragment */
                 {
                 /* msg_len is limited to 2^24, but is effectively checked
                  * against max above */
-                if (!BUF_MEM_grow_clean(s->init_buf,(int)msg_len+DTLS1_HM_HEADER_LENGTH))
+                if (!BUF_MEM_grow_clean(s->init_buf,msg_len+DTLS1_HM_HEADER_LENGTH))
                         {
                         SSLerr(SSL_F_DTLS1_PREPROCESS_FRAGMENT,ERR_R_BUF_LIB);
                         return SSL_AD_INTERNAL_ERROR;
                         }
 
                 s->s3->tmp.message_size  = msg_len;
                 s->d1->r_msg_hdr.msg_len = msg_len;
                 s->s3->tmp.message_type  = msg_hdr->type;
                 s->d1->r_msg_hdr.type    = msg_hdr->type;
                 s->d1->r_msg_hdr.seq     = msg_hdr->seq;
@@ skipping 65 matching lines @@
                 return 0;
         }
 
 
 static int
 dtls1_reassemble_fragment(SSL *s, struct hm_header_st* msg_hdr, int *ok)
         {
         hm_fragment *frag = NULL;
         pitem *item = NULL;
         int i = -1, is_complete;
-        PQ_64BIT seq64;
+        unsigned char seq64be[8];
         unsigned long frag_len = msg_hdr->frag_len, max_len;
 
         if ((msg_hdr->frag_off+frag_len) > msg_hdr->msg_len)
                 goto err;
 
         /* Determine maximum allowed message size. Depends on (user set)
          * maximum certificate length, but 16k is minimum.
          */
         if (DTLS1_HM_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH < s->max_cert_list)
                 max_len = s->max_cert_list;
         else
                 max_len = DTLS1_HM_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH;
 
         if ((msg_hdr->frag_off+frag_len) > max_len)
                 goto err;
 
         /* Try to find item in queue */
-        pq_64bit_init(&seq64);
-        pq_64bit_assign_word(&seq64, msg_hdr->seq);
-        item = pqueue_find(s->d1->buffered_messages, seq64);
-        pq_64bit_free(&seq64);
+        memset(seq64be,0,sizeof(seq64be));
+        seq64be[6] = (unsigned char) (msg_hdr->seq>>8);
+        seq64be[7] = (unsigned char) msg_hdr->seq;
+        item = pqueue_find(s->d1->buffered_messages, seq64be);
 
         if (item == NULL)
                 {
                 frag = dtls1_hm_fragment_new(msg_hdr->msg_len, 1);
                 if ( frag == NULL)
                         goto err;
                 memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr));
                 frag->msg_header.frag_len = frag->msg_header.msg_len;
                 frag->msg_header.frag_off = 0;
                 }
@@ skipping 31 matching lines @@
                                    is_complete);
 
         if (is_complete)
                 {
                 OPENSSL_free(frag->reassembly);
                 frag->reassembly = NULL;
                 }
 
         if (item == NULL)
                 {
-                pq_64bit_init(&seq64);
-                pq_64bit_assign_word(&seq64, msg_hdr->seq);
-                item = pitem_new(seq64, frag);
-                pq_64bit_free(&seq64);
+                memset(seq64be,0,sizeof(seq64be));
+                seq64be[6] = (unsigned char)(msg_hdr->seq>>8);
+                seq64be[7] = (unsigned char)(msg_hdr->seq);
 
+                item = pitem_new(seq64be, frag);
                 if (item == NULL)
                         {
                         goto err;
                         i = -1;
                         }
 
                 pqueue_insert(s->d1->buffered_messages, item);
                 }
 
         return DTLS1_HM_FRAGMENT_RETRY;
 
 err:
         if (frag != NULL) dtls1_hm_fragment_free(frag);
         if (item != NULL) OPENSSL_free(item);
         *ok = 0;
         return i;
         }
 
 
 static int
 dtls1_process_out_of_seq_message(SSL *s, struct hm_header_st* msg_hdr, int *ok)
 {
         int i=-1;
         hm_fragment *frag = NULL;
         pitem *item = NULL;
-        PQ_64BIT seq64;
+        unsigned char seq64be[8];
         unsigned long frag_len = msg_hdr->frag_len;
 
         if ((msg_hdr->frag_off+frag_len) > msg_hdr->msg_len)
                 goto err;
 
         /* Try to find item in queue, to prevent duplicate entries */
-        pq_64bit_init(&seq64);
-        pq_64bit_assign_word(&seq64, msg_hdr->seq);
-        item = pqueue_find(s->d1->buffered_messages, seq64);
-        pq_64bit_free(&seq64);
+        memset(seq64be,0,sizeof(seq64be));
+        seq64be[6] = (unsigned char) (msg_hdr->seq>>8);
+        seq64be[7] = (unsigned char) msg_hdr->seq;
+        item = pqueue_find(s->d1->buffered_messages, seq64be);
 
         /* If we already have an entry and this one is a fragment,
          * don't discard it and rather try to reassemble it.
          */
         if (item != NULL && frag_len < msg_hdr->msg_len)
                 item = NULL;
 
         /* Discard the message if sequence number was already there, is
          * too far in the future, already in the queue or if we received
          * a FINISHED before the SERVER_HELLO, which then must be a stale
@@ skipping 20 matching lines @@
                         return dtls1_reassemble_fragment(s, msg_hdr, ok);
 
                 frag = dtls1_hm_fragment_new(frag_len, 0);
                 if ( frag == NULL)
                         goto err;
 
                 memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr));
 
                 if (frag_len)
                         {
-                        /* read the body of the fragment (header has already been read) */
+                        /* read the body of the fragment (header has already been read */
                         i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
                                 frag->fragment,frag_len,0);
                         if (i<=0 || (unsigned long)i!=frag_len)
                                 goto err;
                         }
 
-                pq_64bit_init(&seq64);
-                pq_64bit_assign_word(&seq64, msg_hdr->seq);
+                memset(seq64be,0,sizeof(seq64be));
+                seq64be[6] = (unsigned char)(msg_hdr->seq>>8);
+                seq64be[7] = (unsigned char)(msg_hdr->seq);
 
-                item = pitem_new(seq64, frag);
-                pq_64bit_free(&seq64);
+                item = pitem_new(seq64be, frag);
                 if ( item == NULL)
                         goto err;
 
                 pqueue_insert(s->d1->buffered_messages, item);
                 }
 
         return DTLS1_HM_FRAGMENT_RETRY;
 
 err:
         if ( frag != NULL) dtls1_hm_fragment_free(frag);
@@ skipping 20 matching lines @@
 
         /* read handshake message header */
         i=s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,wire,
                 DTLS1_HM_HEADER_LENGTH, 0);
         if (i <= 0)     /* nbio, or an error */
                 {
                 s->rwstate=SSL_READING;
                 *ok = 0;
                 return i;
                 }
-        OPENSSL_assert(i == DTLS1_HM_HEADER_LENGTH);
+        /* Handshake fails if message header is incomplete */
+        if (i != DTLS1_HM_HEADER_LENGTH)
+                {
+                al=SSL_AD_UNEXPECTED_MESSAGE;
+                SSLerr(SSL_F_DTLS1_GET_MESSAGE_FRAGMENT,SSL_R_UNEXPECTED_MESSAGE);
+                goto f_err;
+                }
 
         /* parse the message fragment header */
         dtls1_get_message_header(wire, &msg_hdr);
 
         /* 
          * if this is a future (or stale) message it gets buffered
-         * (or dropped)--no further processing at this time 
+         * (or dropped)--no further processing at this time
+         * While listening, we accept seq 1 (ClientHello with cookie)
+         * although we're still expecting seq 0 (ClientHello)
          */
-        if ( msg_hdr.seq != s->d1->handshake_read_seq)
+        if (msg_hdr.seq != s->d1->handshake_read_seq && !(s->d1->listen && msg_hdr.seq == 1))
                 return dtls1_process_out_of_seq_message(s, &msg_hdr, ok);
 
         len = msg_hdr.msg_len;
         frag_off = msg_hdr.frag_off;
         frag_len = msg_hdr.frag_len;
 
         if (frag_len && frag_len < len)
                 return dtls1_reassemble_fragment(s, &msg_hdr, ok);
 
         if (!s->server && s->d1->r_msg_hdr.frag_off == 0 &&
@@ skipping 40 matching lines @@
                         s->rwstate=SSL_READING;
                         *ok = 0;
                         return i;
                         }
                 }
         else
                 i = 0;
 
         /* XDTLS:  an incorrectly formatted fragment should cause the 
          * handshake to fail */
-        OPENSSL_assert(i == (int)frag_len);
+        if (i != (int)frag_len)
+                {
+                al=SSL3_AD_ILLEGAL_PARAMETER;
+                SSLerr(SSL_F_DTLS1_GET_MESSAGE_FRAGMENT,SSL3_AD_ILLEGAL_PARAMETER);
+                goto f_err;
+                }
 
         *ok = 1;
 
         /* Note that s->init_num is *not* used as current offset in
          * s->init_buf->data, but as a counter summing up fragments'
          * lengths: as soon as they sum up to handshake packet
          * length, we assume we have got all the fragments. */
         s->init_num = frag_len;
         return frag_len;
 
@@ skipping 10 matching lines @@
         unsigned char *p,*d;
         int i;
         unsigned long l;
 
         if (s->state == a)
                 {
                 d=(unsigned char *)s->init_buf->data;
                 p= &(d[DTLS1_HM_HEADER_LENGTH]);
 
                 i=s->method->ssl3_enc->final_finish_mac(s,
-                        &(s->s3->finish_dgst1),
-                        &(s->s3->finish_dgst2),
                         sender,slen,s->s3->tmp.finish_md);
                 s->s3->tmp.finish_md_len = i;
                 memcpy(p, s->s3->tmp.finish_md, i);
                 p+=i;
                 l=i;
 
         /* Copy the finished so we can use it for
          * renegotiation checks
          */
         if(s->type == SSL_ST_CONNECT)
@@ skipping 44 matching lines @@
         { 
         unsigned char *p;
 
         if (s->state == a)
                 {
                 p=(unsigned char *)s->init_buf->data;
                 *p++=SSL3_MT_CCS;
                 s->d1->handshake_write_seq = s->d1->next_handshake_write_seq;
                 s->init_num=DTLS1_CCS_HEADER_LENGTH;
 
-                if (s->client_version == DTLS1_BAD_VER)
-                        {
+                if (s->version == DTLS1_BAD_VER) {
                         s->d1->next_handshake_write_seq++;
                         s2n(s->d1->handshake_write_seq,p);
                         s->init_num+=2;
-                        }
+                }
 
                 s->init_off=0;
 
                 dtls1_set_message_header_int(s, SSL3_MT_CCS, 0, 
                         s->d1->handshake_write_seq, 0, 0);
 
                 /* buffer the message to handle re-xmits */
                 dtls1_buffer_message(s, 1);
 
                 s->state=b;
                 }
 
         /* SSL3_ST_CW_CHANGE_B */
         return(dtls1_do_write(s,SSL3_RT_CHANGE_CIPHER_SPEC));
         }
 
 static int dtls1_add_cert_to_buf(BUF_MEM *buf, unsigned long *l, X509 *x)
         {
-                int n;
-                unsigned char *p;
+        int n;
+        unsigned char *p;
 
-                n=i2d_X509(x,NULL);
-                if (!BUF_MEM_grow_clean(buf,(int)(n+(*l)+3)))
-                        {
-                        SSLerr(SSL_F_DTLS1_ADD_CERT_TO_BUF,ERR_R_BUF_LIB);
-                        return 0;
-                        }
-                p=(unsigned char *)&(buf->data[*l]);
-                l2n3(n,p);
-                i2d_X509(x,&p);
-                *l+=n+3;
+        n=i2d_X509(x,NULL);
+        if (!BUF_MEM_grow_clean(buf,(int)(n+(*l)+3)))
+                {
+                SSLerr(SSL_F_DTLS1_ADD_CERT_TO_BUF,ERR_R_BUF_LIB);
+                return 0;
+                }
+        p=(unsigned char *)&(buf->data[*l]);
+        l2n3(n,p);
+        i2d_X509(x,&p);
+        *l+=n+3;
 
-                return 1;
+        return 1;
         }
 unsigned long dtls1_output_cert_chain(SSL *s, X509 *x)
         {
         unsigned char *p;
         int i;
         unsigned long l= 3 + DTLS1_HM_HEADER_LENGTH;
         BUF_MEM *buf;
 
         /* TLSv1 sends a chain with nothing in it, instead of an alert */
         buf=s->init_buf;
         if (!BUF_MEM_grow_clean(buf,10))
                 {
                 SSLerr(SSL_F_DTLS1_OUTPUT_CERT_CHAIN,ERR_R_BUF_LIB);
                 return(0);
                 }
         if (x != NULL)
                 {
                 X509_STORE_CTX xs_ctx;
-  
+
                 if (!X509_STORE_CTX_init(&xs_ctx,s->ctx->cert_store,x,NULL))
                         {
                         SSLerr(SSL_F_DTLS1_OUTPUT_CERT_CHAIN,ERR_R_X509_LIB);
                         return(0);
                         }
   
                 X509_verify_cert(&xs_ctx);
                 /* Don't leave errors in the queue */
                 ERR_clear_error();
                 for (i=0; i < sk_X509_num(xs_ctx.chain); i++)
                         {
                         x = sk_X509_value(xs_ctx.chain, i);
 
                         if (!dtls1_add_cert_to_buf(buf, &l, x))
                                 {
                                 X509_STORE_CTX_cleanup(&xs_ctx);
                                 return 0;
                                 }
                         }
                 X509_STORE_CTX_cleanup(&xs_ctx);
                 }
-        /* Thawte special :-) */
+        /* Thawte special :-) */
         for (i=0; i<sk_X509_num(s->ctx->extra_certs); i++)
                 {
                 x=sk_X509_value(s->ctx->extra_certs,i);
                 if (!dtls1_add_cert_to_buf(buf, &l, x))
                         return 0;
                 }
 
         l-= (3 + DTLS1_HM_HEADER_LENGTH);
 
         p=(unsigned char *)&(buf->data[DTLS1_HM_HEADER_LENGTH]);
@@ skipping 83 matching lines @@
                 }
 
         return 1;
         }
 
 int
 dtls1_buffer_message(SSL *s, int is_ccs)
         {
         pitem *item;
         hm_fragment *frag;
-        PQ_64BIT seq64;
+        unsigned char seq64be[8];
 
         /* this function is called immediately after a message has 
          * been serialized */
         OPENSSL_assert(s->init_off == 0);
 
         frag = dtls1_hm_fragment_new(s->init_num, 0);
 
         memcpy(frag->fragment, s->init_buf->data, s->init_num);
 
         if ( is_ccs)
                 {
                 OPENSSL_assert(s->d1->w_msg_hdr.msg_len + 
-                        DTLS1_CCS_HEADER_LENGTH <= (unsigned int)s->init_num);
+                               ((s->version==DTLS1_VERSION)?DTLS1_CCS_HEADER_LENGTH:3) == (unsigned int)s->init_num);
                 }
         else
                 {
                 OPENSSL_assert(s->d1->w_msg_hdr.msg_len + 
                         DTLS1_HM_HEADER_LENGTH == (unsigned int)s->init_num);
                 }
 
         frag->msg_header.msg_len = s->d1->w_msg_hdr.msg_len;
         frag->msg_header.seq = s->d1->w_msg_hdr.seq;
         frag->msg_header.type = s->d1->w_msg_hdr.type;
         frag->msg_header.frag_off = 0;
         frag->msg_header.frag_len = s->d1->w_msg_hdr.msg_len;
         frag->msg_header.is_ccs = is_ccs;
 
         /* save current state*/
         frag->msg_header.saved_retransmit_state.enc_write_ctx = s->enc_write_ctx;
         frag->msg_header.saved_retransmit_state.write_hash = s->write_hash;
         frag->msg_header.saved_retransmit_state.compress = s->compress;
         frag->msg_header.saved_retransmit_state.session = s->session;
         frag->msg_header.saved_retransmit_state.epoch = s->d1->w_epoch;
+        
+        memset(seq64be,0,sizeof(seq64be));
+        seq64be[6] = (unsigned char)(dtls1_get_queue_priority(frag->msg_header.seq,
+                                                                                                                  frag->msg_header.is_ccs)>>8);
+        seq64be[7] = (unsigned char)(dtls1_get_queue_priority(frag->msg_header.seq,
+                                                                                                                  frag->msg_header.is_ccs));
 
-        pq_64bit_init(&seq64);
-
-        pq_64bit_assign_word(&seq64,
-                                                 dtls1_get_queue_priority(frag->msg_header.seq,
-                                                                                                  frag->msg_header.is_ccs));
-                
-        item = pitem_new(seq64, frag);
-        pq_64bit_free(&seq64);
+        item = pitem_new(seq64be, frag);
         if ( item == NULL)
                 {
                 dtls1_hm_fragment_free(frag);
                 return 0;
                 }
 
 #if 0
         fprintf( stderr, "buffered messge: \ttype = %xx\n", msg_buf->type);
         fprintf( stderr, "\t\t\t\t\tlen = %d\n", msg_buf->len);
         fprintf( stderr, "\t\t\t\t\tseq_num = %d\n", msg_buf->seq_num);
 #endif
 
         pqueue_insert(s->d1->sent_messages, item);
         return 1;
         }
 
 int
 dtls1_retransmit_message(SSL *s, unsigned short seq, unsigned long frag_off,
         int *found)
         {
         int ret;
         /* XDTLS: for now assuming that read/writes are blocking */
         pitem *item;
         hm_fragment *frag ;
         unsigned long header_length;
-        PQ_64BIT seq64;
+        unsigned char seq64be[8];
         struct dtls1_retransmit_state saved_state;
         unsigned char save_write_sequence[8];
 
         /*
           OPENSSL_assert(s->init_num == 0);
           OPENSSL_assert(s->init_off == 0);
          */
 
         /* XDTLS:  the requested message ought to be found, otherwise error */
-        pq_64bit_init(&seq64);
-        pq_64bit_assign_word(&seq64, seq);
+        memset(seq64be,0,sizeof(seq64be));
+        seq64be[6] = (unsigned char)(seq>>8);
+        seq64be[7] = (unsigned char)seq;
 
-        item = pqueue_find(s->d1->sent_messages, seq64);
-        pq_64bit_free(&seq64);
+        item = pqueue_find(s->d1->sent_messages, seq64be);
         if ( item == NULL)
                 {
                 fprintf(stderr, "retransmit:  message %d non-existant\n", seq);
                 *found = 0;
                 return 0;
                 }
 
         *found = 1;
         frag = (hm_fragment *)item->data;
 
@@ skipping 67 matching lines @@
                 dtls1_hm_fragment_free((hm_fragment *)item->data);
                 pitem_free(item);
                 }
         }
 
 
 unsigned char *
 dtls1_set_message_header(SSL *s, unsigned char *p, unsigned char mt,
                         unsigned long len, unsigned long frag_off, unsigned long frag_len)
         {
-        if ( frag_off == 0)
+        /* Don't change sequence numbers while listening */
+        if (frag_off == 0 && !s->d1->listen)
                 {
                 s->d1->handshake_write_seq = s->d1->next_handshake_write_seq;
                 s->d1->next_handshake_write_seq++;
                 }
 
         dtls1_set_message_header_int(s, mt, len, s->d1->handshake_write_seq,
                 frag_off, frag_len);
 
         return p += DTLS1_HM_HEADER_LENGTH;
         }
@@ skipping 32 matching lines @@
         *p++ = msg_hdr->type;
         l2n3(msg_hdr->msg_len, p);
 
         s2n(msg_hdr->seq, p);
         l2n3(msg_hdr->frag_off, p);
         l2n3(msg_hdr->frag_len, p);
 
         return p;
         }
 
-static unsigned int 
+unsigned int 
 dtls1_min_mtu(void)
         {
         return (g_probable_mtu[(sizeof(g_probable_mtu) / 
                 sizeof(g_probable_mtu[0])) - 1]);
         }
 
 static unsigned int 
 dtls1_guess_mtu(unsigned int curr_mtu)
         {
-        size_t i;
+        unsigned int i;
 
         if ( curr_mtu == 0 )
                 return g_probable_mtu[0] ;
 
         for ( i = 0; i < sizeof(g_probable_mtu)/sizeof(g_probable_mtu[0]); i++)
                 if ( curr_mtu > g_probable_mtu[i])
                         return g_probable_mtu[i];
 
         return curr_mtu;
         }
@@ skipping 10 matching lines @@
         n2l3(data, msg_hdr->frag_len);
         }
 
 void
 dtls1_get_ccs_header(unsigned char *data, struct ccs_header_st *ccs_hdr)
         {
         memset(ccs_hdr, 0x00, sizeof(struct ccs_header_st));
 
         ccs_hdr->type = *(data++);
         }