?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tcp: Cache align ACK queue header.
[dragonfly.git] / sys / libprop / prop_object.c
blobe96f67fb114941ae0b2a7901bb3aefd0add3b86c
1 /* $NetBSD: prop_object.c,v 1.26 2009/03/30 07:42:51 haad Exp $ */
2
3 /*-
4 * Copyright (c) 2006, 2007 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_object.h>
33 #include "prop_object_impl.h"
34
35 #if !defined(_KERNEL) && !defined(_STANDALONE)
36 #include <sys/mman.h>
37 #include <sys/stat.h>
38 #include <errno.h>
39 #include <fcntl.h>
40 #include <limits.h>
41 #include <unistd.h>
42 #endif
43
44 /* XXX: netbsd's _nv stuff effectively does addfetch, not fetchadd */
45 #define atomic_inc_32_nv(x) (atomic_fetchadd_int(x, 1)+1)
46 #define atomic_dec_32_nv(x) (atomic_fetchadd_int(x, -1)-1)
47 #define atomic_inc_32(x) atomic_add_int(x, 1)
48 #define atomic_dec_32(x) atomic_add_int(x, 1)
49
50 #include <machine/atomic.h>
51
52 #ifdef _STANDALONE
53 void *
54 _prop_standalone_calloc(size_t size)
55 {
56 void *rv;
57
58 rv = alloc(size);
59 if (rv != NULL)
60 memset(rv, 0, size);
61
62 return (rv);
63 }
64
65 void *
66 _prop_standalone_realloc(void *v, size_t size)
67 {
68 void *rv;
69
70 rv = alloc(size);
71 if (rv != NULL) {
72 memcpy(rv, v, size); /* XXX */
73 dealloc(v, 0); /* XXX */
74 }
75
76 return (rv);
77 }
78 #endif /* _STANDALONE */
79
80 /*
81 * _prop_object_init --
82 * Initialize an object. Called when sub-classes create
83 * an instance.
84 */
85 void
86 _prop_object_init(struct _prop_object *po, const struct _prop_object_type *pot)
87 {
88
89 po->po_type = pot;
90 po->po_refcnt = 1;
91 }
92
93 /*
94 * _prop_object_fini --
95 * Finalize an object. Called when sub-classes destroy
96 * an instance.
97 */
98 /*ARGSUSED*/
99 void
100 _prop_object_fini(struct _prop_object *po _PROP_ARG_UNUSED)
101 {
102 /* Nothing to do, currently. */
103 }
104
105 /*
106 * _prop_object_externalize_start_tag --
107 * Append an XML-style start tag to the externalize buffer.
108 */
109 bool
110 _prop_object_externalize_start_tag(
111 struct _prop_object_externalize_context *ctx, const char *tag)
112 {
113 unsigned int i;
114
115 for (i = 0; i < ctx->poec_depth; i++) {
116 if (_prop_object_externalize_append_char(ctx, '\t') == false)
117 return (false);
118 }
119 if (_prop_object_externalize_append_char(ctx, '<') == false ||
120 _prop_object_externalize_append_cstring(ctx, tag) == false ||
121 _prop_object_externalize_append_char(ctx, '>') == false)
122 return (false);
123
124 return (true);
125 }
126
127 /*
128 * _prop_object_externalize_end_tag --
129 * Append an XML-style end tag to the externalize buffer.
130 */
131 bool
132 _prop_object_externalize_end_tag(
133 struct _prop_object_externalize_context *ctx, const char *tag)
134 {
135
136 if (_prop_object_externalize_append_char(ctx, '<') == false ||
137 _prop_object_externalize_append_char(ctx, '/') == false ||
138 _prop_object_externalize_append_cstring(ctx, tag) == false ||
139 _prop_object_externalize_append_char(ctx, '>') == false ||
140 _prop_object_externalize_append_char(ctx, '\n') == false)
141 return (false);
142
143 return (true);
144 }
145
146 /*
147 * _prop_object_externalize_empty_tag --
148 * Append an XML-style empty tag to the externalize buffer.
149 */
150 bool
151 _prop_object_externalize_empty_tag(
152 struct _prop_object_externalize_context *ctx, const char *tag)
153 {
154 unsigned int i;
155
156 for (i = 0; i < ctx->poec_depth; i++) {
157 if (_prop_object_externalize_append_char(ctx, '\t') == false)
158 return (false);
159 }
160
161 if (_prop_object_externalize_append_char(ctx, '<') == false ||
162 _prop_object_externalize_append_cstring(ctx, tag) == false ||
163 _prop_object_externalize_append_char(ctx, '/') == false ||
164 _prop_object_externalize_append_char(ctx, '>') == false ||
165 _prop_object_externalize_append_char(ctx, '\n') == false)
166 return (false);
167
168 return (true);
169 }
170
171 /*
172 * _prop_object_externalize_append_cstring --
173 * Append a C string to the externalize buffer.
174 */
175 bool
176 _prop_object_externalize_append_cstring(
177 struct _prop_object_externalize_context *ctx, const char *cp)
178 {
179
180 while (*cp != '\0') {
181 if (_prop_object_externalize_append_char(ctx,
182 (unsigned char) *cp) == false)
183 return (false);
184 cp++;
185 }
186
187 return (true);
188 }
189
190 /*
191 * _prop_object_externalize_append_encoded_cstring --
192 * Append an encoded C string to the externalize buffer.
193 */
194 bool
195 _prop_object_externalize_append_encoded_cstring(
196 struct _prop_object_externalize_context *ctx, const char *cp)
197 {
198
199 while (*cp != '\0') {
200 switch (*cp) {
201 case '<':
202 if (_prop_object_externalize_append_cstring(ctx,
203 "&lt;") == false)
204 return (false);
205 break;
206 case '>':
207 if (_prop_object_externalize_append_cstring(ctx,
208 "&gt;") == false)
209 return (false);
210 break;
211 case '&':
212 if (_prop_object_externalize_append_cstring(ctx,
213 "&amp;") == false)
214 return (false);
215 break;
216 default:
217 if (_prop_object_externalize_append_char(ctx,
218 (unsigned char) *cp) == false)
219 return (false);
220 break;
221 }
222 cp++;
223 }
224
225 return (true);
226 }
227
228 #define BUF_EXPAND 256
229
230 /*
231 * _prop_object_externalize_append_char --
232 * Append a single character to the externalize buffer.
233 */
234 bool
235 _prop_object_externalize_append_char(
236 struct _prop_object_externalize_context *ctx, unsigned char c)
237 {
238
239 _PROP_ASSERT(ctx->poec_capacity != 0);
240 _PROP_ASSERT(ctx->poec_buf != NULL);
241 _PROP_ASSERT(ctx->poec_len <= ctx->poec_capacity);
242
243 if (ctx->poec_len == ctx->poec_capacity) {
244 char *cp = _PROP_REALLOC(ctx->poec_buf,
245 ctx->poec_capacity + BUF_EXPAND,
246 M_TEMP);
247 if (cp == NULL)
248 return (false);
249 ctx->poec_capacity = ctx->poec_capacity + BUF_EXPAND;
250 ctx->poec_buf = cp;
251 }
252
253 ctx->poec_buf[ctx->poec_len++] = c;
254
255 return (true);
256 }
257
258 /*
259 * _prop_object_externalize_header --
260 * Append the standard XML header to the externalize buffer.
261 */
262 bool
263 _prop_object_externalize_header(struct _prop_object_externalize_context *ctx)
264 {
265 static const char _plist_xml_header[] =
266 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
267 "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n";
268
269 if (_prop_object_externalize_append_cstring(ctx,
270 _plist_xml_header) == false ||
271 _prop_object_externalize_start_tag(ctx,
272 "plist version=\"1.0\"") == false ||
273 _prop_object_externalize_append_char(ctx, '\n') == false)
274 return (false);
275
276 return (true);
277 }
278
279 /*
280 * _prop_object_externalize_footer --
281 * Append the standard XML footer to the externalize buffer. This
282 * also NUL-terminates the buffer.
283 */
284 bool
285 _prop_object_externalize_footer(struct _prop_object_externalize_context *ctx)
286 {
287
288 if (_prop_object_externalize_end_tag(ctx, "plist") == false ||
289 _prop_object_externalize_append_char(ctx, '\0') == false)
290 return (false);
291
292 return (true);
293 }
294
295 /*
296 * _prop_object_externalize_context_alloc --
297 * Allocate an externalize context.
298 */
299 struct _prop_object_externalize_context *
300 _prop_object_externalize_context_alloc(void)
301 {
302 struct _prop_object_externalize_context *ctx;
303
304 ctx = _PROP_MALLOC(sizeof(*ctx), M_TEMP);
305 if (ctx != NULL) {
306 ctx->poec_buf = _PROP_MALLOC(BUF_EXPAND, M_TEMP);
307 if (ctx->poec_buf == NULL) {
308 _PROP_FREE(ctx, M_TEMP);
309 return (NULL);
310 }
311 ctx->poec_len = 0;
312 ctx->poec_capacity = BUF_EXPAND;
313 ctx->poec_depth = 0;
314 }
315 return (ctx);
316 }
317
318 /*
319 * _prop_object_externalize_context_free --
320 * Free an externalize context.
321 */
322 void
323 _prop_object_externalize_context_free(
324 struct _prop_object_externalize_context *ctx)
325 {
326
327 /* Buffer is always freed by the caller. */
328 _PROP_FREE(ctx, M_TEMP);
329 }
330
331 /*
332 * _prop_object_internalize_skip_comment --
333 * Skip the body and end tag of a comment.
334 */
335 static bool
336 _prop_object_internalize_skip_comment(
337 struct _prop_object_internalize_context *ctx)
338 {
339 const char *cp = ctx->poic_cp;
340
341 while (!_PROP_EOF(*cp)) {
342 if (cp[0] == '-' &&
343 cp[1] == '-' &&
344 cp[2] == '>') {
345 ctx->poic_cp = cp + 3;
346 return (true);
347 }
348 cp++;
349 }
350
351 return (false); /* ran out of buffer */
352 }
353
354 /*
355 * _prop_object_internalize_find_tag --
356 * Find the next tag in an XML stream. Optionally compare the found
357 * tag to an expected tag name. State of the context is undefined
358 * if this routine returns false. Upon success, the context points
359 * to the first octet after the tag.
360 */
361 bool
362 _prop_object_internalize_find_tag(struct _prop_object_internalize_context *ctx,
363 const char *tag, _prop_tag_type_t type)
364 {
365 const char *cp;
366 size_t taglen;
367
368 if (tag != NULL)
369 taglen = strlen(tag);
370 else
371 taglen = 0;
372
373 start_over:
374 cp = ctx->poic_cp;
375
376 /*
377 * Find the start of the tag.
378 */
379 while (_PROP_ISSPACE(*cp))
380 cp++;
381 if (_PROP_EOF(*cp))
382 return (false);
383
384 if (*cp != '<')
385 return (false);
386
387 ctx->poic_tag_start = cp++;
388 if (_PROP_EOF(*cp))
389 return (false);
390
391 if (*cp == '!') {
392 if (cp[1] != '-' || cp[2] != '-')
393 return (false);
394 /*
395 * Comment block -- only allowed if we are allowed to
396 * return a start tag.
397 */
398 if (type == _PROP_TAG_TYPE_END)
399 return (false);
400 ctx->poic_cp = cp + 3;
401 if (_prop_object_internalize_skip_comment(ctx) == false)
402 return (false);
403 goto start_over;
404 }
405
406 if (*cp == '/') {
407 if (type != _PROP_TAG_TYPE_END &&
408 type != _PROP_TAG_TYPE_EITHER)
409 return (false);
410 cp++;
411 if (_PROP_EOF(*cp))
412 return (false);
413 ctx->poic_tag_type = _PROP_TAG_TYPE_END;
414 } else {
415 if (type != _PROP_TAG_TYPE_START &&
416 type != _PROP_TAG_TYPE_EITHER)
417 return (false);
418 ctx->poic_tag_type = _PROP_TAG_TYPE_START;
419 }
420
421 ctx->poic_tagname = cp;
422
423 while (!_PROP_ISSPACE(*cp) && *cp != '/' && *cp != '>')
424 cp++;
425 if (_PROP_EOF(*cp))
426 return (false);
427
428 ctx->poic_tagname_len = cp - ctx->poic_tagname;
429
430 /* Make sure this is the tag we're looking for. */
431 if (tag != NULL &&
432 (taglen != ctx->poic_tagname_len ||
433 memcmp(tag, ctx->poic_tagname, taglen) != 0))
434 return (false);
435
436 /* Check for empty tag. */
437 if (*cp == '/') {
438 if (ctx->poic_tag_type != _PROP_TAG_TYPE_START)
439 return(false); /* only valid on start tags */
440 ctx->poic_is_empty_element = true;
441 cp++;
442 if (_PROP_EOF(*cp) || *cp != '>')
443 return (false);
444 } else
445 ctx->poic_is_empty_element = false;
446
447 /* Easy case of no arguments. */
448 if (*cp == '>') {
449 ctx->poic_tagattr = NULL;
450 ctx->poic_tagattr_len = 0;
451 ctx->poic_tagattrval = NULL;
452 ctx->poic_tagattrval_len = 0;
453 ctx->poic_cp = cp + 1;
454 return (true);
455 }
456
457 _PROP_ASSERT(!_PROP_EOF(*cp));
458 cp++;
459 if (_PROP_EOF(*cp))
460 return (false);
461
462 while (_PROP_ISSPACE(*cp))
463 cp++;
464 if (_PROP_EOF(*cp))
465 return (false);
466
467 ctx->poic_tagattr = cp;
468
469 while (!_PROP_ISSPACE(*cp) && *cp != '=')
470 cp++;
471 if (_PROP_EOF(*cp))
472 return (false);
473
474 ctx->poic_tagattr_len = cp - ctx->poic_tagattr;
475
476 cp++;
477 if (*cp != '\"')
478 return (false);
479 cp++;
480 if (_PROP_EOF(*cp))
481 return (false);
482
483 ctx->poic_tagattrval = cp;
484 while (*cp != '\"')
485 cp++;
486 if (_PROP_EOF(*cp))
487 return (false);
488 ctx->poic_tagattrval_len = cp - ctx->poic_tagattrval;
489
490 cp++;
491 if (*cp != '>')
492 return (false);
493
494 ctx->poic_cp = cp + 1;
495 return (true);
496 }
497
498 /*
499 * _prop_object_internalize_decode_string --
500 * Decode an encoded string.
501 */
502 bool
503 _prop_object_internalize_decode_string(
504 struct _prop_object_internalize_context *ctx,
505 char *target, size_t targsize, size_t *sizep,
506 const char **cpp)
507 {
508 const char *src;
509 size_t tarindex;
510 char c;
511
512 tarindex = 0;
513 src = ctx->poic_cp;
514
515 for (;;) {
516 if (_PROP_EOF(*src))
517 return (false);
518 if (*src == '<') {
519 break;
520 }
521
522 if ((c = *src) == '&') {
523 if (src[1] == 'a' &&
524 src[2] == 'm' &&
525 src[3] == 'p' &&
526 src[4] == ';') {
527 c = '&';
528 src += 5;
529 } else if (src[1] == 'l' &&
530 src[2] == 't' &&
531 src[3] == ';') {
532 c = '<';
533 src += 4;
534 } else if (src[1] == 'g' &&
535 src[2] == 't' &&
536 src[3] == ';') {
537 c = '>';
538 src += 4;
539 } else if (src[1] == 'a' &&
540 src[2] == 'p' &&
541 src[3] == 'o' &&
542 src[4] == 's' &&
543 src[5] == ';') {
544 c = '\'';
545 src += 6;
546 } else if (src[1] == 'q' &&
547 src[2] == 'u' &&
548 src[3] == 'o' &&
549 src[4] == 't' &&
550 src[5] == ';') {
551 c = '\"';
552 src += 6;
553 } else
554 return (false);
555 } else
556 src++;
557 if (target) {
558 if (tarindex >= targsize)
559 return (false);
560 target[tarindex] = c;
561 }
562 tarindex++;
563 }
564
565 _PROP_ASSERT(*src == '<');
566 if (sizep != NULL)
567 *sizep = tarindex;
568 if (cpp != NULL)
569 *cpp = src;
570
571 return (true);
572 }
573
574 /*
575 * _prop_object_internalize_match --
576 * Returns true if the two character streams match.
577 */
578 bool
579 _prop_object_internalize_match(const char *str1, size_t len1,
580 const char *str2, size_t len2)
581 {
582
583 return (len1 == len2 && memcmp(str1, str2, len1) == 0);
584 }
585
586 #define INTERNALIZER(t, f) \
587 { t, sizeof(t) - 1, f }
588
589 static const struct _prop_object_internalizer {
590 const char *poi_tag;
591 size_t poi_taglen;
592 prop_object_internalizer_t poi_intern;
593 } _prop_object_internalizer_table[] = {
594 INTERNALIZER("array", _prop_array_internalize),
595
596 INTERNALIZER("true", _prop_bool_internalize),
597 INTERNALIZER("false", _prop_bool_internalize),
598
599 INTERNALIZER("data", _prop_data_internalize),
600
601 INTERNALIZER("dict", _prop_dictionary_internalize),
602
603 INTERNALIZER("integer", _prop_number_internalize),
604
605 INTERNALIZER("string", _prop_string_internalize),
606
607 { 0, 0, NULL }
608 };
609
610 #undef INTERNALIZER
611
612 /*
613 * _prop_object_internalize_by_tag --
614 * Determine the object type from the tag in the context and
615 * internalize it.
616 */
617 prop_object_t
618 _prop_object_internalize_by_tag(struct _prop_object_internalize_context *ctx)
619 {
620 const struct _prop_object_internalizer *poi;
621 prop_object_t obj, parent_obj;
622 void *data, *iter;
623 prop_object_internalizer_continue_t iter_func;
624 struct _prop_stack stack;
625
626 _prop_stack_init(&stack);
627
628 match_start:
629 for (poi = _prop_object_internalizer_table;
630 poi->poi_tag != NULL; poi++) {
631 if (_prop_object_internalize_match(ctx->poic_tagname,
632 ctx->poic_tagname_len,
633 poi->poi_tag,
634 poi->poi_taglen))
635 break;
636 }
637 if ((poi == NULL) || (poi->poi_tag == NULL)) {
638 while (_prop_stack_pop(&stack, &obj, &iter, &data, NULL)) {
639 iter_func = (prop_object_internalizer_continue_t)iter;
640 (*iter_func)(&stack, &obj, ctx, data, NULL);
641 }
642
643 return (NULL);
644 }
645
646 obj = NULL;
647 if (!(*poi->poi_intern)(&stack, &obj, ctx))
648 goto match_start;
649
650 parent_obj = obj;
651 while (_prop_stack_pop(&stack, &parent_obj, &iter, &data, NULL)) {
652 iter_func = (prop_object_internalizer_continue_t)iter;
653 if (!(*iter_func)(&stack, &parent_obj, ctx, data, obj))
654 goto match_start;
655 obj = parent_obj;
656 }
657
658 return (parent_obj);
659 }
660
661 prop_object_t
662 _prop_generic_internalize(const char *xml, const char *master_tag)
663 {
664 prop_object_t obj = NULL;
665 struct _prop_object_internalize_context *ctx;
666
667 ctx = _prop_object_internalize_context_alloc(xml);
668 if (ctx == NULL)
669 return (NULL);
670
671 /* We start with a <plist> tag. */
672 if (_prop_object_internalize_find_tag(ctx, "plist",
673 _PROP_TAG_TYPE_START) == false)
674 goto out;
675
676 /* Plist elements cannot be empty. */
677 if (ctx->poic_is_empty_element)
678 goto out;
679
680 /*
681 * We don't understand any plist attributes, but Apple XML
682 * property lists often have a "version" attribute. If we
683 * see that one, we simply ignore it.
684 */
685 if (ctx->poic_tagattr != NULL &&
686 !_PROP_TAGATTR_MATCH(ctx, "version"))
687 goto out;
688
689 /* Next we expect to see opening master_tag. */
690 if (_prop_object_internalize_find_tag(ctx, master_tag,
691 _PROP_TAG_TYPE_START) == false)
692 goto out;
693
694 obj = _prop_object_internalize_by_tag(ctx);
695 if (obj == NULL)
696 goto out;
697
698 /*
699 * We've advanced past the closing master_tag.
700 * Now we want </plist>.
701 */
702 if (_prop_object_internalize_find_tag(ctx, "plist",
703 _PROP_TAG_TYPE_END) == false) {
704 prop_object_release(obj);
705 obj = NULL;
706 }
707
708 out:
709 _prop_object_internalize_context_free(ctx);
710 return (obj);
711 }
712
713 /*
714 * _prop_object_internalize_context_alloc --
715 * Allocate an internalize context.
716 */
717 struct _prop_object_internalize_context *
718 _prop_object_internalize_context_alloc(const char *xml)
719 {
720 struct _prop_object_internalize_context *ctx;
721
722 ctx = _PROP_MALLOC(sizeof(struct _prop_object_internalize_context),
723 M_TEMP);
724 if (ctx == NULL)
725 return (NULL);
726
727 ctx->poic_xml = ctx->poic_cp = xml;
728
729 /*
730 * Skip any whitespace and XML preamble stuff that we don't
731 * know about / care about.
732 */
733 for (;;) {
734 while (_PROP_ISSPACE(*xml))
735 xml++;
736 if (_PROP_EOF(*xml) || *xml != '<')
737 goto bad;
738
739 #define MATCH(str) (memcmp(&xml[1], str, sizeof(str) - 1) == 0)
740
741 /*
742 * Skip over the XML preamble that Apple XML property
743 * lists usually include at the top of the file.
744 */
745 if (MATCH("?xml ") ||
746 MATCH("!DOCTYPE plist")) {
747 while (*xml != '>' && !_PROP_EOF(*xml))
748 xml++;
749 if (_PROP_EOF(*xml))
750 goto bad;
751 xml++; /* advance past the '>' */
752 continue;
753 }
754
755 if (MATCH("<!--")) {
756 ctx->poic_cp = xml + 4;
757 if (_prop_object_internalize_skip_comment(ctx) == false)
758 goto bad;
759 xml = ctx->poic_cp;
760 continue;
761 }
762
763 #undef MATCH
764
765 /*
766 * We don't think we should skip it, so let's hope we can
767 * parse it.
768 */
769 break;
770 }
771
772 ctx->poic_cp = xml;
773 return (ctx);
774 bad:
775 _PROP_FREE(ctx, M_TEMP);
776 return (NULL);
777 }
778
779 /*
780 * _prop_object_internalize_context_free --
781 * Free an internalize context.
782 */
783 void
784 _prop_object_internalize_context_free(
785 struct _prop_object_internalize_context *ctx)
786 {
787
788 _PROP_FREE(ctx, M_TEMP);
789 }
790
791 #if !defined(_KERNEL) && !defined(_STANDALONE)
792 /*
793 * _prop_object_externalize_file_dirname --
794 * dirname(3), basically. We have to roll our own because the
795 * system dirname(3) isn't reentrant.
796 */
797 static void
798 _prop_object_externalize_file_dirname(const char *path, char *result)
799 {
800 const char *lastp;
801 size_t len;
802
803 /*
804 * If `path' is a NULL pointer or points to an empty string,
805 * return ".".
806 */
807 if (path == NULL || *path == '\0')
808 goto singledot;
809
810 /* String trailing slashes, if any. */
811 lastp = path + strlen(path) - 1;
812 while (lastp != path && *lastp == '/')
813 lastp--;
814
815 /* Terminate path at the last occurrence of '/'. */
816 do {
817 if (*lastp == '/') {
818 /* Strip trailing slashes, if any. */
819 while (lastp != path && *lastp == '/')
820 lastp--;
821
822 /* ...and copy the result into the result buffer. */
823 len = (lastp - path) + 1 /* last char */;
824 if (len > (PATH_MAX - 1))
825 len = PATH_MAX - 1;
826
827 memcpy(result, path, len);
828 result[len] = '\0';
829 return;
830 }
831 } while (--lastp >= path);
832
833 /* No /'s found, return ".". */
834 singledot:
835 strcpy(result, ".");
836 }
837
838 /*
839 * _prop_object_externalize_write_file --
840 * Write an externalized dictionary to the specified file.
841 * The file is written atomically from the caller's perspective,
842 * and the mode set to 0666 modified by the caller's umask.
843 */
844 bool
845 _prop_object_externalize_write_file(const char *fname, const char *xml,
846 size_t len)
847 {
848 char tname[PATH_MAX];
849 int fd;
850 int save_errno;
851 mode_t myumask;
852
853 if (len > SSIZE_MAX) {
854 errno = EFBIG;
855 return (false);
856 }
857
858 /*
859 * Get the directory name where the file is to be written
860 * and create the temporary file.
861 */
862 _prop_object_externalize_file_dirname(fname, tname);
863 if (strlcat(tname, "/.plistXXXXXX", sizeof(tname)) >= sizeof(tname)) {
864 errno = ENAMETOOLONG;
865 return (false);
866 }
867 if ((fd = mkstemp(tname)) == -1)
868 return (false);
869
870 if (write(fd, xml, len) != (ssize_t)len)
871 goto bad;
872
873 if (fsync(fd) == -1)
874 goto bad;
875
876 myumask = umask(0);
877 (void)umask(myumask);
878 if (fchmod(fd, 0666 & ~myumask) == -1)
879 goto bad;
880
881 (void) close(fd);
882 fd = -1;
883
884 if (rename(tname, fname) == -1)
885 goto bad;
886
887 return (true);
888
889 bad:
890 save_errno = errno;
891 if (fd != -1)
892 (void) close(fd);
893 (void) unlink(tname);
894 errno = save_errno;
895 return (false);
896 }
897
898 /*
899 * _prop_object_internalize_map_file --
900 * Map a file for the purpose of internalizing it.
901 */
902 struct _prop_object_internalize_mapped_file *
903 _prop_object_internalize_map_file(const char *fname)
904 {
905 struct stat sb;
906 struct _prop_object_internalize_mapped_file *mf;
907 size_t pgsize = (size_t)sysconf(_SC_PAGESIZE);
908 size_t pgmask = pgsize - 1;
909 bool need_guard = false;
910 int fd;
911
912 mf = _PROP_MALLOC(sizeof(*mf), M_TEMP);
913 if (mf == NULL)
914 return (NULL);
915
916 fd = open(fname, O_RDONLY, 0400);
917 if (fd == -1) {
918 _PROP_FREE(mf, M_TEMP);
919 return (NULL);
920 }
921
922 if (fstat(fd, &sb) == -1) {
923 (void) close(fd);
924 _PROP_FREE(mf, M_TEMP);
925 return (NULL);
926 }
927 mf->poimf_mapsize = ((size_t)sb.st_size + pgmask) & ~pgmask;
928 if (mf->poimf_mapsize < (size_t)sb.st_size) {
929 (void) close(fd);
930 _PROP_FREE(mf, M_TEMP);
931 return (NULL);
932 }
933
934 /*
935 * If the file length is an integral number of pages, then we
936 * need to map a guard page at the end in order to provide the
937 * necessary NUL-termination of the buffer.
938 */
939 if ((sb.st_size & pgmask) == 0)
940 need_guard = true;
941
942 mf->poimf_xml = mmap(NULL, need_guard ? mf->poimf_mapsize + pgsize
943 : mf->poimf_mapsize,
944 PROT_READ, MAP_FILE|MAP_SHARED, fd, (off_t)0);
945 (void) close(fd);
946 if (mf->poimf_xml == MAP_FAILED) {
947 _PROP_FREE(mf, M_TEMP);
948 return (NULL);
949 }
950 (void) madvise(mf->poimf_xml, mf->poimf_mapsize, MADV_SEQUENTIAL);
951
952 if (need_guard) {
953 if (mmap(mf->poimf_xml + mf->poimf_mapsize,
954 pgsize, PROT_READ,
955 MAP_ANON|MAP_PRIVATE|MAP_FIXED, -1,
956 (off_t)0) == MAP_FAILED) {
957 (void) munmap(mf->poimf_xml, mf->poimf_mapsize);
958 _PROP_FREE(mf, M_TEMP);
959 return (NULL);
960 }
961 mf->poimf_mapsize += pgsize;
962 }
963
964 return (mf);
965 }
966
967 /*
968 * _prop_object_internalize_unmap_file --
969 * Unmap a file previously mapped for internalizing.
970 */
971 void
972 _prop_object_internalize_unmap_file(
973 struct _prop_object_internalize_mapped_file *mf)
974 {
975
976 (void) madvise(mf->poimf_xml, mf->poimf_mapsize, MADV_DONTNEED);
977 (void) munmap(mf->poimf_xml, mf->poimf_mapsize);
978 _PROP_FREE(mf, M_TEMP);
979 }
980 #endif /* !_KERNEL && !_STANDALONE */
981
982 /*
983 * prop_object_retain --
984 * Increment the reference count on an object.
985 */
986 void
987 prop_object_retain(prop_object_t obj)
988 {
989 struct _prop_object *po = obj;
990 uint32_t ncnt;
991
992 ncnt = atomic_inc_32_nv(&po->po_refcnt);
993 _PROP_ASSERT(ncnt != 0);
994 }
995
996 /*
997 * prop_object_release_emergency
998 * A direct free with prop_object_release failed.
999 * Walk down the tree until a leaf is found and
1000 * free that. Do not recurse to avoid stack overflows.
1001 *
1002 * This is a slow edge condition, but necessary to
1003 * guarantee that an object can always be freed.
1004 */
1005 static void
1006 prop_object_release_emergency(prop_object_t obj)
1007 {
1008 struct _prop_object *po;
1009 void (*unlock)(void);
1010 prop_object_t parent = NULL;
1011 uint32_t ocnt;
1012
1013 for (;;) {
1014 po = obj;
1015 _PROP_ASSERT(obj);
1016
1017 if (po->po_type->pot_lock != NULL)
1018 po->po_type->pot_lock();
1019
1020 /* Save pointerto unlock function */
1021 unlock = po->po_type->pot_unlock;
1022
1023 /* Dance a bit to make sure we always get the non-racy ocnt */
1024 ocnt = atomic_dec_32_nv(&po->po_refcnt);
1025 ocnt++;
1026 _PROP_ASSERT(ocnt != 0);
1027
1028 if (ocnt != 1) {
1029 if (unlock != NULL)
1030 unlock();
1031 break;
1032 }
1033
1034 _PROP_ASSERT(po->po_type);
1035 if ((po->po_type->pot_free)(NULL, &obj) ==
1036 _PROP_OBJECT_FREE_DONE) {
1037 if (unlock != NULL)
1038 unlock();
1039 break;
1040 }
1041
1042 if (unlock != NULL)
1043 unlock();
1044
1045 parent = po;
1046 atomic_inc_32(&po->po_refcnt);
1047 }
1048 _PROP_ASSERT(parent);
1049 /* One object was just freed. */
1050 po = parent;
1051 (*po->po_type->pot_emergency_free)(parent);
1052 }
1053
1054 /*
1055 * prop_object_release --
1056 * Decrement the reference count on an object.
1057 *
1058 * Free the object if we are releasing the final
1059 * reference.
1060 */
1061 void
1062 prop_object_release(prop_object_t obj)
1063 {
1064 struct _prop_object *po;
1065 struct _prop_stack stack;
1066 void (*unlock)(void);
1067 int ret;
1068 uint32_t ocnt;
1069
1070 _prop_stack_init(&stack);
1071
1072 do {
1073 do {
1074 po = obj;
1075 _PROP_ASSERT(obj);
1076
1077 if (po->po_type->pot_lock != NULL)
1078 po->po_type->pot_lock();
1079
1080 /* Save pointer to object unlock function */
1081 unlock = po->po_type->pot_unlock;
1082
1083 ocnt = atomic_dec_32_nv(&po->po_refcnt);
1084 ocnt++;
1085 _PROP_ASSERT(ocnt != 0);
1086
1087 if (ocnt != 1) {
1088 ret = 0;
1089 if (unlock != NULL)
1090 unlock();
1091 break;
1092 }
1093
1094 ret = (po->po_type->pot_free)(&stack, &obj);
1095
1096 if (unlock != NULL)
1097 unlock();
1098
1099 if (ret == _PROP_OBJECT_FREE_DONE)
1100 break;
1101
1102 atomic_inc_32(&po->po_refcnt);
1103 } while (ret == _PROP_OBJECT_FREE_RECURSE);
1104 if (ret == _PROP_OBJECT_FREE_FAILED)
1105 prop_object_release_emergency(obj);
1106 } while (_prop_stack_pop(&stack, &obj, NULL, NULL, NULL));
1107 }
1108
1109 /*
1110 * prop_object_type --
1111 * Return the type of an object.
1112 */
1113 prop_type_t
1114 prop_object_type(prop_object_t obj)
1115 {
1116 struct _prop_object *po = obj;
1117
1118 if (obj == NULL)
1119 return (PROP_TYPE_UNKNOWN);
1120
1121 return (po->po_type->pot_type);
1122 }
1123
1124 /*
1125 * prop_object_equals --
1126 * Returns true if thw two objects are equivalent.
1127 */
1128 bool
1129 prop_object_equals(prop_object_t obj1, prop_object_t obj2)
1130 {
1131 return (prop_object_equals_with_error(obj1, obj2, NULL));
1132 }
1133
1134 bool
1135 prop_object_equals_with_error(prop_object_t obj1, prop_object_t obj2,
1136 bool *error_flag)
1137 {
1138 struct _prop_object *po1;
1139 struct _prop_object *po2;
1140 void *stored_pointer1, *stored_pointer2;
1141 prop_object_t next_obj1, next_obj2;
1142 struct _prop_stack stack;
1143 _prop_object_equals_rv_t ret;
1144
1145 _prop_stack_init(&stack);
1146 if (error_flag)
1147 *error_flag = false;
1148
1149 start_subtree:
1150 stored_pointer1 = NULL;
1151 stored_pointer2 = NULL;
1152 po1 = obj1;
1153 po2 = obj2;
1154
1155 if (po1->po_type != po2->po_type)
1156 return (false);
1157
1158 continue_subtree:
1159 ret = (*po1->po_type->pot_equals)(obj1, obj2,
1160 &stored_pointer1, &stored_pointer2,
1161 &next_obj1, &next_obj2);
1162 if (ret == _PROP_OBJECT_EQUALS_FALSE)
1163 goto finish;
1164 if (ret == _PROP_OBJECT_EQUALS_TRUE) {
1165 if (!_prop_stack_pop(&stack, &obj1, &obj2,
1166 &stored_pointer1, &stored_pointer2))
1167 return true;
1168 po1 = obj1;
1169 po2 = obj2;
1170 goto continue_subtree;
1171 }
1172 _PROP_ASSERT(ret == _PROP_OBJECT_EQUALS_RECURSE);
1173
1174 if (!_prop_stack_push(&stack, obj1, obj2,
1175 stored_pointer1, stored_pointer2)) {
1176 if (error_flag)
1177 *error_flag = true;
1178 goto finish;
1179 }
1180 obj1 = next_obj1;
1181 obj2 = next_obj2;
1182 goto start_subtree;
1183
1184 finish:
1185 while (_prop_stack_pop(&stack, &obj1, &obj2, NULL, NULL)) {
1186 po1 = obj1;
1187 (*po1->po_type->pot_equals_finish)(obj1, obj2);
1188 }
1189 return (false);
1190 }
1191
1192 /*
1193 * prop_object_iterator_next --
1194 * Return the next item during an iteration.
1195 */
1196 prop_object_t
1197 prop_object_iterator_next(prop_object_iterator_t pi)
1198 {
1199
1200 return ((*pi->pi_next_object)(pi));
1201 }
1202
1203 /*
1204 * prop_object_iterator_reset --
1205 * Reset the iterator to the first object so as to restart
1206 * iteration.
1207 */
1208 void
1209 prop_object_iterator_reset(prop_object_iterator_t pi)
1210 {
1211
1212 (*pi->pi_reset)(pi);
1213 }
1214
1215 /*
1216 * prop_object_iterator_release --
1217 * Release the object iterator.
1218 */
1219 void
1220 prop_object_iterator_release(prop_object_iterator_t pi)
1221 {
1222
1223 prop_object_release(pi->pi_obj);
1224 _PROP_FREE(pi, M_TEMP);
1225 }
DragonFly BSD