1 files changed, 175 insertions, 3 deletions

diff --git a/src/lib/libssl/d1_both.c b/src/lib/libssl/d1_both.c
index 9f898d6997..de8bab873f 100644
--- a/src/lib/libssl/d1_both.c
+++ b/src/lib/libssl/d1_both.c
@@ -227,14 +227,14 @@ int dtls1_do_write(SSL *s, int type)
         unsigned int len, frag_off, mac_size, blocksize;
 
         /* AHA!  Figure out the MTU, and stick to the right size */
-        if ( ! (SSL_get_options(s) & SSL_OP_NO_QUERY_MTU))
+        if (s->d1->mtu < dtls1_min_mtu() && !(SSL_get_options(s) & SSL_OP_NO_QUERY_MTU))
                 {
                 s->d1->mtu = 
                         BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
 
                 /* I've seen the kernel return bogus numbers when it doesn't know
                  * (initial write), so just make sure we have a reasonable number */
-                if ( s->d1->mtu < dtls1_min_mtu())
+                if (s->d1->mtu < dtls1_min_mtu())
                         {
                         s->d1->mtu = 0;
                         s->d1->mtu = dtls1_guess_mtu(s->d1->mtu);
@@ -1084,7 +1084,11 @@ int dtls1_read_failed(SSL *s, int code)
                 return code;
                 }
 
-        if ( ! SSL_in_init(s))  /* done, no need to send a retransmit */
+#ifndef OPENSSL_NO_HEARTBEATS
+        if (!SSL_in_init(s) && !s->tlsext_hb_pending)  /* done, no need to send a retransmit */
+#else
+        if (!SSL_in_init(s))  /* done, no need to send a retransmit */
+#endif
                 {
                 BIO_set_flags(SSL_get_rbio(s), BIO_FLAGS_READ);
                 return code;
@@ -1417,3 +1421,171 @@ dtls1_get_ccs_header(unsigned char *data, struct ccs_header_st *ccs_hdr)
 
         ccs_hdr->type = *(data++);
         }
+
+int dtls1_shutdown(SSL *s)
+        {
+        int ret;
+#ifndef OPENSSL_NO_SCTP
+        if (BIO_dgram_is_sctp(SSL_get_wbio(s)) &&
+            !(s->shutdown & SSL_SENT_SHUTDOWN))
+                {
+                ret = BIO_dgram_sctp_wait_for_dry(SSL_get_wbio(s));
+                if (ret < 0) return -1;
+
+                if (ret == 0)
+                        BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 1, NULL);
+                }
+#endif
+        ret = ssl3_shutdown(s);
+#ifndef OPENSSL_NO_SCTP
+        BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_SCTP_SAVE_SHUTDOWN, 0, NULL);
+#endif
+        return ret;
+        }
+
+#ifndef OPENSSL_NO_HEARTBEATS
+int
+dtls1_process_heartbeat(SSL *s)
+        {
+        unsigned char *p = &s->s3->rrec.data[0], *pl;
+        unsigned short hbtype;
+        unsigned int payload;
+        unsigned int padding = 16; /* Use minimum padding */
+
+        /* Read type and payload length first */
+        hbtype = *p++;
+        n2s(p, payload);
+        pl = p;
+
+        if (s->msg_callback)
+                s->msg_callback(0, s->version, TLS1_RT_HEARTBEAT,
+                        &s->s3->rrec.data[0], s->s3->rrec.length,
+                        s, s->msg_callback_arg);
+
+        if (hbtype == TLS1_HB_REQUEST)
+                {
+                unsigned char *buffer, *bp;
+                int r;
+
+                /* Allocate memory for the response, size is 1 byte
+                 * message type, plus 2 bytes payload length, plus
+                 * payload, plus padding
+                 */
+                buffer = OPENSSL_malloc(1 + 2 + payload + padding);
+                bp = buffer;
+
+                /* Enter response type, length and copy payload */
+                *bp++ = TLS1_HB_RESPONSE;
+                s2n(payload, bp);
+                memcpy(bp, pl, payload);
+                bp += payload;
+                /* Random padding */
+                RAND_pseudo_bytes(bp, padding);
+
+                r = dtls1_write_bytes(s, TLS1_RT_HEARTBEAT, buffer, 3 + payload + padding);
+
+                if (r >= 0 && s->msg_callback)
+                        s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
+                                buffer, 3 + payload + padding,
+                                s, s->msg_callback_arg);
+
+                OPENSSL_free(buffer);
+
+                if (r < 0)
+                        return r;
+                }
+        else if (hbtype == TLS1_HB_RESPONSE)
+                {
+                unsigned int seq;
+
+                /* We only send sequence numbers (2 bytes unsigned int),
+                 * and 16 random bytes, so we just try to read the
+                 * sequence number */
+                n2s(pl, seq);
+
+                if (payload == 18 && seq == s->tlsext_hb_seq)
+                        {
+                        dtls1_stop_timer(s);
+                        s->tlsext_hb_seq++;
+                        s->tlsext_hb_pending = 0;
+                        }
+                }
+
+        return 0;
+        }
+
+int
+dtls1_heartbeat(SSL *s)
+        {
+        unsigned char *buf, *p;
+        int ret;
+        unsigned int payload = 18; /* Sequence number + random bytes */
+        unsigned int padding = 16; /* Use minimum padding */
+
+        /* Only send if peer supports and accepts HB requests... */
+        if (!(s->tlsext_heartbeat & SSL_TLSEXT_HB_ENABLED) ||
+            s->tlsext_heartbeat & SSL_TLSEXT_HB_DONT_SEND_REQUESTS)
+                {
+                SSLerr(SSL_F_DTLS1_HEARTBEAT,SSL_R_TLS_HEARTBEAT_PEER_DOESNT_ACCEPT);
+                return -1;
+                }
+
+        /* ...and there is none in flight yet... */
+        if (s->tlsext_hb_pending)
+                {
+                SSLerr(SSL_F_DTLS1_HEARTBEAT,SSL_R_TLS_HEARTBEAT_PENDING);
+                return -1;
+                }
+
+        /* ...and no handshake in progress. */
+        if (SSL_in_init(s) || s->in_handshake)
+                {
+                SSLerr(SSL_F_DTLS1_HEARTBEAT,SSL_R_UNEXPECTED_MESSAGE);
+                return -1;
+                }
+
+        /* Check if padding is too long, payload and padding
+         * must not exceed 2^14 - 3 = 16381 bytes in total.
+         */
+        OPENSSL_assert(payload + padding <= 16381);
+
+        /* Create HeartBeat message, we just use a sequence number
+         * as payload to distuingish different messages and add
+         * some random stuff.
+         *  - Message Type, 1 byte
+         *  - Payload Length, 2 bytes (unsigned int)
+         *  - Payload, the sequence number (2 bytes uint)
+         *  - Payload, random bytes (16 bytes uint)
+         *  - Padding
+         */
+        buf = OPENSSL_malloc(1 + 2 + payload + padding);
+        p = buf;
+        /* Message Type */
+        *p++ = TLS1_HB_REQUEST;
+        /* Payload length (18 bytes here) */
+        s2n(payload, p);
+        /* Sequence number */
+        s2n(s->tlsext_hb_seq, p);
+        /* 16 random bytes */
+        RAND_pseudo_bytes(p, 16);
+        p += 16;
+        /* Random padding */
+        RAND_pseudo_bytes(p, padding);
+
+        ret = dtls1_write_bytes(s, TLS1_RT_HEARTBEAT, buf, 3 + payload + padding);
+        if (ret >= 0)
+                {
+                if (s->msg_callback)
+                        s->msg_callback(1, s->version, TLS1_RT_HEARTBEAT,
+                                buf, 3 + payload + padding,
+                                s, s->msg_callback_arg);
+
+                dtls1_start_timer(s);
+                s->tlsext_hb_pending = 1;
+                }
+
+        OPENSSL_free(buf);
+
+        return ret;
+        }
+#endif