/*
* xdr.c
* -----
* Serialization/deserialization routines, using XDR (RFC 4506) encoding.
* These functions are not part of the public libhal API.
*
* Copyright (c) 2016-2018, NORDUnet A/S All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - 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.
*
* - Neither the name of the NORDUnet nor the names of its contributors 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
* HOLDER 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 <stdio.h>
#include <stdint.h>
#include <stddef.h> /* ptrdiff_t */
#include <string.h> /* memcpy, memset */
#include "hal.h"
#include "hal_internal.h" /* htonl/ntohl */
#include "xdr_internal.h"
static int verbose = 0;
/* suppress assert() error messages */
void hal_log(const hal_log_level_t level, const char *format, ...)
{
}
#define DEFINE_HAL_ERROR(_code_,_text_) #_code_,
static char *err_name[] = { HAL_ERROR_LIST };
#undef DEFINE_HAL_ERROR
static void hexdump(uint8_t *buf, uint32_t len)
{
for (uint32_t i = 0; i < len; ++i) {
printf("%02x", buf[i]);
if (i < len - 1)
printf(" ");
}
}
#define test(name, result, expected) \
if ((err = result) != expected) { \
if (!verbose) printf("%s: ", func); \
printf("%s test returned %s, expected %s\n", \
name, err_name[err], err_name[expected]); \
++nerr; \
}
#define test_value(val, exp) \
if (val != exp) { \
if (!verbose) printf("%s: ", func); \
printf("value = %u, expected %u\n", val, exp); \
++nerr; \
}
#define test_len(len, exp) \
if (len != exp) { \
if (!verbose) printf("%s: ", func); \
printf("len = %lu, expected %u\n", len, exp); \
++nerr; \
}
#define test_memcmp(buf, exp, len) \
if (memcmp(buf, exp, len) != 0) { \
if (!verbose) printf("%s: ", func); \
printf("buffer = ["); \
hexdump(buf, len); \
printf("], expected ["); \
hexdump(exp, len); \
printf("]\n"); \
++nerr; \
}
#define test_bufptr(bfp, exp) \
if (bfp != exp) { \
if (!verbose) printf("%s: ", func); \
printf("buf ptr = %p, expected %p\n", bfp, exp); \
++nerr; \
}
static int test_hal_xdr_encode_int(void)
{
hal_error_t err = HAL_OK;
int nerr = 0;
uint8_t *null = NULL;
uint8_t buf[4] = {0};
uint8_t *bufptr = buf;
uint8_t *limit = buf + sizeof(buf);
uint8_t exp[4] = { 0x00, 0x11, 0x22, 0x33 };
uint32_t value = 0x00112233;
const char *func = "hal_xdr_encode_int";
if (verbose)
printf("%s... ", func);
test("null outbuf", hal_xdr_encode_int(NULL, limit, value), HAL_ERROR_ASSERTION_FAILED);
test("null outbuf", hal_xdr_encode_int(&null, limit, value), HAL_ERROR_ASSERTION_FAILED);
test("null limit", hal_xdr_encode_int(&bufptr, NULL, value), HAL_ERROR_ASSERTION_FAILED);
test("outbuf overflow", hal_xdr_encode_int(&bufptr, buf, value), HAL_ERROR_XDR_BUFFER_OVERFLOW);
test("outbuf overflow", hal_xdr_encode_int(&bufptr, buf + 3, value), HAL_ERROR_XDR_BUFFER_OVERFLOW);
test("valid write", hal_xdr_encode_int(&bufptr, limit, value), HAL_OK);
test_memcmp(buf, exp, sizeof(exp));
test_bufptr(bufptr, buf + 4);
if (verbose && nerr == 0)
printf("PASS\n");
return nerr;
}
static int test_hal_xdr_decode_int(void)
{
hal_error_t err = HAL_OK;
int nerr = 0;
const uint8_t *null = NULL;
const uint8_t buf[4] = { 0x00, 0x11, 0x22, 0x33 };
const uint8_t *bufptr = buf;
const uint8_t * const limit = buf + sizeof(buf);
uint32_t value = 0;
const uint32_t exp = 0x00112233;
const char *func = "hal_xdr_decode_int";
if (verbose)
printf("%s... ", func);
test("null inbuf", hal_xdr_decode_int(NULL, limit, &value), HAL_ERROR_ASSERTION_FAILED);
test("null inbuf", hal_xdr_decode_int(&null, limit, &value), HAL_ERROR_ASSERTION_FAILED);
test("null limit", hal_xdr_decode_int(&bufptr, NULL, &value), HAL_ERROR_ASSERTION_FAILED);
test("null value", hal_xdr_decode_int(&bufptr, limit, NULL), HAL_ERROR_ASSERTION_FAILED);
test("inbuf overflow", hal_xdr_decode_int(&bufptr, buf, &value), HAL_ERROR_XDR_BUFFER_OVERFLOW);
test("inbuf overflow", hal_xdr_decode_int(&bufptr, buf + 3, &value), HAL_ERROR_XDR_BUFFER_OVERFLOW);
test("valid read", hal_xdr_decode_int(&bufptr, limit, &value), HAL_OK);
test_value(value, exp);
test_bufptr(bufptr, buf + 4);
if (verbose && nerr == 0)
printf("PASS\n");
return nerr;
}
static int test_hal_xdr_decode_int_peek(void)
{
hal_error_t err = HAL_OK;
int nerr = 0;
const uint8_t buf[4] = { 0x00, 0x11, 0x22, 0x33 };
const uint8_t *bufptr = buf;
const uint8_t * const limit = buf + sizeof(buf);
uint32_t value = 0;
const uint32_t exp = 0x00112233;
const char *func = "hal_xdr_decode_int_peek";
if (verbose)
printf("%s... ", func);
test("valid read", hal_xdr_decode_int_peek(&bufptr, limit, &value), HAL_OK);
test_value(value, exp);
test_bufptr(bufptr, buf);
if (verbose && nerr == 0)
printf("PASS\n");
return nerr;
}
static int test_hal_xdr_encode_fixed_opaque(void)
{
hal_error_t err = HAL_OK;
int nerr = 0;
uint8_t *null = NULL;
uint8_t buf[8];
uint8_t *bufptr = buf;
uint8_t *limit = buf + sizeof(buf);
uint8_t src[8] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
uint8_t exp3[4] = { 0x00, 0x11, 0x22, 0x00 };
uint8_t exp4[4] = { 0x00, 0x11, 0x22, 0x33 };
uint8_t exp5[8] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x00, 0x00, 0x00 };
const char *func = "hal_xdr_encode_fixed_opaque";
if (verbose)
printf("%s... ", func);
test("null outbuf", hal_xdr_encode_fixed_opaque(NULL, limit, src, sizeof(src)), HAL_ERROR_ASSERTION_FAILED);
test("null outbuf", hal_xdr_encode_fixed_opaque(&null, limit, src, sizeof(src)), HAL_ERROR_ASSERTION_FAILED);
test("null limit", hal_xdr_encode_fixed_opaque(&bufptr, NULL, src, sizeof(src)), HAL_ERROR_ASSERTION_FAILED);
test("null value", hal_xdr_encode_fixed_opaque(&bufptr, limit, NULL, sizeof(src)), HAL_ERROR_ASSERTION_FAILED);
test("outbuf overflow", hal_xdr_encode_fixed_opaque(&bufptr, buf, src, sizeof(src)), HAL_ERROR_XDR_BUFFER_OVERFLOW);
memset(buf, 0xff, sizeof(buf));
test("write 3", hal_xdr_encode_fixed_opaque(&bufptr, limit, src, 3), HAL_OK);
test_memcmp(buf, exp3, sizeof(exp3));
test_bufptr(bufptr, buf + 4);
bufptr = buf;
memset(buf, 0xff, sizeof(buf));
test("write 4", hal_xdr_encode_fixed_opaque(&bufptr, limit, src, 4), HAL_OK);
test_memcmp(buf, exp4, sizeof(exp4));
test_bufptr(bufptr, buf + 4)
bufptr = buf;
memset(buf, 0xff, sizeof(buf));
test("write 5", hal_xdr_encode_fixed_opaque(&bufptr, limit, src, 5), HAL_OK);
test_memcmp(buf, exp5, sizeof(exp5));
test_bufptr(bufptr, buf + 8);
bufptr = buf;
memset(buf, 0xff, sizeof(buf));
test("write 8", hal_xdr_encode_fixed_opaque(&bufptr, limit, src, 8), HAL_OK);
test_memcmp(buf, src, sizeof(src));
test_bufptr(bufptr, buf + 8)
if (verbose && nerr == 0)
printf("PASS\n");
return nerr;
}
static int test_hal_xdr_decode_fixed_opaque(void)
{
hal_error_t err = HAL_OK;
int nerr = 0;
const uint8_t *null = NULL;
const uint8_t buf[8] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
const uint8_t *bufptr = buf;
const uint8_t *limit = buf + sizeof(buf);
uint8_t value[8];
uint8_t exp3[4] = { 0x00, 0x11, 0x22, 0x00 };
uint8_t exp4[4] = { 0x00, 0x11, 0x22, 0x33 };
uint8_t exp5[8] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x00, 0x00, 0x00 };
const char *func = "hal_xdr_decode_fixed_opaque";
if (verbose)
printf("%s... ", func);
test("null inbuf", hal_xdr_decode_fixed_opaque(NULL, limit, value, sizeof(value)), HAL_ERROR_ASSERTION_FAILED);
test("null inbuf", hal_xdr_decode_fixed_opaque(&null, limit, value, sizeof(value)), HAL_ERROR_ASSERTION_FAILED);
test("null limit", hal_xdr_decode_fixed_opaque(&bufptr, NULL, value, sizeof(value)), HAL_ERROR_ASSERTION_FAILED);
test("null value", hal_xdr_decode_fixed_opaque(&bufptr, limit, NULL, sizeof(value)), HAL_ERROR_ASSERTION_FAILED);
test("inbuf overflow", hal_xdr_decode_fixed_opaque(&bufptr, buf, value, sizeof(value)), HAL_ERROR_XDR_BUFFER_OVERFLOW);
memset(value, 0xff, sizeof(value));
test("read 3", hal_xdr_decode_fixed_opaque(&bufptr, limit, value, 3), HAL_OK);
test_memcmp(value, exp3, sizeof(exp3));
test_bufptr(bufptr, buf + 4);
bufptr = buf;
memset(value, 0xff, sizeof(value));
test("read 4", hal_xdr_decode_fixed_opaque(&bufptr, limit, value, 4), HAL_OK);
test_memcmp(value, exp4, sizeof(exp4));
test_bufptr(bufptr, buf + 4);
bufptr = buf;
memset(value, 0xff, sizeof(value));
test("read 5", hal_xdr_decode_fixed_opaque(&bufptr, limit, value, 5), HAL_OK);
test_memcmp(value, exp5, sizeof(exp5));
test_bufptr(bufptr, buf + 8);
if (verbose && nerr == 0)
printf("PASS\n");
return nerr;
}
static int test_hal_xdr_encode_variable_opaque(void)
{
hal_error_t err = HAL_OK;
int nerr = 0;
uint8_t *null = NULL;
uint8_t buf[12];
uint8_t *bufptr = buf;
uint8_t *limit = buf + sizeof(buf);
uint8_t src[8] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
uint8_t exp3[8] = { 0x00, 0x00, 0x00, 0x03, 0x00, 0x11, 0x22, 0x00 };
uint8_t exp4[8] = { 0x00, 0x00, 0x00, 0x04, 0x00, 0x11, 0x22, 0x33 };
uint8_t exp5[12] = { 0x00, 0x00, 0x00, 0x05, 0x00, 0x11, 0x22, 0x33, 0x44, 0x00, 0x00, 0x00 };
uint8_t exp8[12] = { 0x00, 0x00, 0x00, 0x08, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
const char *func = "hal_xdr_encode_variable_opaque";
if (verbose)
printf("%s... ", func);
test("null outbuf", hal_xdr_encode_variable_opaque(NULL, limit, src, sizeof(src)), HAL_ERROR_ASSERTION_FAILED);
test("null outbuf", hal_xdr_encode_variable_opaque(&null, limit, src, sizeof(src)), HAL_ERROR_ASSERTION_FAILED);
test("null limit", hal_xdr_encode_variable_opaque(&bufptr, NULL, src, sizeof(src)), HAL_ERROR_ASSERTION_FAILED);
test("null value", hal_xdr_encode_variable_opaque(&bufptr, limit, NULL, sizeof(src)), HAL_ERROR_ASSERTION_FAILED);
test("outbuf overflow", hal_xdr_encode_variable_opaque(&bufptr, buf, src, sizeof(src)), HAL_ERROR_XDR_BUFFER_OVERFLOW);
memset(buf, 0xff, sizeof(buf));
test("write 3", hal_xdr_encode_variable_opaque(&bufptr, limit, src, 3), HAL_OK);
test_memcmp(buf, exp3, sizeof(exp3));
test_bufptr(bufptr, buf + 8);
bufptr = buf;
memset(buf, 0xff, sizeof(buf));
test("write 4", hal_xdr_encode_variable_opaque(&bufptr, limit, src, 4), HAL_OK);
test_memcmp(buf, exp4, sizeof(exp4));
test_bufptr(bufptr, buf + 8)
bufptr = buf;
memset(buf, 0xff, sizeof(buf));
test("write 5", hal_xdr_encode_variable_opaque(&bufptr, limit, src, 5), HAL_OK);
test_memcmp(buf, exp5, sizeof(exp5));
test_bufptr(bufptr, buf + 12);
bufptr = buf;
memset(buf, 0xff, sizeof(buf));
test("write 8", hal_xdr_encode_variable_opaque(&bufptr, limit, src, 8), HAL_OK);
test_memcmp(buf, exp8, sizeof(exp8));
test_bufptr(bufptr, buf + 12)
if (verbose && nerr == 0)
printf("PASS\n");
return nerr;
}
static int test_hal_xdr_decode_variable_opaque(void)
{
hal_error_t err = HAL_OK;
int nerr = 0;
const uint8_t *null = NULL;
uint8_t buf[12] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
const uint8_t *bufptr = buf;
const uint8_t *limit = buf + sizeof(buf);
uint8_t value[12];
size_t len;
uint8_t exp3[4] = { 0x00, 0x11, 0x22, 0x00 };
uint8_t exp4[4] = { 0x00, 0x11, 0x22, 0x33 };
uint8_t exp5[8] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x00, 0x00, 0x00 };
uint8_t exp8[8] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
const char *func = "hal_xdr_decode_variable_opaque";
if (verbose)
printf("%s... ", func);
test("null inbuf", hal_xdr_decode_variable_opaque(NULL, limit, value, &len, sizeof(value)), HAL_ERROR_ASSERTION_FAILED);
test("null inbuf", hal_xdr_decode_variable_opaque(&null, limit, value, &len, sizeof(value)), HAL_ERROR_ASSERTION_FAILED);
test("null limit", hal_xdr_decode_variable_opaque(&bufptr, NULL, value, &len, sizeof(value)), HAL_ERROR_ASSERTION_FAILED);
test("null value", hal_xdr_decode_variable_opaque(&bufptr, limit, NULL, &len, sizeof(value)), HAL_ERROR_ASSERTION_FAILED);
test("inbuf overflow", hal_xdr_decode_variable_opaque(&bufptr, buf, value, &len, sizeof(value)), HAL_ERROR_XDR_BUFFER_OVERFLOW);
buf[3] = 0x03;
memset(value, 0xff, sizeof(value));
test("read 3", hal_xdr_decode_variable_opaque(&bufptr, limit, value, &len, sizeof(value)), HAL_OK);
test_len(len, 3);
test_memcmp(value, exp3, sizeof(exp3));
test_bufptr(bufptr, buf + 8);
bufptr = buf;
buf[3] = 0x04;
memset(value, 0xff, sizeof(value));
test("read 4", hal_xdr_decode_variable_opaque(&bufptr, limit, value, &len, sizeof(value)), HAL_OK);
test_len(len, 4);
test_memcmp(value, exp4, sizeof(exp4));
test_bufptr(bufptr, buf + 8);
bufptr = buf;
buf[3] = 0x05;
memset(value, 0xff, sizeof(value));
test("read 5", hal_xdr_decode_variable_opaque(&bufptr, limit, value, &len, sizeof(value)), HAL_OK);
test_len(len, 5);
test_memcmp(value, exp5, sizeof(exp5));
test_bufptr(bufptr, buf + 12);
bufptr = buf;
buf[3] = 0x08;
memset(value, 0xff, sizeof(value));
test("read 8", hal_xdr_decode_variable_opaque(&bufptr, limit, value, &len, sizeof(value)), HAL_OK);
test_len(len, 8);
test_memcmp(value, exp8, sizeof(exp8));
test_bufptr(bufptr, buf + 12);
if (verbose && nerr == 0)
printf("PASS\n");
return nerr;
}
int main(int argc, char *argv[])
{
if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'v')
verbose = 1;
int nerr = 0;
nerr += test_hal_xdr_encode_int();
nerr += test_hal_xdr_decode_int();
nerr += test_hal_xdr_decode_int_peek();
nerr += test_hal_xdr_encode_fixed_opaque();
nerr += test_hal_xdr_decode_fixed_opaque();
nerr += test_hal_xdr_encode_variable_opaque();
nerr += test_hal_xdr_decode_variable_opaque();
if (nerr)
printf("%d failures\n", nerr);
return nerr;
}
