prop_data.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*      $NetBSD: prop_data.c,v 1.14 2009/01/25 06:59:35 cyber 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_data.h>
   33 #include "prop_object_impl.h"
   34 
   35 #if defined(_KERNEL)
   36 #include <sys/systm.h>
   37 #include <sys/libkern.h>
   38 #elif defined(_STANDALONE)
   39 #include <sys/param.h>
   40 #include <lib/libkern/libkern.h>
   41 #else
   42 #include <errno.h>
   43 #include <limits.h>
   44 #include <stdlib.h>
   45 #endif
   46 
   47 struct _prop_data {
   48         struct _prop_object     pd_obj;
   49         union {
   50                 void *          pdu_mutable;
   51                 const void *    pdu_immutable;
   52         } pd_un;
   53 #define pd_mutable              pd_un.pdu_mutable
   54 #define pd_immutable            pd_un.pdu_immutable
   55         size_t                  pd_size;
   56         int                     pd_flags;
   57 };
   58 
   59 #define PD_F_NOCOPY             0x01
   60 
   61 _PROP_POOL_INIT(_prop_data_pool, sizeof(struct _prop_data), "propdata")
   62 
   63 _PROP_MALLOC_DEFINE(M_PROP_DATA, "prop data",
   64                     "property data container object")
   65 
   66 static _prop_object_free_rv_t
   67                 _prop_data_free(prop_stack_t, prop_object_t *);
   68 static bool     _prop_data_externalize(
   69                                 struct _prop_object_externalize_context *,
   70                                 void *);
   71 static _prop_object_equals_rv_t
   72                 _prop_data_equals(prop_object_t, prop_object_t,
   73                                   void **, void **,
   74                                   prop_object_t *, prop_object_t *);
   75 
   76 static const struct _prop_object_type _prop_object_type_data = {
   77         .pot_type       =       PROP_TYPE_DATA,
   78         .pot_free       =       _prop_data_free,
   79         .pot_extern     =       _prop_data_externalize,
   80         .pot_equals     =       _prop_data_equals,
   81 };
   82 
   83 #define prop_object_is_data(x)          \
   84         ((x) != NULL && (x)->pd_obj.po_type == &_prop_object_type_data)
   85 
   86 /* ARGSUSED */
   87 static _prop_object_free_rv_t
   88 _prop_data_free(prop_stack_t stack, prop_object_t *obj)
   89 {
   90         prop_data_t pd = *obj;
   91 
   92         if ((pd->pd_flags & PD_F_NOCOPY) == 0 && pd->pd_mutable != NULL)
   93                 _PROP_FREE(pd->pd_mutable, M_PROP_DATA);
   94         _PROP_POOL_PUT(_prop_data_pool, pd);
   95 
   96         return (_PROP_OBJECT_FREE_DONE);
   97 }
   98 
   99 static const char _prop_data_base64[] =
  100     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  101 static const char _prop_data_pad64 = '=';
  102 
  103 static bool
  104 _prop_data_externalize(struct _prop_object_externalize_context *ctx, void *v)
  105 {
  106         prop_data_t pd = v;
  107         size_t i, srclen;
  108         const uint8_t *src;
  109         uint8_t output[4];
  110         uint8_t input[3];
  111 
  112         if (pd->pd_size == 0)
  113                 return (_prop_object_externalize_empty_tag(ctx, "data"));
  114 
  115         if (_prop_object_externalize_start_tag(ctx, "data") == false)
  116                 return (false);
  117 
  118         for (src = pd->pd_immutable, srclen = pd->pd_size;
  119              srclen > 2; srclen -= 3) {
  120                 input[0] = *src++;
  121                 input[1] = *src++;
  122                 input[2] = *src++;
  123 
  124                 output[0] = (uint32_t)input[0] >> 2;
  125                 output[1] = ((uint32_t)(input[0] & 0x03) << 4) +
  126                     ((uint32_t)input[1] >> 4);
  127                 output[2] = ((uint32_t)(input[1] & 0x0f) << 2) +
  128                     ((uint32_t)input[2] >> 6);
  129                 output[3] = input[2] & 0x3f;
  130                 _PROP_ASSERT(output[0] < 64);
  131                 _PROP_ASSERT(output[1] < 64);
  132                 _PROP_ASSERT(output[2] < 64);
  133                 _PROP_ASSERT(output[3] < 64);
  134 
  135                 if (_prop_object_externalize_append_char(ctx,
  136                                 _prop_data_base64[output[0]]) == false ||
  137                     _prop_object_externalize_append_char(ctx,
  138                                 _prop_data_base64[output[1]]) == false ||
  139                     _prop_object_externalize_append_char(ctx,
  140                                 _prop_data_base64[output[2]]) == false ||
  141                     _prop_object_externalize_append_char(ctx,
  142                                 _prop_data_base64[output[3]]) == false)
  143                         return (false);
  144         }
  145 
  146         if (srclen != 0) {
  147                 input[0] = input[1] = input[2] = '\0';
  148                 for (i = 0; i < srclen; i++)
  149                         input[i] = *src++;
  150 
  151                 output[0] = (uint32_t)input[0] >> 2;
  152                 output[1] = ((uint32_t)(input[0] & 0x03) << 4) +
  153                     ((uint32_t)input[1] >> 4);
  154                 output[2] = ((uint32_t)(input[1] & 0x0f) << 2) +
  155                     ((uint32_t)input[2] >> 6);
  156                 _PROP_ASSERT(output[0] < 64);
  157                 _PROP_ASSERT(output[1] < 64);
  158                 _PROP_ASSERT(output[2] < 64);
  159 
  160                 if (_prop_object_externalize_append_char(ctx,
  161                                 _prop_data_base64[output[0]]) == false ||
  162                     _prop_object_externalize_append_char(ctx,
  163                                 _prop_data_base64[output[1]]) == false ||
  164                     _prop_object_externalize_append_char(ctx,
  165                                 srclen == 1 ? _prop_data_pad64
  166                                 : _prop_data_base64[output[2]]) == false ||
  167                     _prop_object_externalize_append_char(ctx,
  168                                 _prop_data_pad64) == false)
  169                         return (false);
  170         }
  171 
  172         if (_prop_object_externalize_end_tag(ctx, "data") == false)
  173                 return (false);
  174 
  175         return (true);
  176 }
  177 
  178 /* ARGSUSED */
  179 static _prop_object_equals_rv_t
  180 _prop_data_equals(prop_object_t v1, prop_object_t v2,
  181     void **stored_pointer1, void **stored_pointer2,
  182     prop_object_t *next_obj1, prop_object_t *next_obj2)
  183 {
  184         prop_data_t pd1 = v1;
  185         prop_data_t pd2 = v2;
  186 
  187         if (pd1 == pd2)
  188                 return (_PROP_OBJECT_EQUALS_TRUE);
  189         if (pd1->pd_size != pd2->pd_size)
  190                 return (_PROP_OBJECT_EQUALS_FALSE);
  191         if (pd1->pd_size == 0) {
  192                 _PROP_ASSERT(pd1->pd_immutable == NULL);
  193                 _PROP_ASSERT(pd2->pd_immutable == NULL);
  194                 return (_PROP_OBJECT_EQUALS_TRUE);
  195         }
  196         if (memcmp(pd1->pd_immutable, pd2->pd_immutable, pd1->pd_size) == 0)
  197                 return _PROP_OBJECT_EQUALS_TRUE;
  198         else
  199                 return _PROP_OBJECT_EQUALS_FALSE;
  200 }
  201 
  202 static prop_data_t
  203 _prop_data_alloc(void)
  204 {
  205         prop_data_t pd;
  206 
  207         pd = _PROP_POOL_GET(_prop_data_pool);
  208         if (pd != NULL) {
  209                 _prop_object_init(&pd->pd_obj, &_prop_object_type_data);
  210 
  211                 pd->pd_mutable = NULL;
  212                 pd->pd_size = 0;
  213                 pd->pd_flags = 0;
  214         }
  215 
  216         return (pd);
  217 }
  218 
  219 /*
  220  * prop_data_create_data --
  221  *      Create a data container that contains a copy of the data.
  222  */
  223 prop_data_t
  224 prop_data_create_data(const void *v, size_t size)
  225 {
  226         prop_data_t pd;
  227         void *nv;
  228 
  229         pd = _prop_data_alloc();
  230         if (pd != NULL && size != 0) {
  231                 nv = _PROP_MALLOC(size, M_PROP_DATA);
  232                 if (nv == NULL) {
  233                         prop_object_release(pd);
  234                         return (NULL);
  235                 }
  236                 memcpy(nv, v, size);
  237                 pd->pd_mutable = nv;
  238                 pd->pd_size = size;
  239         }
  240         return (pd);
  241 }
  242 
  243 /*
  244  * prop_data_create_data_nocopy --
  245  *      Create an immutable data container that contains a refrence to the
  246  *      provided external data.
  247  */
  248 prop_data_t
  249 prop_data_create_data_nocopy(const void *v, size_t size)
  250 {
  251         prop_data_t pd;
  252 
  253         pd = _prop_data_alloc();
  254         if (pd != NULL) {
  255                 pd->pd_immutable = v;
  256                 pd->pd_size = size;
  257                 pd->pd_flags |= PD_F_NOCOPY;
  258         }
  259         return (pd);
  260 }
  261 
  262 /*
  263  * prop_data_copy --
  264  *      Copy a data container.  If the original data is external, then
  265  *      the copy is also references the same external data.
  266  */
  267 prop_data_t
  268 prop_data_copy(prop_data_t opd)
  269 {
  270         prop_data_t pd;
  271 
  272         if (! prop_object_is_data(opd))
  273                 return (NULL);
  274 
  275         pd = _prop_data_alloc();
  276         if (pd != NULL) {
  277                 pd->pd_size = opd->pd_size;
  278                 pd->pd_flags = opd->pd_flags;
  279                 if (opd->pd_flags & PD_F_NOCOPY)
  280                         pd->pd_immutable = opd->pd_immutable;
  281                 else if (opd->pd_size != 0) {
  282                         void *nv = _PROP_MALLOC(pd->pd_size, M_PROP_DATA);
  283                         if (nv == NULL) {
  284                                 prop_object_release(pd);
  285                                 return (NULL);
  286                         }
  287                         memcpy(nv, opd->pd_immutable, opd->pd_size);
  288                         pd->pd_mutable = nv;
  289                 }
  290         }
  291         return (pd);
  292 }
  293 
  294 /*
  295  * prop_data_size --
  296  *      Return the size of the data.
  297  */
  298 size_t
  299 prop_data_size(prop_data_t pd)
  300 {
  301 
  302         if (! prop_object_is_data(pd))
  303                 return (0);
  304 
  305         return (pd->pd_size);
  306 }
  307 
  308 /*
  309  * prop_data_data --
  310  *      Return a copy of the contents of the data container.
  311  *      The data is allocated with the M_TEMP malloc type.
  312  *      If the data container is empty, NULL is returned.
  313  */
  314 void *
  315 prop_data_data(prop_data_t pd)
  316 {
  317         void *v;
  318 
  319         if (! prop_object_is_data(pd))
  320                 return (NULL);
  321 
  322         if (pd->pd_size == 0) {
  323                 _PROP_ASSERT(pd->pd_immutable == NULL);
  324                 return (NULL);
  325         }
  326 
  327         _PROP_ASSERT(pd->pd_immutable != NULL);
  328 
  329         v = _PROP_MALLOC(pd->pd_size, M_TEMP);
  330         if (v != NULL)
  331                 memcpy(v, pd->pd_immutable, pd->pd_size);
  332 
  333         return (v);
  334 }
  335 
  336 /*
  337  * prop_data_data_nocopy --
  338  *      Return an immutable reference to the contents of the data
  339  *      container.
  340  */
  341 const void *
  342 prop_data_data_nocopy(prop_data_t pd)
  343 {
  344 
  345         if (! prop_object_is_data(pd))
  346                 return (NULL);
  347 
  348         _PROP_ASSERT((pd->pd_size == 0 && pd->pd_immutable == NULL) ||
  349                      (pd->pd_size != 0 && pd->pd_immutable != NULL));
  350 
  351         return (pd->pd_immutable);
  352 }
  353 
  354 /*
  355  * prop_data_equals --
  356  *      Return true if two strings are equivalent.
  357  */
  358 bool
  359 prop_data_equals(prop_data_t pd1, prop_data_t pd2)
  360 {
  361         if (!prop_object_is_data(pd1) || !prop_object_is_data(pd2))
  362                 return (false);
  363 
  364         return (prop_object_equals(pd1, pd2));
  365 }
  366 
  367 /*
  368  * prop_data_equals_data --
  369  *      Return true if the contained data is equivalent to the specified
  370  *      external data.
  371  */
  372 bool
  373 prop_data_equals_data(prop_data_t pd, const void *v, size_t size)
  374 {
  375 
  376         if (! prop_object_is_data(pd))
  377                 return (false);
  378 
  379         if (pd->pd_size != size)
  380                 return (false);
  381         return (memcmp(pd->pd_immutable, v, size) == 0);
  382 }
  383 
  384 static bool
  385 _prop_data_internalize_decode(struct _prop_object_internalize_context *ctx,
  386                              uint8_t *target, size_t targsize, size_t *sizep,
  387                              const char **cpp)
  388 {
  389         const char *src;
  390         size_t tarindex;
  391         int state, ch;
  392         const char *pos;
  393 
  394         state = 0;
  395         tarindex = 0;
  396         src = ctx->poic_cp;
  397 
  398         for (;;) {
  399                 ch = (unsigned char) *src++;
  400                 if (_PROP_EOF(ch))
  401                         return (false);
  402                 if (_PROP_ISSPACE(ch))
  403                         continue;
  404                 if (ch == '<') {
  405                         src--;
  406                         break;
  407                 }
  408                 if (ch == _prop_data_pad64)
  409                         break;
  410 
  411                 pos = strchr(_prop_data_base64, ch);
  412                 if (pos == NULL)
  413                         return (false);
  414 
  415                 switch (state) {
  416                 case 0:
  417                         if (target) {
  418                                 if (tarindex >= targsize)
  419                                         return (false);
  420                                 target[tarindex] =
  421                                     (uint8_t)((pos - _prop_data_base64) << 2);
  422                         }
  423                         state = 1;
  424                         break;
  425 
  426                 case 1:
  427                         if (target) {
  428                                 if (tarindex + 1 >= targsize)
  429                                         return (false);
  430                                 target[tarindex] |=
  431                                     (uint32_t)(pos - _prop_data_base64) >> 4;
  432                                 target[tarindex + 1] =
  433                                     (uint8_t)(((pos - _prop_data_base64) & 0xf)
  434                                         << 4);
  435                         }
  436                         tarindex++;
  437                         state = 2;
  438                         break;
  439 
  440                 case 2:
  441                         if (target) {
  442                                 if (tarindex + 1 >= targsize)
  443                                         return (false);
  444                                 target[tarindex] |=
  445                                     (uint32_t)(pos - _prop_data_base64) >> 2;
  446                                 target[tarindex + 1] =
  447                                     (uint8_t)(((pos - _prop_data_base64)
  448                                         & 0x3) << 6);
  449                         }
  450                         tarindex++;
  451                         state = 3;
  452                         break;
  453 
  454                 case 3:
  455                         if (target) {
  456                                 if (tarindex >= targsize)
  457                                         return (false);
  458                                 target[tarindex] |= (uint8_t)
  459                                     (pos - _prop_data_base64);
  460                         }
  461                         tarindex++;
  462                         state = 0;
  463                         break;
  464 
  465                 default:
  466                         _PROP_ASSERT(/*CONSTCOND*/0);
  467                 }
  468         }
  469 
  470         /*
  471          * We are done decoding the Base64 characters.  Let's see if we
  472          * ended up on a byte boundary and/or with unrecognized trailing
  473          * characters.
  474          */
  475         if (ch == _prop_data_pad64) {
  476                 ch = (unsigned char) *src;      /* src already advanced */
  477                 if (_PROP_EOF(ch))
  478                         return (false);
  479                 switch (state) {
  480                 case 0:         /* Invalid = in first position */
  481                 case 1:         /* Invalid = in second position */
  482                         return (false);
  483 
  484                 case 2:         /* Valid, one byte of info */
  485                         /* Skip whitespace */
  486                         for (ch = (unsigned char) *src++;
  487                              ch != '<'; ch = (unsigned char) *src++) {
  488                                 if (_PROP_EOF(ch))
  489                                         return (false);
  490                                 if (!_PROP_ISSPACE(ch))
  491                                         break;
  492                         }
  493                         /* Make sure there is another trailing = */
  494                         if (ch != _prop_data_pad64)
  495                                 return (false);
  496                         ch = (unsigned char) *src;
  497                         /* FALLTHROUGH */
  498 
  499                 case 3:         /* Valid, two bytes of info */
  500                         /*
  501                          * We know this char is a =.  Is there anything but
  502                          * whitespace after it?
  503                          */
  504                         for (ch = (unsigned char) *src++;
  505                              ch != '<'; ch = (unsigned char) *src++) {
  506                                 if (_PROP_EOF(ch))
  507                                         return (false);
  508                                 if (!_PROP_ISSPACE(ch))
  509                                         return (false);
  510                         }
  511                         /* back up to '<' */
  512                         src--;
  513                 }
  514         } else {
  515                 /*
  516                  * We ended by seeing the end of the Base64 string.  Make
  517                  * sure there are no partial bytes lying around.
  518                  */
  519                 if (state != 0)
  520                         return (false);
  521         }
  522 
  523         _PROP_ASSERT(*src == '<');
  524         if (sizep != NULL)
  525                 *sizep = tarindex;
  526         if (cpp != NULL)
  527                 *cpp = src;
  528 
  529         return (true);
  530 }
  531 
  532 /*
  533  * _prop_data_internalize --
  534  *      Parse a <data>...</data> and return the object created from the
  535  *      external representation.
  536  */
  537 
  538 /* strtoul is used for parsing, enforce. */
  539 typedef int PROP_DATA_ASSERT[/* CONSTCOND */sizeof(size_t) == sizeof(unsigned long) ? 1 : -1];
  540 
  541 /* ARGSUSED */
  542 bool
  543 _prop_data_internalize(prop_stack_t stack, prop_object_t *obj,
  544     struct _prop_object_internalize_context *ctx)
  545 {
  546         prop_data_t data;
  547         uint8_t *buf;
  548         size_t len, alen;
  549 
  550         /*
  551          * We don't accept empty elements.
  552          * This actually only checks for the node to be <data/>
  553          * (Which actually causes another error if found.)
  554          */
  555         if (ctx->poic_is_empty_element)
  556                 return (true);
  557 
  558         /*
  559          * If we got a "size" attribute, get the size of the data blob
  560          * from that.  Otherwise, we have to figure it out from the base64.
  561          */
  562         if (ctx->poic_tagattr != NULL) {
  563                 char *cp;
  564 
  565                 if (!_PROP_TAGATTR_MATCH(ctx, "size") ||
  566                     ctx->poic_tagattrval_len == 0)
  567                         return (true);
  568 
  569 #ifndef _KERNEL
  570                 errno = 0;
  571 #endif
  572                 len = strtoul(ctx->poic_tagattrval, &cp, 0);
  573 #ifndef _KERNEL         /* XXX can't check for ERANGE in the kernel */
  574                 if (len == ULONG_MAX && errno == ERANGE)
  575                         return (true);
  576 #endif
  577                 if (cp != ctx->poic_tagattrval + ctx->poic_tagattrval_len)
  578                         return (true);
  579                 _PROP_ASSERT(*cp == '\"');
  580         } else if (_prop_data_internalize_decode(ctx, NULL, 0, &len,
  581                                                 NULL) == false)
  582                 return (true);
  583 
  584         /*
  585          * Always allocate one extra in case we don't land on an even byte
  586          * boundary during the decode.
  587          */
  588         buf = _PROP_MALLOC(len + 1, M_PROP_DATA);
  589         if (buf == NULL)
  590                 return (true);
  591 
  592         if (_prop_data_internalize_decode(ctx, buf, len + 1, &alen,
  593                                           &ctx->poic_cp) == false) {
  594                 _PROP_FREE(buf, M_PROP_DATA);
  595                 return (true);
  596         }
  597         if (alen != len) {
  598                 _PROP_FREE(buf, M_PROP_DATA);
  599                 return (true);
  600         }
  601 
  602         if (_prop_object_internalize_find_tag(ctx, "data",
  603                                               _PROP_TAG_TYPE_END) == false) {
  604                 _PROP_FREE(buf, M_PROP_DATA);
  605                 return (true);
  606         }
  607 
  608         data = _prop_data_alloc();
  609         if (data == NULL) {
  610                 _PROP_FREE(buf, M_PROP_DATA);
  611                 return (true);
  612         }
  613 
  614         /*
  615          * Handle alternate type of empty node.
  616          * XML document could contain open/close tags, yet still be empty.
  617          */
  618         if (alen == 0) {
  619                 _PROP_FREE(buf, M_PROP_DATA);
  620                 data->pd_mutable = NULL;
  621         } else {
  622                 data->pd_mutable = buf;
  623         }
  624         data->pd_size = len;
  625 
  626         *obj = data;
  627         return (true);
  628 }
Cache object: b73e2c242f4dbfead2209166c17e4df4
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/libprop/prop_data.c

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