Annotation of embedaddon/strongswan/src/libstrongswan/tests/suites/test_host.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2013 Tobias Brunner
! 3: * HSR Hochschule fuer Technik Rapperswil
! 4: *
! 5: * This program is free software; you can redistribute it and/or modify it
! 6: * under the terms of the GNU General Public License as published by the
! 7: * Free Software Foundation; either version 2 of the License, or (at your
! 8: * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
! 9: *
! 10: * This program is distributed in the hope that it will be useful, but
! 11: * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
! 12: * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
! 13: * for more details.
! 14: */
! 15:
! 16: #include "test_suite.h"
! 17:
! 18: #include <networking/host.h>
! 19:
! 20: /**
! 21: * Verify a netmask (a number of set bits starting at byte 0)
! 22: * Can also be used to check for %any (mask == 0)
! 23: */
! 24: static void verify_netmask(chunk_t addr, int mask)
! 25: {
! 26: int byte, bit;
! 27:
! 28: for (byte = 0; byte < addr.len; byte++)
! 29: {
! 30: for (bit = 7; bit >= 0; bit--)
! 31: {
! 32: int val = (addr.ptr[byte] >> bit) & 0x01;
! 33: if (mask-- > 0)
! 34: {
! 35: ck_assert_int_eq(val, 1);
! 36: }
! 37: else
! 38: {
! 39: ck_assert_int_eq(val, 0);
! 40: }
! 41: }
! 42: }
! 43: }
! 44:
! 45: /*******************************************************************************
! 46: * host_create_any
! 47: */
! 48:
! 49: static void verify_any(host_t *host, int family, uint16_t port)
! 50: {
! 51: verify_netmask(host->get_address(host), 0);
! 52: ck_assert(host->is_anyaddr(host));
! 53: ck_assert_int_eq(host->get_port(host), port);
! 54: ck_assert_int_eq(host->get_family(host), family);
! 55: }
! 56:
! 57: static void test_create_any(int family)
! 58: {
! 59: host_t *host;
! 60:
! 61: host = host_create_any(family);
! 62: verify_any(host, family, 0);
! 63: host->destroy(host);
! 64: }
! 65:
! 66: START_TEST(test_create_any_v4)
! 67: {
! 68: test_create_any(AF_INET);
! 69: }
! 70: END_TEST
! 71:
! 72: START_TEST(test_create_any_v6)
! 73: {
! 74: test_create_any(AF_INET6);
! 75: }
! 76: END_TEST
! 77:
! 78: START_TEST(test_create_any_other)
! 79: {
! 80: host_t *host;
! 81:
! 82: host = host_create_any(AF_UNSPEC);
! 83: ck_assert(host == NULL);
! 84: }
! 85: END_TEST
! 86:
! 87: /*******************************************************************************
! 88: * host_create_from_string
! 89: */
! 90:
! 91: static void verify_address(host_t *host, chunk_t addr, int family, uint16_t port)
! 92: {
! 93: ck_assert(chunk_equals(host->get_address(host), addr));
! 94: ck_assert(!host->is_anyaddr(host));
! 95: ck_assert_int_eq(host->get_port(host), port);
! 96: ck_assert_int_eq(host->get_family(host), family);
! 97: }
! 98:
! 99: static const chunk_t addr_v4 = chunk_from_chars(0xc0, 0xa8, 0x00, 0x01);
! 100: static const chunk_t addr_v6 = chunk_from_chars(0xfe, 0xc1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 101: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01);
! 102:
! 103: START_TEST(test_create_from_string_v4)
! 104: {
! 105: host_t *host;
! 106:
! 107: host = host_create_from_string(NULL, 500);
! 108: ck_assert(!host);
! 109:
! 110: host = host_create_from_string("%any", 500);
! 111: verify_any(host, AF_INET, 500);
! 112: host->destroy(host);
! 113:
! 114: host = host_create_from_string("%any4", 500);
! 115: verify_any(host, AF_INET, 500);
! 116: host->destroy(host);
! 117:
! 118: host = host_create_from_string("0.0.0.0", 500);
! 119: verify_any(host, AF_INET, 500);
! 120: host->destroy(host);
! 121:
! 122: host = host_create_from_string("192.168.0.1", 500);
! 123: verify_address(host, addr_v4, AF_INET, 500);
! 124: host->destroy(host);
! 125:
! 126: host = host_create_from_string("192.168.0.1::500", 500);
! 127: ck_assert(host == NULL);
! 128: host = host_create_from_string("123.456.789.012", 500);
! 129: ck_assert(host == NULL);
! 130: host = host_create_from_string("1.1.1.1.1.1.1.1", 500);
! 131: ck_assert(host == NULL);
! 132: host = host_create_from_string("foo.b.a.r", 500);
! 133: ck_assert(host == NULL);
! 134: }
! 135: END_TEST
! 136:
! 137: START_TEST(test_create_from_string_any_v6)
! 138: {
! 139: host_t *host;
! 140:
! 141: host = host_create_from_string("%any6", 500);
! 142: verify_any(host, AF_INET6, 500);
! 143: host->destroy(host);
! 144:
! 145: host = host_create_from_string("::", 500);
! 146: verify_any(host, AF_INET6, 500);
! 147: host->destroy(host);
! 148:
! 149: host = host_create_from_string("fec1::1", 500);
! 150: verify_address(host, addr_v6, AF_INET6, 500);
! 151: host->destroy(host);
! 152:
! 153: host = host_create_from_string("fec1::1.500", 500);
! 154: ck_assert(host == NULL);
! 155: host = host_create_from_string("f::e::c::1::1", 500);
! 156: ck_assert(host == NULL);
! 157: host = host_create_from_string("foo::bar", 500);
! 158: ck_assert(host == NULL);
! 159: }
! 160: END_TEST
! 161:
! 162: /*******************************************************************************
! 163: * host_create_from_string_and_family
! 164: */
! 165:
! 166: static void test_create_from_string_and_family_any(char *string, int family,
! 167: int expected)
! 168: {
! 169: host_t *host;
! 170:
! 171: host = host_create_from_string_and_family(string, family, 500);
! 172: if (expected == AF_UNSPEC)
! 173: {
! 174: ck_assert(host == NULL);
! 175: }
! 176: else
! 177: {
! 178: verify_any(host, expected, 500);
! 179: host->destroy(host);
! 180: }
! 181: }
! 182:
! 183: static void test_create_from_string_and_family_addr(char *string, chunk_t addr,
! 184: int family, int expected)
! 185: {
! 186: host_t *host;
! 187:
! 188: host = host_create_from_string_and_family(string, family, 500);
! 189: if (expected == AF_UNSPEC)
! 190: {
! 191: ck_assert(host == NULL);
! 192: }
! 193: else
! 194: {
! 195: verify_address(host, addr, expected, 500);
! 196: host->destroy(host);
! 197: }
! 198: }
! 199:
! 200: START_TEST(test_create_from_string_and_family_v4)
! 201: {
! 202: test_create_from_string_and_family_any(NULL, AF_INET, AF_UNSPEC);
! 203: test_create_from_string_and_family_any("%any", AF_INET, AF_INET);
! 204: test_create_from_string_and_family_any("%any4", AF_INET, AF_INET);
! 205: test_create_from_string_and_family_any("0.0.0.0", AF_INET, AF_INET);
! 206:
! 207: test_create_from_string_and_family_any("%any4", AF_INET6, AF_UNSPEC);
! 208: test_create_from_string_and_family_any("0.0.0.0", AF_INET6, AF_UNSPEC);
! 209:
! 210: test_create_from_string_and_family_addr("192.168.0.1", addr_v4, AF_INET, AF_INET);
! 211: test_create_from_string_and_family_addr("192.168.0.1", addr_v4, AF_INET6, AF_UNSPEC);
! 212: }
! 213: END_TEST
! 214:
! 215: START_TEST(test_create_from_string_and_family_v6)
! 216: {
! 217: test_create_from_string_and_family_any(NULL, AF_INET6, AF_UNSPEC);
! 218: test_create_from_string_and_family_any("%any", AF_INET6, AF_INET6);
! 219: test_create_from_string_and_family_any("%any6", AF_INET6, AF_INET6);
! 220: test_create_from_string_and_family_any("::", AF_INET6, AF_INET6);
! 221:
! 222: test_create_from_string_and_family_any("%any6", AF_INET, AF_UNSPEC);
! 223: test_create_from_string_and_family_any("::", AF_INET, AF_UNSPEC);
! 224:
! 225: test_create_from_string_and_family_addr("fec1::1", addr_v6, AF_INET6, AF_INET6);
! 226: test_create_from_string_and_family_addr("fec1::1", addr_v6, AF_INET, AF_UNSPEC);
! 227: }
! 228: END_TEST
! 229:
! 230: START_TEST(test_create_from_string_and_family_other)
! 231: {
! 232: test_create_from_string_and_family_any(NULL, AF_UNSPEC, AF_UNSPEC);
! 233: test_create_from_string_and_family_any("%any", AF_UNSPEC, AF_INET);
! 234: test_create_from_string_and_family_any("%any4", AF_UNSPEC, AF_INET);
! 235: test_create_from_string_and_family_any("0.0.0.0", AF_UNSPEC, AF_INET);
! 236:
! 237: test_create_from_string_and_family_any("%any6", AF_UNSPEC, AF_INET6);
! 238: test_create_from_string_and_family_any("::", AF_UNSPEC, AF_INET6);
! 239:
! 240: test_create_from_string_and_family_addr("192.168.0.1", addr_v4, AF_UNSPEC, AF_INET);
! 241: test_create_from_string_and_family_addr("fec1::1", addr_v6, AF_UNSPEC, AF_INET6);
! 242: }
! 243: END_TEST
! 244:
! 245: /*******************************************************************************
! 246: * host_create_from_dns
! 247: */
! 248:
! 249: static void test_create_from_dns(int family, chunk_t addr)
! 250: {
! 251: host_t *host;
! 252:
! 253: host = host_create_from_dns("localhost", family, 500);
! 254: if (family != AF_INET6)
! 255: {
! 256: ck_assert(host != NULL);
! 257: }
! 258: if (host)
! 259: {
! 260: if (family != AF_UNSPEC)
! 261: {
! 262: verify_address(host, addr, family, 500);
! 263: }
! 264: host->destroy(host);
! 265: }
! 266: }
! 267:
! 268: START_TEST(test_create_from_dns_any)
! 269: {
! 270: test_create_from_dns(AF_UNSPEC, chunk_empty);
! 271: }
! 272: END_TEST
! 273:
! 274: START_TEST(test_create_from_dns_v4)
! 275: {
! 276: test_create_from_dns(AF_INET, chunk_from_chars(127,0,0,1));
! 277: }
! 278: END_TEST
! 279:
! 280: START_TEST(test_create_from_dns_v6)
! 281: {
! 282: test_create_from_dns(AF_INET6,
! 283: chunk_from_chars(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1));
! 284: }
! 285: END_TEST
! 286:
! 287: /*******************************************************************************
! 288: * host_create_from_sockaddr
! 289: */
! 290:
! 291: START_TEST(test_create_from_sockaddr_v4)
! 292: {
! 293: struct sockaddr_in addr = {
! 294: #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
! 295: .sin_len = sizeof(struct sockaddr_in),
! 296: #endif
! 297: .sin_family = AF_INET,
! 298: .sin_port = htons(500),
! 299: }, *val;
! 300: socklen_t *socklen;
! 301: host_t *host;
! 302:
! 303: host = host_create_from_sockaddr((sockaddr_t*)&addr);
! 304: verify_any(host, AF_INET, 500);
! 305: val = (struct sockaddr_in*)host->get_sockaddr(host);
! 306: ck_assert(memeq(&addr, val, sizeof(addr)));
! 307: socklen = host->get_sockaddr_len(host);
! 308: ck_assert(*socklen == sizeof(addr));
! 309: host->destroy(host);
! 310: }
! 311: END_TEST
! 312:
! 313: START_TEST(test_create_from_sockaddr_v6)
! 314: {
! 315: struct sockaddr_in6 addr = {
! 316: #ifdef HAVE_STRUCT_SOCKADDR_SA_LEN
! 317: .sin6_len = sizeof(struct sockaddr_in6),
! 318: #endif
! 319: .sin6_family = AF_INET6,
! 320: .sin6_port = htons(500),
! 321: }, *val;
! 322: socklen_t *socklen;
! 323: host_t *host;
! 324:
! 325: host = host_create_from_sockaddr((sockaddr_t*)&addr);
! 326: verify_any(host, AF_INET6, 500);
! 327: val = (struct sockaddr_in6*)host->get_sockaddr(host);
! 328: ck_assert(memeq(&addr, val, sizeof(addr)));
! 329: socklen = host->get_sockaddr_len(host);
! 330: ck_assert(*socklen == sizeof(addr));
! 331: host->destroy(host);
! 332: }
! 333: END_TEST
! 334:
! 335: START_TEST(test_create_from_sockaddr_other)
! 336: {
! 337: struct sockaddr addr = {
! 338: .sa_family = AF_UNIX,
! 339: };
! 340: host_t *host;
! 341:
! 342: host = host_create_from_sockaddr((sockaddr_t*)&addr);
! 343: ck_assert(host == NULL);
! 344: }
! 345: END_TEST
! 346:
! 347: /*******************************************************************************
! 348: * host_create_from_chunk
! 349: */
! 350:
! 351: START_TEST(test_create_from_chunk_v4)
! 352: {
! 353: host_t *host;
! 354:
! 355: host = host_create_from_chunk(AF_INET, addr_v4, 500);
! 356: verify_address(host, addr_v4, AF_INET, 500);
! 357: host->destroy(host);
! 358:
! 359: host = host_create_from_chunk(AF_UNSPEC, addr_v4, 500);
! 360: verify_address(host, addr_v4, AF_INET, 500);
! 361: host->destroy(host);
! 362:
! 363: host = host_create_from_chunk(AF_INET, chunk_empty, 500);
! 364: ck_assert(host == NULL);
! 365: host = host_create_from_chunk(AF_UNSPEC, chunk_empty, 500);
! 366: ck_assert(host == NULL);
! 367: }
! 368: END_TEST
! 369:
! 370: START_TEST(test_create_from_chunk_v6)
! 371: {
! 372: host_t *host;
! 373:
! 374: host = host_create_from_chunk(AF_INET6, addr_v6, 500);
! 375: verify_address(host, addr_v6, AF_INET6, 500);
! 376: host->destroy(host);
! 377:
! 378: host = host_create_from_chunk(AF_UNSPEC, addr_v6, 500);
! 379: verify_address(host, addr_v6, AF_INET6, 500);
! 380: host->destroy(host);
! 381:
! 382: host = host_create_from_chunk(AF_INET6, chunk_empty, 500);
! 383: ck_assert(host == NULL);
! 384: }
! 385: END_TEST
! 386:
! 387: START_TEST(test_create_from_chunk_other)
! 388: {
! 389: host_t *host;
! 390:
! 391: host = host_create_from_chunk(AF_UNIX, addr_v6, 500);
! 392: ck_assert(host == NULL);
! 393: }
! 394: END_TEST
! 395:
! 396: /*******************************************************************************
! 397: * host_create_from_subnet
! 398: */
! 399:
! 400: START_TEST(test_create_from_subnet_v4)
! 401: {
! 402: host_t *host;
! 403: int bits = -1;
! 404:
! 405: host = host_create_from_subnet("0.0.0.0/0", &bits);
! 406: verify_any(host, AF_INET, 0);
! 407: ck_assert_int_eq(bits, 0);
! 408: host->destroy(host);
! 409:
! 410: host = host_create_from_subnet("192.168.0.1", &bits);
! 411: verify_address(host, addr_v4, AF_INET, 0);
! 412: ck_assert_int_eq(bits, 32);
! 413: host->destroy(host);
! 414:
! 415: host = host_create_from_subnet("192.168.0.1/24", &bits);
! 416: verify_address(host, addr_v4, AF_INET, 0);
! 417: ck_assert_int_eq(bits, 24);
! 418: host->destroy(host);
! 419:
! 420: host = host_create_from_subnet("foo.b.a.r", &bits);
! 421: ck_assert(host == NULL);
! 422: }
! 423: END_TEST
! 424:
! 425: START_TEST(test_create_from_subnet_v6)
! 426: {
! 427: host_t *host;
! 428: int bits = -1;
! 429:
! 430: host = host_create_from_subnet("::/0", &bits);
! 431: verify_any(host, AF_INET6, 0);
! 432: ck_assert_int_eq(bits, 0);
! 433: host->destroy(host);
! 434:
! 435: host = host_create_from_subnet("fec1::1", &bits);
! 436: verify_address(host, addr_v6, AF_INET6, 0);
! 437: ck_assert_int_eq(bits, 128);
! 438: host->destroy(host);
! 439:
! 440: host = host_create_from_subnet("fec1::1/64", &bits);
! 441: verify_address(host, addr_v6, AF_INET6, 0);
! 442: ck_assert_int_eq(bits, 64);
! 443: host->destroy(host);
! 444:
! 445: host = host_create_from_subnet("foo::bar", &bits);
! 446: ck_assert(host == NULL);
! 447: }
! 448: END_TEST
! 449:
! 450: /*******************************************************************************
! 451: * host_create_from_range
! 452: */
! 453:
! 454: static const chunk_t addr_v4_to = chunk_from_chars(0xc0, 0xa8, 0x00, 0x05);
! 455: static const chunk_t addr_v6_to = chunk_from_chars(0xfe, 0xc1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
! 456: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05);
! 457:
! 458: static void verify_range(char *str, int family, chunk_t from_addr,
! 459: chunk_t to_addr)
! 460: {
! 461: host_t *from, *to;
! 462:
! 463: if (!family)
! 464: {
! 465: ck_assert(!host_create_from_range(str, &from, &to));
! 466: }
! 467: else
! 468: {
! 469: ck_assert(host_create_from_range(str, &from, &to));
! 470: verify_address(from, from_addr, family, 0);
! 471: verify_address(to, to_addr, family, 0);
! 472: from->destroy(from);
! 473: to->destroy(to);
! 474: }
! 475: }
! 476:
! 477: START_TEST(test_create_from_range_v4)
! 478: {
! 479: host_t *from, *to;
! 480:
! 481: ck_assert(host_create_from_range("0.0.0.0-0.0.0.0", &from, &to));
! 482: verify_any(from, AF_INET, 0);
! 483: verify_any(to, AF_INET, 0);
! 484: from->destroy(from);
! 485: to->destroy(to);
! 486:
! 487: verify_range("192.168.0.1-192.168.0.1", AF_INET, addr_v4, addr_v4);
! 488: verify_range("192.168.0.1-192.168.0.5", AF_INET, addr_v4, addr_v4_to);
! 489: verify_range("192.168.0.1- 192.168.0.5", AF_INET, addr_v4, addr_v4_to);
! 490: verify_range("192.168.0.1 -192.168.0.5", AF_INET, addr_v4, addr_v4_to);
! 491: verify_range("192.168.0.1 - 192.168.0.5", AF_INET, addr_v4, addr_v4_to);
! 492: verify_range("192.168.0.5-192.168.0.1", AF_INET, addr_v4_to, addr_v4);
! 493:
! 494: verify_range("192.168.0.1", 0, chunk_empty, chunk_empty);
! 495: verify_range("192.168.0.1-", 0, chunk_empty, chunk_empty);
! 496: verify_range("-192.168.0.1", 0, chunk_empty, chunk_empty);
! 497: verify_range("192.168.0.1-192", 0, chunk_empty, chunk_empty);
! 498: verify_range("192.168.0.1-192.168", 0, chunk_empty, chunk_empty);
! 499: verify_range("192.168.0.1-192.168.0", 0, chunk_empty, chunk_empty);
! 500: verify_range("foo.b.a.r", 0, chunk_empty, chunk_empty);
! 501: verify_range("foo.b.a.r-b.a.r.f", 0, chunk_empty, chunk_empty);
! 502: }
! 503: END_TEST
! 504:
! 505: START_TEST(test_create_from_range_v6)
! 506: {
! 507: host_t *from, *to;
! 508:
! 509: ck_assert(host_create_from_range("::-::", &from, &to));
! 510: verify_any(from, AF_INET6, 0);
! 511: verify_any(to, AF_INET6, 0);
! 512: from->destroy(from);
! 513: to->destroy(to);
! 514:
! 515: verify_range("fec1::1-fec1::1", AF_INET6, addr_v6, addr_v6);
! 516: verify_range("fec1::1-fec1::5", AF_INET6, addr_v6, addr_v6_to);
! 517: verify_range("fec1::1- fec1::5", AF_INET6, addr_v6, addr_v6_to);
! 518: verify_range("fec1::1 -fec1::5", AF_INET6, addr_v6, addr_v6_to);
! 519: verify_range("fec1::1 - fec1::5", AF_INET6, addr_v6, addr_v6_to);
! 520: verify_range("fec1::5-fec1::1", AF_INET6, addr_v6_to, addr_v6);
! 521:
! 522: verify_range("fec1::1", 0, chunk_empty, chunk_empty);
! 523: verify_range("fec1::1-", 0, chunk_empty, chunk_empty);
! 524: verify_range("-fec1::1", 0, chunk_empty, chunk_empty);
! 525: verify_range("fec1::1-fec1", 0, chunk_empty, chunk_empty);
! 526: verify_range("foo::bar", 0, chunk_empty, chunk_empty);
! 527: verify_range("foo::bar-bar::foo", 0, chunk_empty, chunk_empty);
! 528:
! 529: verify_range("fec1::1-192.168.0.1", 0, chunk_empty, chunk_empty);
! 530: verify_range("192.168.0.1-fec1::1", 0, chunk_empty, chunk_empty);
! 531: }
! 532: END_TEST
! 533:
! 534: /*******************************************************************************
! 535: * host_create_netmask
! 536: */
! 537:
! 538: static void test_create_netmask(int family)
! 539: {
! 540: host_t *netmask;
! 541: int i, len = (family == AF_INET) ? 32 : 128;
! 542:
! 543: netmask = host_create_netmask(family, -1);
! 544: ck_assert(netmask == NULL);
! 545: for (i = 0; i <= len; i++)
! 546: {
! 547: netmask = host_create_netmask(family, i);
! 548: verify_netmask(netmask->get_address(netmask), i);
! 549: netmask->destroy(netmask);
! 550: }
! 551: netmask = host_create_netmask(family, len + 1);
! 552: ck_assert(netmask == NULL);
! 553: }
! 554:
! 555: START_TEST(test_create_netmask_v4)
! 556: {
! 557: test_create_netmask(AF_INET);
! 558: }
! 559: END_TEST
! 560:
! 561: START_TEST(test_create_netmask_v6)
! 562: {
! 563: test_create_netmask(AF_INET6);
! 564: }
! 565: END_TEST
! 566:
! 567: START_TEST(test_create_netmask_other)
! 568: {
! 569: host_t *netmask;
! 570:
! 571: netmask = host_create_netmask(AF_UNSPEC, 0);
! 572: ck_assert(netmask == NULL);
! 573: }
! 574: END_TEST
! 575:
! 576: /*******************************************************************************
! 577: * equals, ip_equals
! 578: */
! 579:
! 580: START_TEST(test_equals)
! 581: {
! 582: host_t *a, *b;
! 583:
! 584: a = host_create_from_string("192.168.0.1", 500);
! 585: b = host_create_from_string("192.168.0.1", 0);
! 586: ck_assert(!a->equals(a, b));
! 587: ck_assert(!b->equals(b, a));
! 588: ck_assert(a->ip_equals(a, b));
! 589: ck_assert(b->ip_equals(b, a));
! 590: b->set_port(b, 500);
! 591: ck_assert(a->equals(a, b));
! 592: ck_assert(b->equals(b, a));
! 593: ck_assert(a->ip_equals(a, b));
! 594: ck_assert(b->ip_equals(b, a));
! 595: b->destroy(b);
! 596: b = host_create_from_string("192.168.0.2", 500);
! 597: ck_assert(!a->ip_equals(a, b));
! 598: ck_assert(!a->equals(a, b));
! 599: b->destroy(b);
! 600:
! 601: b = host_create_from_string("fec1::1", 500);
! 602: ck_assert(!a->ip_equals(a, b));
! 603: ck_assert(!a->equals(a, b));
! 604: a->destroy(a);
! 605: a = host_create_from_string("fec1::1", 500);
! 606: ck_assert(a->equals(a, b));
! 607: ck_assert(a->ip_equals(a, b));
! 608: a->destroy(a);
! 609: b->destroy(b);
! 610: }
! 611: END_TEST
! 612:
! 613: START_TEST(test_equals_any)
! 614: {
! 615: host_t *a, *b;
! 616:
! 617: a = host_create_from_string("%any", 500);
! 618: b = host_create_from_string("%any", 0);
! 619: ck_assert(!a->equals(a, b));
! 620: ck_assert(a->ip_equals(a, b));
! 621: b->set_port(b, 500);
! 622: ck_assert(a->equals(a, b));
! 623: ck_assert(a->ip_equals(a, b));
! 624: b->destroy(b);
! 625: b = host_create_from_string("%any6", 0);
! 626: ck_assert(a->ip_equals(a, b));
! 627: ck_assert(!a->equals(a, b));
! 628: b->set_port(b, 500);
! 629: ck_assert(a->ip_equals(a, b));
! 630: ck_assert(a->equals(a, b));
! 631: a->destroy(a);
! 632: b->destroy(b);
! 633: }
! 634: END_TEST
! 635:
! 636: /*******************************************************************************
! 637: * clone
! 638: */
! 639:
! 640: START_TEST(test_clone)
! 641: {
! 642: host_t *a, *b;
! 643:
! 644: a = host_create_from_string("192.168.0.1", 500);
! 645: b = a->clone(a);
! 646: ck_assert(a != b);
! 647: ck_assert(a->equals(a, b));
! 648: a->destroy(a);
! 649: b->destroy(b);
! 650: }
! 651: END_TEST
! 652:
! 653: /*******************************************************************************
! 654: * printf hook
! 655: */
! 656:
! 657: static struct {
! 658: char *addr;
! 659: uint16_t port;
! 660: /* results for %H, %+H, %#H (falls back to the first entry) */
! 661: char *result[3];
! 662: } printf_data[] = {
! 663: {NULL, 0, { "(null)" }},
! 664: {NULL, 500, { "(null)" }},
! 665: {"%any", 0, { "%any", "0.0.0.0", "0.0.0.0" }},
! 666: {"%any", 500, { "%any", "0.0.0.0", "0.0.0.0[500]" }},
! 667: {"%any6", 0, { "%any6", "::", "::" }},
! 668: {"%any6", 500, { "%any6", "::", "::[500]" }},
! 669: {"192.168.0.1", 0, { "192.168.0.1" }},
! 670: {"192.168.0.1", 500, { "192.168.0.1", "192.168.0.1", "192.168.0.1[500]" }},
! 671: {"fec1::1", 0, { "fec1::1" }},
! 672: {"fec1::1", 500, { "fec1::1", "fec1::1", "fec1::1[500]" }},
! 673: };
! 674:
! 675: static void verify_printf(host_t *host, const char *format, char *expected)
! 676: {
! 677: char buf[64];
! 678:
! 679: snprintf(buf, sizeof(buf), format, host);
! 680: ck_assert_str_eq(expected, buf);
! 681: }
! 682:
! 683: START_TEST(test_printf_hook)
! 684: {
! 685: static const char *formats[] = { "%H", "%+H", "%#H" };
! 686: host_t *host = NULL;
! 687: char *expected;
! 688: int i;
! 689:
! 690: if (printf_data[_i].addr)
! 691: {
! 692: host = host_create_from_string(printf_data[_i].addr,
! 693: printf_data[_i].port);
! 694: }
! 695: for (i = 0; i < countof(formats); i++)
! 696: {
! 697: expected = printf_data[_i].result[i];
! 698: expected = expected ?: printf_data[_i].result[0];
! 699: verify_printf(host, formats[i], expected);
! 700: }
! 701: DESTROY_IF(host);
! 702: }
! 703: END_TEST
! 704:
! 705: START_TEST(test_printf_hook_align)
! 706: {
! 707: host_t *host;
! 708:
! 709: verify_printf(NULL, "%14H", " (null)");
! 710: verify_printf(NULL, "%-14H", "(null) ");
! 711:
! 712: host = host_create_from_string("192.168.0.1", 0);
! 713: verify_printf(host, "%14H", " 192.168.0.1");
! 714: verify_printf(host, "%-14H", "192.168.0.1 ");
! 715: verify_printf(host, "%4H", "192.168.0.1");
! 716: verify_printf(host, "%-4H", "192.168.0.1");
! 717: host->destroy(host);
! 718: }
! 719: END_TEST
! 720:
! 721: Suite *host_suite_create()
! 722: {
! 723: Suite *s;
! 724: TCase *tc;
! 725:
! 726: s = suite_create("host");
! 727:
! 728: tc = tcase_create("host_create_any");
! 729: tcase_add_test(tc, test_create_any_v4);
! 730: tcase_add_test(tc, test_create_any_v6);
! 731: tcase_add_test(tc, test_create_any_other);
! 732: suite_add_tcase(s, tc);
! 733:
! 734: tc = tcase_create("host_create_from_string");
! 735: tcase_add_test(tc, test_create_from_string_v4);
! 736: tcase_add_test(tc, test_create_from_string_any_v6);
! 737: suite_add_tcase(s, tc);
! 738:
! 739: tc = tcase_create("host_create_from_string_and_family");
! 740: tcase_add_test(tc, test_create_from_string_and_family_v4);
! 741: tcase_add_test(tc, test_create_from_string_and_family_v6);
! 742: tcase_add_test(tc, test_create_from_string_and_family_other);
! 743: suite_add_tcase(s, tc);
! 744:
! 745: tc = tcase_create("host_create_from_dns");
! 746: tcase_add_test(tc, test_create_from_dns_any);
! 747: tcase_add_test(tc, test_create_from_dns_v4);
! 748: tcase_add_test(tc, test_create_from_dns_v6);
! 749: suite_add_tcase(s, tc);
! 750:
! 751: tc = tcase_create("host_create_from_sockaddr");
! 752: tcase_add_test(tc, test_create_from_sockaddr_v4);
! 753: tcase_add_test(tc, test_create_from_sockaddr_v6);
! 754: tcase_add_test(tc, test_create_from_sockaddr_other);
! 755: suite_add_tcase(s, tc);
! 756:
! 757: tc = tcase_create("host_create_from_chunk");
! 758: tcase_add_test(tc, test_create_from_chunk_v4);
! 759: tcase_add_test(tc, test_create_from_chunk_v6);
! 760: tcase_add_test(tc, test_create_from_chunk_other);
! 761: suite_add_tcase(s, tc);
! 762:
! 763: tc = tcase_create("host_create_from_subnet");
! 764: tcase_add_test(tc, test_create_from_subnet_v4);
! 765: tcase_add_test(tc, test_create_from_subnet_v6);
! 766: suite_add_tcase(s, tc);
! 767:
! 768: tc = tcase_create("host_create_from_range");
! 769: tcase_add_test(tc, test_create_from_range_v4);
! 770: tcase_add_test(tc, test_create_from_range_v6);
! 771: suite_add_tcase(s, tc);
! 772:
! 773: tc = tcase_create("host_create_netmask");
! 774: tcase_add_test(tc, test_create_netmask_v4);
! 775: tcase_add_test(tc, test_create_netmask_v6);
! 776: tcase_add_test(tc, test_create_netmask_other);
! 777: suite_add_tcase(s, tc);
! 778:
! 779: tc = tcase_create("equals, ip_equals");
! 780: tcase_add_test(tc, test_equals);
! 781: tcase_add_test(tc, test_equals_any);
! 782: suite_add_tcase(s, tc);
! 783:
! 784: tc = tcase_create("clone");
! 785: tcase_add_test(tc, test_clone);
! 786: suite_add_tcase(s, tc);
! 787:
! 788: tc = tcase_create("printf hook");
! 789: tcase_add_loop_test(tc, test_printf_hook, 0, countof(printf_data));
! 790: tcase_add_test(tc, test_printf_hook_align);
! 791: suite_add_tcase(s, tc);
! 792:
! 793: return s;
! 794: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_host.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites