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
START_TEST(addr_alloc)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
START_TEST(addr_binary_addr)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
START_TEST(addr_parse4)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
START_TEST(addr_parse6)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
START_TEST(addr_info)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
START_TEST(addr_flags2str)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
make_nl_addr_suite(void)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 }
238