common/lib/libprop/prop_object_impl.h

   1 /*      $NetBSD: prop_object_impl.h,v 1.29 2009/01/03 18:31:34 pooka 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 #ifndef _PROPLIB_PROP_OBJECT_IMPL_H_
  33 #define _PROPLIB_PROP_OBJECT_IMPL_H_
  34
  35 #if defined(_KERNEL) || defined(_STANDALONE)
  36 #include <lib/libkern/libkern.h>
  37 #else
  38 #include <inttypes.h>
  39 #endif
  40
  41 #include "prop_stack.h"
  42
  43 struct _prop_object_externalize_context {
  44         char *          poec_buf;               /* string buffer */
  45         size_t          poec_capacity;          /* capacity of buffer */
  46         size_t          poec_len;               /* current length of string */
  47         unsigned int    poec_depth;             /* nesting depth */
  48 };
  49
  50 bool            _prop_object_externalize_start_tag(
  51                                 struct _prop_object_externalize_context *,
  52                                 const char *);
  53 bool            _prop_object_externalize_end_tag(
  54                                 struct _prop_object_externalize_context *,
  55                                 const char *);
  56 bool            _prop_object_externalize_empty_tag(
  57                                 struct _prop_object_externalize_context *,
  58                                 const char *);
  59 bool            _prop_object_externalize_append_cstring(
  60                                 struct _prop_object_externalize_context *,
  61                                 const char *);
  62 bool            _prop_object_externalize_append_encoded_cstring(
  63                                 struct _prop_object_externalize_context *,
  64                                 const char *);
  65 bool            _prop_object_externalize_append_char(
  66                                 struct _prop_object_externalize_context *,
  67                                 unsigned char);
  68 bool            _prop_object_externalize_header(
  69                                 struct _prop_object_externalize_context *);
  70 bool            _prop_object_externalize_footer(
  71                                 struct _prop_object_externalize_context *);
  72
  73 struct _prop_object_externalize_context *
  74         _prop_object_externalize_context_alloc(void);
  75 void    _prop_object_externalize_context_free(
  76                                 struct _prop_object_externalize_context *);
  77
  78 typedef enum {
  79         _PROP_TAG_TYPE_START,                   /* e.g. <dict> */
  80         _PROP_TAG_TYPE_END,                     /* e.g. </dict> */
  81         _PROP_TAG_TYPE_EITHER
  82 } _prop_tag_type_t;
  83
  84 struct _prop_object_internalize_context {
  85         const char *poic_xml;
  86         const char *poic_cp;
  87
  88         const char *poic_tag_start;
  89
  90         const char *poic_tagname;
  91         size_t      poic_tagname_len;
  92         const char *poic_tagattr;
  93         size_t      poic_tagattr_len;
  94         const char *poic_tagattrval;
  95         size_t      poic_tagattrval_len;
  96
  97         bool   poic_is_empty_element;
  98         _prop_tag_type_t poic_tag_type;
  99 };
 100
 101 typedef enum {
 102         _PROP_OBJECT_FREE_DONE,
 103         _PROP_OBJECT_FREE_RECURSE,
 104         _PROP_OBJECT_FREE_FAILED
 105 } _prop_object_free_rv_t;
 106
 107 typedef enum {
 108         _PROP_OBJECT_EQUALS_FALSE,
 109         _PROP_OBJECT_EQUALS_TRUE,
 110         _PROP_OBJECT_EQUALS_RECURSE
 111 } _prop_object_equals_rv_t;
 112
 113 #define _PROP_EOF(c)            ((c) == '\0')
 114 #define _PROP_ISSPACE(c)        \
 115         ((c) == ' ' || (c) == '\t' || (c) == '\n' || (c) == '\r' || \
 116          _PROP_EOF(c))
 117
 118 #define _PROP_TAG_MATCH(ctx, t)                                 \
 119         _prop_object_internalize_match((ctx)->poic_tagname,     \
 120                                        (ctx)->poic_tagname_len, \
 121                                        (t), strlen(t))
 122
 123 #define _PROP_TAGATTR_MATCH(ctx, a)                             \
 124         _prop_object_internalize_match((ctx)->poic_tagattr,     \
 125                                        (ctx)->poic_tagattr_len, \
 126                                        (a), strlen(a))
 127
 128 #define _PROP_TAGATTRVAL_MATCH(ctx, a)                            \
 129         _prop_object_internalize_match((ctx)->poic_tagattrval,    \
 130                                        (ctx)->poic_tagattrval_len,\
 131                                        (a), strlen(a))
 132
 133 bool            _prop_object_internalize_find_tag(
 134                                 struct _prop_object_internalize_context *,
 135                                 const char *, _prop_tag_type_t);
 136 bool            _prop_object_internalize_match(const char *, size_t,
 137                                                const char *, size_t);
 138 prop_object_t   _prop_object_internalize_by_tag(
 139                                 struct _prop_object_internalize_context *);
 140 bool            _prop_object_internalize_decode_string(
 141                                 struct _prop_object_internalize_context *,
 142                                 char *, size_t, size_t *, const char **);
 143 prop_object_t   _prop_generic_internalize(const char *, const char *);
 144
 145 struct _prop_object_internalize_context *
 146                 _prop_object_internalize_context_alloc(const char *);
 147 void            _prop_object_internalize_context_free(
 148                                 struct _prop_object_internalize_context *);
 149
 150 #if !defined(_KERNEL) && !defined(_STANDALONE)
 151 bool            _prop_object_externalize_write_file(const char *,
 152                                                     const char *, size_t);
 153
 154 struct _prop_object_internalize_mapped_file {
 155         char *  poimf_xml;
 156         size_t  poimf_mapsize;
 157 };
 158
 159 struct _prop_object_internalize_mapped_file *
 160                 _prop_object_internalize_map_file(const char *);
 161 void            _prop_object_internalize_unmap_file(
 162                                 struct _prop_object_internalize_mapped_file *);
 163 #endif /* !_KERNEL && !_STANDALONE */
 164
 165 typedef bool (*prop_object_internalizer_t)(prop_stack_t, prop_object_t *,
 166                                 struct _prop_object_internalize_context *);
 167 typedef bool (*prop_object_internalizer_continue_t)(prop_stack_t,
 168                                 prop_object_t *,
 169                                 struct _prop_object_internalize_context *,
 170                                 void *, prop_object_t);
 171
 172         /* These are here because they're required by shared code. */
 173 bool            _prop_array_internalize(prop_stack_t, prop_object_t *,
 174                                 struct _prop_object_internalize_context *);
 175 bool            _prop_bool_internalize(prop_stack_t, prop_object_t *,
 176                                 struct _prop_object_internalize_context *);
 177 bool            _prop_data_internalize(prop_stack_t, prop_object_t *,
 178                                 struct _prop_object_internalize_context *);
 179 bool            _prop_dictionary_internalize(prop_stack_t, prop_object_t *,
 180                                 struct _prop_object_internalize_context *);
 181 bool            _prop_number_internalize(prop_stack_t, prop_object_t *,
 182                                 struct _prop_object_internalize_context *);
 183 bool            _prop_string_internalize(prop_stack_t, prop_object_t *,
 184                                 struct _prop_object_internalize_context *);
 185
 186 struct _prop_object_type {
 187         /* type indicator */
 188         uint32_t        pot_type;
 189         /* func to free object */
 190         _prop_object_free_rv_t
 191                         (*pot_free)(prop_stack_t, prop_object_t *);
 192         /*
 193          * func to free the child returned by pot_free with stack == NULL.
 194          *
 195          * Must be implemented if pot_free can return anything other than
 196          * _PROP_OBJECT_FREE_DONE.
 197          */
 198         void    (*pot_emergency_free)(prop_object_t);
 199         /* func to externalize object */
 200         bool    (*pot_extern)(struct _prop_object_externalize_context *,
 201                               void *);
 202         /* func to test quality */
 203         _prop_object_equals_rv_t
 204                 (*pot_equals)(prop_object_t, prop_object_t,
 205                               void **, void **,
 206                               prop_object_t *, prop_object_t *);
 207         /*
 208          * func to finish equality iteration.
 209          *
 210          * Must be implemented if pot_equals can return
 211          * _PROP_OBJECT_EQUALS_RECURSE
 212          */
 213         void    (*pot_equals_finish)(prop_object_t, prop_object_t);
 214         void    (*pot_lock)(void);
 215         void    (*pot_unlock)(void);
 216 };
 217
 218 struct _prop_object {
 219         const struct _prop_object_type *po_type;/* type descriptor */
 220         uint32_t        po_refcnt;              /* reference count */
 221 };
 222
 223 void            _prop_object_init(struct _prop_object *,
 224                                   const struct _prop_object_type *);
 225 void            _prop_object_fini(struct _prop_object *);
 226
 227 struct _prop_object_iterator {
 228         prop_object_t   (*pi_next_object)(void *);
 229         void            (*pi_reset)(void *);
 230         prop_object_t   pi_obj;
 231         uint32_t        pi_version;
 232 };
 233
 234 #define _PROP_NOTHREAD_ONCE_DECL(x)     static bool x = false;
 235 #define _PROP_NOTHREAD_ONCE_RUN(x,f)                                    \
 236         do {                                                            \
 237                 if ((x) == false) {                                     \
 238                         f();                                            \
 239                         x = true;                                       \
 240                 }                                                       \
 241         } while (/*CONSTCOND*/0)
 242
 243 #if defined(_KERNEL)
 244
 245 /*
 246  * proplib in the kernel...
 247  */
 248
 249 #include <sys/param.h>
 250 #include <sys/malloc.h>
 251 #include <sys/pool.h>
 252 #include <sys/systm.h>
 253 #include <sys/rwlock.h>
 254 #include <sys/once.h>
 255
 256 #define _PROP_ASSERT(x)                 KASSERT(x)
 257
 258 #define _PROP_MALLOC(s, t)              malloc((s), (t), M_WAITOK)
 259 #define _PROP_CALLOC(s, t)              malloc((s), (t), M_WAITOK | M_ZERO)
 260 #define _PROP_REALLOC(v, s, t)          realloc((v), (s), (t), M_WAITOK)
 261 #define _PROP_FREE(v, t)                free((v), (t))
 262
 263 #define _PROP_POOL_GET(p)               pool_get(&(p), PR_WAITOK)
 264 #define _PROP_POOL_PUT(p, v)            pool_put(&(p), (v))
 265
 266 struct prop_pool_init {
 267         struct pool *pp;
 268         size_t size;
 269         const char *wchan;
 270 };
 271 #define _PROP_POOL_INIT(pp, size, wchan)                                \
 272 struct pool pp;                                                         \
 273 static const struct prop_pool_init _link_ ## pp[1] = {                  \
 274         { &pp, size, wchan }                                            \
 275 };                                                                      \
 276 __link_set_add_rodata(prop_linkpools, _link_ ## pp);
 277
 278 #define _PROP_MALLOC_DEFINE(t, s, l)                                    \
 279                 MALLOC_DEFINE(t, s, l);
 280
 281 #define _PROP_MUTEX_DECL_STATIC(x)      static kmutex_t x;
 282 #define _PROP_MUTEX_INIT(x)             mutex_init(&(x),MUTEX_DEFAULT,IPL_NONE)
 283 #define _PROP_MUTEX_LOCK(x)             mutex_enter(&(x))
 284 #define _PROP_MUTEX_UNLOCK(x)           mutex_exit(&(x))
 285
 286 #define _PROP_RWLOCK_DECL(x)            krwlock_t x ;
 287 #define _PROP_RWLOCK_INIT(x)            rw_init(&(x))
 288 #define _PROP_RWLOCK_RDLOCK(x)          rw_enter(&(x), RW_READER)
 289 #define _PROP_RWLOCK_WRLOCK(x)          rw_enter(&(x), RW_WRITER)
 290 #define _PROP_RWLOCK_UNLOCK(x)          rw_exit(&(x))
 291 #define _PROP_RWLOCK_DESTROY(x)         rw_destroy(&(x))
 292
 293 #define _PROP_ONCE_DECL(x)              static ONCE_DECL(x);
 294 #define _PROP_ONCE_RUN(x,f)             RUN_ONCE(&(x), f)
 295
 296 #elif defined(_STANDALONE)
 297
 298 /*
 299  * proplib in a standalone environment...
 300  */
 301
 302 #include <lib/libsa/stand.h>
 303
 304 void *          _prop_standalone_calloc(size_t);
 305 void *          _prop_standalone_realloc(void *, size_t);
 306
 307 #define _PROP_ASSERT(x)                 /* nothing */
 308
 309 #define _PROP_MALLOC(s, t)              alloc((s))
 310 #define _PROP_CALLOC(s, t)              _prop_standalone_calloc((s))
 311 #define _PROP_REALLOC(v, s, t)          _prop_standalone_realloc((v), (s))
 312 #define _PROP_FREE(v, t)                dealloc((v), 0)         /* XXX */
 313
 314 #define _PROP_POOL_GET(p)               alloc((p))
 315 #define _PROP_POOL_PUT(p, v)            dealloc((v), (p))
 316
 317 #define _PROP_POOL_INIT(p, s, d)        static const size_t p = s;
 318
 319 #define _PROP_MALLOC_DEFINE(t, s, l)    /* nothing */
 320
 321 #define _PROP_MUTEX_DECL_STATIC(x)      /* nothing */
 322 #define _PROP_MUTEX_INIT(x)             /* nothing */
 323 #define _PROP_MUTEX_LOCK(x)             /* nothing */
 324 #define _PROP_MUTEX_UNLOCK(x)           /* nothing */
 325
 326 #define _PROP_RWLOCK_DECL(x)            /* nothing */
 327 #define _PROP_RWLOCK_INIT(x)            /* nothing */
 328 #define _PROP_RWLOCK_RDLOCK(x)          /* nothing */
 329 #define _PROP_RWLOCK_WRLOCK(x)          /* nothing */
 330 #define _PROP_RWLOCK_UNLOCK(x)          /* nothing */
 331 #define _PROP_RWLOCK_DESTROY(x)         /* nothing */
 332
 333 #define _PROP_ONCE_DECL(x)              _PROP_NOTHREAD_ONCE_DECL(x)
 334 #define _PROP_ONCE_RUN(x,f)             _PROP_NOTHREAD_ONCE_RUN(x,f)
 335
 336 #else
 337
 338 /*
 339  * proplib in user space...
 340  */
 341
 342 #include <assert.h>
 343 #include <string.h>
 344 #include <stdio.h>
 345 #include <stdlib.h>
 346 #include <stddef.h>
 347
 348 #define _PROP_ASSERT(x)                 /*LINTED*/assert(x)
 349
 350 #define _PROP_MALLOC(s, t)              malloc((s))
 351 #define _PROP_CALLOC(s, t)              calloc(1, (s))
 352 #define _PROP_REALLOC(v, s, t)          realloc((v), (s))
 353 #define _PROP_FREE(v, t)                free((v))
 354
 355 #define _PROP_POOL_GET(p)               malloc((p))
 356 #define _PROP_POOL_PUT(p, v)            free((v))
 357
 358 #define _PROP_POOL_INIT(p, s, d)        static const size_t p = s;
 359
 360 #define _PROP_MALLOC_DEFINE(t, s, l)    /* nothing */
 361
 362 #if defined(__NetBSD__) && defined(_LIBPROP)
 363 /*
 364  * Use the same mechanism as libc; we get pthread mutexes for threaded
 365  * programs and do-nothing stubs for non-threaded programs.
 366  */
 367 #include "reentrant.h"
 368 #define _PROP_MUTEX_DECL_STATIC(x)      static mutex_t x;
 369 #define _PROP_MUTEX_INIT(x)             mutex_init(&(x), NULL)
 370 #define _PROP_MUTEX_LOCK(x)             mutex_lock(&(x))
 371 #define _PROP_MUTEX_UNLOCK(x)           mutex_unlock(&(x))
 372
 373 #define _PROP_RWLOCK_DECL(x)            rwlock_t x ;
 374 #define _PROP_RWLOCK_INIT(x)            rwlock_init(&(x), NULL)
 375 #define _PROP_RWLOCK_RDLOCK(x)          rwlock_rdlock(&(x))
 376 #define _PROP_RWLOCK_WRLOCK(x)          rwlock_wrlock(&(x))
 377 #define _PROP_RWLOCK_UNLOCK(x)          rwlock_unlock(&(x))
 378 #define _PROP_RWLOCK_DESTROY(x)         rwlock_destroy(&(x))
 379
 380 #define _PROP_ONCE_DECL(x)                                              \
 381         static pthread_once_t x = PTHREAD_ONCE_INIT;
 382 #define _PROP_ONCE_RUN(x,f)             thr_once(&(x), (void(*)(void))f);
 383
 384 #elif defined(HAVE_NBTOOL_CONFIG_H)
 385 /*
 386  * None of NetBSD's build tools are multi-threaded.
 387  */
 388 #define _PROP_MUTEX_DECL_STATIC(x)      /* nothing */
 389 #define _PROP_MUTEX_INIT(x)             /* nothing */
 390 #define _PROP_MUTEX_LOCK(x)             /* nothing */
 391 #define _PROP_MUTEX_UNLOCK(x)           /* nothing */
 392
 393 #define _PROP_RWLOCK_DECL(x)            /* nothing */
 394 #define _PROP_RWLOCK_INIT(x)            /* nothing */
 395 #define _PROP_RWLOCK_RDLOCK(x)          /* nothing */
 396 #define _PROP_RWLOCK_WRLOCK(x)          /* nothing */
 397 #define _PROP_RWLOCK_UNLOCK(x)          /* nothing */
 398 #define _PROP_RWLOCK_DESTROY(x)         /* nothing */
 399
 400 #define _PROP_ONCE_DECL(x)              _PROP_NOTHREAD_ONCE_DECL(x)
 401 #define _PROP_ONCE_RUN(x,f)             _PROP_NOTHREAD_ONCE_RUN(x,f)
 402 #else
 403 /*
 404  * Use pthread mutexes everywhere else.
 405  */
 406 #include <pthread.h>
 407 #define _PROP_MUTEX_DECL_STATIC(x)      static pthread_mutex_t x;
 408 #define _PROP_MUTEX_INIT(x)             pthread_mutex_init(&(x), NULL)
 409 #define _PROP_MUTEX_LOCK(x)             pthread_mutex_lock(&(x))
 410 #define _PROP_MUTEX_UNLOCK(x)           pthread_mutex_unlock(&(x))
 411
 412 #define _PROP_RWLOCK_DECL(x)            pthread_rwlock_t x ;
 413 #define _PROP_RWLOCK_INIT(x)            pthread_rwlock_init(&(x), NULL)
 414 #define _PROP_RWLOCK_RDLOCK(x)          pthread_rwlock_rdlock(&(x))
 415 #define _PROP_RWLOCK_WRLOCK(x)          pthread_rwlock_wrlock(&(x))
 416 #define _PROP_RWLOCK_UNLOCK(x)          pthread_rwlock_unlock(&(x))
 417 #define _PROP_RWLOCK_DESTROY(x)         pthread_rwlock_destroy(&(x))
 418
 419 #define _PROP_ONCE_DECL(x)                                              \
 420         static pthread_once_t x = PTHREAD_ONCE_INIT;
 421 #define _PROP_ONCE_RUN(x,f)             pthread_once(&(x),(void(*)(void))f)
 422 #endif
 423
 424 #endif /* _KERNEL */
 425
 426 /*
 427  * Language features.
 428  */
 429 #if defined(__NetBSD__)
 430 #include <sys/cdefs.h>
 431 #define _PROP_ARG_UNUSED                __unused
 432 #else
 433 #define _PROP_ARG_UNUSED                /* delete */
 434 #endif /* __NetBSD__ */
 435
 436 #endif /* _PROPLIB_PROP_OBJECT_IMPL_H_ */