2 * Copyright (C) 2000-2012 Free Software Foundation, Inc.
4 * Author: Nikos Mavrogiannopoulos
6 * This file is part of GnuTLS.
8 * The GnuTLS is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 3 of
11 * the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>
24 * This file holds all the buffering code used in gnutls.
25 * The buffering code works as:
28 * 1. uses a buffer to hold data (application/handshake),
29 * we got but they were not requested, yet.
30 * (see gnutls_record_buffer_put(), gnutls_record_buffer_get_size() etc.)
32 * 2. uses a buffer to hold data that were incomplete (ie the read/write
34 * (see _gnutls_io_read_buffered(), _gnutls_io_write_buffered() etc.)
37 * 1. Uses buffer to hold the last received handshake message.
38 * (see _gnutls_handshake_hash_buffer_put() etc.)
42 #include <gnutls_int.h>
43 #include <gnutls_errors.h>
44 #include <gnutls_num.h>
45 #include <gnutls_record.h>
46 #include <gnutls_buffers.h>
47 #include <gnutls_mbuffers.h>
48 #include <gnutls_state.h>
49 #include <gnutls_dtls.h>
51 #include <gnutls_constate.h> /* gnutls_epoch_get */
57 #define EAGAIN EWOULDBLOCK
60 /* this is the maximum number of messages allowed to queue.
64 /* Buffers received packets of type APPLICATION DATA and
68 _gnutls_record_buffer_put (gnutls_session_t session
,
69 content_type_t type
, uint64
* seq
, mbuffer_st
* bufel
)
73 memcpy(&bufel
->record_sequence
, seq
, sizeof(*seq
));
75 _mbuffer_enqueue(&session
->internals
.record_buffer
, bufel
);
76 _gnutls_buffers_log ("BUF[REC]: Inserted %d bytes of Data(%d)\n",
77 (int) bufel
->msg
.size
, (int) type
);
83 * gnutls_record_check_pending:
84 * @session: is a #gnutls_session_t structure.
86 * This function checks if there are unread data
87 * in the gnutls buffers. If the return value is
88 * non-zero the next call to gnutls_record_recv()
89 * is guarranteed not to block.
91 * Returns: Returns the size of the data or zero.
94 gnutls_record_check_pending (gnutls_session_t session
)
96 return _gnutls_record_buffer_get_size (session
) + session
->internals
.record_recv_buffer
.byte_length
;
100 _gnutls_record_buffer_get (content_type_t type
,
101 gnutls_session_t session
, uint8_t * data
,
102 size_t length
, uint8_t seq
[8])
107 if (length
== 0 || data
== NULL
)
110 return GNUTLS_E_INVALID_REQUEST
;
113 bufel
= _mbuffer_head_get_first(&session
->internals
.record_buffer
, &msg
);
115 return gnutls_assert_val(GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
);
117 if (type
!= bufel
->type
)
119 if (IS_DTLS(session
))
120 _gnutls_audit_log(session
, "Discarded unexpected %s (%d) packet (expecting: %s (%d))\n",
121 _gnutls_packet2str(bufel
->type
), (int)bufel
->type
,
122 _gnutls_packet2str(type
), (int)type
);
123 _mbuffer_head_remove_bytes(&session
->internals
.record_buffer
, msg
.size
);
124 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET
);
127 if (msg
.size
<= length
)
131 memcpy(seq
, bufel
->record_sequence
.i
, 8);
133 memcpy(data
, msg
.data
, length
);
134 _mbuffer_head_remove_bytes(&session
->internals
.record_buffer
, length
);
140 reset_errno (gnutls_session_t session
)
142 session
->internals
.errnum
= 0;
146 get_errno (gnutls_session_t session
)
150 if (session
->internals
.errnum
!= 0)
151 ret
= session
->internals
.errnum
;
153 ret
= session
->internals
.errno_func (session
->
154 internals
.transport_recv_ptr
);
159 _gnutls_dgram_read (gnutls_session_t session
, mbuffer_st
**bufel
,
160 gnutls_pull_func pull_func
)
164 size_t max_size
= _gnutls_get_max_decrypted_data(session
);
165 size_t recv_size
= MAX_RECV_SIZE(session
);
166 gnutls_transport_ptr_t fd
= session
->internals
.transport_recv_ptr
;
168 if (recv_size
> max_size
)
169 recv_size
= max_size
;
171 *bufel
= _mbuffer_alloc (0, max_size
);
173 return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR
);
175 ptr
= (*bufel
)->msg
.data
;
177 session
->internals
.direction
= 0;
179 reset_errno (session
);
180 i
= pull_func (fd
, ptr
, recv_size
);
184 int err
= get_errno (session
);
186 _gnutls_read_log ("READ: %d returned from %p, errno=%d gerrno=%d\n",
187 (int) i
, fd
, errno
, session
->internals
.errnum
);
191 ret
= GNUTLS_E_AGAIN
;
194 else if (err
== EINTR
)
196 ret
= GNUTLS_E_INTERRUPTED
;
202 ret
= GNUTLS_E_PULL_ERROR
;
208 _gnutls_read_log ("READ: Got %d bytes from %p\n", (int) i
, fd
);
211 /* If we get here, we likely have a stream socket.
212 * FIXME: this probably breaks DCCP. */
218 _mbuffer_set_udata_size (*bufel
, i
);
221 _gnutls_read_log ("READ: read %d bytes from %p\n", (int) i
, fd
);
226 _mbuffer_xfree(bufel
);
231 _gnutls_stream_read (gnutls_session_t session
, mbuffer_st
**bufel
,
232 size_t size
, gnutls_pull_func pull_func
)
236 size_t max_size
= _gnutls_get_max_decrypted_data(session
);
238 gnutls_transport_ptr_t fd
= session
->internals
.transport_recv_ptr
;
240 *bufel
= _mbuffer_alloc (0, MAX(max_size
, size
));
244 return GNUTLS_E_MEMORY_ERROR
;
246 ptr
= (*bufel
)->msg
.data
;
248 session
->internals
.direction
= 0;
253 reset_errno (session
);
255 i
= pull_func (fd
, &ptr
[size
- left
], left
);
259 int err
= get_errno (session
);
261 _gnutls_read_log ("READ: %d returned from %p, errno=%d gerrno=%d\n",
262 (int) i
, fd
, errno
, session
->internals
.errnum
);
264 if (err
== EAGAIN
|| err
== EINTR
)
269 _gnutls_read_log ("READ: returning %d bytes from %p\n",
270 (int) (size
- left
), fd
);
276 return GNUTLS_E_AGAIN
;
277 return GNUTLS_E_INTERRUPTED
;
282 return GNUTLS_E_PULL_ERROR
;
288 _gnutls_read_log ("READ: Got %d bytes from %p\n", (int) i
, fd
);
295 (*bufel
)->msg
.size
+= i
;
300 _gnutls_read_log ("READ: read %d bytes from %p\n",
301 (int) (size
- left
), fd
);
303 return (size
- left
);
307 /* This function is like read. But it does not return -1 on error.
308 * It does return gnutls_errno instead.
310 * Flags are only used if the default recv() function is being used.
313 _gnutls_read (gnutls_session_t session
, mbuffer_st
**bufel
,
314 size_t size
, gnutls_pull_func pull_func
)
316 if (IS_DTLS (session
))
317 /* Size is not passed, since a whole datagram will be read. */
318 return _gnutls_dgram_read (session
, bufel
, pull_func
);
320 return _gnutls_stream_read (session
, bufel
, size
, pull_func
);
324 _gnutls_writev_emu (gnutls_session_t session
, gnutls_transport_ptr_t fd
, const giovec_t
* giovec
,
325 unsigned int giovec_cnt
)
331 for (j
= 0; j
< giovec_cnt
; j
++)
333 ret
= session
->internals
.push_func (fd
, giovec
[j
].iov_base
, giovec
[j
].iov_len
);
340 if ((size_t)ret
!= giovec
[j
].iov_len
)
351 _gnutls_writev (gnutls_session_t session
, const giovec_t
* giovec
,
355 gnutls_transport_ptr_t fd
= session
->internals
.transport_send_ptr
;
357 reset_errno (session
);
359 if (session
->internals
.push_func
!= NULL
)
360 i
= _gnutls_writev_emu (session
, fd
, giovec
, giovec_cnt
);
362 i
= session
->internals
.vec_push_func (fd
, giovec
, giovec_cnt
);
366 int err
= get_errno (session
);
367 _gnutls_debug_log ("errno: %d\n", err
);
369 return GNUTLS_E_AGAIN
;
370 else if (err
== EINTR
)
371 return GNUTLS_E_INTERRUPTED
;
375 return GNUTLS_E_PUSH_ERROR
;
381 /* This function is like recv(with MSG_PEEK). But it does not return -1 on error.
382 * It does return gnutls_errno instead.
383 * This function reads data from the socket and keeps them in a buffer, of up to
386 * This is not a general purpose function. It returns EXACTLY the data requested,
387 * which are stored in a local (in the session) buffer.
391 _gnutls_io_read_buffered (gnutls_session_t session
, size_t total
,
392 content_type_t recv_type
)
396 mbuffer_st
*bufel
= NULL
;
397 size_t recvdata
, readsize
;
399 if (total
> MAX_RECV_SIZE(session
) || total
== 0)
401 gnutls_assert (); /* internal error */
402 return GNUTLS_E_INVALID_REQUEST
;
405 /* calculate the actual size, ie. get the minimum of the
406 * buffered data and the requested data.
408 min
= MIN (session
->internals
.record_recv_buffer
.byte_length
, total
);
411 /* if we have enough buffered data
412 * then just return them.
420 /* min is over zero. recvdata is the data we must
421 * receive in order to return the requested data.
423 recvdata
= total
- min
;
426 /* Check if the previously read data plus the new data to
427 * receive are longer than the maximum receive buffer size.
429 if ((session
->internals
.record_recv_buffer
.byte_length
+ recvdata
) >
430 MAX_RECV_SIZE(session
))
432 gnutls_assert (); /* internal error */
433 return GNUTLS_E_INVALID_REQUEST
;
447 _gnutls_read (session
, &bufel
, readsize
,
448 session
->internals
.pull_func
);
450 /* return immediately if we got an interrupt or eagain
453 if (ret
< 0 && gnutls_error_is_fatal (ret
) == 0)
455 _mbuffer_xfree (&bufel
);
460 /* copy fresh data to our buffer.
465 ("RB: Have %d bytes into buffer. Adding %d bytes.\n",
466 (int) session
->internals
.record_recv_buffer
.byte_length
, (int) ret
);
467 _gnutls_read_log ("RB: Requested %d bytes\n", (int) total
);
469 _mbuffer_enqueue (&session
->internals
.record_recv_buffer
, bufel
);
472 _mbuffer_xfree (&bufel
);
487 ret
= MIN(total
, session
->internals
.record_recv_buffer
.byte_length
);
489 ret
= session
->internals
.record_recv_buffer
.byte_length
;
491 if ((ret
> 0) && ((size_t) ret
< total
))
494 return gnutls_assert_val(GNUTLS_E_AGAIN
);
502 /* This function is like write. But it does not return -1 on error.
503 * It does return gnutls_errno instead.
505 * This function takes full responsibility of freeing msg->data.
507 * In case of E_AGAIN and E_INTERRUPTED errors, you must call
508 * gnutls_write_flush(), until it returns ok (0).
510 * We need to push exactly the data in msg->size, since we cannot send
511 * less data. In TLS the peer must receive the whole packet in order
512 * to decrypt and verify the integrity.
516 _gnutls_io_write_buffered (gnutls_session_t session
,
517 mbuffer_st
* bufel
, unsigned int mflag
)
519 mbuffer_head_st
*const send_buffer
= &session
->internals
.record_send_buffer
;
521 /* to know where the procedure was interrupted.
523 session
->internals
.direction
= 1;
525 _mbuffer_enqueue (send_buffer
, bufel
);
528 ("WRITE: enqueued %d bytes for %p. Total %d bytes.\n",
529 (int) bufel
->msg
.size
, session
->internals
.transport_recv_ptr
,
530 (int) send_buffer
->byte_length
);
532 if (mflag
== MBUFFER_FLUSH
)
533 return _gnutls_io_write_flush (session
);
535 return bufel
->msg
.size
;
538 typedef ssize_t (*send_func
) (gnutls_session_t
, const giovec_t
*, int);
540 /* This function writes the data that are left in the
541 * TLS write buffer (ie. because the previous write was
545 _gnutls_io_write_flush (gnutls_session_t session
)
548 mbuffer_head_st
*send_buffer
= &session
->internals
.record_send_buffer
;
550 ssize_t sent
= 0, tosend
= 0;
551 giovec_t iovec
[MAX_QUEUE
];
555 _gnutls_write_log ("WRITE FLUSH: %d bytes in buffer.\n",
556 (int) send_buffer
->byte_length
);
558 for (cur
= _mbuffer_head_get_first (send_buffer
, &msg
);
559 cur
!= NULL
; cur
= _mbuffer_head_get_next (cur
, &msg
))
561 iovec
[i
].iov_base
= msg
.data
;
562 iovec
[i
++].iov_len
= msg
.size
;
565 /* we buffer up to MAX_QUEUE messages */
569 return GNUTLS_E_INTERNAL_ERROR
;
579 ret
= _gnutls_writev (session
, iovec
, i
);
582 _mbuffer_head_remove_bytes (send_buffer
, ret
);
583 _gnutls_write_log ("WRITE: wrote %d bytes, %d bytes left.\n",
584 ret
, (int) send_buffer
->byte_length
);
588 else if (ret
== GNUTLS_E_INTERRUPTED
|| ret
== GNUTLS_E_AGAIN
)
590 _gnutls_write_log ("WRITE interrupted: %d bytes left.\n",
591 (int) send_buffer
->byte_length
);
596 _gnutls_write_log ("WRITE error: code %d, %d bytes left.\n",
597 ret
, (int) send_buffer
->byte_length
);
605 return gnutls_assert_val(GNUTLS_E_AGAIN
);
611 /* Checks whether there are received data within
614 * Returns 0 if data were received, GNUTLS_E_TIMEDOUT
615 * on timeout and a negative error code on error.
618 _gnutls_io_check_recv (gnutls_session_t session
, unsigned int ms
)
620 gnutls_transport_ptr_t fd
= session
->internals
.transport_send_ptr
;
623 if (session
->internals
.pull_timeout_func
== system_recv_timeout
&&
624 session
->internals
.pull_func
!= system_read
)
625 return gnutls_assert_val(GNUTLS_E_PULL_ERROR
);
627 reset_errno (session
);
629 ret
= session
->internals
.pull_timeout_func(fd
, ms
);
631 err
= get_errno (session
);
632 if (ret
== -1 && err
== EINTR
)
633 return GNUTLS_E_INTERRUPTED
;
634 else if (ret
== -1 && err
== EAGAIN
)
635 return GNUTLS_E_AGAIN
;
637 return gnutls_assert_val(GNUTLS_E_PULL_ERROR
);
641 else return GNUTLS_E_TIMEDOUT
;
644 /* HANDSHAKE buffers part
647 /* This function writes the data that are left in the
648 * Handshake write buffer (ie. because the previous write was
653 _gnutls_handshake_io_write_flush (gnutls_session_t session
)
655 mbuffer_head_st
*const send_buffer
=
656 &session
->internals
.handshake_send_buffer
;
663 _gnutls_write_log ("HWRITE FLUSH: %d bytes in buffer.\n",
664 (int) send_buffer
->byte_length
);
666 if (IS_DTLS(session
))
667 return _dtls_transmit(session
);
669 for (cur
= _mbuffer_head_get_first (send_buffer
, &msg
);
670 cur
!= NULL
; cur
= _mbuffer_head_get_first (send_buffer
, &msg
))
674 ret
= _gnutls_send_int (session
, cur
->type
,
677 msg
.data
, msg
.size
, 0);
683 ret
= _mbuffer_head_remove_bytes (send_buffer
, ret
);
685 _gnutls_epoch_refcount_dec(session
, epoch
);
687 _gnutls_write_log ("HWRITE: wrote %d bytes, %d bytes left.\n",
688 ret
, (int) send_buffer
->byte_length
);
693 _gnutls_write_log ("HWRITE error: code %d, %d bytes left.\n",
694 ret
, (int) send_buffer
->byte_length
);
701 return _gnutls_io_write_flush (session
);
705 /* This is a send function for the gnutls handshake
706 * protocol. Just makes sure that all data have been sent.
710 _gnutls_handshake_io_cache_int (gnutls_session_t session
,
711 gnutls_handshake_description_t htype
,
714 mbuffer_head_st
* send_buffer
;
716 if (IS_DTLS(session
))
718 bufel
->handshake_sequence
= session
->internals
.dtls
.hsk_write_seq
-1;
722 &session
->internals
.handshake_send_buffer
;
724 bufel
->epoch
= (uint16_t)_gnutls_epoch_refcount_inc(session
, EPOCH_WRITE_CURRENT
);
725 bufel
->htype
= htype
;
726 if (bufel
->htype
== GNUTLS_HANDSHAKE_CHANGE_CIPHER_SPEC
)
727 bufel
->type
= GNUTLS_CHANGE_CIPHER_SPEC
;
729 bufel
->type
= GNUTLS_HANDSHAKE
;
731 _mbuffer_enqueue (send_buffer
, bufel
);
734 ("HWRITE: enqueued [%s] %d. Total %d bytes.\n",
735 _gnutls_handshake2str (bufel
->htype
), (int) bufel
->msg
.size
, (int) send_buffer
->byte_length
);
740 static int handshake_compare(const void* _e1
, const void* _e2
)
742 const handshake_buffer_st
* e1
= _e1
;
743 const handshake_buffer_st
* e2
= _e2
;
745 if (e1
->sequence
<= e2
->sequence
)
751 #define SSL2_HEADERS 1
753 parse_handshake_header (gnutls_session_t session
, mbuffer_st
* bufel
,
754 handshake_buffer_st
* hsk
)
756 uint8_t *dataptr
= NULL
; /* for realloc */
757 size_t handshake_header_size
= HANDSHAKE_HEADER_SIZE(session
), data_size
;
759 /* Note: SSL2_HEADERS == 1 */
760 if (_mbuffer_get_udata_size(bufel
) < handshake_header_size
)
761 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH
);
763 dataptr
= _mbuffer_get_udata_ptr(bufel
);
765 /* if reading a client hello of SSLv2 */
766 if (!IS_DTLS(session
) && bufel
->htype
== GNUTLS_HANDSHAKE_CLIENT_HELLO_V2
)
768 handshake_header_size
= SSL2_HEADERS
; /* we've already read one byte */
770 hsk
->length
= _mbuffer_get_udata_size(bufel
) - handshake_header_size
; /* we've read the first byte */
772 if (dataptr
[0] != GNUTLS_HANDSHAKE_CLIENT_HELLO
)
773 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET
);
775 hsk
->htype
= GNUTLS_HANDSHAKE_CLIENT_HELLO_V2
;
778 hsk
->start_offset
= 0;
779 hsk
->end_offset
= hsk
->length
;
781 else /* TLS handshake headers */
784 hsk
->htype
= dataptr
[0];
786 /* we do not use DECR_LEN because we know
787 * that the packet has enough data.
789 hsk
->length
= _gnutls_read_uint24 (&dataptr
[1]);
790 handshake_header_size
= HANDSHAKE_HEADER_SIZE(session
);
792 if (IS_DTLS(session
))
794 hsk
->sequence
= _gnutls_read_uint16 (&dataptr
[4]);
795 hsk
->start_offset
= _gnutls_read_uint24 (&dataptr
[6]);
796 hsk
->end_offset
= hsk
->start_offset
+ _gnutls_read_uint24 (&dataptr
[9]);
801 hsk
->start_offset
= 0;
802 hsk
->end_offset
= hsk
->length
;
805 data_size
= _mbuffer_get_udata_size(bufel
) - handshake_header_size
;
807 /* make the length offset */
808 if (hsk
->end_offset
> 0) hsk
->end_offset
--;
810 _gnutls_handshake_log ("HSK[%p]: %s was received. Length %d[%d], frag offset %d, frag length: %d, sequence: %d\n",
811 session
, _gnutls_handshake2str (hsk
->htype
),
812 (int) hsk
->length
, (int)data_size
, hsk
->start_offset
, hsk
->end_offset
-hsk
->start_offset
+1, (int)hsk
->sequence
);
814 hsk
->header_size
= handshake_header_size
;
815 memcpy(hsk
->header
, _mbuffer_get_udata_ptr(bufel
), handshake_header_size
);
817 if (hsk
->length
> 0 &&
818 (hsk
->end_offset
-hsk
->start_offset
>= data_size
))
819 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH
);
821 if (hsk
->length
> 0 && (hsk
->start_offset
>= hsk
->end_offset
||
822 hsk
->end_offset
-hsk
->start_offset
>= data_size
||
823 hsk
->end_offset
>= hsk
->length
))
824 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH
);
825 else if (hsk
->length
== 0 && hsk
->end_offset
!= 0 && hsk
->start_offset
!= 0)
826 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH
);
828 return handshake_header_size
;
831 static void _gnutls_handshake_buffer_move(handshake_buffer_st
* dst
, handshake_buffer_st
* src
)
833 memcpy(dst
, src
, sizeof(*dst
));
834 memset(src
, 0, sizeof(*src
));
838 /* will merge the given handshake_buffer_st to the handshake_recv_buffer
839 * list. The given hsk packet will be released in any case (success or failure).
842 static int merge_handshake_packet(gnutls_session_t session
, handshake_buffer_st
* hsk
)
844 int exists
= 0, i
, pos
= 0;
847 for (i
=0;i
<session
->internals
.handshake_recv_buffer_size
;i
++)
849 if (session
->internals
.handshake_recv_buffer
[i
].htype
== hsk
->htype
)
858 pos
= session
->internals
.handshake_recv_buffer_size
;
860 if (pos
> MAX_HANDSHAKE_MSGS
)
861 return gnutls_assert_val(GNUTLS_E_TOO_MANY_HANDSHAKE_PACKETS
);
865 if (hsk
->length
> 0 && hsk
->end_offset
> 0 && hsk
->end_offset
-hsk
->start_offset
+1 != hsk
->length
)
867 ret
= _gnutls_buffer_resize(&hsk
->data
, hsk
->length
);
869 return gnutls_assert_val(ret
);
871 hsk
->data
.length
= hsk
->length
;
873 memmove(&hsk
->data
.data
[hsk
->start_offset
], hsk
->data
.data
, hsk
->end_offset
-hsk
->start_offset
+1);
876 session
->internals
.handshake_recv_buffer_size
++;
878 /* rewrite headers to make them look as each packet came as a single fragment */
879 _gnutls_write_uint24(hsk
->length
, &hsk
->header
[1]);
880 _gnutls_write_uint24(0, &hsk
->header
[6]);
881 _gnutls_write_uint24(hsk
->length
, &hsk
->header
[9]);
883 _gnutls_handshake_buffer_move(&session
->internals
.handshake_recv_buffer
[pos
], hsk
);
888 if (hsk
->start_offset
< session
->internals
.handshake_recv_buffer
[pos
].start_offset
&&
889 hsk
->end_offset
>= session
->internals
.handshake_recv_buffer
[pos
].start_offset
)
891 memcpy(&session
->internals
.handshake_recv_buffer
[pos
].data
.data
[hsk
->start_offset
],
892 hsk
->data
.data
, hsk
->data
.length
);
893 session
->internals
.handshake_recv_buffer
[pos
].start_offset
= hsk
->start_offset
;
894 session
->internals
.handshake_recv_buffer
[pos
].end_offset
=
895 MIN(hsk
->end_offset
, session
->internals
.handshake_recv_buffer
[pos
].end_offset
);
897 else if (hsk
->end_offset
> session
->internals
.handshake_recv_buffer
[pos
].end_offset
&&
898 hsk
->start_offset
<= session
->internals
.handshake_recv_buffer
[pos
].end_offset
+1)
900 memcpy(&session
->internals
.handshake_recv_buffer
[pos
].data
.data
[hsk
->start_offset
],
901 hsk
->data
.data
, hsk
->data
.length
);
903 session
->internals
.handshake_recv_buffer
[pos
].end_offset
= hsk
->end_offset
;
904 session
->internals
.handshake_recv_buffer
[pos
].start_offset
=
905 MIN(hsk
->start_offset
, session
->internals
.handshake_recv_buffer
[pos
].start_offset
);
907 _gnutls_handshake_buffer_clear(hsk
);
913 /* returns non-zero on match and zero on mismatch
915 inline static int cmp_hsk_types(gnutls_handshake_description_t expected
, gnutls_handshake_description_t recvd
)
917 if ((expected
!= GNUTLS_HANDSHAKE_CLIENT_HELLO
|| recvd
!= GNUTLS_HANDSHAKE_CLIENT_HELLO_V2
) &&
924 #define LAST_ELEMENT (session->internals.handshake_recv_buffer_size-1)
926 /* returns the last stored handshake packet.
928 static int get_last_packet(gnutls_session_t session
, gnutls_handshake_description_t htype
,
929 handshake_buffer_st
* hsk
, unsigned int optional
)
931 handshake_buffer_st
* recv_buf
= session
->internals
.handshake_recv_buffer
;
933 if (IS_DTLS(session
))
935 if (session
->internals
.handshake_recv_buffer_size
== 0 ||
936 (session
->internals
.dtls
.hsk_read_seq
!= recv_buf
[LAST_ELEMENT
].sequence
))
939 if (htype
!= recv_buf
[LAST_ELEMENT
].htype
)
942 _gnutls_audit_log(session
, "Received unexpected handshake message '%s' (%d). Expected '%s' (%d)\n",
943 _gnutls_handshake2str(recv_buf
[0].htype
), (int)recv_buf
[0].htype
, _gnutls_handshake2str(htype
), (int)htype
);
945 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET
);
948 else if ((recv_buf
[LAST_ELEMENT
].start_offset
== 0 &&
949 recv_buf
[LAST_ELEMENT
].end_offset
== recv_buf
[LAST_ELEMENT
].length
-1) ||
950 recv_buf
[LAST_ELEMENT
].length
== 0)
952 session
->internals
.dtls
.hsk_read_seq
++;
953 _gnutls_handshake_buffer_move(hsk
, &recv_buf
[LAST_ELEMENT
]);
954 session
->internals
.handshake_recv_buffer_size
--;
962 if (session
->internals
.handshake_recv_buffer_size
> 0 && recv_buf
[0].length
== recv_buf
[0].data
.length
)
964 if (cmp_hsk_types(htype
, recv_buf
[0].htype
) == 0)
966 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_HANDSHAKE_PACKET
);
969 _gnutls_handshake_buffer_move(hsk
, &recv_buf
[0]);
970 session
->internals
.handshake_recv_buffer_size
--;
974 return gnutls_assert_val(GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
);
978 RETURN_DTLS_EAGAIN_OR_TIMEOUT(session
, 0);
981 /* This is a receive function for the gnutls handshake
982 * protocol. Makes sure that we have received all data.
984 * htype is the next handshake packet expected.
987 _gnutls_parse_record_buffered_msgs (gnutls_session_t session
)
990 mbuffer_st
* bufel
= NULL
, *prev
= NULL
;
993 handshake_buffer_st
* recv_buf
= session
->internals
.handshake_recv_buffer
;
995 bufel
= _mbuffer_head_get_first(&session
->internals
.record_buffer
, &msg
);
997 return GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
;
999 if (!IS_DTLS(session
))
1001 ssize_t remain
, append
, header_size
;
1005 if (bufel
->type
!= GNUTLS_HANDSHAKE
)
1006 return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET
);
1008 /* if we have a half received message the complete it.
1010 remain
= recv_buf
[0].length
-
1011 recv_buf
[0].data
.length
;
1013 /* this is the rest of a previous message */
1014 if (session
->internals
.handshake_recv_buffer_size
> 0 && recv_buf
[0].length
> 0 && remain
> 0)
1016 if (msg
.size
<= remain
)
1021 ret
= _gnutls_buffer_append_data(&recv_buf
[0].data
, msg
.data
, append
);
1023 return gnutls_assert_val(ret
);
1025 _mbuffer_head_remove_bytes(&session
->internals
.record_buffer
, append
);
1027 else /* received new message */
1029 ret
= parse_handshake_header(session
, bufel
, &recv_buf
[0]);
1031 return gnutls_assert_val(ret
);
1034 session
->internals
.handshake_recv_buffer_size
= 1;
1036 _mbuffer_set_uhead_size(bufel
, header_size
);
1038 data_size
= MIN(recv_buf
[0].length
, _mbuffer_get_udata_size(bufel
));
1039 ret
= _gnutls_buffer_append_data(&recv_buf
[0].data
, _mbuffer_get_udata_ptr(bufel
), data_size
);
1041 return gnutls_assert_val(ret
);
1042 _mbuffer_set_uhead_size(bufel
, 0);
1043 _mbuffer_head_remove_bytes(&session
->internals
.record_buffer
, data_size
+header_size
);
1046 /* if packet is complete then return it
1048 if (recv_buf
[0].length
==
1049 recv_buf
[0].data
.length
)
1053 bufel
= _mbuffer_head_get_first(&session
->internals
.record_buffer
, &msg
);
1055 while(bufel
!= NULL
);
1057 /* if we are here it means that the received packets were not
1058 * enough to complete the handshake packet.
1060 return gnutls_assert_val(GNUTLS_E_AGAIN
);
1064 handshake_buffer_st tmp
;
1070 * 1. insert to handshake_recv_buffer
1071 * 2. sort handshake_recv_buffer on sequence numbers
1072 * 3. return first packet if completed or GNUTLS_E_AGAIN.
1076 if (bufel
->type
!= GNUTLS_HANDSHAKE
)
1079 goto next
; /* ignore packet */
1082 _gnutls_handshake_buffer_init(&tmp
);
1084 ret
= parse_handshake_header(session
, bufel
, &tmp
);
1088 _gnutls_audit_log(session
, "Invalid handshake packet headers. Discarding.\n");
1092 _mbuffer_consume(&session
->internals
.record_buffer
, bufel
, ret
);
1094 data_size
= MIN(tmp
.length
, tmp
.end_offset
-tmp
.start_offset
+1);
1096 ret
= _gnutls_buffer_append_data(&tmp
.data
, _mbuffer_get_udata_ptr(bufel
), data_size
);
1098 return gnutls_assert_val(ret
);
1100 _mbuffer_consume(&session
->internals
.record_buffer
, bufel
, data_size
);
1102 ret
= merge_handshake_packet(session
, &tmp
);
1104 return gnutls_assert_val(ret
);
1107 while(_mbuffer_get_udata_size(bufel
) > 0);
1110 bufel
= _mbuffer_dequeue(&session
->internals
.record_buffer
, bufel
);
1112 _mbuffer_xfree(&prev
);
1116 bufel
= _mbuffer_head_get_next(bufel
, NULL
);
1118 while(bufel
!= NULL
);
1120 /* sort in descending order */
1121 if (session
->internals
.handshake_recv_buffer_size
> 1)
1122 qsort(recv_buf
, session
->internals
.handshake_recv_buffer_size
,
1123 sizeof(recv_buf
[0]), handshake_compare
);
1125 while(session
->internals
.handshake_recv_buffer_size
> 0 &&
1126 recv_buf
[LAST_ELEMENT
].sequence
< session
->internals
.dtls
.hsk_read_seq
)
1128 _gnutls_audit_log(session
, "Discarded replayed handshake packet with sequence %d\n", recv_buf
[LAST_ELEMENT
].sequence
);
1129 _gnutls_handshake_buffer_clear(&recv_buf
[LAST_ELEMENT
]);
1130 session
->internals
.handshake_recv_buffer_size
--;
1137 /* This is a receive function for the gnutls handshake
1138 * protocol. Makes sure that we have received all data.
1141 _gnutls_handshake_io_recv_int (gnutls_session_t session
,
1142 gnutls_handshake_description_t htype
,
1143 handshake_buffer_st
* hsk
, unsigned int optional
)
1147 ret
= get_last_packet(session
, htype
, hsk
, optional
);
1148 if (ret
!= GNUTLS_E_AGAIN
&& ret
!= GNUTLS_E_INTERRUPTED
&& ret
!= GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
)
1150 return gnutls_assert_val(ret
);
1153 /* try using the already existing records before
1154 * trying to receive.
1156 ret
= _gnutls_parse_record_buffered_msgs(session
);
1158 if (ret
== 0) ret
= get_last_packet(session
, htype
, hsk
, optional
);
1160 if (IS_DTLS(session
))
1167 if ((ret
!= GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
&& ret
< 0) || ret
>= 0)
1168 return gnutls_assert_val(ret
);
1171 /* if we don't have a complete message waiting for us, try
1173 ret
= _gnutls_recv_in_buffers(session
, GNUTLS_HANDSHAKE
, htype
);
1175 return gnutls_assert_val_fatal(ret
);
1177 ret
= _gnutls_parse_record_buffered_msgs(session
);
1178 if (ret
== 0) ret
= get_last_packet(session
, htype
, hsk
, optional
);