The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/libprop/prop_object.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    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 }

Cache object: a24229a5fc89018d26bb0d17976df6d2


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.