summaryrefslogtreecommitdiffstats
path: root/ssl/statem/statem_dtls.c
diff options
context:
space:
mode:
Diffstat (limited to 'ssl/statem/statem_dtls.c')
-rw-r--r--ssl/statem/statem_dtls.c142
1 files changed, 71 insertions, 71 deletions
diff --git a/ssl/statem/statem_dtls.c b/ssl/statem/statem_dtls.c
index 828118833f..0e54ea5ddb 100644
--- a/ssl/statem/statem_dtls.c
+++ b/ssl/statem/statem_dtls.c
@@ -43,18 +43,17 @@ static unsigned char bitmask_start_values[] =
static unsigned char bitmask_end_values[] =
{ 0xff, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f };
-static void dtls1_fix_message_header(SSL *s, unsigned long frag_off,
- unsigned long frag_len);
+static void dtls1_fix_message_header(SSL *s, size_t frag_off,
+ size_t 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,
+ size_t len,
unsigned short seq_num,
- unsigned long frag_off,
- unsigned long frag_len);
-static int dtls_get_reassembled_message(SSL *s, long *len);
+ size_t frag_off,
+ size_t frag_len);
+static int dtls_get_reassembled_message(SSL *s, int *errtype, size_t *len);
-static hm_fragment *dtls1_hm_fragment_new(unsigned long frag_len,
- int reassembly)
+static hm_fragment *dtls1_hm_fragment_new(size_t frag_len, int reassembly)
{
hm_fragment *frag = NULL;
unsigned char *buf = NULL;
@@ -111,9 +110,10 @@ void dtls1_hm_fragment_free(hm_fragment *frag)
int dtls1_do_write(SSL *s, int type)
{
int ret;
- unsigned int curr_mtu;
+ size_t written;
+ size_t curr_mtu;
int retry = 1;
- unsigned int len, frag_off, mac_size, blocksize, used_len;
+ size_t len, frag_off, mac_size, blocksize, used_len;
if (!dtls1_query_mtu(s))
return -1;
@@ -215,6 +215,7 @@ int dtls1_do_write(SSL *s, int type)
len = s->init_num;
/* Shouldn't ever happen */
+ /* TODO(size_t): can this go now? */
if (len > INT_MAX)
len = INT_MAX;
@@ -236,7 +237,8 @@ int dtls1_do_write(SSL *s, int type)
data[s->init_off]);
}
- ret = dtls1_write_bytes(s, type, &s->init_buf->data[s->init_off], len);
+ ret = dtls1_write_bytes(s, type, &s->init_buf->data[s->init_off], len,
+ &written);
if (ret < 0) {
/*
* might need to update MTU here, but we don't know which
@@ -262,7 +264,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 == (unsigned int)ret);
+ OPENSSL_assert(len == written);
if (type == SSL3_RT_HANDSHAKE && !s->d1->retransmitting) {
/*
@@ -272,7 +274,7 @@ int dtls1_do_write(SSL *s, int type)
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;
+ size_t xlen;
if (frag_off == 0 && s->version != DTLS1_BAD_VER) {
/*
@@ -285,17 +287,17 @@ int dtls1_do_write(SSL *s, int type)
l2n3(0, p);
l2n3(msg_hdr->msg_len, p);
p -= DTLS1_HM_HEADER_LENGTH;
- xlen = ret;
+ xlen = written;
} else {
p += DTLS1_HM_HEADER_LENGTH;
- xlen = ret - DTLS1_HM_HEADER_LENGTH;
+ xlen = written - DTLS1_HM_HEADER_LENGTH;
}
if (!ssl3_finish_mac(s, p, xlen))
return -1;
}
- if (ret == (int)s->init_num) {
+ if (written == s->init_num) {
if (s->msg_callback)
s->msg_callback(1, s->version, type, s->init_buf->data,
(size_t)(s->init_off + s->init_num), s,
@@ -304,12 +306,12 @@ int dtls1_do_write(SSL *s, int type)
s->init_off = 0; /* done writing this message */
s->init_num = 0;
- return (1);
+ return 1;
}
- s->init_off += ret;
- s->init_num -= ret;
- ret -= DTLS1_HM_HEADER_LENGTH;
- frag_off += ret;
+ s->init_off += written;
+ s->init_num -= written;
+ written -= DTLS1_HM_HEADER_LENGTH;
+ frag_off += written;
/*
* We save the fragment offset for the next fragment so we have it
@@ -320,32 +322,34 @@ int dtls1_do_write(SSL *s, int type)
dtls1_fix_message_header(s, frag_off, 0);
}
}
- return (0);
+ return 0;
}
int dtls_get_message(SSL *s, int *mt, size_t *len)
{
struct hm_header_st *msg_hdr;
unsigned char *p;
- unsigned long msg_len;
- int ok;
- long tmplen;
+ size_t msg_len;
+ size_t tmplen;
+ int errtype;
msg_hdr = &s->d1->r_msg_hdr;
memset(msg_hdr, 0, sizeof(*msg_hdr));
again:
- ok = dtls_get_reassembled_message(s, &tmplen);
- if (tmplen == DTLS1_HM_BAD_FRAGMENT || tmplen == DTLS1_HM_FRAGMENT_RETRY) {
- /* bad fragment received */
- goto again;
- } else if (tmplen <= 0 && !ok) {
+ if (!dtls_get_reassembled_message(s, &errtype, &tmplen)) {
+ if (errtype == DTLS1_HM_BAD_FRAGMENT
+ || errtype == DTLS1_HM_FRAGMENT_RETRY) {
+ /* bad fragment received */
+ goto again;
+ }
return 0;
}
*mt = s->s3->tmp.message_type;
p = (unsigned char *)s->init_buf->data;
+ *len = s->init_num;
if (*mt == SSL3_MT_CHANGE_CIPHER_SPEC) {
if (s->msg_callback) {
@@ -355,7 +359,6 @@ int dtls_get_message(SSL *s, int *mt, size_t *len)
/*
* This isn't a real handshake message so skip the processing below.
*/
- *len = (unsigned long)tmplen;
return 1;
}
@@ -383,7 +386,6 @@ int dtls_get_message(SSL *s, int *mt, size_t *len)
s->d1->handshake_read_seq++;
s->init_msg = s->init_buf->data + DTLS1_HM_HEADER_LENGTH;
- *len = s->init_num;
return 1;
}
@@ -444,7 +446,7 @@ static int dtls1_preprocess_fragment(SSL *s, struct hm_header_st *msg_hdr)
return 0; /* no error */
}
-static int dtls1_retrieve_buffered_fragment(SSL *s, int *ok)
+static int dtls1_retrieve_buffered_fragment(SSL *s, size_t *len)
{
/*-
* (0) check whether the desired fragment is available
@@ -456,8 +458,6 @@ static int dtls1_retrieve_buffered_fragment(SSL *s, int *ok)
hm_fragment *frag;
int al;
- *ok = 0;
-
do {
item = pqueue_peek(s->d1->buffered_messages);
if (item == NULL)
@@ -480,7 +480,7 @@ static int dtls1_retrieve_buffered_fragment(SSL *s, int *ok)
return 0;
if (s->d1->handshake_read_seq == frag->msg_header.seq) {
- unsigned long frag_len = frag->msg_header.frag_len;
+ size_t frag_len = frag->msg_header.frag_len;
pqueue_pop(s->d1->buffered_messages);
al = dtls1_preprocess_fragment(s, &frag->msg_header);
@@ -496,34 +496,35 @@ static int dtls1_retrieve_buffered_fragment(SSL *s, int *ok)
pitem_free(item);
if (al == 0) {
- *ok = 1;
- return frag_len;
+ *len = frag_len;
+ return 1;
}
ssl3_send_alert(s, SSL3_AL_FATAL, al);
s->init_num = 0;
- *ok = 0;
- return -1;
- } else
return 0;
+ } else {
+ return 0;
+ }
}
static int
-dtls1_reassemble_fragment(SSL *s, const struct hm_header_st *msg_hdr, int *ok)
+dtls1_reassemble_fragment(SSL *s, const struct hm_header_st *msg_hdr)
{
hm_fragment *frag = NULL;
pitem *item = NULL;
int i = -1, is_complete;
unsigned char seq64be[8];
- unsigned long frag_len = msg_hdr->frag_len;
+ size_t frag_len = msg_hdr->frag_len;
size_t read;
if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len ||
msg_hdr->msg_len > dtls1_max_handshake_message_len(s))
goto err;
- if (frag_len == 0)
+ if (frag_len == 0) {
return DTLS1_HM_FRAGMENT_RETRY;
+ }
/* Try to find item in queue */
memset(seq64be, 0, sizeof(seq64be));
@@ -610,19 +611,17 @@ dtls1_reassemble_fragment(SSL *s, const struct hm_header_st *msg_hdr, int *ok)
err:
if (item == NULL)
dtls1_hm_fragment_free(frag);
- *ok = 0;
- return i;
+ return -1;
}
static int
-dtls1_process_out_of_seq_message(SSL *s, const struct hm_header_st *msg_hdr,
- int *ok)
+dtls1_process_out_of_seq_message(SSL *s, const struct hm_header_st *msg_hdr)
{
int i = -1;
hm_fragment *frag = NULL;
pitem *item = NULL;
unsigned char seq64be[8];
- unsigned long frag_len = msg_hdr->frag_len;
+ size_t frag_len = msg_hdr->frag_len;
size_t read;
if ((msg_hdr->frag_off + frag_len) > msg_hdr->msg_len)
@@ -662,8 +661,9 @@ dtls1_process_out_of_seq_message(SSL *s, const struct hm_header_st *msg_hdr,
frag_len -= read;
}
} else {
- if (frag_len != msg_hdr->msg_len)
- return dtls1_reassemble_fragment(s, msg_hdr, ok);
+ if (frag_len != msg_hdr->msg_len) {
+ return dtls1_reassemble_fragment(s, msg_hdr);;
+ }
if (frag_len > dtls1_max_handshake_message_len(s))
goto err;
@@ -707,26 +707,25 @@ dtls1_process_out_of_seq_message(SSL *s, const struct hm_header_st *msg_hdr,
err:
if (item == NULL)
dtls1_hm_fragment_free(frag);
- *ok = 0;
- return i;
+ return 0;
}
-static int dtls_get_reassembled_message(SSL *s, long *len)
+static int dtls_get_reassembled_message(SSL *s, int *errtype, size_t *len)
{
unsigned char wire[DTLS1_HM_HEADER_LENGTH];
- unsigned long mlen, frag_off, frag_len;
+ size_t mlen, frag_off, frag_len;
int i, al, recvd_type;
struct hm_header_st msg_hdr;
- int ok;
size_t read;
+ *errtype = 0;
+
redo:
/* see if we have the required fragment already */
- if ((frag_len = dtls1_retrieve_buffered_fragment(s, &ok)) || ok) {
- if (ok)
- s->init_num = frag_len;
+ if (dtls1_retrieve_buffered_fragment(s, &frag_len)) {
+ s->init_num = frag_len;
*len = frag_len;
- return ok;
+ return 1;
}
/* read handshake message header */
@@ -734,7 +733,7 @@ static int dtls_get_reassembled_message(SSL *s, long *len)
DTLS1_HM_HEADER_LENGTH, 0, &read);
if (i <= 0) { /* nbio, or an error */
s->rwstate = SSL_READING;
- *len = i;
+ *len = 0;
return 0;
}
if (recvd_type == SSL3_RT_CHANGE_CIPHER_SPEC) {
@@ -785,13 +784,13 @@ static int dtls_get_reassembled_message(SSL *s, long *len)
* although we're still expecting seq 0 (ClientHello)
*/
if (msg_hdr.seq != s->d1->handshake_read_seq) {
- *len = dtls1_process_out_of_seq_message(s, &msg_hdr, &ok);
- return ok;
+ *errtype = dtls1_process_out_of_seq_message(s, &msg_hdr);
+ return 0;
}
if (frag_len && frag_len < mlen) {
- *len = dtls1_reassemble_fragment(s, &msg_hdr, &ok);
- return ok;
+ *errtype = dtls1_reassemble_fragment(s, &msg_hdr);
+ return 0;
}
if (!s->server && s->d1->r_msg_hdr.frag_off == 0 &&
@@ -834,11 +833,12 @@ static int dtls_get_reassembled_message(SSL *s, long *len)
*/
if (i <= 0) {
s->rwstate = SSL_READING;
- *len = i;
+ *len = 0;
return 0;
}
- } else
+ } else {
read = 0;
+ }
/*
* XDTLS: an incorrectly formatted fragment should cause the handshake
@@ -862,7 +862,7 @@ static int dtls_get_reassembled_message(SSL *s, long *len)
f_err:
ssl3_send_alert(s, SSL3_AL_FATAL, al);
s->init_num = 0;
- *len = -1;
+ *len = 0;
return 0;
}
@@ -1134,8 +1134,8 @@ void dtls1_set_message_header(SSL *s,
/* don't actually do the writing, wait till the MTU has been retrieved */
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)
+ size_t len, unsigned short seq_num,
+ size_t frag_off, size_t frag_len)
{
struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
@@ -1147,7 +1147,7 @@ dtls1_set_message_header_int(SSL *s, unsigned char mt,
}
static void
-dtls1_fix_message_header(SSL *s, unsigned long frag_off, unsigned long frag_len)
+dtls1_fix_message_header(SSL *s, size_t frag_off, size_t frag_len)
{
struct hm_header_st *msg_hdr = &s->d1->w_msg_hdr;
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-07 19:17:40 +0000