src/test/test-dns-domain.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2014 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20  ***/
  21
  22 #include "alloc-util.h"
  23 #include "dns-domain.h"
  24 #include "macro.h"
  25 #include "string-util.h"
  26
  27 static void test_dns_label_unescape_one(const char *what, const char *expect, size_t buffer_sz, int ret) {
  28         char buffer[buffer_sz];
  29         int r;
  30
  31         r = dns_label_unescape(&what, buffer, buffer_sz);
  32         assert_se(r == ret);
  33
  34         if (r < 0)
  35                 return;
  36
  37         assert_se(streq(buffer, expect));
  38 }
  39
  40 static void test_dns_label_unescape(void) {
  41         test_dns_label_unescape_one("hallo", "hallo", 6, 5);
  42         test_dns_label_unescape_one("hallo", "hallo", 4, -ENOBUFS);
  43         test_dns_label_unescape_one("", "", 10, 0);
  44         test_dns_label_unescape_one("hallo\\.foobar", "hallo.foobar", 20, 12);
  45         test_dns_label_unescape_one("hallo.foobar", "hallo", 10, 5);
  46         test_dns_label_unescape_one("hallo\n.foobar", "hallo", 20, -EINVAL);
  47         test_dns_label_unescape_one("hallo\\", "hallo", 20, -EINVAL);
  48         test_dns_label_unescape_one("hallo\\032 ", "hallo  ", 20, 7);
  49         test_dns_label_unescape_one(".", "", 20, 0);
  50         test_dns_label_unescape_one("..", "", 20, -EINVAL);
  51         test_dns_label_unescape_one(".foobar", "", 20, -EINVAL);
  52         test_dns_label_unescape_one("foobar.", "foobar", 20, 6);
  53 }
  54
  55 static void test_dns_name_to_wire_format_one(const char *what, const char *expect, size_t buffer_sz, int ret) {
  56         uint8_t buffer[buffer_sz];
  57         int r;
  58
  59         r = dns_name_to_wire_format(what, buffer, buffer_sz, false);
  60         assert_se(r == ret);
  61
  62         if (r < 0)
  63                 return;
  64
  65         assert_se(!memcmp(buffer, expect, r));
  66 }
  67
  68 static void test_dns_name_to_wire_format(void) {
  69         static const char out0[] = { 0 };
  70         static const char out1[] = { 3, 'f', 'o', 'o', 0 };
  71         static const char out2[] = { 5, 'h', 'a', 'l', 'l', 'o', 3, 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
  72         static const char out3[] = { 4, ' ', 'f', 'o', 'o', 3, 'b', 'a', 'r', 0 };
  73         static const char out4[] = { 9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  74                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  75                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  76                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  77                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  78                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  79                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  80                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  81                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  82                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  83                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  84                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  85                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  86                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  87                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  88                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  89                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  90                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  91                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  92                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  93                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  94                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  95                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  96                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  97                                      9, 'a', '1', '2', '3', '4', '5', '6', '7', '8',
  98                                      3, 'a', '1', '2', 0 };
  99
 100         test_dns_name_to_wire_format_one("", out0, sizeof(out0), sizeof(out0));
 101
 102         test_dns_name_to_wire_format_one("foo", out1, sizeof(out1), sizeof(out1));
 103         test_dns_name_to_wire_format_one("foo", out1, sizeof(out1) + 1, sizeof(out1));
 104         test_dns_name_to_wire_format_one("foo", out1, sizeof(out1) - 1, -ENOBUFS);
 105
 106         test_dns_name_to_wire_format_one("hallo.foo.bar", out2, sizeof(out2), sizeof(out2));
 107         test_dns_name_to_wire_format_one("hallo.foo..bar", NULL, 32, -EINVAL);
 108
 109         test_dns_name_to_wire_format_one("\\032foo.bar", out3, sizeof(out3), sizeof(out3));
 110
 111         test_dns_name_to_wire_format_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a123", NULL, 500, -EINVAL);
 112         test_dns_name_to_wire_format_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12", out4, sizeof(out4), sizeof(out4));
 113 }
 114
 115 static void test_dns_label_unescape_suffix_one(const char *what, const char *expect1, const char *expect2, size_t buffer_sz, int ret1, int ret2) {
 116         char buffer[buffer_sz];
 117         const char *label;
 118         int r;
 119
 120         label = what + strlen(what);
 121
 122         r = dns_label_unescape_suffix(what, &label, buffer, buffer_sz);
 123         assert_se(r == ret1);
 124         if (r >= 0)
 125                 assert_se(streq(buffer, expect1));
 126
 127         r = dns_label_unescape_suffix(what, &label, buffer, buffer_sz);
 128         assert_se(r == ret2);
 129         if (r >= 0)
 130                 assert_se(streq(buffer, expect2));
 131 }
 132
 133 static void test_dns_label_unescape_suffix(void) {
 134         test_dns_label_unescape_suffix_one("hallo", "hallo", "", 6, 5, 0);
 135         test_dns_label_unescape_suffix_one("hallo", "hallo", "", 4, -ENOBUFS, -ENOBUFS);
 136         test_dns_label_unescape_suffix_one("", "", "", 10, 0, 0);
 137         test_dns_label_unescape_suffix_one("hallo\\.foobar", "hallo.foobar", "", 20, 12, 0);
 138         test_dns_label_unescape_suffix_one("hallo.foobar", "foobar", "hallo", 10, 6, 5);
 139         test_dns_label_unescape_suffix_one("hallo.foobar\n", "foobar", "foobar", 20, -EINVAL, -EINVAL);
 140         test_dns_label_unescape_suffix_one("hallo\\", "hallo", "hallo", 20, -EINVAL, -EINVAL);
 141         test_dns_label_unescape_suffix_one("hallo\\032 ", "hallo  ", "", 20, 7, 0);
 142         test_dns_label_unescape_suffix_one(".", "", "", 20, 0, 0);
 143         test_dns_label_unescape_suffix_one("..", "", "", 20, 0, -EINVAL);
 144         test_dns_label_unescape_suffix_one(".foobar", "foobar", "", 20, 6, -EINVAL);
 145         test_dns_label_unescape_suffix_one("foobar.", "foobar", "", 20, 6, 0);
 146         test_dns_label_unescape_suffix_one("foo\\\\bar", "foo\\bar", "", 20, 7, 0);
 147         test_dns_label_unescape_suffix_one("foo.bar", "bar", "foo", 20, 3, 3);
 148         test_dns_label_unescape_suffix_one("foo..bar", "bar", "", 20, 3, -EINVAL);
 149         test_dns_label_unescape_suffix_one("foo...bar", "bar", "", 20, 3, -EINVAL);
 150         test_dns_label_unescape_suffix_one("foo\\.bar", "foo.bar", "", 20, 7, 0);
 151         test_dns_label_unescape_suffix_one("foo\\\\.bar", "bar", "foo\\", 20, 3, 4);
 152         test_dns_label_unescape_suffix_one("foo\\\\\\.bar", "foo\\.bar", "", 20, 8, 0);
 153 }
 154
 155 static void test_dns_label_escape_one(const char *what, size_t l, const char *expect, int ret) {
 156         _cleanup_free_ char *t = NULL;
 157         int r;
 158
 159         r = dns_label_escape_new(what, l, &t);
 160         assert_se(r == ret);
 161
 162         if (r < 0)
 163                 return;
 164
 165         assert_se(streq_ptr(expect, t));
 166 }
 167
 168 static void test_dns_label_escape(void) {
 169         test_dns_label_escape_one("", 0, NULL, -EINVAL);
 170         test_dns_label_escape_one("hallo", 5, "hallo", 5);
 171         test_dns_label_escape_one("hallo", 6, "hallo\\000", 9);
 172         test_dns_label_escape_one("hallo hallo.foobar,waldi", 24, "hallo\\032hallo\\.foobar\\044waldi", 31);
 173 }
 174
 175 static void test_dns_name_normalize_one(const char *what, const char *expect, int ret) {
 176         _cleanup_free_ char *t = NULL;
 177         int r;
 178
 179         r = dns_name_normalize(what, &t);
 180         assert_se(r == ret);
 181
 182         if (r < 0)
 183                 return;
 184
 185         assert_se(streq_ptr(expect, t));
 186 }
 187
 188 static void test_dns_name_normalize(void) {
 189         test_dns_name_normalize_one("", ".", 0);
 190         test_dns_name_normalize_one("f", "f", 0);
 191         test_dns_name_normalize_one("f.waldi", "f.waldi", 0);
 192         test_dns_name_normalize_one("f \\032.waldi", "f\\032\\032.waldi", 0);
 193         test_dns_name_normalize_one("\\000", "\\000", 0);
 194         test_dns_name_normalize_one("..", NULL, -EINVAL);
 195         test_dns_name_normalize_one(".foobar", NULL, -EINVAL);
 196         test_dns_name_normalize_one("foobar.", "foobar", 0);
 197         test_dns_name_normalize_one(".", ".", 0);
 198 }
 199
 200 static void test_dns_name_equal_one(const char *a, const char *b, int ret) {
 201         int r;
 202
 203         r = dns_name_equal(a, b);
 204         assert_se(r == ret);
 205
 206         r = dns_name_equal(b, a);
 207         assert_se(r == ret);
 208 }
 209
 210 static void test_dns_name_equal(void) {
 211         test_dns_name_equal_one("", "", true);
 212         test_dns_name_equal_one("x", "x", true);
 213         test_dns_name_equal_one("x", "x.", true);
 214         test_dns_name_equal_one("abc.def", "abc.def", true);
 215         test_dns_name_equal_one("abc.def", "ABC.def", true);
 216         test_dns_name_equal_one("abc.def", "CBA.def", false);
 217         test_dns_name_equal_one("", "xxx", false);
 218         test_dns_name_equal_one("ab", "a", false);
 219         test_dns_name_equal_one("\\000", "\\000", true);
 220         test_dns_name_equal_one(".", "", true);
 221         test_dns_name_equal_one(".", ".", true);
 222         test_dns_name_equal_one("..", "..", -EINVAL);
 223 }
 224
 225 static void test_dns_name_between_one(const char *a, const char *b, const char *c, int ret) {
 226         int r;
 227
 228         r = dns_name_between(a, b, c);
 229         assert_se(r == ret);
 230
 231         r = dns_name_between(c, b, a);
 232         if (ret >= 0)
 233                 assert_se(r == 0);
 234         else
 235                 assert_se(r == ret);
 236 }
 237
 238 static void test_dns_name_between(void) {
 239         /* see https://tools.ietf.org/html/rfc4034#section-6.1
 240            Note that we use "\033.z.example" in stead of "\001.z.example" as we
 241            consider the latter invalid */
 242         test_dns_name_between_one("example", "a.example", "yljkjljk.a.example", true);
 243         test_dns_name_between_one("a.example", "yljkjljk.a.example", "Z.a.example", true);
 244         test_dns_name_between_one("yljkjljk.a.example", "Z.a.example", "zABC.a.EXAMPLE", true);
 245         test_dns_name_between_one("Z.a.example", "zABC.a.EXAMPLE", "z.example", true);
 246         test_dns_name_between_one("zABC.a.EXAMPLE", "z.example", "\\033.z.example", true);
 247         test_dns_name_between_one("z.example", "\\033.z.example", "*.z.example", true);
 248         test_dns_name_between_one("\\033.z.example", "*.z.example", "\\200.z.example", true);
 249         test_dns_name_between_one("*.z.example", "\\200.z.example", "example", true);
 250         test_dns_name_between_one("\\200.z.example", "example", "a.example", true);
 251
 252         test_dns_name_between_one("example", "a.example", "example", -EINVAL);
 253         test_dns_name_between_one("example", "example", "yljkjljk.a.example", false);
 254         test_dns_name_between_one("example", "yljkjljk.a.example", "yljkjljk.a.example", false);
 255 }
 256
 257 static void test_dns_name_endswith_one(const char *a, const char *b, int ret) {
 258         assert_se(dns_name_endswith(a, b) == ret);
 259 }
 260
 261 static void test_dns_name_endswith(void) {
 262         test_dns_name_endswith_one("", "", true);
 263         test_dns_name_endswith_one("", "xxx", false);
 264         test_dns_name_endswith_one("xxx", "", true);
 265         test_dns_name_endswith_one("x", "x", true);
 266         test_dns_name_endswith_one("x", "y", false);
 267         test_dns_name_endswith_one("x.y", "y", true);
 268         test_dns_name_endswith_one("x.y", "Y", true);
 269         test_dns_name_endswith_one("x.y", "x", false);
 270         test_dns_name_endswith_one("x.y.z", "Z", true);
 271         test_dns_name_endswith_one("x.y.z", "y.Z", true);
 272         test_dns_name_endswith_one("x.y.z", "x.y.Z", true);
 273         test_dns_name_endswith_one("x.y.z", "waldo", false);
 274         test_dns_name_endswith_one("x.y.z.u.v.w", "y.z", false);
 275         test_dns_name_endswith_one("x.y.z.u.v.w", "u.v.w", true);
 276         test_dns_name_endswith_one("x.y\001.z", "waldo", -EINVAL);
 277 }
 278
 279 static void test_dns_name_startswith_one(const char *a, const char *b, int ret) {
 280         assert_se(dns_name_startswith(a, b) == ret);
 281 }
 282
 283 static void test_dns_name_startswith(void) {
 284         test_dns_name_startswith_one("", "", true);
 285         test_dns_name_startswith_one("", "xxx", false);
 286         test_dns_name_startswith_one("xxx", "", true);
 287         test_dns_name_startswith_one("x", "x", true);
 288         test_dns_name_startswith_one("x", "y", false);
 289         test_dns_name_startswith_one("x.y", "x.y", true);
 290         test_dns_name_startswith_one("x.y", "y.x", false);
 291         test_dns_name_startswith_one("x.y", "x", true);
 292         test_dns_name_startswith_one("x.y", "X", true);
 293         test_dns_name_startswith_one("x.y", "y", false);
 294         test_dns_name_startswith_one("x.y", "", true);
 295         test_dns_name_startswith_one("x.y", "X", true);
 296 }
 297
 298 static void test_dns_name_is_root(void) {
 299         assert_se(dns_name_is_root(""));
 300         assert_se(dns_name_is_root("."));
 301         assert_se(!dns_name_is_root("xxx"));
 302         assert_se(!dns_name_is_root("xxx."));
 303         assert_se(!dns_name_is_root(".."));
 304 }
 305
 306 static void test_dns_name_is_single_label(void) {
 307         assert_se(!dns_name_is_single_label(""));
 308         assert_se(!dns_name_is_single_label("."));
 309         assert_se(!dns_name_is_single_label(".."));
 310         assert_se(dns_name_is_single_label("x"));
 311         assert_se(dns_name_is_single_label("x."));
 312         assert_se(!dns_name_is_single_label("xx.yy"));
 313 }
 314
 315 static void test_dns_name_reverse_one(const char *address, const char *name) {
 316         _cleanup_free_ char *p = NULL;
 317         union in_addr_union a, b = {};
 318         int familya, familyb;
 319
 320         assert_se(in_addr_from_string_auto(address, &familya, &a) >= 0);
 321         assert_se(dns_name_reverse(familya, &a, &p) >= 0);
 322         assert_se(streq(p, name));
 323         assert_se(dns_name_address(p, &familyb, &b) > 0);
 324         assert_se(familya == familyb);
 325         assert_se(in_addr_equal(familya, &a, &b));
 326 }
 327
 328 static void test_dns_name_reverse(void) {
 329         test_dns_name_reverse_one("47.11.8.15", "15.8.11.47.in-addr.arpa");
 330         test_dns_name_reverse_one("fe80::47", "7.4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa");
 331         test_dns_name_reverse_one("127.0.0.1", "1.0.0.127.in-addr.arpa");
 332         test_dns_name_reverse_one("::1", "1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa");
 333 }
 334
 335 static void test_dns_name_concat_one(const char *a, const char *b, int r, const char *result) {
 336         _cleanup_free_ char *p = NULL;
 337
 338         assert_se(dns_name_concat(a, b, &p) == r);
 339         assert_se(streq_ptr(p, result));
 340 }
 341
 342 static void test_dns_name_concat(void) {
 343         test_dns_name_concat_one("", "", 0, ".");
 344         test_dns_name_concat_one(".", "", 0, ".");
 345         test_dns_name_concat_one("", ".", 0, ".");
 346         test_dns_name_concat_one(".", ".", 0, ".");
 347         test_dns_name_concat_one("foo", "bar", 0, "foo.bar");
 348         test_dns_name_concat_one("foo.foo", "bar.bar", 0, "foo.foo.bar.bar");
 349         test_dns_name_concat_one("foo", NULL, 0, "foo");
 350         test_dns_name_concat_one("foo", ".", 0, "foo");
 351         test_dns_name_concat_one("foo.", "bar.", 0, "foo.bar");
 352         test_dns_name_concat_one(NULL, NULL, 0, ".");
 353         test_dns_name_concat_one(NULL, ".", 0, ".");
 354         test_dns_name_concat_one(NULL, "foo", 0, "foo");
 355 }
 356
 357 static void test_dns_name_is_valid_one(const char *s, int ret) {
 358         assert_se(dns_name_is_valid(s) == ret);
 359 }
 360
 361 static void test_dns_name_is_valid(void) {
 362         test_dns_name_is_valid_one("foo", 1);
 363         test_dns_name_is_valid_one("foo.", 1);
 364         test_dns_name_is_valid_one("Foo", 1);
 365         test_dns_name_is_valid_one("foo.bar", 1);
 366         test_dns_name_is_valid_one("foo.bar.baz", 1);
 367         test_dns_name_is_valid_one("", 1);
 368         test_dns_name_is_valid_one("foo..bar", 0);
 369         test_dns_name_is_valid_one(".foo.bar", 0);
 370         test_dns_name_is_valid_one("foo.bar.", 1);
 371         test_dns_name_is_valid_one("\\zbar", 0);
 372         test_dns_name_is_valid_one("ä", 1);
 373         test_dns_name_is_valid_one("\n", 0);
 374
 375         /* 256 characters*/
 376         test_dns_name_is_valid_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345", 0);
 377
 378         /* 255 characters*/
 379         test_dns_name_is_valid_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a1234", 0);
 380
 381         /* 254 characters*/
 382         test_dns_name_is_valid_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a123", 0);
 383
 384         /* 253 characters*/
 385         test_dns_name_is_valid_one("a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12345678.a12", 1);
 386
 387         /* label of 64 chars length */
 388         test_dns_name_is_valid_one("a123456789a123456789a123456789a123456789a123456789a123456789a123", 0);
 389
 390         /* label of 63 chars length */
 391         test_dns_name_is_valid_one("a123456789a123456789a123456789a123456789a123456789a123456789a12", 1);
 392 }
 393
 394 static void test_dns_service_name_is_valid(void) {
 395         assert_se(dns_service_name_is_valid("Lennart's Compüter"));
 396         assert_se(dns_service_name_is_valid("piff.paff"));
 397
 398         assert_se(!dns_service_name_is_valid(NULL));
 399         assert_se(!dns_service_name_is_valid(""));
 400         assert_se(!dns_service_name_is_valid("foo\nbar"));
 401         assert_se(!dns_service_name_is_valid("foo\201bar"));
 402         assert_se(!dns_service_name_is_valid("this is an overly long string that is certainly longer than 63 characters"));
 403 }
 404
 405 static void test_dns_srv_type_is_valid(void) {
 406
 407         assert_se(dns_srv_type_is_valid("_http._tcp"));
 408         assert_se(dns_srv_type_is_valid("_foo-bar._tcp"));
 409         assert_se(dns_srv_type_is_valid("_w._udp"));
 410         assert_se(dns_srv_type_is_valid("_a800._tcp"));
 411         assert_se(dns_srv_type_is_valid("_a-800._tcp"));
 412
 413         assert_se(!dns_srv_type_is_valid(NULL));
 414         assert_se(!dns_srv_type_is_valid(""));
 415         assert_se(!dns_srv_type_is_valid("x"));
 416         assert_se(!dns_srv_type_is_valid("_foo"));
 417         assert_se(!dns_srv_type_is_valid("_tcp"));
 418         assert_se(!dns_srv_type_is_valid("_"));
 419         assert_se(!dns_srv_type_is_valid("_foo."));
 420         assert_se(!dns_srv_type_is_valid("_föo._tcp"));
 421         assert_se(!dns_srv_type_is_valid("_f\no._tcp"));
 422         assert_se(!dns_srv_type_is_valid("_800._tcp"));
 423         assert_se(!dns_srv_type_is_valid("_-800._tcp"));
 424         assert_se(!dns_srv_type_is_valid("_-foo._tcp"));
 425         assert_se(!dns_srv_type_is_valid("_piep._foo._udp"));
 426 }
 427
 428 static void test_dns_service_join_one(const char *a, const char *b, const char *c, int r, const char *d) {
 429         _cleanup_free_ char *x = NULL, *y = NULL, *z = NULL, *t = NULL;
 430
 431         assert_se(dns_service_join(a, b, c, &t) == r);
 432         assert_se(streq_ptr(t, d));
 433
 434         if (r < 0)
 435                 return;
 436
 437         assert_se(dns_service_split(t, &x, &y, &z) >= 0);
 438         assert_se(streq_ptr(a, x));
 439         assert_se(streq_ptr(b, y));
 440         assert_se(dns_name_equal(c, z) > 0);
 441 }
 442
 443 static void test_dns_service_join(void) {
 444         test_dns_service_join_one("", "", "", -EINVAL, NULL);
 445         test_dns_service_join_one("", "_http._tcp", "", -EINVAL, NULL);
 446         test_dns_service_join_one("", "_http._tcp", "foo", -EINVAL, NULL);
 447         test_dns_service_join_one("foo", "", "foo", -EINVAL, NULL);
 448         test_dns_service_join_one("foo", "foo", "foo", -EINVAL, NULL);
 449
 450         test_dns_service_join_one("foo", "_http._tcp", "", 0, "foo._http._tcp");
 451         test_dns_service_join_one(NULL, "_http._tcp", "", 0, "_http._tcp");
 452         test_dns_service_join_one("foo", "_http._tcp", "foo", 0, "foo._http._tcp.foo");
 453         test_dns_service_join_one(NULL, "_http._tcp", "foo", 0, "_http._tcp.foo");
 454         test_dns_service_join_one("Lennart's PC", "_pc._tcp", "foo.bar.com", 0, "Lennart\\039s\\032PC._pc._tcp.foo.bar.com");
 455         test_dns_service_join_one(NULL, "_pc._tcp", "foo.bar.com", 0, "_pc._tcp.foo.bar.com");
 456 }
 457
 458 static void test_dns_service_split_one(const char *joined, const char *a, const char *b, const char *c, int r) {
 459         _cleanup_free_ char *x = NULL, *y = NULL, *z = NULL, *t = NULL;
 460
 461         assert_se(dns_service_split(joined, &x, &y, &z) == r);
 462         assert_se(streq_ptr(x, a));
 463         assert_se(streq_ptr(y, b));
 464         assert_se(streq_ptr(z, c));
 465
 466         if (r < 0)
 467                 return;
 468
 469         if (y) {
 470                 assert_se(dns_service_join(x, y, z, &t) == 0);
 471                 assert_se(dns_name_equal(joined, t) > 0);
 472         } else
 473                 assert_se(!x && dns_name_equal(z, joined) > 0);
 474 }
 475
 476 static void test_dns_service_split(void) {
 477         test_dns_service_split_one("", NULL, NULL, ".", 0);
 478         test_dns_service_split_one("foo", NULL, NULL, "foo", 0);
 479         test_dns_service_split_one("foo.bar", NULL, NULL, "foo.bar", 0);
 480         test_dns_service_split_one("_foo.bar", NULL, NULL, "_foo.bar", 0);
 481         test_dns_service_split_one("_foo._bar", NULL, "_foo._bar", ".", 0);
 482         test_dns_service_split_one("_meh._foo._bar", "_meh", "_foo._bar", ".", 0);
 483         test_dns_service_split_one("Wuff\\032Wuff._foo._bar.waldo.com", "Wuff Wuff", "_foo._bar", "waldo.com", 0);
 484 }
 485
 486 static void test_dns_name_change_suffix_one(const char *name, const char *old_suffix, const char *new_suffix, int r, const char *result) {
 487         _cleanup_free_ char *s = NULL;
 488
 489         assert_se(dns_name_change_suffix(name, old_suffix, new_suffix, &s) == r);
 490         assert_se(streq_ptr(s, result));
 491 }
 492
 493 static void test_dns_name_change_suffix(void) {
 494         test_dns_name_change_suffix_one("foo.bar", "bar", "waldo", 1, "foo.waldo");
 495         test_dns_name_change_suffix_one("foo.bar.waldi.quux", "foo.bar.waldi.quux", "piff.paff", 1, "piff.paff");
 496         test_dns_name_change_suffix_one("foo.bar.waldi.quux", "bar.waldi.quux", "piff.paff", 1, "foo.piff.paff");
 497         test_dns_name_change_suffix_one("foo.bar.waldi.quux", "waldi.quux", "piff.paff", 1, "foo.bar.piff.paff");
 498         test_dns_name_change_suffix_one("foo.bar.waldi.quux", "quux", "piff.paff", 1, "foo.bar.waldi.piff.paff");
 499         test_dns_name_change_suffix_one("foo.bar.waldi.quux", "", "piff.paff", 1, "foo.bar.waldi.quux.piff.paff");
 500         test_dns_name_change_suffix_one("", "", "piff.paff", 1, "piff.paff");
 501         test_dns_name_change_suffix_one("", "", "", 1, ".");
 502         test_dns_name_change_suffix_one("a", "b", "c", 0, NULL);
 503 }
 504
 505 static void test_dns_name_suffix_one(const char *name, unsigned n_labels, const char *result, int ret) {
 506         const char *p = NULL;
 507
 508         assert_se(ret == dns_name_suffix(name, n_labels, &p));
 509         assert_se(streq_ptr(p, result));
 510 }
 511
 512 static void test_dns_name_suffix(void) {
 513         test_dns_name_suffix_one("foo.bar", 2, "foo.bar", 0);
 514         test_dns_name_suffix_one("foo.bar", 1, "bar", 1);
 515         test_dns_name_suffix_one("foo.bar", 0, "", 2);
 516         test_dns_name_suffix_one("foo.bar", 3, NULL, -EINVAL);
 517         test_dns_name_suffix_one("foo.bar", 4, NULL, -EINVAL);
 518
 519         test_dns_name_suffix_one("bar", 1, "bar", 0);
 520         test_dns_name_suffix_one("bar", 0, "", 1);
 521         test_dns_name_suffix_one("bar", 2, NULL, -EINVAL);
 522         test_dns_name_suffix_one("bar", 3, NULL, -EINVAL);
 523
 524         test_dns_name_suffix_one("", 0, "", 0);
 525         test_dns_name_suffix_one("", 1, NULL, -EINVAL);
 526         test_dns_name_suffix_one("", 2, NULL, -EINVAL);
 527 }
 528
 529 static void test_dns_name_count_labels_one(const char *name, int n) {
 530         assert_se(dns_name_count_labels(name) == n);
 531 }
 532
 533 static void test_dns_name_count_labels(void) {
 534         test_dns_name_count_labels_one("foo.bar.quux.", 3);
 535         test_dns_name_count_labels_one("foo.bar.quux", 3);
 536         test_dns_name_count_labels_one("foo.bar.", 2);
 537         test_dns_name_count_labels_one("foo.bar", 2);
 538         test_dns_name_count_labels_one("foo.", 1);
 539         test_dns_name_count_labels_one("foo", 1);
 540         test_dns_name_count_labels_one("", 0);
 541         test_dns_name_count_labels_one(".", 0);
 542         test_dns_name_count_labels_one("..", -EINVAL);
 543 }
 544
 545 static void test_dns_name_equal_skip_one(const char *a, unsigned n_labels, const char *b, int ret) {
 546         assert_se(dns_name_equal_skip(a, n_labels, b) == ret);
 547 }
 548
 549 static void test_dns_name_equal_skip(void) {
 550         test_dns_name_equal_skip_one("foo", 0, "bar", 0);
 551         test_dns_name_equal_skip_one("foo", 0, "foo", 1);
 552         test_dns_name_equal_skip_one("foo", 1, "foo", 0);
 553         test_dns_name_equal_skip_one("foo", 2, "foo", 0);
 554
 555         test_dns_name_equal_skip_one("foo.bar", 0, "foo.bar", 1);
 556         test_dns_name_equal_skip_one("foo.bar", 1, "foo.bar", 0);
 557         test_dns_name_equal_skip_one("foo.bar", 2, "foo.bar", 0);
 558         test_dns_name_equal_skip_one("foo.bar", 3, "foo.bar", 0);
 559
 560         test_dns_name_equal_skip_one("foo.bar", 0, "bar", 0);
 561         test_dns_name_equal_skip_one("foo.bar", 1, "bar", 1);
 562         test_dns_name_equal_skip_one("foo.bar", 2, "bar", 0);
 563         test_dns_name_equal_skip_one("foo.bar", 3, "bar", 0);
 564
 565         test_dns_name_equal_skip_one("foo.bar", 0, "", 0);
 566         test_dns_name_equal_skip_one("foo.bar", 1, "", 0);
 567         test_dns_name_equal_skip_one("foo.bar", 2, "", 1);
 568         test_dns_name_equal_skip_one("foo.bar", 3, "", 0);
 569
 570         test_dns_name_equal_skip_one("", 0, "", 1);
 571         test_dns_name_equal_skip_one("", 1, "", 0);
 572         test_dns_name_equal_skip_one("", 1, "foo", 0);
 573         test_dns_name_equal_skip_one("", 2, "foo", 0);
 574 }
 575
 576 static void test_dns_name_compare_func(void) {
 577         assert_se(dns_name_compare_func("", "") == 0);
 578         assert_se(dns_name_compare_func("", ".") == 0);
 579         assert_se(dns_name_compare_func(".", "") == 0);
 580         assert_se(dns_name_compare_func("foo", "foo.") == 0);
 581         assert_se(dns_name_compare_func("foo.", "foo") == 0);
 582         assert_se(dns_name_compare_func("foo", "foo") == 0);
 583         assert_se(dns_name_compare_func("foo.", "foo.") == 0);
 584         assert_se(dns_name_compare_func("heise.de", "HEISE.DE.") == 0);
 585
 586         assert_se(dns_name_compare_func("de.", "heise.de") != 0);
 587 }
 588
 589 static void test_dns_name_common_suffix_one(const char *a, const char *b, const char *result) {
 590         const char *c;
 591
 592         assert_se(dns_name_common_suffix(a, b, &c) >= 0);
 593         assert_se(streq(c, result));
 594 }
 595
 596 static void test_dns_name_common_suffix(void) {
 597         test_dns_name_common_suffix_one("", "", "");
 598         test_dns_name_common_suffix_one("foo", "", "");
 599         test_dns_name_common_suffix_one("", "foo", "");
 600         test_dns_name_common_suffix_one("foo", "bar", "");
 601         test_dns_name_common_suffix_one("bar", "foo", "");
 602         test_dns_name_common_suffix_one("foo", "foo", "foo");
 603         test_dns_name_common_suffix_one("quux.foo", "foo", "foo");
 604         test_dns_name_common_suffix_one("foo", "quux.foo", "foo");
 605         test_dns_name_common_suffix_one("this.is.a.short.sentence", "this.is.another.short.sentence", "short.sentence");
 606         test_dns_name_common_suffix_one("FOO.BAR", "tEST.bAR", "BAR");
 607 }
 608
 609 static void test_dns_name_apply_idna_one(const char *s, const char *result) {
 610 #ifdef HAVE_LIBIDN
 611         _cleanup_free_ char *buf = NULL;
 612         assert_se(dns_name_apply_idna(s, &buf) >= 0);
 613         assert_se(dns_name_equal(buf, result) > 0);
 614 #endif
 615 }
 616
 617 static void test_dns_name_apply_idna(void) {
 618         test_dns_name_apply_idna_one("", "");
 619         test_dns_name_apply_idna_one("foo", "foo");
 620         test_dns_name_apply_idna_one("foo.", "foo");
 621         test_dns_name_apply_idna_one("foo.bar", "foo.bar");
 622         test_dns_name_apply_idna_one("foo.bar.", "foo.bar");
 623         test_dns_name_apply_idna_one("föö", "xn--f-1gaa");
 624         test_dns_name_apply_idna_one("föö.", "xn--f-1gaa");
 625         test_dns_name_apply_idna_one("föö.bär", "xn--f-1gaa.xn--br-via");
 626         test_dns_name_apply_idna_one("föö.bär.", "xn--f-1gaa.xn--br-via");
 627 }
 628
 629 int main(int argc, char *argv[]) {
 630
 631         test_dns_label_unescape();
 632         test_dns_label_unescape_suffix();
 633         test_dns_label_escape();
 634         test_dns_name_normalize();
 635         test_dns_name_equal();
 636         test_dns_name_endswith();
 637         test_dns_name_startswith();
 638         test_dns_name_between();
 639         test_dns_name_is_root();
 640         test_dns_name_is_single_label();
 641         test_dns_name_reverse();
 642         test_dns_name_concat();
 643         test_dns_name_is_valid();
 644         test_dns_name_to_wire_format();
 645         test_dns_service_name_is_valid();
 646         test_dns_srv_type_is_valid();
 647         test_dns_service_join();
 648         test_dns_service_split();
 649         test_dns_name_change_suffix();
 650         test_dns_name_suffix();
 651         test_dns_name_count_labels();
 652         test_dns_name_equal_skip();
 653         test_dns_name_compare_func();
 654         test_dns_name_common_suffix();
 655         test_dns_name_apply_idna();
 656
 657         return 0;
 658 }