mirror of https://github.com/getdnsapi/getdns.git
477 lines
17 KiB
C
477 lines
17 KiB
C
/*
|
||
* Copyright (c) 2013, NLNet Labs, Verisign, Inc.
|
||
* 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 names of the copyright holders 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 Verisign, Inc. 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.
|
||
*/
|
||
#ifndef _check_getdns_context_set_upstream_recursive_servers_h_
|
||
#define _check_getdns_context_set_upstream_recursive_servers_h_
|
||
|
||
/*
|
||
******************************************************************************************
|
||
* *
|
||
* T E S T S F O R G E T D N S _ C O N T E X T _ S E T _ S T U B _ R E S O L U T I O N *
|
||
* *
|
||
******************************************************************************************
|
||
*/
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_1)
|
||
{
|
||
/*
|
||
* context is NULL
|
||
* expect: GETDNS_RETURN_INVALID_PARAMETER
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
|
||
LIST_CREATE(upstream_list);
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_INVALID_PARAMETER, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
LIST_DESTROY(upstream_list);
|
||
}
|
||
END_TEST
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_2)
|
||
{
|
||
/*
|
||
* upstream_list is NULL
|
||
* expect: GETDNS_RETURN_INVALID_PARAMETER
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
CONTEXT_CREATE(TRUE);
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, NULL),
|
||
GETDNS_RETURN_INVALID_PARAMETER, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
|
||
CONTEXT_DESTROY;
|
||
}
|
||
END_TEST
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_3)
|
||
{
|
||
/*
|
||
* create upstream_list
|
||
* create context
|
||
* a dict in upstream_list does not contain getdns_bindata
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
}
|
||
END_TEST
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_4)
|
||
{
|
||
/*
|
||
* create upstream_list
|
||
* create context
|
||
* a dict in upstream_list does not contain two names
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
struct getdns_bindata address_type = { 5, (void *) "IPv4" };
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
}
|
||
END_TEST
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_5)
|
||
{
|
||
/*
|
||
* create upstream_list
|
||
* create context
|
||
* a dict in upstream_list contains names other than address_type ,
|
||
address_data, and port
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
struct getdns_bindata address_data = { 4, (void *)"\x08\x08\x08\x08" };
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
ASSERT_RC(getdns_dict_set_int(dict, "not_address_type", 100),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_int()");
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "not_address_data", &address_data),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
}
|
||
END_TEST
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_6)
|
||
{
|
||
/*
|
||
* create upstream_list
|
||
* create context
|
||
* a dict in upstream_list contains invalid address_ type (not “IPv4” or “IPv6”)
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
struct getdns_bindata address_type = { 5, (void *)"IPv5" };
|
||
struct getdns_bindata address_data = { 4, (void *)"\x08\x08\x08\x08" };
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
}
|
||
END_TEST
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_7)
|
||
{
|
||
/*
|
||
* create upstream_list
|
||
* create context
|
||
* a dict in upstream_list contains named address_type and
|
||
address_data but the data type isn’t bindata
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
ASSERT_RC(getdns_dict_set_int(dict, "address_type", 100),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_int()");
|
||
|
||
ASSERT_RC(getdns_dict_set_int(dict, "address_data", 200),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_int()");
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
}
|
||
END_TEST
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_8)
|
||
{
|
||
/*
|
||
* create upstream_list
|
||
* create context
|
||
* a dict in upstream_list contains invalid address_data
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
struct getdns_bindata address_type = { 5, (void *)"IPv5" };
|
||
struct getdns_bindata address_data = { 4, (void *)"\x08\x08\x08\x08" };
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_CONTEXT_UPDATE_FAIL, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
}
|
||
END_TEST
|
||
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_9)
|
||
{
|
||
/*
|
||
* create context
|
||
* Call getdns_list_create() to create a list
|
||
* Call getdns_dict_create() to create a list
|
||
* Create bindata containing “IPv4”
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
struct getdns_dict *response = NULL;
|
||
struct getdns_bindata address_type = { 4, (void *)"IPv4" };
|
||
struct getdns_bindata address_data = { 4, (void *)"\x08\x08\x08\x08" };
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
ASSERT_RC(getdns_general_sync(context, "google.com", GETDNS_RRTYPE_A, NULL, &response),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_general_sync()");
|
||
|
||
|
||
EXTRACT_RESPONSE;
|
||
|
||
assert_noerror(&ex_response);
|
||
assert_address_in_answer(&ex_response, TRUE, FALSE);
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
DICT_DESTROY(response);
|
||
}
|
||
END_TEST
|
||
|
||
/* This test disabled because travis does not support IPv6 in their
|
||
* container based infrastructure!
|
||
*/
|
||
#if 0
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_10)
|
||
{
|
||
/*
|
||
* create context
|
||
* Call getdns_list_create() to create a list
|
||
* Call getdns_dict_create() to create a list
|
||
* Create bindata containing “IPv6”
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
struct getdns_dict *response = NULL;
|
||
struct getdns_bindata address_type = { 5, (void *)"IPv6" };
|
||
struct getdns_bindata address_data = { 16, (void *)"\x26\x20\x00\x74\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x01\x00\x01" };
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
ASSERT_RC(getdns_general_sync(context, "google.com", GETDNS_RRTYPE_A, NULL, &response),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_general_sync()");
|
||
|
||
EXTRACT_RESPONSE;
|
||
|
||
assert_noerror(&ex_response);
|
||
assert_address_in_answer(&ex_response, TRUE, FALSE);
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
DICT_DESTROY(response);
|
||
}
|
||
END_TEST
|
||
#endif
|
||
START_TEST (getdns_context_set_upstream_recursive_servers_11)
|
||
{
|
||
/*
|
||
* create context
|
||
* Call getdns_list_create() to create a list
|
||
* Call getdns_dict_create() to create a list
|
||
* Create bindata containing “IPv4”
|
||
*/
|
||
|
||
struct getdns_context *context = NULL;
|
||
struct getdns_list *upstream_list = NULL;
|
||
struct getdns_dict *dict = NULL;
|
||
struct getdns_dict *response = NULL;
|
||
struct getdns_bindata address_type = { 4, (void *)"IPv4" };
|
||
struct getdns_bindata address_data = { 4, (void *)"\x08\x08\x08\x08" };
|
||
struct getdns_bindata port = { 3, (void *)"53" };
|
||
size_t index = 0;
|
||
|
||
CONTEXT_CREATE(TRUE);
|
||
LIST_CREATE(upstream_list);
|
||
DICT_CREATE(dict);
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_type", &address_type),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "address_data", &address_data),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_dict_set_bindata(dict, "53", &port),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_dict_set_bindata()");
|
||
|
||
ASSERT_RC(getdns_list_set_dict(upstream_list, index, dict), GETDNS_RETURN_GOOD,
|
||
"Return code from getdns_list_set_dict()");
|
||
|
||
|
||
ASSERT_RC(getdns_context_set_upstream_recursive_servers(context, upstream_list),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_context_set_upstream_recursive_servers()");
|
||
|
||
ASSERT_RC(getdns_general_sync(context, "google.com", GETDNS_RRTYPE_A, NULL, &response),
|
||
GETDNS_RETURN_GOOD, "Return code from getdns_general_sync()");
|
||
|
||
|
||
EXTRACT_RESPONSE;
|
||
printf("the resp is %s\n", getdns_pretty_print_dict(response));
|
||
|
||
|
||
assert_noerror(&ex_response);
|
||
assert_address_in_answer(&ex_response, TRUE, FALSE);
|
||
|
||
CONTEXT_DESTROY;
|
||
LIST_DESTROY(upstream_list);
|
||
DICT_DESTROY(dict);
|
||
DICT_DESTROY(response);
|
||
}
|
||
END_TEST
|
||
|
||
|
||
|
||
|
||
Suite *
|
||
getdns_context_set_upstream_recursive_servers_suite (void)
|
||
{
|
||
Suite *s = suite_create ("getdns_context_set_upstream_recursive_servers()");
|
||
|
||
/* Negative test caseis */
|
||
TCase *tc_neg = tcase_create("Negative");
|
||
tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_1);
|
||
tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_2);
|
||
tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_3);
|
||
tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_4);
|
||
tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_5);
|
||
tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_6);
|
||
tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_7);
|
||
tcase_add_test(tc_neg, getdns_context_set_upstream_recursive_servers_8);
|
||
|
||
suite_add_tcase(s, tc_neg);
|
||
|
||
/* Positive test cases */
|
||
TCase *tc_pos = tcase_create("Positive");
|
||
tcase_add_test(tc_pos, getdns_context_set_upstream_recursive_servers_9);
|
||
/***** tcase_add_test(tc_pos, getdns_context_set_upstream_recursive_servers_10); *****/
|
||
tcase_add_test(tc_pos, getdns_context_set_upstream_recursive_servers_11);
|
||
|
||
suite_add_tcase(s, tc_pos);
|
||
|
||
return s;
|
||
|
||
}
|
||
|
||
#endif
|