/*      $NetBSD: prop_string.c,v 1.24 2025/05/14 03:25:46 thorpej Exp $ */

/*-
* Copyright (c) 2006, 2020, 2025 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Jason R. Thorpe.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include "prop_object_impl.h"
#include <prop/prop_string.h>

#include <sys/rbtree.h>
#if defined(_KERNEL) || defined(_STANDALONE)
#include <sys/stdarg.h>
#else
#include <stdarg.h>
#endif /* _KERNEL || _STANDALONE */

struct _prop_string {
       struct _prop_object     ps_obj;
       union {
               char *          psu_mutable;
               const char *    psu_immutable;
       } ps_un;
#define ps_mutable              ps_un.psu_mutable
#define ps_immutable            ps_un.psu_immutable
       size_t                  ps_size;        /* not including \0 */
       struct rb_node          ps_link;
       int                     ps_flags;
};

#define PS_F_NOCOPY             0x01
#define PS_F_MUTABLE            0x02

_PROP_POOL_INIT(_prop_string_pool, sizeof(struct _prop_string), "propstng")
_PROP_MALLOC_DEFINE(M_PROP_STRING, "prop string",
                   "property string container object")

static const struct _prop_object_type_tags _prop_string_type_tags = {
       .xml_tag                =       "string",
       .json_open_tag          =       "\"",
       .json_close_tag         =       "\"",
};

static _prop_object_free_rv_t
               _prop_string_free(prop_stack_t, prop_object_t *);
static bool     _prop_string_externalize(
                               struct _prop_object_externalize_context *,
                               void *);
static _prop_object_equals_rv_t
               _prop_string_equals(prop_object_t, prop_object_t,
                                   void **, void **,
                                   prop_object_t *, prop_object_t *);

static const struct _prop_object_type _prop_object_type_string = {
       .pot_type       =       PROP_TYPE_STRING,
       .pot_free       =       _prop_string_free,
       .pot_extern     =       _prop_string_externalize,
       .pot_equals     =       _prop_string_equals,
};

#define prop_object_is_string(x)        \
       ((x) != NULL && (x)->ps_obj.po_type == &_prop_object_type_string)
#define prop_string_contents(x)  ((x)->ps_immutable ? (x)->ps_immutable : "")

/*
* In order to reduce memory usage, all immutable string objects are
* de-duplicated.
*/

static int
/*ARGSUSED*/
_prop_string_rb_compare_nodes(void *ctx _PROP_ARG_UNUSED,
                             const void *n1, const void *n2)
{
       const struct _prop_string * const ps1 = n1;
       const struct _prop_string * const ps2 = n2;

       _PROP_ASSERT(ps1->ps_immutable != NULL);
       _PROP_ASSERT(ps2->ps_immutable != NULL);

       return strcmp(ps1->ps_immutable, ps2->ps_immutable);
}

static int
/*ARGSUSED*/
_prop_string_rb_compare_key(void *ctx _PROP_ARG_UNUSED,
                           const void *n, const void *v)
{
       const struct _prop_string * const ps = n;
       const char * const cp = v;

       _PROP_ASSERT(ps->ps_immutable != NULL);

       return strcmp(ps->ps_immutable, cp);
}

static const rb_tree_ops_t _prop_string_rb_tree_ops = {
       .rbto_compare_nodes = _prop_string_rb_compare_nodes,
       .rbto_compare_key = _prop_string_rb_compare_key,
       .rbto_node_offset = offsetof(struct _prop_string, ps_link),
       .rbto_context = NULL
};

static struct rb_tree _prop_string_tree;

_PROP_ONCE_DECL(_prop_string_init_once)
_PROP_MUTEX_DECL_STATIC(_prop_string_tree_mutex)

static int
_prop_string_init(void)
{

       _PROP_MUTEX_INIT(_prop_string_tree_mutex);
       rb_tree_init(&_prop_string_tree,
                    &_prop_string_rb_tree_ops);

       return 0;
}

/* ARGSUSED */
static _prop_object_free_rv_t
_prop_string_free(prop_stack_t stack, prop_object_t *obj)
{
       prop_string_t ps = *obj;

       if ((ps->ps_flags & PS_F_MUTABLE) == 0) {
               _PROP_MUTEX_LOCK(_prop_string_tree_mutex);
               /*
                * Double-check the retain count now that we've
                * acquired the tree lock; holding this lock prevents
                * new retains from coming in by finding it in the
                * tree.
                */
               if (_PROP_ATOMIC_LOAD(&ps->ps_obj.po_refcnt) == 0)
                       rb_tree_remove_node(&_prop_string_tree, ps);
               else
                       ps = NULL;
               _PROP_MUTEX_UNLOCK(_prop_string_tree_mutex);

               if (ps == NULL)
                       return (_PROP_OBJECT_FREE_DONE);
       }

       if ((ps->ps_flags & PS_F_NOCOPY) == 0 && ps->ps_mutable != NULL)
               _PROP_FREE(ps->ps_mutable, M_PROP_STRING);
       _PROP_POOL_PUT(_prop_string_pool, ps);

       return (_PROP_OBJECT_FREE_DONE);
}

bool
_prop_string_externalize_internal(struct _prop_object_externalize_context *ctx,
                                 const struct _prop_object_type_tags *tags,
                                 const char *str)
{
       if (_prop_extern_append_start_tag(ctx, tags, NULL) == false ||
           _prop_extern_append_encoded_cstring(ctx, str) == false ||
           _prop_extern_append_end_tag(ctx, tags) == false) {
               return false;
       }

       return true;
}

static bool
_prop_string_externalize(struct _prop_object_externalize_context *ctx,
                        void *v)
{
       prop_string_t ps = v;

       if (ps->ps_size == 0) {
               return _prop_extern_append_empty_tag(ctx,
                   &_prop_string_type_tags);
       }

       return _prop_string_externalize_internal(ctx, &_prop_string_type_tags,
           ps->ps_immutable);
}

/* ARGSUSED */
static _prop_object_equals_rv_t
_prop_string_equals(prop_object_t v1, prop_object_t v2,
   void **stored_pointer1, void **stored_pointer2,
   prop_object_t *next_obj1, prop_object_t *next_obj2)
{
       prop_string_t str1 = v1;
       prop_string_t str2 = v2;

       if (str1 == str2)
               return (_PROP_OBJECT_EQUALS_TRUE);
       if (str1->ps_size != str2->ps_size)
               return (_PROP_OBJECT_EQUALS_FALSE);
       if (strcmp(prop_string_contents(str1), prop_string_contents(str2)))
               return (_PROP_OBJECT_EQUALS_FALSE);
       else
               return (_PROP_OBJECT_EQUALS_TRUE);
}

static prop_string_t
_prop_string_alloc(int const flags)
{
       prop_string_t ps;

       ps = _PROP_POOL_GET(_prop_string_pool);
       if (ps != NULL) {
               _prop_object_init(&ps->ps_obj, &_prop_object_type_string);

               ps->ps_mutable = NULL;
               ps->ps_size = 0;
               ps->ps_flags = flags;
       }

       return (ps);
}

static prop_string_t
_prop_string_instantiate(int const flags, const char * const str,
   size_t const len)
{
       prop_string_t ps;

       _PROP_ONCE_RUN(_prop_string_init_once, _prop_string_init);

       ps = _prop_string_alloc(flags);
       if (ps != NULL) {
               ps->ps_immutable = str;
               ps->ps_size = len;

               if ((flags & PS_F_MUTABLE) == 0) {
                       prop_string_t ops;

                       _PROP_MUTEX_LOCK(_prop_string_tree_mutex);
                       ops = rb_tree_insert_node(&_prop_string_tree, ps);
                       if (ops != ps) {
                               /*
                                * Equivalent string object already exist;
                                * free the new one and return a reference
                                * to the existing object.
                                */
                               prop_object_retain(ops);
                               _PROP_MUTEX_UNLOCK(_prop_string_tree_mutex);
                               if ((flags & PS_F_NOCOPY) == 0) {
                                       _PROP_FREE(ps->ps_mutable,
                                           M_PROP_STRING);
                               }
                               _PROP_POOL_PUT(_prop_string_pool, ps);
                               ps = ops;
                       } else {
                               _PROP_MUTEX_UNLOCK(_prop_string_tree_mutex);
                       }
               }
       } else if ((flags & PS_F_NOCOPY) == 0) {
               _PROP_FREE(_PROP_UNCONST(str), M_PROP_STRING);
       }

       return (ps);
}

_PROP_DEPRECATED(prop_string_create,
   "this program uses prop_string_create(); all functions "
   "supporting mutable prop_strings are deprecated.")
_PROP_EXPORT prop_string_t
prop_string_create(void)
{

       return (_prop_string_alloc(PS_F_MUTABLE));
}

_PROP_DEPRECATED(prop_string_create_cstring,
   "this program uses prop_string_create_cstring(); all functions "
   "supporting mutable prop_strings are deprecated.")
_PROP_EXPORT prop_string_t
prop_string_create_cstring(const char *str)
{
       prop_string_t ps;
       char *cp;
       size_t len;

       _PROP_ASSERT(str != NULL);

       ps = _prop_string_alloc(PS_F_MUTABLE);
       if (ps != NULL) {
               len = strlen(str);
               cp = _PROP_MALLOC(len + 1, M_PROP_STRING);
               if (cp == NULL) {
                       prop_object_release(ps);
                       return (NULL);
               }
               strcpy(cp, str);
               ps->ps_mutable = cp;
               ps->ps_size = len;
       }
       return (ps);
}

_PROP_DEPRECATED(prop_string_create_cstring_nocopy,
   "this program uses prop_string_create_cstring_nocopy(), "
   "which is deprecated; use prop_string_create_nocopy() instead.")
_PROP_EXPORT prop_string_t
prop_string_create_cstring_nocopy(const char *str)
{
       return prop_string_create_nocopy(str);
}

/*
* prop_string_create_format --
*      Create a string object using the provided format string.
*/
_PROP_EXPORT prop_string_t __printflike(1, 2)
prop_string_create_format(const char *fmt, ...)
{
       char *str = NULL;
       int len;
       size_t nlen;
       va_list ap;

       _PROP_ASSERT(fmt != NULL);

       va_start(ap, fmt);
       len = vsnprintf(NULL, 0, fmt, ap);
       va_end(ap);

       if (len < 0)
               return (NULL);
       nlen = len + 1;

       str = _PROP_MALLOC(nlen, M_PROP_STRING);
       if (str == NULL)
               return (NULL);

       va_start(ap, fmt);
       vsnprintf(str, nlen, fmt, ap);
       va_end(ap);

       return _prop_string_instantiate(0, str, (size_t)len);
}

/*
* prop_string_create_copy --
*      Create a string object by coping the provided constant string.
*/
_PROP_EXPORT prop_string_t
prop_string_create_copy(const char *str)
{
       return prop_string_create_format("%s", str);
}

/*
* prop_string_create_nocopy --
*      Create a string object using the provided external constant
*      string.
*/
_PROP_EXPORT prop_string_t
prop_string_create_nocopy(const char *str)
{

       _PROP_ASSERT(str != NULL);

       return _prop_string_instantiate(PS_F_NOCOPY, str, strlen(str));
}

/*
* prop_string_copy --
*      Copy a string.  This reduces to a retain in the common case.
*      Deprecated mutable string objects must be copied.
*/
_PROP_EXPORT prop_string_t
prop_string_copy(prop_string_t ops)
{
       char *cp;

       if (! prop_object_is_string(ops))
               return (NULL);

       if ((ops->ps_flags & PS_F_MUTABLE) == 0) {
               prop_object_retain(ops);
               return (ops);
       }

       cp = _PROP_MALLOC(ops->ps_size + 1, M_PROP_STRING);
       if (cp == NULL)
               return NULL;

       strcpy(cp, prop_string_contents(ops));

       return _prop_string_instantiate(PS_F_MUTABLE, cp, ops->ps_size);
}

_PROP_DEPRECATED(prop_string_copy_mutable,
   "this program uses prop_string_copy_mutable(); all functions "
   "supporting mutable prop_strings are deprecated.")
_PROP_EXPORT prop_string_t
prop_string_copy_mutable(prop_string_t ops)
{
       char *cp;

       if (! prop_object_is_string(ops))
               return (NULL);

       cp = _PROP_MALLOC(ops->ps_size + 1, M_PROP_STRING);
       if (cp == NULL)
               return NULL;

       strcpy(cp, prop_string_contents(ops));

       return _prop_string_instantiate(PS_F_MUTABLE, cp, ops->ps_size);
}

/*
* prop_string_size --
*      Return the size of the string, not including the terminating NUL.
*/
_PROP_EXPORT size_t
prop_string_size(prop_string_t ps)
{

       if (! prop_object_is_string(ps))
               return (0);

       return (ps->ps_size);
}

/*
* prop_string_value --
*      Returns a pointer to the string object's value.  This pointer
*      remains valid only as long as the string object.
*/
_PROP_EXPORT const char *
prop_string_value(prop_string_t ps)
{

       if (! prop_object_is_string(ps))
               return (NULL);

       if ((ps->ps_flags & PS_F_MUTABLE) == 0)
               return (ps->ps_immutable);

       return (prop_string_contents(ps));
}

/*
* prop_string_copy_value --
*      Copy the string object's value into the supplied buffer.
*/
_PROP_EXPORT bool
prop_string_copy_value(prop_string_t ps, void *buf, size_t buflen)
{

       if (! prop_object_is_string(ps))
               return (false);

       if (buf == NULL || buflen < ps->ps_size + 1)
               return (false);

       strcpy(buf, prop_string_contents(ps));

       return (true);
}

_PROP_DEPRECATED(prop_string_mutable,
   "this program uses prop_string_mutable(); all functions "
   "supporting mutable prop_strings are deprecated.")
_PROP_EXPORT bool
prop_string_mutable(prop_string_t ps)
{

       if (! prop_object_is_string(ps))
               return (false);

       return ((ps->ps_flags & PS_F_MUTABLE) != 0);
}

_PROP_DEPRECATED(prop_string_cstring,
   "this program uses prop_string_cstring(), "
   "which is deprecated; use prop_string_copy_value() instead.")
_PROP_EXPORT char *
prop_string_cstring(prop_string_t ps)
{
       char *cp;

       if (! prop_object_is_string(ps))
               return (NULL);

       cp = _PROP_MALLOC(ps->ps_size + 1, M_TEMP);
       if (cp != NULL)
               strcpy(cp, prop_string_contents(ps));

       return (cp);
}

_PROP_DEPRECATED(prop_string_cstring_nocopy,
   "this program uses prop_string_cstring_nocopy(), "
   "which is deprecated; use prop_string_value() instead.")
_PROP_EXPORT const char *
prop_string_cstring_nocopy(prop_string_t ps)
{

       if (! prop_object_is_string(ps))
               return (NULL);

       return (prop_string_contents(ps));
}

_PROP_DEPRECATED(prop_string_append,
   "this program uses prop_string_append(); all functions "
   "supporting mutable prop_strings are deprecated.")
_PROP_EXPORT bool
prop_string_append(prop_string_t dst, prop_string_t src)
{
       char *ocp, *cp;
       size_t len;

       if (! (prop_object_is_string(dst) &&
              prop_object_is_string(src)))
               return (false);

       if ((dst->ps_flags & PS_F_MUTABLE) == 0)
               return (false);

       len = dst->ps_size + src->ps_size;
       cp = _PROP_MALLOC(len + 1, M_PROP_STRING);
       if (cp == NULL)
               return (false);
       snprintf(cp, len + 1, "%s%s", prop_string_contents(dst),
               prop_string_contents(src));
       ocp = dst->ps_mutable;
       dst->ps_mutable = cp;
       dst->ps_size = len;
       if (ocp != NULL)
               _PROP_FREE(ocp, M_PROP_STRING);

       return (true);
}

_PROP_DEPRECATED(prop_string_append_cstring,
   "this program uses prop_string_append_cstring(); all functions "
   "supporting mutable prop_strings are deprecated.")
_PROP_EXPORT bool
prop_string_append_cstring(prop_string_t dst, const char *src)
{
       char *ocp, *cp;
       size_t len;

       if (! prop_object_is_string(dst))
               return (false);

       _PROP_ASSERT(src != NULL);

       if ((dst->ps_flags & PS_F_MUTABLE) == 0)
               return (false);

       len = dst->ps_size + strlen(src);
       cp = _PROP_MALLOC(len + 1, M_PROP_STRING);
       if (cp == NULL)
               return (false);
       snprintf(cp, len + 1, "%s%s", prop_string_contents(dst), src);
       ocp = dst->ps_mutable;
       dst->ps_mutable = cp;
       dst->ps_size = len;
       if (ocp != NULL)
               _PROP_FREE(ocp, M_PROP_STRING);

       return (true);
}

/*
* prop_string_equals --
*      Return true if two strings are equivalent.
*/
_PROP_EXPORT bool
prop_string_equals(prop_string_t str1, prop_string_t str2)
{
       if (!prop_object_is_string(str1) || !prop_object_is_string(str2))
               return (false);

       return prop_object_equals(str1, str2);
}

/*
* prop_string_equals_string --
*      Return true if the string object is equivalent to the specified
*      C string.
*/
_PROP_EXPORT bool
prop_string_equals_string(prop_string_t ps, const char *cp)
{

       if (! prop_object_is_string(ps))
               return (false);

       return (strcmp(prop_string_contents(ps), cp) == 0);
}

_PROP_DEPRECATED(prop_string_equals_cstring,
   "this program uses prop_string_equals_cstring(), "
   "which is deprecated; prop_string_equals_string() instead.")
_PROP_EXPORT bool
prop_string_equals_cstring(prop_string_t ps, const char *cp)
{
       return prop_string_equals_string(ps, cp);
}

/*
* prop_string_compare --
*      Compare two string objects, using strcmp() semantics.
*/
_PROP_EXPORT int
prop_string_compare(prop_string_t ps1, prop_string_t ps2)
{
       if (!prop_object_is_string(ps1) || !prop_object_is_string(ps2))
               return (-666);  /* arbitrary */

       return (strcmp(prop_string_contents(ps1),
                      prop_string_contents(ps2)));
}

/*
* prop_string_compare_string --
*      Compare a string object to the specified C string, using
*      strcmp() semantics.
*/
_PROP_EXPORT int
prop_string_compare_string(prop_string_t ps, const char *cp)
{
       if (!prop_object_is_string(ps))
               return (-666);  /* arbitrary */

       return (strcmp(prop_string_contents(ps), cp));
}

/*
* _prop_string_internalize --
*      Parse a <string>...</string> and return the object created from the
*      external representation.
*/
/* ARGSUSED */
bool
_prop_string_internalize(prop_stack_t stack, prop_object_t *obj,
   struct _prop_object_internalize_context *ctx)
{
       char *str;
       size_t len, alen;

       /*
        * N.B. for empty JSON strings, the layer above us has made it
        * look like XML.
        */
       if (ctx->poic_is_empty_element) {
               *obj = prop_string_create();
               return (true);
       }

       /* No attributes recognized here. */
       if (ctx->poic_tagattr != NULL)
               return (true);

       /* Compute the length of the result. */
       if (_prop_intern_decode_string(ctx, NULL, 0, &len, NULL) == false)
               return (true);

       str = _PROP_MALLOC(len + 1, M_PROP_STRING);
       if (str == NULL)
               return (true);

       if (_prop_intern_decode_string(ctx, str, len, &alen,
                                      &ctx->poic_cp) == false ||
           alen != len) {
               _PROP_FREE(str, M_PROP_STRING);
               return (true);
       }
       str[len] = '\0';

       if (ctx->poic_format == PROP_FORMAT_JSON) {
               if (*ctx->poic_cp != '"') {
                       _PROP_FREE(str, M_PROP_STRING);
                       return (true);
               }
               ctx->poic_cp++;
       } else {
               if (_prop_xml_intern_find_tag(ctx, "string",
                                             _PROP_TAG_TYPE_END) == false) {
                       _PROP_FREE(str, M_PROP_STRING);
                       return (true);
               }
       }

       *obj = _prop_string_instantiate(0, str, len);
       return (true);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.