Branch data Line data Source code
1 : : /* ssl/d1_lib.c */
2 : : /*
3 : : * DTLS implementation written by Nagendra Modadugu
4 : : * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.
5 : : */
6 : : /* ====================================================================
7 : : * Copyright (c) 1999-2005 The OpenSSL Project. All rights reserved.
8 : : *
9 : : * Redistribution and use in source and binary forms, with or without
10 : : * modification, are permitted provided that the following conditions
11 : : * are met:
12 : : *
13 : : * 1. Redistributions of source code must retain the above copyright
14 : : * notice, this list of conditions and the following disclaimer.
15 : : *
16 : : * 2. Redistributions in binary form must reproduce the above copyright
17 : : * notice, this list of conditions and the following disclaimer in
18 : : * the documentation and/or other materials provided with the
19 : : * distribution.
20 : : *
21 : : * 3. All advertising materials mentioning features or use of this
22 : : * software must display the following acknowledgment:
23 : : * "This product includes software developed by the OpenSSL Project
24 : : * for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25 : : *
26 : : * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27 : : * endorse or promote products derived from this software without
28 : : * prior written permission. For written permission, please contact
29 : : * openssl-core@OpenSSL.org.
30 : : *
31 : : * 5. Products derived from this software may not be called "OpenSSL"
32 : : * nor may "OpenSSL" appear in their names without prior written
33 : : * permission of the OpenSSL Project.
34 : : *
35 : : * 6. Redistributions of any form whatsoever must retain the following
36 : : * acknowledgment:
37 : : * "This product includes software developed by the OpenSSL Project
38 : : * for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39 : : *
40 : : * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41 : : * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 : : * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43 : : * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
44 : : * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 : : * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47 : : * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 : : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 : : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 : : * OF THE POSSIBILITY OF SUCH DAMAGE.
52 : : * ====================================================================
53 : : *
54 : : * This product includes cryptographic software written by Eric Young
55 : : * (eay@cryptsoft.com). This product includes software written by Tim
56 : : * Hudson (tjh@cryptsoft.com).
57 : : *
58 : : */
59 : :
60 : : #include <stdio.h>
61 : : #define USE_SOCKETS
62 : : #include <openssl/objects.h>
63 : : #include "ssl_locl.h"
64 : :
65 : : #if defined(OPENSSL_SYS_VMS)
66 : : #include <sys/timeb.h>
67 : : #endif
68 : :
69 : : static void get_current_time(struct timeval *t);
70 : : static void dtls1_set_handshake_header(SSL *s, int type, unsigned long len);
71 : : static int dtls1_handshake_write(SSL *s);
72 : : const char dtls1_version_str[]="DTLSv1" OPENSSL_VERSION_PTEXT;
73 : : int dtls1_listen(SSL *s, struct sockaddr *client);
74 : :
75 : : const SSL3_ENC_METHOD DTLSv1_enc_data={
76 : : tls1_enc,
77 : : tls1_mac,
78 : : tls1_setup_key_block,
79 : : tls1_generate_master_secret,
80 : : tls1_change_cipher_state,
81 : : tls1_final_finish_mac,
82 : : TLS1_FINISH_MAC_LENGTH,
83 : : tls1_cert_verify_mac,
84 : : TLS_MD_CLIENT_FINISH_CONST,TLS_MD_CLIENT_FINISH_CONST_SIZE,
85 : : TLS_MD_SERVER_FINISH_CONST,TLS_MD_SERVER_FINISH_CONST_SIZE,
86 : : tls1_alert_code,
87 : : tls1_export_keying_material,
88 : : SSL_ENC_FLAG_DTLS|SSL_ENC_FLAG_EXPLICIT_IV,
89 : : DTLS1_HM_HEADER_LENGTH,
90 : : dtls1_set_handshake_header,
91 : : dtls1_handshake_write
92 : : };
93 : :
94 : : const SSL3_ENC_METHOD DTLSv1_2_enc_data={
95 : : tls1_enc,
96 : : tls1_mac,
97 : : tls1_setup_key_block,
98 : : tls1_generate_master_secret,
99 : : tls1_change_cipher_state,
100 : : tls1_final_finish_mac,
101 : : TLS1_FINISH_MAC_LENGTH,
102 : : tls1_cert_verify_mac,
103 : : TLS_MD_CLIENT_FINISH_CONST,TLS_MD_CLIENT_FINISH_CONST_SIZE,
104 : : TLS_MD_SERVER_FINISH_CONST,TLS_MD_SERVER_FINISH_CONST_SIZE,
105 : : tls1_alert_code,
106 : : tls1_export_keying_material,
107 : : SSL_ENC_FLAG_DTLS|SSL_ENC_FLAG_EXPLICIT_IV|SSL_ENC_FLAG_SIGALGS
108 : : |SSL_ENC_FLAG_SHA256_PRF|SSL_ENC_FLAG_TLS1_2_CIPHERS,
109 : : DTLS1_HM_HEADER_LENGTH,
110 : : dtls1_set_handshake_header,
111 : : dtls1_handshake_write
112 : : };
113 : :
114 : 0 : long dtls1_default_timeout(void)
115 : : {
116 : : /* 2 hours, the 24 hours mentioned in the DTLSv1 spec
117 : : * is way too long for http, the cache would over fill */
118 : 0 : return(60*60*2);
119 : : }
120 : :
121 : 0 : int dtls1_new(SSL *s)
122 : : {
123 : : DTLS1_STATE *d1;
124 : :
125 [ # # ]: 0 : if (!ssl3_new(s)) return(0);
126 [ # # ]: 0 : if ((d1=OPENSSL_malloc(sizeof *d1)) == NULL) return (0);
127 : : memset(d1,0, sizeof *d1);
128 : :
129 : : /* d1->handshake_epoch=0; */
130 : :
131 : 0 : d1->unprocessed_rcds.q=pqueue_new();
132 : 0 : d1->processed_rcds.q=pqueue_new();
133 : 0 : d1->buffered_messages = pqueue_new();
134 : 0 : d1->sent_messages=pqueue_new();
135 : 0 : d1->buffered_app_data.q=pqueue_new();
136 : :
137 [ # # ]: 0 : if ( s->server)
138 : : {
139 : 0 : d1->cookie_len = sizeof(s->d1->cookie);
140 : : }
141 : :
142 [ # # ][ # # ]: 0 : if( ! d1->unprocessed_rcds.q || ! d1->processed_rcds.q
143 [ # # ][ # # ]: 0 : || ! d1->buffered_messages || ! d1->sent_messages || ! d1->buffered_app_data.q)
[ # # ]
144 : : {
145 [ # # ]: 0 : if ( d1->unprocessed_rcds.q) pqueue_free(d1->unprocessed_rcds.q);
146 [ # # ]: 0 : if ( d1->processed_rcds.q) pqueue_free(d1->processed_rcds.q);
147 [ # # ]: 0 : if ( d1->buffered_messages) pqueue_free(d1->buffered_messages);
148 [ # # ]: 0 : if ( d1->sent_messages) pqueue_free(d1->sent_messages);
149 [ # # ]: 0 : if ( d1->buffered_app_data.q) pqueue_free(d1->buffered_app_data.q);
150 : 0 : OPENSSL_free(d1);
151 : 0 : return (0);
152 : : }
153 : :
154 : 0 : s->d1=d1;
155 : 0 : s->method->ssl_clear(s);
156 : 0 : return(1);
157 : : }
158 : :
159 : 0 : static void dtls1_clear_queues(SSL *s)
160 : : {
161 : 0 : pitem *item = NULL;
162 : 0 : hm_fragment *frag = NULL;
163 : : DTLS1_RECORD_DATA *rdata;
164 : :
165 [ # # ]: 0 : while( (item = pqueue_pop(s->d1->unprocessed_rcds.q)) != NULL)
166 : : {
167 : 0 : rdata = (DTLS1_RECORD_DATA *) item->data;
168 [ # # ]: 0 : if (rdata->rbuf.buf)
169 : : {
170 : 0 : OPENSSL_free(rdata->rbuf.buf);
171 : : }
172 : 0 : OPENSSL_free(item->data);
173 : 0 : pitem_free(item);
174 : : }
175 : :
176 [ # # ]: 0 : while( (item = pqueue_pop(s->d1->processed_rcds.q)) != NULL)
177 : : {
178 : 0 : rdata = (DTLS1_RECORD_DATA *) item->data;
179 [ # # ]: 0 : if (rdata->rbuf.buf)
180 : : {
181 : 0 : OPENSSL_free(rdata->rbuf.buf);
182 : : }
183 : 0 : OPENSSL_free(item->data);
184 : 0 : pitem_free(item);
185 : : }
186 : :
187 [ # # ]: 0 : while( (item = pqueue_pop(s->d1->buffered_messages)) != NULL)
188 : : {
189 : 0 : frag = (hm_fragment *)item->data;
190 : 0 : OPENSSL_free(frag->fragment);
191 : 0 : OPENSSL_free(frag);
192 : 0 : pitem_free(item);
193 : : }
194 : :
195 [ # # ]: 0 : while ( (item = pqueue_pop(s->d1->sent_messages)) != NULL)
196 : : {
197 : 0 : frag = (hm_fragment *)item->data;
198 : 0 : OPENSSL_free(frag->fragment);
199 : 0 : OPENSSL_free(frag);
200 : 0 : pitem_free(item);
201 : : }
202 : :
203 [ # # ]: 0 : while ( (item = pqueue_pop(s->d1->buffered_app_data.q)) != NULL)
204 : : {
205 : 0 : rdata = (DTLS1_RECORD_DATA *) item->data;
206 [ # # ]: 0 : if (rdata->rbuf.buf)
207 : : {
208 : 0 : OPENSSL_free(rdata->rbuf.buf);
209 : : }
210 : 0 : OPENSSL_free(item->data);
211 : 0 : pitem_free(item);
212 : : }
213 : 0 : }
214 : :
215 : 0 : void dtls1_free(SSL *s)
216 : : {
217 : 0 : ssl3_free(s);
218 : :
219 : 0 : dtls1_clear_queues(s);
220 : :
221 : 0 : pqueue_free(s->d1->unprocessed_rcds.q);
222 : 0 : pqueue_free(s->d1->processed_rcds.q);
223 : 0 : pqueue_free(s->d1->buffered_messages);
224 : 0 : pqueue_free(s->d1->sent_messages);
225 : 0 : pqueue_free(s->d1->buffered_app_data.q);
226 : :
227 : 0 : OPENSSL_free(s->d1);
228 : 0 : s->d1 = NULL;
229 : 0 : }
230 : :
231 : 0 : void dtls1_clear(SSL *s)
232 : : {
233 : : pqueue unprocessed_rcds;
234 : : pqueue processed_rcds;
235 : : pqueue buffered_messages;
236 : : pqueue sent_messages;
237 : : pqueue buffered_app_data;
238 : : unsigned int mtu;
239 : :
240 [ # # ]: 0 : if (s->d1)
241 : : {
242 : 0 : unprocessed_rcds = s->d1->unprocessed_rcds.q;
243 : 0 : processed_rcds = s->d1->processed_rcds.q;
244 : 0 : buffered_messages = s->d1->buffered_messages;
245 : 0 : sent_messages = s->d1->sent_messages;
246 : 0 : buffered_app_data = s->d1->buffered_app_data.q;
247 : 0 : mtu = s->d1->mtu;
248 : :
249 : 0 : dtls1_clear_queues(s);
250 : :
251 : 0 : memset(s->d1, 0, sizeof(*(s->d1)));
252 : :
253 [ # # ]: 0 : if (s->server)
254 : : {
255 : 0 : s->d1->cookie_len = sizeof(s->d1->cookie);
256 : : }
257 : :
258 [ # # ]: 0 : if (SSL_get_options(s) & SSL_OP_NO_QUERY_MTU)
259 : : {
260 : 0 : s->d1->mtu = mtu;
261 : : }
262 : :
263 : 0 : s->d1->unprocessed_rcds.q = unprocessed_rcds;
264 : 0 : s->d1->processed_rcds.q = processed_rcds;
265 : 0 : s->d1->buffered_messages = buffered_messages;
266 : 0 : s->d1->sent_messages = sent_messages;
267 : 0 : s->d1->buffered_app_data.q = buffered_app_data;
268 : : }
269 : :
270 : 0 : ssl3_clear(s);
271 [ # # ]: 0 : if (s->options & SSL_OP_CISCO_ANYCONNECT)
272 : 0 : s->version=DTLS1_BAD_VER;
273 [ # # ]: 0 : else if (s->method->version == DTLS_ANY_VERSION)
274 : 0 : s->version=DTLS1_2_VERSION;
275 : : else
276 : 0 : s->version=s->method->version;
277 : 0 : }
278 : :
279 : 0 : long dtls1_ctrl(SSL *s, int cmd, long larg, void *parg)
280 : : {
281 : 0 : int ret=0;
282 : :
283 [ # # # # ]: 0 : switch (cmd)
284 : : {
285 : : case DTLS_CTRL_GET_TIMEOUT:
286 [ # # ]: 0 : if (dtls1_get_timeout(s, (struct timeval*) parg) != NULL)
287 : : {
288 : 0 : ret = 1;
289 : : }
290 : : break;
291 : : case DTLS_CTRL_HANDLE_TIMEOUT:
292 : 0 : ret = dtls1_handle_timeout(s);
293 : 0 : break;
294 : : case DTLS_CTRL_LISTEN:
295 : 0 : ret = dtls1_listen(s, parg);
296 : 0 : break;
297 : :
298 : : default:
299 : 0 : ret = ssl3_ctrl(s, cmd, larg, parg);
300 : 0 : break;
301 : : }
302 : 0 : return(ret);
303 : : }
304 : :
305 : : /*
306 : : * As it's impossible to use stream ciphers in "datagram" mode, this
307 : : * simple filter is designed to disengage them in DTLS. Unfortunately
308 : : * there is no universal way to identify stream SSL_CIPHER, so we have
309 : : * to explicitly list their SSL_* codes. Currently RC4 is the only one
310 : : * available, but if new ones emerge, they will have to be added...
311 : : */
312 : 0 : const SSL_CIPHER *dtls1_get_cipher(unsigned int u)
313 : : {
314 : 0 : const SSL_CIPHER *ciph = ssl3_get_cipher(u);
315 : :
316 [ # # ]: 0 : if (ciph != NULL)
317 : : {
318 [ # # ]: 0 : if (ciph->algorithm_enc == SSL_RC4)
319 : : return NULL;
320 : : }
321 : :
322 : 0 : return ciph;
323 : : }
324 : :
325 : 0 : void dtls1_start_timer(SSL *s)
326 : : {
327 : : #ifndef OPENSSL_NO_SCTP
328 : : /* Disable timer for SCTP */
329 : : if (BIO_dgram_is_sctp(SSL_get_wbio(s)))
330 : : {
331 : : memset(&(s->d1->next_timeout), 0, sizeof(struct timeval));
332 : : return;
333 : : }
334 : : #endif
335 : :
336 : : /* If timer is not set, initialize duration with 1 second */
337 [ # # ][ # # ]: 0 : if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0)
338 : : {
339 : 0 : s->d1->timeout_duration = 1;
340 : : }
341 : :
342 : : /* Set timeout to current time */
343 : 0 : get_current_time(&(s->d1->next_timeout));
344 : :
345 : : /* Add duration to current time */
346 : 0 : s->d1->next_timeout.tv_sec += s->d1->timeout_duration;
347 : 0 : BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0, &(s->d1->next_timeout));
348 : 0 : }
349 : :
350 : 0 : struct timeval* dtls1_get_timeout(SSL *s, struct timeval* timeleft)
351 : : {
352 : : struct timeval timenow;
353 : :
354 : : /* If no timeout is set, just return NULL */
355 [ # # ][ # # ]: 0 : if (s->d1->next_timeout.tv_sec == 0 && s->d1->next_timeout.tv_usec == 0)
356 : : {
357 : : return NULL;
358 : : }
359 : :
360 : : /* Get current time */
361 : 0 : get_current_time(&timenow);
362 : :
363 : : /* If timer already expired, set remaining time to 0 */
364 [ # # ][ # # ]: 0 : if (s->d1->next_timeout.tv_sec < timenow.tv_sec ||
365 [ # # ]: 0 : (s->d1->next_timeout.tv_sec == timenow.tv_sec &&
366 : 0 : s->d1->next_timeout.tv_usec <= timenow.tv_usec))
367 : : {
368 : : memset(timeleft, 0, sizeof(struct timeval));
369 : 0 : return timeleft;
370 : : }
371 : :
372 : : /* Calculate time left until timer expires */
373 : 0 : memcpy(timeleft, &(s->d1->next_timeout), sizeof(struct timeval));
374 : 0 : timeleft->tv_sec -= timenow.tv_sec;
375 : 0 : timeleft->tv_usec -= timenow.tv_usec;
376 [ # # ]: 0 : if (timeleft->tv_usec < 0)
377 : : {
378 : 0 : timeleft->tv_sec--;
379 : 0 : timeleft->tv_usec += 1000000;
380 : : }
381 : :
382 : : /* If remaining time is less than 15 ms, set it to 0
383 : : * to prevent issues because of small devergences with
384 : : * socket timeouts.
385 : : */
386 [ # # ][ # # ]: 0 : if (timeleft->tv_sec == 0 && timeleft->tv_usec < 15000)
387 : : {
388 : : memset(timeleft, 0, sizeof(struct timeval));
389 : : }
390 : :
391 : :
392 : 0 : return timeleft;
393 : : }
394 : :
395 : 0 : int dtls1_is_timer_expired(SSL *s)
396 : : {
397 : : struct timeval timeleft;
398 : :
399 : : /* Get time left until timeout, return false if no timer running */
400 [ # # ]: 0 : if (dtls1_get_timeout(s, &timeleft) == NULL)
401 : : {
402 : : return 0;
403 : : }
404 : :
405 : : /* Return false if timer is not expired yet */
406 [ # # ][ # # ]: 0 : if (timeleft.tv_sec > 0 || timeleft.tv_usec > 0)
407 : : {
408 : : return 0;
409 : : }
410 : :
411 : : /* Timer expired, so return true */
412 : 0 : return 1;
413 : : }
414 : :
415 : 0 : void dtls1_double_timeout(SSL *s)
416 : : {
417 : 0 : s->d1->timeout_duration *= 2;
418 [ # # ]: 0 : if (s->d1->timeout_duration > 60)
419 : 0 : s->d1->timeout_duration = 60;
420 : 0 : dtls1_start_timer(s);
421 : 0 : }
422 : :
423 : 0 : void dtls1_stop_timer(SSL *s)
424 : : {
425 : : /* Reset everything */
426 : 0 : memset(&(s->d1->timeout), 0, sizeof(struct dtls1_timeout_st));
427 : 0 : memset(&(s->d1->next_timeout), 0, sizeof(struct timeval));
428 : 0 : s->d1->timeout_duration = 1;
429 : 0 : BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT, 0, &(s->d1->next_timeout));
430 : : /* Clear retransmission buffer */
431 : 0 : dtls1_clear_record_buffer(s);
432 : 0 : }
433 : :
434 : 0 : int dtls1_check_timeout_num(SSL *s)
435 : : {
436 : 0 : s->d1->timeout.num_alerts++;
437 : :
438 : : /* Reduce MTU after 2 unsuccessful retransmissions */
439 [ # # ]: 0 : if (s->d1->timeout.num_alerts > 2)
440 : : {
441 : 0 : s->d1->mtu = BIO_ctrl(SSL_get_wbio(s), BIO_CTRL_DGRAM_GET_FALLBACK_MTU, 0, NULL);
442 : : }
443 : :
444 [ # # ]: 0 : if (s->d1->timeout.num_alerts > DTLS1_TMO_ALERT_COUNT)
445 : : {
446 : : /* fail the connection, enough alerts have been sent */
447 : 0 : SSLerr(SSL_F_DTLS1_CHECK_TIMEOUT_NUM,SSL_R_READ_TIMEOUT_EXPIRED);
448 : 0 : return -1;
449 : : }
450 : :
451 : : return 0;
452 : : }
453 : :
454 : 0 : int dtls1_handle_timeout(SSL *s)
455 : : {
456 : : /* if no timer is expired, don't do anything */
457 [ # # ]: 0 : if (!dtls1_is_timer_expired(s))
458 : : {
459 : : return 0;
460 : : }
461 : :
462 : 0 : dtls1_double_timeout(s);
463 : :
464 [ # # ]: 0 : if (dtls1_check_timeout_num(s) < 0)
465 : : return -1;
466 : :
467 : 0 : s->d1->timeout.read_timeouts++;
468 [ # # ]: 0 : if (s->d1->timeout.read_timeouts > DTLS1_TMO_READ_COUNT)
469 : : {
470 : 0 : s->d1->timeout.read_timeouts = 1;
471 : : }
472 : :
473 : : #ifndef OPENSSL_NO_HEARTBEATS
474 [ # # ]: 0 : if (s->tlsext_hb_pending)
475 : : {
476 : 0 : s->tlsext_hb_pending = 0;
477 : 0 : return dtls1_heartbeat(s);
478 : : }
479 : : #endif
480 : :
481 : 0 : dtls1_start_timer(s);
482 : 0 : return dtls1_retransmit_buffered_messages(s);
483 : : }
484 : :
485 : 0 : static void get_current_time(struct timeval *t)
486 : : {
487 : : #if defined(_WIN32)
488 : : SYSTEMTIME st;
489 : : union { unsigned __int64 ul; FILETIME ft; } now;
490 : :
491 : : GetSystemTime(&st);
492 : : SystemTimeToFileTime(&st,&now.ft);
493 : : #ifdef __MINGW32__
494 : : now.ul -= 116444736000000000ULL;
495 : : #else
496 : : now.ul -= 116444736000000000UI64; /* re-bias to 1/1/1970 */
497 : : #endif
498 : : t->tv_sec = (long)(now.ul/10000000);
499 : : t->tv_usec = ((int)(now.ul%10000000))/10;
500 : : #elif defined(OPENSSL_SYS_VMS)
501 : : struct timeb tb;
502 : : ftime(&tb);
503 : : t->tv_sec = (long)tb.time;
504 : : t->tv_usec = (long)tb.millitm * 1000;
505 : : #else
506 : 0 : gettimeofday(t, NULL);
507 : : #endif
508 : 0 : }
509 : :
510 : 0 : int dtls1_listen(SSL *s, struct sockaddr *client)
511 : : {
512 : : int ret;
513 : :
514 : 0 : SSL_set_options(s, SSL_OP_COOKIE_EXCHANGE);
515 : 0 : s->d1->listen = 1;
516 : :
517 : 0 : ret = SSL_accept(s);
518 [ # # ]: 0 : if (ret <= 0) return ret;
519 : :
520 : 0 : (void) BIO_dgram_get_peer(SSL_get_rbio(s), client);
521 : 0 : return 1;
522 : : }
523 : :
524 : 0 : static void dtls1_set_handshake_header(SSL *s, int htype, unsigned long len)
525 : : {
526 : 0 : unsigned char *p = (unsigned char *)s->init_buf->data;
527 : 0 : dtls1_set_message_header(s, p, htype, len, 0, len);
528 : 0 : s->init_num = (int)len + DTLS1_HM_HEADER_LENGTH;
529 : 0 : s->init_off = 0;
530 : : /* Buffer the message to handle re-xmits */
531 : 0 : dtls1_buffer_message(s, 0);
532 : 0 : }
533 : :
534 : 0 : static int dtls1_handshake_write(SSL *s)
535 : : {
536 : 0 : return dtls1_do_write(s, SSL3_RT_HANDSHAKE);
537 : : }
|
