Update copyright year
[openssl.git] / ssl / record / ssl3_buffer.c
1 /*
2  * Copyright 1995-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include "../ssl_locl.h"
11 #include "record_locl.h"
12
13 void SSL3_BUFFER_set_data(SSL3_BUFFER *b, const unsigned char *d, size_t n)
14 {
15     if (d != NULL)
16         memcpy(b->buf, d, n);
17     b->left = n;
18     b->offset = 0;
19 }
20
21 /*
22  * Clear the contents of an SSL3_BUFFER but retain any memory allocated. Also
23  * retains the default_len setting
24  */
25 void SSL3_BUFFER_clear(SSL3_BUFFER *b)
26 {
27     b->offset = 0;
28     b->left = 0;
29 }
30
31 void SSL3_BUFFER_release(SSL3_BUFFER *b)
32 {
33     OPENSSL_free(b->buf);
34     b->buf = NULL;
35 }
36
37 int ssl3_setup_read_buffer(SSL *s)
38 {
39     unsigned char *p;
40     size_t len, align = 0, headerlen;
41     SSL3_BUFFER *b;
42
43     b = RECORD_LAYER_get_rbuf(&s->rlayer);
44
45     if (SSL_IS_DTLS(s))
46         headerlen = DTLS1_RT_HEADER_LENGTH;
47     else
48         headerlen = SSL3_RT_HEADER_LENGTH;
49
50 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
51     align = (-SSL3_RT_HEADER_LENGTH) & (SSL3_ALIGN_PAYLOAD - 1);
52 #endif
53
54     if (b->buf == NULL) {
55         len = SSL3_RT_MAX_PLAIN_LENGTH
56             + SSL3_RT_MAX_ENCRYPTED_OVERHEAD + headerlen + align;
57 #ifndef OPENSSL_NO_COMP
58         if (ssl_allow_compression(s))
59             len += SSL3_RT_MAX_COMPRESSED_OVERHEAD;
60 #endif
61         if (b->default_len > len)
62             len = b->default_len;
63         if ((p = OPENSSL_malloc(len)) == NULL) {
64             /*
65              * We've got a malloc failure, and we're still initialising buffers.
66              * We assume we're so doomed that we won't even be able to send an
67              * alert.
68              */
69             SSLfatal(s, SSL_AD_NO_ALERT, SSL_F_SSL3_SETUP_READ_BUFFER,
70                      ERR_R_MALLOC_FAILURE);
71             return 0;
72         }
73         b->buf = p;
74         b->len = len;
75     }
76
77     RECORD_LAYER_set_packet(&s->rlayer, &(b->buf[0]));
78     return 1;
79 }
80
81 int ssl3_setup_write_buffer(SSL *s, size_t numwpipes, size_t len)
82 {
83     unsigned char *p;
84     size_t align = 0, headerlen;
85     SSL3_BUFFER *wb;
86     size_t currpipe;
87
88     s->rlayer.numwpipes = numwpipes;
89
90     if (len == 0) {
91         if (SSL_IS_DTLS(s))
92             headerlen = DTLS1_RT_HEADER_LENGTH + 1;
93         else
94             headerlen = SSL3_RT_HEADER_LENGTH;
95
96 #if defined(SSL3_ALIGN_PAYLOAD) && SSL3_ALIGN_PAYLOAD!=0
97         align = (-SSL3_RT_HEADER_LENGTH) & (SSL3_ALIGN_PAYLOAD - 1);
98 #endif
99
100         len = ssl_get_max_send_fragment(s)
101             + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD + headerlen + align;
102 #ifndef OPENSSL_NO_COMP
103         if (ssl_allow_compression(s))
104             len += SSL3_RT_MAX_COMPRESSED_OVERHEAD;
105 #endif
106         if (!(s->options & SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS))
107             len += headerlen + align + SSL3_RT_SEND_MAX_ENCRYPTED_OVERHEAD;
108     }
109
110     wb = RECORD_LAYER_get_wbuf(&s->rlayer);
111     for (currpipe = 0; currpipe < numwpipes; currpipe++) {
112         SSL3_BUFFER *thiswb = &wb[currpipe];
113
114         if (thiswb->buf != NULL && thiswb->len != len) {
115             OPENSSL_free(thiswb->buf);
116             thiswb->buf = NULL;         /* force reallocation */
117         }
118
119         if (thiswb->buf == NULL) {
120             p = OPENSSL_malloc(len);
121             if (p == NULL) {
122                 s->rlayer.numwpipes = currpipe;
123                 /*
124                  * We've got a malloc failure, and we're still initialising
125                  * buffers. We assume we're so doomed that we won't even be able
126                  * to send an alert.
127                  */
128                 SSLfatal(s, SSL_AD_NO_ALERT,
129                          SSL_F_SSL3_SETUP_WRITE_BUFFER, ERR_R_MALLOC_FAILURE);
130                 return 0;
131             }
132             memset(thiswb, 0, sizeof(SSL3_BUFFER));
133             thiswb->buf = p;
134             thiswb->len = len;
135         }
136     }
137
138     return 1;
139 }
140
141 int ssl3_setup_buffers(SSL *s)
142 {
143     if (!ssl3_setup_read_buffer(s)) {
144         /* SSLfatal() already called */
145         return 0;
146     }
147     if (!ssl3_setup_write_buffer(s, 1, 0)) {
148         /* SSLfatal() already called */
149         return 0;
150     }
151     return 1;
152 }
153
154 int ssl3_release_write_buffer(SSL *s)
155 {
156     SSL3_BUFFER *wb;
157     size_t pipes;
158
159     pipes = s->rlayer.numwpipes;
160     while (pipes > 0) {
161         wb = &RECORD_LAYER_get_wbuf(&s->rlayer)[pipes - 1];
162
163         OPENSSL_free(wb->buf);
164         wb->buf = NULL;
165         pipes--;
166     }
167     s->rlayer.numwpipes = 0;
168     return 1;
169 }
170
171 int ssl3_release_read_buffer(SSL *s)
172 {
173     SSL3_BUFFER *b;
174
175     b = RECORD_LAYER_get_rbuf(&s->rlayer);
176     OPENSSL_free(b->buf);
177     b->buf = NULL;
178     return 1;
179 }