src/tests/testAddress.cc

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