wsencode.h File Reference

Go to the source code of this file.

Macros
#define	WS_PUT_UINT8(buf, val)
#define	WS_PUT_UINT16(buf, val)
#define	WS_PUT_UINT32(buf, val)
#define	WS_GET_UINT8(buf, var)
#define	WS_GET_UINT16(buf, var)
#define	WS_GET_UINT32(buf, var)
#define	WS_MB_UINT32_MAX_ENCODED_LEN   5

Enumerations
enum	WsEncodingSpec {   WS_ENC_END, WS_ENC_BYTE, WS_ENC_INT8, WS_ENC_UINT8,   WS_ENC_INT16, WS_ENC_UINT16, WS_ENC_INT32, WS_ENC_UINT32,   WS_ENC_MB_UINT16, WS_ENC_MB_UINT32, WS_ENC_DATA }

Functions
unsigned char *	ws_encode_mb_uint32 (WsUInt32 value, unsigned char *buffer, size_t *len_return)
WsUInt32	ws_decode_mb_uint32 (const unsigned char *buffer, size_t *len)
WsBool	ws_encode_buffer (WsBuffer *buffer,...)
size_t	ws_decode_buffer (const unsigned char *buffer, size_t buffer_len,...)

Macro Definition Documentation

WS_GET_UINT16

#define WS_GET_UINT16	(		buf,
			var
	)

Value:

do {                        \
        const unsigned char *_p = (buf);        \
        WsUInt16 _val;                  \
        _val = _p[0];                   \
        _val <<= 8;                 \
        _val |= _p[1];                  \
        (var) = _val;                   \
    } while (0);

Definition at line 107 of file wsencode.h.

Referenced by ws_asm_dasm(), and ws_decode_buffer().

WS_GET_UINT32

#define WS_GET_UINT32	(		buf,
			var
	)

Value:

do {                        \
        const unsigned char *_p = (buf);        \
        WsUInt32 _val;                  \
        _val = _p[0];                   \
        _val <<= 8;                 \
        _val |= _p[1];                  \
        _val <<= 8;                 \
        _val |= _p[2];                  \
        _val <<= 8;                 \
        _val |= _p[3];                  \
        (var) = _val;                   \
    } while (0);

Definition at line 117 of file wsencode.h.

Referenced by ws_decode_buffer().

WS_GET_UINT8

#define WS_GET_UINT8	(		buf,
			var
	)

Value:

do {                        \
        const unsigned char *_p = (buf);        \
        (var) = _p[0];                  \
    } while (0);

Definition at line 101 of file wsencode.h.

Referenced by ws_asm_dasm(), and ws_decode_buffer().

WS_MB_UINT32_MAX_ENCODED_LEN

#define WS_MB_UINT32_MAX_ENCODED_LEN   5

Definition at line 133 of file wsencode.h.

Referenced by ws_bc_data_free(), and ws_encode_mb_uint32().

WS_PUT_UINT16

#define WS_PUT_UINT16	(		buf,
			val
	)

Value:

do {                        \
        unsigned char *_p = (buf);          \
        _p[0] = (((val) & 0xff00) >> 8);        \
        _p[1] = ((val) & 0xff);             \
    } while (0)

Definition at line 85 of file wsencode.h.

Referenced by ws_encode_buffer().

WS_PUT_UINT32

#define WS_PUT_UINT32	(		buf,
			val
	)

Value:

do {                        \
        unsigned char *_p = (buf);          \
        _p[0] = (((val) & 0xff000000) >> 24);       \
        _p[1] = (((val) & 0x00ff0000) >> 16);       \
        _p[2] = (((val) & 0x0000ff00) >> 8);        \
        _p[3] = ((val) & 0x000000ff);           \
    } while (0)

Definition at line 92 of file wsencode.h.

Referenced by ws_encode_buffer().

WS_PUT_UINT8

#define WS_PUT_UINT8	(		buf,
			val
	)

Value:

do {                        \
        unsigned char *_p = (buf);          \
        _p[0] = ((val) & 0xff);             \
    } while (0)

Definition at line 78 of file wsencode.h.

Referenced by ws_bc_encode(), and ws_encode_buffer().

Enumeration Type Documentation

WsEncodingSpec

enum WsEncodingSpec

Enumerator
WS_ENC_END
WS_ENC_BYTE
WS_ENC_INT8
WS_ENC_UINT8
WS_ENC_INT16
WS_ENC_UINT16
WS_ENC_INT32
WS_ENC_UINT32
WS_ENC_MB_UINT16
WS_ENC_MB_UINT32
WS_ENC_DATA

Definition at line 136 of file wsencode.h.

{
    /* The terminator of the encoding list.  This must be the last item
       in all encoding and decoding function calls. */
    WS_ENC_END,

    /* 8 bits of data.  The value must be given as `WsByte'. */
    WS_ENC_BYTE,

    /* A signed 8 bit integer.  The value must be given as `WsInt8'. */
    WS_ENC_INT8,

    /* An unsigned 8 bit integer.  The value must be given as `WsUInt8'. */
    WS_ENC_UINT8,

    /* A signed 16 bit integer.  The value must be given as `WsInt16'. */
    WS_ENC_INT16,

    /* An unsigned 16 bit integer.  The value must be given as `WsUInt16'. */
    WS_ENC_UINT16,

    /* A signed 32 bit integer.  The value must be given as `WsInt32'. */
    WS_ENC_INT32,

    /* An unsigned 32 bit integer.  The value must be given as `WsUInt32'. */
    WS_ENC_UINT32,

    /* An unsigned 16 bit integer in the multi-byte format.  The value
       must be given as `WsUInt16'. */
    WS_ENC_MB_UINT16,

    /* An unsigned 32 bit integer in the multi-byte format.  The value
       must be given as `WsUInt32'. */
    WS_ENC_MB_UINT32,

    /* Binary data specified with two arguments: unsigned char *, size_t */
    WS_ENC_DATA
} WsEncodingSpec;

Function Documentation

ws_decode_buffer()

size_t ws_decode_buffer	(	const unsigned char *	buffer,
		size_t	buffer_len,
			...
	)

Definition at line 222 of file wsencode.c.

References WsBufferRec::len, ws_decode_mb_uint32(), WS_ENC_BYTE, WS_ENC_DATA, WS_ENC_END, WS_ENC_INT16, WS_ENC_INT32, WS_ENC_INT8, WS_ENC_MB_UINT16, WS_ENC_MB_UINT32, WS_ENC_UINT16, WS_ENC_UINT32, WS_ENC_UINT8, ws_fatal(), WS_GET_UINT16, WS_GET_UINT32, and WS_GET_UINT8.

Referenced by ws_bc_decode().

{
    va_list ap;
    WsEncodingSpec spec;
    WsUInt8 *i8p;
    WsUInt16 *i16p;
    WsUInt32 *i32p;
    unsigned char **cpp;
    size_t len;
    size_t orig_buffer_len = buffer_len;

    va_start(ap, buffer_len);

    while ((spec = va_arg(ap, int)) != WS_ENC_END) {
        switch (spec) {
        case WS_ENC_BYTE:
        case WS_ENC_INT8:
        case WS_ENC_UINT8:
            if (buffer_len < 1)
                goto too_short_buffer;

            i8p = va_arg(ap, WsUInt8 *);
            WS_GET_UINT8(buffer, *i8p);

            buffer++;
            buffer_len--;
            break;

        case WS_ENC_INT16:
        case WS_ENC_UINT16:
            if (buffer_len < 2)
                goto too_short_buffer;

            i16p = va_arg(ap, WsUInt16 *);
            WS_GET_UINT16(buffer, *i16p);

            buffer += 2;
            buffer_len -= 2;
            break;

        case WS_ENC_INT32:
        case WS_ENC_UINT32:
            if (buffer_len < 4)
                goto too_short_buffer;

            i32p = va_arg(ap, WsUInt32 *);
            WS_GET_UINT32(buffer, *i32p);

            buffer += 4;
            buffer_len -= 4;
            break;

        case WS_ENC_MB_UINT16:
        case WS_ENC_MB_UINT32:
            {
                size_t len = buffer_len;
                WsUInt32 i32;

                if (buffer_len < 1)
                    goto too_short_buffer;

                i32 = ws_decode_mb_uint32(buffer, &len);

                if (spec == WS_ENC_MB_UINT16) {
                    i16p = va_arg(ap, WsUInt16 *);
                    *i16p = i32;
                } else {
                    i32p = va_arg(ap, WsUInt32 *);
                    *i32p = i32;
                }

                buffer += len;
                buffer_len -= len;
            }
            break;

        case WS_ENC_DATA:
            cpp = va_arg(ap, unsigned char **);
            len = va_arg(ap, size_t);

            if (buffer_len < len)
                goto too_short_buffer;

            *cpp = (unsigned char *) buffer;
            buffer += len;
            buffer_len -= len;
            break;

        default:
            ws_fatal("ws_encode_buffer(): unknown type %d: probably a missing "
                     "WS_ENC_END",
                     spec);
            break;
        }
    }
    va_end(ap);

    return orig_buffer_len - buffer_len;

too_short_buffer:

    va_end(ap);

    return 0;
}

ws_decode_mb_uint32()

WsUInt32 ws_decode_mb_uint32	(	const unsigned char *	buffer,
		size_t *	len
	)

Definition at line 104 of file wsencode.c.

References WsBufferRec::len, WS_MB_CONT_BIT, and WS_MB_DATA_MASK.

Referenced by ws_bc_data_free(), and ws_decode_buffer().

{
    WsUInt32 value = 0;
    size_t i;

    for (i = 0; i < *len; i++) {
        value <<= 7;
        value |= buffer[i] & WS_MB_DATA_MASK;

        if ((buffer[i] & WS_MB_CONT_BIT) == 0)
            break;
    }

    *len = i + 1;

    return value;
}

ws_encode_buffer()

WsBool ws_encode_buffer	(	WsBuffer *	buffer,
			...
	)

Definition at line 123 of file wsencode.c.

References WsBufferRec::data, error(), WsBufferRec::len, ws_buffer_append_space(), WS_ENC_BYTE, WS_ENC_DATA, WS_ENC_END, WS_ENC_INT16, WS_ENC_INT32, WS_ENC_INT8, WS_ENC_MB_UINT16, WS_ENC_MB_UINT32, WS_ENC_UINT16, WS_ENC_UINT32, WS_ENC_UINT8, ws_encode_mb_uint32(), WS_FALSE, ws_fatal(), WS_PUT_UINT16, WS_PUT_UINT32, WS_PUT_UINT8, and WS_TRUE.

Referenced by ws_asm_linearize(), and ws_bc_encode().

{
    va_list ap;
    WsEncodingSpec spec;
    int ival;
    unsigned char *p;
    unsigned char *cp;
    size_t len;
    WsUInt32 ui32;
    unsigned char data[64];

    va_start(ap, buffer);

    while ((spec = va_arg(ap, int)) != WS_ENC_END)
    {
        switch (spec)
        {
        case WS_ENC_BYTE:
        case WS_ENC_INT8:
        case WS_ENC_UINT8:
            ival = va_arg(ap, int);

            if (!ws_buffer_append_space(buffer, &p, 1))
                goto error;

            WS_PUT_UINT8(p, ival);
            break;

        case WS_ENC_INT16:
        case WS_ENC_UINT16:
            ival = va_arg(ap, int);

            if (!ws_buffer_append_space(buffer, &p, 2))
                goto error;

            WS_PUT_UINT16(p, ival);
            break;

        case WS_ENC_INT32:
        case WS_ENC_UINT32:
            ival = va_arg(ap, long);

            if (!ws_buffer_append_space(buffer, &p, 4))
                goto error;

            WS_PUT_UINT32(p, ival);
            break;

        case WS_ENC_MB_UINT16:
        case WS_ENC_MB_UINT32:
            if (spec == WS_ENC_MB_UINT16)
                ui32 = va_arg(ap, int);
            else
                ui32 = va_arg(ap, long);

            len = sizeof(data);
            cp = ws_encode_mb_uint32(ui32, data, &len);

            if (!ws_buffer_append_space(buffer, &p, len))
                goto error;

            memcpy(p, cp, len);
            break;

        case WS_ENC_DATA:
            cp = va_arg(ap, unsigned char *);
            len = va_arg(ap, unsigned int);

            if (!ws_buffer_append_space(buffer, &p, len))
                goto error;

            memcpy(p, cp, len);
            break;

        default:
            ws_fatal("ws_encode_buffer(): unknown type %d: probably a missing "
                     "WS_ENC_END",
                     spec);
            break;
        }
    }

    va_end(ap);

    return WS_TRUE;


    /*
     * Error handling.
     */

error:

    va_end(ap);

    return WS_FALSE;
}

ws_encode_mb_uint32()

unsigned char* ws_encode_mb_uint32	(	WsUInt32	value,
		unsigned char *	buffer,
		size_t *	len_return
	)

Definition at line 79 of file wsencode.c.

References WsBufferRec::len, WS_MB_CONT_BIT, WS_MB_DATA_MASK, and WS_MB_UINT32_MAX_ENCODED_LEN.

Referenced by ws_bc_encode(), and ws_encode_buffer().

{
    unsigned char *p = buffer + WS_MB_UINT32_MAX_ENCODED_LEN;
    size_t len = 1;

    /* Set the terminator byte. */
    *p = value & WS_MB_DATA_MASK;
    value >>= 7;
    p--;

    /* And add the data. */
    while (value > 0) {
        *p = (value & WS_MB_DATA_MASK) | WS_MB_CONT_BIT;
        value >>= 7;
        p--;
        len++;
    }

    *len_return = len;

    return p + 1;
}