1 /* $NetBSD: prop_string.c,v 1.11 2008/08/03 04:00:12 thorpej Exp $ */
2
3 /*-
4 * Copyright (c) 2006 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Jason R. Thorpe.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <libprop/prop_string.h>
33 #include "prop_object_impl.h"
34
35 #if defined(_KERNEL)
36 #define sprintf ksprintf
37 #endif
38
39 struct _prop_string {
40 struct _prop_object ps_obj;
41 union {
42 char * psu_mutable;
43 const char * psu_immutable;
44 } ps_un;
45 #define ps_mutable ps_un.psu_mutable
46 #define ps_immutable ps_un.psu_immutable
47 size_t ps_size; /* not including \0 */
48 int ps_flags;
49 };
50
51 #define PS_F_NOCOPY 0x01
52
53 _PROP_POOL_INIT(_prop_string_pool, sizeof(struct _prop_string), "propstng");
54
55 _PROP_MALLOC_DEFINE(M_PROP_STRING, "prop string",
56 "property string container object")
57
58 static _prop_object_free_rv_t
59 _prop_string_free(prop_stack_t, prop_object_t *);
60 static bool _prop_string_externalize(
61 struct _prop_object_externalize_context *,
62 void *);
63 static _prop_object_equals_rv_t
64 _prop_string_equals(prop_object_t, prop_object_t,
65 void **, void **,
66 prop_object_t *, prop_object_t *);
67
68 static const struct _prop_object_type _prop_object_type_string = {
69 .pot_type = PROP_TYPE_STRING,
70 .pot_free = _prop_string_free,
71 .pot_extern = _prop_string_externalize,
72 .pot_equals = _prop_string_equals,
73 };
74
75 #define prop_object_is_string(x) \
76 ((x) != NULL && (x)->ps_obj.po_type == &_prop_object_type_string)
77 #define prop_string_contents(x) ((x)->ps_immutable ? (x)->ps_immutable : "")
78
79 /* ARGSUSED */
80 static _prop_object_free_rv_t
_prop_string_free(prop_stack_t stack,prop_object_t * obj)81 _prop_string_free(prop_stack_t stack, prop_object_t *obj)
82 {
83 prop_string_t ps = *obj;
84
85 if ((ps->ps_flags & PS_F_NOCOPY) == 0 && ps->ps_mutable != NULL)
86 _PROP_FREE(ps->ps_mutable, M_PROP_STRING);
87 _PROP_POOL_PUT(_prop_string_pool, ps);
88
89 return (_PROP_OBJECT_FREE_DONE);
90 }
91
92 static bool
_prop_string_externalize(struct _prop_object_externalize_context * ctx,void * v)93 _prop_string_externalize(struct _prop_object_externalize_context *ctx,
94 void *v)
95 {
96 prop_string_t ps = v;
97
98 if (ps->ps_size == 0)
99 return (_prop_object_externalize_empty_tag(ctx, "string"));
100
101 if (_prop_object_externalize_start_tag(ctx, "string") == false ||
102 _prop_object_externalize_append_encoded_cstring(ctx,
103 ps->ps_immutable) == false ||
104 _prop_object_externalize_end_tag(ctx, "string") == false)
105 return (false);
106
107 return (true);
108 }
109
110 /* ARGSUSED */
111 static _prop_object_equals_rv_t
_prop_string_equals(prop_object_t v1,prop_object_t v2,void ** stored_pointer1,void ** stored_pointer2,prop_object_t * next_obj1,prop_object_t * next_obj2)112 _prop_string_equals(prop_object_t v1, prop_object_t v2,
113 void **stored_pointer1, void **stored_pointer2,
114 prop_object_t *next_obj1, prop_object_t *next_obj2)
115 {
116 prop_string_t str1 = v1;
117 prop_string_t str2 = v2;
118
119 if (str1 == str2)
120 return (_PROP_OBJECT_EQUALS_TRUE);
121 if (str1->ps_size != str2->ps_size)
122 return (_PROP_OBJECT_EQUALS_FALSE);
123 if (strcmp(prop_string_contents(str1), prop_string_contents(str2)))
124 return (_PROP_OBJECT_EQUALS_FALSE);
125 else
126 return (_PROP_OBJECT_EQUALS_TRUE);
127 }
128
129 static prop_string_t
_prop_string_alloc(void)130 _prop_string_alloc(void)
131 {
132 prop_string_t ps;
133
134 ps = _PROP_POOL_GET(_prop_string_pool);
135 if (ps != NULL) {
136 _prop_object_init(&ps->ps_obj, &_prop_object_type_string);
137
138 ps->ps_mutable = NULL;
139 ps->ps_size = 0;
140 ps->ps_flags = 0;
141 }
142
143 return (ps);
144 }
145
146 /*
147 * prop_string_create --
148 * Create an empty mutable string.
149 */
150 prop_string_t
prop_string_create(void)151 prop_string_create(void)
152 {
153
154 return (_prop_string_alloc());
155 }
156
157 /*
158 * prop_string_create_cstring --
159 * Create a string that contains a copy of the provided C string.
160 */
161 prop_string_t
prop_string_create_cstring(const char * str)162 prop_string_create_cstring(const char *str)
163 {
164 prop_string_t ps;
165 char *cp;
166 size_t len;
167
168 ps = _prop_string_alloc();
169 if (ps != NULL) {
170 len = strlen(str);
171 cp = _PROP_MALLOC(len + 1, M_PROP_STRING);
172 if (cp == NULL) {
173 prop_object_release(ps);
174 return (NULL);
175 }
176 strcpy(cp, str);
177 ps->ps_mutable = cp;
178 ps->ps_size = len;
179 }
180 return (ps);
181 }
182
183 /*
184 * prop_string_create_cstring_nocopy --
185 * Create an immutable string that contains a refrence to the
186 * provided C string.
187 */
188 prop_string_t
prop_string_create_cstring_nocopy(const char * str)189 prop_string_create_cstring_nocopy(const char *str)
190 {
191 prop_string_t ps;
192
193 ps = _prop_string_alloc();
194 if (ps != NULL) {
195 ps->ps_immutable = str;
196 ps->ps_size = strlen(str);
197 ps->ps_flags |= PS_F_NOCOPY;
198 }
199 return (ps);
200 }
201
202 /*
203 * prop_string_copy --
204 * Copy a string. If the original string is immutable, then the
205 * copy is also immutable and references the same external data.
206 */
207 prop_string_t
prop_string_copy(prop_string_t ops)208 prop_string_copy(prop_string_t ops)
209 {
210 prop_string_t ps;
211
212 if (! prop_object_is_string(ops))
213 return (NULL);
214
215 ps = _prop_string_alloc();
216 if (ps != NULL) {
217 ps->ps_size = ops->ps_size;
218 ps->ps_flags = ops->ps_flags;
219 if (ops->ps_flags & PS_F_NOCOPY)
220 ps->ps_immutable = ops->ps_immutable;
221 else {
222 char *cp = _PROP_MALLOC(ps->ps_size + 1, M_PROP_STRING);
223 if (cp == NULL) {
224 prop_object_release(ps);
225 return (NULL);
226 }
227 strcpy(cp, prop_string_contents(ops));
228 ps->ps_mutable = cp;
229 }
230 }
231 return (ps);
232 }
233
234 /*
235 * prop_string_copy_mutable --
236 * Copy a string, always returning a mutable copy.
237 */
238 prop_string_t
prop_string_copy_mutable(prop_string_t ops)239 prop_string_copy_mutable(prop_string_t ops)
240 {
241 prop_string_t ps;
242 char *cp;
243
244 if (! prop_object_is_string(ops))
245 return (NULL);
246
247 ps = _prop_string_alloc();
248 if (ps != NULL) {
249 ps->ps_size = ops->ps_size;
250 cp = _PROP_MALLOC(ps->ps_size + 1, M_PROP_STRING);
251 if (cp == NULL) {
252 prop_object_release(ps);
253 return (NULL);
254 }
255 strcpy(cp, prop_string_contents(ops));
256 ps->ps_mutable = cp;
257 }
258 return (ps);
259 }
260
261 /*
262 * prop_string_size --
263 * Return the size of the string, not including the terminating NUL.
264 */
265 size_t
prop_string_size(prop_string_t ps)266 prop_string_size(prop_string_t ps)
267 {
268
269 if (! prop_object_is_string(ps))
270 return (0);
271
272 return (ps->ps_size);
273 }
274
275 /*
276 * prop_string_mutable --
277 * Return true if the string is a mutable string.
278 */
279 bool
prop_string_mutable(prop_string_t ps)280 prop_string_mutable(prop_string_t ps)
281 {
282
283 if (! prop_object_is_string(ps))
284 return (false);
285
286 return ((ps->ps_flags & PS_F_NOCOPY) == 0);
287 }
288
289 /*
290 * prop_string_cstring --
291 * Return a copy of the contents of the string as a C string.
292 * The string is allocated with the M_TEMP malloc type.
293 */
294 char *
prop_string_cstring(prop_string_t ps)295 prop_string_cstring(prop_string_t ps)
296 {
297 char *cp;
298
299 if (! prop_object_is_string(ps))
300 return (NULL);
301
302 cp = _PROP_MALLOC(ps->ps_size + 1, M_TEMP);
303 if (cp != NULL)
304 strcpy(cp, prop_string_contents(ps));
305
306 return (cp);
307 }
308
309 /*
310 * prop_string_cstring_nocopy --
311 * Return an immutable reference to the contents of the string
312 * as a C string.
313 */
314 const char *
prop_string_cstring_nocopy(prop_string_t ps)315 prop_string_cstring_nocopy(prop_string_t ps)
316 {
317
318 if (! prop_object_is_string(ps))
319 return (NULL);
320
321 return (prop_string_contents(ps));
322 }
323
324 /*
325 * prop_string_append --
326 * Append the contents of one string to another. Returns true
327 * upon success. The destination string must be mutable.
328 */
329 bool
prop_string_append(prop_string_t dst,prop_string_t src)330 prop_string_append(prop_string_t dst, prop_string_t src)
331 {
332 char *ocp, *cp;
333 size_t len;
334
335 if (! (prop_object_is_string(dst) &&
336 prop_object_is_string(src)))
337 return (false);
338
339 if (dst->ps_flags & PS_F_NOCOPY)
340 return (false);
341
342 len = dst->ps_size + src->ps_size;
343 cp = _PROP_MALLOC(len + 1, M_PROP_STRING);
344 if (cp == NULL)
345 return (false);
346 sprintf(cp, "%s%s", prop_string_contents(dst),
347 prop_string_contents(src));
348 ocp = dst->ps_mutable;
349 dst->ps_mutable = cp;
350 dst->ps_size = len;
351 if (ocp != NULL)
352 _PROP_FREE(ocp, M_PROP_STRING);
353
354 return (true);
355 }
356
357 /*
358 * prop_string_append_cstring --
359 * Append a C string to a string. Returns true upon success.
360 * The destination string must be mutable.
361 */
362 bool
prop_string_append_cstring(prop_string_t dst,const char * src)363 prop_string_append_cstring(prop_string_t dst, const char *src)
364 {
365 char *ocp, *cp;
366 size_t len;
367
368 if (! prop_object_is_string(dst))
369 return (false);
370
371 _PROP_ASSERT(src != NULL);
372
373 if (dst->ps_flags & PS_F_NOCOPY)
374 return (false);
375
376 len = dst->ps_size + strlen(src);
377 cp = _PROP_MALLOC(len + 1, M_PROP_STRING);
378 if (cp == NULL)
379 return (false);
380 sprintf(cp, "%s%s", prop_string_contents(dst), src);
381 ocp = dst->ps_mutable;
382 dst->ps_mutable = cp;
383 dst->ps_size = len;
384 if (ocp != NULL)
385 _PROP_FREE(ocp, M_PROP_STRING);
386
387 return (true);
388 }
389
390 /*
391 * prop_string_equals --
392 * Return true if two strings are equivalent.
393 */
394 bool
prop_string_equals(prop_string_t str1,prop_string_t str2)395 prop_string_equals(prop_string_t str1, prop_string_t str2)
396 {
397 if (!prop_object_is_string(str1) || !prop_object_is_string(str2))
398 return (false);
399
400 return prop_object_equals(str1, str2);
401 }
402
403 /*
404 * prop_string_equals_cstring --
405 * Return true if the string is equivalent to the specified
406 * C string.
407 */
408 bool
prop_string_equals_cstring(prop_string_t ps,const char * cp)409 prop_string_equals_cstring(prop_string_t ps, const char *cp)
410 {
411
412 if (! prop_object_is_string(ps))
413 return (false);
414
415 return (strcmp(prop_string_contents(ps), cp) == 0);
416 }
417
418 /*
419 * _prop_string_internalize --
420 * Parse a <string>...</string> and return the object created from the
421 * external representation.
422 */
423 /* ARGSUSED */
424 bool
_prop_string_internalize(prop_stack_t stack,prop_object_t * obj,struct _prop_object_internalize_context * ctx)425 _prop_string_internalize(prop_stack_t stack, prop_object_t *obj,
426 struct _prop_object_internalize_context *ctx)
427 {
428 prop_string_t string;
429 char *str;
430 size_t len, alen;
431
432 if (ctx->poic_is_empty_element) {
433 *obj = prop_string_create();
434 return (true);
435 }
436
437 /* No attributes recognized here. */
438 if (ctx->poic_tagattr != NULL)
439 return (true);
440
441 /* Compute the length of the result. */
442 if (_prop_object_internalize_decode_string(ctx, NULL, 0, &len,
443 NULL) == false)
444 return (true);
445
446 str = _PROP_MALLOC(len + 1, M_PROP_STRING);
447 if (str == NULL)
448 return (true);
449
450 if (_prop_object_internalize_decode_string(ctx, str, len, &alen,
451 &ctx->poic_cp) == false ||
452 alen != len) {
453 _PROP_FREE(str, M_PROP_STRING);
454 return (true);
455 }
456 str[len] = '\0';
457
458 if (_prop_object_internalize_find_tag(ctx, "string",
459 _PROP_TAG_TYPE_END) == false) {
460 _PROP_FREE(str, M_PROP_STRING);
461 return (true);
462 }
463
464 string = _prop_string_alloc();
465 if (string == NULL) {
466 _PROP_FREE(str, M_PROP_STRING);
467 return (true);
468 }
469
470 string->ps_mutable = str;
471 string->ps_size = len;
472 *obj = string;
473
474 return (true);
475 }
476