static bool test_compare_addr4(void)
{
struct bib_entry *bib;
struct in_addr addr4;
bool success = true;
bib = bib_create_str("1::1", 1111, "1.1.1.1", 1111, L4PROTO_TCP);
if (!bib)
return false;
if (str_to_addr4("2.2.2.2", &addr4) != 0)
goto fail;
success &= assert_true(compare_addr4(bib, &addr4) < 0, "< 0");
if (str_to_addr4("1.1.1.1", &addr4) != 0)
goto fail;
success &= assert_true(compare_addr4(bib, &addr4) == 0, "= 0");
if (str_to_addr4("0.0.0.0", &addr4) != 0)
goto fail;
success &= assert_true(compare_addr4(bib, &addr4) > 0, "> 0");
bib_kfree(bib);
return success;
fail:
bib_kfree(bib);
return false;
}
static bool remove_entry(char *addr4, __u8 len4, char *addr6, __u8 len6,
int expected_error)
{
struct ipv4_prefix prefix4;
struct ipv6_prefix prefix6;
bool success;
int error;
log_debug("----------------");
log_debug("Removing entry %s/%u %s/%u", addr6, len6, addr4, len4);
if (!addr4 && !addr6) {
log_err("Both addr4 and addr6 are NULL.");
return false;
}
if (addr4) {
if (is_error(str_to_addr4(addr4, &prefix4.address)))
return false;
prefix4.len = len4;
}
if (addr6) {
if (is_error(str_to_addr6(addr6, &prefix6.address)))
return false;
prefix6.len = len6;
}
error = eamt_rm(addr6 ? &prefix6 : NULL, addr4 ? &prefix4 : NULL);
success = ASSERT_INT(expected_error, error, "removing EAM entry");
/* rtrie_print(eamt.tree6); */
return success;
}
static int __add_entry(char *addr4, __u8 len4, char *addr6, __u8 len6)
{
struct ipv4_prefix prefix4;
struct ipv6_prefix prefix6;
int error;
if (str_to_addr4(addr4, &prefix4.address))
return false;
prefix4.len = len4;
if (str_to_addr6(addr6, &prefix6.address))
return false;
prefix6.len = len6;
log_debug("\nInserting %s/%u | %s/%u", addr6, len6, addr4, len4);
error = eamt_add(&prefix6, &prefix4, true);
/*
if (error) {
log_err("Errcode %d; I'm not going to print the tree.", error);
} else {
rtrie_print(eamt.tree6);
}
*/
return error;
}
/* Fall through */
end:
free(str_copy);
return error;
}
int str_to_addr4(const char *str, struct in_addr *result)
{
if (!inet_pton(AF_INET, str, result)) {
log_err("Cannot parse '%s' as an IPv4 address.", str);
return -EINVAL;
}
return 0;
}
int str_to_addr6(const char *str, struct in6_addr *result)
{
if (!inet_pton(AF_INET6, str, result)) {
log_err("Cannot parse '%s' as an IPv6 address.", str);
return -EINVAL;
}
return 0;
}
#undef STR_MAX_LEN
#define STR_MAX_LEN (INET_ADDRSTRLEN + 1 + 5) /* [addr + null chara] + # + port */
int str_to_addr4_port(const char *str, struct ipv4_transport_addr *addr_out)
{
const char *FORMAT = "<IPv4 address>#<port> (eg. 203.0.113.8#80)";
/* strtok corrupts the string, so we'll be using this copy instead. */
char str_copy[STR_MAX_LEN];
char *token;
int error;
if (strlen(str) + 1 > STR_MAX_LEN) {
log_err("'%s' is too long for this poor, limited parser...", str);
return -EINVAL;
}
strcpy(str_copy, str);
token = strtok(str_copy, "#");
if (!token) {
log_err("Cannot parse '%s' as a %s.", str, FORMAT);
return -EINVAL;
}
error = str_to_addr4(token, &addr_out->l3);
if (error)
return error;
token = strtok(NULL, "#");
if (!token) {
log_err("'%s' does not seem to contain a port (format: %s).", str, FORMAT);
return -EINVAL;
}
return str_to_u16(token, &addr_out->l4, 0, MAX_PORT); /* Error msg already printed. */
}
static bool init(void)
{
char *pool4_addrs[] = { "1.1.1.1", "2.2.2.2" };
int i;
for (i = 0; i < ARRAY_SIZE(IPV4_ADDRS); i++) {
if (is_error(str_to_addr4(IPV4_ADDRS[i], &addr4[i].l3)))
return false;
addr4[i].l4 = IPV4_PORTS[i];
}
for (i = 0; i < ARRAY_SIZE(IPV4_ADDRS); i++) {
if (is_error(str_to_addr6(IPV6_ADDRS[i], &addr6[i].l3)))
return false;
addr6[i].l4 = IPV6_PORTS[i];
}
if (is_error(config_init(false)))
return false;
if (is_error(pool4_init(pool4_addrs, ARRAY_SIZE(pool4_addrs)))) {
config_destroy();
return false;
}
if (is_error(bibdb_init())) {
pool4_destroy();
config_destroy();
return false;
}
return true;
}
/* strtok corrupts the string, so we'll be using this copy instead. */
char str_copy[STR_MAX_LEN];
char *token;
int error;
if (strlen(str) + 1 > STR_MAX_LEN) {
log_err("'%s' is too long for this poor, limited parser...", str);
return -EINVAL;
}
strcpy(str_copy, str);
token = strtok(str_copy, "#");
if (!token) {
log_err("Cannot parse '%s' as a %s.", str, FORMAT);
return -EINVAL;
}
error = str_to_addr6(token, &addr_out->l3);
if (error)
return error;
token = strtok(NULL, "#");
if (!token) {
log_err("'%s' does not seem to contain a port (format: %s).", str, FORMAT);
return -EINVAL;
}
return str_to_u16(token, &addr_out->l4, 0, MAX_PORT); /* Error msg already printed. */
}
#undef STR_MAX_LEN
#define STR_MAX_LEN (INET_ADDRSTRLEN + 1 + 2) /* [addr + null chara] + / + mask */
int str_to_prefix4(const char *str, struct ipv4_prefix *prefix_out)
{
const char *FORMAT = "<IPv4 address>[/<mask>] (eg. 192.0.2.0/24)";
/* strtok corrupts the string, so we'll be using this copy instead. */
char str_copy[STR_MAX_LEN];
char *token;
int error;
if (strlen(str) + 1 > STR_MAX_LEN) {
log_err("'%s' is too long for this poor, limited parser...", str);
return -EINVAL;
}
strcpy(str_copy, str);
token = strtok(str_copy, "/");
if (!token) {
log_err("Cannot parse '%s' as a %s.", str, FORMAT);
return -EINVAL;
}
error = str_to_addr4(token, &prefix_out->addr);
if (error)
return error;
token = strtok(NULL, "/");
if (!token) {
prefix_out->len = IPV4_MAX_PREFIX;
return 0;
}
return str_to_u8(token, &prefix_out->len, 0, 32); /* Error msg already printed. */
}
bool test_append_ipv4(char* expected_as_string, char* prefix_as_string, int prefix_len)
{
char ipv4_as_string[INET_ADDRSTRLEN] = "192.0.2.33";
struct in_addr ipv4;
struct in6_addr prefix, actual, expected;
if (!str_to_addr4(ipv4_as_string, &ipv4)) {
log_warning("Can't parse IPv4 address '%s'. Failing test.", ipv4_as_string);
return false;
}
if (!str_to_addr6(prefix_as_string, &prefix)) {
log_warning("Can't parse prefix '%s'. Failing test.", prefix_as_string);
return false;
}
if (!str_to_addr6(expected_as_string, &expected)) {
log_warning("Can't parse expected address '%s'. Failing test.", expected_as_string);
return false;
}
actual = nat64_append_ipv4(&prefix, &ipv4, prefix_len);
if (!ipv6_addr_equals(&expected, &actual)) {
log_warning("Test failed: %s Expected: %pI6c. Actual: %pI6c.",
"Append IPv4.", &expected, &actual);
return false;
}
return true;
}
bool init(void)
{
int error;
int i;
for (i = 0; i < ARRAY_SIZE(IPV4_ADDRS); i++) {
error = str_to_addr4(IPV4_ADDRS[i], &addr4[i].address);
if (error)
return false;
addr4[i].l4_id = IPV4_PORTS[i];
}
for (i = 0; i < ARRAY_SIZE(IPV4_ADDRS); i++) {
error = str_to_addr6(IPV6_ADDRS[i], &addr6[i].address);
if (error)
return false;
addr6[i].l4_id = IPV6_PORTS[i];
}
error = bib_init();
if (error)
return false;
error = session_init(session_always_dies);
if (error) {
bib_destroy();
return false;
}
return true;
}
static bool init(void)
{
int i;
if (!str_to_addr4(ipv4_addr_str, &ipv4_addr)) {
log_warning("Could not convert '%s' to a IPv4 address. Failing...", ipv4_addr_str);
return false;
}
for (i = 0; i < 6; i++) {
if (!str_to_addr6(ipv6_addr_str[i], &ipv6_addr[i])) {
log_warning("Could not convert '%s' to a IPv6 address. Failing...", ipv6_addr_str[i]);
return false;
}
}
for (i = 0; i < 6; i++) {
if (!str_to_addr6(prefixes_str[i], &prefixes[i].address)) {
log_warning("Could not convert '%s' to a IPv6 address. Failing...", prefixes_str[i]);
return false;
}
prefixes[i].len = prefixes_mask[i];
}
return true;
}
bool str_to_addr4_port(const char *str, struct ipv4_tuple_address *addr_out)
{
const char *FORMAT = "<IPv4 address>#<port> (eg. 10.20.30.40#50)";
const int STR_MAX_LEN = INET_ADDRSTRLEN + 1 + 5; // [addr + null chara] + # + port
char str_copy[STR_MAX_LEN]; // strtok corrupts the string, so we'll be using this copy instead.
char *token;
if (strlen(str) + 1 > STR_MAX_LEN) {
printf("Error: '%s' is too long for this poor, limited parser...\n", str);
return false;
}
strcpy(str_copy, str);
token = strtok(str_copy, "#");
if (!token || !str_to_addr4(token, &addr_out->address)) {
printf("Error: Cannot parse '%s' as a %s.\n", str, FORMAT);
return false;
}
token = strtok(NULL, "#");
if (!token) {
printf("Error: '%s' does not seem to contain a port (format: %s).\n", str, FORMAT);
return false;
}
if (!str_to_u16(token, &addr_out->l4_id, 0, MAX_PORT))
return false; // Error msg already printed.
return true;
}
/**
* Prepares the environment for the tests.
*
* @return whether the initialization was successful or not. An error message has been printed to
* the kernel ring buffer.
*/
static bool init(void)
{
u_int8_t protocols[] = { IPPROTO_UDP, IPPROTO_TCP, IPPROTO_ICMP };
int i;
struct ipv6_prefix prefix;
// Init test addresses
if (str_to_addr6(remote_ipv6_str, &remote_ipv6) != 0) {
log_warning("Can't parse address '%s'. Failing test...", remote_ipv6_str);
return false;
}
if (str_to_addr6(local_ipv6_str, &local_ipv6) != 0) {
log_warning("Can't parse address '%s'. Failing test...", local_ipv6_str);
return false;
}
if (str_to_addr4(local_ipv4_str, &local_ipv4) != 0) {
log_warning("Can't parse address '%s'. Failing test...", local_ipv4_str);
return false;
}
if (str_to_addr4(remote_ipv4_str, &remote_ipv4) != 0) {
log_warning("Can't parse address '%s'. Failing test...", remote_ipv4_str);
return false;
}
// Init the IPv6 pool module
if (!pool6_init())
return false;
if (str_to_addr6("64:ff9b::", &prefix.address) != 0) {
log_warning("Cannot parse the IPv6 prefix. Failing...");
return false;
}
prefix.len = 96;
if (pool6_register(&prefix) != 0) {
log_warning("Could not add the IPv6 prefix. Failing...");
return false;
}
// Init the BIB module
if (!bib_init())
return false;
for (i = 0; i < ARRAY_SIZE(protocols); i++)
if (!add_bib(&local_ipv4, 80, &remote_ipv6, 1500, protocols[i]))
return false;
return true;
}
struct ipv4_tuple_address create_tuple_addr_4(int index)
{
struct ipv4_tuple_address result;
if (!str_to_addr4(IPV4_ADDRS[index], &result.address))
log_warning("Can't convert '%s' to a in_addr. Test is going to fail.", IPV4_ADDRS[index]);
result.l4_id = IPV4_PORTS[index];
return result;
}
bool str_to_addr4_verbose(const char *str, struct in_addr *addr)
{
if (str_to_addr4(str, addr) != 0)
{
log_warning("Cannot parse '%s' as a valid IPv4 address", str);
return false;
}
return true;
}
/**
* Prepares the environment for the tests.
*
* @return whether the initialization was successful or not. An error message has been printed to
* the kernel ring buffer.
*/
static bool init(void)
{
l4_protocol l4_protos[] = { L4PROTO_UDP, L4PROTO_TCP, L4PROTO_ICMP };
int i;
struct ipv6_prefix prefix;
/* Init test addresses */
if (str_to_addr6(remote_ipv6_str, &remote_ipv6) != 0) {
log_warning("Can't parse address '%s'. Failing test...", remote_ipv6_str);
return false;
}
if (str_to_addr6(local_ipv6_str, &local_ipv6) != 0) {
log_warning("Can't parse address '%s'. Failing test...", local_ipv6_str);
return false;
}
if (str_to_addr4(local_ipv4_str, &local_ipv4) != 0) {
log_warning("Can't parse address '%s'. Failing test...", local_ipv4_str);
return false;
}
if (str_to_addr4(remote_ipv4_str, &remote_ipv4) != 0) {
log_warning("Can't parse address '%s'. Failing test...", remote_ipv4_str);
return false;
}
/* Init the IPv6 pool module */
if (is_error(pool6_init(NULL, 0))) /* we'll use the defaults. */
return false;
if (str_to_addr6("64:ff9b::", &prefix.address) != 0) {
log_warning("Cannot parse the IPv6 prefix. Failing...");
return false;
}
prefix.len = 96;
/* Init the BIB module */
if (is_error(bib_init()))
return false;
for (i = 0; i < ARRAY_SIZE(l4_protos); i++)
if (!add_bib(&local_ipv4, 80, &remote_ipv6, 1500, l4_protos[i]))
return false;
return true;
}
int init_ipv4_tuple(struct tuple *tuple4, unsigned char *src_addr, u16 src_port,
unsigned char *dst_addr, u16 dst_port, l4_protocol l4_proto)
{
int error;
error = str_to_addr4(src_addr, &tuple4->src.addr4.l3);
if (error)
return error;
tuple4->src.addr4.l4 = src_port;
error = str_to_addr4(dst_addr, &tuple4->dst.addr4.l3);
if (error)
return error;
tuple4->dst.addr4.l4 = (l4_proto != L4PROTO_ICMP) ? dst_port : src_port;
tuple4->l3_proto = L3PROTO_IPV4;
tuple4->l4_proto = l4_proto;
return 0;
}
bool test_address_filtering_aux(int src_addr_id, int src_port_id, int dst_addr_id, int dst_port_id,
bool expected)
{
struct nf_conntrack_tuple tuple;
if (!str_to_addr4(IPV4_ADDRS[src_addr_id], &tuple.ipv4_src_addr)) {
log_warning("Can't parse the '%s' source address. Failing test.", IPV4_ADDRS[src_addr_id]);
return false;
}
if (!str_to_addr4(IPV4_ADDRS[dst_addr_id], &tuple.ipv4_dst_addr)) {
log_warning("Can't parse the '%s' dest address. Failing test.", IPV4_ADDRS[dst_addr_id]);
return false;
}
tuple.src_port = cpu_to_be16(IPV4_PORTS[src_port_id]);
tuple.dst_port = cpu_to_be16(IPV4_PORTS[dst_port_id]);
tuple.L4_PROTOCOL = IPPROTO_UDP;
tuple.L3_PROTOCOL = NFPROTO_IPV4;
return (expected == session_allow(&tuple));
}
int init_module(void)
{
START_TESTS("Packet");
if (str_to_addr6("1::1", &dummies6[0]) != 0)
return -EINVAL;
if (str_to_addr6("2::2", &dummies6[1]) != 0)
return -EINVAL;
if (str_to_addr4("1.1.1.1", &dummies4[0]) != 0)
return -EINVAL;
if (str_to_addr4("2.2.2.2", &dummies4[1]) != 0)
return -EINVAL;
CALL_TEST(test_function_is_dont_fragment_set(), "Dont fragment getter");
CALL_TEST(test_function_is_more_fragments_set(), "More fragments getter");
CALL_TEST(test_function_build_ipv4_frag_off_field(), "Generate frag offset + flags function");
CALL_TEST(test_inner_packet_validation4(), "Inner packet IPv4 Validation");
CALL_TEST(test_inner_packet_validation6(), "Inner packet IPv6 Validation");
END_TESTS;
}
bool ASSERT_ADDR4(char const *expected_str, struct in_addr const *actual,
char const *test_name)
{
struct in_addr expected;
if (!expected_str)
return __ASSERT_ADDR4(NULL, actual, test_name);
return str_to_addr4(expected_str, &expected)
? false
: __ASSERT_ADDR4(&expected, actual, test_name);
}
static bool assert_session_exists(char *src6_addr, u16 src6_port,
char *dst6_addr, u16 dst6_port,
char *src4_addr, u16 src4_port,
char *dst4_addr, u16 dst4_port,
l4_protocol proto, u_int8_t state,
session_timer_type timer_type, unsigned long timeout)
{
struct session_entry expected;
int result;
if (str_to_addr6(src6_addr, &expected.src6.l3))
return false;
if (str_to_addr6(dst6_addr, &expected.dst6.l3))
return false;
if (str_to_addr4(src4_addr, &expected.src4.l3))
return false;
if (str_to_addr4(dst4_addr, &expected.dst4.l3))
return false;
expected.src6.l4 = src6_port;
expected.dst6.l4 = dst6_port;
expected.src4.l4 = src4_port;
expected.dst4.l4 = dst4_port;
expected.proto = proto;
expected.state = state;
expected.timer_type = timer_type;
expected.update_time = 0;
expected.timeout = msecs_to_jiffies(timeout * 1000);
expected.has_stored = false;
result = session_exists(&expected);
if (result > 0)
return true;
else if (result < 0)
return false;
return ASSERT_BOOL(1, 0, "session search");
}
static int init(void)
{
struct config_prefix6 pool6;
struct pool4_entry_usr entry;
int error;
pool6.set = true;
pool6.prefix.len = 96;
error = str_to_addr6("3::", &pool6.prefix.addr);
if (error)
return error;
error = xlator_add(FW_NETFILTER, INAME_DEFAULT, &pool6, &jool);
if (error)
return error;
entry.mark = 0;
entry.iterations = 0;
entry.flags = ITERATIONS_SET | ITERATIONS_INFINITE;
error = str_to_addr4("192.0.2.128", &entry.range.prefix.addr);
if (error)
goto fail;
entry.range.prefix.len = 32;
entry.range.ports.min = 1024;
entry.range.ports.max = 1024;
entry.proto = L4PROTO_TCP;
error = pool4db_add(jool.nat64.pool4, &entry);
if (error)
goto fail;
entry.proto = L4PROTO_UDP;
error = pool4db_add(jool.nat64.pool4, &entry);
if (error)
goto fail;
entry.proto = L4PROTO_ICMP;
error = pool4db_add(jool.nat64.pool4, &entry);
if (error)
goto fail;
return 0;
fail:
xlator_put(&jool);
xlator_rm(INAME_DEFAULT);
return error;
}
static int mcast4opt_set_out_interface(struct netsocket_config *cfg)
{
struct in_addr addr;
if (!cfg->out_interface)
return 0;
if (str_to_addr4(cfg->out_interface, &addr))
return 1;
if (setsockopt(sk, IPPROTO_IP, IP_MULTICAST_IF, &addr, sizeof(addr))) {
log_perror("-> setsockopt(IP_MULTICAST_IF) failed", errno);
return 1;
}
log_info("-> The outgoing interface was overriden.");
return 0;
}
static bool init(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(IPV4_ADDRS); i++) {
if (is_error(str_to_addr4(IPV4_ADDRS[i], &addr4[i].l3)))
return false;
addr4[i].l4 = IPV4_PORTS[i];
}
for (i = 0; i < ARRAY_SIZE(IPV4_ADDRS); i++) {
if (is_error(str_to_addr6(IPV6_ADDRS[i], &addr6[i].l3)))
return false;
addr6[i].l4 = IPV6_PORTS[i];
}
if (is_error(config_init(false)))
goto config_fail;
if (is_error(pktqueue_init()))
goto pktqueue_fail;
if (is_error(pool4_init(NULL, 0)))
goto pool4_fail;
if (is_error(pool6_init(NULL, 0)))
goto pool6_fail;
if (is_error(bibdb_init()))
goto bib_fail;
if (is_error(sessiondb_init()))
goto session_fail;
return true;
session_fail:
bibdb_destroy();
bib_fail:
pool6_destroy();
pool6_fail:
pool4_destroy();
pool4_fail:
pktqueue_destroy();
pktqueue_fail:
config_destroy();
config_fail:
return false;
}
static bool test_4to6(char *addr4_str, char *addr6_str)
{
struct in_addr addr4;
struct in6_addr addr6;
bool success = true;
log_debug("Testing %s -> %s...", addr4_str, addr6_str);
if (str_to_addr4(addr4_str, &addr4))
return false;
if (addr6_str) {
success &= ASSERT_INT(0, eamt_xlat_4to6(&addr4, &addr6), "errcode");
success &= ASSERT_ADDR6(addr6_str, &addr6, "resulting address");
} else {
success &= ASSERT_INT(-ESRCH, eamt_xlat_4to6(&addr4, &addr6), "errcode");
}
return success;
}
static int mcast4opt_add_membership(struct netsocket_config *cfg)
{
struct ip_mreq mreq;
mreq.imr_multiaddr = *get_addr4(bound_address);
if (cfg->in_interface) {
if (str_to_addr4(cfg->in_interface, &mreq.imr_interface))
return 1;
} else {
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
}
if (setsockopt(sk, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq,
sizeof(mreq))) {
log_perror("-> setsockopt(IP_ADD_MEMBERSHIP) failed", errno);
return 1;
}
log_info("-> We're now registered to the multicast group.");
return 0;
}
bool test_extract_ipv4(char* ipv6_as_string, int prefix_len)
{
const char expected_as_string[INET_ADDRSTRLEN] = "192.0.2.33";
struct in_addr expected;
struct in_addr actual;
struct in6_addr ipv6;
if (!str_to_addr4(expected_as_string, &expected)) {
log_warning("Can't parse expected IPv4 address '%s'. Failing test.", expected_as_string);
return false;
}
if (!str_to_addr6(ipv6_as_string, &ipv6)) {
log_warning("Can't parse IPv6 address being tested '%s'. Failing test.", ipv6_as_string);
return false;
}
actual = nat64_extract_ipv4(&ipv6, prefix_len);
ASSERT_EQUALS_IPV4(expected, actual, "Extract IPv4.")
return true;
}
static bool init(void)
{
int addr_ctr, port_ctr;
for (addr_ctr = 0; addr_ctr < ARRAY_SIZE(expected_ips); addr_ctr++) {
if (str_to_addr4(expected_ips_as_str[addr_ctr], &expected_ips[addr_ctr]) != 0) {
log_warning("Cannot parse test address '%s'. Failing.", expected_ips_as_str[addr_ctr]);
return false;
}
}
if (pool4_init(expected_ips_as_str, ARRAY_SIZE(expected_ips_as_str)) != 0) {
log_warning("Could not init the pool. Failing...");
return false;
}
for (addr_ctr = 0; addr_ctr < ARRAY_SIZE(expected_ips); addr_ctr++)
for (port_ctr = 0; port_ctr < ID_COUNT; port_ctr++)
ports[addr_ctr][port_ctr] = false;
return true;
}
/** Convert the network mask in CIDR format ('/n') to address format.
*
* @param[in] af Address Family: AF_INET[6].
* @param[in] bits Network mask bits, integer value from: /n.
* @param[out] net Network mask in address format.
* @return true if OK, otherwise false.
*/
int convert_bits_to_netmask(int af, unsigned char bits, void *net)
{
unsigned char ii = 0;
switch(af)
{
case AF_INET:
str_to_addr4("0.0.0.0", net);
(*(struct in_addr *)net).s_addr = \
BROADCAST_ADDR >>(IPV4_NETMASK_BITS_MAX - bits);
break;
case AF_INET6:
str_to_addr6("::0", net);
for (ii = 0; ii < IPV6_SIZE_UINT32; ii++)
{
if (bits <= ii * IPV6_SIZE_UINT32_BITS )
{
if (bits == ii * IPV6_SIZE_UINT32_BITS )
(*(struct in6_addr *)net).s6_addr32[ii] = \
DONT_CARE;
else
(*(struct in6_addr *)net).s6_addr32[ii] = \
htonl( BROADCAST_ADDR <<(IPV6_NETMASK_BITS_MAX - bits ) );
}
else
{
(*(struct in6_addr *)net).s6_addr32[ii] = BROADCAST_ADDR;
}
}
break;
default:
/* log_warning("%s. Error, bad address family.", "convert_bits_to_netmask"); */
return false;
}
return true;
}
int str_to_addr4_port(const char *str, struct ipv4_tuple_address *addr_out)
{
const char *FORMAT = "<IPv4 address>#<port> (eg. 10.20.30.40#50)";
/* [addr + null chara] + # + port */
const unsigned int STR_MAX_LEN = INET_ADDRSTRLEN + 1 + 5;
/* strtok corrupts the string, so we'll be using this copy instead. */
char str_copy[STR_MAX_LEN];
char *token;
int error;
if (strlen(str) + 1 > STR_MAX_LEN) {
log_err(ERR_PARSE_ADDR4_PORT, "'%s' is too long for this poor, limited parser...", str);
return -EINVAL;
}
strcpy(str_copy, str);
token = strtok(str_copy, "#");
if (!token) {
log_err(ERR_PARSE_ADDR4_PORT, "Cannot parse '%s' as a %s.", str, FORMAT);
return -EINVAL;
}
error = str_to_addr4(token, &addr_out->address);
if (error)
return error;
token = strtok(NULL, "#");
if (!token) {
log_err(ERR_PARSE_ADDR4_PORT, "'%s' does not seem to contain a port (format: %s).", str,
FORMAT);
return -EINVAL;
}
error = str_to_u16(token, &addr_out->l4_id, 0, MAX_PORT);
if (error)
return error; /* Error msg already printed. */
return 0;
}
static bool init(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(IPV4_ADDRS); i++) {
if (is_error(str_to_addr4(IPV4_ADDRS[i], &addr4[i].l3)))
return false;
addr4[i].l4 = IPV4_PORTS[i];
}
for (i = 0; i < ARRAY_SIZE(IPV4_ADDRS); i++) {
if (is_error(str_to_addr6(IPV6_ADDRS[i], &addr6[i].l3)))
return false;
addr6[i].l4 = IPV6_PORTS[i];
}
if (is_error(sessiondb_init()))
return false;
if (is_error(pktqueue_init()))
return false;
return true;
}
static bool init(void)
{
int i;
if (!pool4_init(false)) {
log_warning("Could not init the pool. Failing...");
return false;
}
for (i = 0; i < ARRAY_SIZE(expected_ips); i++) {
if (str_to_addr4(expected_ips_as_str[i], &expected_ips[i]) != 0) {
log_warning("Cannot parse test address '%s'. Failing.", expected_ips_as_str[i]);
return false;
}
if (pool4_register(&expected_ips[i]) != 0) {
log_warning("Could not register address %pI4. Failing...", &expected_ips[i]);
return false;
}
}
return true;
}
