Deleted Added
sdiff udiff text old ( 89837 ) new ( 100928 )
full compact
s3_pkt.c (89837) s3_pkt.c (100928)
1/* ssl/s3_pkt.c */
2/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
8 *

--- 42 unchanged lines hidden (view full) ---

51 * SUCH DAMAGE.
52 *
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
57 */
58/* ====================================================================
1/* ssl/s3_pkt.c */
2/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3 * All rights reserved.
4 *
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
8 *

--- 42 unchanged lines hidden (view full) ---

51 * SUCH DAMAGE.
52 *
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
57 */
58/* ====================================================================
59 * Copyright (c) 1998-2000 The OpenSSL Project. All rights reserved.
59 * Copyright (c) 1998-2002 The OpenSSL Project. All rights reserved.
60 *
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
63 * are met:
64 *
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
67 *

--- 44 unchanged lines hidden (view full) ---

112#include <stdio.h>
113#include <errno.h>
114#define USE_SOCKETS
115#include <openssl/evp.h>
116#include <openssl/buffer.h>
117#include "ssl_locl.h"
118
119static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
60 *
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
63 * are met:
64 *
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
67 *

--- 44 unchanged lines hidden (view full) ---

112#include <stdio.h>
113#include <errno.h>
114#define USE_SOCKETS
115#include <openssl/evp.h>
116#include <openssl/buffer.h>
117#include "ssl_locl.h"
118
119static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
120 unsigned int len);
120 unsigned int len, int create_empty_fragment);
121static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
122 unsigned int len);
123static int ssl3_get_record(SSL *s);
124static int do_compress(SSL *ssl);
125static int do_uncompress(SSL *ssl);
126static int do_change_cipher_spec(SSL *ssl);
127
128/* used only by ssl3_get_record */

--- 28 unchanged lines hidden (view full) ---

157 }
158
159 /* else we need to read more data */
160 if (!s->read_ahead)
161 max=n;
162
163 {
164 /* avoid buffer overflow */
121static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
122 unsigned int len);
123static int ssl3_get_record(SSL *s);
124static int do_compress(SSL *ssl);
125static int do_uncompress(SSL *ssl);
126static int do_change_cipher_spec(SSL *ssl);
127
128/* used only by ssl3_get_record */

--- 28 unchanged lines hidden (view full) ---

157 }
158
159 /* else we need to read more data */
160 if (!s->read_ahead)
161 max=n;
162
163 {
164 /* avoid buffer overflow */
165 int max_max = SSL3_RT_MAX_PACKET_SIZE - s->packet_length;
166 if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
167 max_max += SSL3_RT_MAX_EXTRA;
165 int max_max = s->s3->rbuf_len - s->packet_length;
168 if (max > max_max)
169 max = max_max;
170 }
171 if (n > max) /* does not happen */
172 {
173 SSLerr(SSL_F_SSL3_READ_N,SSL_R_INTERNAL_ERROR);
174 return -1;
175 }

--- 57 unchanged lines hidden (view full) ---

233 int ssl_major,ssl_minor,al;
234 int enc_err,n,i,ret= -1;
235 SSL3_RECORD *rr;
236 SSL_SESSION *sess;
237 unsigned char *p;
238 unsigned char md[EVP_MAX_MD_SIZE];
239 short version;
240 unsigned int mac_size;
166 if (max > max_max)
167 max = max_max;
168 }
169 if (n > max) /* does not happen */
170 {
171 SSLerr(SSL_F_SSL3_READ_N,SSL_R_INTERNAL_ERROR);
172 return -1;
173 }

--- 57 unchanged lines hidden (view full) ---

231 int ssl_major,ssl_minor,al;
232 int enc_err,n,i,ret= -1;
233 SSL3_RECORD *rr;
234 SSL_SESSION *sess;
235 unsigned char *p;
236 unsigned char md[EVP_MAX_MD_SIZE];
237 short version;
238 unsigned int mac_size;
241 int clear=0,extra;
239 int clear=0;
240 size_t extra;
242
243 rr= &(s->s3->rrec);
244 sess=s->session;
245
246 if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
247 extra=SSL3_RT_MAX_EXTRA;
248 else
249 extra=0;
241
242 rr= &(s->s3->rrec);
243 sess=s->session;
244
245 if (s->options & SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER)
246 extra=SSL3_RT_MAX_EXTRA;
247 else
248 extra=0;
249 if (extra != s->s3->rbuf_len - SSL3_RT_MAX_PACKET_SIZE)
250 {
251 /* actually likely an application error: SLS_OP_MICROSOFT_BIG_SSLV3_BUFFER
252 * set after ssl3_setup_buffers() was done */
253 SSLerr(SSL_F_SSL3_GET_RECORD, SSL_R_INTERNAL_ERROR);
254 return -1;
255 }
250
251again:
252 /* check if we have the header */
253 if ( (s->rstate != SSL_ST_READ_BODY) ||
254 (s->packet_length < SSL3_RT_HEADER_LENGTH))
255 {
256
257again:
258 /* check if we have the header */
259 if ( (s->rstate != SSL_ST_READ_BODY) ||
260 (s->packet_length < SSL3_RT_HEADER_LENGTH))
261 {
256 n=ssl3_read_n(s,SSL3_RT_HEADER_LENGTH,
257 SSL3_RT_MAX_PACKET_SIZE,0);
262 n=ssl3_read_n(s, SSL3_RT_HEADER_LENGTH, s->s3->rbuf_len, 0);
258 if (n <= 0) return(n); /* error or non-blocking */
259 s->rstate=SSL_ST_READ_BODY;
260
261 p=s->packet;
262
263 /* Pull apart the header into the SSL3_RECORD */
264 rr->type= *(p++);
265 ssl_major= *(p++);

--- 20 unchanged lines hidden (view full) ---

286 }
287
288 if ((version>>8) != SSL3_VERSION_MAJOR)
289 {
290 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_WRONG_VERSION_NUMBER);
291 goto err;
292 }
293
263 if (n <= 0) return(n); /* error or non-blocking */
264 s->rstate=SSL_ST_READ_BODY;
265
266 p=s->packet;
267
268 /* Pull apart the header into the SSL3_RECORD */
269 rr->type= *(p++);
270 ssl_major= *(p++);

--- 20 unchanged lines hidden (view full) ---

291 }
292
293 if ((version>>8) != SSL3_VERSION_MAJOR)
294 {
295 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_WRONG_VERSION_NUMBER);
296 goto err;
297 }
298
294 if (rr->length >
295 (unsigned int)SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
299 if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
296 {
297 al=SSL_AD_RECORD_OVERFLOW;
298 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PACKET_LENGTH_TOO_LONG);
299 goto f_err;
300 }
301
302 /* now s->rstate == SSL_ST_READ_BODY */
303 }
304
305 /* s->rstate == SSL_ST_READ_BODY, get and decode the data */
306
300 {
301 al=SSL_AD_RECORD_OVERFLOW;
302 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_PACKET_LENGTH_TOO_LONG);
303 goto f_err;
304 }
305
306 /* now s->rstate == SSL_ST_READ_BODY */
307 }
308
309 /* s->rstate == SSL_ST_READ_BODY, get and decode the data */
310
307 if (rr->length > (s->packet_length-SSL3_RT_HEADER_LENGTH))
311 if (rr->length > s->packet_length-SSL3_RT_HEADER_LENGTH)
308 {
309 /* now s->packet_length == SSL3_RT_HEADER_LENGTH */
310 i=rr->length;
311 n=ssl3_read_n(s,i,i,1);
312 if (n <= 0) return(n); /* error or non-blocking io */
313 /* now n == rr->length,
314 * and s->packet_length == SSL3_RT_HEADER_LENGTH + rr->length */
315 }

--- 11 unchanged lines hidden (view full) ---

327 * the decryption or by the decompression
328 * When the data is 'copied' into the rr->data buffer,
329 * rr->input will be pointed at the new buffer */
330
331 /* We now have - encrypted [ MAC [ compressed [ plain ] ] ]
332 * rr->length bytes of encrypted compressed stuff. */
333
334 /* check is not needed I believe */
312 {
313 /* now s->packet_length == SSL3_RT_HEADER_LENGTH */
314 i=rr->length;
315 n=ssl3_read_n(s,i,i,1);
316 if (n <= 0) return(n); /* error or non-blocking io */
317 /* now n == rr->length,
318 * and s->packet_length == SSL3_RT_HEADER_LENGTH + rr->length */
319 }

--- 11 unchanged lines hidden (view full) ---

331 * the decryption or by the decompression
332 * When the data is 'copied' into the rr->data buffer,
333 * rr->input will be pointed at the new buffer */
334
335 /* We now have - encrypted [ MAC [ compressed [ plain ] ] ]
336 * rr->length bytes of encrypted compressed stuff. */
337
338 /* check is not needed I believe */
335 if (rr->length > (unsigned int)SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
339 if (rr->length > SSL3_RT_MAX_ENCRYPTED_LENGTH+extra)
336 {
337 al=SSL_AD_RECORD_OVERFLOW;
338 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
339 goto f_err;
340 }
341
342 /* decrypt in place in 'rr->input' */
343 rr->data=rr->input;

--- 52 unchanged lines hidden (view full) ---

396 {
397 goto decryption_failed_or_bad_record_mac;
398 }
399 }
400
401 /* r->length is now just compressed */
402 if (s->expand != NULL)
403 {
340 {
341 al=SSL_AD_RECORD_OVERFLOW;
342 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_ENCRYPTED_LENGTH_TOO_LONG);
343 goto f_err;
344 }
345
346 /* decrypt in place in 'rr->input' */
347 rr->data=rr->input;

--- 52 unchanged lines hidden (view full) ---

400 {
401 goto decryption_failed_or_bad_record_mac;
402 }
403 }
404
405 /* r->length is now just compressed */
406 if (s->expand != NULL)
407 {
404 if (rr->length >
405 (unsigned int)SSL3_RT_MAX_COMPRESSED_LENGTH+extra)
408 if (rr->length > SSL3_RT_MAX_COMPRESSED_LENGTH+extra)
406 {
407 al=SSL_AD_RECORD_OVERFLOW;
408 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG);
409 goto f_err;
410 }
411 if (!do_uncompress(s))
412 {
413 al=SSL_AD_DECOMPRESSION_FAILURE;
414 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BAD_DECOMPRESSION);
415 goto f_err;
416 }
417 }
418
409 {
410 al=SSL_AD_RECORD_OVERFLOW;
411 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_COMPRESSED_LENGTH_TOO_LONG);
412 goto f_err;
413 }
414 if (!do_uncompress(s))
415 {
416 al=SSL_AD_DECOMPRESSION_FAILURE;
417 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_BAD_DECOMPRESSION);
418 goto f_err;
419 }
420 }
421
419 if (rr->length > (unsigned int)SSL3_RT_MAX_PLAIN_LENGTH+extra)
422 if (rr->length > SSL3_RT_MAX_PLAIN_LENGTH+extra)
420 {
421 al=SSL_AD_RECORD_OVERFLOW;
422 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DATA_LENGTH_TOO_LONG);
423 goto f_err;
424 }
425
426 rr->off=0;
427 /* So at this point the following is true

--- 76 unchanged lines hidden (view full) ---

504
505 if (SSL_in_init(s) && !s->in_handshake)
506 {
507 i=s->handshake_func(s);
508 if (i < 0) return(i);
509 if (i == 0)
510 {
511 SSLerr(SSL_F_SSL3_WRITE_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
423 {
424 al=SSL_AD_RECORD_OVERFLOW;
425 SSLerr(SSL_F_SSL3_GET_RECORD,SSL_R_DATA_LENGTH_TOO_LONG);
426 goto f_err;
427 }
428
429 rr->off=0;
430 /* So at this point the following is true

--- 76 unchanged lines hidden (view full) ---

507
508 if (SSL_in_init(s) && !s->in_handshake)
509 {
510 i=s->handshake_func(s);
511 if (i < 0) return(i);
512 if (i == 0)
513 {
514 SSLerr(SSL_F_SSL3_WRITE_BYTES,SSL_R_SSL_HANDSHAKE_FAILURE);
512 return(-1);
515 return -1;
513 }
514 }
515
516 n=(len-tot);
517 for (;;)
518 {
519 if (n > SSL3_RT_MAX_PLAIN_LENGTH)
520 nw=SSL3_RT_MAX_PLAIN_LENGTH;
521 else
522 nw=n;
523
516 }
517 }
518
519 n=(len-tot);
520 for (;;)
521 {
522 if (n > SSL3_RT_MAX_PLAIN_LENGTH)
523 nw=SSL3_RT_MAX_PLAIN_LENGTH;
524 else
525 nw=n;
526
524 i=do_ssl3_write(s,type,&(buf[tot]),nw);
527 i=do_ssl3_write(s, type, &(buf[tot]), nw, 0);
525 if (i <= 0)
526 {
527 s->s3->wnum=tot;
528 if (i <= 0)
529 {
530 s->s3->wnum=tot;
528 return(i);
531 return i;
529 }
530
531 if ((i == (int)n) ||
532 (type == SSL3_RT_APPLICATION_DATA &&
533 (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE)))
534 {
532 }
533
534 if ((i == (int)n) ||
535 (type == SSL3_RT_APPLICATION_DATA &&
536 (s->mode & SSL_MODE_ENABLE_PARTIAL_WRITE)))
537 {
535 return(tot+i);
538 /* next chunk of data should get another prepended empty fragment
539 * in ciphersuites with known-IV weakness: */
540 s->s3->empty_fragment_done = 0;
541
542 return tot+i;
536 }
537
538 n-=i;
539 tot+=i;
540 }
541 }
542
543static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
543 }
544
545 n-=i;
546 tot+=i;
547 }
548 }
549
550static int do_ssl3_write(SSL *s, int type, const unsigned char *buf,
544 unsigned int len)
551 unsigned int len, int create_empty_fragment)
545 {
546 unsigned char *p,*plen;
547 int i,mac_size,clear=0;
552 {
553 unsigned char *p,*plen;
554 int i,mac_size,clear=0;
555 int prefix_len = 0;
548 SSL3_RECORD *wr;
549 SSL3_BUFFER *wb;
550 SSL_SESSION *sess;
551
556 SSL3_RECORD *wr;
557 SSL3_BUFFER *wb;
558 SSL_SESSION *sess;
559
552 /* first check is there is a SSL3_RECORD still being written
560 /* first check if there is a SSL3_BUFFER still being written
553 * out. This will happen with non blocking IO */
554 if (s->s3->wbuf.left != 0)
555 return(ssl3_write_pending(s,type,buf,len));
556
557 /* If we have an alert to send, lets send it */
558 if (s->s3->alert_dispatch)
559 {
560 i=ssl3_dispatch_alert(s);
561 if (i <= 0)
562 return(i);
563 /* if it went, fall through and send more stuff */
564 }
565
561 * out. This will happen with non blocking IO */
562 if (s->s3->wbuf.left != 0)
563 return(ssl3_write_pending(s,type,buf,len));
564
565 /* If we have an alert to send, lets send it */
566 if (s->s3->alert_dispatch)
567 {
568 i=ssl3_dispatch_alert(s);
569 if (i <= 0)
570 return(i);
571 /* if it went, fall through and send more stuff */
572 }
573
566 if (len == 0) return(len);
574 if (len == 0 && !create_empty_fragment)
575 return 0;
567
568 wr= &(s->s3->wrec);
569 wb= &(s->s3->wbuf);
570 sess=s->session;
571
572 if ( (sess == NULL) ||
573 (s->enc_write_ctx == NULL) ||
574 (s->write_hash == NULL))
575 clear=1;
576
577 if (clear)
578 mac_size=0;
579 else
580 mac_size=EVP_MD_size(s->write_hash);
581
576
577 wr= &(s->s3->wrec);
578 wb= &(s->s3->wbuf);
579 sess=s->session;
580
581 if ( (sess == NULL) ||
582 (s->enc_write_ctx == NULL) ||
583 (s->write_hash == NULL))
584 clear=1;
585
586 if (clear)
587 mac_size=0;
588 else
589 mac_size=EVP_MD_size(s->write_hash);
590
582 p=wb->buf;
591 /* 'create_empty_fragment' is true only when this function calls itself */
592 if (!clear && !create_empty_fragment && !s->s3->empty_fragment_done)
593 {
594 /* countermeasure against known-IV weakness in CBC ciphersuites
595 * (see http://www.openssl.org/~bodo/tls-cbc.txt) */
583
596
597 if (s->s3->need_empty_fragments && type == SSL3_RT_APPLICATION_DATA)
598 {
599 /* recursive function call with 'create_empty_fragment' set;
600 * this prepares and buffers the data for an empty fragment
601 * (these 'prefix_len' bytes are sent out later
602 * together with the actual payload) */
603 prefix_len = do_ssl3_write(s, type, buf, 0, 1);
604 if (prefix_len <= 0)
605 goto err;
606
607 if (s->s3->wbuf_len < (size_t)prefix_len + SSL3_RT_MAX_PACKET_SIZE)
608 {
609 /* insufficient space */
610 SSLerr(SSL_F_DO_SSL3_WRITE, SSL_R_INTERNAL_ERROR);
611 goto err;
612 }
613 }
614
615 s->s3->empty_fragment_done = 1;
616 }
617
618 p = wb->buf + prefix_len;
619
584 /* write the header */
620 /* write the header */
621
585 *(p++)=type&0xff;
586 wr->type=type;
587
588 *(p++)=(s->version>>8);
589 *(p++)=s->version&0xff;
590
622 *(p++)=type&0xff;
623 wr->type=type;
624
625 *(p++)=(s->version>>8);
626 *(p++)=s->version&0xff;
627
591 /* record where we are to write out packet length */
628 /* field where we are to write out packet length */
592 plen=p;
593 p+=2;
594
595 /* lets setup the record stuff. */
596 wr->data=p;
597 wr->length=(int)len;
598 wr->input=(unsigned char *)buf;
599

--- 34 unchanged lines hidden (view full) ---

634 s2n(wr->length,plen);
635
636 /* we should now have
637 * wr->data pointing to the encrypted data, which is
638 * wr->length long */
639 wr->type=type; /* not needed but helps for debugging */
640 wr->length+=SSL3_RT_HEADER_LENGTH;
641
629 plen=p;
630 p+=2;
631
632 /* lets setup the record stuff. */
633 wr->data=p;
634 wr->length=(int)len;
635 wr->input=(unsigned char *)buf;
636

--- 34 unchanged lines hidden (view full) ---

671 s2n(wr->length,plen);
672
673 /* we should now have
674 * wr->data pointing to the encrypted data, which is
675 * wr->length long */
676 wr->type=type; /* not needed but helps for debugging */
677 wr->length+=SSL3_RT_HEADER_LENGTH;
678
642 /* Now lets setup wb */
643 wb->left=wr->length;
644 wb->offset=0;
679 if (create_empty_fragment)
680 {
681 /* we are in a recursive call;
682 * just return the length, don't write out anything here
683 */
684 return wr->length;
685 }
645
686
687 /* now let's set up wb */
688 wb->left = prefix_len + wr->length;
689 wb->offset = 0;
690
691 /* memorize arguments so that ssl3_write_pending can detect bad write retries later */
646 s->s3->wpend_tot=len;
647 s->s3->wpend_buf=buf;
648 s->s3->wpend_type=type;
649 s->s3->wpend_ret=len;
650
651 /* we now just need to write the buffer */
692 s->s3->wpend_tot=len;
693 s->s3->wpend_buf=buf;
694 s->s3->wpend_type=type;
695 s->s3->wpend_ret=len;
696
697 /* we now just need to write the buffer */
652 return(ssl3_write_pending(s,type,buf,len));
698 return ssl3_write_pending(s,type,buf,len);
653err:
699err:
654 return(-1);
700 return -1;
655 }
656
657/* if s->s3->wbuf.left != 0, we need to call this */
658static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
659 unsigned int len)
660 {
661 int i;
662

--- 409 unchanged lines hidden (view full) ---

1072
1073 switch (rr->type)
1074 {
1075 default:
1076#ifndef NO_TLS
1077 /* TLS just ignores unknown message types */
1078 if (s->version == TLS1_VERSION)
1079 {
701 }
702
703/* if s->s3->wbuf.left != 0, we need to call this */
704static int ssl3_write_pending(SSL *s, int type, const unsigned char *buf,
705 unsigned int len)
706 {
707 int i;
708

--- 409 unchanged lines hidden (view full) ---

1118
1119 switch (rr->type)
1120 {
1121 default:
1122#ifndef NO_TLS
1123 /* TLS just ignores unknown message types */
1124 if (s->version == TLS1_VERSION)
1125 {
1126 rr->length = 0;
1080 goto start;
1081 }
1082#endif
1083 al=SSL_AD_UNEXPECTED_MESSAGE;
1084 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
1085 goto f_err;
1086 case SSL3_RT_CHANGE_CIPHER_SPEC:
1087 case SSL3_RT_ALERT:

--- 20 unchanged lines hidden (view full) ---

1108 (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
1109 ) || (
1110 (s->state & SSL_ST_ACCEPT) &&
1111 (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
1112 (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
1113 )
1114 ))
1115 {
1127 goto start;
1128 }
1129#endif
1130 al=SSL_AD_UNEXPECTED_MESSAGE;
1131 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
1132 goto f_err;
1133 case SSL3_RT_CHANGE_CIPHER_SPEC:
1134 case SSL3_RT_ALERT:

--- 20 unchanged lines hidden (view full) ---

1155 (s->state <= SSL3_ST_CR_SRVR_HELLO_A)
1156 ) || (
1157 (s->state & SSL_ST_ACCEPT) &&
1158 (s->state <= SSL3_ST_SW_HELLO_REQ_A) &&
1159 (s->state >= SSL3_ST_SR_CLNT_HELLO_A)
1160 )
1161 ))
1162 {
1116 s->s3->in_read_app_data=0;
1163 s->s3->in_read_app_data=2;
1117 return(-1);
1118 }
1119 else
1120 {
1121 al=SSL_AD_UNEXPECTED_MESSAGE;
1122 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
1123 goto f_err;
1124 }

--- 69 unchanged lines hidden (view full) ---

1194 }
1195
1196int ssl3_dispatch_alert(SSL *s)
1197 {
1198 int i,j;
1199 void (*cb)()=NULL;
1200
1201 s->s3->alert_dispatch=0;
1164 return(-1);
1165 }
1166 else
1167 {
1168 al=SSL_AD_UNEXPECTED_MESSAGE;
1169 SSLerr(SSL_F_SSL3_READ_BYTES,SSL_R_UNEXPECTED_RECORD);
1170 goto f_err;
1171 }

--- 69 unchanged lines hidden (view full) ---

1241 }
1242
1243int ssl3_dispatch_alert(SSL *s)
1244 {
1245 int i,j;
1246 void (*cb)()=NULL;
1247
1248 s->s3->alert_dispatch=0;
1202 i=do_ssl3_write(s,SSL3_RT_ALERT,&s->s3->send_alert[0],2);
1249 i = do_ssl3_write(s, SSL3_RT_ALERT, &s->s3->send_alert[0], 2, 0);
1203 if (i <= 0)
1204 {
1205 s->s3->alert_dispatch=1;
1206 }
1207 else
1208 {
1209 /* Alert sent to BIO. If it is important, flush it now.
1210 * If the message does not get sent due to non-blocking IO,

--- 17 unchanged lines hidden --- 		1250 if (i <= 0)
1251 {
1252 s->s3->alert_dispatch=1;
1253 }
1254 else
1255 {
1256 /* Alert sent to BIO. If it is important, flush it now.
1257 * If the message does not get sent due to non-blocking IO,

--- 17 unchanged lines hidden ---