2019-01-16 18:32:32 +01:00
|
|
|
/* Copyright (c) 2014-2019, The Tor Project, Inc. */
|
2017-10-27 16:59:36 +02:00
|
|
|
/* See LICENSE for licensing information */
|
|
|
|
|
2014-08-27 12:41:25 +02:00
|
|
|
#define ROUTERSET_PRIVATE
|
|
|
|
|
2018-07-05 22:34:59 +02:00
|
|
|
#include "core/or/or.h"
|
|
|
|
#include "core/or/policies.h"
|
2018-10-01 18:08:09 +02:00
|
|
|
#include "feature/dirparse/policy_parse.h"
|
2018-07-05 22:34:59 +02:00
|
|
|
#include "feature/nodelist/nodelist.h"
|
2018-10-01 18:08:09 +02:00
|
|
|
#include "feature/nodelist/routerset.h"
|
|
|
|
#include "lib/geoip/geoip.h"
|
2018-07-05 22:34:59 +02:00
|
|
|
|
|
|
|
#include "core/or/addr_policy_st.h"
|
|
|
|
#include "core/or/extend_info_st.h"
|
|
|
|
#include "feature/nodelist/node_st.h"
|
|
|
|
#include "feature/nodelist/routerinfo_st.h"
|
|
|
|
#include "feature/nodelist/routerstatus_st.h"
|
2018-06-20 15:35:05 +02:00
|
|
|
|
|
|
|
#include "test/test.h"
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
#define NS_MODULE routerset
|
|
|
|
|
|
|
|
#define NS_SUBMODULE routerset_new
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional (blackbox) test to determine that each member of the routerset
|
|
|
|
* is non-NULL
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *rs;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
rs = routerset_new();
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(rs, OP_NE, NULL);
|
|
|
|
tt_ptr_op(rs->list, OP_NE, NULL);
|
|
|
|
tt_ptr_op(rs->names, OP_NE, NULL);
|
|
|
|
tt_ptr_op(rs->digests, OP_NE, NULL);
|
|
|
|
tt_ptr_op(rs->policies, OP_NE, NULL);
|
|
|
|
tt_ptr_op(rs->country_names, OP_NE, NULL);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(rs);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_get_countryname
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test to strip the braces from a "{xx}" country code string.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
const char *input;
|
|
|
|
char *name;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
/* strlen(c) < 4 */
|
|
|
|
input = "xxx";
|
|
|
|
name = routerset_get_countryname(input);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(name, OP_EQ, NULL);
|
2014-08-27 12:41:25 +02:00
|
|
|
tor_free(name);
|
|
|
|
|
|
|
|
/* c[0] != '{' */
|
|
|
|
input = "xxx}";
|
|
|
|
name = routerset_get_countryname(input);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(name, OP_EQ, NULL);
|
2014-08-27 12:41:25 +02:00
|
|
|
tor_free(name);
|
|
|
|
|
|
|
|
/* c[3] != '}' */
|
|
|
|
input = "{xxx";
|
|
|
|
name = routerset_get_countryname(input);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(name, OP_EQ, NULL);
|
2014-08-27 12:41:25 +02:00
|
|
|
tor_free(name);
|
|
|
|
|
|
|
|
/* tor_strlower */
|
|
|
|
input = "{XX}";
|
|
|
|
name = routerset_get_countryname(input);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(name, OP_EQ, "xx");
|
2014-08-27 12:41:25 +02:00
|
|
|
tor_free(name);
|
|
|
|
|
|
|
|
input = "{xx}";
|
|
|
|
name = routerset_get_countryname(input);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(name, OP_EQ, "xx");
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
tor_free(name);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_refresh_counties, geoip_not_loaded)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural (whitebox) test for routerset_refresh_counties, when the GeoIP DB
|
|
|
|
* is not loaded.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(int, geoip_is_loaded, (sa_family_t family));
|
|
|
|
NS_DECL(int, geoip_get_n_countries, (void));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(geoip_is_loaded);
|
|
|
|
NS_MOCK(geoip_get_n_countries);
|
|
|
|
|
|
|
|
routerset_refresh_countries(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(set->countries, OP_EQ, NULL);
|
|
|
|
tt_int_op(set->n_countries, OP_EQ, 0);
|
|
|
|
tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
NS_UNMOCK(geoip_is_loaded);
|
|
|
|
NS_UNMOCK(geoip_get_n_countries);
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
NS(geoip_is_loaded)(sa_family_t family)
|
|
|
|
{
|
|
|
|
(void)family;
|
|
|
|
CALLED(geoip_is_loaded)++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
NS(geoip_get_n_countries)(void)
|
|
|
|
{
|
|
|
|
CALLED(geoip_get_n_countries)++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_refresh_counties, no_countries)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_refresh_counties, when there are no countries.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(int, geoip_is_loaded, (sa_family_t family));
|
|
|
|
NS_DECL(int, geoip_get_n_countries, (void));
|
|
|
|
NS_DECL(country_t, geoip_get_country, (const char *country));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(geoip_is_loaded);
|
|
|
|
NS_MOCK(geoip_get_n_countries);
|
|
|
|
NS_MOCK(geoip_get_country);
|
|
|
|
|
|
|
|
routerset_refresh_countries(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(set->countries, OP_NE, NULL);
|
|
|
|
tt_int_op(set->n_countries, OP_EQ, 1);
|
|
|
|
tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);
|
|
|
|
tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_country), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
NS_UNMOCK(geoip_is_loaded);
|
|
|
|
NS_UNMOCK(geoip_get_n_countries);
|
|
|
|
NS_UNMOCK(geoip_get_country);
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
NS(geoip_is_loaded)(sa_family_t family)
|
|
|
|
{
|
|
|
|
(void)family;
|
|
|
|
CALLED(geoip_is_loaded)++;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
NS(geoip_get_n_countries)(void)
|
|
|
|
{
|
|
|
|
CALLED(geoip_get_n_countries)++;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static country_t
|
|
|
|
NS(geoip_get_country)(const char *countrycode)
|
|
|
|
{
|
|
|
|
(void)countrycode;
|
|
|
|
CALLED(geoip_get_country)++;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_refresh_counties, one_valid_country)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_refresh_counties, with one valid country.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(int, geoip_is_loaded, (sa_family_t family));
|
|
|
|
NS_DECL(int, geoip_get_n_countries, (void));
|
|
|
|
NS_DECL(country_t, geoip_get_country, (const char *country));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(geoip_is_loaded);
|
|
|
|
NS_MOCK(geoip_get_n_countries);
|
|
|
|
NS_MOCK(geoip_get_country);
|
|
|
|
smartlist_add(set->country_names, tor_strndup("foo", 3));
|
|
|
|
|
|
|
|
routerset_refresh_countries(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(set->countries, OP_NE, NULL);
|
|
|
|
tt_int_op(set->n_countries, OP_EQ, 2);
|
|
|
|
tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_country), OP_EQ, 1);
|
|
|
|
tt_int_op((unsigned int)(*set->countries), OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
NS_UNMOCK(geoip_is_loaded);
|
|
|
|
NS_UNMOCK(geoip_get_n_countries);
|
|
|
|
NS_UNMOCK(geoip_get_country);
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
NS(geoip_is_loaded)(sa_family_t family)
|
|
|
|
{
|
|
|
|
(void)family;
|
|
|
|
CALLED(geoip_is_loaded)++;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
NS(geoip_get_n_countries)(void)
|
|
|
|
{
|
|
|
|
CALLED(geoip_get_n_countries)++;
|
|
|
|
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static country_t
|
|
|
|
NS(geoip_get_country)(const char *countrycode)
|
|
|
|
{
|
|
|
|
(void)countrycode;
|
|
|
|
CALLED(geoip_get_country)++;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_refresh_counties, one_invalid_country)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_refresh_counties, with one invalid
|
|
|
|
* country code..
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(int, geoip_is_loaded, (sa_family_t family));
|
|
|
|
NS_DECL(int, geoip_get_n_countries, (void));
|
|
|
|
NS_DECL(country_t, geoip_get_country, (const char *country));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(geoip_is_loaded);
|
|
|
|
NS_MOCK(geoip_get_n_countries);
|
|
|
|
NS_MOCK(geoip_get_country);
|
|
|
|
smartlist_add(set->country_names, tor_strndup("foo", 3));
|
|
|
|
|
|
|
|
routerset_refresh_countries(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(set->countries, OP_NE, NULL);
|
|
|
|
tt_int_op(set->n_countries, OP_EQ, 2);
|
|
|
|
tt_int_op(CALLED(geoip_is_loaded), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_n_countries), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_country), OP_EQ, 1);
|
|
|
|
tt_int_op((unsigned int)(*set->countries), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
NS_UNMOCK(geoip_is_loaded);
|
|
|
|
NS_UNMOCK(geoip_get_n_countries);
|
|
|
|
NS_UNMOCK(geoip_get_country);
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
NS(geoip_is_loaded)(sa_family_t family)
|
|
|
|
{
|
|
|
|
(void)family;
|
|
|
|
CALLED(geoip_is_loaded)++;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
NS(geoip_get_n_countries)(void)
|
|
|
|
{
|
|
|
|
CALLED(geoip_get_n_countries)++;
|
|
|
|
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
static country_t
|
|
|
|
NS(geoip_get_country)(const char *countrycode)
|
|
|
|
{
|
|
|
|
(void)countrycode;
|
|
|
|
CALLED(geoip_get_country)++;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_parse, malformed)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test, with a malformed string to parse.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
const char *s = "_";
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
r = routerset_parse(set, s, "");
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, -1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_parse, valid_hexdigest)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_parse, that routerset_parse returns 0
|
|
|
|
* on a valid hexdigest entry.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set;
|
|
|
|
const char *s;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
s = "$0000000000000000000000000000000000000000";
|
|
|
|
r = routerset_parse(set, s, "");
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
|
|
|
tt_int_op(digestmap_isempty(set->digests), OP_NE, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_parse, valid_nickname)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_parse, when given a valid nickname as input.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set;
|
|
|
|
const char *s;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
s = "fred";
|
|
|
|
r = routerset_parse(set, s, "");
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
|
|
|
tt_int_op(strmap_isempty(set->names), OP_NE, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_parse, get_countryname)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_parse, when given a valid countryname.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set;
|
|
|
|
const char *s;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
s = "{cc}";
|
|
|
|
r = routerset_parse(set, s, "");
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
|
|
|
tt_int_op(smartlist_len(set->country_names), OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
2015-09-14 12:16:43 +02:00
|
|
|
#define NS_SUBMODULE ASPECT(routerset_parse, policy_wildcard)
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
/*
|
2015-09-14 12:16:43 +02:00
|
|
|
* Structural test for routerset_parse, when given a valid wildcard policy.
|
2014-08-27 12:41:25 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string,
|
2015-09-11 07:10:54 +02:00
|
|
|
(const char *s, int assume_action, int *malformed_list));
|
2014-08-27 12:41:25 +02:00
|
|
|
|
2016-06-02 15:46:12 +02:00
|
|
|
static addr_policy_t *NS(mock_addr_policy);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set;
|
|
|
|
const char *s;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(router_parse_addr_policy_item_from_string);
|
2014-08-29 21:09:27 +02:00
|
|
|
NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
s = "*";
|
|
|
|
r = routerset_parse(set, s, "");
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
|
|
|
tt_int_op(smartlist_len(set->policies), OP_NE, 0);
|
|
|
|
tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_policy_t *
|
2015-09-11 07:10:54 +02:00
|
|
|
NS(router_parse_addr_policy_item_from_string)(const char *s,
|
|
|
|
int assume_action,
|
|
|
|
int *malformed_list)
|
2014-08-27 12:41:25 +02:00
|
|
|
{
|
|
|
|
(void)s;
|
|
|
|
(void)assume_action;
|
2015-09-11 07:10:54 +02:00
|
|
|
(void)malformed_list;
|
2014-08-27 12:41:25 +02:00
|
|
|
CALLED(router_parse_addr_policy_item_from_string)++;
|
|
|
|
|
|
|
|
return NS(mock_addr_policy);
|
|
|
|
}
|
|
|
|
|
2015-09-14 12:16:43 +02:00
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_parse, policy_ipv4)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_parse, when given a valid IPv4 address
|
|
|
|
* literal policy.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string,
|
2015-10-02 13:54:20 +02:00
|
|
|
(const char *s, int assume_action, int *bogus));
|
2015-09-14 12:16:43 +02:00
|
|
|
|
2016-06-02 15:46:12 +02:00
|
|
|
static addr_policy_t *NS(mock_addr_policy);
|
2015-09-14 12:16:43 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set;
|
|
|
|
const char *s;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(router_parse_addr_policy_item_from_string);
|
|
|
|
NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
|
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
s = "127.0.0.1";
|
|
|
|
r = routerset_parse(set, s, "");
|
|
|
|
tt_int_op(r, OP_EQ, 0);
|
|
|
|
tt_int_op(smartlist_len(set->policies), OP_NE, 0);
|
|
|
|
tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
|
|
|
|
|
2015-10-02 14:33:54 +02:00
|
|
|
done:
|
2015-09-14 12:16:43 +02:00
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_policy_t *
|
2015-10-02 13:54:20 +02:00
|
|
|
NS(router_parse_addr_policy_item_from_string)(const char *s, int assume_action,
|
|
|
|
int *bogus)
|
2015-09-14 12:16:43 +02:00
|
|
|
{
|
|
|
|
(void)s;
|
|
|
|
(void)assume_action;
|
|
|
|
CALLED(router_parse_addr_policy_item_from_string)++;
|
2015-10-02 13:54:20 +02:00
|
|
|
*bogus = 0;
|
2015-09-14 12:16:43 +02:00
|
|
|
|
|
|
|
return NS(mock_addr_policy);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_parse, policy_ipv6)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_parse, when given a valid IPv6 address
|
|
|
|
* literal policy.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(addr_policy_t *, router_parse_addr_policy_item_from_string,
|
2015-10-02 13:54:20 +02:00
|
|
|
(const char *s, int assume_action, int *bad));
|
2015-09-14 12:16:43 +02:00
|
|
|
|
2016-06-02 15:46:12 +02:00
|
|
|
static addr_policy_t *NS(mock_addr_policy);
|
2015-09-14 12:16:43 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set;
|
|
|
|
const char *s;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(router_parse_addr_policy_item_from_string);
|
|
|
|
NS(mock_addr_policy) = tor_malloc_zero(sizeof(addr_policy_t));
|
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
s = "::1";
|
|
|
|
r = routerset_parse(set, s, "");
|
|
|
|
tt_int_op(r, OP_EQ, 0);
|
|
|
|
tt_int_op(smartlist_len(set->policies), OP_NE, 0);
|
|
|
|
tt_int_op(CALLED(router_parse_addr_policy_item_from_string), OP_EQ, 1);
|
|
|
|
|
2015-10-02 14:33:54 +02:00
|
|
|
done:
|
2015-09-14 12:16:43 +02:00
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_policy_t *
|
2015-10-02 13:54:20 +02:00
|
|
|
NS(router_parse_addr_policy_item_from_string)(const char *s,
|
|
|
|
int assume_action, int *bad)
|
2015-09-14 12:16:43 +02:00
|
|
|
{
|
|
|
|
(void)s;
|
|
|
|
(void)assume_action;
|
|
|
|
CALLED(router_parse_addr_policy_item_from_string)++;
|
2015-10-02 13:54:20 +02:00
|
|
|
*bad = 0;
|
2015-09-14 12:16:43 +02:00
|
|
|
|
|
|
|
return NS(mock_addr_policy);
|
|
|
|
}
|
|
|
|
|
2014-08-27 12:41:25 +02:00
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_union, source_bad)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_union, when given a bad source argument.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(smartlist_t *, smartlist_new, (void));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set, *bad_set;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
bad_set = routerset_new();
|
|
|
|
smartlist_free(bad_set->list);
|
|
|
|
bad_set->list = NULL;
|
|
|
|
|
|
|
|
NS_MOCK(smartlist_new);
|
|
|
|
|
|
|
|
routerset_union(set, NULL);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
routerset_union(set, bad_set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(CALLED(smartlist_new), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
NS_UNMOCK(smartlist_new);
|
|
|
|
routerset_free(set);
|
|
|
|
|
|
|
|
/* Just recreate list, so we can simply use routerset_free. */
|
|
|
|
bad_set->list = smartlist_new();
|
|
|
|
routerset_free(bad_set);
|
|
|
|
}
|
|
|
|
|
|
|
|
static smartlist_t *
|
|
|
|
NS(smartlist_new)(void)
|
|
|
|
{
|
|
|
|
CALLED(smartlist_new)++;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_union, one)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_union.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *src = routerset_new();
|
|
|
|
routerset_t *tgt;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
tgt = routerset_new();
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(src->list, "{xx}");
|
2014-08-27 12:41:25 +02:00
|
|
|
routerset_union(tgt, src);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(smartlist_len(tgt->list), OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(src);
|
|
|
|
routerset_free(tgt);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_is_list
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional tests for routerset_is_list.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set;
|
|
|
|
addr_policy_t *policy;
|
|
|
|
int is_list;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
/* len(set->country_names) == 0, len(set->policies) == 0 */
|
|
|
|
set = routerset_new();
|
|
|
|
is_list = routerset_is_list(set);
|
|
|
|
routerset_free(set);
|
|
|
|
set = NULL;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(is_list, OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
/* len(set->country_names) != 0, len(set->policies) == 0 */
|
|
|
|
set = routerset_new();
|
|
|
|
smartlist_add(set->country_names, tor_strndup("foo", 3));
|
|
|
|
is_list = routerset_is_list(set);
|
|
|
|
routerset_free(set);
|
|
|
|
set = NULL;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(is_list, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
/* len(set->country_names) == 0, len(set->policies) != 0 */
|
|
|
|
set = routerset_new();
|
|
|
|
policy = tor_malloc_zero(sizeof(addr_policy_t));
|
|
|
|
smartlist_add(set->policies, (void *)policy);
|
|
|
|
is_list = routerset_is_list(set);
|
|
|
|
routerset_free(set);
|
|
|
|
set = NULL;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(is_list, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
/* len(set->country_names) != 0, len(set->policies) != 0 */
|
|
|
|
set = routerset_new();
|
|
|
|
smartlist_add(set->country_names, tor_strndup("foo", 3));
|
|
|
|
policy = tor_malloc_zero(sizeof(addr_policy_t));
|
|
|
|
smartlist_add(set->policies, (void *)policy);
|
|
|
|
is_list = routerset_is_list(set);
|
|
|
|
routerset_free(set);
|
|
|
|
set = NULL;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(is_list, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_needs_geoip
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional tests for routerset_needs_geoip.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
2017-11-21 15:37:47 +01:00
|
|
|
routerset_t *set;
|
2014-08-27 12:41:25 +02:00
|
|
|
int needs_geoip;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
set = NULL;
|
|
|
|
needs_geoip = routerset_needs_geoip(set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(needs_geoip, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
needs_geoip = routerset_needs_geoip(set);
|
2017-11-21 15:37:47 +01:00
|
|
|
routerset_free(set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(needs_geoip, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
set = NULL;
|
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
smartlist_add(set->country_names, tor_strndup("xx", 2));
|
|
|
|
needs_geoip = routerset_needs_geoip(set);
|
2017-11-21 15:37:47 +01:00
|
|
|
routerset_free(set);
|
2014-08-27 12:41:25 +02:00
|
|
|
set = NULL;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(needs_geoip, OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_is_empty
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional tests for routerset_is_empty.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = NULL;
|
|
|
|
int is_empty;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
is_empty = routerset_is_empty(set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(is_empty, OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
is_empty = routerset_is_empty(set);
|
|
|
|
routerset_free(set);
|
|
|
|
set = NULL;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(is_empty, OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
set = routerset_new();
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(set->list, "{xx}");
|
2014-08-27 12:41:25 +02:00
|
|
|
is_empty = routerset_is_empty(set);
|
|
|
|
routerset_free(set);
|
|
|
|
set = NULL;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(is_empty, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, null_set_or_null_set_list)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains, when given a NULL set or the
|
|
|
|
* set has a NULL list.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = NULL;
|
|
|
|
int contains;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
set = tor_malloc_zero(sizeof(routerset_t));
|
|
|
|
set->list = NULL;
|
|
|
|
contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
|
|
|
|
tor_free(set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_nickname)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains, when given a valid routerset but a
|
|
|
|
* NULL nickname.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
char *nickname = NULL;
|
|
|
|
int contains;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
contains = routerset_contains(set, NULL, 0, nickname, NULL, 0);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_nickname)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains, when given a valid routerset
|
|
|
|
* and the nickname is in the routerset.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
const char *nickname;
|
|
|
|
int contains;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
nickname = "Foo"; /* This tests the lowercase comparison as well. */
|
|
|
|
strmap_set_lc(set->names, nickname, (void *)1);
|
|
|
|
contains = routerset_contains(set, NULL, 0, nickname, NULL, 0);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 4);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_nickname)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains, when given a valid routerset
|
|
|
|
* and the nickname is not in the routerset.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int contains;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
strmap_set_lc(set->names, "bar", (void *)1);
|
|
|
|
contains = routerset_contains(set, NULL, 0, "foo", NULL, 0);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_digest)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains, when given a valid routerset
|
|
|
|
* and the digest is contained in the routerset.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int contains;
|
2014-09-15 20:04:19 +02:00
|
|
|
uint8_t foo[20] = { 2, 3, 4 };
|
2014-08-27 12:41:25 +02:00
|
|
|
(void)arg;
|
|
|
|
|
2014-09-15 20:04:19 +02:00
|
|
|
digestmap_set(set->digests, (const char*)foo, (void *)1);
|
|
|
|
contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 4);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_digest)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains, when given a valid routerset
|
|
|
|
* and the digest is not contained in the routerset.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int contains;
|
2014-09-15 20:04:19 +02:00
|
|
|
uint8_t bar[20] = { 9, 10, 11, 55 };
|
|
|
|
uint8_t foo[20] = { 1, 2, 3, 4};
|
2014-08-27 12:41:25 +02:00
|
|
|
(void)arg;
|
|
|
|
|
2014-09-15 20:04:19 +02:00
|
|
|
digestmap_set(set->digests, (const char*)bar, (void *)1);
|
|
|
|
contains = routerset_contains(set, NULL, 0, NULL, (const char*)foo, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_digest)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains, when given a valid routerset
|
|
|
|
* and the digest is NULL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int contains;
|
2014-09-15 20:04:19 +02:00
|
|
|
uint8_t bar[20] = { 9, 10, 11, 55 };
|
2014-08-27 12:41:25 +02:00
|
|
|
(void)arg;
|
|
|
|
|
2014-09-15 20:04:19 +02:00
|
|
|
digestmap_set(set->digests, (const char*)bar, (void *)1);
|
2014-08-27 12:41:25 +02:00
|
|
|
contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_addr)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_contains, when given a valid routerset
|
|
|
|
* and the address is rejected by policy.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
|
|
|
|
(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
|
|
|
|
|
2014-09-02 19:56:54 +02:00
|
|
|
static tor_addr_t MOCK_TOR_ADDR;
|
|
|
|
#define MOCK_TOR_ADDR_PTR (&MOCK_TOR_ADDR)
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
tor_addr_t *addr = MOCK_TOR_ADDR_PTR;
|
|
|
|
int contains;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(compare_tor_addr_to_addr_policy);
|
|
|
|
|
|
|
|
contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
|
|
|
|
tt_int_op(contains, OP_EQ, 3);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_policy_result_t
|
|
|
|
NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
|
|
|
|
const smartlist_t *policy)
|
|
|
|
{
|
|
|
|
(void)port;
|
|
|
|
(void)policy;
|
|
|
|
CALLED(compare_tor_addr_to_addr_policy)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
|
2014-08-27 12:41:25 +02:00
|
|
|
return ADDR_POLICY_REJECTED;
|
|
|
|
|
|
|
|
done:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_no_addr)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_contains, when given a valid routerset
|
|
|
|
* and the address is not rejected by policy.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
|
|
|
|
(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
tor_addr_t *addr = MOCK_TOR_ADDR_PTR;
|
|
|
|
int contains;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(compare_tor_addr_to_addr_policy);
|
|
|
|
|
|
|
|
contains = routerset_contains(set, addr, 0, NULL, NULL, 0);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
|
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_policy_result_t
|
|
|
|
NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
|
|
|
|
const smartlist_t *policy)
|
|
|
|
{
|
|
|
|
(void)port;
|
|
|
|
(void)policy;
|
|
|
|
CALLED(compare_tor_addr_to_addr_policy)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
return ADDR_POLICY_ACCEPTED;
|
|
|
|
|
|
|
|
done:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, set_and_null_addr)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_contains, when given a valid routerset
|
|
|
|
* and the address is NULL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
|
|
|
|
(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int contains;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(compare_tor_addr_to_addr_policy);
|
|
|
|
|
|
|
|
contains = routerset_contains(set, NULL, 0, NULL, NULL, 0);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_policy_result_t
|
|
|
|
NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
|
|
|
|
const smartlist_t *policy)
|
|
|
|
{
|
|
|
|
(void)port;
|
|
|
|
(void)policy;
|
|
|
|
CALLED(compare_tor_addr_to_addr_policy)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
return ADDR_POLICY_ACCEPTED;
|
|
|
|
|
|
|
|
done:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, countries_no_geoip)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_contains, when there is no matching country
|
|
|
|
* for the address.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
|
|
|
|
(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
|
|
|
|
NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int contains = 1;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(compare_tor_addr_to_addr_policy);
|
|
|
|
NS_MOCK(geoip_get_country_by_addr);
|
|
|
|
|
|
|
|
set->countries = bitarray_init_zero(1);
|
|
|
|
bitarray_set(set->countries, 1);
|
|
|
|
contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 0);
|
|
|
|
tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_policy_result_t
|
|
|
|
NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
|
|
|
|
const smartlist_t *policy)
|
|
|
|
{
|
|
|
|
(void)port;
|
|
|
|
(void)policy;
|
|
|
|
CALLED(compare_tor_addr_to_addr_policy)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return ADDR_POLICY_ACCEPTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
|
|
|
|
{
|
|
|
|
CALLED(geoip_get_country_by_addr)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains, countries_geoip)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_contains, when there a matching country
|
|
|
|
* for the address.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(addr_policy_result_t, compare_tor_addr_to_addr_policy,
|
|
|
|
(const tor_addr_t *addr, uint16_t port, const smartlist_t *policy));
|
|
|
|
NS_DECL(int, geoip_get_country_by_addr, (const tor_addr_t *addr));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int contains = 1;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(compare_tor_addr_to_addr_policy);
|
|
|
|
NS_MOCK(geoip_get_country_by_addr);
|
|
|
|
|
|
|
|
set->n_countries = 2;
|
|
|
|
set->countries = bitarray_init_zero(1);
|
|
|
|
bitarray_set(set->countries, 1);
|
|
|
|
contains = routerset_contains(set, MOCK_TOR_ADDR_PTR, 0, NULL, NULL, -1);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(contains, OP_EQ, 2);
|
|
|
|
tt_int_op(CALLED(compare_tor_addr_to_addr_policy), OP_EQ, 1);
|
|
|
|
tt_int_op(CALLED(geoip_get_country_by_addr), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
addr_policy_result_t
|
|
|
|
NS(compare_tor_addr_to_addr_policy)(const tor_addr_t *addr, uint16_t port,
|
|
|
|
const smartlist_t *policy)
|
|
|
|
{
|
|
|
|
(void)port;
|
|
|
|
(void)policy;
|
|
|
|
CALLED(compare_tor_addr_to_addr_policy)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return ADDR_POLICY_ACCEPTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
NS(geoip_get_country_by_addr)(const tor_addr_t *addr)
|
|
|
|
{
|
|
|
|
CALLED(geoip_get_country_by_addr)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(addr, OP_EQ, MOCK_TOR_ADDR_PTR);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, only_flag_and_no_ccs)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_add_unknown_ccs, where only_if_some_cc_set
|
|
|
|
* is set and there are no country names.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
routerset_t **setp = &set;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
r = routerset_add_unknown_ccs(setp, 1);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, creates_set)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_add_unknown_ccs, where the set argument
|
|
|
|
* is created if passed in as NULL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* The mock is only used to stop the test from asserting erroneously. */
|
|
|
|
NS_DECL(country_t, geoip_get_country, (const char *country));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = NULL;
|
|
|
|
routerset_t **setp = &set;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(geoip_get_country);
|
|
|
|
|
|
|
|
r = routerset_add_unknown_ccs(setp, 0);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_ptr_op(*setp, OP_NE, NULL);
|
|
|
|
tt_int_op(r, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
if (set != NULL)
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
country_t
|
|
|
|
NS(geoip_get_country)(const char *country)
|
|
|
|
{
|
|
|
|
(void)country;
|
|
|
|
CALLED(geoip_get_country)++;
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, add_unknown)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_add_unknown_ccs, that the "{??}"
|
|
|
|
* country code is added to the list.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(country_t, geoip_get_country, (const char *country));
|
|
|
|
NS_DECL(int, geoip_is_loaded, (sa_family_t family));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
routerset_t **setp = &set;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(geoip_get_country);
|
|
|
|
NS_MOCK(geoip_is_loaded);
|
|
|
|
|
|
|
|
r = routerset_add_unknown_ccs(setp, 0);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 1);
|
|
|
|
tt_int_op(smartlist_contains_string(set->country_names, "??"), OP_EQ, 1);
|
|
|
|
tt_int_op(smartlist_contains_string(set->list, "{??}"), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
if (set != NULL)
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
country_t
|
|
|
|
NS(geoip_get_country)(const char *country)
|
|
|
|
{
|
|
|
|
int arg_is_qq, arg_is_a1;
|
|
|
|
|
|
|
|
CALLED(geoip_get_country)++;
|
|
|
|
|
|
|
|
arg_is_qq = !strcmp(country, "??");
|
|
|
|
arg_is_a1 = !strcmp(country, "A1");
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
if (arg_is_qq)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
done:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
NS(geoip_is_loaded)(sa_family_t family)
|
|
|
|
{
|
|
|
|
CALLED(geoip_is_loaded)++;
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(family, OP_EQ, AF_INET);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_add_unknown_ccs, add_a1)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_add_unknown_ccs, that the "{a1}"
|
|
|
|
* country code is added to the list.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(country_t, geoip_get_country, (const char *country));
|
|
|
|
NS_DECL(int, geoip_is_loaded, (sa_family_t family));
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
routerset_t **setp = &set;
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(geoip_get_country);
|
|
|
|
NS_MOCK(geoip_is_loaded);
|
|
|
|
|
|
|
|
r = routerset_add_unknown_ccs(setp, 0);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 1);
|
|
|
|
tt_int_op(smartlist_contains_string(set->country_names, "a1"), OP_EQ, 1);
|
|
|
|
tt_int_op(smartlist_contains_string(set->list, "{a1}"), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
if (set != NULL)
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
country_t
|
|
|
|
NS(geoip_get_country)(const char *country)
|
|
|
|
{
|
|
|
|
int arg_is_qq, arg_is_a1;
|
|
|
|
|
|
|
|
CALLED(geoip_get_country)++;
|
|
|
|
|
|
|
|
arg_is_qq = !strcmp(country, "??");
|
|
|
|
arg_is_a1 = !strcmp(country, "A1");
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(arg_is_qq || arg_is_a1, OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
if (arg_is_a1)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
done:
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
NS(geoip_is_loaded)(sa_family_t family)
|
|
|
|
{
|
|
|
|
CALLED(geoip_is_loaded)++;
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(family, OP_EQ, AF_INET);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_contains_extendinfo
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains_extendinfo.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
extend_info_t ei;
|
|
|
|
int r;
|
|
|
|
const char *nickname = "foo";
|
|
|
|
(void)arg;
|
|
|
|
|
2014-08-29 21:09:27 +02:00
|
|
|
memset(&ei, 0, sizeof(ei));
|
2014-08-27 12:41:25 +02:00
|
|
|
strmap_set_lc(set->names, nickname, (void *)1);
|
|
|
|
strncpy(ei.nickname, nickname, sizeof(ei.nickname) - 1);
|
|
|
|
ei.nickname[sizeof(ei.nickname) - 1] = '\0';
|
|
|
|
|
|
|
|
r = routerset_contains_extendinfo(set, &ei);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 4);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_contains_router
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains_router.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
routerinfo_t ri;
|
|
|
|
country_t country = 1;
|
|
|
|
int r;
|
|
|
|
const char *nickname = "foo";
|
|
|
|
(void)arg;
|
|
|
|
|
2014-08-29 21:09:27 +02:00
|
|
|
memset(&ri, 0, sizeof(ri));
|
2014-08-27 12:41:25 +02:00
|
|
|
strmap_set_lc(set->names, nickname, (void *)1);
|
|
|
|
ri.nickname = (char *)nickname;
|
|
|
|
|
|
|
|
r = routerset_contains_router(set, &ri, country);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 4);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_contains_routerstatus
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains_routerstatus.
|
|
|
|
*/
|
|
|
|
|
|
|
|
// XXX: This is a bit brief. It only populates and tests the nickname fields
|
|
|
|
// ie., enough to make the containment check succeed. Perhaps it should do
|
|
|
|
// a bit more or test a bit more.
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
routerstatus_t rs;
|
|
|
|
country_t country = 1;
|
|
|
|
int r;
|
|
|
|
const char *nickname = "foo";
|
|
|
|
(void)arg;
|
|
|
|
|
2014-08-29 21:09:27 +02:00
|
|
|
memset(&rs, 0, sizeof(rs));
|
2014-08-27 12:41:25 +02:00
|
|
|
strmap_set_lc(set->names, nickname, (void *)1);
|
|
|
|
strncpy(rs.nickname, nickname, sizeof(rs.nickname) - 1);
|
|
|
|
rs.nickname[sizeof(rs.nickname) - 1] = '\0';
|
|
|
|
|
|
|
|
r = routerset_contains_routerstatus(set, &rs, country);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 4);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains_node, none)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains_node, when the node has no
|
|
|
|
* routerset or routerinfo.
|
|
|
|
*/
|
|
|
|
|
2016-06-02 15:46:12 +02:00
|
|
|
static node_t NS(mock_node);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
2018-09-18 21:32:25 +02:00
|
|
|
memset(&NS(mock_node), 0, sizeof(NS(mock_node)));
|
2014-08-27 12:41:25 +02:00
|
|
|
NS(mock_node).ri = NULL;
|
|
|
|
NS(mock_node).rs = NULL;
|
|
|
|
|
|
|
|
r = routerset_contains_node(set, &NS(mock_node));
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains_node, routerstatus)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains_node, when the node has a
|
|
|
|
* routerset and no routerinfo.
|
|
|
|
*/
|
|
|
|
|
2016-06-02 15:46:12 +02:00
|
|
|
static node_t NS(mock_node);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int r;
|
|
|
|
const char *nickname = "foo";
|
|
|
|
routerstatus_t rs;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
strmap_set_lc(set->names, nickname, (void *)1);
|
|
|
|
|
|
|
|
strncpy(rs.nickname, nickname, sizeof(rs.nickname) - 1);
|
|
|
|
rs.nickname[sizeof(rs.nickname) - 1] = '\0';
|
2018-09-18 21:32:25 +02:00
|
|
|
memset(&NS(mock_node), 0, sizeof(NS(mock_node)));
|
2014-08-27 12:41:25 +02:00
|
|
|
NS(mock_node).ri = NULL;
|
|
|
|
NS(mock_node).rs = &rs;
|
|
|
|
|
|
|
|
r = routerset_contains_node(set, &NS(mock_node));
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 4);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_contains_node, routerinfo)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_contains_node, when the node has no
|
|
|
|
* routerset and a routerinfo.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int r;
|
|
|
|
const char *nickname = "foo";
|
|
|
|
routerinfo_t ri;
|
|
|
|
node_t mock_node;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
strmap_set_lc(set->names, nickname, (void *)1);
|
|
|
|
|
|
|
|
ri.nickname = (char *)nickname;
|
2018-09-18 21:32:25 +02:00
|
|
|
memset(&mock_node, 0, sizeof(mock_node));
|
2014-08-27 12:41:25 +02:00
|
|
|
mock_node.ri = &ri;
|
|
|
|
mock_node.rs = NULL;
|
|
|
|
|
|
|
|
r = routerset_contains_node(set, &mock_node);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 4);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_get_all_nodes, no_routerset)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_get_all_nodes, when routerset is NULL or
|
|
|
|
* the routerset list is NULL.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
smartlist_t *out = smartlist_new();
|
|
|
|
routerset_t *set = NULL;
|
|
|
|
(void)arg;
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(smartlist_len(out), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
routerset_get_all_nodes(out, NULL, NULL, 0);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(smartlist_len(out), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
smartlist_free(set->list);
|
|
|
|
routerset_get_all_nodes(out, NULL, NULL, 0);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(smartlist_len(out), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
/* Just recreate list, so we can simply use routerset_free. */
|
|
|
|
set->list = smartlist_new();
|
|
|
|
|
2014-09-03 15:51:14 +02:00
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
smartlist_free(out);
|
2014-08-27 12:41:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list_with_no_nodes)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_get_all_nodes, when the routerset list
|
|
|
|
* is empty.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(const node_t *, node_get_by_nickname,
|
2017-08-23 01:04:31 +02:00
|
|
|
(const char *nickname, unsigned flags));
|
2016-06-02 15:46:12 +02:00
|
|
|
static const char *NS(mock_nickname);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
smartlist_t *out = smartlist_new();
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int out_len;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(node_get_by_nickname);
|
|
|
|
|
|
|
|
NS(mock_nickname) = "foo";
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(set->list, NS(mock_nickname));
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
routerset_get_all_nodes(out, set, NULL, 0);
|
|
|
|
out_len = smartlist_len(out);
|
|
|
|
|
|
|
|
smartlist_free(out);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(out_len, OP_EQ, 0);
|
|
|
|
tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
const node_t *
|
2017-08-23 01:04:31 +02:00
|
|
|
NS(node_get_by_nickname)(const char *nickname, unsigned flags)
|
2014-08-27 12:41:25 +02:00
|
|
|
{
|
|
|
|
CALLED(node_get_by_nickname)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(nickname, OP_EQ, NS(mock_nickname));
|
2017-08-23 01:04:31 +02:00
|
|
|
tt_uint_op(flags, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list_flag_not_running)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_get_all_nodes, with the running_only flag
|
|
|
|
* is set but the nodes are not running.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(const node_t *, node_get_by_nickname,
|
2017-08-23 01:04:31 +02:00
|
|
|
(const char *nickname, unsigned flags));
|
2016-06-02 15:46:12 +02:00
|
|
|
static const char *NS(mock_nickname);
|
|
|
|
static node_t NS(mock_node);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
smartlist_t *out = smartlist_new();
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int out_len;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(node_get_by_nickname);
|
|
|
|
|
|
|
|
NS(mock_node).is_running = 0;
|
|
|
|
NS(mock_nickname) = "foo";
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(set->list, NS(mock_nickname));
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
routerset_get_all_nodes(out, set, NULL, 1);
|
|
|
|
out_len = smartlist_len(out);
|
|
|
|
|
|
|
|
smartlist_free(out);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(out_len, OP_EQ, 0);
|
|
|
|
tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
const node_t *
|
2017-08-23 01:04:31 +02:00
|
|
|
NS(node_get_by_nickname)(const char *nickname, unsigned flags)
|
2014-08-27 12:41:25 +02:00
|
|
|
{
|
|
|
|
CALLED(node_get_by_nickname)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(nickname, OP_EQ, NS(mock_nickname));
|
2017-08-23 01:04:31 +02:00
|
|
|
tt_int_op(flags, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return &NS(mock_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_get_all_nodes, list)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_get_all_nodes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(const node_t *, node_get_by_nickname,
|
2017-08-23 01:04:31 +02:00
|
|
|
(const char *nickname, unsigned flags));
|
2016-06-02 15:46:12 +02:00
|
|
|
static char *NS(mock_nickname);
|
|
|
|
static node_t NS(mock_node);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
smartlist_t *out = smartlist_new();
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
int out_len;
|
|
|
|
node_t *ent;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(node_get_by_nickname);
|
|
|
|
|
|
|
|
NS(mock_nickname) = tor_strdup("foo");
|
|
|
|
smartlist_add(set->list, NS(mock_nickname));
|
|
|
|
|
|
|
|
routerset_get_all_nodes(out, set, NULL, 0);
|
|
|
|
out_len = smartlist_len(out);
|
|
|
|
ent = (node_t *)smartlist_get(out, 0);
|
|
|
|
|
|
|
|
smartlist_free(out);
|
|
|
|
routerset_free(set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(out_len, OP_EQ, 1);
|
|
|
|
tt_ptr_op(ent, OP_EQ, &NS(mock_node));
|
|
|
|
tt_int_op(CALLED(node_get_by_nickname), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
const node_t *
|
2017-08-23 01:04:31 +02:00
|
|
|
NS(node_get_by_nickname)(const char *nickname, unsigned flags)
|
2014-08-27 12:41:25 +02:00
|
|
|
{
|
|
|
|
CALLED(node_get_by_nickname)++;
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(nickname, OP_EQ, NS(mock_nickname));
|
2017-08-23 01:04:31 +02:00
|
|
|
tt_int_op(flags, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
return &NS(mock_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_get_all_nodes, nodelist_with_no_nodes)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_get_all_nodes, when the nodelist has no nodes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(smartlist_t *, nodelist_get_list, (void));
|
|
|
|
|
2016-06-02 15:46:12 +02:00
|
|
|
static smartlist_t *NS(mock_smartlist);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
smartlist_t *out = smartlist_new();
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(nodelist_get_list);
|
|
|
|
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(set->country_names, "{xx}");
|
2014-08-27 12:41:25 +02:00
|
|
|
NS(mock_smartlist) = smartlist_new();
|
|
|
|
|
|
|
|
routerset_get_all_nodes(out, set, NULL, 1);
|
|
|
|
r = smartlist_len(out);
|
|
|
|
routerset_free(set);
|
|
|
|
smartlist_free(out);
|
|
|
|
smartlist_free(NS(mock_smartlist));
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
|
|
|
tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
smartlist_t *
|
|
|
|
NS(nodelist_get_list)(void)
|
|
|
|
{
|
|
|
|
CALLED(nodelist_get_list)++;
|
|
|
|
|
|
|
|
return NS(mock_smartlist);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_get_all_nodes, nodelist_flag_not_running)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_get_all_nodes, with a non-list routerset
|
|
|
|
* the running_only flag is set, but the nodes are not running.
|
|
|
|
*/
|
|
|
|
|
|
|
|
NS_DECL(smartlist_t *, nodelist_get_list, (void));
|
|
|
|
|
2016-06-02 15:46:12 +02:00
|
|
|
static smartlist_t *NS(mock_smartlist);
|
|
|
|
static node_t NS(mock_node);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
smartlist_t *out = smartlist_new();
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
NS_MOCK(nodelist_get_list);
|
|
|
|
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(set->country_names, "{xx}");
|
2014-08-27 12:41:25 +02:00
|
|
|
NS(mock_smartlist) = smartlist_new();
|
|
|
|
NS(mock_node).is_running = 0;
|
|
|
|
smartlist_add(NS(mock_smartlist), (void *)&NS(mock_node));
|
|
|
|
|
|
|
|
routerset_get_all_nodes(out, set, NULL, 1);
|
|
|
|
r = smartlist_len(out);
|
|
|
|
routerset_free(set);
|
|
|
|
smartlist_free(out);
|
|
|
|
smartlist_free(NS(mock_smartlist));
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
|
|
|
tt_int_op(CALLED(nodelist_get_list), OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
smartlist_t *
|
|
|
|
NS(nodelist_get_list)(void)
|
|
|
|
{
|
|
|
|
CALLED(nodelist_get_list)++;
|
|
|
|
|
|
|
|
return NS(mock_smartlist);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_subtract_nodes
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_subtract_nodes.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = routerset_new();
|
|
|
|
smartlist_t *list = smartlist_new();
|
|
|
|
const char *nickname = "foo";
|
|
|
|
routerinfo_t ri;
|
|
|
|
node_t mock_node;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
strmap_set_lc(set->names, nickname, (void *)1);
|
|
|
|
|
|
|
|
ri.nickname = (char *)nickname;
|
|
|
|
mock_node.rs = NULL;
|
|
|
|
mock_node.ri = &ri;
|
|
|
|
smartlist_add(list, (void *)&mock_node);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(smartlist_len(list), OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
routerset_subtract_nodes(list, set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(smartlist_len(list), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
smartlist_free(list);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_subtract_nodes, null_routerset)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_subtract_nodes, with a NULL routerset.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *set = NULL;
|
|
|
|
smartlist_t *list = smartlist_new();
|
|
|
|
const char *nickname = "foo";
|
|
|
|
routerinfo_t ri;
|
|
|
|
node_t mock_node;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
ri.nickname = (char *)nickname;
|
|
|
|
mock_node.ri = &ri;
|
|
|
|
smartlist_add(list, (void *)&mock_node);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(smartlist_len(list), OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
routerset_subtract_nodes(list, set);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(smartlist_len(list), OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
routerset_free(set);
|
|
|
|
smartlist_free(list);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_to_string
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_to_string.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
2014-09-03 15:51:14 +02:00
|
|
|
routerset_t *set = NULL;
|
|
|
|
char *s = NULL;
|
2014-08-27 12:41:25 +02:00
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
set = NULL;
|
|
|
|
s = routerset_to_string(set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(s, OP_EQ, "");
|
2014-08-27 12:41:25 +02:00
|
|
|
tor_free(s);
|
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
s = routerset_to_string(set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(s, OP_EQ, "");
|
2014-08-27 12:41:25 +02:00
|
|
|
tor_free(s);
|
2014-09-03 15:51:14 +02:00
|
|
|
routerset_free(set); set = NULL;
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
smartlist_add(set->list, tor_strndup("a", 1));
|
|
|
|
s = routerset_to_string(set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(s, OP_EQ, "a");
|
2014-08-27 12:41:25 +02:00
|
|
|
tor_free(s);
|
2014-09-03 15:51:14 +02:00
|
|
|
routerset_free(set); set = NULL;
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
set = routerset_new();
|
|
|
|
smartlist_add(set->list, tor_strndup("a", 1));
|
|
|
|
smartlist_add(set->list, tor_strndup("b", 1));
|
|
|
|
s = routerset_to_string(set);
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_str_op(s, OP_EQ, "a,b");
|
2014-08-27 12:41:25 +02:00
|
|
|
tor_free(s);
|
2014-09-03 15:51:14 +02:00
|
|
|
routerset_free(set); set = NULL;
|
2014-08-27 12:41:25 +02:00
|
|
|
|
2014-09-03 15:51:14 +02:00
|
|
|
done:
|
|
|
|
tor_free(s);
|
2017-11-21 15:37:47 +01:00
|
|
|
routerset_free(set);
|
2014-08-27 12:41:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_equal, empty_empty)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_equal, with both routersets empty.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *a = routerset_new(), *b = routerset_new();
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
|
|
|
r = routerset_equal(a, b);
|
|
|
|
routerset_free(a);
|
|
|
|
routerset_free(b);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_equal, empty_not_empty)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_equal, with one routersets empty.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *a = routerset_new(), *b = routerset_new();
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(b->list, "{xx}");
|
2014-08-27 12:41:25 +02:00
|
|
|
r = routerset_equal(a, b);
|
|
|
|
routerset_free(a);
|
|
|
|
routerset_free(b);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_equal, differing_lengths)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_equal, with the routersets having
|
|
|
|
* differing lengths.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *a = routerset_new(), *b = routerset_new();
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(a->list, "{aa}");
|
|
|
|
smartlist_add_strdup(b->list, "{b1}");
|
|
|
|
smartlist_add_strdup(b->list, "{b2}");
|
2014-08-27 12:41:25 +02:00
|
|
|
r = routerset_equal(a, b);
|
|
|
|
routerset_free(a);
|
|
|
|
routerset_free(b);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_equal, unequal)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_equal, with the routersets being
|
|
|
|
* different.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *a = routerset_new(), *b = routerset_new();
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(a->list, "foo");
|
|
|
|
smartlist_add_strdup(b->list, "bar");
|
2014-08-27 12:41:25 +02:00
|
|
|
r = routerset_equal(a, b);
|
|
|
|
routerset_free(a);
|
|
|
|
routerset_free(b);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_equal, equal)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Functional test for routerset_equal, with the routersets being
|
|
|
|
* equal.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *a = routerset_new(), *b = routerset_new();
|
|
|
|
int r;
|
|
|
|
(void)arg;
|
|
|
|
|
2016-10-27 12:15:57 +02:00
|
|
|
smartlist_add_strdup(a->list, "foo");
|
|
|
|
smartlist_add_strdup(b->list, "foo");
|
2014-08-27 12:41:25 +02:00
|
|
|
r = routerset_equal(a, b);
|
|
|
|
routerset_free(a);
|
|
|
|
routerset_free(b);
|
|
|
|
|
2014-11-12 19:28:07 +01:00
|
|
|
tt_int_op(r, OP_EQ, 1);
|
2014-08-27 12:41:25 +02:00
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE ASPECT(routerset_free, null_routerset)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_free, where the routerset is NULL.
|
|
|
|
*/
|
|
|
|
|
2017-11-17 17:46:25 +01:00
|
|
|
NS_DECL(void, smartlist_free_, (smartlist_t *sl));
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
(void)arg;
|
|
|
|
|
2017-11-17 17:46:25 +01:00
|
|
|
NS_MOCK(smartlist_free_);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
2017-11-21 15:37:47 +01:00
|
|
|
routerset_free_(NULL);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
2017-11-17 17:46:25 +01:00
|
|
|
tt_int_op(CALLED(smartlist_free_), OP_EQ, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-11-17 17:46:25 +01:00
|
|
|
NS(smartlist_free_)(smartlist_t *s)
|
2014-08-27 12:41:25 +02:00
|
|
|
{
|
|
|
|
(void)s;
|
2017-11-17 17:46:25 +01:00
|
|
|
CALLED(smartlist_free_)++;
|
2014-08-27 12:41:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
#define NS_SUBMODULE routerset_free
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structural test for routerset_free.
|
|
|
|
*/
|
|
|
|
|
2017-11-17 17:46:25 +01:00
|
|
|
NS_DECL(void, smartlist_free_, (smartlist_t *sl));
|
|
|
|
NS_DECL(void, strmap_free_,(strmap_t *map, void (*free_val)(void*)));
|
|
|
|
NS_DECL(void, digestmap_free_, (digestmap_t *map, void (*free_val)(void*)));
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
static void
|
|
|
|
NS(test_main)(void *arg)
|
|
|
|
{
|
|
|
|
routerset_t *routerset = routerset_new();
|
|
|
|
(void)arg;
|
|
|
|
|
2017-11-17 17:46:25 +01:00
|
|
|
NS_MOCK(smartlist_free_);
|
|
|
|
NS_MOCK(strmap_free_);
|
|
|
|
NS_MOCK(digestmap_free_);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
routerset_free(routerset);
|
|
|
|
|
2017-11-17 17:46:25 +01:00
|
|
|
tt_int_op(CALLED(smartlist_free_), OP_NE, 0);
|
|
|
|
tt_int_op(CALLED(strmap_free_), OP_NE, 0);
|
|
|
|
tt_int_op(CALLED(digestmap_free_), OP_NE, 0);
|
2014-08-27 12:41:25 +02:00
|
|
|
|
|
|
|
done:
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-11-17 17:46:25 +01:00
|
|
|
NS(smartlist_free_)(smartlist_t *s)
|
2014-08-27 12:41:25 +02:00
|
|
|
{
|
2017-11-17 17:46:25 +01:00
|
|
|
CALLED(smartlist_free_)++;
|
|
|
|
smartlist_free___real(s);
|
2014-08-27 12:41:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-11-17 17:46:25 +01:00
|
|
|
NS(strmap_free_)(strmap_t *map, void (*free_val)(void*))
|
2014-08-27 12:41:25 +02:00
|
|
|
{
|
2017-11-17 17:46:25 +01:00
|
|
|
CALLED(strmap_free_)++;
|
|
|
|
strmap_free___real(map, free_val);
|
2014-08-27 12:41:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-11-17 17:46:25 +01:00
|
|
|
NS(digestmap_free_)(digestmap_t *map, void (*free_val)(void*))
|
2014-08-27 12:41:25 +02:00
|
|
|
{
|
2017-11-17 17:46:25 +01:00
|
|
|
CALLED(digestmap_free_)++;
|
|
|
|
digestmap_free___real(map, free_val);
|
2014-08-27 12:41:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#undef NS_SUBMODULE
|
|
|
|
|
|
|
|
struct testcase_t routerset_tests[] = {
|
|
|
|
TEST_CASE(routerset_new),
|
|
|
|
TEST_CASE(routerset_get_countryname),
|
|
|
|
TEST_CASE(routerset_is_list),
|
|
|
|
TEST_CASE(routerset_needs_geoip),
|
|
|
|
TEST_CASE(routerset_is_empty),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, null_set_or_null_set_list),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_nickname),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_null_nickname),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_no_nickname),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_digest),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_no_digest),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_null_digest),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_addr),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_no_addr),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, set_and_null_addr),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, countries_no_geoip),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains, countries_geoip),
|
|
|
|
TEST_CASE_ASPECT(routerset_add_unknown_ccs, only_flag_and_no_ccs),
|
|
|
|
TEST_CASE_ASPECT(routerset_add_unknown_ccs, creates_set),
|
|
|
|
TEST_CASE_ASPECT(routerset_add_unknown_ccs, add_unknown),
|
|
|
|
TEST_CASE_ASPECT(routerset_add_unknown_ccs, add_a1),
|
|
|
|
TEST_CASE(routerset_contains_extendinfo),
|
|
|
|
TEST_CASE(routerset_contains_router),
|
|
|
|
TEST_CASE(routerset_contains_routerstatus),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains_node, none),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains_node, routerinfo),
|
|
|
|
TEST_CASE_ASPECT(routerset_contains_node, routerstatus),
|
|
|
|
TEST_CASE_ASPECT(routerset_get_all_nodes, no_routerset),
|
|
|
|
TEST_CASE_ASPECT(routerset_get_all_nodes, list_with_no_nodes),
|
|
|
|
TEST_CASE_ASPECT(routerset_get_all_nodes, list_flag_not_running),
|
|
|
|
TEST_CASE_ASPECT(routerset_get_all_nodes, list),
|
|
|
|
TEST_CASE_ASPECT(routerset_get_all_nodes, nodelist_with_no_nodes),
|
|
|
|
TEST_CASE_ASPECT(routerset_get_all_nodes, nodelist_flag_not_running),
|
|
|
|
TEST_CASE_ASPECT(routerset_refresh_counties, geoip_not_loaded),
|
|
|
|
TEST_CASE_ASPECT(routerset_refresh_counties, no_countries),
|
|
|
|
TEST_CASE_ASPECT(routerset_refresh_counties, one_valid_country),
|
|
|
|
TEST_CASE_ASPECT(routerset_refresh_counties, one_invalid_country),
|
|
|
|
TEST_CASE_ASPECT(routerset_union, source_bad),
|
|
|
|
TEST_CASE_ASPECT(routerset_union, one),
|
|
|
|
TEST_CASE_ASPECT(routerset_parse, malformed),
|
|
|
|
TEST_CASE_ASPECT(routerset_parse, valid_hexdigest),
|
|
|
|
TEST_CASE_ASPECT(routerset_parse, valid_nickname),
|
|
|
|
TEST_CASE_ASPECT(routerset_parse, get_countryname),
|
2015-09-14 12:16:43 +02:00
|
|
|
TEST_CASE_ASPECT(routerset_parse, policy_wildcard),
|
|
|
|
TEST_CASE_ASPECT(routerset_parse, policy_ipv4),
|
|
|
|
TEST_CASE_ASPECT(routerset_parse, policy_ipv6),
|
2014-08-27 12:41:25 +02:00
|
|
|
TEST_CASE(routerset_subtract_nodes),
|
|
|
|
TEST_CASE_ASPECT(routerset_subtract_nodes, null_routerset),
|
|
|
|
TEST_CASE(routerset_to_string),
|
|
|
|
TEST_CASE_ASPECT(routerset_equal, empty_empty),
|
|
|
|
TEST_CASE_ASPECT(routerset_equal, empty_not_empty),
|
|
|
|
TEST_CASE_ASPECT(routerset_equal, differing_lengths),
|
|
|
|
TEST_CASE_ASPECT(routerset_equal, unequal),
|
|
|
|
TEST_CASE_ASPECT(routerset_equal, equal),
|
|
|
|
TEST_CASE_ASPECT(routerset_free, null_routerset),
|
|
|
|
TEST_CASE(routerset_free),
|
|
|
|
END_OF_TESTCASES
|
|
|
|
};
|