diff options
Diffstat (limited to 'dom/media/webrtc/transport/third_party/nrappkit/src/registry/registry.c')
| -rw-r--r-- | dom/media/webrtc/transport/third_party/nrappkit/src/registry/registry.c | 604 |
1 files changed, 604 insertions, 0 deletions
diff --git a/dom/media/webrtc/transport/third_party/nrappkit/src/registry/registry.c b/dom/media/webrtc/transport/third_party/nrappkit/src/registry/registry.c new file mode 100644 index 0000000000..709b1c3fb7 --- /dev/null +++ b/dom/media/webrtc/transport/third_party/nrappkit/src/registry/registry.c @@ -0,0 +1,604 @@ +/* + * + * registry.c + * + * $Source: /Users/ekr/tmp/nrappkit-dump/nrappkit/src/registry/registry.c,v $ + * $Revision: 1.6 $ + * $Date: 2007/11/21 00:09:12 $ + * + * Datastore for tracking configuration and related info. + * + * + * Copyright (C) 2005, Network Resonance, Inc. + * Copyright (C) 2006, Network Resonance, Inc. + * All Rights Reserved + * + * 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. + * 3. Neither the name of Network Resonance, Inc. nor the name of any + * contributors to this software may be used to endorse or promote + * products derived from this software without specific prior written + * permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT OWNER 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 <assert.h> +#include <string.h> +#ifndef _MSC_VER +#include <strings.h> +#include <sys/param.h> +#include <netinet/in.h> +#endif +#ifdef OPENSSL +#include <openssl/ssl.h> +#endif +#include <ctype.h> +#include "registry.h" +#include "registry_int.h" +#include "registry_vtbl.h" +#include "r_assoc.h" +#include "nr_common.h" +#include "r_log.h" +#include "r_errors.h" +#include "r_macros.h" +#include "c2ru.h" + +/* vtbl used to switch hit between local and remote invocations */ +static nr_registry_module *reg_vtbl = 0; + +/* must be in the order the types are numbered */ +static char *typenames[] = { "char", "UCHAR", "INT2", "UINT2", "INT4", "UINT4", "INT8", "UINT8", "double", "Data", "string", "registry" }; + +int NR_LOG_REGISTRY=0; + +NR_registry NR_TOP_LEVEL_REGISTRY = ""; + +int +NR_reg_init(void *mode) +{ + int r, _status; + nr_registry_module *module = (nr_registry_module*)mode; +#ifdef SANITY_CHECKS + NR_registry registry; +#endif + + if (reg_vtbl) { + if (reg_vtbl != module) { + r_log(LOG_GENERIC,LOG_ERR,"Can't reinitialize registry in different mode"); + ABORT(R_INTERNAL); + } + + return(0); + } + + reg_vtbl = module; + + if ((r=reg_vtbl->vtbl->init(mode))) + ABORT(r); + +#ifdef SANITY_CHECKS + if ((r=NR_reg_get_registry(NR_TOP_LEVEL_REGISTRY, registry))) + ABORT(r); + assert(strcmp(registry, NR_TOP_LEVEL_REGISTRY) == 0); +#endif + + r_log_init(); + r_log_register("registry",&NR_LOG_REGISTRY); + + _status=0; + abort: + r_log(NR_LOG_REGISTRY, + (_status ? LOG_ERR : LOG_INFO), + (_status ? "Couldn't initialize registry" : "Initialized registry")); + return(_status); +} + +int +NR_reg_initted(void) +{ + return reg_vtbl!=0; +} + +#define NRREGGET(func, method, type) \ +int \ +func(NR_registry name, type *out) \ +{ \ + return reg_vtbl->vtbl->method(name, out); \ +} + +NRREGGET(NR_reg_get_char, get_char, char) +NRREGGET(NR_reg_get_uchar, get_uchar, UCHAR) +NRREGGET(NR_reg_get_int2, get_int2, INT2) +NRREGGET(NR_reg_get_uint2, get_uint2, UINT2) +NRREGGET(NR_reg_get_int4, get_int4, INT4) +NRREGGET(NR_reg_get_uint4, get_uint4, UINT4) +NRREGGET(NR_reg_get_int8, get_int8, INT8) +NRREGGET(NR_reg_get_uint8, get_uint8, UINT8) +NRREGGET(NR_reg_get_double, get_double, double) + +int +NR_reg_get_registry(NR_registry name, NR_registry out) +{ + return reg_vtbl->vtbl->get_registry(name, out); +} + +int +NR_reg_get_bytes(NR_registry name, UCHAR *out, size_t size, size_t *length) +{ + return reg_vtbl->vtbl->get_bytes(name, out, size, length); +} + +int +NR_reg_get_string(NR_registry name, char *out, size_t size) +{ + return reg_vtbl->vtbl->get_string(name, out, size); +} + +int +NR_reg_get_length(NR_registry name, size_t *length) +{ + return reg_vtbl->vtbl->get_length(name, length); +} + +int +NR_reg_get_type(NR_registry name, NR_registry_type type) +{ + return reg_vtbl->vtbl->get_type(name, type); +} + +#define NRREGSET(func, method, type) \ +int \ +func(NR_registry name, type data) \ +{ \ + return reg_vtbl->vtbl->method(name, data); \ +} + +NRREGSET(NR_reg_set_char, set_char, char) +NRREGSET(NR_reg_set_uchar, set_uchar, UCHAR) +NRREGSET(NR_reg_set_int2, set_int2, INT2) +NRREGSET(NR_reg_set_uint2, set_uint2, UINT2) +NRREGSET(NR_reg_set_int4, set_int4, INT4) +NRREGSET(NR_reg_set_uint4, set_uint4, UINT4) +NRREGSET(NR_reg_set_int8, set_int8, INT8) +NRREGSET(NR_reg_set_uint8, set_uint8, UINT8) +NRREGSET(NR_reg_set_double, set_double, double) +NRREGSET(NR_reg_set_string, set_string, char*) + +int +NR_reg_set_registry(NR_registry name) +{ + return reg_vtbl->vtbl->set_registry(name); +} + +int +NR_reg_set_bytes(NR_registry name, unsigned char *data, size_t length) +{ + return reg_vtbl->vtbl->set_bytes(name, data, length); +} + + +int +NR_reg_del(NR_registry name) +{ + return reg_vtbl->vtbl->del(name); +} + +int +NR_reg_fin(NR_registry name) +{ + return reg_vtbl->vtbl->fin(name); +} + +int +NR_reg_get_child_count(NR_registry parent, unsigned int *count) +{ + assert(sizeof(count) == sizeof(size_t)); + return reg_vtbl->vtbl->get_child_count(parent, (size_t*)count); +} + +int +NR_reg_get_child_registry(NR_registry parent, unsigned int i, NR_registry child) +{ + int r, _status; + size_t count; + NR_registry *children=0; + + if ((r=reg_vtbl->vtbl->get_child_count(parent, &count))) + ABORT(r); + + if (i >= count) + ABORT(R_NOT_FOUND); + else { + count++; + children = (NR_registry *)RCALLOC(count * sizeof(NR_registry)); + if (!children) + ABORT(R_NO_MEMORY); + + if ((r=reg_vtbl->vtbl->get_children(parent, children, count, &count))) + ABORT(r); + + if (i >= count) + ABORT(R_NOT_FOUND); + + strncpy(child, children[i], sizeof(NR_registry)); + } + + _status=0; + abort: + RFREE(children); + return(_status); +} + +int +NR_reg_get_children(NR_registry parent, NR_registry *children, size_t size, size_t *length) +{ + return reg_vtbl->vtbl->get_children(parent, children, size, length); +} + +int +NR_reg_dump() +{ + int r, _status; + + if ((r=reg_vtbl->vtbl->dump(0))) + ABORT(r); + + _status=0; + abort: + return(_status); +} + +// convenience methods, call RFREE on the returned data +int +NR_reg_alloc_data(NR_registry name, Data *data) +{ + int r, _status; + size_t length; + UCHAR *tmp = 0; + size_t sanity_check; + + if ((r=NR_reg_get_length(name, &length))) + ABORT(r); + + if (!(tmp = (void*)RMALLOC(length))) + ABORT(R_NO_MEMORY); + + if ((r=NR_reg_get_bytes(name, tmp, length, &sanity_check))) + ABORT(r); + + assert(length == sanity_check); + + data->len = length; + data->data = tmp; + + _status=0; + abort: + if (_status) { + if (tmp) RFREE(tmp); + } + return(_status); +} + +int +NR_reg_alloc_string(NR_registry name, char **data) +{ + int r, _status; + size_t length; + char *tmp = 0; + + if ((r=NR_reg_get_length(name, &length))) + ABORT(r); + + if (!(tmp = (void*)RMALLOC(length+1))) + ABORT(R_NO_MEMORY); + + if ((r=NR_reg_get_string(name, tmp, length+1))) + ABORT(r); + + assert(length == strlen(tmp)); + + *data = tmp; + + _status=0; + abort: + if (_status) { + if (tmp) RFREE(tmp); + } + return(_status); +} + + +char * +nr_reg_type_name(int type) +{ + if ((type < NR_REG_TYPE_CHAR) || (type > NR_REG_TYPE_REGISTRY)) + return(NULL); + + return(typenames[type]); +} + +int +nr_reg_compute_type(char *typename, int *type) +{ + int _status; + size_t i; + +#ifdef SANITY_CHECKS + assert(!strcasecmp(typenames[NR_REG_TYPE_CHAR], "char")); + assert(!strcasecmp(typenames[NR_REG_TYPE_UCHAR], "UCHAR")); + assert(!strcasecmp(typenames[NR_REG_TYPE_INT2], "INT2")); + assert(!strcasecmp(typenames[NR_REG_TYPE_UINT2], "UINT2")); + assert(!strcasecmp(typenames[NR_REG_TYPE_INT4], "INT4")); + assert(!strcasecmp(typenames[NR_REG_TYPE_UINT4], "UINT4")); + assert(!strcasecmp(typenames[NR_REG_TYPE_INT8], "INT8")); + assert(!strcasecmp(typenames[NR_REG_TYPE_UINT8], "UINT8")); + assert(!strcasecmp(typenames[NR_REG_TYPE_DOUBLE], "double")); + assert(!strcasecmp(typenames[NR_REG_TYPE_BYTES], "Data")); + assert(!strcasecmp(typenames[NR_REG_TYPE_STRING], "string")); + assert(!strcasecmp(typenames[NR_REG_TYPE_REGISTRY], "registry")); + assert(sizeof(typenames)/sizeof(*typenames) == (NR_REG_TYPE_REGISTRY+1)); +#endif + + for (i = 0; i < sizeof(typenames)/sizeof(*typenames); ++i) { + if (!strcasecmp(typenames[i], typename)) { + *type = i; + return 0; + } + } + ABORT(R_BAD_ARGS); + + _status=0; + abort: + return(_status); +} + +/* More convenience functions: the same as their parents but they + take a prefix and a suffix */ +#define NRGET2(func, type, get) \ +int \ +func(NR_registry parent, char *child, type *out) \ +{ \ + int r, _status; \ + NR_registry registry; \ + \ + if ((r = NR_reg_make_registry(parent, child, registry))) \ + ABORT(r); \ + \ + if ((r = get(registry, out))) { \ + ABORT(r); \ + } \ + \ + _status = 0; \ +abort: \ + return (_status); \ +} + +NRGET2(NR_reg_get2_char, char, NR_reg_get_char) +NRGET2(NR_reg_get2_uchar, UCHAR, NR_reg_get_uchar) +NRGET2(NR_reg_get2_int2, INT2, NR_reg_get_int2) +NRGET2(NR_reg_get2_uint2, UINT2, NR_reg_get_uint2) +NRGET2(NR_reg_get2_int4, INT4, NR_reg_get_int4) +NRGET2(NR_reg_get2_uint4, UINT4, NR_reg_get_uint4) +NRGET2(NR_reg_get2_int8, INT8, NR_reg_get_int8) +NRGET2(NR_reg_get2_uint8, UINT8, NR_reg_get_uint8) +NRGET2(NR_reg_get2_double, double, NR_reg_get_double) +NRGET2(NR_reg_alloc2_string, char*, NR_reg_alloc_string) +NRGET2(NR_reg_alloc2_data, Data, NR_reg_alloc_data) + +int +NR_reg_get2_bytes(NR_registry parent, char *child, UCHAR *out, size_t size, size_t *length) +{ + int r, _status; + NR_registry registry; + + if ((r=NR_reg_make_registry(parent, child, registry))) + ABORT(r); + + if ((r=NR_reg_get_bytes(registry, out, size, length))) + ABORT(r); + + _status = 0; +abort: + return (_status); +} + +int +NR_reg_get2_string(NR_registry parent, char *child, char *out, size_t size) +{ + int r, _status; + NR_registry registry; + + if ((r=NR_reg_make_registry(parent, child, registry))) + ABORT(r); + + if ((r=NR_reg_get_string(registry, out, size))) + ABORT(r); + + _status = 0; +abort: + return (_status); +} + +/* More convenience functions: the same as their parents but they + take a prefix and a suffix */ +#define NRSET2(func, type, set) \ +int \ +func(NR_registry parent, char *child, type in) \ +{ \ + int r, _status; \ + NR_registry registry; \ + \ + if ((r = NR_reg_make_registry(parent, child, registry))) \ + ABORT(r); \ + \ + if ((r = set(registry, in))) { \ + ABORT(r); \ + } \ + \ + _status = 0; \ +abort: \ + return (_status); \ +} + +NRSET2(NR_reg_set2_char, char, NR_reg_set_char) +NRSET2(NR_reg_set2_uchar, UCHAR, NR_reg_set_uchar) +NRSET2(NR_reg_set2_int2, INT2, NR_reg_set_int2) +NRSET2(NR_reg_set2_uint2, UINT2, NR_reg_set_uint2) +NRSET2(NR_reg_set2_int4, INT4, NR_reg_set_int4) +NRSET2(NR_reg_set2_uint4, UINT4, NR_reg_set_uint4) +NRSET2(NR_reg_set2_int8, INT8, NR_reg_set_int8) +NRSET2(NR_reg_set2_uint8, UINT8, NR_reg_set_uint8) +NRSET2(NR_reg_set2_double, double, NR_reg_set_double) +NRSET2(NR_reg_set2_string, char*, NR_reg_set_string) + +int +NR_reg_set2_bytes(NR_registry prefix, char *name, UCHAR *data, size_t length) +{ + int r, _status; + NR_registry registry; + + if ((r = NR_reg_make_registry(prefix, name, registry))) + ABORT(r); + + if ((r = NR_reg_set_bytes(registry, data, length))) + ABORT(r); + + _status = 0; +abort: + return (_status); +} + + +int +NR_reg_make_child_registry(NR_registry parent, NR_registry descendant, unsigned int generation, NR_registry child) +{ + int _status; + size_t length; + + length = strlen(parent); + + if (strncasecmp(parent, descendant, length)) + ABORT(R_BAD_ARGS); + + while (descendant[length] != '\0') { + if (descendant[length] == '.') { + if (generation == 0) + break; + + --generation; + } + + ++length; + if (length >= sizeof(NR_registry)) + ABORT(R_BAD_ARGS); + } + + strncpy(child, descendant, length); + child[length] = '\0'; + + _status=0; + abort: + return(_status); +} + +int +NR_reg_get2_child_count(NR_registry base, NR_registry name, unsigned int *count) + { + int r, _status; + NR_registry registry; + + if ((r=nr_c2ru_make_registry(base, name, registry))) + ABORT(r); + + if (r=NR_reg_get_child_count(registry,count)) + ABORT(r); + + _status=0; + abort: + return(_status); + } + +int +NR_reg_get2_child_registry(NR_registry base, NR_registry name, unsigned int i, NR_registry child) + { + int r, _status; + NR_registry registry; + + if ((r=nr_c2ru_make_registry(base, name, registry))) + ABORT(r); + + if (r=NR_reg_get_child_registry(registry, i, child)) + ABORT(r); + + _status=0; + abort: + return(_status); + } + + +/* requires parent already in legal form */ +int +NR_reg_make_registry(NR_registry parent, char *child, NR_registry out) +{ + int r, _status; + size_t plen; + size_t clen; + char *c; + size_t i; + + if ((r=nr_reg_is_valid(parent))) + ABORT(r); + + if (*child == '.') + ABORT(R_BAD_ARGS); + + clen = strlen(child); + if (!clen) + ABORT(R_BAD_ARGS); + plen = strlen(parent); + if ((plen + clen + 2) > sizeof(NR_registry)) + ABORT(R_BAD_ARGS); + + if (out != parent) + strcpy(out, parent); + + c = &(out[plen]); + + if (parent[0] != '\0') { + *c = '.'; + ++c; + } + + for (i = 0; i < clen; ++i, ++c) { + *c = child[i]; + if (isspace(*c) || *c == '.' || *c == '/' || ! isprint(*c)) + *c = '_'; + } + + *c = '\0'; + + _status = 0; +abort: + return _status; +} + |