src/libstrongswan/tests/suites/test_host.c

   1 /*
   2  * Copyright (C) 2013 Tobias Brunner
   3  * 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, u_int16_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, u_int16_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         u_int16_t port;
 660         /* results for %H, %+H, %#H (falls back to [0]) */
 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[0]" }},
 666         {"%any",      500, { "%any", "0.0.0.0", "0.0.0.0[500]" }},
 667         {"%any6",       0, { "%any6", "::", "::[0]" }},
 668         {"%any6",     500, { "%any6", "::", "::[500]" }},
 669         {"192.168.0.1",   0, { "192.168.0.1", "192.168.0.1", "192.168.0.1[0]" }},
 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", "fec1::1", "fec1::1[0]" }},
 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 }