/* Test ns_name-related functions.
Copyright (C) 2017-2018 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with the GNU C Library; if not, see
<http://www.gnu.org/licenses/>. */
/* This test program processes the tst-ns_name.data file. */
#include <ctype.h>
#include <resolv.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <support/check.h>
#include <support/support.h>
#include <support/xstdio.h>
/* A byte buffer and its length. */
struct buffer
{
unsigned char *data;
size_t length;
};
/* Convert a base64-encoded string to its binary representation. */
static bool
base64_to_buffer (const char *base64, struct buffer *result)
{
/* "-" denotes an empty input. */
if (strcmp (base64, "-") == 0)
{
result->data = xmalloc (1);
result->length = 0;
return true;
}
size_t size = strlen (base64);
unsigned char *data = xmalloc (size);
int ret = b64_pton (base64, data, size);
if (ret < 0 || ret > size)
return false;
result->data = xrealloc (data, ret);
result->length = ret;
return true;
}
/* A test case for ns_name_unpack and ns_name_ntop. */
struct test_case
{
char *path;
size_t lineno;
struct buffer input;
size_t input_offset;
int unpack_result;
struct buffer unpack_output;
int ntop_result;
char *ntop_text;
};
/* Deallocate the buffers associated with the test case. */
static void
free_test_case (struct test_case *t)
{
free (t->path);
free (t->input.data);
free (t->unpack_output.data);
free (t->ntop_text);
}
/* Extract the test case information from a test file line. */
static bool
parse_test_case (const char *path, size_t lineno, const char *line,
struct test_case *result)
{
memset (result, 0, sizeof (*result));
result->path = xstrdup (path);
result->lineno = lineno;
result->ntop_result = -1;
char *input = NULL;
char *unpack_output = NULL;
int ret = sscanf (line, "%ms %zu %d %ms %d %ms",
&input, &result->input_offset,
&result->unpack_result, &unpack_output,
&result->ntop_result, &result->ntop_text);
if (ret < 3)
{
printf ("%s:%zu: error: missing input fields\n", path, lineno);
free (input);
return false;
}
if (!base64_to_buffer (input, &result->input))
{
printf ("%s:%zu: error: malformed base64 input data\n", path, lineno);
free (input);
free (unpack_output);
free (result->ntop_text);
return false;
}
free (input);
if (unpack_output == NULL)
result->unpack_output = (struct buffer) { NULL, 0 };
else if (!base64_to_buffer (unpack_output, &result->unpack_output))
{
printf ("%s:%zu: error: malformed base64 unpack data\n", path, lineno);
free (result->input.data);
free (unpack_output);
free (result->ntop_text);
return false;
}
free (unpack_output);
/* At this point, all allocated buffers have been transferred to
*result. */
if (result->input_offset > result->input.length)
{
printf ("%s:%zu: error: input offset %zu exceeds buffer size %zu\n",
path, lineno, result->input_offset, result->input.length);
free_test_case (result);
return false;
}
if (result->unpack_result < -1)
{
printf ("%s:%zu: error: invalid unpack result %d\n",
path, lineno, result->unpack_result);
free_test_case (result);
return false;
}
if (result->ntop_result < -1)
{
printf ("%s:%zu: error: invalid ntop result %d\n",
path, lineno, result->ntop_result);
free_test_case (result);
return false;
}
bool fields_consistent;
switch (ret)
{
case 3:
fields_consistent = result->unpack_result == -1;
break;
case 5:
fields_consistent = result->unpack_result != -1
&& result->ntop_result == -1;
break;
case 6:
fields_consistent = result->unpack_result != -1
&& result->ntop_result != -1;
break;
default:
fields_consistent = false;
}
if (!fields_consistent)
{
printf ("%s:%zu: error: wrong number of fields: %d\n",
path, lineno, ret);
free_test_case (result);
return false;
}
return true;
}
/* Format the buffer as a hexadecimal string and write it to standard
output. */
static void
print_hex (const char *label, struct buffer buffer)
{
printf (" %s ", label);
unsigned char *p = buffer.data;
unsigned char *end = p + buffer.length;
while (p < end)
{
printf ("%02X", *p & 0xFF);
++p;
}
putchar ('\n');
}
/* Run the test case specified in *T. */
static void
run_test_case (struct test_case *t)
{
/* Test ns_name_unpack. */
unsigned char *unpacked = xmalloc (NS_MAXCDNAME);
int consumed = ns_name_unpack
(t->input.data, t->input.data + t->input.length,
t->input.data + t->input_offset,
unpacked, NS_MAXCDNAME);
if (consumed != t->unpack_result)
{
support_record_failure ();
printf ("%s:%zu: error: wrong result from ns_name_unpack\n"
" expected: %d\n"
" actual: %d\n",
t->path, t->lineno, t->unpack_result, consumed);
return;
}
if (consumed != -1)
{
if (memcmp (unpacked, t->unpack_output.data,
t->unpack_output.length) != 0)
{
support_record_failure ();
printf ("%s:%zu: error: wrong data from ns_name_unpack\n",
t->path, t->lineno);
print_hex ("expected:", t->unpack_output);
print_hex ("actual: ",
(struct buffer) { unpacked, t->unpack_output.length });
return;
}
/* Test ns_name_ntop. */
char *text = xmalloc (NS_MAXDNAME);
int ret = ns_name_ntop (unpacked, text, NS_MAXDNAME);
if (ret != t->ntop_result)
{
support_record_failure ();
printf ("%s:%zu: error: wrong result from ns_name_top\n"
" expected: %d\n"
" actual: %d\n",
t->path, t->lineno, t->ntop_result, ret);
return;
}
if (ret != -1)
{
if (strcmp (text, t->ntop_text) != 0)
{
support_record_failure ();
printf ("%s:%zu: error: wrong data from ns_name_ntop\n",
t->path, t->lineno);
printf (" expected: \"%s\"\n", t->ntop_text);
printf (" actual: \"%s\"\n", text);
return;
}
/* Test ns_name_pton. Unpacking does not check the
NS_MAXCDNAME limit, but packing does, so we need to
adjust the expected result. */
int expected;
if (t->unpack_output.length > NS_MAXCDNAME)
expected = -1;
else if (strcmp (text, ".") == 0)
/* The root domain is fully qualified. */
expected = 1;
else
/* The domain name is never fully qualified. */
expected = 0;
unsigned char *repacked = xmalloc (NS_MAXCDNAME);
ret = ns_name_pton (text, repacked, NS_MAXCDNAME);
if (ret != expected)
{
support_record_failure ();
printf ("%s:%zu: error: wrong result from ns_name_pton\n"
" expected: %d\n"
" actual: %d\n",
t->path, t->lineno, expected, ret);
return;
}
if (ret >= 0
&& memcmp (repacked, unpacked, t->unpack_output.length) != 0)
{
support_record_failure ();
printf ("%s:%zu: error: wrong data from ns_name_pton\n",
t->path, t->lineno);
print_hex ("expected:", t->unpack_output);
print_hex ("actual: ",
(struct buffer) { repacked, t->unpack_output.length });
return;
}
/* Test ns_name_compress, no compression case. */
if (t->unpack_output.length > NS_MAXCDNAME)
expected = -1;
else
expected = t->unpack_output.length;
memset (repacked, '$', NS_MAXCDNAME);
{
enum { ptr_count = 5 };
const unsigned char *dnptrs[ptr_count] = { repacked, };
ret = ns_name_compress (text, repacked, NS_MAXCDNAME,
dnptrs, dnptrs + ptr_count);
if (ret != expected)
{
support_record_failure ();
printf ("%s:%zu: error: wrong result from ns_name_compress\n"
" expected: %d\n"
" actual: %d\n",
t->path, t->lineno, expected, ret);
return;
}
if (ret < 0)
{
TEST_VERIFY (dnptrs[0] == repacked);
TEST_VERIFY (dnptrs[1] == NULL);
}
else
{
if (memcmp (repacked, unpacked, t->unpack_output.length) != 0)
{
support_record_failure ();
printf ("%s:%zu: error: wrong data from ns_name_compress\n",
t->path, t->lineno);
print_hex ("expected:", t->unpack_output);
print_hex ("actual: ", (struct buffer) { repacked, ret });
return;
}
TEST_VERIFY (dnptrs[0] == repacked);
if (unpacked[0] == '\0')
/* The root domain is not a compression target. */
TEST_VERIFY (dnptrs[1] == NULL);
else
{
TEST_VERIFY (dnptrs[1] == repacked);
TEST_VERIFY (dnptrs[2] == NULL);
}
}
}
/* Test ns_name_compress, full compression case. Skip this
test for invalid names and the root domain. */
if (expected >= 0 && unpacked[0] != '\0')
{
/* The destination buffer needs additional room for the
offset, the initial name, and the compression
reference. */
enum { name_offset = 259 };
size_t target_offset = name_offset + t->unpack_output.length;
size_t repacked_size = target_offset + 2;
repacked = xrealloc (repacked, repacked_size);
memset (repacked, '@', repacked_size);
memcpy (repacked + name_offset,
t->unpack_output.data, t->unpack_output.length);
enum { ptr_count = 5 };
const unsigned char *dnptrs[ptr_count]
= { repacked, repacked + name_offset, };
ret = ns_name_compress
(text, repacked + target_offset, NS_MAXCDNAME,
dnptrs, dnptrs + ptr_count);
if (ret != 2)
{
support_record_failure ();
printf ("%s:%zu: error: wrong result from ns_name_compress"
" (2)\n"
" expected: 2\n"
" actual: %d\n",
t->path, t->lineno, ret);
return;
}
if (memcmp (repacked + target_offset, "\xc1\x03", 2) != 0)
{
support_record_failure ();
printf ("%s:%zu: error: wrong data from ns_name_compress"
" (2)\n"
" expected: C103\n",
t->path, t->lineno);
print_hex ("actual: ",
(struct buffer) { repacked + target_offset, ret });
return;
}
TEST_VERIFY (dnptrs[0] == repacked);
TEST_VERIFY (dnptrs[1] == repacked + name_offset);
TEST_VERIFY (dnptrs[2] == NULL);
}
free (repacked);
}
free (text);
}
free (unpacked);
}
/* Open the file at PATH, parse the test cases contained in it, and
run them. */
static void
run_test_file (const char *path)
{
FILE *fp = xfopen (path, "re");
char *line = NULL;
size_t line_allocated = 0;
size_t lineno = 0;
while (true)
{
ssize_t ret = getline (&line, &line_allocated, fp);
if (ret < 0)
{
if (ferror (fp))
{
printf ("%s: error reading file: %m\n", path);
exit (1);
}
TEST_VERIFY (feof (fp));
break;
}
++lineno;
char *p = line;
while (isspace (*p))
++p;
if (*p == '\0' || *p == '#')
continue;
struct test_case test_case;
if (!parse_test_case (path, lineno, line, &test_case))
{
support_record_failure ();
continue;
}
run_test_case (&test_case);
free_test_case (&test_case);
}
free (line);
xfclose (fp);
}
static int
do_test (void)
{
run_test_file ("tst-ns_name.data");
return 0;
}
#include <support/test-driver.c>