git.meshlink.io Git - catta/blob - avahi-core/entry.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 <sys/socket.h>
  27 #include <arpa/inet.h>
  28 #include <string.h>
  29 #include <sys/utsname.h>
  30 #include <unistd.h>
  31 #include <errno.h>
  32 #include <stdio.h>
  33 #include <assert.h>
  34 #include <stdlib.h>
  35
  36 #include <avahi-common/domain.h>
  37 #include <avahi-common/timeval.h>
  38 #include <avahi-common/malloc.h>
  39 #include <avahi-common/error.h>
  40
  41 #include "server.h"
  42 #include "iface.h"
  43 #include "socket.h"
  44 #include "browse.h"
  45 #include "log.h"
  46 #include "util.h"
  47 #include "dns-srv-rr.h"
  48
  49 void avahi_entry_free(AvahiServer*s, AvahiEntry *e) {
  50     AvahiEntry *t;
  51
  52     assert(s);
  53     assert(e);
  54
  55     avahi_goodbye_entry(s, e, 1, 1);
  56
  57     /* Remove from linked list */
  58     AVAHI_LLIST_REMOVE(AvahiEntry, entries, s->entries, e);
  59
  60     /* Remove from hash table indexed by name */
  61     t = avahi_hashmap_lookup(s->entries_by_key, e->record->key);
  62     AVAHI_LLIST_REMOVE(AvahiEntry, by_key, t, e);
  63     if (t)
  64         avahi_hashmap_replace(s->entries_by_key, t->record->key, t);
  65     else
  66         avahi_hashmap_remove(s->entries_by_key, e->record->key);
  67
  68     /* Remove from associated group */
  69     if (e->group)
  70         AVAHI_LLIST_REMOVE(AvahiEntry, by_group, e->group->entries, e);
  71
  72     avahi_record_unref(e->record);
  73     avahi_free(e);
  74 }
  75
  76 void avahi_entry_group_free(AvahiServer *s, AvahiSEntryGroup *g) {
  77     assert(s);
  78     assert(g);
  79
  80     while (g->entries)
  81         avahi_entry_free(s, g->entries);
  82
  83     if (g->register_time_event)
  84         avahi_time_event_free(g->register_time_event);
  85
  86     AVAHI_LLIST_REMOVE(AvahiSEntryGroup, groups, s->groups, g);
  87     avahi_free(g);
  88 }
  89
  90 void avahi_cleanup_dead_entries(AvahiServer *s) {
  91     assert(s);
  92
  93     if (s->need_group_cleanup) {
  94         AvahiSEntryGroup *g, *next;
  95
  96         for (g = s->groups; g; g = next) {
  97             next = g->groups_next;
  98
  99             if (g->dead)
 100                 avahi_entry_group_free(s, g);
 101         }
 102
 103         s->need_group_cleanup = 0;
 104     }
 105
 106     if (s->need_entry_cleanup) {
 107         AvahiEntry *e, *next;
 108
 109         for (e = s->entries; e; e = next) {
 110             next = e->entries_next;
 111
 112             if (e->dead)
 113                 avahi_entry_free(s, e);
 114         }
 115
 116         s->need_entry_cleanup = 0;
 117     }
 118
 119     if (s->need_browser_cleanup)
 120         avahi_browser_cleanup(s);
 121 }
 122
 123 static int check_record_conflict(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *r, AvahiPublishFlags flags) {
 124     AvahiEntry *e;
 125
 126     assert(s);
 127     assert(r);
 128
 129     for (e = avahi_hashmap_lookup(s->entries_by_key, r->key); e; e = e->by_key_next) {
 130         if (e->dead)
 131             continue;
 132
 133         if (!(flags & AVAHI_PUBLISH_UNIQUE) && !(e->flags & AVAHI_PUBLISH_UNIQUE))
 134             continue;
 135
 136         if ((flags & AVAHI_PUBLISH_ALLOW_MULTIPLE) && (e->flags & AVAHI_PUBLISH_ALLOW_MULTIPLE) )
 137             continue;
 138
 139         if ((interface <= 0 ||
 140              e->interface <= 0 ||
 141              e->interface == interface) &&
 142             (protocol == AVAHI_PROTO_UNSPEC ||
 143              e->protocol == AVAHI_PROTO_UNSPEC ||
 144              e->protocol == protocol))
 145
 146             return -1;
 147     }
 148
 149     return 0;
 150 }
 151
 152 int avahi_server_add(
 153     AvahiServer *s,
 154     AvahiSEntryGroup *g,
 155     AvahiIfIndex interface,
 156     AvahiProtocol protocol,
 157     AvahiPublishFlags flags,
 158     AvahiRecord *r) {
 159
 160     assert(s);
 161     assert(r);
 162
 163     if (!AVAHI_IF_VALID(interface))
 164         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_INTERFACE);
 165
 166     if (!AVAHI_PROTO_VALID(protocol))
 167         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PROTOCOL);
 168
 169     if (!AVAHI_FLAGS_VALID(
 170             flags,
 171             AVAHI_PUBLISH_NO_ANNOUNCE|
 172             AVAHI_PUBLISH_NO_PROBE|
 173             AVAHI_PUBLISH_UNIQUE|
 174             AVAHI_PUBLISH_ALLOW_MULTIPLE|
 175             AVAHI_PUBLISH_IS_PROXY|
 176             AVAHI_PUBLISH_UPDATE))
 177         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_FLAGS);
 178
 179     if (!avahi_is_valid_domain_name(r->key->name))
 180         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME);
 181
 182     if (r->ttl == 0)
 183         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_TTL);
 184
 185     if (avahi_key_is_pattern(r->key))
 186         return avahi_server_set_errno(s, AVAHI_ERR_IS_PATTERN);
 187
 188     if (!avahi_record_is_valid(r))
 189         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_RECORD);
 190
 191     if (flags & AVAHI_PUBLISH_UPDATE) {
 192         AvahiEntry *e;
 193         AvahiRecord *old_record;
 194         int is_first = 1;
 195
 196         /* Update and existing record */
 197
 198         /* Find the first matching entry */
 199         for (e = avahi_hashmap_lookup(s->entries_by_key, r->key); e; e = e->by_key_next) {
 200             if (!e->dead && e->group == g && e->interface == interface && e->protocol == protocol)
 201                 break;
 202
 203             is_first = 0;
 204         }
 205
 206         /* Hmm, nothing found? */
 207         if (!e)
 208             return avahi_server_set_errno(s, AVAHI_ERR_NOT_FOUND);
 209
 210         /* Update the entry */
 211         old_record = e->record;
 212         e->record = avahi_record_ref(r);
 213         e->flags = flags;
 214
 215         /* Announce our changes when needed */
 216         if (!avahi_record_equal_no_ttl(old_record, r) && (!g || g->state != AVAHI_ENTRY_GROUP_UNCOMMITED)) {
 217
 218             /* Remove the old entry from all caches, if needed */
 219             if (!(e->flags & AVAHI_PUBLISH_UNIQUE))
 220                 avahi_goodbye_entry(s, e, 1, 0);
 221
 222             /* Reannounce our updated entry */
 223             avahi_reannounce_entry(s, e);
 224         }
 225
 226         /* If we were the first entry in the list, we need to update the key */
 227         if (is_first)
 228             avahi_hashmap_replace(s->entries_by_key, e->record->key, e);
 229
 230         avahi_record_unref(old_record);
 231
 232     } else {
 233         AvahiEntry *e, *t;
 234
 235         /* Add a new record */
 236
 237         if (check_record_conflict(s, interface, protocol, r, flags) < 0)
 238             return avahi_server_set_errno(s, AVAHI_ERR_LOCAL_COLLISION);
 239
 240         if (!(e = avahi_new(AvahiEntry, 1)))
 241             return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 242
 243         e->server = s;
 244         e->record = avahi_record_ref(r);
 245         e->group = g;
 246         e->interface = interface;
 247         e->protocol = protocol;
 248         e->flags = flags;
 249         e->dead = 0;
 250
 251         AVAHI_LLIST_HEAD_INIT(AvahiAnnouncer, e->announcers);
 252
 253         AVAHI_LLIST_PREPEND(AvahiEntry, entries, s->entries, e);
 254
 255         /* Insert into hash table indexed by name */
 256         t = avahi_hashmap_lookup(s->entries_by_key, e->record->key);
 257         AVAHI_LLIST_PREPEND(AvahiEntry, by_key, t, e);
 258         avahi_hashmap_replace(s->entries_by_key, e->record->key, t);
 259
 260         /* Insert into group list */
 261         if (g)
 262             AVAHI_LLIST_PREPEND(AvahiEntry, by_group, g->entries, e);
 263
 264         avahi_announce_entry(s, e);
 265     }
 266
 267     return AVAHI_OK;
 268 }
 269
 270 const AvahiRecord *avahi_server_iterate(AvahiServer *s, AvahiSEntryGroup *g, void **state) {
 271     AvahiEntry **e = (AvahiEntry**) state;
 272     assert(s);
 273     assert(e);
 274
 275     if (!*e)
 276         *e = g ? g->entries : s->entries;
 277
 278     while (*e && (*e)->dead)
 279         *e = g ? (*e)->by_group_next : (*e)->entries_next;
 280
 281     if (!*e)
 282         return NULL;
 283
 284     return avahi_record_ref((*e)->record);
 285 }
 286
 287 int avahi_server_dump(AvahiServer *s, AvahiDumpCallback callback, void* userdata) {
 288     AvahiEntry *e;
 289
 290     assert(s);
 291     assert(callback);
 292
 293     callback(";;; ZONE DUMP FOLLOWS ;;;", userdata);
 294
 295     for (e = s->entries; e; e = e->entries_next) {
 296         char *t;
 297         char ln[256];
 298
 299         if (e->dead)
 300             continue;
 301
 302         if (!(t = avahi_record_to_string(e->record)))
 303             return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 304
 305         snprintf(ln, sizeof(ln), "%s ; iface=%i proto=%i", t, e->interface, e->protocol);
 306         avahi_free(t);
 307
 308         callback(ln, userdata);
 309     }
 310
 311     avahi_dump_caches(s->monitor, callback, userdata);
 312
 313     if (s->wide_area_lookup_engine)
 314         avahi_wide_area_cache_dump(s->wide_area_lookup_engine, callback, userdata);
 315     return AVAHI_OK;
 316 }
 317
 318 int avahi_server_add_ptr(
 319     AvahiServer *s,
 320     AvahiSEntryGroup *g,
 321     AvahiIfIndex interface,
 322     AvahiProtocol protocol,
 323     AvahiPublishFlags flags,
 324     uint32_t ttl,
 325     const char *name,
 326     const char *dest) {
 327
 328     AvahiRecord *r;
 329     int ret;
 330
 331     assert(s);
 332     assert(dest);
 333
 334     if ((name && !avahi_is_valid_domain_name(name)) || !avahi_is_valid_domain_name(dest))
 335         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME);
 336
 337     if (!name)
 338         name = s->host_name_fqdn;
 339
 340     if (!(r = avahi_record_new_full(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_PTR, ttl)))
 341         return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 342
 343     r->data.ptr.name = avahi_normalize_name_strdup(dest);
 344     ret = avahi_server_add(s, g, interface, protocol, flags, r);
 345     avahi_record_unref(r);
 346     return ret;
 347 }
 348
 349 int avahi_server_add_address(
 350     AvahiServer *s,
 351     AvahiSEntryGroup *g,
 352     AvahiIfIndex interface,
 353     AvahiProtocol protocol,
 354     AvahiPublishFlags flags,
 355     const char *name,
 356     AvahiAddress *a) {
 357
 358     char *n = NULL;
 359     int ret = AVAHI_OK;
 360
 361     assert(s);
 362     assert(a);
 363
 364     if (!AVAHI_IF_VALID(interface))
 365         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_INTERFACE);
 366
 367     if (!AVAHI_PROTO_VALID(protocol) || !AVAHI_PROTO_VALID(a->proto))
 368         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PROTOCOL);
 369
 370     if (!AVAHI_FLAGS_VALID(flags, AVAHI_PUBLISH_NO_REVERSE|AVAHI_PUBLISH_NO_ANNOUNCE|AVAHI_PUBLISH_NO_PROBE|AVAHI_PUBLISH_UPDATE))
 371         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_FLAGS);
 372
 373     if (name && !avahi_is_valid_domain_name(name))
 374         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME);
 375
 376     if (!name)
 377         name = s->host_name_fqdn;
 378     else {
 379         if (!(n = avahi_normalize_name_strdup(name)))
 380             return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 381
 382         name = n;
 383     }
 384
 385     if (a->proto == AVAHI_PROTO_INET) {
 386         AvahiRecord  *r;
 387
 388         if (!(r = avahi_record_new_full(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A, AVAHI_DEFAULT_TTL_HOST_NAME))) {
 389             ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 390             goto fail;
 391         }
 392
 393         r->data.a.address = a->data.ipv4;
 394         ret = avahi_server_add(s, g, interface, protocol, (flags & ~ AVAHI_PUBLISH_NO_REVERSE) | AVAHI_PUBLISH_UNIQUE | AVAHI_PUBLISH_ALLOW_MULTIPLE, r);
 395         avahi_record_unref(r);
 396
 397         if (ret < 0)
 398             goto fail;
 399
 400         if (!(flags & AVAHI_PUBLISH_NO_REVERSE)) {
 401             char *reverse;
 402
 403             if (!(reverse = avahi_reverse_lookup_name_ipv4(&a->data.ipv4))) {
 404                 ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 405                 goto fail;
 406             }
 407
 408             ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_PUBLISH_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
 409             avahi_free(reverse);
 410         }
 411
 412     } else {
 413         AvahiRecord *r;
 414
 415         assert(a->proto == AVAHI_PROTO_INET6);
 416
 417         if (!(r = avahi_record_new_full(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA, AVAHI_DEFAULT_TTL_HOST_NAME))) {
 418             ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 419             goto fail;
 420         }
 421
 422         r->data.aaaa.address = a->data.ipv6;
 423         ret = avahi_server_add(s, g, interface, protocol, (flags & ~ AVAHI_PUBLISH_NO_REVERSE) | AVAHI_PUBLISH_UNIQUE | AVAHI_PUBLISH_ALLOW_MULTIPLE, r);
 424         avahi_record_unref(r);
 425
 426         if (ret < 0)
 427             goto fail;
 428
 429         if (!(flags & AVAHI_PUBLISH_NO_REVERSE)) {
 430             char *reverse;
 431
 432             if (!(reverse = avahi_reverse_lookup_name_ipv6_arpa(&a->data.ipv6))) {
 433                 ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 434                 goto fail;
 435             }
 436
 437             ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_PUBLISH_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
 438             avahi_free(reverse);
 439
 440             if (ret < 0)
 441                 goto fail;
 442
 443             if (!(reverse = avahi_reverse_lookup_name_ipv6_int(&a->data.ipv6))) {
 444                 ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 445                 goto fail;
 446             }
 447
 448             ret = avahi_server_add_ptr(s, g, interface, protocol, flags | AVAHI_PUBLISH_UNIQUE, AVAHI_DEFAULT_TTL_HOST_NAME, reverse, name);
 449             avahi_free(reverse);
 450         }
 451     }
 452
 453 fail:
 454
 455     avahi_free(n);
 456
 457     return ret;
 458 }
 459
 460 static int server_add_txt_strlst_nocopy(
 461     AvahiServer *s,
 462     AvahiSEntryGroup *g,
 463     AvahiIfIndex interface,
 464     AvahiProtocol protocol,
 465     AvahiPublishFlags flags,
 466     uint32_t ttl,
 467     const char *name,
 468     AvahiStringList *strlst) {
 469
 470     AvahiRecord *r;
 471     int ret;
 472
 473     assert(s);
 474
 475     if (!(r = avahi_record_new_full(name ? name : s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_TXT, ttl))) {
 476         avahi_string_list_free(strlst);
 477         return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 478     }
 479
 480     r->data.txt.string_list = strlst;
 481     ret = avahi_server_add(s, g, interface, protocol, flags, r);
 482     avahi_record_unref(r);
 483
 484     return ret;
 485 }
 486
 487 static AvahiStringList *add_magic_cookie(
 488     AvahiServer *s,
 489     AvahiStringList *strlst) {
 490
 491     assert(s);
 492
 493     if (!s->config.add_service_cookie)
 494         return strlst;
 495
 496     if (avahi_string_list_find(strlst, AVAHI_SERVICE_COOKIE))
 497         /* This string list already contains a magic cookie */
 498         return strlst;
 499
 500     return avahi_string_list_add_printf(strlst, AVAHI_SERVICE_COOKIE"=%u", s->local_service_cookie);
 501 }
 502
 503 static int server_add_service_strlst_nocopy(
 504     AvahiServer *s,
 505     AvahiSEntryGroup *g,
 506     AvahiIfIndex interface,
 507     AvahiProtocol protocol,
 508     AvahiPublishFlags flags,
 509     const char *name,
 510     const char *type,
 511     const char *domain,
 512     const char *host,
 513     uint16_t port,
 514     AvahiStringList *strlst) {
 515
 516     char ptr_name[AVAHI_DOMAIN_NAME_MAX], svc_name[AVAHI_DOMAIN_NAME_MAX], enum_ptr[AVAHI_DOMAIN_NAME_MAX], *h = NULL;
 517     AvahiRecord *r = NULL;
 518     int ret = AVAHI_OK;
 519
 520     assert(s);
 521     assert(type);
 522     assert(name);
 523
 524     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
 525     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
 526     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_FLAGS_VALID(flags, AVAHI_PUBLISH_NO_COOKIE|AVAHI_PUBLISH_IS_PROXY|AVAHI_PUBLISH_UPDATE), AVAHI_ERR_INVALID_FLAGS);
 527     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, avahi_is_valid_service_name(name), AVAHI_ERR_INVALID_SERVICE_NAME);
 528     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, avahi_is_valid_service_type_strict(type), AVAHI_ERR_INVALID_SERVICE_TYPE);
 529     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, !domain || avahi_is_valid_domain_name(domain), AVAHI_ERR_INVALID_DOMAIN_NAME);
 530     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, !host || avahi_is_valid_domain_name(host), AVAHI_ERR_INVALID_HOST_NAME);
 531
 532     if (!domain)
 533         domain = s->domain_name;
 534
 535     if (!host)
 536         host = s->host_name_fqdn;
 537
 538     if (!(h = avahi_normalize_name_strdup(host))) {
 539         ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 540         goto fail;
 541     }
 542
 543     if ((ret = avahi_service_name_join(svc_name, sizeof(svc_name), name, type, domain)) < 0 ||
 544         (ret = avahi_service_name_join(ptr_name, sizeof(ptr_name), NULL, type, domain)) < 0 ||
 545         (ret = avahi_service_name_join(enum_ptr, sizeof(enum_ptr), NULL, "_services._dns-sd._udp", domain)) < 0) {
 546         avahi_server_set_errno(s, ret);
 547         goto fail;
 548     }
 549
 550     /* Add service enumeration PTR record */
 551
 552     if ((ret = avahi_server_add_ptr(s, g, interface, protocol, flags & AVAHI_PUBLISH_IS_PROXY, AVAHI_DEFAULT_TTL, ptr_name, svc_name)) < 0)
 553         goto fail;
 554
 555     /* Add SRV record */
 556
 557     if (!(r = avahi_record_new_full(svc_name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV, AVAHI_DEFAULT_TTL_HOST_NAME))) {
 558         ret = avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 559         goto fail;
 560     }
 561
 562     r->data.srv.priority = 0;
 563     r->data.srv.weight = 0;
 564     r->data.srv.port = port;
 565     r->data.srv.name = h;
 566     h = NULL;
 567     ret = avahi_server_add(s, g, interface, protocol, (flags & AVAHI_PUBLISH_IS_PROXY) | AVAHI_PUBLISH_UNIQUE, r);
 568     avahi_record_unref(r);
 569
 570     if (ret < 0)
 571         goto fail;
 572
 573     /* Add TXT record */
 574
 575     if (!(flags & AVAHI_PUBLISH_NO_COOKIE))
 576         strlst = add_magic_cookie(s, strlst);
 577
 578     ret = server_add_txt_strlst_nocopy(s, g, interface, protocol, (flags & AVAHI_PUBLISH_IS_PROXY) | AVAHI_PUBLISH_UNIQUE, AVAHI_DEFAULT_TTL, svc_name, strlst);
 579     strlst = NULL;
 580
 581     if (ret < 0)
 582         goto fail;
 583
 584     /* Add service type enumeration record */
 585
 586     ret = avahi_server_add_ptr(s, g, interface, protocol, (flags & AVAHI_PUBLISH_IS_PROXY), AVAHI_DEFAULT_TTL, enum_ptr, ptr_name);
 587
 588 fail:
 589
 590     avahi_string_list_free(strlst);
 591     avahi_free(h);
 592
 593     return ret;
 594 }
 595
 596 int avahi_server_add_service_strlst(
 597     AvahiServer *s,
 598     AvahiSEntryGroup *g,
 599     AvahiIfIndex interface,
 600     AvahiProtocol protocol,
 601     AvahiPublishFlags flags,
 602     const char *name,
 603     const char *type,
 604     const char *domain,
 605     const char *host,
 606     uint16_t port,
 607     AvahiStringList *strlst) {
 608
 609     assert(s);
 610     assert(type);
 611     assert(name);
 612
 613     return server_add_service_strlst_nocopy(s, g, interface, protocol, flags, name, type, domain, host, port, avahi_string_list_copy(strlst));
 614 }
 615
 616 int avahi_server_add_service_va(
 617     AvahiServer *s,
 618     AvahiSEntryGroup *g,
 619     AvahiIfIndex interface,
 620     AvahiProtocol protocol,
 621     AvahiPublishFlags flags,
 622     const char *name,
 623     const char *type,
 624     const char *domain,
 625     const char *host,
 626     uint16_t port,
 627     va_list va) {
 628
 629     assert(s);
 630     assert(type);
 631     assert(name);
 632
 633     return server_add_service_strlst_nocopy(s, g, interface, protocol, flags, name, type, domain, host, port, avahi_string_list_new_va(va));
 634 }
 635
 636 int avahi_server_add_service(
 637     AvahiServer *s,
 638     AvahiSEntryGroup *g,
 639     AvahiIfIndex interface,
 640     AvahiProtocol protocol,
 641     AvahiPublishFlags flags,
 642     const char *name,
 643     const char *type,
 644     const char *domain,
 645     const char *host,
 646     uint16_t port,
 647     ... ){
 648
 649     va_list va;
 650     int ret;
 651
 652     va_start(va, port);
 653     ret = avahi_server_add_service_va(s, g, interface, protocol, flags, name, type, domain, host, port, va);
 654     va_end(va);
 655
 656     return ret;
 657 }
 658
 659 static int server_update_service_txt_strlst_nocopy(
 660     AvahiServer *s,
 661     AvahiSEntryGroup *g,
 662     AvahiIfIndex interface,
 663     AvahiProtocol protocol,
 664     AvahiPublishFlags flags,
 665     const char *name,
 666     const char *type,
 667     const char *domain,
 668     AvahiStringList *strlst) {
 669
 670     char svc_name[AVAHI_DOMAIN_NAME_MAX];
 671     int ret = AVAHI_OK;
 672
 673     assert(s);
 674     assert(type);
 675     assert(name);
 676
 677     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
 678     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
 679     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_FLAGS_VALID(flags, AVAHI_PUBLISH_IS_PROXY|AVAHI_PUBLISH_NO_COOKIE), AVAHI_ERR_INVALID_FLAGS);
 680     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, avahi_is_valid_service_name(name), AVAHI_ERR_INVALID_SERVICE_NAME);
 681     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, avahi_is_valid_service_type_strict(type), AVAHI_ERR_INVALID_SERVICE_TYPE);
 682     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, !domain || avahi_is_valid_domain_name(domain), AVAHI_ERR_INVALID_DOMAIN_NAME);
 683
 684     if (!domain)
 685         domain = s->domain_name;
 686
 687     if ((ret = avahi_service_name_join(svc_name, sizeof(svc_name), name, type, domain)) < 0) {
 688         avahi_server_set_errno(s, ret);
 689         goto fail;
 690     }
 691
 692     /* Add TXT record */
 693     if (!(flags & AVAHI_PUBLISH_NO_COOKIE))
 694         strlst = add_magic_cookie(s, strlst);
 695
 696     ret = server_add_txt_strlst_nocopy(s, g, interface, protocol, (flags & AVAHI_PUBLISH_IS_PROXY) | AVAHI_PUBLISH_UNIQUE | AVAHI_PUBLISH_UPDATE, AVAHI_DEFAULT_TTL, svc_name, strlst);
 697     strlst = NULL;
 698
 699 fail:
 700
 701     avahi_string_list_free(strlst);
 702
 703     return ret;
 704 }
 705
 706 int avahi_server_update_service_txt_strlst(
 707     AvahiServer *s,
 708     AvahiSEntryGroup *g,
 709     AvahiIfIndex interface,
 710     AvahiProtocol protocol,
 711     AvahiPublishFlags flags,
 712     const char *name,
 713     const char *type,
 714     const char *domain,
 715     AvahiStringList *strlst) {
 716
 717     return server_update_service_txt_strlst_nocopy(s, g, interface, protocol, flags, name, type, domain, avahi_string_list_copy(strlst));
 718 }
 719
 720 /** Update the TXT record for a service with the NULL terminated list of strings of the va_list. */
 721 int avahi_server_update_service_txt_va(
 722     AvahiServer *s,
 723     AvahiSEntryGroup *g,
 724     AvahiIfIndex interface,
 725     AvahiProtocol protocol,
 726     AvahiPublishFlags flags,
 727     const char *name,
 728     const char *type,
 729     const char *domain,
 730     va_list va) {
 731
 732     return server_update_service_txt_strlst_nocopy(s, g, interface, protocol, flags, name, type, domain, avahi_string_list_new_va(va));
 733 }
 734
 735 /** Update the TXT record for a service with the NULL termonate list of strings */
 736 int avahi_server_update_service_txt(
 737     AvahiServer *s,
 738     AvahiSEntryGroup *g,
 739     AvahiIfIndex interface,
 740     AvahiProtocol protocol,
 741     AvahiPublishFlags flags,
 742     const char *name,
 743     const char *type,
 744     const char *domain,
 745     ...) {
 746
 747     va_list va;
 748     int ret;
 749
 750     va_start(va, domain);
 751     ret = avahi_server_update_service_txt_va(s, g, interface, protocol, flags, name, type, domain, va);
 752     va_end(va);
 753
 754     return ret;
 755 }
 756
 757 int avahi_server_add_service_subtype(
 758     AvahiServer *s,
 759     AvahiSEntryGroup *g,
 760     AvahiIfIndex interface,
 761     AvahiProtocol protocol,
 762     AvahiPublishFlags flags,
 763     const char *name,
 764     const char *type,
 765     const char *domain,
 766     const char *subtype) {
 767
 768     int ret = AVAHI_OK;
 769     char svc_name[AVAHI_DOMAIN_NAME_MAX], ptr_name[AVAHI_DOMAIN_NAME_MAX];
 770
 771     assert(name);
 772     assert(type);
 773     assert(subtype);
 774
 775     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
 776     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_PROTO_VALID(protocol), AVAHI_ERR_INVALID_PROTOCOL);
 777     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, AVAHI_FLAGS_VALID(flags, 0), AVAHI_ERR_INVALID_FLAGS);
 778     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, avahi_is_valid_service_name(name), AVAHI_ERR_INVALID_SERVICE_NAME);
 779     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, avahi_is_valid_service_type_strict(type), AVAHI_ERR_INVALID_SERVICE_TYPE);
 780     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, !domain || avahi_is_valid_domain_name(domain), AVAHI_ERR_INVALID_DOMAIN_NAME);
 781     AVAHI_CHECK_VALIDITY_SET_RET_GOTO_FAIL(s, avahi_is_valid_service_subtype(subtype), AVAHI_ERR_INVALID_SERVICE_SUBTYPE);
 782
 783     if (!domain)
 784         domain = s->domain_name;
 785
 786     if ((ret = avahi_service_name_join(svc_name, sizeof(svc_name), name, type, domain)) < 0 ||
 787         (ret = avahi_service_name_join(ptr_name, sizeof(ptr_name), NULL, subtype, domain)) < 0) {
 788         avahi_server_set_errno(s, ret);
 789         goto fail;
 790     }
 791
 792     if ((ret = avahi_server_add_ptr(s, g, interface, protocol, flags & AVAHI_PUBLISH_IS_PROXY, AVAHI_DEFAULT_TTL, ptr_name, svc_name)) < 0)
 793         goto fail;
 794
 795 fail:
 796
 797     return ret;
 798 }
 799
 800 static void hexstring(char *s, size_t sl, const void *p, size_t pl) {
 801     static const char hex[] = "0123456789abcdef";
 802     int b = 0;
 803     const uint8_t *k = p;
 804
 805     while (sl > 1 && pl > 0) {
 806         *(s++) = hex[(b ? *k : *k >> 4) & 0xF];
 807
 808         if (b) {
 809             k++;
 810             pl--;
 811         }
 812
 813         b = !b;
 814
 815         sl--;
 816     }
 817
 818     if (sl > 0)
 819         *s = 0;
 820 }
 821
 822 int avahi_server_add_dns_server_address(
 823     AvahiServer *s,
 824     AvahiSEntryGroup *g,
 825     AvahiIfIndex interface,
 826     AvahiProtocol protocol,
 827     AvahiPublishFlags flags,
 828     const char *domain,
 829     AvahiDNSServerType type,
 830     const AvahiAddress *address,
 831     uint16_t port /** should be 53 */) {
 832
 833     AvahiRecord *r;
 834     int ret;
 835     char n[64], h[64];
 836
 837     assert(s);
 838     assert(address);
 839
 840     if (!AVAHI_IF_VALID(interface))
 841         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_INTERFACE);
 842
 843     if (!AVAHI_PROTO_VALID(protocol) || !AVAHI_PROTO_VALID(address->proto))
 844         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PROTOCOL);
 845
 846     if (!AVAHI_FLAGS_VALID(flags, 0) || (type != AVAHI_DNS_SERVER_UPDATE && type != AVAHI_DNS_SERVER_RESOLVE))
 847         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_FLAGS);
 848
 849     if (port == 0)
 850         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PORT);
 851
 852     if (domain && !avahi_is_valid_domain_name(domain))
 853         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME);
 854
 855     if (!domain)
 856         domain = s->domain_name;
 857
 858     if (address->proto == AVAHI_PROTO_INET) {
 859         hexstring(h, sizeof(h), &address->data, sizeof(AvahiIPv4Address));
 860         snprintf(n, sizeof(n), "ip-%s.%s", h, domain);
 861         r = avahi_record_new_full(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A, AVAHI_DEFAULT_TTL_HOST_NAME);
 862         r->data.a.address = address->data.ipv4;
 863     } else {
 864         hexstring(h, sizeof(h), &address->data, sizeof(AvahiIPv6Address));
 865         snprintf(n, sizeof(n), "ip6-%s.%s", h, domain);
 866         r = avahi_record_new_full(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA, AVAHI_DEFAULT_TTL_HOST_NAME);
 867         r->data.aaaa.address = address->data.ipv6;
 868     }
 869
 870     if (!r)
 871         return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 872
 873     ret = avahi_server_add(s, g, interface, protocol, AVAHI_PUBLISH_UNIQUE | AVAHI_PUBLISH_ALLOW_MULTIPLE, r);
 874     avahi_record_unref(r);
 875
 876     if (ret < 0)
 877         return ret;
 878
 879     return avahi_server_add_dns_server_name(s, g, interface, protocol, flags, domain, type, n, port);
 880 }
 881
 882 int avahi_server_add_dns_server_name(
 883     AvahiServer *s,
 884     AvahiSEntryGroup *g,
 885     AvahiIfIndex interface,
 886     AvahiProtocol protocol,
 887     AvahiPublishFlags flags,
 888     const char *domain,
 889     AvahiDNSServerType type,
 890     const char *name,
 891     uint16_t port /** should be 53 */) {
 892
 893     int ret = -1;
 894     char t[256], *d = NULL, *n = NULL;
 895     AvahiRecord *r;
 896
 897     assert(s);
 898     assert(name);
 899
 900     if (!AVAHI_IF_VALID(interface))
 901         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_INTERFACE);
 902
 903     if (!AVAHI_PROTO_VALID(protocol))
 904         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PROTOCOL);
 905
 906     if (!AVAHI_FLAGS_VALID(flags, 0) || (type != AVAHI_DNS_SERVER_UPDATE && type != AVAHI_DNS_SERVER_RESOLVE))
 907         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_FLAGS);
 908
 909     if (port == 0)
 910         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PORT);
 911
 912     if (!avahi_is_valid_domain_name(name))
 913         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME);
 914
 915     if (domain && !avahi_is_valid_domain_name(domain))
 916         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME);
 917
 918     if (!domain)
 919         domain = s->domain_name;
 920
 921     if (!(n = avahi_normalize_name_strdup(name)) ||
 922         !(d = avahi_normalize_name_strdup(domain))) {
 923         avahi_free(n);
 924         avahi_free(d);
 925         return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 926     }
 927
 928     snprintf(t, sizeof(t), "%s.%s", type == AVAHI_DNS_SERVER_RESOLVE ? "_domain._udp" : "_dns-update._udp", d);
 929     avahi_free(d);
 930
 931     if (!(r = avahi_record_new_full(t, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV, AVAHI_DEFAULT_TTL_HOST_NAME))) {
 932         avahi_free(n);
 933         return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 934     }
 935
 936     r->data.srv.priority = 0;
 937     r->data.srv.weight = 0;
 938     r->data.srv.port = port;
 939     r->data.srv.name = n;
 940     ret = avahi_server_add(s, g, interface, protocol, AVAHI_PUBLISH_NULL, r);
 941     avahi_record_unref(r);
 942
 943     return ret;
 944 }
 945
 946 void avahi_s_entry_group_change_state(AvahiSEntryGroup *g, AvahiEntryGroupState state) {
 947     assert(g);
 948
 949     if (g->state == state)
 950         return;
 951
 952     assert(state <= AVAHI_ENTRY_GROUP_COLLISION);
 953
 954     if (g->state == AVAHI_ENTRY_GROUP_ESTABLISHED) {
 955
 956         /* If the entry group was established for a time longer then
 957          * 5s, reset the establishment trial counter */
 958
 959         if (avahi_age(&g->established_at) > 5000000)
 960             g->n_register_try = 0;
 961     }
 962
 963     if (state == AVAHI_ENTRY_GROUP_ESTABLISHED)
 964
 965         /* If the entry group is now established, remember the time
 966          * this happened */
 967
 968         gettimeofday(&g->established_at, NULL);
 969
 970     g->state = state;
 971
 972     if (g->callback)
 973         g->callback(g->server, g, state, g->userdata);
 974 }
 975
 976 AvahiSEntryGroup *avahi_s_entry_group_new(AvahiServer *s, AvahiSEntryGroupCallback callback, void* userdata) {
 977     AvahiSEntryGroup *g;
 978
 979     assert(s);
 980
 981     if (!(g = avahi_new(AvahiSEntryGroup, 1))) {
 982         avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
 983         return NULL;
 984     }
 985
 986     g->server = s;
 987     g->callback = callback;
 988     g->userdata = userdata;
 989     g->dead = 0;
 990     g->state = AVAHI_ENTRY_GROUP_UNCOMMITED;
 991     g->n_probing = 0;
 992     g->n_register_try = 0;
 993     g->register_time_event = NULL;
 994     g->register_time.tv_sec = 0;
 995     g->register_time.tv_usec = 0;
 996     AVAHI_LLIST_HEAD_INIT(AvahiEntry, g->entries);
 997
 998     AVAHI_LLIST_PREPEND(AvahiSEntryGroup, groups, s->groups, g);
 999     return g;
1000 }
1001
1002 void avahi_s_entry_group_free(AvahiSEntryGroup *g) {
1003     AvahiEntry *e;
1004
1005     assert(g);
1006     assert(g->server);
1007
1008     for (e = g->entries; e; e = e->by_group_next) {
1009         if (!e->dead) {
1010             avahi_goodbye_entry(g->server, e, 1, 1);
1011             e->dead = 1;
1012         }
1013     }
1014
1015     if (g->register_time_event) {
1016         avahi_time_event_free(g->register_time_event);
1017         g->register_time_event = NULL;
1018     }
1019
1020     g->dead = 1;
1021
1022     g->server->need_group_cleanup = 1;
1023     g->server->need_entry_cleanup = 1;
1024 }
1025
1026 static void entry_group_commit_real(AvahiSEntryGroup *g) {
1027     assert(g);
1028
1029     gettimeofday(&g->register_time, NULL);
1030
1031     avahi_s_entry_group_change_state(g, AVAHI_ENTRY_GROUP_REGISTERING);
1032
1033     if (!g->dead) {
1034         avahi_announce_group(g->server, g);
1035         avahi_s_entry_group_check_probed(g, 0);
1036     }
1037 }
1038
1039 static void entry_group_register_time_event_callback(AvahiTimeEvent *e, void* userdata) {
1040     AvahiSEntryGroup *g = userdata;
1041     assert(g);
1042
1043 /*     avahi_log_debug("Holdoff passed, waking up and going on."); */
1044
1045     avahi_time_event_free(g->register_time_event);
1046     g->register_time_event = NULL;
1047
1048     /* Holdoff time passed, so let's start probing */
1049     entry_group_commit_real(g);
1050 }
1051
1052 int avahi_s_entry_group_commit(AvahiSEntryGroup *g) {
1053     struct timeval now;
1054
1055     assert(g);
1056     assert(!g->dead);
1057
1058     if (g->state != AVAHI_ENTRY_GROUP_UNCOMMITED && g->state != AVAHI_ENTRY_GROUP_COLLISION)
1059         return avahi_server_set_errno(g->server, AVAHI_ERR_BAD_STATE);
1060
1061     g->n_register_try++;
1062
1063     avahi_timeval_add(&g->register_time,
1064                       1000*(g->n_register_try >= AVAHI_RR_RATE_LIMIT_COUNT ?
1065                             AVAHI_RR_HOLDOFF_MSEC_RATE_LIMIT :
1066                             AVAHI_RR_HOLDOFF_MSEC));
1067
1068     gettimeofday(&now, NULL);
1069
1070     if (avahi_timeval_compare(&g->register_time, &now) <= 0) {
1071         /* Holdoff time passed, so let's start probing */
1072 /*         avahi_log_debug("Holdoff passed, directly going on.");  */
1073
1074         entry_group_commit_real(g);
1075     } else {
1076 /*          avahi_log_debug("Holdoff not passed, sleeping.");  */
1077
1078          /* Holdoff time has not yet passed, so let's wait */
1079         assert(!g->register_time_event);
1080         g->register_time_event = avahi_time_event_new(g->server->time_event_queue, &g->register_time, entry_group_register_time_event_callback, g);
1081
1082         avahi_s_entry_group_change_state(g, AVAHI_ENTRY_GROUP_REGISTERING);
1083     }
1084
1085     return AVAHI_OK;
1086 }
1087
1088 void avahi_s_entry_group_reset(AvahiSEntryGroup *g) {
1089     AvahiEntry *e;
1090     assert(g);
1091
1092     for (e = g->entries; e; e = e->by_group_next) {
1093         if (!e->dead) {
1094             avahi_goodbye_entry(g->server, e, 1, 1);
1095             e->dead = 1;
1096         }
1097     }
1098     g->server->need_entry_cleanup = 1;
1099
1100     if (g->register_time_event) {
1101         avahi_time_event_free(g->register_time_event);
1102         g->register_time_event = NULL;
1103     }
1104
1105     g->n_probing = 0;
1106
1107     gettimeofday(&g->register_time, NULL);
1108
1109     avahi_s_entry_group_change_state(g, AVAHI_ENTRY_GROUP_UNCOMMITED);
1110 }
1111
1112 int avahi_entry_is_commited(AvahiEntry *e) {
1113     assert(e);
1114     assert(!e->dead);
1115
1116     return !e->group ||
1117         e->group->state == AVAHI_ENTRY_GROUP_REGISTERING ||
1118         e->group->state == AVAHI_ENTRY_GROUP_ESTABLISHED;
1119 }
1120
1121 AvahiEntryGroupState avahi_s_entry_group_get_state(AvahiSEntryGroup *g) {
1122     assert(g);
1123     assert(!g->dead);
1124
1125     return g->state;
1126 }
1127
1128 void avahi_s_entry_group_set_data(AvahiSEntryGroup *g, void* userdata) {
1129     assert(g);
1130
1131     g->userdata = userdata;
1132 }
1133
1134 void* avahi_s_entry_group_get_data(AvahiSEntryGroup *g) {
1135     assert(g);
1136
1137     return g->userdata;
1138 }
1139
1140 int avahi_s_entry_group_is_empty(AvahiSEntryGroup *g) {
1141     AvahiEntry *e;
1142     assert(g);
1143
1144     /* Look for an entry that is not dead */
1145     for (e = g->entries; e; e = e->by_group_next)
1146         if (!e->dead)
1147             return 0;
1148
1149     return 1;
1150 }