head	1.17;
access;
symbols
	XDS_0_9_3:1.17
	XDS_0_9_2:1.17
	XDS_0_9_1:1.15
	XDS_0_9_0:1.13;
locks; strict;
comment	@ * @;


1.17
date	2005.06.02.18.51.44;	author rse;	state Exp;
branches;
next	1.16;

1.16
date	2005.06.02.18.43.06;	author rse;	state Exp;
branches;
next	1.15;

1.15
date	2004.09.12.17.32.14;	author rse;	state Exp;
branches;
next	1.14;

1.14
date	2004.09.12.17.20.36;	author rse;	state Exp;
branches;
next	1.13;

1.13
date	2003.02.17.12.36.02;	author rse;	state Exp;
branches;
next	1.12;

1.12
date	2002.03.17.10.25.53;	author rse;	state Exp;
branches;
next	1.11;

1.11
date	2002.01.02.17.13.44;	author rse;	state Exp;
branches;
next	1.10;

1.10
date	2001.08.30.11.15.54;	author simons;	state Exp;
branches;
next	1.9;

1.9
date	2001.08.30.10.42.09;	author simons;	state Exp;
branches;
next	1.8;

1.8
date	2001.08.23.08.42.50;	author simons;	state Exp;
branches;
next	1.7;

1.7
date	2001.08.22.20.23.48;	author simons;	state Exp;
branches;
next	1.6;

1.6
date	2001.08.13.19.48.02;	author rse;	state Exp;
branches;
next	1.5;

1.5
date	2001.08.12.11.31.45;	author rse;	state Exp;
branches;
next	1.4;

1.4
date	2001.08.09.21.05.18;	author rse;	state Exp;
branches;
next	1.3;

1.3
date	2001.08.09.20.59.05;	author rse;	state Exp;
branches;
next	1.2;

1.2
date	2001.08.09.19.58.35;	author rse;	state Exp;
branches;
next	1.1;

1.1
date	2001.08.08.19.15.23;	author rse;	state Exp;
branches;
next	;


desc
@@


1.17
log
@Bumped year in copyright messages for year 2005.
@
text
@/*
**  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_engine_xdr.c: XDR encoding/decoding engine
*/

#include <string.h>

#include "xds.h"

/*
 * Encode/decode signed 32-bit integer values.
 */

int xdr_encode_int32(xds_t *xds, void *engine_context,
                     void *buffer, size_t buffer_size,
                     size_t *used_buffer_size, va_list *args)
{
    xds_uint32_t tmp;
    xds_int32_t value;

    xds_init_encoding_engine(4);

    /* Get value and format it into the buffer. */
    value = va_arg(*args, xds_uint32_t);
    if (value < 0) {
        value = 0 - value;
        tmp = 0 - (xds_uint32_t) value;
    }
    else
        tmp = (xds_uint32_t) value;
    ((xds_uint8_t *)buffer)[0] = (tmp >> 24) & 0x000000ff;
    ((xds_uint8_t *)buffer)[1] = (tmp >> 16) & 0x000000ff;
    ((xds_uint8_t *)buffer)[2] = (tmp >>  8) & 0x000000ff;
    ((xds_uint8_t *)buffer)[3] = (tmp >>  0) & 0x000000ff;

    return XDS_OK;
}

int xdr_decode_int32(xds_t *xds, void *engine_context,
                     void *buffer, size_t buffer_size,
                     size_t *used_buffer_size, va_list *args)
{
    xds_int32_t *value;
    xds_uint32_t tmp;

    xds_init_decoding_engine(4);

    /* Get value and format it into the buffer. */
    value = va_arg(*args, xds_int32_t *);
    xds_check_parameter(value != NULL);

    if (((xds_uint8_t *) buffer)[0] & 0x80) {
        /* negative number */
        tmp =  ((xds_uint8_t *)buffer)[0];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[1];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[2];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[3];
        tmp = 0 - tmp;
        *value = 0 - (int32_t)tmp;
    }
    else {
        /* positive number */
        *value =  ((xds_uint8_t *)buffer)[0];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[1];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[2];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[3];
    }

    return XDS_OK;
}

/*
 * Encode/decode unsigned 32-bit integer values.
 */

int xdr_encode_uint32(xds_t *xds, void *engine_context,
                      void *buffer, size_t buffer_size,
                      size_t *used_buffer_size, va_list *args)
{
    xds_uint32_t value;

    xds_init_encoding_engine(4);

    /* Get value and format it into the buffer. */
    value = va_arg(*args, xds_uint32_t);
    ((xds_uint8_t *)buffer)[0] = (value >> 24) & 0x000000ff;
    ((xds_uint8_t *)buffer)[1] = (value >> 16) & 0x000000ff;
    ((xds_uint8_t *)buffer)[2] = (value >>  8) & 0x000000ff;
    ((xds_uint8_t *)buffer)[3] = (value >>  0) & 0x000000ff;

    return XDS_OK;
}

int xdr_decode_uint32(xds_t *xds, void *engine_context,
                      void *buffer, size_t buffer_size,
                      size_t *used_buffer_size, va_list *args)
{
    xds_uint32_t *value;

    xds_init_decoding_engine(4);

    /* Get value and format it into the buffer. */
    value = va_arg(*args, xds_uint32_t *);
    xds_check_parameter(value != NULL);

    *value =  ((xds_uint8_t *)buffer)[0];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[1];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[2];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[3];

    return XDS_OK;
}

#ifdef XDS_HAVE_64_BIT_SUPPORT

/*
 * Encode/decode signed 64-bit integer values.
 */

int xdr_encode_int64(xds_t *xds, void *engine_context,
                     void *buffer, size_t buffer_size,
                     size_t *used_buffer_size, va_list *args)
{
    xds_uint64_t tmp;
    xds_int64_t value;

    xds_init_encoding_engine(8);

    /* Get value and format it into the buffer. */
    value = va_arg(*args, xds_uint64_t);
    if (value < 0) {
        value = 0 - value;
        tmp = 0 - (xds_uint64_t)value;
    }
    else
        tmp = (xds_uint64_t)value;
    ((xds_uint8_t *)buffer)[0] = (tmp >> 56) & 0x000000ff;
    ((xds_uint8_t *)buffer)[1] = (tmp >> 48) & 0x000000ff;
    ((xds_uint8_t *)buffer)[2] = (tmp >> 40) & 0x000000ff;
    ((xds_uint8_t *)buffer)[3] = (tmp >> 32) & 0x000000ff;
    ((xds_uint8_t *)buffer)[4] = (tmp >> 24) & 0x000000ff;
    ((xds_uint8_t *)buffer)[5] = (tmp >> 16) & 0x000000ff;
    ((xds_uint8_t *)buffer)[6] = (tmp >>  8) & 0x000000ff;
    ((xds_uint8_t *)buffer)[7] = (tmp >>  0) & 0x000000ff;

    return XDS_OK;
}

int xdr_decode_int64(xds_t *xds, void *engine_context,
                     void *buffer, size_t buffer_size,
                     size_t *used_buffer_size, va_list *args)
{
    xds_int64_t *value;
    xds_uint64_t tmp;

    xds_init_decoding_engine(8);

    /* Get value and format it into the buffer. */
    value = va_arg(*args, xds_int64_t *);
    xds_check_parameter(value != NULL);

    if (((xds_uint8_t *)buffer)[0] & 0x80) {
        /* negative number */
        tmp =  ((xds_uint8_t *)buffer)[0];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[1];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[2];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[3];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[4];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[5];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[6];
        tmp = tmp << 8;
        tmp += ((xds_uint8_t *)buffer)[7];
        tmp = 0 - tmp;
        *value = 0 - (xds_int64_t)tmp;
    }
    else {
        /* positive number */
        *value =  ((xds_uint8_t *)buffer)[0];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[1];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[2];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[3];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[4];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[5];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[6];
        *value = *value << 8;
        *value += ((xds_uint8_t *)buffer)[7];
    }

    return XDS_OK;
}

/*
 * Encode/decode unsigned 64-bit integer values.
 */

int xdr_encode_uint64(xds_t *xds, void *engine_context,
                      void *buffer, size_t buffer_size,
                      size_t *used_buffer_size, va_list *args)
{
    xds_uint64_t value;

    xds_init_encoding_engine(8);

    /* Get value and format it into the buffer. */
    value = va_arg(*args, xds_uint64_t);
    ((xds_uint8_t *)buffer)[0] = (value >> 56) & 0x000000ff;
    ((xds_uint8_t *)buffer)[1] = (value >> 48) & 0x000000ff;
    ((xds_uint8_t *)buffer)[2] = (value >> 40) & 0x000000ff;
    ((xds_uint8_t *)buffer)[3] = (value >> 32) & 0x000000ff;
    ((xds_uint8_t *)buffer)[4] = (value >> 24) & 0x000000ff;
    ((xds_uint8_t *)buffer)[5] = (value >> 16) & 0x000000ff;
    ((xds_uint8_t *)buffer)[6] = (value >>  8) & 0x000000ff;
    ((xds_uint8_t *)buffer)[7] = (value >>  0) & 0x000000ff;

    return XDS_OK;
}

int xdr_decode_uint64(xds_t *xds, void *engine_context,
                      void *buffer, size_t buffer_size,
                      size_t *used_buffer_size, va_list *args)
{
    xds_uint64_t *value;

    xds_init_decoding_engine(8);

    /* Get value and format it into the buffer. */
    value = va_arg(*args, xds_uint64_t *);
    xds_check_parameter(value != NULL);

    *value =  ((xds_uint8_t *)buffer)[0];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[1];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[2];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[3];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[4];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[5];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[6];
    *value = *value << 8;
    *value += ((xds_uint8_t *)buffer)[7];

    return XDS_OK;
}

#endif /* XDS_HAVE_64_BIT_SUPPORT */

/*
 * Encode/decode floating point values.
 */

typedef struct
    {
    xds_uint8_t  sign;		/* :1 */
    xds_uint32_t fraction;	/* :23 */
    xds_int8_t   exponent;	/* :8 */
    }
myfloat_t;

static int float2myfloat(myfloat_t* new_num, float num)
    {
    size_t i;
    float  tmp;

    /* Handle zero as a special case. */

    if (num == 0.0)
	{
	new_num->sign     = 0;
	new_num->fraction = 0;
	new_num->exponent = -127;
	return 0;
	}

    /* Determine the sign of the number. */

    if (num < 0.0)
	{
	new_num->sign = 1;
	num = 0.0 - num;
	}
    else
	new_num->sign = 0;

    /* Canonify the number before we convert it. */

    new_num->exponent = 0;
    while (num < 1.0)
	{
	num *= 2.0;
	--new_num->exponent;
	}

    /* Find the exponent. */

    for (i = 0, tmp = 1.0; i <= 128; ++i, tmp *= 2.0)
	{
	if (tmp * 2.0 > num)
	    break;
	}
    if (i <= 128)
	{
	num = num / tmp - 1.0;
	new_num->exponent += i;
	}
    else
	return 1;

    /* Calculate the fraction part. */

    for (new_num->fraction = 0, i = 0; i < 23; ++i)
	{
	new_num->fraction *= 2.0;
	if (num >= 1.0 / 2.0)
	    {
	    new_num->fraction += 1.0;
	    num = num * 2.0 - 1.0;
	    }
	else
	    num *= 2.0;
	}

    return 0;
    }


int xdr_encode_float(xds_t *xds, void *engine_context,
		     void *buffer, size_t buffer_size,
		     size_t *used_buffer_size, va_list *args)
{
    myfloat_t   value = { 0, 0, 0 };
    xds_uint8_t tmp;

    xds_init_encoding_engine(4);

    /* Get value and format it into the structure. */
    float2myfloat(&value, (float)va_arg(*args, double));

    memset(buffer, 0, 4);

    if (value.sign == 1)
	((xds_uint8_t*)buffer)[0] |= 0x80;

    tmp = value.exponent + 127;
    ((xds_uint8_t*)buffer)[0] |= tmp >> 1;
    ((xds_uint8_t*)buffer)[1] |= (tmp & 0x01) << 7;

    ((xds_uint8_t*)buffer)[1] |= (xds_uint8_t)((value.fraction & 0x7fffff) >> 16);
    ((xds_uint8_t*)buffer)[2] |= (xds_uint8_t)((value.fraction & 0x00ffff) >>  8);
    ((xds_uint8_t*)buffer)[3] |= (xds_uint8_t)((value.fraction & 0x0000ff) >>  0);

    return XDS_OK;
}

int xdr_decode_float(xds_t *xds, void *engine_context,
		     void *buffer, size_t buffer_size,
		     size_t *used_buffer_size, va_list *args)
{
    float*       value;
    xds_uint32_t fraction;
    xds_uint8_t  exponent;
    size_t       i;
    char         sign;

    xds_init_decoding_engine(4);

    value = va_arg(*args, float*);
    *value = 0.0;

    sign = (((xds_uint8_t*)buffer)[0] & 0x80) >> 7;
    exponent  = (((xds_uint8_t*)buffer)[0] & 0x7f) << 1;
    exponent += (((xds_uint8_t*)buffer)[1] & 0x80) >> 7;
    fraction  = (((xds_uint8_t*)buffer)[1] & 0x7fffff) << 16;
    fraction += ((xds_uint8_t*)buffer)[2] << 8;
    fraction += ((xds_uint8_t*)buffer)[3];

    if (fraction == 0 && exponent == 0)
	return XDS_OK;

    for (i = 23; i > 0; --i)
	{
	if ((fraction & 0x01) == 1)
	    *value += 1.0;
	*value /= 2.0;
	fraction /= 2.0;
	}
    *value += 1.0;

    if (exponent > 127)
	{
	for (exponent -= 127; exponent > 0; --exponent)
	    *value *= 2.0;
	}
    else
	{
	for (exponent = 127 - exponent; exponent > 0; --exponent)
	    *value /= 2.0;
	}

    if (sign == 1)
	*value = 0.0 - *value;

    return XDS_OK;
}


/*
 * Encode/decode double-precision floating point values.
 */

typedef struct
    {
    xds_uint8_t  sign;		/* :1 */
    xds_uint64_t fraction;	/* :52 */
    xds_int16_t  exponent;	/* :11 */
    }
mydouble_t;

static int double2mydouble(mydouble_t* new_num, double num)
    {
    size_t i;
    double  tmp;

    /* Handle zero as a special case. */

    if (num == 0.0)
	{
	new_num->sign     = 0;
	new_num->fraction = 0;
	new_num->exponent = -1023;
	return 0;
	}

    /* Determine the sign of the number. */

    if (num < 0.0)
	{
	new_num->sign = 1;
	num = 0.0 - num;
	}
    else
	new_num->sign = 0;

    /* Canonify the number before we convert it. */

    new_num->exponent = 0;
    while (num < 1.0)
	{
	num *= 2.0;
	--new_num->exponent;
	}

    /* Find the exponent. */

    for (i = 0, tmp = 1.0; i <= 1024; ++i, tmp *= 2.0)
	{
	if (tmp * 2.0 > num)
	    break;
	}
    if (i <= 1024)
	{
	num = num / tmp - 1.0;
	new_num->exponent += i;
	}
    else
	return 1;

    /* Calculate the fraction part. */

    for (new_num->fraction = 0, i = 0; i < 52; ++i)
	{
	new_num->fraction *= 2.0;
	if (num >= 1.0 / 2.0)
	    {
	    new_num->fraction += 1.0;
	    num = num * 2.0 - 1.0;
	    }
	else
	    num *= 2.0;
	}

    return 0;
    }


int xdr_encode_double(xds_t *xds, void *engine_context,
		     void *buffer, size_t buffer_size,
		     size_t *used_buffer_size, va_list *args)
{
    mydouble_t   value = { 0, 0, 0 };
    xds_uint16_t tmp;

    xds_init_encoding_engine(8);

    /* Get value and format it into the structure. */
    double2mydouble(&value, va_arg(*args, double));

    memset(buffer, 0, 8);

    if (value.sign == 1)
	((xds_uint8_t*)buffer)[0] |= 0x80;

    tmp = value.exponent + 1023;
    ((xds_uint8_t*)buffer)[0] |= (tmp >> 4) & 0x7f;
    ((xds_uint8_t*)buffer)[1] |= (tmp & 0x0f) << 4;

    ((xds_uint8_t*)buffer)[1] |= (xds_uint8_t)((value.fraction & 0x0f000000000000) >> 48);
    ((xds_uint8_t*)buffer)[2] |= (xds_uint8_t)((value.fraction & 0x00ff0000000000) >> 40);
    ((xds_uint8_t*)buffer)[3] |= (xds_uint8_t)((value.fraction & 0x0000ff00000000) >> 32);
    ((xds_uint8_t*)buffer)[4] |= (xds_uint8_t)((value.fraction & 0x000000ff000000) >> 24);
    ((xds_uint8_t*)buffer)[5] |= (xds_uint8_t)((value.fraction & 0x00000000ff0000) >> 16);
    ((xds_uint8_t*)buffer)[6] |= (xds_uint8_t)((value.fraction & 0x0000000000ff00) >>  8);
    ((xds_uint8_t*)buffer)[7] |= (xds_uint8_t)((value.fraction & 0x000000000000ff) >>  0);

    return XDS_OK;
}

int xdr_decode_double(xds_t *xds, void *engine_context,
		     void *buffer, size_t buffer_size,
		     size_t *used_buffer_size, va_list *args)
{
    double*      value;
    xds_uint64_t fraction;
    xds_uint16_t exponent;
    size_t       i;
    char         sign;

    xds_init_decoding_engine(8);

    value = va_arg(*args, double*);
    *value = 0.0;

    sign = (((xds_uint8_t*)buffer)[0] & 0x80) >> 7;
    exponent  = (((xds_uint8_t*)buffer)[0] & 0x7f) << 4;
    exponent += (((xds_uint8_t*)buffer)[1] & 0xf0) >> 4;

    fraction  = (xds_uint64_t)((((xds_uint8_t*)buffer)[1] & 0x0f)) << 48;
    fraction += (xds_uint64_t)(((xds_uint8_t*)buffer)[2]) << 40;
    fraction += (xds_uint64_t)(((xds_uint8_t*)buffer)[3]) << 32;
    fraction += (xds_uint64_t)(((xds_uint8_t*)buffer)[4]) << 24;
    fraction += (xds_uint64_t)(((xds_uint8_t*)buffer)[5]) << 16;
    fraction += (xds_uint64_t)(((xds_uint8_t*)buffer)[6]) <<  8;
    fraction += (xds_uint64_t)(((xds_uint8_t*)buffer)[7]) <<  0;

    if (fraction == 0 && exponent == 0)
	return XDS_OK;

    for (i = 52; i > 0; --i)
	{
	if ((fraction & 0x01) == 1)
	    *value += 1.0;
	*value /= 2.0;
	fraction /= 2.0;
	}
    *value += 1.0;

    if (exponent > 1023)
	{
	for (exponent -= 1023; exponent > 0; --exponent)
	    *value *= 2.0;
	}
    else
	{
	for (exponent = 1023 - exponent; exponent > 0; --exponent)
	    *value /= 2.0;
	}

    if (sign == 1)
	*value = 0.0 - *value;

    return XDS_OK;
}

/*
 * Encode/decode NUL-terminated character strings.
 */

int xdr_encode_string(xds_t *xds, void *engine_context,
                      void *buffer, size_t buffer_size,
                      size_t *used_buffer_size, va_list *args)
{
    char *p;
    size_t p_len;
    size_t padding;

    xds_init_encoding_engine(4);

    /* Get value from stack and calculate the correct amount of padding. */
    p = va_arg(*args, char *);
    xds_check_parameter(p != NULL);
    p_len = strlen(p);
    padding = (4 - (p_len & 0x03)) & 0x03;
    assert((p_len + padding) % 4 == 0);

    /* We need (4 + p_len + padding) bytes in the buffer to format our
       parameter. If we don't have them, return an underflow error. */
    *used_buffer_size = 4 + p_len + padding;
    if (buffer_size < *used_buffer_size)
        return XDS_ERR_OVERFLOW;

    /* Format the values into the buffer. */
    ((xds_uint8_t *)buffer)[0] = (p_len >> 24) & 0x000000ff;
    ((xds_uint8_t *)buffer)[1] = (p_len >> 16) & 0x000000ff;
    ((xds_uint8_t *)buffer)[2] = (p_len >>  8) & 0x000000ff;
    ((xds_uint8_t *)buffer)[3] = (p_len >>  0) & 0x000000ff;
    memmove((xds_uint8_t *)buffer + 4, p, p_len);
    memset((xds_uint8_t *)buffer + 4 + p_len, 0, padding);

    return XDS_OK;
}

int xdr_decode_string(xds_t *xds, void *engine_context,
                      void *buffer, size_t buffer_size,
                      size_t *used_buffer_size, va_list *args)
{
    char **p;
    size_t p_len;
    size_t padding;

    xds_init_decoding_engine(4);

    /* Get value. */
    p = va_arg(*args, char **);
    xds_check_parameter(p != NULL);

    /* Read the size of the message. */
    p_len =  ((xds_uint8_t *)buffer)[0];
    p_len = p_len << 8;
    p_len += ((xds_uint8_t *)buffer)[1];
    p_len = p_len << 8;
    p_len += ((xds_uint8_t *)buffer)[2];
    p_len = p_len << 8;
    p_len += ((xds_uint8_t *)buffer)[3];

    /* Calculate padding. */
    padding = (4 - (p_len & 0x03)) & 0x03;

    /* Do we have enough data? */
    *used_buffer_size = 4 + p_len + padding;
    if (buffer_size < *used_buffer_size)
        return XDS_ERR_UNDERFLOW;

    /* Allocate buffer for the data. */
    *p = (char *)malloc(p_len + 1);
    if (*p == NULL)
        return XDS_ERR_NO_MEM;

    /* Copy data into the buffer. */
    memmove(*p, (xds_uint8_t *)buffer + 4, p_len);
    (*p)[p_len] = '\0';

    return XDS_OK;
}

/*
 * Encode/decode octet streams.
 */

int xdr_encode_octetstream(xds_t *xds, void *engine_context,
                           void *buffer, size_t buffer_size,
                           size_t *used_buffer_size, va_list *args)
{
    xds_uint8_t *p;
    size_t p_len;
    size_t padding;

    xds_init_encoding_engine(4);

    /* Get value from stack and calculate the correct amount of padding. */
    p = (xds_uint8_t *) va_arg(*args, void *);
    xds_check_parameter(p != NULL);
    p_len = va_arg(*args, size_t);
    padding = (4 - (p_len & 0x03)) & 0x03;
    assert((p_len + padding) % 4 == 0);

    /* We need (4 + p_len + padding) bytes in the buffer to format our
       parameter. If we don't have them, return an underflow error. */
    *used_buffer_size = 4 + p_len + padding;
    if (buffer_size < *used_buffer_size)
        return XDS_ERR_OVERFLOW;

    /* Format the values into the buffer. */
    ((xds_uint8_t *)buffer)[0] = (p_len >> 24) & 0x000000ff;
    ((xds_uint8_t *)buffer)[1] = (p_len >> 16) & 0x000000ff;
    ((xds_uint8_t *)buffer)[2] = (p_len >>  8) & 0x000000ff;
    ((xds_uint8_t *)buffer)[3] = (p_len >>  0) & 0x000000ff;
    memmove((xds_uint8_t *) buffer + 4, p, p_len);
    memset((xds_uint8_t *) buffer + 4 + p_len, 0, padding);

    return XDS_OK;
}

int xdr_decode_octetstream(xds_t *xds, void *engine_context,
                           void *buffer, size_t buffer_size,
                           size_t *used_buffer_size, va_list *args)
{
    void **p;
    size_t *p_len;
    size_t padding;

    xds_init_decoding_engine(4);

    p = va_arg(*args, void **);
    p_len = va_arg(*args, size_t *);
    xds_check_parameter(p != NULL);
    xds_check_parameter(p_len != NULL);

    /* Read the size of the message. */
    *p_len =  ((xds_uint8_t *)buffer)[0];
    *p_len = *p_len << 8;
    *p_len += ((xds_uint8_t *)buffer)[1];
    *p_len = *p_len << 8;
    *p_len += ((xds_uint8_t *)buffer)[2];
    *p_len = *p_len << 8;
    *p_len += ((xds_uint8_t *)buffer)[3];

    /* Calculate padding. */
    padding = (4 - (*p_len & 0x03)) & 0x03;

    /* Do we have enough data? */
    *used_buffer_size = 4 + *p_len + padding;
    if (buffer_size < *used_buffer_size)
        return XDS_ERR_UNDERFLOW;

    /* Allocate buffer for the data. */
    *p = malloc(*p_len);
    if (*p == NULL)
        return XDS_ERR_NO_MEM;

    /* Copy data into the buffer. */
    memmove(*p, (xds_uint8_t *) buffer + 4, *p_len);

    return XDS_OK;
}

@


1.16
log
@Fix XDR string decoding function by NUL terminating
the target buffer (instead of the source buffer).

Submitted by: Unknown <ossp@@jm.2good.nu>
@
text
@d3 3
a5 3
**  Copyright (c) 2001-2004 Ralf S. Engelschall <rse@@engelschall.com>
**  Copyright (c) 2001-2004 The OSSP Project <http://www.ossp.org/>
**  Copyright (c) 2001-2004 Cable & Wireless <http://www.cw.com/>
@


1.15
log
@Bumped year in copyright messages for year 2004.
@
text
@d699 1
a699 1
    ((xds_uint8_t *)buffer)[4 + p_len] = '\0';
@


1.14
log
@Fixed a few size_t/int conflicts and uninitialized value warnings.
@
text
@d3 3
a5 3
**  Copyright (c) 2001-2003 Ralf S. Engelschall <rse@@engelschall.com>
**  Copyright (c) 2001-2003 The OSSP Project <http://www.ossp.org/>
**  Copyright (c) 2001-2003 Cable & Wireless Germany <http://www.cw.com/de/>
@


1.13
log
@upgrade to standard OSSP copyright and bump year to 2003
@
text
@d380 1
a380 1
    myfloat_t   value;
d539 1
a539 1
    mydouble_t   value;
@


1.12
log
@update texts
@
text
@d3 3
a5 2
**  Copyright (c) 2001-2002 The OSSP Project (http://www.ossp.org/)
**  Copyright (c) 2001-2002 Cable & Wireless Deutschland (http://www.cw.com/de/)
@


1.11
log
@bump copyright year
@
text
@d2 1
a2 1
**  XDS - OSSP Extensible Data Serialization Library
d6 2
a7 2
**  This file is part of OSSP XDS, an extensible data serialization
**  library which can be found at http://www.ossp.org/pkg/xds/.
@


1.10
log
@Removed the bitfield specifications from myfloat_t and mydouble_t
because some compilers cannot handle bitfield elements that are bigger
than an integer and we need this for the 52-bit fraction part in
mydouble_t. By omitting the qualifiers, we waste a few byte on the
stack, but that's way better than trying to deal with this problem by
splitting fractions into two integers.
@
text
@d3 2
a4 2
**  Copyright (c) 2001 The OSSP Project (http://www.ossp.org/)
**  Copyright (c) 2001 Cable & Wireless Deutschland (http://www.cw.com/de/)
@


1.9
log
@Implemented encoding and decoding of doubles.
@
text
@d302 3
a304 3
    xds_uint8_t  sign     :1;
    xds_uint32_t fraction :23;
    xds_int8_t   exponent :8;
d461 3
a463 3
    xds_uint8_t  sign     :1;
    xds_uint64_t fraction :52;
    xds_int16_t  exponent :11;
@


1.8
log
@- Moved all float-related stuff into xds_engine_xdr.c so that we don't
  need any prototypes or structure declarations in the public header
  file.

- Renamed xds_float_t to my_float.

- Renamed float2xds_float() to float2myfloat().
@
text
@d302 3
a304 3
    unsigned int sign     :1;
    unsigned int fraction :23;
    int          exponent :8;
a309 1
    const static unsigned int base = 2;
d325 1
a325 1
    if (num < 0)
d328 1
a328 1
	num = 0 - num;
d336 1
a336 1
    while (num < 1)
d338 1
a338 1
	num *= base;
d344 1
a344 1
    for (i = 0, tmp = 1; i <= 128; ++i, tmp *= base)
d346 1
a346 1
	if (tmp*base > num)
d351 1
a351 1
	num = num / tmp - 1;
d361 2
a362 2
	new_num->fraction *= base;
	if (num >= 1.0 / base)
d364 2
a365 2
	    new_num->fraction |= 1;
	    num = num * base - 1;
d368 1
a368 4
	    {
	    new_num->fraction |= 0;
	    num *= base;
	    }
d418 3
a423 3
    exponent  = (((xds_uint8_t*)buffer)[0] & 0x7f) << 1;
    exponent += (((xds_uint8_t*)buffer)[1] & 0x80) >> 7;
    sign = (((xds_uint8_t*)buffer)[0] & 0x80) >> 7;
d431 1
a431 1
	    *value += 1;
d433 1
a433 1
	fraction /= 2;
d435 1
a435 1
    *value += 1;
d459 75
d535 2
a536 2
                      void *buffer, size_t buffer_size,
                      size_t *used_buffer_size, va_list *args)
d538 26
a563 2
    /* XXX */
    return -1;
d567 2
a568 2
                      void *buffer, size_t buffer_size,
                      size_t *used_buffer_size, va_list *args)
d570 50
a619 2
    /* XXX */
    return -1;
@


1.7
log
@Implemented xdr_encode_float() and xdr_decode_float().
@
text
@d300 79
d383 1
a383 1
    xds_float_t value;
d389 1
a389 1
    float2xds_float(&value, (float)va_arg(*args, double));
@


1.6
log
@Remove trailing whitespaces on all non-generated files.
@
text
@d297 84
@


1.5
log
@Hhmm... who has introduced ossp.com?!
Our project's domain is ossp.org, of course.
@
text
@d76 1
a76 1
    if (((xds_uint8_t *) buffer)[0] & 0x80) {   
d88 1
a88 1
    else {                             
d195 1
a195 1
    if (((xds_uint8_t *)buffer)[0] & 0x80) {  
@


1.4
log
@Group functions with leading summary comment
@
text
@d7 1
a7 1
**  library which can be found at http://www.ossp.com/pkg/xds/.
@


1.3
log
@Final adjustments to coding style in order to make OSSP XDS look equal
in style to all other OSSP parts. This should remove most of the
strangeness GNU indent usually introduces.
@
text
@d34 4
d102 4
d149 4
d237 4
d296 4
d316 4
d396 4
@


1.2
log
@Use the license consistently.
@
text
@d34 1
a34 1
int xdr_encode_int32(xds_t * xds, void *engine_context,
d36 1
a36 1
                     size_t * used_buffer_size, va_list * args)
a43 1

d51 4
a54 6
    ((xds_uint8_t *) buffer)[0] = (tmp >> 24) & 0x000000ff;
    ((xds_uint8_t *) buffer)[1] = (tmp >> 16) & 0x000000ff;
    ((xds_uint8_t *) buffer)[2] = (tmp >> 8) & 0x000000ff;
    ((xds_uint8_t *) buffer)[3] = (tmp >> 0) & 0x000000ff;

    /* Done. */
d59 1
a59 1
int xdr_decode_int32(xds_t * xds, void *engine_context,
d61 1
a61 1
                     size_t * used_buffer_size, va_list * args)
a68 1

d72 3
a74 2
    if (((xds_uint8_t *) buffer)[0] & 0x80) {   /* negative number */
        tmp = ((xds_uint8_t *) buffer)[0];
d76 1
a76 1
        tmp += ((xds_uint8_t *) buffer)[1];
d78 1
a78 1
        tmp += ((xds_uint8_t *) buffer)[2];
d80 1
a80 1
        tmp += ((xds_uint8_t *) buffer)[3];
d82 1
a82 1
        *value = 0 - (int32_t) tmp;
d84 3
a86 2
    else {                             /* positive number */
        *value = ((xds_uint8_t *) buffer)[0];
d88 1
a88 1
        *value += ((xds_uint8_t *) buffer)[1];
d90 1
a90 1
        *value += ((xds_uint8_t *) buffer)[2];
d92 1
a92 1
        *value += ((xds_uint8_t *) buffer)[3];
a94 2
    /* Done. */

d98 1
a98 1
int xdr_encode_uint32(xds_t * xds, void *engine_context,
d100 1
a100 1
                      size_t * used_buffer_size, va_list * args)
a106 1

d108 4
a111 6
    ((xds_uint8_t *) buffer)[0] = (value >> 24) & 0x000000ff;
    ((xds_uint8_t *) buffer)[1] = (value >> 16) & 0x000000ff;
    ((xds_uint8_t *) buffer)[2] = (value >> 8) & 0x000000ff;
    ((xds_uint8_t *) buffer)[3] = (value >> 0) & 0x000000ff;

    /* Done. */
d116 1
a116 1
int xdr_decode_uint32(xds_t * xds, void *engine_context,
d118 1
a118 1
                      size_t * used_buffer_size, va_list * args)
a124 1

d128 1
a128 1
    *value = ((xds_uint8_t *) buffer)[0];
d130 1
a130 1
    *value += ((xds_uint8_t *) buffer)[1];
d132 1
a132 1
    *value += ((xds_uint8_t *) buffer)[2];
d134 1
a134 3
    *value += ((xds_uint8_t *) buffer)[3];

    /* Done. */
d141 1
a141 1
int xdr_encode_int64(xds_t * xds, void *engine_context,
d143 1
a143 1
                     size_t * used_buffer_size, va_list * args)
a150 1

d154 1
a154 1
        tmp = 0 - (xds_uint64_t) value;
d157 9
a165 11
        tmp = (xds_uint64_t) value;
    ((xds_uint8_t *) buffer)[0] = (tmp >> 56) & 0x000000ff;
    ((xds_uint8_t *) buffer)[1] = (tmp >> 48) & 0x000000ff;
    ((xds_uint8_t *) buffer)[2] = (tmp >> 40) & 0x000000ff;
    ((xds_uint8_t *) buffer)[3] = (tmp >> 32) & 0x000000ff;
    ((xds_uint8_t *) buffer)[4] = (tmp >> 24) & 0x000000ff;
    ((xds_uint8_t *) buffer)[5] = (tmp >> 16) & 0x000000ff;
    ((xds_uint8_t *) buffer)[6] = (tmp >> 8) & 0x000000ff;
    ((xds_uint8_t *) buffer)[7] = (tmp >> 0) & 0x000000ff;

    /* Done. */
d170 1
a170 1
int xdr_decode_int64(xds_t * xds, void *engine_context,
d172 1
a172 1
                     size_t * used_buffer_size, va_list * args)
a179 1

d183 3
a185 2
    if (((xds_uint8_t *) buffer)[0] & 0x80) {   /* negative number */
        tmp = ((xds_uint8_t *) buffer)[0];
d187 1
a187 1
        tmp += ((xds_uint8_t *) buffer)[1];
d189 1
a189 1
        tmp += ((xds_uint8_t *) buffer)[2];
d191 1
a191 1
        tmp += ((xds_uint8_t *) buffer)[3];
d193 1
a193 1
        tmp += ((xds_uint8_t *) buffer)[4];
d195 1
a195 1
        tmp += ((xds_uint8_t *) buffer)[5];
d197 1
a197 1
        tmp += ((xds_uint8_t *) buffer)[6];
d199 1
a199 1
        tmp += ((xds_uint8_t *) buffer)[7];
d201 1
a201 1
        *value = 0 - (xds_int64_t) tmp;
d203 3
a205 2
    else {                             /* positive number */
        *value = ((xds_uint8_t *) buffer)[0];
d207 1
a207 1
        *value += ((xds_uint8_t *) buffer)[1];
d209 1
a209 1
        *value += ((xds_uint8_t *) buffer)[2];
d211 1
a211 1
        *value += ((xds_uint8_t *) buffer)[3];
d213 1
a213 1
        *value += ((xds_uint8_t *) buffer)[4];
d215 1
a215 1
        *value += ((xds_uint8_t *) buffer)[5];
d217 1
a217 1
        *value += ((xds_uint8_t *) buffer)[6];
d219 1
a219 1
        *value += ((xds_uint8_t *) buffer)[7];
a221 2
    /* Done. */

d225 1
a225 1
int xdr_encode_uint64(xds_t * xds, void *engine_context,
d227 1
a227 1
                      size_t * used_buffer_size, va_list * args)
a233 1

d235 8
a242 10
    ((xds_uint8_t *) buffer)[0] = (value >> 56) & 0x000000ff;
    ((xds_uint8_t *) buffer)[1] = (value >> 48) & 0x000000ff;
    ((xds_uint8_t *) buffer)[2] = (value >> 40) & 0x000000ff;
    ((xds_uint8_t *) buffer)[3] = (value >> 32) & 0x000000ff;
    ((xds_uint8_t *) buffer)[4] = (value >> 24) & 0x000000ff;
    ((xds_uint8_t *) buffer)[5] = (value >> 16) & 0x000000ff;
    ((xds_uint8_t *) buffer)[6] = (value >> 8) & 0x000000ff;
    ((xds_uint8_t *) buffer)[7] = (value >> 0) & 0x000000ff;

    /* Done. */
d247 1
a247 1
int xdr_decode_uint64(xds_t * xds, void *engine_context,
d249 1
a249 1
                      size_t * used_buffer_size, va_list * args)
a255 1

d259 1
a259 1
    *value = ((xds_uint8_t *) buffer)[0];
d261 1
a261 1
    *value += ((xds_uint8_t *) buffer)[1];
d263 1
a263 1
    *value += ((xds_uint8_t *) buffer)[2];
d265 1
a265 1
    *value += ((xds_uint8_t *) buffer)[3];
d267 1
a267 1
    *value += ((xds_uint8_t *) buffer)[4];
d269 1
a269 1
    *value += ((xds_uint8_t *) buffer)[5];
d271 1
a271 1
    *value += ((xds_uint8_t *) buffer)[6];
d273 1
a273 3
    *value += ((xds_uint8_t *) buffer)[7];

    /* Done. */
d280 1
a280 1
int xdr_encode_double(xds_t * xds, void *engine_context,
d282 1
a282 1
                      size_t * used_buffer_size, va_list * args)
d284 1
d288 1
a288 1
int xdr_decode_double(xds_t * xds, void *engine_context,
d290 1
a290 1
                      size_t * used_buffer_size, va_list * args)
d292 1
d296 1
a296 1
int xdr_encode_string(xds_t * xds, void *engine_context,
d298 1
a298 1
                      size_t * used_buffer_size, va_list * args)
a306 1

d314 1
a314 2
     * parameter. If we don't have them, return an underflow error. */

d320 6
a325 9

    ((xds_uint8_t *) buffer)[0] = (p_len >> 24) & 0x000000ff;
    ((xds_uint8_t *) buffer)[1] = (p_len >> 16) & 0x000000ff;
    ((xds_uint8_t *) buffer)[2] = (p_len >> 8) & 0x000000ff;
    ((xds_uint8_t *) buffer)[3] = (p_len >> 0) & 0x000000ff;
    memmove((xds_uint8_t *) buffer + 4, p, p_len);
    memset((xds_uint8_t *) buffer + 4 + p_len, 0, padding);

    /* Done. */
d330 1
a330 1
int xdr_decode_string(xds_t * xds, void *engine_context,
d332 1
a332 1
                      size_t * used_buffer_size, va_list * args)
d340 1
d345 1
a345 2

    p_len = ((xds_uint8_t *) buffer)[0];
d347 1
a347 1
    p_len += ((xds_uint8_t *) buffer)[1];
d349 1
a349 1
    p_len += ((xds_uint8_t *) buffer)[2];
d351 1
a351 1
    p_len += ((xds_uint8_t *) buffer)[3];
a353 1

d356 1
a356 2
    /* Do we have enough data?. */

a361 1

d367 2
a368 5

    memmove(*p, (xds_uint8_t *) buffer + 4, p_len);
    ((xds_uint8_t *) buffer)[4 + p_len] = '\0';

    /* Done. */
d373 1
a373 1
int xdr_encode_octetstream(xds_t * xds, void *engine_context,
d375 1
a375 1
                           size_t * used_buffer_size, va_list * args)
a383 1

d391 1
a391 2
     * parameter. If we don't have them, return an underflow error. */

d397 4
a400 5

    ((xds_uint8_t *) buffer)[0] = (p_len >> 24) & 0x000000ff;
    ((xds_uint8_t *) buffer)[1] = (p_len >> 16) & 0x000000ff;
    ((xds_uint8_t *) buffer)[2] = (p_len >> 8) & 0x000000ff;
    ((xds_uint8_t *) buffer)[3] = (p_len >> 0) & 0x000000ff;
a403 2
    /* Done. */

d407 1
a407 1
int xdr_decode_octetstream(xds_t * xds, void *engine_context,
d409 1
a409 1
                           size_t * used_buffer_size, va_list * args)
d423 1
a423 2

    *p_len = ((xds_uint8_t *) buffer)[0];
d425 1
a425 1
    *p_len += ((xds_uint8_t *) buffer)[1];
d427 1
a427 1
    *p_len += ((xds_uint8_t *) buffer)[2];
d429 1
a429 1
    *p_len += ((xds_uint8_t *) buffer)[3];
a431 1

d434 1
a434 2
    /* Do we have enough data?. */

a439 1

a444 1

a446 2
    /* Done. */

d449 1
@


1.1
log
@First cut of the ruthless style adjustments to OSSP XDS:

o adjust source tree to follow OSSP source tree style
  by heavily combining sources into smaller sets
  (needs more work when still missing parts are added later)

o automatic re-indentation of sources with GNU indent
  (still needs manual review and adjustments; will follow)

These two heavy steps were mostly done automatically with the help of
two helper scripts written in Perl. So expect more manual adjustments to
follow...
@
text
@d1 28
a28 23
/* 
 * XDS - OSSP Extensible Data Serialization Library Copyright (c) 2001 The
 * OSSP Project (http://www.ossp.org/) Copyright (c) 2001 Cable & Wireless
 * Deutschland (http://www.cw.com/de/)
 * 
 * This file is part of OSSP XDS, an extensible data serialization library
 * which can be found at http://www.ossp.com/pkg/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. */
d31 1
@