1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
2  * All rights reserved.
3  *
4  * This package is an SSL implementation written
5  * by Eric Young (eay@cryptsoft.com).
6  * The implementation was written so as to conform with Netscapes SSL.
7  *
8  * This library is free for commercial and non-commercial use as long as
9  * the following conditions are aheared to.  The following conditions
10  * apply to all code found in this distribution, be it the RC4, RSA,
11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
12  * included with this distribution is covered by the same copyright terms
13  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
14  *
15  * Copyright remains Eric Young's, and as such any Copyright notices in
16  * the code are not to be removed.
17  * If this package is used in a product, Eric Young should be given attribution
18  * as the author of the parts of the library used.
19  * This can be in the form of a textual message at program startup or
20  * in documentation (online or textual) provided with the package.
21  *
22  * Redistribution and use in source and binary forms, with or without
23  * modification, are permitted provided that the following conditions
24  * are met:
25  * 1. Redistributions of source code must retain the copyright
26  *    notice, this list of conditions and the following disclaimer.
27  * 2. Redistributions in binary form must reproduce the above copyright
28  *    notice, this list of conditions and the following disclaimer in the
29  *    documentation and/or other materials provided with the distribution.
30  * 3. All advertising materials mentioning features or use of this software
31  *    must display the following acknowledgement:
32  *    "This product includes cryptographic software written by
33  *     Eric Young (eay@cryptsoft.com)"
34  *    The word 'cryptographic' can be left out if the rouines from the library
35  *    being used are not cryptographic related :-).
36  * 4. If you include any Windows specific code (or a derivative thereof) from
37  *    the apps directory (application code) you must include an acknowledgement:
38  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
50  * SUCH DAMAGE.
51  *
52  * The licence and distribution terms for any publically available version or
53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
54  * copied and put under another distribution licence
55  * [including the GNU Public Licence.] */
56 
57 #include <openssl/buf.h>
58 
59 #include <string.h>
60 
61 #include <openssl/mem.h>
62 #include <openssl/err.h>
63 
64 
BUF_MEM_new(void)65 BUF_MEM *BUF_MEM_new(void) {
66   BUF_MEM *ret;
67 
68   ret = OPENSSL_malloc(sizeof(BUF_MEM));
69   if (ret == NULL) {
70     OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
71     return NULL;
72   }
73 
74   memset(ret, 0, sizeof(BUF_MEM));
75   return ret;
76 }
77 
BUF_MEM_free(BUF_MEM * buf)78 void BUF_MEM_free(BUF_MEM *buf) {
79   if (buf == NULL) {
80     return;
81   }
82 
83   if (buf->data != NULL) {
84     OPENSSL_cleanse(buf->data, buf->max);
85     OPENSSL_free(buf->data);
86   }
87 
88   OPENSSL_free(buf);
89 }
90 
buf_mem_grow(BUF_MEM * buf,size_t len,char clean)91 static size_t buf_mem_grow(BUF_MEM *buf, size_t len, char clean) {
92   char *new_buf;
93   size_t n, alloc_size;
94 
95   if (buf->length >= len) {
96     buf->length = len;
97     return len;
98   }
99   if (buf->max >= len) {
100     memset(&buf->data[buf->length], 0, len - buf->length);
101     buf->length = len;
102     return len;
103   }
104 
105   n = len + 3;
106   if (n < len) {
107     /* overflow */
108     OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
109     return 0;
110   }
111   n = n / 3;
112   alloc_size = n * 4;
113   if (alloc_size / 4 != n) {
114     /* overflow */
115     OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
116     return 0;
117   }
118 
119   if (buf->data == NULL) {
120     new_buf = OPENSSL_malloc(alloc_size);
121   } else {
122     if (clean) {
123       new_buf = OPENSSL_realloc_clean(buf->data, buf->max, alloc_size);
124     } else {
125       new_buf = OPENSSL_realloc(buf->data, alloc_size);
126     }
127   }
128 
129   if (new_buf == NULL) {
130     OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
131     len = 0;
132   } else {
133     buf->data = new_buf;
134     buf->max = alloc_size;
135     memset(&buf->data[buf->length], 0, len - buf->length);
136     buf->length = len;
137   }
138 
139   return len;
140 }
141 
BUF_MEM_grow(BUF_MEM * buf,size_t len)142 size_t BUF_MEM_grow(BUF_MEM *buf, size_t len) {
143   return buf_mem_grow(buf, len, 0 /* don't clear old buffer contents. */);
144 }
145 
BUF_MEM_grow_clean(BUF_MEM * buf,size_t len)146 size_t BUF_MEM_grow_clean(BUF_MEM *buf, size_t len) {
147   return buf_mem_grow(buf, len, 1 /* clear old buffer contents. */);
148 }
149 
BUF_strdup(const char * buf)150 char *BUF_strdup(const char *buf) {
151   if (buf == NULL) {
152     return NULL;
153   }
154 
155   return BUF_strndup(buf, strlen(buf));
156 }
157 
BUF_strnlen(const char * str,size_t max_len)158 size_t BUF_strnlen(const char *str, size_t max_len) {
159   size_t i;
160 
161   for (i = 0; i < max_len; i++) {
162     if (str[i] == 0) {
163       break;
164     }
165   }
166 
167   return i;
168 }
169 
BUF_strndup(const char * buf,size_t size)170 char *BUF_strndup(const char *buf, size_t size) {
171   char *ret;
172   size_t alloc_size;
173 
174   if (buf == NULL) {
175     return NULL;
176   }
177 
178   size = BUF_strnlen(buf, size);
179 
180   alloc_size = size + 1;
181   if (alloc_size < size) {
182     /* overflow */
183     OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
184     return NULL;
185   }
186   ret = OPENSSL_malloc(alloc_size);
187   if (ret == NULL) {
188     OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
189     return NULL;
190   }
191 
192   memcpy(ret, buf, size);
193   ret[size] = '\0';
194   return ret;
195 }
196 
BUF_strlcpy(char * dst,const char * src,size_t dst_size)197 size_t BUF_strlcpy(char *dst, const char *src, size_t dst_size) {
198   size_t l = 0;
199 
200   for (; dst_size > 1 && *src; dst_size--) {
201     *dst++ = *src++;
202     l++;
203   }
204 
205   if (dst_size) {
206     *dst = 0;
207   }
208 
209   return l + strlen(src);
210 }
211 
BUF_strlcat(char * dst,const char * src,size_t dst_size)212 size_t BUF_strlcat(char *dst, const char *src, size_t dst_size) {
213   size_t l = 0;
214   for (; dst_size > 0 && *dst; dst_size--, dst++) {
215     l++;
216   }
217   return l + BUF_strlcpy(dst, src, dst_size);
218 }
219 
BUF_memdup(const void * data,size_t dst_size)220 void *BUF_memdup(const void *data, size_t dst_size) {
221   void *ret;
222 
223   if (dst_size == 0) {
224     return NULL;
225   }
226 
227   ret = OPENSSL_malloc(dst_size);
228   if (ret == NULL) {
229     OPENSSL_PUT_ERROR(BUF, ERR_R_MALLOC_FAILURE);
230     return NULL;
231   }
232 
233   memcpy(ret, data, dst_size);
234   return ret;
235 }
236