]> git.proxmox.com Git - ceph.git/blame - ceph/src/test/test_ipaddr.cc
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
update sources to v12.2.0
[ceph.git] / ceph / src / test / test_ipaddr.cc
CommitLineData
7c673cae
FG		 1#include "include/ipaddr.h"
2#include "gtest/gtest.h"
3
4#if defined(__FreeBSD__)
5#include <sys/types.h>
6#include <sys/socket.h>
31f18b77 7#include <netinet/in.h>
7c673cae
FG		 8#endif
9#include <arpa/inet.h>
31f18b77 10#include <ifaddrs.h>
7c673cae
FG		 11
12static void ipv4(struct sockaddr_in *addr, const char *s) {
13 int err;
14
15 addr->sin_family = AF_INET;
16 err = inet_pton(AF_INET, s, &addr->sin_addr);
17 ASSERT_EQ(1, err);
18}
19
20static void ipv6(struct sockaddr_in6 *addr, const char *s) {
21 int err;
22
23 addr->sin6_family = AF_INET6;
24 err = inet_pton(AF_INET6, s, &addr->sin6_addr);
25 ASSERT_EQ(1, err);
26}
27
28static char eth0[] = "eth0";
29static char eth1[] = "eth1";
30
31TEST(CommonIPAddr, TestNotFound)
32{
33 struct ifaddrs one, two;
34 struct sockaddr_in a_one;
35 struct sockaddr_in6 a_two;
36 struct sockaddr_in net;
b5b8bbf5 37 const struct ifaddrs *result;
7c673cae
FG		 38
39 memset(&net, '0', sizeof(net));
40
41 one.ifa_next = &two;
42 one.ifa_addr = (struct sockaddr*)&a_one;
43 one.ifa_name = eth0;
44
45 two.ifa_next = NULL;
46 two.ifa_addr = (struct sockaddr*)&a_two;
47 two.ifa_name = eth1;
48
49 ipv4(&a_one, "10.11.12.13");
50 ipv6(&a_two, "2001:1234:5678:90ab::cdef");
51 ipv4(&net, "10.11.234.56");
52
53 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 24);
54 ASSERT_EQ(0, result);
55}
56
57TEST(CommonIPAddr, TestV4_Simple)
58{
59 struct ifaddrs one, two;
60 struct sockaddr_in a_one;
61 struct sockaddr_in6 a_two;
62 struct sockaddr_in net;
b5b8bbf5 63 const struct ifaddrs *result;
7c673cae
FG		 64
65 memset(&net, '0', sizeof(net));
66
67 one.ifa_next = &two;
68 one.ifa_addr = (struct sockaddr*)&a_one;
69 one.ifa_name = eth0;
70
71 two.ifa_next = NULL;
72 two.ifa_addr = (struct sockaddr*)&a_two;
73 two.ifa_name = eth1;
74
75 ipv4(&a_one, "10.11.12.13");
76 ipv6(&a_two, "2001:1234:5678:90ab::cdef");
77 ipv4(&net, "10.11.12.42");
78
79 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 24);
b5b8bbf5 80 ASSERT_EQ((struct sockaddr*)&a_one, result->ifa_addr);
7c673cae
FG		 81}
82
83TEST(CommonIPAddr, TestV4_Prefix25)
84{
85 struct ifaddrs one, two;
86 struct sockaddr_in a_one;
87 struct sockaddr_in a_two;
88 struct sockaddr_in net;
b5b8bbf5 89 const struct ifaddrs *result;
7c673cae
FG		 90
91 memset(&net, '0', sizeof(net));
92
93 one.ifa_next = &two;
94 one.ifa_addr = (struct sockaddr*)&a_one;
95 one.ifa_name = eth0;
96
97 two.ifa_next = NULL;
98 two.ifa_addr = (struct sockaddr*)&a_two;
99 two.ifa_name = eth1;
100
101 ipv4(&a_one, "10.11.12.13");
102 ipv4(&a_two, "10.11.12.129");
103 ipv4(&net, "10.11.12.128");
104
105 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 25);
b5b8bbf5 106 ASSERT_EQ((struct sockaddr*)&a_two, result->ifa_addr);
7c673cae
FG		 107}
108
109TEST(CommonIPAddr, TestV4_Prefix16)
110{
111 struct ifaddrs one, two;
112 struct sockaddr_in a_one;
113 struct sockaddr_in a_two;
114 struct sockaddr_in net;
b5b8bbf5 115 const struct ifaddrs *result;
7c673cae
FG		 116
117 memset(&net, '0', sizeof(net));
118
119 one.ifa_next = &two;
120 one.ifa_addr = (struct sockaddr*)&a_one;
121 one.ifa_name = eth0;
122
123 two.ifa_next = NULL;
124 two.ifa_addr = (struct sockaddr*)&a_two;
125 two.ifa_name = eth1;
126
127 ipv4(&a_one, "10.1.1.2");
128 ipv4(&a_two, "10.2.1.123");
129 ipv4(&net, "10.2.0.0");
130
131 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 16);
b5b8bbf5 132 ASSERT_EQ((struct sockaddr*)&a_two, result->ifa_addr);
7c673cae
FG		 133}
134
135TEST(CommonIPAddr, TestV4_PrefixTooLong)
136{
137 struct ifaddrs one;
138 struct sockaddr_in a_one;
139 struct sockaddr_in net;
b5b8bbf5 140 const struct ifaddrs *result;
7c673cae
FG		 141
142 memset(&net, '0', sizeof(net));
143
144 one.ifa_next = NULL;
145 one.ifa_addr = (struct sockaddr*)&a_one;
146 one.ifa_name = eth0;
147
148 ipv4(&a_one, "10.11.12.13");
149 ipv4(&net, "10.11.12.12");
150
151 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 42);
152 ASSERT_EQ(0, result);
153}
154
155TEST(CommonIPAddr, TestV4_PrefixZero)
156{
157 struct ifaddrs one, two;
158 struct sockaddr_in6 a_one;
159 struct sockaddr_in a_two;
160 struct sockaddr_in net;
b5b8bbf5 161 const struct ifaddrs *result;
7c673cae
FG		 162
163 memset(&net, '0', sizeof(net));
164
165 one.ifa_next = &two;
166 one.ifa_addr = (struct sockaddr*)&a_one;
167 one.ifa_name = eth0;
168
169 two.ifa_next = NULL;
170 two.ifa_addr = (struct sockaddr*)&a_two;
171 two.ifa_name = eth1;
172
173 ipv6(&a_one, "2001:1234:5678:900F::cdef");
174 ipv4(&a_two, "10.1.2.3");
175 ipv4(&net, "255.0.1.2");
176
177 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 0);
b5b8bbf5 178 ASSERT_EQ((struct sockaddr*)&a_two, result->ifa_addr);
7c673cae
FG		 179}
180
181TEST(CommonIPAddr, TestV6_Simple)
182{
183 struct ifaddrs one, two;
184 struct sockaddr_in a_one;
185 struct sockaddr_in6 a_two;
186 struct sockaddr_in6 net;
b5b8bbf5 187 const struct ifaddrs *result;
7c673cae
FG		 188
189 memset(&net, '0', sizeof(net));
190
191 one.ifa_next = &two;
192 one.ifa_addr = (struct sockaddr*)&a_one;
193 one.ifa_name = eth0;
194
195 two.ifa_next = NULL;
196 two.ifa_addr = (struct sockaddr*)&a_two;
197 two.ifa_name = eth1;
198
199 ipv4(&a_one, "10.11.12.13");
200 ipv6(&a_two, "2001:1234:5678:90ab::cdef");
201 ipv6(&net, "2001:1234:5678:90ab::dead:beef");
202
203 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 64);
b5b8bbf5 204 ASSERT_EQ((struct sockaddr*)&a_two, result->ifa_addr);
7c673cae
FG		 205}
206
207TEST(CommonIPAddr, TestV6_Prefix57)
208{
209 struct ifaddrs one, two;
210 struct sockaddr_in6 a_one;
211 struct sockaddr_in6 a_two;
212 struct sockaddr_in6 net;
b5b8bbf5 213 const struct ifaddrs *result;
7c673cae
FG		 214
215 memset(&net, '0', sizeof(net));
216
217 one.ifa_next = &two;
218 one.ifa_addr = (struct sockaddr*)&a_one;
219 one.ifa_name = eth0;
220
221 two.ifa_next = NULL;
222 two.ifa_addr = (struct sockaddr*)&a_two;
223 two.ifa_name = eth1;
224
225 ipv6(&a_one, "2001:1234:5678:900F::cdef");
226 ipv6(&a_two, "2001:1234:5678:90ab::cdef");
227 ipv6(&net, "2001:1234:5678:90ab::dead:beef");
228
229 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 57);
b5b8bbf5 230 ASSERT_EQ((struct sockaddr*)&a_two, result->ifa_addr);
7c673cae
FG		 231}
232
233TEST(CommonIPAddr, TestV6_PrefixTooLong)
234{
235 struct ifaddrs one;
236 struct sockaddr_in6 a_one;
237 struct sockaddr_in6 net;
b5b8bbf5 238 const struct ifaddrs *result;
7c673cae
FG		 239
240 memset(&net, '0', sizeof(net));
241
242 one.ifa_next = NULL;
243 one.ifa_addr = (struct sockaddr*)&a_one;
244 one.ifa_name = eth0;
245
246 ipv6(&a_one, "2001:1234:5678:900F::cdef");
247 ipv6(&net, "2001:1234:5678:900F::cdee");
248
249 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 9000);
250 ASSERT_EQ(0, result);
251}
252
253TEST(CommonIPAddr, TestV6_PrefixZero)
254{
255 struct ifaddrs one, two;
256 struct sockaddr_in a_one;
257 struct sockaddr_in6 a_two;
258 struct sockaddr_in6 net;
b5b8bbf5 259 const struct ifaddrs *result;
7c673cae
FG		 260
261 one.ifa_next = &two;
262 one.ifa_addr = (struct sockaddr*)&a_one;
263 one.ifa_name = eth0;
264
265 two.ifa_next = NULL;
266 two.ifa_addr = (struct sockaddr*)&a_two;
267 two.ifa_name = eth1;
268
269 ipv4(&a_one, "10.2.3.4");
270 ipv6(&a_two, "2001:f00b::1");
271 ipv6(&net, "ff00::1");
272
273 result = find_ip_in_subnet(&one, (struct sockaddr*)&net, 0);
b5b8bbf5 274 ASSERT_EQ((struct sockaddr*)&a_two, result->ifa_addr);
7c673cae
FG		 275}
276
277TEST(CommonIPAddr, ParseNetwork_Empty)
278{
279 struct sockaddr_storage network;
280 unsigned int prefix_len;
281 bool ok;
282
283 ok = parse_network("", &network, &prefix_len);
284 ASSERT_EQ(ok, false);
285}
286
287TEST(CommonIPAddr, ParseNetwork_Bad_Junk)
288{
289 struct sockaddr_storage network;
290 unsigned int prefix_len;
291 bool ok;
292
293 ok = parse_network("foo", &network, &prefix_len);
294 ASSERT_EQ(ok, false);
295}
296
297TEST(CommonIPAddr, ParseNetwork_Bad_SlashNum)
298{
299 struct sockaddr_storage network;
300 unsigned int prefix_len;
301 bool ok;
302
303 ok = parse_network("/24", &network, &prefix_len);
304 ASSERT_EQ(ok, false);
305}
306
307TEST(CommonIPAddr, ParseNetwork_Bad_Slash)
308{
309 struct sockaddr_storage network;
310 unsigned int prefix_len;
311 bool ok;
312
313 ok = parse_network("/", &network, &prefix_len);
314 ASSERT_EQ(ok, false);
315}
316
317TEST(CommonIPAddr, ParseNetwork_Bad_IPv4)
318{
319 struct sockaddr_storage network;
320 unsigned int prefix_len;
321 bool ok;
322
323 ok = parse_network("123.123.123.123", &network, &prefix_len);
324 ASSERT_EQ(ok, false);
325}
326
327TEST(CommonIPAddr, ParseNetwork_Bad_IPv4Slash)
328{
329 struct sockaddr_storage network;
330 unsigned int prefix_len;
331 bool ok;
332
333 ok = parse_network("123.123.123.123/", &network, &prefix_len);
334 ASSERT_EQ(ok, false);
335}
336
337TEST(CommonIPAddr, ParseNetwork_Bad_IPv4SlashNegative)
338{
339 struct sockaddr_storage network;
340 unsigned int prefix_len;
341 bool ok;
342
343 ok = parse_network("123.123.123.123/-3", &network, &prefix_len);
344 ASSERT_EQ(ok, false);
345}
346
347TEST(CommonIPAddr, ParseNetwork_Bad_IPv4SlashJunk)
348{
349 struct sockaddr_storage network;
350 unsigned int prefix_len;
351 bool ok;
352
353 ok = parse_network("123.123.123.123/foo", &network, &prefix_len);
354 ASSERT_EQ(ok, false);
355}
356
357TEST(CommonIPAddr, ParseNetwork_Bad_IPv6)
358{
359 struct sockaddr_storage network;
360 unsigned int prefix_len;
361 bool ok;
362
363 ok = parse_network("2001:1234:5678:90ab::dead:beef", &network, &prefix_len);
364 ASSERT_EQ(ok, false);
365}
366
367TEST(CommonIPAddr, ParseNetwork_Bad_IPv6Slash)
368{
369 struct sockaddr_storage network;
370 unsigned int prefix_len;
371 bool ok;
372
373 ok = parse_network("2001:1234:5678:90ab::dead:beef/", &network, &prefix_len);
374 ASSERT_EQ(ok, false);
375}
376
377TEST(CommonIPAddr, ParseNetwork_Bad_IPv6SlashNegative)
378{
379 struct sockaddr_storage network;
380 unsigned int prefix_len;
381 bool ok;
382
383 ok = parse_network("2001:1234:5678:90ab::dead:beef/-3", &network, &prefix_len);
384 ASSERT_EQ(ok, false);
385}
386
387TEST(CommonIPAddr, ParseNetwork_Bad_IPv6SlashJunk)
388{
389 struct sockaddr_storage network;
390 unsigned int prefix_len;
391 bool ok;
392
393 ok = parse_network("2001:1234:5678:90ab::dead:beef/foo", &network, &prefix_len);
394 ASSERT_EQ(ok, false);
395}
396
397TEST(CommonIPAddr, ParseNetwork_IPv4_0)
398{
399 struct sockaddr_in network;
400 struct sockaddr_storage net_storage;
401 unsigned int prefix_len;
402 bool ok;
403
404 ok = parse_network("123.123.123.123/0", &net_storage, &prefix_len);
405 network = *(struct sockaddr_in *) &net_storage;
406 ASSERT_EQ(ok, true);
407 ASSERT_EQ(0U, prefix_len);
408 ASSERT_EQ(AF_INET, network.sin_family);
409 ASSERT_EQ(0, network.sin_port);
410 struct sockaddr_in want;
411 ipv4(&want, "123.123.123.123");
412 ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
413}
414
415TEST(CommonIPAddr, ParseNetwork_IPv4_13)
416{
417 struct sockaddr_in network;
418 struct sockaddr_storage net_storage;
419 unsigned int prefix_len;
420 bool ok;
421
422 ok = parse_network("123.123.123.123/13", &net_storage, &prefix_len);
423 network = *(struct sockaddr_in *) &net_storage;
424 ASSERT_EQ(ok, true);
425 ASSERT_EQ(13U, prefix_len);
426 ASSERT_EQ(AF_INET, network.sin_family);
427 ASSERT_EQ(0, network.sin_port);
428 struct sockaddr_in want;
429 ipv4(&want, "123.123.123.123");
430 ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
431}
432
433TEST(CommonIPAddr, ParseNetwork_IPv4_32)
434{
435 struct sockaddr_in network;
436 struct sockaddr_storage net_storage;
437 unsigned int prefix_len;
438 bool ok;
439
440 ok = parse_network("123.123.123.123/32", &net_storage, &prefix_len);
441 network = *(struct sockaddr_in *) &net_storage;
442 ASSERT_EQ(ok, true);
443 ASSERT_EQ(32U, prefix_len);
444 ASSERT_EQ(AF_INET, network.sin_family);
445 ASSERT_EQ(0, network.sin_port);
446 struct sockaddr_in want;
447 ipv4(&want, "123.123.123.123");
448 ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
449}
450
451TEST(CommonIPAddr, ParseNetwork_IPv4_42)
452{
453 struct sockaddr_in network;
454 struct sockaddr_storage net_storage;
455 unsigned int prefix_len;
456 bool ok;
457
458 ok = parse_network("123.123.123.123/42", &net_storage, &prefix_len);
459 network = *(struct sockaddr_in *) &net_storage;
460 ASSERT_EQ(ok, true);
461 ASSERT_EQ(42U, prefix_len);
462 ASSERT_EQ(AF_INET, network.sin_family);
463 ASSERT_EQ(0, network.sin_port);
464 struct sockaddr_in want;
465 ipv4(&want, "123.123.123.123");
466 ASSERT_EQ(want.sin_addr.s_addr, network.sin_addr.s_addr);
467}
468
469TEST(CommonIPAddr, ParseNetwork_IPv6_0)
470{
471 struct sockaddr_in6 network;
472 struct sockaddr_storage net_storage;
473 unsigned int prefix_len;
474 bool ok;
475
476 ok = parse_network("2001:1234:5678:90ab::dead:beef/0", &net_storage, &prefix_len);
477 network = *(struct sockaddr_in6 *) &net_storage;
478 ASSERT_EQ(ok, true);
479 ASSERT_EQ(0U, prefix_len);
480 ASSERT_EQ(AF_INET6, network.sin6_family);
481 ASSERT_EQ(0, network.sin6_port);
482 struct sockaddr_in6 want;
483 ipv6(&want, "2001:1234:5678:90ab::dead:beef");
484 ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
485}
486
487TEST(CommonIPAddr, ParseNetwork_IPv6_67)
488{
489 struct sockaddr_in6 network;
490 struct sockaddr_storage net_storage;
491 unsigned int prefix_len;
492 bool ok;
493
494 ok = parse_network("2001:1234:5678:90ab::dead:beef/67", &net_storage, &prefix_len);
495 network = *(struct sockaddr_in6 *) &net_storage;
496 ASSERT_EQ(ok, true);
497 ASSERT_EQ(67U, prefix_len);
498 ASSERT_EQ(AF_INET6, network.sin6_family);
499 ASSERT_EQ(0, network.sin6_port);
500 struct sockaddr_in6 want;
501 ipv6(&want, "2001:1234:5678:90ab::dead:beef");
502 ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
503}
504
505TEST(CommonIPAddr, ParseNetwork_IPv6_128)
506{
507 struct sockaddr_in6 network;
508 struct sockaddr_storage net_storage;
509 unsigned int prefix_len;
510 bool ok;
511
512 ok = parse_network("2001:1234:5678:90ab::dead:beef/128", &net_storage, &prefix_len);
513 network = *(struct sockaddr_in6 *) &net_storage;
514 ASSERT_EQ(ok, true);
515 ASSERT_EQ(128U, prefix_len);
516 ASSERT_EQ(AF_INET6, network.sin6_family);
517 ASSERT_EQ(0, network.sin6_port);
518 struct sockaddr_in6 want;
519 ipv6(&want, "2001:1234:5678:90ab::dead:beef");
520 ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
521}
522
523TEST(CommonIPAddr, ParseNetwork_IPv6_9000)
524{
525 struct sockaddr_in6 network;
526 struct sockaddr_storage net_storage;
527 unsigned int prefix_len;
528 bool ok;
529
530 ok = parse_network("2001:1234:5678:90ab::dead:beef/9000", &net_storage, &prefix_len);
531 network = *(struct sockaddr_in6 *) &net_storage;
532 ASSERT_EQ(ok, true);
533 ASSERT_EQ(9000U, prefix_len);
534 ASSERT_EQ(AF_INET6, network.sin6_family);
535 ASSERT_EQ(0, network.sin6_port);
536 struct sockaddr_in6 want;
537 ipv6(&want, "2001:1234:5678:90ab::dead:beef");
538 ASSERT_EQ(0, memcmp(want.sin6_addr.s6_addr, network.sin6_addr.s6_addr, sizeof(network.sin6_addr.s6_addr)));
539}
Ceph