1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at https://curl.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * SPDX-License-Identifier: curl
22 *
23 ***************************************************************************/
24
25 #include "curl_setup.h"
26 #include "dynbuf.h"
27 #include "curl_printf.h"
28 #ifdef BUILDING_LIBCURL
29 #include "curl_memory.h"
30 #endif
31 #include "memdebug.h"
32
33 #define MIN_FIRST_ALLOC 32
34
35 #define DYNINIT 0xbee51da /* random pattern */
36
37 /*
38 * Init a dynbuf struct.
39 */
Curl_dyn_init(struct dynbuf * s,size_t toobig)40 void Curl_dyn_init(struct dynbuf *s, size_t toobig)
41 {
42 DEBUGASSERT(s);
43 DEBUGASSERT(toobig);
44 s->bufr = NULL;
45 s->leng = 0;
46 s->allc = 0;
47 s->toobig = toobig;
48 #ifdef DEBUGBUILD
49 s->init = DYNINIT;
50 #endif
51 }
52
53 /*
54 * free the buffer and re-init the necessary fields. It does not touch the
55 * 'init' field and thus this buffer can be reused to add data to again.
56 */
Curl_dyn_free(struct dynbuf * s)57 void Curl_dyn_free(struct dynbuf *s)
58 {
59 DEBUGASSERT(s);
60 Curl_safefree(s->bufr);
61 s->leng = s->allc = 0;
62 }
63
64 /*
65 * Store/append an chunk of memory to the dynbuf.
66 */
dyn_nappend(struct dynbuf * s,const unsigned char * mem,size_t len)67 static CURLcode dyn_nappend(struct dynbuf *s,
68 const unsigned char *mem, size_t len)
69 {
70 size_t indx = s->leng;
71 size_t a = s->allc;
72 size_t fit = len + indx + 1; /* new string + old string + zero byte */
73
74 /* try to detect if there is rubbish in the struct */
75 DEBUGASSERT(s->init == DYNINIT);
76 DEBUGASSERT(s->toobig);
77 DEBUGASSERT(indx < s->toobig);
78 DEBUGASSERT(!s->leng || s->bufr);
79 DEBUGASSERT(a <= s->toobig);
80 DEBUGASSERT(!len || mem);
81
82 if(fit > s->toobig) {
83 Curl_dyn_free(s);
84 return CURLE_TOO_LARGE;
85 }
86 else if(!a) {
87 DEBUGASSERT(!indx);
88 /* first invoke */
89 if(MIN_FIRST_ALLOC > s->toobig)
90 a = s->toobig;
91 else if(fit < MIN_FIRST_ALLOC)
92 a = MIN_FIRST_ALLOC;
93 else
94 a = fit;
95 }
96 else {
97 while(a < fit)
98 a *= 2;
99 if(a > s->toobig)
100 /* no point in allocating a larger buffer than this is allowed to use */
101 a = s->toobig;
102 }
103
104 if(a != s->allc) {
105 /* this logic is not using Curl_saferealloc() to make the tool not have to
106 include that as well when it uses this code */
107 void *p = realloc(s->bufr, a);
108 if(!p) {
109 Curl_dyn_free(s);
110 return CURLE_OUT_OF_MEMORY;
111 }
112 s->bufr = p;
113 s->allc = a;
114 }
115
116 if(len)
117 memcpy(&s->bufr[indx], mem, len);
118 s->leng = indx + len;
119 s->bufr[s->leng] = 0;
120 return CURLE_OK;
121 }
122
123 /*
124 * Clears the string, keeps the allocation. This can also be called on a
125 * buffer that already was freed.
126 */
Curl_dyn_reset(struct dynbuf * s)127 void Curl_dyn_reset(struct dynbuf *s)
128 {
129 DEBUGASSERT(s);
130 DEBUGASSERT(s->init == DYNINIT);
131 DEBUGASSERT(!s->leng || s->bufr);
132 if(s->leng)
133 s->bufr[0] = 0;
134 s->leng = 0;
135 }
136
137 /*
138 * Specify the size of the tail to keep (number of bytes from the end of the
139 * buffer). The rest will be dropped.
140 */
Curl_dyn_tail(struct dynbuf * s,size_t trail)141 CURLcode Curl_dyn_tail(struct dynbuf *s, size_t trail)
142 {
143 DEBUGASSERT(s);
144 DEBUGASSERT(s->init == DYNINIT);
145 DEBUGASSERT(!s->leng || s->bufr);
146 if(trail > s->leng)
147 return CURLE_BAD_FUNCTION_ARGUMENT;
148 else if(trail == s->leng)
149 return CURLE_OK;
150 else if(!trail) {
151 Curl_dyn_reset(s);
152 }
153 else {
154 memmove(&s->bufr[0], &s->bufr[s->leng - trail], trail);
155 s->leng = trail;
156 s->bufr[s->leng] = 0;
157 }
158 return CURLE_OK;
159
160 }
161
162 /*
163 * Appends a buffer with length.
164 */
Curl_dyn_addn(struct dynbuf * s,const void * mem,size_t len)165 CURLcode Curl_dyn_addn(struct dynbuf *s, const void *mem, size_t len)
166 {
167 DEBUGASSERT(s);
168 DEBUGASSERT(s->init == DYNINIT);
169 DEBUGASSERT(!s->leng || s->bufr);
170 return dyn_nappend(s, mem, len);
171 }
172
173 /*
174 * Append a null-terminated string at the end.
175 */
Curl_dyn_add(struct dynbuf * s,const char * str)176 CURLcode Curl_dyn_add(struct dynbuf *s, const char *str)
177 {
178 size_t n;
179 DEBUGASSERT(str);
180 DEBUGASSERT(s);
181 DEBUGASSERT(s->init == DYNINIT);
182 DEBUGASSERT(!s->leng || s->bufr);
183 n = strlen(str);
184 return dyn_nappend(s, (unsigned char *)str, n);
185 }
186
187 /*
188 * Append a string vprintf()-style
189 */
Curl_dyn_vaddf(struct dynbuf * s,const char * fmt,va_list ap)190 CURLcode Curl_dyn_vaddf(struct dynbuf *s, const char *fmt, va_list ap)
191 {
192 #ifdef BUILDING_LIBCURL
193 int rc;
194 DEBUGASSERT(s);
195 DEBUGASSERT(s->init == DYNINIT);
196 DEBUGASSERT(!s->leng || s->bufr);
197 DEBUGASSERT(fmt);
198 rc = Curl_dyn_vprintf(s, fmt, ap);
199
200 if(!rc)
201 return CURLE_OK;
202 else if(rc == MERR_TOO_LARGE)
203 return CURLE_TOO_LARGE;
204 return CURLE_OUT_OF_MEMORY;
205 #else
206 char *str;
207 str = vaprintf(fmt, ap); /* this allocs a new string to append */
208
209 if(str) {
210 CURLcode result = dyn_nappend(s, (unsigned char *)str, strlen(str));
211 free(str);
212 return result;
213 }
214 /* If we failed, we cleanup the whole buffer and return error */
215 Curl_dyn_free(s);
216 return CURLE_OUT_OF_MEMORY;
217 #endif
218 }
219
220 /*
221 * Append a string printf()-style
222 */
Curl_dyn_addf(struct dynbuf * s,const char * fmt,...)223 CURLcode Curl_dyn_addf(struct dynbuf *s, const char *fmt, ...)
224 {
225 CURLcode result;
226 va_list ap;
227 DEBUGASSERT(s);
228 DEBUGASSERT(s->init == DYNINIT);
229 DEBUGASSERT(!s->leng || s->bufr);
230 va_start(ap, fmt);
231 result = Curl_dyn_vaddf(s, fmt, ap);
232 va_end(ap);
233 return result;
234 }
235
236 /*
237 * Returns a pointer to the buffer.
238 */
Curl_dyn_ptr(const struct dynbuf * s)239 char *Curl_dyn_ptr(const struct dynbuf *s)
240 {
241 DEBUGASSERT(s);
242 DEBUGASSERT(s->init == DYNINIT);
243 DEBUGASSERT(!s->leng || s->bufr);
244 return s->bufr;
245 }
246
Curl_dyn_take(struct dynbuf * s,size_t * plen)247 char *Curl_dyn_take(struct dynbuf *s, size_t *plen)
248 {
249 char *ptr = s->bufr;
250 DEBUGASSERT(s);
251 DEBUGASSERT(s->init == DYNINIT);
252 *plen = s->leng;
253 s->bufr = NULL;
254 s->leng = 0;
255 s->allc = 0;
256 return ptr;
257 }
258
259 /*
260 * Returns an unsigned pointer to the buffer.
261 */
Curl_dyn_uptr(const struct dynbuf * s)262 unsigned char *Curl_dyn_uptr(const struct dynbuf *s)
263 {
264 DEBUGASSERT(s);
265 DEBUGASSERT(s->init == DYNINIT);
266 DEBUGASSERT(!s->leng || s->bufr);
267 return (unsigned char *)s->bufr;
268 }
269
270 /*
271 * Returns the length of the buffer.
272 */
Curl_dyn_len(const struct dynbuf * s)273 size_t Curl_dyn_len(const struct dynbuf *s)
274 {
275 DEBUGASSERT(s);
276 DEBUGASSERT(s->init == DYNINIT);
277 DEBUGASSERT(!s->leng || s->bufr);
278 return s->leng;
279 }
280
281 /*
282 * Set a new (smaller) length.
283 */
Curl_dyn_setlen(struct dynbuf * s,size_t set)284 CURLcode Curl_dyn_setlen(struct dynbuf *s, size_t set)
285 {
286 DEBUGASSERT(s);
287 DEBUGASSERT(s->init == DYNINIT);
288 DEBUGASSERT(!s->leng || s->bufr);
289 if(set > s->leng)
290 return CURLE_BAD_FUNCTION_ARGUMENT;
291 s->leng = set;
292 s->bufr[s->leng] = 0;
293 return CURLE_OK;
294 }
295
