ossp-pkg/xds/xds.c
/*
** OSSP xds - Extensible Data Serialization
** Copyright (c) 2001-2005 Ralf S. Engelschall <rse@engelschall.com>
** Copyright (c) 2001-2005 The OSSP Project <http://www.ossp.org/>
** Copyright (c) 2001-2005 Cable & Wireless <http://www.cw.com/>
**
** This file is part of OSSP xds, an extensible data serialization
** library which can be found at http://www.ossp.org/pkg/lib/xds/.
**
** Permission to use, copy, modify, and distribute this software for
** any purpose with or without fee is hereby granted, provided that
** the above copyright notice and this permission notice appear in all
** copies.
**
** THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED 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 AUTHORS AND COPYRIGHT HOLDERS AND THEIR
** 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.
**
** xds.c: XDS library framework
*/
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include "xds_p.h"
int xds_init(xds_t **xds, xds_mode_t mode)
{
xds_t *ctx;
/* Sanity check parameter. */
assert(xds != NULL);
if (xds == NULL)
return XDS_ERR_INVALID_ARG;
assert(mode == XDS_ENCODE || mode == XDS_DECODE);
if (mode != XDS_ENCODE && mode != XDS_DECODE)
return XDS_ERR_INVALID_ARG;
/* Allocate context structure. */
if ((ctx = malloc(sizeof (struct xds_context))) == NULL)
return XDS_ERR_SYSTEM; /* errno set by malloc(3) */
/* Set mode of operation in context. */
ctx->mode = mode;
/* Initialize buffer handling. */
ctx->buffer = NULL;
ctx->buffer_len = 0;
ctx->buffer_capacity = 0;
ctx->we_own_buffer = XDS_FALSE;
/* Initialize engines map. */
ctx->engines = NULL;
ctx->engines_len = 0;
ctx->engines_capacity = 0;
*xds = ctx;
return XDS_OK;
}
int xds_destroy(xds_t *xds)
{
size_t i;
/* Sanity check parameter. */
assert(xds != NULL);
if (xds == NULL)
return XDS_ERR_INVALID_ARG;
/* Free allocated memory. */
assert(xds->buffer != NULL
|| (xds->buffer_capacity == 0 && xds->buffer_len == 0));
if (xds->buffer != NULL && xds->we_own_buffer)
free(xds->buffer);
assert(xds->engines != NULL || xds->engines_capacity == 0);
if (xds->engines != NULL) {
for (i = 0; i < xds->engines_len; i++) {
assert(xds->engines[i].name != NULL);
free(xds->engines[i].name);
}
free(xds->engines);
}
free(xds);
return XDS_OK;
}
int xds_setbuffer(xds_t *xds, xds_scope_t flag, void *buffer,
size_t buffer_len)
{
/* Sanity check parameters. */
xds_check_parameter(xds != NULL);
xds_check_parameter(flag == XDS_GIFT || flag == XDS_LOAN);
xds_check_parameter((buffer != NULL && buffer_len != 0)
|| flag == XDS_GIFT);
/* Free the old buffer if there is one. */
if (xds->buffer != NULL && xds->we_own_buffer)
free(xds->buffer);
xds->buffer_len = 0;
if (flag == XDS_GIFT) {
xds->buffer = buffer;
if (buffer == NULL)
xds->buffer_capacity = 0;
else
xds->buffer_capacity = buffer_len;
xds->we_own_buffer = XDS_TRUE;
}
else {
xds->buffer = buffer;
xds->buffer_capacity = buffer_len;
xds->we_own_buffer = XDS_FALSE;
}
return XDS_OK;
}
int xds_getbuffer(xds_t *xds, xds_scope_t flag, void **buffer,
size_t *buffer_len)
{
/* Sanity check parameters. */
xds_check_parameter(xds != NULL);
xds_check_parameter(flag == XDS_GIFT || flag == XDS_LOAN);
xds_check_parameter(buffer != NULL);
xds_check_parameter(buffer_len != NULL);
/* Return the buffer to the caller. */
*buffer = xds->buffer;
*buffer_len = xds->buffer_len;
if (flag == XDS_GIFT) {
xds->buffer = NULL;
xds->buffer_capacity = 0;
xds->buffer_len = 0;
}
else
xds->buffer_len = 0;
return XDS_OK;
}
static int xds_set_capacity(void **array, size_t *array_capacity,
size_t new_capacity, size_t elem_size,
size_t initial_capacity)
{
void *buf;
size_t size;
/* Sanity checks. */
xds_check_parameter(array != NULL);
xds_check_parameter(array_capacity != NULL);
xds_check_parameter(elem_size != 0);
xds_check_parameter(initial_capacity != 0);
/* Do we need to re-allocate? */
if (*array_capacity > new_capacity)
return XDS_OK;
/* Find the correct capacity. */
size = (*array_capacity != 0) ? (*array_capacity * 2) : initial_capacity;
while (size < new_capacity)
size *= 2;
/* Allocate the array and store the new values. */
if ((buf = realloc(*array, size * elem_size)) == NULL)
return XDS_ERR_NO_MEM;
*array = buf;
*array_capacity = size;
return XDS_OK;
}
static int xds_find_engine(const engine_map_t *engines, size_t last,
const char *name, size_t *pos)
{
size_t first;
/* Sanity checks. */
xds_check_parameter(engines != NULL || last == 0);
xds_check_parameter(name != NULL);
xds_check_parameter(pos != NULL);
/* Use binary search to find "name" in "engines". */
for (first = 0; (last - first) > 0; ) {
size_t half = first + ((last - first) / 2);
int rc = strcmp(engines[half].name, name);
if (rc < 0)
first = half + 1;
else if (rc == 0) { /* found it */
*pos = half;
return XDS_TRUE;
}
else
last = half;
assert(first <= last);
}
*pos = first;
return XDS_FALSE;
}
int xds_register(xds_t *xds, const char *name, xds_engine_t engine,
void *engine_context)
{
size_t pos;
/* Sanity checks. */
xds_check_parameter(xds != NULL);
xds_check_parameter(name != NULL);
xds_check_parameter(engine != NULL);
for (pos = 0; name[pos] != '\0'; ++pos) {
if (!isalnum((int)name[pos]) && name[pos] != '-' && name[pos] != '_')
return XDS_ERR_INVALID_ARG;
}
/* Copy the name argument into our own memory. */
name = strdup(name);
if (name == NULL)
return XDS_ERR_NO_MEM;
/* Search engines for the entry. */
if (xds_find_engine(xds->engines, xds->engines_len, name, &pos)) {
/* overwrite existing entry */
free(xds->engines[pos].name);
}
else {
/* insert new entry */
int rc = xds_set_capacity((void **)&xds->engines,
&xds->engines_capacity,
xds->engines_len + 1,
sizeof (engine_map_t),
XDS_INITIAL_ENGINES_CAPACITY);
assert(rc == XDS_OK || rc == XDS_ERR_NO_MEM);
if (rc != XDS_OK)
return rc;
memmove(&xds->engines[pos + 1], &xds->engines[pos],
(xds->engines_len - pos) * sizeof (engine_map_t));
xds->engines_len++;
}
/* Insert entry. */
xds->engines[pos].name = (char *)name;
xds->engines[pos].engine = engine;
xds->engines[pos].context = engine_context;
/* Everything is fine. */
return XDS_OK;
}
int xds_unregister(xds_t *xds, const char *name)
{
size_t pos;
int rc;
/* Sanity checks. */
xds_check_parameter(xds != NULL);
xds_check_parameter(name != NULL);
for (pos = 0; name[pos] != '\0'; pos++) {
if (!isalnum((int)name[pos]) && name[pos] != '-' && name[pos] != '_')
return XDS_ERR_INVALID_ARG;
}
/* Find the entry we're supposed to delete. */
if (!xds_find_engine(xds->engines, xds->engines_len, name, &pos))
return XDS_ERR_UNKNOWN_ENGINE;
/* Free the memory allocated for this entry and move the entries behind
it back if necessary. */
assert(xds->engines[pos].name != NULL);
free(xds->engines[pos].name);
memmove(&xds->engines[pos], &xds->engines[pos + 1],
(xds->engines_len - (pos + 1)) * sizeof (engine_map_t));
xds->engines_len--;
/* Lower capacity if necessary. */
rc = xds_set_capacity((void **)&xds->engines, &xds->engines_capacity,
xds->engines_len, sizeof (engine_map_t),
XDS_INITIAL_ENGINES_CAPACITY);
assert(rc == XDS_OK || rc == XDS_ERR_NO_MEM);
if (rc != XDS_OK)
return rc;
return XDS_OK;
}
int xds_encode(xds_t *xds, const char *fmt, ...)
{
int rc;
va_list args;
/* Sanity checks. */
xds_check_parameter(xds != NULL);
xds_check_parameter(fmt != NULL);
va_start(args, fmt);
rc = xds_vencode(xds, fmt, args);
va_end(args);
return rc;
}
int xds_vencode(xds_t *xds, const char *fmt_arg, va_list args)
{
va_list args_backup;
size_t buffer_len_backup;
char *name;
char *p;
char *fmt;
int rc;
/* Sanity checks. */
xds_check_parameter(xds != NULL);
xds_check_parameter(fmt_arg != NULL);
assert(xds->mode == XDS_ENCODE);
if (xds->mode != XDS_ENCODE)
return XDS_ERR_INVALID_MODE;
/* Ensure we have a buffer allocated ready for use. */
if (xds->buffer == NULL) {
/* allocate a new buffer */
rc = xds_set_capacity((void **)&xds->buffer, &xds->buffer_capacity,
XDS_INITIAL_BUFFER_CAPACITY, sizeof (char),
XDS_INITIAL_BUFFER_CAPACITY);
assert(rc == XDS_OK || rc == XDS_ERR_NO_MEM);
if (rc != XDS_OK)
return rc;
xds->buffer_len = 0;
xds->we_own_buffer = XDS_TRUE;
}
/* Iterate through items in format string and execute apropriate engines. */
fmt = p = strdup(fmt_arg);
if (fmt == NULL)
return XDS_ERR_NO_MEM;
buffer_len_backup = xds->buffer_len;
for (name = p; *p != '\0'; name = p) {
while (isalnum((int)*p) || *p == '-' || *p == '_')
p++;
if (*p != '\0')
*p++ = '\0';
else
*p = '\0';
if (strlen(name) > 0) {
int restart_engine;
size_t used_buffer_size;
size_t pos;
if (xds_find_engine(xds->engines, xds->engines_len, name, &pos)
== XDS_FALSE) {
rc = XDS_ERR_UNKNOWN_ENGINE;
goto leave;
}
do {
/* Ensure the buffer has free space. */
assert(xds->buffer_len <= xds->buffer_capacity);
if (xds->buffer_len == xds->buffer_capacity) {
if (xds->we_own_buffer) {
rc = xds_set_capacity((void **)&xds->buffer,
&xds->buffer_capacity,
xds->buffer_len + 1, sizeof (char),
XDS_INITIAL_BUFFER_CAPACITY);
assert(rc == XDS_OK || rc == XDS_ERR_NO_MEM);
if (rc != XDS_OK)
goto leave;
}
else {
rc = XDS_ERR_OVERFLOW;
goto leave;
}
}
/* Execute the engine. */
used_buffer_size = 0;
args_backup = args;
rc = (*xds->engines[pos].engine)(
xds, xds->engines[pos].context,
xds->buffer + xds->buffer_len,
xds->buffer_capacity - xds->buffer_len,
&used_buffer_size, &args);
assert(rc <= 0);
if (rc == XDS_OK) {
restart_engine = XDS_FALSE;
xds->buffer_len += used_buffer_size;
}
else if (rc == XDS_ERR_OVERFLOW) { /* enlarge buffer */
if (!xds->we_own_buffer)
goto leave;
restart_engine = XDS_TRUE;
args = args_backup;
rc = xds_set_capacity(
(void **)&xds->buffer, &xds->buffer_capacity,
xds->buffer_capacity +
((used_buffer_size == 0) ? 1 : used_buffer_size),
sizeof (char), XDS_INITIAL_BUFFER_CAPACITY);
assert(rc == XDS_OK || rc == XDS_ERR_NO_MEM);
if (rc != XDS_OK)
goto leave;
}
else
goto leave;
}
while (restart_engine);
}
}
rc = XDS_OK;
/* Clean up and leave. */
leave:
free(fmt);
if (rc != XDS_OK)
xds->buffer_len = buffer_len_backup;
return rc;
}
int xds_decode(xds_t *xds, const char *fmt, ...)
{
int rc;
va_list args;
/* Sanity checks. */
xds_check_parameter(xds != NULL);
xds_check_parameter(fmt != NULL);
va_start(args, fmt);
rc = xds_vdecode(xds, fmt, args);
va_end(args);
return rc;
}
int xds_vdecode(xds_t *xds, const char *fmt_arg, va_list args)
{
size_t buffer_len_backup;
char *name;
char *p;
char *fmt;
int rc;
/* Sanity checks. */
xds_check_parameter(xds != NULL);
xds_check_parameter(fmt_arg != NULL);
assert(xds->mode == XDS_DECODE);
if (xds->mode != XDS_DECODE)
return XDS_ERR_INVALID_MODE;
/* Ensure we have a buffer to decode. */
if (xds->buffer == NULL || xds->buffer_capacity == 0)
return XDS_ERR_UNDERFLOW;
/* Iterate through the items in the format string and execute the
apropriate engines. */
fmt = p = strdup(fmt_arg);
if (fmt == NULL)
return XDS_ERR_NO_MEM;
buffer_len_backup = xds->buffer_len;
for (name = p; *p != '\0'; name = p) {
while (isalnum((int)*p) || *p == '-' || *p == '_')
p++;
if (*p != '\0')
*p++ = '\0';
else
*p = '\0';
if (strlen(name) > 0) {
size_t pos;
size_t used_buffer_size = 0;
if (xds_find_engine(xds->engines, xds->engines_len, name, &pos)) {
rc = (*xds->engines[pos].engine)(
xds, xds->engines[pos].context,
xds->buffer + xds->buffer_len,
xds->buffer_capacity - xds->buffer_len,
&used_buffer_size, &args);
assert(rc <= 0);
if (rc == XDS_OK)
xds->buffer_len += used_buffer_size;
else
goto leave;
}
else {
rc = XDS_ERR_UNKNOWN_ENGINE;
goto leave;
}
}
}
rc = XDS_OK;
/* Clean up and leave. */
leave:
free(fmt);
if (rc != XDS_OK)
xds->buffer_len = buffer_len_backup;
return rc;
}
