git.meshlink.io Git - catta/blob - libavahi-core/rr.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <sys/types.h>
  25 #include <sys/socket.h>
  26 #include <arpa/inet.h>
  27
  28 #include "util.h"
  29 #include "rr.h"
  30 #include "dns.h"
  31
  32 AvahiKey *avahi_key_new(const gchar *name, guint16 class, guint16 type) {
  33     AvahiKey *k;
  34     g_assert(name);
  35
  36     k = g_new(AvahiKey, 1);
  37     k->ref = 1;
  38     k->name = avahi_normalize_name(name);
  39     k->class = class;
  40     k->type = type;
  41
  42 /*     g_message("%p %% ref=1", k); */
  43
  44     return k;
  45 }
  46
  47 AvahiKey *avahi_key_ref(AvahiKey *k) {
  48     g_assert(k);
  49     g_assert(k->ref >= 1);
  50
  51     k->ref++;
  52
  53 /*     g_message("%p ++ ref=%i", k, k->ref); */
  54
  55     return k;
  56 }
  57
  58 void avahi_key_unref(AvahiKey *k) {
  59     g_assert(k);
  60     g_assert(k->ref >= 1);
  61
  62 /*     g_message("%p -- ref=%i", k, k->ref-1); */
  63
  64     if ((--k->ref) <= 0) {
  65         g_free(k->name);
  66         g_free(k);
  67     }
  68 }
  69
  70 AvahiRecord *avahi_record_new(AvahiKey *k) {
  71     AvahiRecord *r;
  72
  73     g_assert(k);
  74
  75     r = g_new(AvahiRecord, 1);
  76     r->ref = 1;
  77     r->key = avahi_key_ref(k);
  78
  79     memset(&r->data, 0, sizeof(r->data));
  80
  81     r->ttl = AVAHI_DEFAULT_TTL;
  82
  83     return r;
  84 }
  85
  86 AvahiRecord *avahi_record_new_full(const gchar *name, guint16 class, guint16 type) {
  87     AvahiRecord *r;
  88     AvahiKey *k;
  89
  90     g_assert(name);
  91
  92     k = avahi_key_new(name, class, type);
  93     r = avahi_record_new(k);
  94     avahi_key_unref(k);
  95
  96     return r;
  97 }
  98
  99 AvahiRecord *avahi_record_ref(AvahiRecord *r) {
 100     g_assert(r);
 101     g_assert(r->ref >= 1);
 102
 103     r->ref++;
 104     return r;
 105 }
 106
 107 void avahi_record_unref(AvahiRecord *r) {
 108     g_assert(r);
 109     g_assert(r->ref >= 1);
 110
 111     if ((--r->ref) <= 0) {
 112         switch (r->key->type) {
 113
 114             case AVAHI_DNS_TYPE_SRV:
 115                 g_free(r->data.srv.name);
 116                 break;
 117
 118             case AVAHI_DNS_TYPE_PTR:
 119             case AVAHI_DNS_TYPE_CNAME:
 120                 g_free(r->data.ptr.name);
 121                 break;
 122
 123             case AVAHI_DNS_TYPE_HINFO:
 124                 g_free(r->data.hinfo.cpu);
 125                 g_free(r->data.hinfo.os);
 126                 break;
 127
 128             case AVAHI_DNS_TYPE_TXT:
 129                 avahi_string_list_free(r->data.txt.string_list);
 130                 break;
 131
 132             case AVAHI_DNS_TYPE_A:
 133             case AVAHI_DNS_TYPE_AAAA:
 134                 break;
 135
 136             default:
 137                 g_free(r->data.generic.data);
 138         }
 139
 140         avahi_key_unref(r->key);
 141         g_free(r);
 142     }
 143 }
 144
 145 const gchar *avahi_dns_class_to_string(guint16 class) {
 146     if (class & AVAHI_DNS_CACHE_FLUSH)
 147         return "FLUSH";
 148
 149     if (class == AVAHI_DNS_CLASS_IN)
 150         return "IN";
 151
 152     return NULL;
 153 }
 154
 155 const gchar *avahi_dns_type_to_string(guint16 type) {
 156     switch (type) {
 157         case AVAHI_DNS_TYPE_CNAME:
 158             return "CNAME";
 159         case AVAHI_DNS_TYPE_A:
 160             return "A";
 161         case AVAHI_DNS_TYPE_AAAA:
 162             return "AAAA";
 163         case AVAHI_DNS_TYPE_PTR:
 164             return "PTR";
 165         case AVAHI_DNS_TYPE_HINFO:
 166             return "HINFO";
 167         case AVAHI_DNS_TYPE_TXT:
 168             return "TXT";
 169         case AVAHI_DNS_TYPE_SRV:
 170             return "SRV";
 171         case AVAHI_DNS_TYPE_ANY:
 172             return "ANY";
 173         default:
 174             return NULL;
 175     }
 176 }
 177
 178
 179 gchar *avahi_key_to_string(const AvahiKey *k) {
 180     return g_strdup_printf("%s\t%s\t%s",
 181                            k->name,
 182                            avahi_dns_class_to_string(k->class),
 183                            avahi_dns_type_to_string(k->type));
 184 }
 185
 186 gchar *avahi_record_to_string(const AvahiRecord *r) {
 187     gchar *p, *s;
 188     char buf[257], *t = NULL, *d = NULL;
 189
 190     switch (r->key->type) {
 191         case AVAHI_DNS_TYPE_A:
 192             inet_ntop(AF_INET, &r->data.a.address.address, t = buf, sizeof(buf));
 193             break;
 194
 195         case AVAHI_DNS_TYPE_AAAA:
 196             inet_ntop(AF_INET6, &r->data.aaaa.address.address, t = buf, sizeof(buf));
 197             break;
 198
 199         case AVAHI_DNS_TYPE_PTR:
 200         case AVAHI_DNS_TYPE_CNAME :
 201
 202             t = r->data.ptr.name;
 203             break;
 204
 205         case AVAHI_DNS_TYPE_TXT:
 206             t = d = avahi_string_list_to_string(r->data.txt.string_list);
 207             break;
 208
 209         case AVAHI_DNS_TYPE_HINFO:
 210
 211             snprintf(t = buf, sizeof(buf), "\"%s\" \"%s\"", r->data.hinfo.cpu, r->data.hinfo.os);
 212             break;
 213
 214         case AVAHI_DNS_TYPE_SRV:
 215
 216             snprintf(t = buf, sizeof(buf), "%u %u %u %s",
 217                      r->data.srv.priority,
 218                      r->data.srv.weight,
 219                      r->data.srv.port,
 220                      r->data.srv.name);
 221
 222             break;
 223     }
 224
 225     p = avahi_key_to_string(r->key);
 226     s = g_strdup_printf("%s %s ; ttl=%u", p, t ? t : "<unparsable>", r->ttl);
 227     g_free(p);
 228     g_free(d);
 229
 230     return s;
 231 }
 232
 233 gboolean avahi_key_equal(const AvahiKey *a, const AvahiKey *b) {
 234     g_assert(a);
 235     g_assert(b);
 236
 237     if (a == b)
 238         return TRUE;
 239
 240 /*     g_message("equal: %p %p", a, b); */
 241
 242     return avahi_domain_equal(a->name, b->name) &&
 243         a->type == b->type &&
 244         a->class == b->class;
 245 }
 246
 247 gboolean avahi_key_pattern_match(const AvahiKey *pattern, const AvahiKey *k) {
 248     g_assert(pattern);
 249     g_assert(k);
 250
 251 /*     g_message("equal: %p %p", a, b); */
 252
 253     g_assert(!avahi_key_is_pattern(k));
 254
 255     if (pattern == k)
 256         return TRUE;
 257
 258     return avahi_domain_equal(pattern->name, k->name) &&
 259         (pattern->type == k->type || pattern->type == AVAHI_DNS_TYPE_ANY) &&
 260         pattern->class == k->class;
 261 }
 262
 263 gboolean avahi_key_is_pattern(const AvahiKey *k) {
 264     g_assert(k);
 265
 266     return k->type == AVAHI_DNS_TYPE_ANY;
 267 }
 268
 269
 270 guint avahi_key_hash(const AvahiKey *k) {
 271     g_assert(k);
 272
 273     return avahi_domain_hash(k->name) + k->type + k->class;
 274 }
 275
 276 static gboolean rdata_equal(const AvahiRecord *a, const AvahiRecord *b) {
 277     g_assert(a);
 278     g_assert(b);
 279     g_assert(a->key->type == b->key->type);
 280
 281 /*     t = avahi_record_to_string(a); */
 282 /*     g_message("comparing %s", t); */
 283 /*     g_free(t); */
 284
 285 /*     t = avahi_record_to_string(b); */
 286 /*     g_message("and %s", t); */
 287 /*     g_free(t); */
 288
 289
 290     switch (a->key->type) {
 291         case AVAHI_DNS_TYPE_SRV:
 292             return
 293                 a->data.srv.priority == b->data.srv.priority &&
 294                 a->data.srv.weight == b->data.srv.weight &&
 295                 a->data.srv.port == b->data.srv.port &&
 296                 avahi_domain_equal(a->data.srv.name, b->data.srv.name);
 297
 298         case AVAHI_DNS_TYPE_PTR:
 299         case AVAHI_DNS_TYPE_CNAME:
 300             return avahi_domain_equal(a->data.ptr.name, b->data.ptr.name);
 301
 302         case AVAHI_DNS_TYPE_HINFO:
 303             return
 304                 !strcmp(a->data.hinfo.cpu, b->data.hinfo.cpu) &&
 305                 !strcmp(a->data.hinfo.os, b->data.hinfo.os);
 306
 307         case AVAHI_DNS_TYPE_TXT:
 308             return avahi_string_list_equal(a->data.txt.string_list, b->data.txt.string_list);
 309
 310         case AVAHI_DNS_TYPE_A:
 311             return memcmp(&a->data.a.address, &b->data.a.address, sizeof(AvahiIPv4Address)) == 0;
 312
 313         case AVAHI_DNS_TYPE_AAAA:
 314             return memcmp(&a->data.aaaa.address, &b->data.aaaa.address, sizeof(AvahiIPv6Address)) == 0;
 315
 316         default:
 317             return a->data.generic.size == b->data.generic.size &&
 318                 (a->data.generic.size == 0 || memcmp(a->data.generic.data, b->data.generic.data, a->data.generic.size) == 0);
 319     }
 320
 321 }
 322
 323 gboolean avahi_record_equal_no_ttl(const AvahiRecord *a, const AvahiRecord *b) {
 324     g_assert(a);
 325     g_assert(b);
 326
 327     if (a == b)
 328         return TRUE;
 329
 330     return
 331         avahi_key_equal(a->key, b->key) &&
 332         rdata_equal(a, b);
 333 }
 334
 335
 336 AvahiRecord *avahi_record_copy(AvahiRecord *r) {
 337     AvahiRecord *copy;
 338
 339     copy = g_new(AvahiRecord, 1);
 340     copy->ref = 1;
 341     copy->key = avahi_key_ref(r->key);
 342     copy->ttl = r->ttl;
 343
 344     switch (r->key->type) {
 345         case AVAHI_DNS_TYPE_PTR:
 346         case AVAHI_DNS_TYPE_CNAME:
 347             copy->data.ptr.name = g_strdup(r->data.ptr.name);
 348             break;
 349
 350         case AVAHI_DNS_TYPE_SRV:
 351             copy->data.srv.priority = r->data.srv.priority;
 352             copy->data.srv.weight = r->data.srv.weight;
 353             copy->data.srv.port = r->data.srv.port;
 354             copy->data.srv.name = g_strdup(r->data.srv.name);
 355             break;
 356
 357         case AVAHI_DNS_TYPE_HINFO:
 358             copy->data.hinfo.os = g_strdup(r->data.hinfo.os);
 359             copy->data.hinfo.cpu = g_strdup(r->data.hinfo.cpu);
 360             break;
 361
 362         case AVAHI_DNS_TYPE_TXT:
 363             copy->data.txt.string_list = avahi_string_list_copy(r->data.txt.string_list);
 364             break;
 365
 366         case AVAHI_DNS_TYPE_A:
 367             copy->data.a.address = r->data.a.address;
 368             break;
 369
 370         case AVAHI_DNS_TYPE_AAAA:
 371             copy->data.aaaa.address = r->data.aaaa.address;
 372             break;
 373
 374         default:
 375             copy->data.generic.data = g_memdup(r->data.generic.data, r->data.generic.size);
 376             copy->data.generic.size = r->data.generic.size;
 377             break;
 378
 379     }
 380
 381     return copy;
 382 }
 383
 384
 385 guint avahi_key_get_estimate_size(AvahiKey *k) {
 386     g_assert(k);
 387
 388     return strlen(k->name)+1+4;
 389 }
 390
 391 guint avahi_record_get_estimate_size(AvahiRecord *r) {
 392     guint n;
 393     g_assert(r);
 394
 395     n = avahi_key_get_estimate_size(r->key) + 4 + 2;
 396
 397     switch (r->key->type) {
 398         case AVAHI_DNS_TYPE_PTR:
 399         case AVAHI_DNS_TYPE_CNAME:
 400             n += strlen(r->data.ptr.name) + 1;
 401             break;
 402
 403         case AVAHI_DNS_TYPE_SRV:
 404             n += 6 + strlen(r->data.srv.name) + 1;
 405             break;
 406
 407         case AVAHI_DNS_TYPE_HINFO:
 408             n += strlen(r->data.hinfo.os) + 1 + strlen(r->data.hinfo.cpu) + 1;
 409             break;
 410
 411         case AVAHI_DNS_TYPE_TXT:
 412             n += avahi_string_list_serialize(r->data.txt.string_list, NULL, 0);
 413             break;
 414
 415         case AVAHI_DNS_TYPE_A:
 416             n += sizeof(AvahiIPv4Address);
 417             break;
 418
 419         case AVAHI_DNS_TYPE_AAAA:
 420             n += sizeof(AvahiIPv6Address);
 421             break;
 422
 423         default:
 424             n += r->data.generic.size;
 425     }
 426
 427     return n;
 428 }
 429
 430 static gint lexicographical_memcmp(gconstpointer a, size_t al, gconstpointer b, size_t bl) {
 431     size_t c;
 432     gint ret;
 433
 434     g_assert(a);
 435     g_assert(b);
 436
 437     c = al < bl ? al : bl;
 438     if ((ret = memcmp(a, b, c)) != 0)
 439         return ret;
 440
 441     if (al == bl)
 442         return 0;
 443     else
 444         return al == c ? 1 : -1;
 445 }
 446
 447 static gint uint16_cmp(guint16 a, guint16 b) {
 448     return a == b ? 0 : (a < b ? a : b);
 449 }
 450
 451 static gint lexicographical_domain_cmp(const gchar *a, const gchar *b) {
 452     g_assert(a);
 453     g_assert(b);
 454
 455
 456     for (;;) {
 457         gchar t1[64];
 458         gchar t2[64];
 459         size_t al, bl;
 460         gint r;
 461
 462         if (!a && !b)
 463             return 0;
 464
 465         if (a && !b)
 466             return 1;
 467
 468         if (b && !a)
 469             return -1;
 470
 471         avahi_unescape_label(t1, sizeof(t1), &a);
 472         avahi_unescape_label(t2, sizeof(t2), &b);
 473
 474         al = strlen(t1);
 475         bl = strlen(t2);
 476
 477         if (al != bl)
 478             return al < bl ? -1 : 1;
 479
 480         if ((r =  strcmp(t1, t2)) != 0)
 481             return r;
 482     }
 483 }
 484
 485 gint avahi_record_lexicographical_compare(AvahiRecord *a, AvahiRecord *b) {
 486     g_assert(a);
 487     g_assert(b);
 488
 489     if (a == b)
 490         return 0;
 491
 492 /*     gchar *t; */
 493
 494 /*     g_message("comparing [%s]", t = avahi_record_to_string(a)); */
 495 /*     g_free(t); */
 496
 497 /*     g_message("and [%s]", t = avahi_record_to_string(b)); */
 498 /*     g_free(t); */
 499
 500     if (a->key->class < b->key->class)
 501         return -1;
 502     else if (a->key->class > b->key->class)
 503         return 1;
 504
 505     if (a->key->type < b->key->type)
 506         return -1;
 507     else if (a->key->type > b->key->type)
 508         return 1;
 509
 510     switch (a->key->type) {
 511
 512         case AVAHI_DNS_TYPE_PTR:
 513         case AVAHI_DNS_TYPE_CNAME:
 514             return lexicographical_domain_cmp(a->data.ptr.name, b->data.ptr.name);
 515
 516         case AVAHI_DNS_TYPE_SRV: {
 517             gint r;
 518             if ((r = uint16_cmp(a->data.srv.priority, b->data.srv.priority)) == 0 &&
 519                 (r = uint16_cmp(a->data.srv.weight, b->data.srv.weight)) == 0 &&
 520                 (r = uint16_cmp(a->data.srv.port, b->data.srv.port)) == 0)
 521                 r = lexicographical_domain_cmp(a->data.srv.name, b->data.srv.name);
 522
 523             return r;
 524         }
 525
 526         case AVAHI_DNS_TYPE_HINFO: {
 527             size_t al = strlen(a->data.hinfo.cpu), bl = strlen(b->data.hinfo.cpu);
 528             gint r;
 529
 530             if (al != bl)
 531                 return al < bl ? -1 : 1;
 532
 533             if ((r = strcmp(a->data.hinfo.cpu, b->data.hinfo.cpu)) != 0)
 534                 return r;
 535
 536             al = strlen(a->data.hinfo.os), bl = strlen(b->data.hinfo.os);
 537
 538             if (al != bl)
 539                 return al < bl ? -1 : 1;
 540
 541             if ((r = strcmp(a->data.hinfo.os, b->data.hinfo.os)) != 0)
 542                 return r;
 543
 544             return 0;
 545
 546         }
 547
 548         case AVAHI_DNS_TYPE_TXT: {
 549
 550             guint8 *ma, *mb;
 551             guint asize, bsize;
 552             gint r;
 553
 554             ma = g_new(guint8, asize = avahi_string_list_serialize(a->data.txt.string_list, NULL, 0));
 555             mb = g_new(guint8, bsize = avahi_string_list_serialize(b->data.txt.string_list, NULL, 0));
 556             avahi_string_list_serialize(a->data.txt.string_list, ma, asize);
 557             avahi_string_list_serialize(a->data.txt.string_list, mb, bsize);
 558
 559             r = lexicographical_memcmp(ma, asize, mb, bsize);
 560             g_free(ma);
 561             g_free(mb);
 562
 563             return r;
 564         }
 565
 566         case AVAHI_DNS_TYPE_A:
 567             return memcmp(&a->data.a.address, &b->data.a.address, sizeof(AvahiIPv4Address));
 568
 569         case AVAHI_DNS_TYPE_AAAA:
 570             return memcmp(&a->data.aaaa.address, &b->data.aaaa.address, sizeof(AvahiIPv6Address));
 571
 572         default:
 573             return lexicographical_memcmp(a->data.generic.data, a->data.generic.size,
 574                                           b->data.generic.data, b->data.generic.size);
 575     }
 576
 577 }