| 1 |
/* SPDX-License-Identifier: LGPL-2.1-only */ |
| 2 |
/* |
| 3 |
* Copyright (c) 2013 Thomas Graf <[email protected]> |
| 4 |
*/ |
| 5 |
|
| 6 |
#include "nl-default.h" |
| 7 |
|
| 8 |
#include <check.h> |
| 9 |
#include <netlink/addr.h> |
| 10 |
#include <netlink/route/addr.h> |
| 11 |
|
| 12 |
#include "cksuite-all.h" |
| 13 |
|
| 14 |
START_TEST(addr_alloc) |
| 15 |
{ |
| 16 |
struct nl_addr *addr; |
| 17 |
|
| 18 |
addr = nl_addr_alloc(16); |
| 19 |
ck_assert_msg(addr, "Allocation should not return NULL"); |
| 20 |
|
| 21 |
ck_assert_msg(nl_addr_iszero(addr) != 0, |
| 22 |
"New empty address should be all zeros"); |
| 23 |
|
| 24 |
ck_assert_msg(nl_addr_get_family(addr) == AF_UNSPEC, |
| 25 |
"New empty address should have family AF_UNSPEC"); |
| 26 |
|
| 27 |
ck_assert_msg(nl_addr_get_prefixlen(addr) == 0, |
| 28 |
"New empty address should have prefix length 0"); |
| 29 |
|
| 30 |
ck_assert_msg(!nl_addr_shared(addr), |
| 31 |
"New empty address should not be shared"); |
| 32 |
|
| 33 |
ck_assert_msg(nl_addr_get(addr) == addr, |
| 34 |
"nl_addr_get() should return pointer to address"); |
| 35 |
|
| 36 |
ck_assert_msg(nl_addr_shared(addr) != 0, |
| 37 |
"Address should be shared after call to nl_addr_get()"); |
| 38 |
|
| 39 |
nl_addr_put(addr); |
| 40 |
|
| 41 |
ck_assert_msg( |
| 42 |
!nl_addr_shared(addr), |
| 43 |
"Address should not be shared after call to nl_addr_put()"); |
| 44 |
|
| 45 |
ck_assert_msg(nl_addr_fill_sockaddr(addr, NULL, 0) != 0, |
| 46 |
"Socket address filling should fail for empty address"); |
| 47 |
|
| 48 |
nl_addr_put(addr); |
| 49 |
} |
| 50 |
END_TEST |
| 51 |
|
| 52 |
START_TEST(addr_binary_addr) |
| 53 |
{ |
| 54 |
struct nl_addr *addr, *addr2; |
| 55 |
char baddr[4] = { 0x1, 0x2, 0x3, 0x4 }; |
| 56 |
char baddr2[6] = { 0x1, 0x2, 0x3, 0x4, 0x5, 0x6 }; |
| 57 |
|
| 58 |
addr = nl_addr_alloc(4); |
| 59 |
ck_assert_msg(addr != NULL, "Allocation should not return NULL"); |
| 60 |
|
| 61 |
ck_assert_msg(nl_addr_set_binary_addr(addr, baddr, 4) >= 0, |
| 62 |
"Valid binary address should be settable"); |
| 63 |
|
| 64 |
ck_assert_msg( |
| 65 |
nl_addr_get_prefixlen(addr) == 0, |
| 66 |
"Prefix length should be unchanged after nl_addr_set_binary_addr()"); |
| 67 |
|
| 68 |
ck_assert_msg(nl_addr_get_len(addr) == 4, "Address length should be 4"); |
| 69 |
|
| 70 |
ck_assert_msg( |
| 71 |
nl_addr_set_binary_addr(addr, baddr2, 6) != 0, |
| 72 |
"Should not be able to set binary address exceeding maximum length"); |
| 73 |
|
| 74 |
ck_assert_msg(nl_addr_get_len(addr) == 4, |
| 75 |
"Address length should still be 4"); |
| 76 |
|
| 77 |
ck_assert_msg( |
| 78 |
nl_addr_guess_family(addr) == AF_INET, |
| 79 |
"Binary address of length 4 should be guessed as AF_INET"); |
| 80 |
|
| 81 |
ck_assert_msg(memcmp(baddr, nl_addr_get_binary_addr(addr), 4) == 0, |
| 82 |
"Binary address mismatches"); |
| 83 |
|
| 84 |
addr2 = nl_addr_build(AF_UNSPEC, baddr, 4); |
| 85 |
ck_assert_msg(addr2 != NULL, "Building of address should not fail"); |
| 86 |
|
| 87 |
nl_addr_set_prefixlen(addr, 32); |
| 88 |
ck_assert_msg( |
| 89 |
nl_addr_get_prefixlen(addr) == 32, |
| 90 |
"Prefix length should be successful changed after nl_addr_set_prefixlen()"); |
| 91 |
|
| 92 |
ck_assert_msg(!nl_addr_cmp(addr, addr2), |
| 93 |
"Addresses built from same binary address should match"); |
| 94 |
|
| 95 |
nl_addr_put(addr); |
| 96 |
nl_addr_put(addr2); |
| 97 |
} |
| 98 |
END_TEST |
| 99 |
|
| 100 |
START_TEST(addr_parse4) |
| 101 |
{ |
| 102 |
struct nl_addr *addr4, *clone; |
| 103 |
struct sockaddr_in sin; |
| 104 |
socklen_t len = sizeof(sin); |
| 105 |
char *addr_str = "10.0.0.1/16"; |
| 106 |
char buf[128]; |
| 107 |
|
| 108 |
ck_assert_msg(nl_addr_parse(addr_str, AF_INET6, &addr4) != 0, |
| 109 |
"Should not be able to parse IPv4 address in IPv6 mode"); |
| 110 |
|
| 111 |
ck_assert_msg(nl_addr_parse(addr_str, AF_UNSPEC, &addr4) == 0, |
| 112 |
"Should be able to parse \"%s\"", addr_str); |
| 113 |
|
| 114 |
ck_assert_msg(nl_addr_get_family(addr4) == AF_INET, |
| 115 |
"Address family should be AF_INET"); |
| 116 |
|
| 117 |
ck_assert_msg(nl_addr_get_prefixlen(addr4) == 16, |
| 118 |
"Prefix length should be 16"); |
| 119 |
|
| 120 |
ck_assert_msg(!nl_addr_iszero(addr4), |
| 121 |
"Address should not be all zeroes"); |
| 122 |
|
| 123 |
clone = nl_addr_clone(addr4); |
| 124 |
ck_assert_msg(clone != NULL, "Cloned address should not be NULL"); |
| 125 |
|
| 126 |
ck_assert_msg(nl_addr_cmp(addr4, clone) == 0, |
| 127 |
"Cloned address should not mismatch original"); |
| 128 |
|
| 129 |
ck_assert_msg(nl_addr_fill_sockaddr(addr4, (struct sockaddr *)&sin, |
| 130 |
&len) == 0, |
| 131 |
"Should be able to fill socketaddr"); |
| 132 |
|
| 133 |
ck_assert_msg( |
| 134 |
!strcmp(nl_addr2str(addr4, buf, sizeof(buf)), addr_str), |
| 135 |
"Address translated back to string does not match original"); |
| 136 |
|
| 137 |
nl_addr_put(addr4); |
| 138 |
nl_addr_put(clone); |
| 139 |
} |
| 140 |
END_TEST |
| 141 |
|
| 142 |
START_TEST(addr_parse6) |
| 143 |
{ |
| 144 |
struct nl_addr *addr6, *clone; |
| 145 |
struct sockaddr_in6 sin; |
| 146 |
socklen_t len = sizeof(sin); |
| 147 |
char *addr_str = "2001:1:2::3/64"; |
| 148 |
char buf[128]; |
| 149 |
|
| 150 |
ck_assert_msg(nl_addr_parse(addr_str, AF_INET, &addr6) != 0, |
| 151 |
"Should not be able to parse IPv6 address in IPv4 mode"); |
| 152 |
|
| 153 |
ck_assert_msg(nl_addr_parse(addr_str, AF_UNSPEC, &addr6) == 0, |
| 154 |
"Should be able to parse \"%s\"", addr_str); |
| 155 |
|
| 156 |
ck_assert_msg(nl_addr_get_family(addr6) == AF_INET6, |
| 157 |
"Address family should be AF_INET6"); |
| 158 |
|
| 159 |
ck_assert_msg(nl_addr_get_prefixlen(addr6) == 64, |
| 160 |
"Prefix length should be 64"); |
| 161 |
|
| 162 |
ck_assert_msg(!nl_addr_iszero(addr6), |
| 163 |
"Address should not be all zeroes"); |
| 164 |
|
| 165 |
clone = nl_addr_clone(addr6); |
| 166 |
ck_assert_msg(clone != NULL, "Cloned address should not be NULL"); |
| 167 |
|
| 168 |
ck_assert_msg(nl_addr_cmp(addr6, clone) == 0, |
| 169 |
"Cloned address should not mismatch original"); |
| 170 |
|
| 171 |
ck_assert_msg(nl_addr_fill_sockaddr(addr6, (struct sockaddr *)&sin, |
| 172 |
&len) == 0, |
| 173 |
"Should be able to fill socketaddr"); |
| 174 |
|
| 175 |
ck_assert_msg( |
| 176 |
!strcmp(nl_addr2str(addr6, buf, sizeof(buf)), addr_str), |
| 177 |
"Address translated back to string does not match original"); |
| 178 |
|
| 179 |
_nl_clear_pointer(&addr6, nl_addr_put); |
| 180 |
|
| 181 |
ck_assert(nl_addr_parse("default", AF_INET6, &addr6) == 0); |
| 182 |
ck_assert_int_eq(nl_addr_get_len(addr6), 16); |
| 183 |
ck_assert_int_eq(nl_addr_get_prefixlen(addr6), 0); |
| 184 |
ck_assert_mem_eq(nl_addr_get_binary_addr(addr6), ((uint8_t[16]){ 0 }), |
| 185 |
16); |
| 186 |
|
| 187 |
nl_addr_put(addr6); |
| 188 |
nl_addr_put(clone); |
| 189 |
} |
| 190 |
END_TEST |
| 191 |
|
| 192 |
START_TEST(addr_info) |
| 193 |
{ |
| 194 |
struct nl_addr *addr; |
| 195 |
char *addr_str = "127.0.0.1"; |
| 196 |
struct addrinfo *result; |
| 197 |
|
| 198 |
ck_assert_msg(nl_addr_parse(addr_str, AF_UNSPEC, &addr) == 0, |
| 199 |
"Parsing of valid address should not fail"); |
| 200 |
|
| 201 |
ck_assert_msg(nl_addr_info(addr, &result) == 0, |
| 202 |
"getaddrinfo() on loopback address should work"); |
| 203 |
|
| 204 |
freeaddrinfo(result); |
| 205 |
nl_addr_put(addr); |
| 206 |
} |
| 207 |
END_TEST |
| 208 |
|
| 209 |
START_TEST(addr_flags2str) |
| 210 |
{ |
| 211 |
int ifa_flags = IFA_F_TENTATIVE | IFA_F_DADFAILED; |
| 212 |
int ifa_flags2; |
| 213 |
char buf[128]; |
| 214 |
|
| 215 |
rtnl_addr_flags2str(ifa_flags, buf, sizeof(buf)); |
| 216 |
ck_assert_str_eq(buf, "dadfailed,tentative"); |
| 217 |
|
| 218 |
ifa_flags2 = rtnl_addr_str2flags(buf); |
| 219 |
ck_assert_int_eq(ifa_flags2, ifa_flags); |
| 220 |
} |
| 221 |
END_TEST |
| 222 |
|
| 223 |
Suite *make_nl_addr_suite(void) |
| 224 |
{ |
| 225 |
Suite *suite = suite_create("Abstract addresses"); |
| 226 |
TCase *tc = tcase_create("Core"); |
| 227 |
|
| 228 |
tcase_add_test(tc, addr_alloc); |
| 229 |
tcase_add_test(tc, addr_binary_addr); |
| 230 |
tcase_add_test(tc, addr_parse4); |
| 231 |
tcase_add_test(tc, addr_parse6); |
| 232 |
tcase_add_test(tc, addr_info); |
| 233 |
tcase_add_test(tc, addr_flags2str); |
| 234 |
suite_add_tcase(suite, tc); |
| 235 |
|
| 236 |
return suite; |
| 237 |
} |