git.meshlink.io Git - catta/blob - avahi-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 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <string.h>
  27 #include <stdio.h>
  28 #include <sys/types.h>
  29 #include <sys/socket.h>
  30 #include <arpa/inet.h>
  31 #include <assert.h>
  32
  33 #include <avahi-common/domain.h>
  34 #include <avahi-common/malloc.h>
  35 #include <avahi-common/defs.h>
  36
  37 #include "rr.h"
  38 #include "log.h"
  39 #include "util.h"
  40 #include "hashmap.h"
  41 #include "domain-util.h"
  42 #include "rr-util.h"
  43 #include "addr-util.h"
  44
  45 AvahiKey *avahi_key_new(const char *name, uint16_t class, uint16_t type) {
  46     AvahiKey *k;
  47     assert(name);
  48
  49     if (!(k = avahi_new(AvahiKey, 1))) {
  50         avahi_log_error("avahi_new() failed.");
  51         return NULL;
  52     }
  53
  54     if (!(k->name = avahi_normalize_name_strdup(name))) {
  55         avahi_log_error("avahi_normalize_name() failed.");
  56         avahi_free(k);
  57         return NULL;
  58     }
  59
  60     k->ref = 1;
  61     k->clazz = class;
  62     k->type = type;
  63
  64     return k;
  65 }
  66
  67 AvahiKey *avahi_key_new_cname(AvahiKey *key) {
  68     assert(key);
  69
  70     if (key->clazz != AVAHI_DNS_CLASS_IN)
  71         return NULL;
  72
  73     if (key->type == AVAHI_DNS_TYPE_CNAME)
  74         return NULL;
  75
  76     return avahi_key_new(key->name, key->clazz, AVAHI_DNS_TYPE_CNAME);
  77 }
  78
  79 AvahiKey *avahi_key_ref(AvahiKey *k) {
  80     assert(k);
  81     assert(k->ref >= 1);
  82
  83     k->ref++;
  84
  85     return k;
  86 }
  87
  88 void avahi_key_unref(AvahiKey *k) {
  89     assert(k);
  90     assert(k->ref >= 1);
  91
  92     if ((--k->ref) <= 0) {
  93         avahi_free(k->name);
  94         avahi_free(k);
  95     }
  96 }
  97
  98 AvahiRecord *avahi_record_new(AvahiKey *k, uint32_t ttl) {
  99     AvahiRecord *r;
 100
 101     assert(k);
 102
 103     if (!(r = avahi_new(AvahiRecord, 1))) {
 104         avahi_log_error("avahi_new() failed.");
 105         return NULL;
 106     }
 107
 108     r->ref = 1;
 109     r->key = avahi_key_ref(k);
 110
 111     memset(&r->data, 0, sizeof(r->data));
 112
 113     r->ttl = ttl != (uint32_t) -1 ? ttl : AVAHI_DEFAULT_TTL;
 114
 115     return r;
 116 }
 117
 118 AvahiRecord *avahi_record_new_full(const char *name, uint16_t class, uint16_t type, uint32_t ttl) {
 119     AvahiRecord *r;
 120     AvahiKey *k;
 121
 122     assert(name);
 123
 124     if (!(k = avahi_key_new(name, class, type))) {
 125         avahi_log_error("avahi_key_new() failed.");
 126         return NULL;
 127     }
 128
 129     r = avahi_record_new(k, ttl);
 130     avahi_key_unref(k);
 131
 132     if (!r) {
 133         avahi_log_error("avahi_record_new() failed.");
 134         return NULL;
 135     }
 136
 137     return r;
 138 }
 139
 140 AvahiRecord *avahi_record_ref(AvahiRecord *r) {
 141     assert(r);
 142     assert(r->ref >= 1);
 143
 144     r->ref++;
 145     return r;
 146 }
 147
 148 void avahi_record_unref(AvahiRecord *r) {
 149     assert(r);
 150     assert(r->ref >= 1);
 151
 152     if ((--r->ref) <= 0) {
 153         switch (r->key->type) {
 154
 155             case AVAHI_DNS_TYPE_SRV:
 156                 avahi_free(r->data.srv.name);
 157                 break;
 158
 159             case AVAHI_DNS_TYPE_PTR:
 160             case AVAHI_DNS_TYPE_CNAME:
 161             case AVAHI_DNS_TYPE_NS:
 162                 avahi_free(r->data.ptr.name);
 163                 break;
 164
 165             case AVAHI_DNS_TYPE_HINFO:
 166                 avahi_free(r->data.hinfo.cpu);
 167                 avahi_free(r->data.hinfo.os);
 168                 break;
 169
 170             case AVAHI_DNS_TYPE_TXT:
 171                 avahi_string_list_free(r->data.txt.string_list);
 172                 break;
 173
 174             case AVAHI_DNS_TYPE_A:
 175             case AVAHI_DNS_TYPE_AAAA:
 176                 break;
 177
 178             default:
 179                 avahi_free(r->data.generic.data);
 180         }
 181
 182         avahi_key_unref(r->key);
 183         avahi_free(r);
 184     }
 185 }
 186
 187 const char *avahi_dns_class_to_string(uint16_t class) {
 188     if (class & AVAHI_DNS_CACHE_FLUSH)
 189         return "FLUSH";
 190
 191     switch (class) {
 192         case AVAHI_DNS_CLASS_IN:
 193             return "IN";
 194         case AVAHI_DNS_CLASS_ANY:
 195             return "ANY";
 196         default:
 197             return NULL;
 198     }
 199 }
 200
 201 const char *avahi_dns_type_to_string(uint16_t type) {
 202     switch (type) {
 203         case AVAHI_DNS_TYPE_CNAME:
 204             return "CNAME";
 205         case AVAHI_DNS_TYPE_A:
 206             return "A";
 207         case AVAHI_DNS_TYPE_AAAA:
 208             return "AAAA";
 209         case AVAHI_DNS_TYPE_PTR:
 210             return "PTR";
 211         case AVAHI_DNS_TYPE_HINFO:
 212             return "HINFO";
 213         case AVAHI_DNS_TYPE_TXT:
 214             return "TXT";
 215         case AVAHI_DNS_TYPE_SRV:
 216             return "SRV";
 217         case AVAHI_DNS_TYPE_ANY:
 218             return "ANY";
 219         case AVAHI_DNS_TYPE_SOA:
 220             return "SOA";
 221         case AVAHI_DNS_TYPE_NS:
 222             return "NS";
 223         default:
 224             return NULL;
 225     }
 226 }
 227
 228 char *avahi_key_to_string(const AvahiKey *k) {
 229     char class[16], type[16];
 230     const char *c, *t;
 231
 232     assert(k);
 233     assert(k->ref >= 1);
 234
 235     /* According to RFC3597 */
 236
 237     if (!(c = avahi_dns_class_to_string(k->clazz))) {
 238         snprintf(class, sizeof(class), "CLASS%u", k->clazz);
 239         c = class;
 240     }
 241
 242     if (!(t = avahi_dns_type_to_string(k->type))) {
 243         snprintf(type, sizeof(type), "TYPE%u", k->type);
 244         t = type;
 245     }
 246
 247     return avahi_strdup_printf("%s\t%s\t%s", k->name, c, t);
 248 }
 249
 250 char *avahi_record_to_string(const AvahiRecord *r) {
 251     char *p, *s;
 252     char buf[1024], *t = NULL, *d = NULL;
 253
 254     assert(r);
 255     assert(r->ref >= 1);
 256
 257     switch (r->key->type) {
 258         case AVAHI_DNS_TYPE_A:
 259             inet_ntop(AF_INET, &r->data.a.address.address, t = buf, sizeof(buf));
 260             break;
 261
 262         case AVAHI_DNS_TYPE_AAAA:
 263             inet_ntop(AF_INET6, &r->data.aaaa.address.address, t = buf, sizeof(buf));
 264             break;
 265
 266         case AVAHI_DNS_TYPE_PTR:
 267         case AVAHI_DNS_TYPE_CNAME:
 268         case AVAHI_DNS_TYPE_NS:
 269
 270             t = r->data.ptr.name;
 271             break;
 272
 273         case AVAHI_DNS_TYPE_TXT:
 274             t = d = avahi_string_list_to_string(r->data.txt.string_list);
 275             break;
 276
 277         case AVAHI_DNS_TYPE_HINFO:
 278
 279             snprintf(t = buf, sizeof(buf), "\"%s\" \"%s\"", r->data.hinfo.cpu, r->data.hinfo.os);
 280             break;
 281
 282         case AVAHI_DNS_TYPE_SRV:
 283
 284             snprintf(t = buf, sizeof(buf), "%u %u %u %s",
 285                      r->data.srv.priority,
 286                      r->data.srv.weight,
 287                      r->data.srv.port,
 288                      r->data.srv.name);
 289
 290             break;
 291
 292         default: {
 293
 294             uint8_t *c;
 295             uint16_t n;
 296             int i;
 297             char *e;
 298
 299             /* According to RFC3597 */
 300
 301             snprintf(t = buf, sizeof(buf), "\\# %u", r->data.generic.size);
 302
 303             e = strchr(t, 0);
 304
 305             for (c = r->data.generic.data, n = r->data.generic.size, i = 0;
 306                  n > 0 && i < 20;
 307                  c ++, n --, i++) {
 308
 309                 sprintf(e, " %02X", *c);
 310                 e = strchr(e, 0);
 311             }
 312
 313             break;
 314         }
 315     }
 316
 317     p = avahi_key_to_string(r->key);
 318     s = avahi_strdup_printf("%s %s ; ttl=%u", p, t, r->ttl);
 319     avahi_free(p);
 320     avahi_free(d);
 321
 322     return s;
 323 }
 324
 325 int avahi_key_equal(const AvahiKey *a, const AvahiKey *b) {
 326     assert(a);
 327     assert(b);
 328
 329     if (a == b)
 330         return 1;
 331
 332     return avahi_domain_equal(a->name, b->name) &&
 333         a->type == b->type &&
 334         a->clazz == b->clazz;
 335 }
 336
 337 int avahi_key_pattern_match(const AvahiKey *pattern, const AvahiKey *k) {
 338     assert(pattern);
 339     assert(k);
 340
 341     assert(!avahi_key_is_pattern(k));
 342
 343     if (pattern == k)
 344         return 1;
 345
 346     return avahi_domain_equal(pattern->name, k->name) &&
 347         (pattern->type == k->type || pattern->type == AVAHI_DNS_TYPE_ANY) &&
 348         (pattern->clazz == k->clazz || pattern->clazz == AVAHI_DNS_CLASS_ANY);
 349 }
 350
 351 int avahi_key_is_pattern(const AvahiKey *k) {
 352     assert(k);
 353
 354     return
 355         k->type == AVAHI_DNS_TYPE_ANY ||
 356         k->clazz == AVAHI_DNS_CLASS_ANY;
 357 }
 358
 359 unsigned avahi_key_hash(const AvahiKey *k) {
 360     assert(k);
 361
 362     return
 363         avahi_domain_hash(k->name) +
 364         k->type +
 365         k->clazz;
 366 }
 367
 368 static int rdata_equal(const AvahiRecord *a, const AvahiRecord *b) {
 369     assert(a);
 370     assert(b);
 371     assert(a->key->type == b->key->type);
 372
 373     switch (a->key->type) {
 374         case AVAHI_DNS_TYPE_SRV:
 375             return
 376                 a->data.srv.priority == b->data.srv.priority &&
 377                 a->data.srv.weight == b->data.srv.weight &&
 378                 a->data.srv.port == b->data.srv.port &&
 379                 avahi_domain_equal(a->data.srv.name, b->data.srv.name);
 380
 381         case AVAHI_DNS_TYPE_PTR:
 382         case AVAHI_DNS_TYPE_CNAME:
 383         case AVAHI_DNS_TYPE_NS:
 384             return avahi_domain_equal(a->data.ptr.name, b->data.ptr.name);
 385
 386         case AVAHI_DNS_TYPE_HINFO:
 387             return
 388                 !strcmp(a->data.hinfo.cpu, b->data.hinfo.cpu) &&
 389                 !strcmp(a->data.hinfo.os, b->data.hinfo.os);
 390
 391         case AVAHI_DNS_TYPE_TXT:
 392             return avahi_string_list_equal(a->data.txt.string_list, b->data.txt.string_list);
 393
 394         case AVAHI_DNS_TYPE_A:
 395             return memcmp(&a->data.a.address, &b->data.a.address, sizeof(AvahiIPv4Address)) == 0;
 396
 397         case AVAHI_DNS_TYPE_AAAA:
 398             return memcmp(&a->data.aaaa.address, &b->data.aaaa.address, sizeof(AvahiIPv6Address)) == 0;
 399
 400         default:
 401             return a->data.generic.size == b->data.generic.size &&
 402                 (a->data.generic.size == 0 || memcmp(a->data.generic.data, b->data.generic.data, a->data.generic.size) == 0);
 403     }
 404
 405 }
 406
 407 int avahi_record_equal_no_ttl(const AvahiRecord *a, const AvahiRecord *b) {
 408     assert(a);
 409     assert(b);
 410
 411     if (a == b)
 412         return 1;
 413
 414     return
 415         avahi_key_equal(a->key, b->key) &&
 416         rdata_equal(a, b);
 417 }
 418
 419
 420 AvahiRecord *avahi_record_copy(AvahiRecord *r) {
 421     AvahiRecord *copy;
 422
 423     if (!(copy = avahi_new(AvahiRecord, 1))) {
 424         avahi_log_error("avahi_new() failed.");
 425         return NULL;
 426     }
 427
 428     copy->ref = 1;
 429     copy->key = avahi_key_ref(r->key);
 430     copy->ttl = r->ttl;
 431
 432     switch (r->key->type) {
 433         case AVAHI_DNS_TYPE_PTR:
 434         case AVAHI_DNS_TYPE_CNAME:
 435         case AVAHI_DNS_TYPE_NS:
 436             if (!(copy->data.ptr.name = avahi_strdup(r->data.ptr.name)))
 437                 goto fail;
 438             break;
 439
 440         case AVAHI_DNS_TYPE_SRV:
 441             copy->data.srv.priority = r->data.srv.priority;
 442             copy->data.srv.weight = r->data.srv.weight;
 443             copy->data.srv.port = r->data.srv.port;
 444             if (!(copy->data.srv.name = avahi_strdup(r->data.srv.name)))
 445                 goto fail;
 446             break;
 447
 448         case AVAHI_DNS_TYPE_HINFO:
 449             if (!(copy->data.hinfo.os = avahi_strdup(r->data.hinfo.os)))
 450                 goto fail;
 451
 452             if (!(copy->data.hinfo.cpu = avahi_strdup(r->data.hinfo.cpu))) {
 453                 avahi_free(r->data.hinfo.os);
 454                 goto fail;
 455             }
 456             break;
 457
 458         case AVAHI_DNS_TYPE_TXT:
 459             copy->data.txt.string_list = avahi_string_list_copy(r->data.txt.string_list);
 460             break;
 461
 462         case AVAHI_DNS_TYPE_A:
 463             copy->data.a.address = r->data.a.address;
 464             break;
 465
 466         case AVAHI_DNS_TYPE_AAAA:
 467             copy->data.aaaa.address = r->data.aaaa.address;
 468             break;
 469
 470         default:
 471             if (!(copy->data.generic.data = avahi_memdup(r->data.generic.data, r->data.generic.size)))
 472                 goto fail;
 473             copy->data.generic.size = r->data.generic.size;
 474             break;
 475
 476     }
 477
 478     return copy;
 479
 480 fail:
 481     avahi_log_error("Failed to allocate memory");
 482
 483     avahi_key_unref(copy->key);
 484     avahi_free(copy);
 485
 486     return NULL;
 487 }
 488
 489
 490 size_t avahi_key_get_estimate_size(AvahiKey *k) {
 491     assert(k);
 492
 493     return strlen(k->name)+1+4;
 494 }
 495
 496 size_t avahi_record_get_estimate_size(AvahiRecord *r) {
 497     size_t n;
 498     assert(r);
 499
 500     n = avahi_key_get_estimate_size(r->key) + 4 + 2;
 501
 502     switch (r->key->type) {
 503         case AVAHI_DNS_TYPE_PTR:
 504         case AVAHI_DNS_TYPE_CNAME:
 505         case AVAHI_DNS_TYPE_NS:
 506             n += strlen(r->data.ptr.name) + 1;
 507             break;
 508
 509         case AVAHI_DNS_TYPE_SRV:
 510             n += 6 + strlen(r->data.srv.name) + 1;
 511             break;
 512
 513         case AVAHI_DNS_TYPE_HINFO:
 514             n += strlen(r->data.hinfo.os) + 1 + strlen(r->data.hinfo.cpu) + 1;
 515             break;
 516
 517         case AVAHI_DNS_TYPE_TXT:
 518             n += avahi_string_list_serialize(r->data.txt.string_list, NULL, 0);
 519             break;
 520
 521         case AVAHI_DNS_TYPE_A:
 522             n += sizeof(AvahiIPv4Address);
 523             break;
 524
 525         case AVAHI_DNS_TYPE_AAAA:
 526             n += sizeof(AvahiIPv6Address);
 527             break;
 528
 529         default:
 530             n += r->data.generic.size;
 531     }
 532
 533     return n;
 534 }
 535
 536 static int lexicographical_memcmp(const void* a, size_t al, const void* b, size_t bl) {
 537     size_t c;
 538     int ret;
 539
 540     assert(a);
 541     assert(b);
 542
 543     c = al < bl ? al : bl;
 544     if ((ret = memcmp(a, b, c)))
 545         return ret;
 546
 547     if (al == bl)
 548         return 0;
 549     else
 550         return al == c ? 1 : -1;
 551 }
 552
 553 static int uint16_cmp(uint16_t a, uint16_t b) {
 554     return a == b ? 0 : (a < b ? -1 : 1);
 555 }
 556
 557 int avahi_record_lexicographical_compare(AvahiRecord *a, AvahiRecord *b) {
 558     int r;
 559 /*      char *t1, *t2; */
 560
 561     assert(a);
 562     assert(b);
 563
 564 /*     t1 = avahi_record_to_string(a); */
 565 /*     t2 = avahi_record_to_string(b); */
 566 /*     g_message("lexicocmp: %s %s", t1, t2); */
 567 /*     avahi_free(t1); */
 568 /*     avahi_free(t2); */
 569
 570     if (a == b)
 571         return 0;
 572
 573     if ((r = uint16_cmp(a->key->clazz, b->key->clazz)) ||
 574         (r = uint16_cmp(a->key->type, b->key->type)))
 575         return r;
 576
 577     switch (a->key->type) {
 578
 579         case AVAHI_DNS_TYPE_PTR:
 580         case AVAHI_DNS_TYPE_CNAME:
 581         case AVAHI_DNS_TYPE_NS:
 582             return avahi_binary_domain_cmp(a->data.ptr.name, b->data.ptr.name);
 583
 584         case AVAHI_DNS_TYPE_SRV: {
 585             if ((r = uint16_cmp(a->data.srv.priority, b->data.srv.priority)) == 0 &&
 586                 (r = uint16_cmp(a->data.srv.weight, b->data.srv.weight)) == 0 &&
 587                 (r = uint16_cmp(a->data.srv.port, b->data.srv.port)) == 0)
 588                 r = avahi_binary_domain_cmp(a->data.srv.name, b->data.srv.name);
 589
 590             return r;
 591         }
 592
 593         case AVAHI_DNS_TYPE_HINFO: {
 594
 595             if ((r = strcmp(a->data.hinfo.cpu, b->data.hinfo.cpu)) ||
 596                 (r = strcmp(a->data.hinfo.os, b->data.hinfo.os)))
 597                 return r;
 598
 599             return 0;
 600
 601         }
 602
 603         case AVAHI_DNS_TYPE_TXT: {
 604
 605             uint8_t *ma = NULL, *mb = NULL;
 606             size_t asize, bsize;
 607
 608             asize = avahi_string_list_serialize(a->data.txt.string_list, NULL, 0);
 609             bsize = avahi_string_list_serialize(b->data.txt.string_list, NULL, 0);
 610
 611             if (asize > 0 && !(ma = avahi_new(uint8_t, asize)))
 612                 goto fail;
 613
 614             if (bsize > 0 && !(mb = avahi_new(uint8_t, bsize))) {
 615                 avahi_free(ma);
 616                 goto fail;
 617             }
 618
 619             avahi_string_list_serialize(a->data.txt.string_list, ma, asize);
 620             avahi_string_list_serialize(b->data.txt.string_list, mb, bsize);
 621
 622             if (asize && bsize)
 623                 r = lexicographical_memcmp(ma, asize, mb, bsize);
 624             else if (asize && !bsize)
 625                 r = 1;
 626             else if (!asize && bsize)
 627                 r = -1;
 628             else
 629                 r = 0;
 630
 631             avahi_free(ma);
 632             avahi_free(mb);
 633
 634             return r;
 635         }
 636
 637         case AVAHI_DNS_TYPE_A:
 638             return memcmp(&a->data.a.address, &b->data.a.address, sizeof(AvahiIPv4Address));
 639
 640         case AVAHI_DNS_TYPE_AAAA:
 641             return memcmp(&a->data.aaaa.address, &b->data.aaaa.address, sizeof(AvahiIPv6Address));
 642
 643         default:
 644             return lexicographical_memcmp(a->data.generic.data, a->data.generic.size,
 645                                           b->data.generic.data, b->data.generic.size);
 646     }
 647
 648
 649 fail:
 650     avahi_log_error(__FILE__": Out of memory");
 651     return -1; /* or whatever ... */
 652 }
 653
 654 int avahi_record_is_goodbye(AvahiRecord *r) {
 655     assert(r);
 656
 657     return r->ttl == 0;
 658 }
 659
 660 int avahi_key_is_valid(AvahiKey *k) {
 661     assert(k);
 662
 663     if (!avahi_is_valid_domain_name(k->name))
 664         return 0;
 665
 666     return 1;
 667 }
 668
 669 int avahi_record_is_valid(AvahiRecord *r) {
 670     assert(r);
 671
 672     if (!avahi_key_is_valid(r->key))
 673         return 0;
 674
 675     switch (r->key->type) {
 676
 677         case AVAHI_DNS_TYPE_PTR:
 678         case AVAHI_DNS_TYPE_CNAME:
 679         case AVAHI_DNS_TYPE_NS:
 680             return avahi_is_valid_domain_name(r->data.ptr.name);
 681
 682         case AVAHI_DNS_TYPE_SRV:
 683             return avahi_is_valid_domain_name(r->data.srv.name);
 684
 685         case AVAHI_DNS_TYPE_HINFO:
 686             return
 687                 strlen(r->data.hinfo.os) <= 255 &&
 688                 strlen(r->data.hinfo.cpu) <= 255;
 689
 690         case AVAHI_DNS_TYPE_TXT: {
 691
 692             AvahiStringList *strlst;
 693
 694             for (strlst = r->data.txt.string_list; strlst; strlst = strlst->next)
 695                 if (strlst->size > 255 || strlst->size <= 0)
 696                     return 0;
 697
 698             return 1;
 699         }
 700     }
 701
 702     return 1;
 703 }
 704
 705 static AvahiAddress *get_address(const AvahiRecord *r, AvahiAddress *a) {
 706     assert(r);
 707
 708     switch (r->key->type) {
 709         case AVAHI_DNS_TYPE_A:
 710             a->proto = AVAHI_PROTO_INET;
 711             a->data.ipv4 = r->data.a.address;
 712             break;
 713
 714         case AVAHI_DNS_TYPE_AAAA:
 715             a->proto = AVAHI_PROTO_INET6;
 716             a->data.ipv6 = r->data.aaaa.address;
 717             break;
 718
 719         default:
 720             return NULL;
 721     }
 722
 723     return a;
 724 }
 725
 726 int avahi_record_is_link_local_address(const AvahiRecord *r) {
 727     AvahiAddress a;
 728
 729     assert(r);
 730
 731     if (!get_address(r, &a))
 732         return 0;
 733
 734     return avahi_address_is_link_local(&a);
 735 }