← Back to branch summary

~ubuntu-branches/ubuntu/raring/ceph/raring

« back to all changes in this revision

Viewing changes to src/test/test_ipaddr.cc

  • Committer: Package Import Robot
  • Author(s): Laszlo Boszormenyi (GCS)
  • Date: 2012-02-05 10:07:38 UTC
  • mfrom: (1.1.7) (0.1.11 sid)
  • Revision ID: package-import@ubuntu.com-20120205100738-00s0bxx93mamy8tk
Tags: 0.41-1
New upstream release.

Show diffs side-by-side

added added

removed removed

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