1 /* Copyright (c) 2008 The NetBSD Foundation, Inc.
2 * All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
14 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
15 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
16 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
18 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
20 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
22 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
23 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
24 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
25
26 #include "atf-c/detail/dynstr.h"
27
28 #include <errno.h>
29 #include <stdarg.h>
30 #include <stdint.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34
35 #include "atf-c/detail/sanity.h"
36 #include "atf-c/detail/text.h"
37 #include "atf-c/error.h"
38
39 /* ---------------------------------------------------------------------
40 * Auxiliary functions.
41 * --------------------------------------------------------------------- */
42
43 static
44 atf_error_t
resize(atf_dynstr_t * ad,size_t newsize)45 resize(atf_dynstr_t *ad, size_t newsize)
46 {
47 char *newdata;
48 atf_error_t err;
49
50 PRE(newsize > ad->m_datasize);
51
52 newdata = (char *)malloc(newsize);
53 if (newdata == NULL) {
54 err = atf_no_memory_error();
55 } else {
56 strcpy(newdata, ad->m_data);
57 free(ad->m_data);
58 ad->m_data = newdata;
59 ad->m_datasize = newsize;
60 err = atf_no_error();
61 }
62
63 return err;
64 }
65
66 static
67 atf_error_t
prepend_or_append(atf_dynstr_t * ad,const char * fmt,va_list ap,bool prepend)68 prepend_or_append(atf_dynstr_t *ad, const char *fmt, va_list ap,
69 bool prepend)
70 {
71 char *aux;
72 atf_error_t err;
73 size_t newlen;
74 va_list ap2;
75
76 va_copy(ap2, ap);
77 err = atf_text_format_ap(&aux, fmt, ap2);
78 va_end(ap2);
79 if (atf_is_error(err))
80 goto out;
81 newlen = ad->m_length + strlen(aux);
82
83 if (newlen + sizeof(char) > ad->m_datasize) {
84 err = resize(ad, newlen + sizeof(char));
85 if (atf_is_error(err))
86 goto out_free;
87 }
88
89 if (prepend) {
90 memmove(ad->m_data + strlen(aux), ad->m_data, ad->m_length + 1);
91 memcpy(ad->m_data, aux, strlen(aux));
92 } else
93 strcpy(ad->m_data + ad->m_length, aux);
94 ad->m_length = newlen;
95 err = atf_no_error();
96
97 out_free:
98 free(aux);
99 out:
100 return err;
101 }
102
103 /* ---------------------------------------------------------------------
104 * The "atf_dynstr" type.
105 * --------------------------------------------------------------------- */
106
107 /*
108 * Constants.
109 */
110
111 const size_t atf_dynstr_npos = SIZE_MAX;
112
113 /*
114 * Constructors and destructors.
115 */
116
117 atf_error_t
atf_dynstr_init(atf_dynstr_t * ad)118 atf_dynstr_init(atf_dynstr_t *ad)
119 {
120 atf_error_t err;
121
122 ad->m_data = (char *)malloc(sizeof(char));
123 if (ad->m_data == NULL) {
124 err = atf_no_memory_error();
125 goto out;
126 }
127
128 ad->m_data[0] = '\0';
129 ad->m_datasize = 1;
130 ad->m_length = 0;
131 err = atf_no_error();
132
133 out:
134 return err;
135 }
136
137 atf_error_t
atf_dynstr_init_ap(atf_dynstr_t * ad,const char * fmt,va_list ap)138 atf_dynstr_init_ap(atf_dynstr_t *ad, const char *fmt, va_list ap)
139 {
140 atf_error_t err;
141
142 ad->m_datasize = strlen(fmt) + 1;
143 ad->m_length = 0;
144
145 do {
146 va_list ap2;
147 int ret;
148
149 ad->m_datasize *= 2;
150 ad->m_data = (char *)malloc(ad->m_datasize);
151 if (ad->m_data == NULL) {
152 err = atf_no_memory_error();
153 goto out;
154 }
155
156 va_copy(ap2, ap);
157 ret = vsnprintf(ad->m_data, ad->m_datasize, fmt, ap2);
158 va_end(ap2);
159 if (ret < 0) {
160 free(ad->m_data);
161 err = atf_libc_error(errno, "Cannot format string");
162 goto out;
163 }
164
165 INV(ret >= 0);
166 if ((size_t)ret >= ad->m_datasize) {
167 free(ad->m_data);
168 ad->m_data = NULL;
169 }
170 ad->m_length = ret;
171 } while (ad->m_length >= ad->m_datasize);
172
173 err = atf_no_error();
174 out:
175 POST(atf_is_error(err) || ad->m_data != NULL);
176 return err;
177 }
178
179 atf_error_t
atf_dynstr_init_fmt(atf_dynstr_t * ad,const char * fmt,...)180 atf_dynstr_init_fmt(atf_dynstr_t *ad, const char *fmt, ...)
181 {
182 va_list ap;
183 atf_error_t err;
184
185 va_start(ap, fmt);
186 err = atf_dynstr_init_ap(ad, fmt, ap);
187 va_end(ap);
188
189 return err;
190 }
191
192 atf_error_t
atf_dynstr_init_raw(atf_dynstr_t * ad,const void * mem,size_t memlen)193 atf_dynstr_init_raw(atf_dynstr_t *ad, const void *mem, size_t memlen)
194 {
195 atf_error_t err;
196
197 if (memlen >= SIZE_MAX - 1) {
198 err = atf_no_memory_error();
199 goto out;
200 }
201
202 ad->m_data = (char *)malloc(memlen + 1);
203 if (ad->m_data == NULL) {
204 err = atf_no_memory_error();
205 goto out;
206 }
207
208 ad->m_datasize = memlen + 1;
209 memcpy(ad->m_data, mem, memlen);
210 ad->m_data[memlen] = '\0';
211 ad->m_length = strlen(ad->m_data);
212 INV(ad->m_length <= memlen);
213 err = atf_no_error();
214
215 out:
216 return err;
217 }
218
219 atf_error_t
atf_dynstr_init_rep(atf_dynstr_t * ad,size_t len,char ch)220 atf_dynstr_init_rep(atf_dynstr_t *ad, size_t len, char ch)
221 {
222 atf_error_t err;
223
224 if (len == SIZE_MAX) {
225 err = atf_no_memory_error();
226 goto out;
227 }
228
229 ad->m_datasize = (len + 1) * sizeof(char);
230 ad->m_data = (char *)malloc(ad->m_datasize);
231 if (ad->m_data == NULL) {
232 err = atf_no_memory_error();
233 goto out;
234 }
235
236 memset(ad->m_data, ch, len);
237 ad->m_data[len] = '\0';
238 ad->m_length = len;
239 err = atf_no_error();
240
241 out:
242 return err;
243 }
244
245 atf_error_t
atf_dynstr_init_substr(atf_dynstr_t * ad,const atf_dynstr_t * src,size_t beg,size_t end)246 atf_dynstr_init_substr(atf_dynstr_t *ad, const atf_dynstr_t *src,
247 size_t beg, size_t end)
248 {
249 if (beg > src->m_length)
250 beg = src->m_length;
251
252 if (end == atf_dynstr_npos || end > src->m_length)
253 end = src->m_length;
254
255 return atf_dynstr_init_raw(ad, src->m_data + beg, end - beg);
256 }
257
258 atf_error_t
atf_dynstr_copy(atf_dynstr_t * dest,const atf_dynstr_t * src)259 atf_dynstr_copy(atf_dynstr_t *dest, const atf_dynstr_t *src)
260 {
261 atf_error_t err;
262
263 dest->m_data = (char *)malloc(src->m_datasize);
264 if (dest->m_data == NULL)
265 err = atf_no_memory_error();
266 else {
267 memcpy(dest->m_data, src->m_data, src->m_datasize);
268 dest->m_datasize = src->m_datasize;
269 dest->m_length = src->m_length;
270 err = atf_no_error();
271 }
272
273 return err;
274 }
275
276 void
atf_dynstr_fini(atf_dynstr_t * ad)277 atf_dynstr_fini(atf_dynstr_t *ad)
278 {
279 INV(ad->m_data != NULL);
280 free(ad->m_data);
281 }
282
283 char *
atf_dynstr_fini_disown(atf_dynstr_t * ad)284 atf_dynstr_fini_disown(atf_dynstr_t *ad)
285 {
286 INV(ad->m_data != NULL);
287 return ad->m_data;
288 }
289
290 /*
291 * Getters.
292 */
293
294 const char *
atf_dynstr_cstring(const atf_dynstr_t * ad)295 atf_dynstr_cstring(const atf_dynstr_t *ad)
296 {
297 return ad->m_data;
298 }
299
300 size_t
atf_dynstr_length(const atf_dynstr_t * ad)301 atf_dynstr_length(const atf_dynstr_t *ad)
302 {
303 return ad->m_length;
304 }
305
306 size_t
atf_dynstr_rfind_ch(const atf_dynstr_t * ad,char ch)307 atf_dynstr_rfind_ch(const atf_dynstr_t *ad, char ch)
308 {
309 size_t pos;
310
311 for (pos = ad->m_length; pos > 0 && ad->m_data[pos - 1] != ch; pos--)
312 ;
313
314 return pos == 0 ? atf_dynstr_npos : pos - 1;
315 }
316
317 /*
318 * Modifiers.
319 */
320
321 atf_error_t
atf_dynstr_append_ap(atf_dynstr_t * ad,const char * fmt,va_list ap)322 atf_dynstr_append_ap(atf_dynstr_t *ad, const char *fmt, va_list ap)
323 {
324 atf_error_t err;
325 va_list ap2;
326
327 va_copy(ap2, ap);
328 err = prepend_or_append(ad, fmt, ap2, false);
329 va_end(ap2);
330
331 return err;
332 }
333
334 atf_error_t
atf_dynstr_append_fmt(atf_dynstr_t * ad,const char * fmt,...)335 atf_dynstr_append_fmt(atf_dynstr_t *ad, const char *fmt, ...)
336 {
337 va_list ap;
338 atf_error_t err;
339
340 va_start(ap, fmt);
341 err = prepend_or_append(ad, fmt, ap, false);
342 va_end(ap);
343
344 return err;
345 }
346
347 void
atf_dynstr_clear(atf_dynstr_t * ad)348 atf_dynstr_clear(atf_dynstr_t *ad)
349 {
350 ad->m_data[0] = '\0';
351 ad->m_length = 0;
352 }
353
354 atf_error_t
atf_dynstr_prepend_ap(atf_dynstr_t * ad,const char * fmt,va_list ap)355 atf_dynstr_prepend_ap(atf_dynstr_t *ad, const char *fmt, va_list ap)
356 {
357 atf_error_t err;
358 va_list ap2;
359
360 va_copy(ap2, ap);
361 err = prepend_or_append(ad, fmt, ap2, true);
362 va_end(ap2);
363
364 return err;
365 }
366
367 atf_error_t
atf_dynstr_prepend_fmt(atf_dynstr_t * ad,const char * fmt,...)368 atf_dynstr_prepend_fmt(atf_dynstr_t *ad, const char *fmt, ...)
369 {
370 va_list ap;
371 atf_error_t err;
372
373 va_start(ap, fmt);
374 err = prepend_or_append(ad, fmt, ap, true);
375 va_end(ap);
376
377 return err;
378 }
379
380 /*
381 * Operators.
382 */
383
384 bool
atf_equal_dynstr_cstring(const atf_dynstr_t * ad,const char * str)385 atf_equal_dynstr_cstring(const atf_dynstr_t *ad, const char *str)
386 {
387 return strcmp(ad->m_data, str) == 0;
388 }
389
390 bool
atf_equal_dynstr_dynstr(const atf_dynstr_t * s1,const atf_dynstr_t * s2)391 atf_equal_dynstr_dynstr(const atf_dynstr_t *s1, const atf_dynstr_t *s2)
392 {
393 return strcmp(s1->m_data, s2->m_data) == 0;
394 }
395