← Back to branch summary

~clint-fewbar/ubuntu/precise/squid3/ignore-sighup-early

« back to all changes in this revision

Viewing changes to src/ip/testIpAddress.cc

  • Committer: Bazaar Package Importer
  • Author(s): Luigi Gangitano
  • Date: 2009-09-24 14:51:06 UTC
  • mfrom: (1.1.12 upstream)
  • mto: (20.2.1 sid)
  • mto: This revision was merged to the branch mainline in revision 21.
  • Revision ID: james.westby@ubuntu.com-20090924145106-38jgrzmj0d73pha5
Tags: 3.1.0.13-1
http://bugs.debian.org/523943
http://bugs.debian.org/432351
* Upload to experimental

* New upstream release
  - Fixes Follow-X-Forwarded-For support (Closes: #523943)
  - Adds IPv6 support (Closes: #432351)

* debian/rules
  - Removed obsolete configuration options
  - Enable db and radius basic authentication modules

* debian/patches/01-cf.data.debian
  - Adapted to new upstream version

* debian/patches/02-makefile-defaults
  - Adapted to new upstream version

* debian/{squid.postinst,squid.rc,README.Debian,watch}
  - Updated references to squid 3.1

* debian/squid3.install
  - Install CSS file for error pages
  - Install manual pages for new authentication modules

* debian/squid3-common.install
  - Install documented version of configuration file in /usr/share/doc/squid3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ip/testIpAddress.cc
 
1
#include "config.h"
 
2
#include "testIpAddress.h"
 
3
#include "ip/IpAddress.h"
 
4
 
 
5
#if HAVE_CSTRING
 
6
#include <cstring>
 
7
#endif
 
8
#if HAVE_NETINET_IN_H
 
9
#include <netinet/in.h>
 
10
#endif
 
11
#if HAVE_ARPA_INET_H
 
12
#include <arpa/inet.h>
 
13
#endif
 
14
#if HAVE_NETDB_H
 
15
#include <netdb.h>
 
16
#endif
 
17
#if HAVE_STRING
 
18
#include <string>
 
19
#endif
 
20
#if HAVE_STDEXCEPT
 
21
#include <stdexcept>
 
22
#endif
 
23
 
 
24
 
 
25
CPPUNIT_TEST_SUITE_REGISTRATION( testIpAddress );
 
26
 
 
27
/* so that we don't break POD dependency just for the test */
 
28
struct timeval current_time;
 
29
double current_dtime;
 
30
time_t squid_curtime = 0;
 
31
 
 
32
 
 
33
void
 
34
testIpAddress::testDefaults()
 
35
{
 
36
    IpAddress anIPA;
 
37
 
 
38
    /* test stored values */
 
39
    CPPUNIT_ASSERT( anIPA.IsAnyAddr() );
 
40
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
41
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
42
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
43
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
44
#if USE_IPV6
 
45
    CPPUNIT_ASSERT( anIPA.IsIPv6() );
 
46
#else
 
47
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
48
#endif
 
49
}
 
50
 
 
51
void
 
52
testIpAddress::testInAddrConstructor()
 
53
{
 
54
    struct in_addr inval;
 
55
    struct in_addr outval;
 
56
 
 
57
    inval.s_addr = htonl(0xC0A8640C);
 
58
    outval.s_addr = htonl(0x00000000);
 
59
 
 
60
    IpAddress anIPA(inval);
 
61
 
 
62
    /* test stored values */
 
63
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
64
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
65
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
66
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
67
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
68
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
69
    anIPA.GetInAddr(outval);
 
70
    CPPUNIT_ASSERT( memcmp(&inval, &outval, sizeof(struct in_addr)) == 0 );
 
71
}
 
72
 
 
73
#if USE_IPV6
 
74
void
 
75
testIpAddress::testInAddr6Constructor()
 
76
{
 
77
    struct in6_addr inval;
 
78
    struct in6_addr outval = IN6ADDR_ANY_INIT;
 
79
 
 
80
    inval.s6_addr32[0] = htonl(0xC0A8640C);
 
81
    inval.s6_addr32[1] = htonl(0xFFFFFFFF);
 
82
    inval.s6_addr32[2] = htonl(0xFFFFFFFF);
 
83
    inval.s6_addr32[3] = htonl(0xFFFFFFFF);
 
84
 
 
85
    IpAddress anIPA(inval);
 
86
 
 
87
    /* test stored values */
 
88
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
89
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
90
    CPPUNIT_ASSERT( !anIPA.IsIPv4() );
 
91
    CPPUNIT_ASSERT( anIPA.IsIPv6() );
 
92
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
93
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
94
    anIPA.GetInAddr(outval);
 
95
    CPPUNIT_ASSERT( memcmp( &inval, &outval, sizeof(struct in6_addr)) == 0 );
 
96
}
 
97
#endif
 
98
 
 
99
void
 
100
testIpAddress::testSockAddrConstructor()
 
101
{
 
102
    struct sockaddr_in insock;
 
103
    struct sockaddr_in outsock;
 
104
 
 
105
    memset(&insock,  0, sizeof(struct sockaddr_in));
 
106
    memset(&outsock, 0, sizeof(struct sockaddr_in));
 
107
 
 
108
    insock.sin_family = AF_INET;
 
109
    insock.sin_port = htons(80);
 
110
    insock.sin_addr.s_addr = htonl(0xC0A8640C);
 
111
#if HAVE_SIN_LEN_IN_SAI
 
112
    insock.sin_len = sizeof(struct sockaddr_in);
 
113
#endif
 
114
 
 
115
    IpAddress anIPA((const struct sockaddr_in)insock);
 
116
 
 
117
    /* test stored values */
 
118
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
119
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
120
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
121
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
122
    CPPUNIT_ASSERT( anIPA.IsSockAddr() );
 
123
    CPPUNIT_ASSERT_EQUAL( (u_short) 80 , anIPA.GetPort() );
 
124
    anIPA.GetSockAddr(outsock);
 
125
    CPPUNIT_ASSERT( memcmp( &insock, &outsock, sizeof(struct sockaddr_in)) == 0 );
 
126
}
 
127
 
 
128
#if USE_IPV6
 
129
void
 
130
testIpAddress::testSockAddr6Constructor()
 
131
{
 
132
    struct sockaddr_in6 insock;
 
133
    struct sockaddr_in6 outsock;
 
134
 
 
135
    memset(&insock, 0, sizeof(struct sockaddr_in6));
 
136
    memset(&outsock, 0, sizeof(struct sockaddr_in6));
 
137
 
 
138
    insock.sin6_family = AF_INET6;
 
139
    insock.sin6_port = htons(80);
 
140
    insock.sin6_addr.s6_addr32[0] = htonl(0xFFFFFFFF);
 
141
    insock.sin6_addr.s6_addr32[1] = htonl(0x00000000);
 
142
    insock.sin6_addr.s6_addr32[2] = htonl(0x0000FFFF);
 
143
    insock.sin6_addr.s6_addr32[3] = htonl(0xC0A8640C);
 
144
#if HAVE_SIN6_LEN_IN_SAI
 
145
    insock.sin6_len = sizeof(struct sockaddr_in6);
 
146
#endif
 
147
 
 
148
    IpAddress anIPA((const struct sockaddr_in6)insock);
 
149
 
 
150
    /* test stored values */
 
151
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
152
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
153
    CPPUNIT_ASSERT( !anIPA.IsIPv4() );
 
154
    CPPUNIT_ASSERT( anIPA.IsIPv6() );
 
155
    CPPUNIT_ASSERT( anIPA.IsSockAddr() );
 
156
    CPPUNIT_ASSERT_EQUAL( (u_short) 80 , anIPA.GetPort() );
 
157
    anIPA.GetSockAddr(outsock);
 
158
    CPPUNIT_ASSERT( memcmp( &insock, &outsock, sizeof(struct sockaddr_in6)) == 0 );
 
159
}
 
160
#endif
 
161
 
 
162
 
 
163
void
 
164
testIpAddress::testCopyConstructor()
 
165
{
 
166
    struct sockaddr_in insock;
 
167
    struct sockaddr_in outsock;
 
168
 
 
169
    memset(&insock,  0, sizeof(struct sockaddr_in));
 
170
    memset(&outsock, 0, sizeof(struct sockaddr_in));
 
171
 
 
172
    insock.sin_family = AF_INET;
 
173
    insock.sin_port = htons(80);
 
174
    insock.sin_addr.s_addr = htonl(0xC0A8640C);
 
175
#if HAVE_SIN_LEN_IN_SAI
 
176
    insock.sin_len = sizeof(struct sockaddr_in);
 
177
#endif
 
178
 
 
179
    IpAddress inIPA(insock);
 
180
    IpAddress outIPA(inIPA);
 
181
 
 
182
 
 
183
    /* test stored values */
 
184
    CPPUNIT_ASSERT( !outIPA.IsAnyAddr() );
 
185
    CPPUNIT_ASSERT( !outIPA.IsNoAddr() );
 
186
    CPPUNIT_ASSERT( outIPA.IsIPv4() );
 
187
    CPPUNIT_ASSERT( !outIPA.IsIPv6() );
 
188
    CPPUNIT_ASSERT( outIPA.IsSockAddr() );
 
189
    CPPUNIT_ASSERT_EQUAL( (u_short) 80 , outIPA.GetPort() );
 
190
    outIPA.GetSockAddr(outsock);
 
191
    CPPUNIT_ASSERT( memcmp( &insock, &outsock, sizeof(struct sockaddr_in)) == 0 );
 
192
}
 
193
 
 
194
void
 
195
testIpAddress::testHostentConstructor()
 
196
{
 
197
    struct hostent *hp = NULL;
 
198
    struct in_addr outval;
 
199
    struct in_addr expectval;
 
200
 
 
201
    expectval.s_addr = htonl(0xC0A8640C);
 
202
 
 
203
    hp = gethostbyname("192.168.100.12");
 
204
    CPPUNIT_ASSERT( hp != NULL /* gethostbyname failure.*/ );
 
205
 
 
206
    IpAddress anIPA(*hp);
 
207
 
 
208
    /* test stored values */
 
209
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
210
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
211
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
212
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
213
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
214
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
215
    anIPA.GetInAddr(outval);
 
216
    CPPUNIT_ASSERT( memcmp( &expectval, &outval, sizeof(struct in_addr)) == 0 );
 
217
}
 
218
 
 
219
void
 
220
testIpAddress::testStringConstructor()
 
221
{
 
222
    struct in_addr outval;
 
223
    struct in_addr expectval;
 
224
 
 
225
    expectval.s_addr = htonl(0xC0A8640C);
 
226
 
 
227
    IpAddress anIPA = "192.168.100.12";
 
228
 
 
229
    /* test stored values */
 
230
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
231
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
232
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
233
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
234
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
235
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
236
    anIPA.GetInAddr(outval);
 
237
    CPPUNIT_ASSERT( memcmp( &expectval, &outval, sizeof(struct in_addr)) == 0 );
 
238
 
 
239
#if USE_IPV6
 
240
    struct in6_addr expectv6;
 
241
    struct in6_addr outval6;
 
242
 
 
243
    expectv6.s6_addr32[0] = htonl(0x20000800);
 
244
    expectv6.s6_addr32[1] = htonl(0x00000000);
 
245
    expectv6.s6_addr32[2] = htonl(0x00000000);
 
246
    expectv6.s6_addr32[3] = htonl(0x00000045);
 
247
 
 
248
    IpAddress bnIPA = "2000:800::45";
 
249
 
 
250
    /* test stored values */
 
251
    CPPUNIT_ASSERT( !bnIPA.IsAnyAddr() );
 
252
    CPPUNIT_ASSERT( !bnIPA.IsNoAddr() );
 
253
    CPPUNIT_ASSERT( !bnIPA.IsIPv4() );
 
254
    CPPUNIT_ASSERT(  bnIPA.IsIPv6() );
 
255
    CPPUNIT_ASSERT( !bnIPA.IsSockAddr() );
 
256
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , bnIPA.GetPort() );
 
257
    bnIPA.GetInAddr(outval6);
 
258
    CPPUNIT_ASSERT( memcmp( &expectv6, &outval6, sizeof(struct in6_addr)) == 0 );
 
259
 
 
260
    /* test IPv6 as an old netmask format. This is invalid but sometimes use. */
 
261
    IpAddress cnIPA = "ffff:ffff:fff0::";
 
262
 
 
263
    expectv6.s6_addr32[0] = htonl(0xFFFFFFFF);
 
264
    expectv6.s6_addr32[1] = htonl(0xFFF00000);
 
265
    expectv6.s6_addr32[2] = htonl(0x00000000);
 
266
    expectv6.s6_addr32[3] = htonl(0x00000000);
 
267
 
 
268
    /* test stored values */
 
269
    CPPUNIT_ASSERT( !cnIPA.IsAnyAddr() );
 
270
    CPPUNIT_ASSERT( !cnIPA.IsNoAddr() );
 
271
    CPPUNIT_ASSERT( !cnIPA.IsIPv4() );
 
272
    CPPUNIT_ASSERT( cnIPA.IsIPv6() );
 
273
    CPPUNIT_ASSERT( !cnIPA.IsSockAddr() );
 
274
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , cnIPA.GetPort() );
 
275
    cnIPA.GetInAddr(outval6);
 
276
    CPPUNIT_ASSERT( memcmp( &expectv6, &outval6, sizeof(struct in6_addr)) == 0 );
 
277
#endif
 
278
}
 
279
 
 
280
void
 
281
testIpAddress::testSetEmpty()
 
282
{
 
283
    IpAddress anIPA;
 
284
    struct in_addr inval;
 
285
 
 
286
    inval.s_addr = htonl(0xC0A8640C);
 
287
 
 
288
    anIPA = inval;
 
289
 
 
290
    /* test stored values before empty */
 
291
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
292
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
293
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
294
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
295
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
296
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
297
 
 
298
    anIPA.SetEmpty();
 
299
 
 
300
    /* test stored values after empty */
 
301
    CPPUNIT_ASSERT( anIPA.IsAnyAddr() );
 
302
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
303
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
304
#if USE_IPV6
 
305
    CPPUNIT_ASSERT( anIPA.IsIPv6() );
 
306
#else
 
307
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
308
#endif
 
309
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
310
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
311
}
 
312
 
 
313
void
 
314
testIpAddress::testBooleans()
 
315
{
 
316
    IpAddress lhsIPA;
 
317
    IpAddress rhsIPA;
 
318
    struct in_addr valLow;
 
319
    struct in_addr valHigh;
 
320
 
 
321
    valLow.s_addr  = htonl(0xC0A8640C);
 
322
    valHigh.s_addr = htonl(0xC0A8640F);
 
323
 
 
324
    /* test equality */
 
325
    lhsIPA = valLow;
 
326
    rhsIPA = valLow;
 
327
    CPPUNIT_ASSERT( lhsIPA.matchIPAddr(rhsIPA) == 0 );
 
328
    CPPUNIT_ASSERT(  ( lhsIPA == rhsIPA ) );
 
329
    CPPUNIT_ASSERT( !( lhsIPA != rhsIPA ) );
 
330
    CPPUNIT_ASSERT(  ( lhsIPA >= rhsIPA ) );
 
331
    CPPUNIT_ASSERT( !( lhsIPA >  rhsIPA ) );
 
332
    CPPUNIT_ASSERT(  ( lhsIPA <= rhsIPA ) );
 
333
    CPPUNIT_ASSERT( !( lhsIPA <  rhsIPA ) );
 
334
 
 
335
    /* test inequality (less than) */
 
336
    lhsIPA = valLow;
 
337
    rhsIPA = valHigh;
 
338
    CPPUNIT_ASSERT( lhsIPA.matchIPAddr(rhsIPA) < 0 );
 
339
    CPPUNIT_ASSERT( !( lhsIPA == rhsIPA ) );
 
340
    CPPUNIT_ASSERT(  ( lhsIPA != rhsIPA ) );
 
341
    CPPUNIT_ASSERT( !( lhsIPA >= rhsIPA ) );
 
342
    CPPUNIT_ASSERT( !( lhsIPA >  rhsIPA ) );
 
343
    CPPUNIT_ASSERT(  ( lhsIPA <= rhsIPA ) );
 
344
    CPPUNIT_ASSERT(  ( lhsIPA <  rhsIPA ) );
 
345
 
 
346
    /* test inequality (greater than) */
 
347
    lhsIPA = valHigh;
 
348
    rhsIPA = valLow;
 
349
    CPPUNIT_ASSERT( lhsIPA.matchIPAddr(rhsIPA) > 0 );
 
350
    CPPUNIT_ASSERT( !( lhsIPA == rhsIPA ) );
 
351
    CPPUNIT_ASSERT(  ( lhsIPA != rhsIPA ) );
 
352
    CPPUNIT_ASSERT(  ( lhsIPA >= rhsIPA ) );
 
353
    CPPUNIT_ASSERT(  ( lhsIPA >  rhsIPA ) );
 
354
    CPPUNIT_ASSERT( !( lhsIPA <= rhsIPA ) );
 
355
    CPPUNIT_ASSERT( !( lhsIPA <  rhsIPA ) );
 
356
 
 
357
}
 
358
 
 
359
void
 
360
testIpAddress::testNtoA()
 
361
{
 
362
    struct in_addr inval;
 
363
    char buf[MAX_IPSTRLEN];
 
364
    IpAddress anIPA;
 
365
 
 
366
    anIPA.SetAnyAddr();
 
367
 
 
368
    /* test AnyAddr display values */
 
369
#if USE_IPV6
 
370
    CPPUNIT_ASSERT( memcmp("::", anIPA.NtoA(buf,MAX_IPSTRLEN), 2) == 0 );
 
371
#else
 
372
    CPPUNIT_ASSERT( memcmp("0.0.0.0",anIPA.NtoA(buf,MAX_IPSTRLEN), 7) == 0 );
 
373
#endif
 
374
 
 
375
    inval.s_addr = htonl(0xC0A8640C);
 
376
    anIPA = inval;
 
377
 
 
378
    /* test IP display */
 
379
    CPPUNIT_ASSERT( memcmp("192.168.100.12",anIPA.NtoA(buf,MAX_IPSTRLEN), 14) == 0 );
 
380
 
 
381
    anIPA.SetNoAddr();
 
382
 
 
383
    /* test NoAddr display values */
 
384
#if USE_IPV6
 
385
    CPPUNIT_ASSERT( memcmp("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",anIPA.NtoA(buf,MAX_IPSTRLEN), 39) == 0 );
 
386
#else
 
387
    CPPUNIT_ASSERT( memcmp("255.255.255.255",anIPA.NtoA(buf,MAX_IPSTRLEN), 15) == 0 );
 
388
#endif
 
389
}
 
390
 
 
391
void
 
392
testIpAddress::testToURL_fromInAddr()
 
393
{
 
394
    char buf[MAX_IPSTRLEN];
 
395
    buf[0] = '\0';
 
396
    struct in_addr inval;
 
397
 
 
398
    inval.s_addr = htonl(0xC0A8640C);
 
399
 
 
400
    IpAddress anIPA(inval);
 
401
 
 
402
    /* test values */
 
403
    anIPA.ToURL(buf,MAX_IPSTRLEN);
 
404
    CPPUNIT_ASSERT( memcmp("192.168.100.12", buf, 14) == 0 );
 
405
 
 
406
#if USE_IPV6
 
407
 
 
408
    /* test output when constructed from in6_addr with IPv6 */
 
409
    struct in6_addr ip6val;
 
410
 
 
411
    ip6val.s6_addr32[0] = htonl(0xC0A8640C);
 
412
    ip6val.s6_addr32[1] = htonl(0xFFFFFFFF);
 
413
    ip6val.s6_addr32[2] = htonl(0xFFFFFFFF);
 
414
    ip6val.s6_addr32[3] = htonl(0xFFFFFFFF);
 
415
 
 
416
    IpAddress bnIPA(ip6val);
 
417
 
 
418
    bnIPA.ToURL(buf,MAX_IPSTRLEN);
 
419
    CPPUNIT_ASSERT( memcmp("[c0a8:640c:ffff:ffff:ffff:ffff:ffff:ffff]", buf, 41) == 0 );
 
420
 
 
421
#endif
 
422
}
 
423
 
 
424
void
 
425
testIpAddress::testToURL_fromSockAddr()
 
426
{
 
427
    struct sockaddr_in sock;
 
428
    sock.sin_addr.s_addr = htonl(0xC0A8640C);
 
429
    sock.sin_port = htons(80);
 
430
    sock.sin_family = AF_INET;
 
431
#if HAVE_SIN_LEN_IN_SAI
 
432
    sock.sin_len = sizeof(struct sockaddr_in);
 
433
#endif
 
434
 
 
435
    IpAddress anIPA(sock);
 
436
    char buf[MAX_IPSTRLEN];
 
437
 
 
438
    /* test values */
 
439
    anIPA.ToURL(buf,MAX_IPSTRLEN);
 
440
    CPPUNIT_ASSERT( memcmp("192.168.100.12:80", buf, 17) == 0 );
 
441
 
 
442
#if USE_IPV6
 
443
 
 
444
    /* test output when constructed from in6_addr with IPv6 */
 
445
    struct sockaddr_in6 ip6val;
 
446
 
 
447
    ip6val.sin6_addr.s6_addr32[0] = htonl(0xC0A8640C);
 
448
    ip6val.sin6_addr.s6_addr32[1] = htonl(0xFFFFFFFF);
 
449
    ip6val.sin6_addr.s6_addr32[2] = htonl(0xFFFFFFFF);
 
450
    ip6val.sin6_addr.s6_addr32[3] = htonl(0xFFFFFFFF);
 
451
    ip6val.sin6_port = htons(80);
 
452
    ip6val.sin6_family = AF_INET6;
 
453
#if HAVE_SIN6_LEN_IN_SAI
 
454
    ip6val.sin6_len = sizeof(struct sockaddr_in6);
 
455
#endif
 
456
 
 
457
    IpAddress bnIPA(ip6val);
 
458
 
 
459
    bnIPA.ToURL(buf,MAX_IPSTRLEN);
 
460
    CPPUNIT_ASSERT( memcmp("[c0a8:640c:ffff:ffff:ffff:ffff:ffff:ffff]:80", buf, 44) == 0 );
 
461
 
 
462
#endif
 
463
 
 
464
}
 
465
 
 
466
void
 
467
testIpAddress::testGetReverseString()
 
468
{
 
469
    char buf[MAX_IPSTRLEN];
 
470
 
 
471
    struct in_addr ipv4val;
 
472
    ipv4val.s_addr = htonl(0xC0A8640C);
 
473
 
 
474
    IpAddress v4IPA(ipv4val);
 
475
 
 
476
    /* test IPv4 output */
 
477
    v4IPA.GetReverseString(buf);
 
478
    CPPUNIT_ASSERT( memcmp("12.100.168.192.in-addr.arpa.",buf, 28) == 0 );
 
479
 
 
480
    v4IPA.GetReverseString(buf,AF_INET);
 
481
    CPPUNIT_ASSERT( memcmp("12.100.168.192.in-addr.arpa.",buf, 28) == 0 );
 
482
 
 
483
    v4IPA.GetReverseString(buf,AF_INET6);
 
484
    CPPUNIT_ASSERT( memcmp("",buf, 1) == 0 );
 
485
 
 
486
 
 
487
#if USE_IPV6
 
488
    struct in6_addr ip6val;
 
489
 
 
490
    ip6val.s6_addr32[0] = htonl(0xC0A8640C);
 
491
    ip6val.s6_addr32[1] = htonl(0xFFFFFFFF);
 
492
    ip6val.s6_addr32[2] = htonl(0xFFFFFFFF);
 
493
    ip6val.s6_addr32[3] = htonl(0xFFFFFFFF);
 
494
 
 
495
    IpAddress v6IPA(ip6val);
 
496
 
 
497
    /* test IPv6 output */
 
498
    v6IPA.GetReverseString(buf);
 
499
    CPPUNIT_ASSERT( memcmp("f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.f.c.0.4.6.8.a.0.c.ip6.arpa.",buf,73) == 0 );
 
500
 
 
501
#endif
 
502
 
 
503
}
 
504
 
 
505
void
 
506
testIpAddress::testMasking()
 
507
{
 
508
    char buf[MAX_IPSTRLEN];
 
509
    IpAddress anIPA;
 
510
    IpAddress maskIPA;
 
511
 
 
512
    /* Test Basic CIDR Routine */
 
513
    anIPA.SetAnyAddr();
 
514
    CPPUNIT_ASSERT_EQUAL( 0 ,anIPA.GetCIDR() );
 
515
 
 
516
    anIPA.SetNoAddr();
 
517
#if USE_IPV6
 
518
    CPPUNIT_ASSERT_EQUAL( 128 , anIPA.GetCIDR() );
 
519
#else
 
520
    CPPUNIT_ASSERT_EQUAL( 32 , anIPA.GetCIDR() );
 
521
#endif
 
522
 
 
523
    /* Test Numeric ApplyCIDR */
 
524
    anIPA.SetNoAddr();
 
525
    CPPUNIT_ASSERT( !anIPA.ApplyMask(129) );
 
526
#if !USE_IPV6
 
527
    CPPUNIT_ASSERT( !anIPA.ApplyMask(33) );
 
528
#endif
 
529
    CPPUNIT_ASSERT( anIPA.ApplyMask(31) );
 
530
    CPPUNIT_ASSERT_EQUAL( 31 , anIPA.GetCIDR() );
 
531
 
 
532
    anIPA.SetNoAddr();
 
533
    anIPA.ApplyMask(31, AF_INET);
 
534
#if USE_IPV6
 
535
    CPPUNIT_ASSERT_EQUAL( 127 , anIPA.GetCIDR() );
 
536
#else
 
537
    CPPUNIT_ASSERT_EQUAL( 31 , anIPA.GetCIDR() );
 
538
#endif
 
539
 
 
540
#if USE_IPV6
 
541
    anIPA.SetNoAddr();
 
542
    anIPA.ApplyMask(80,AF_INET6);
 
543
    CPPUNIT_ASSERT_EQUAL( 80 , anIPA.GetCIDR() );
 
544
    /* BUG Check: test values by display. */
 
545
    CPPUNIT_ASSERT( anIPA.NtoA(buf,MAX_IPSTRLEN) != NULL );
 
546
    CPPUNIT_ASSERT( memcmp("ffff:ffff:ffff:ffff:ffff::", buf, 26) == 0 );
 
547
#endif
 
548
 
 
549
    /* Test Network Bitmask from IpAddress */
 
550
    anIPA.SetNoAddr();
 
551
    maskIPA = "255.255.240.0";
 
552
    CPPUNIT_ASSERT_EQUAL( 20 , maskIPA.GetCIDR() );
 
553
    anIPA.ApplyMask(maskIPA);
 
554
    CPPUNIT_ASSERT_EQUAL( 20 , anIPA.GetCIDR() );
 
555
 
 
556
    /* BUG Check: test values memory after masking. */
 
557
    struct in_addr btest;
 
558
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
559
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
560
    anIPA.GetInAddr(btest);
 
561
    CPPUNIT_ASSERT_EQUAL( (uint32_t)htonl(0xFFFFF000) , btest.s_addr );
 
562
 
 
563
    /* BUG Check failing test. Masked values for display. */
 
564
    CPPUNIT_ASSERT( memcmp("255.255.240.0",anIPA.NtoA(buf,MAX_IPSTRLEN), 13) == 0 );
 
565
 
 
566
 
 
567
#if USE_IPV6
 
568
    anIPA.SetNoAddr();
 
569
    maskIPA.SetNoAddr();
 
570
 
 
571
    /* IPv6 masks MUST be CIDR representations. */
 
572
    /* however as with IPv4 they can technically be represented as a bitmask */
 
573
    maskIPA = "ffff:ffff:fff0::";
 
574
    CPPUNIT_ASSERT( !maskIPA.IsAnyAddr() );
 
575
    CPPUNIT_ASSERT( !maskIPA.IsNoAddr() );
 
576
    anIPA.ApplyMask(maskIPA);
 
577
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
578
    CPPUNIT_ASSERT_EQUAL( 44 , anIPA.GetCIDR() );
 
579
 
 
580
    anIPA.SetNoAddr();
 
581
    maskIPA.SetNoAddr();
 
582
 
 
583
    /* IPv4 masks represented in IPv6 as IPv4 bitmasks. */
 
584
    maskIPA = "::ffff:ffff:f000";
 
585
    CPPUNIT_ASSERT( !maskIPA.IsAnyAddr() );
 
586
    CPPUNIT_ASSERT( !maskIPA.IsNoAddr() );
 
587
    CPPUNIT_ASSERT(  maskIPA.IsIPv4() );
 
588
    CPPUNIT_ASSERT( !maskIPA.IsIPv6() );
 
589
    anIPA.ApplyMask(maskIPA);
 
590
    CPPUNIT_ASSERT( !maskIPA.IsAnyAddr() );
 
591
    CPPUNIT_ASSERT( !maskIPA.IsNoAddr() );
 
592
    CPPUNIT_ASSERT(  maskIPA.IsIPv4() );
 
593
    CPPUNIT_ASSERT( !maskIPA.IsIPv6() );
 
594
    CPPUNIT_ASSERT_EQUAL( 20 , anIPA.GetCIDR() );
 
595
#endif
 
596
 
 
597
}
 
598
 
 
599
void
 
600
testIpAddress::testAddrInfo()
 
601
{
 
602
    struct addrinfo *expect;
 
603
    struct addrinfo *ipval = NULL;
 
604
    struct addrinfo hints;
 
605
 
 
606
    memset(&hints, 0, sizeof(struct addrinfo));
 
607
 
 
608
    hints.ai_flags = AI_NUMERICHOST;
 
609
 
 
610
    IpAddress anIP = "127.0.0.1";
 
611
 
 
612
    /* assert this just to check that getaddrinfo is working properly */
 
613
    CPPUNIT_ASSERT( xgetaddrinfo("127.0.0.1", NULL, &hints, &expect ) == 0 );
 
614
 
 
615
    anIP.GetAddrInfo(ipval);
 
616
 
 
617
#if 0
 
618
    /* display a byte-by-byte hex comparison of the addr cores */
 
619
    unsigned int *p;
 
620
    p = (unsigned int*)expect;
 
621
    printf("\nSYS-ADDRINFO: %2x %2x %2x %2x %2x %2x",
 
622
           p[0],p[1],p[2],p[3],p[4],p[5]);
 
623
 
 
624
    p = (unsigned int*)ipval;
 
625
    printf("\nSQD-ADDRINFO: %2x %2x %2x %2x %2x %2x",
 
626
           p[0],p[1],p[2],p[3],p[4],p[5] );
 
627
    printf("\n");
 
628
#endif /*0*/
 
629
 
 
630
    // check the addrinfo object core. (BUT not the two ptrs at the tail)
 
631
    // details
 
632
    CPPUNIT_ASSERT_EQUAL( expect->ai_flags, ipval->ai_flags );
 
633
    CPPUNIT_ASSERT_EQUAL( expect->ai_family, ipval->ai_family );
 
634
    // check the sockaddr it points to.
 
635
    CPPUNIT_ASSERT_EQUAL( expect->ai_addrlen, ipval->ai_addrlen );
 
636
 
 
637
#if 0
 
638
    p = (unsigned int*)(expect->ai_addr);
 
639
    printf("\nSYS-ADDR: (%d)  %x %x %x %x %x %x %x %x ...",
 
640
           expect->ai_addrlen,
 
641
           p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7] );
 
642
 
 
643
    p = (unsigned int*)(ipval->ai_addr);
 
644
    printf("\nSQD-ADDR: (%d) %x %x %x %x %x %x %x %x ...",
 
645
           ipval->ai_addrlen,
 
646
           p[0],p[1],p[2],p[3],p[4],p[5],p[6],p[7] );
 
647
    printf("\n");
 
648
#if HAVE_SS_LEN_IN_SS
 
649
    printf("\nSYS SS_LEN=%d\nSQD SS_LEN=%d\n",((struct sockaddr_storage*)expect->ai_addr)->ss_len,
 
650
           ((struct sockaddr_storage*)ipval->ai_addr)->ss_len );
 
651
#endif
 
652
#endif /*0*/
 
653
 
 
654
#if USE_IPV6
 
655
#if HAVE_SS_LEN_IN_SS
 
656
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_storage*)expect->ai_addr)->ss_len,
 
657
                          ((struct sockaddr_storage*)ipval->ai_addr)->ss_len );
 
658
    CPPUNIT_ASSERT_EQUAL( (socklen_t)((struct sockaddr_storage*)ipval->ai_addr)->ss_len, ipval->ai_addrlen );
 
659
#endif
 
660
#if HAVE_SIN6_LEN_IN_SAI
 
661
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_in6*)expect->ai_addr)->sin6_len,
 
662
                          ((struct sockaddr_in6*)ipval->ai_addr)->sin6_len );
 
663
    CPPUNIT_ASSERT_EQUAL( (socklen_t)((struct sockaddr_in6*)ipval->ai_addr)->sin6_len, ipval->ai_addrlen );
 
664
#endif
 
665
#if HAVE_SIN_LEN_IN_SAI
 
666
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_in*)expect->ai_addr)->sin_len,
 
667
                          ((struct sockaddr_in*)ipval->ai_addr)->sin_len );
 
668
    CPPUNIT_ASSERT_EQUAL( (socklen_t)((struct sockaddr_in*)ipval->ai_addr)->sin_len, ipval->ai_addrlen );
 
669
#endif
 
670
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_in6*)expect->ai_addr)->sin6_family,
 
671
                          ((struct sockaddr_in6*)ipval->ai_addr)->sin6_family );
 
672
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_in6*)expect->ai_addr)->sin6_port,
 
673
                          ((struct sockaddr_in6*)ipval->ai_addr)->sin6_port );
 
674
#else
 
675
#if HAVE_SS_LEN_IN_SS
 
676
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_storage*)expect->ai_addr)->ss_len,
 
677
                          ((struct sockaddr_storage*)ipval->ai_addr)->ss_len );
 
678
    CPPUNIT_ASSERT_EQUAL( (socklen_t)((struct sockaddr_storage*)ipval->ai_addr)->ss_len, ipval->ai_addrlen );
 
679
#endif
 
680
#if HAVE_SIN_LEN_IN_SAI
 
681
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_in*)expect->ai_addr)->sin_len,
 
682
                          ((struct sockaddr_in*)ipval->ai_addr)->sin_len );
 
683
    CPPUNIT_ASSERT_EQUAL( (socklen_t)((struct sockaddr_in*)ipval->ai_addr)->sin_len, ipval->ai_addrlen );
 
684
#endif
 
685
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_in*)expect->ai_addr)->sin_family,
 
686
                          ((struct sockaddr_in*)ipval->ai_addr)->sin_family );
 
687
    CPPUNIT_ASSERT_EQUAL( ((struct sockaddr_in*)expect->ai_addr)->sin_port,
 
688
                          ((struct sockaddr_in*)ipval->ai_addr)->sin_port );
 
689
#endif /* USE_IPV6 */
 
690
 
 
691
    CPPUNIT_ASSERT( memcmp( expect->ai_addr, ipval->ai_addr, expect->ai_addrlen ) == 0 );
 
692
 
 
693
    xfreeaddrinfo(expect);
 
694
}
 
695
 
 
696
void
 
697
testIpAddress::testBugNullingDisplay()
 
698
{
 
699
    // Weird Bug: address set to empty during string conversion somewhere.
 
700
    // initial string gets created and returned OK.
 
701
    // but at the end of the process m_SocketAddr is left NULL'ed
 
702
 
 
703
    char ntoabuf[MAX_IPSTRLEN];
 
704
    char hostbuf[MAX_IPSTRLEN];
 
705
    char urlbuf[MAX_IPSTRLEN];
 
706
 
 
707
    struct in_addr outval;
 
708
    struct in_addr expectval;
 
709
 
 
710
    expectval.s_addr = htonl(0xC0A8640C);
 
711
 
 
712
    IpAddress anIPA = "192.168.100.12";
 
713
 
 
714
 
 
715
    /* test stored values */
 
716
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
717
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
718
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
719
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
720
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
721
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
722
    anIPA.GetInAddr(outval);
 
723
    CPPUNIT_ASSERT( memcmp( &expectval, &outval, sizeof(struct in_addr)) == 0 );
 
724
 
 
725
 
 
726
    /* POKE NtoA display function to see what it is doing */
 
727
    anIPA.NtoA(ntoabuf,MAX_IPSTRLEN);
 
728
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
729
    /* test stored values */
 
730
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
731
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
732
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
733
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
734
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
735
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
736
    anIPA.GetInAddr(outval);
 
737
    CPPUNIT_ASSERT( memcmp( &expectval, &outval, sizeof(struct in_addr)) == 0 );
 
738
 
 
739
 
 
740
 
 
741
    /* POKE ToHostname display function to see what it is doing */
 
742
    anIPA.ToHostname(hostbuf,MAX_IPSTRLEN);
 
743
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
744
    /* test stored values */
 
745
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
746
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
747
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
748
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
749
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
750
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
751
    anIPA.GetInAddr(outval);
 
752
    CPPUNIT_ASSERT( memcmp( &expectval, &outval, sizeof(struct in_addr)) == 0 );
 
753
 
 
754
 
 
755
    /* POKE ToURL display function to see what it is doing */
 
756
    anIPA.ToURL(urlbuf,MAX_IPSTRLEN);
 
757
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
758
    /* test stored values */
 
759
    CPPUNIT_ASSERT( !anIPA.IsAnyAddr() );
 
760
    CPPUNIT_ASSERT( !anIPA.IsNoAddr() );
 
761
    CPPUNIT_ASSERT( anIPA.IsIPv4() );
 
762
    CPPUNIT_ASSERT( !anIPA.IsIPv6() );
 
763
    CPPUNIT_ASSERT_EQUAL( (u_short) 0 , anIPA.GetPort() );
 
764
    CPPUNIT_ASSERT( !anIPA.IsSockAddr() );
 
765
    anIPA.GetInAddr(outval);
 
766
    CPPUNIT_ASSERT( memcmp( &expectval, &outval, sizeof(struct in_addr)) == 0 );
 
767
 
 
768
}