git.meshlink.io Git - catta/blob - avahi-core/server.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/types.h>
  27 #include <sys/socket.h>
  28 #include <arpa/inet.h>
  29 #include <string.h>
  30 #include <sys/utsname.h>
  31 #include <unistd.h>
  32 #include <errno.h>
  33 #include <stdio.h>
  34 #include <assert.h>
  35 #include <stdlib.h>
  36
  37 #include <avahi-common/domain.h>
  38 #include <avahi-common/timeval.h>
  39 #include <avahi-common/malloc.h>
  40 #include <avahi-common/error.h>
  41
  42 #include "internal.h"
  43 #include "iface.h"
  44 #include "socket.h"
  45 #include "browse.h"
  46 #include "log.h"
  47 #include "util.h"
  48 #include "dns-srv-rr.h"
  49 #include "addr-util.h"
  50 #include "domain-util.h"
  51 #include "rr-util.h"
  52
  53 static void enum_aux_records(AvahiServer *s, AvahiInterface *i, const char *name, uint16_t type, void (*callback)(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata), void* userdata) {
  54     assert(s);
  55     assert(i);
  56     assert(name);
  57     assert(callback);
  58
  59     if (type == AVAHI_DNS_TYPE_ANY) {
  60         AvahiEntry *e;
  61
  62         for (e = s->entries; e; e = e->entries_next)
  63             if (!e->dead &&
  64                 avahi_entry_is_registered(s, e, i) &&
  65                 e->record->key->clazz == AVAHI_DNS_CLASS_IN &&
  66                 avahi_domain_equal(name, e->record->key->name))
  67                 callback(s, e->record, e->flags & AVAHI_PUBLISH_UNIQUE, userdata);
  68
  69     } else {
  70         AvahiEntry *e;
  71         AvahiKey *k;
  72
  73         if (!(k = avahi_key_new(name, AVAHI_DNS_CLASS_IN, type)))
  74             return; /** OOM */
  75
  76         for (e = avahi_hashmap_lookup(s->entries_by_key, k); e; e = e->by_key_next)
  77             if (!e->dead && avahi_entry_is_registered(s, e, i))
  78                 callback(s, e->record, e->flags & AVAHI_PUBLISH_UNIQUE, userdata);
  79
  80         avahi_key_unref(k);
  81     }
  82 }
  83
  84 void avahi_server_enumerate_aux_records(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, void (*callback)(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata), void* userdata) {
  85     assert(s);
  86     assert(i);
  87     assert(r);
  88     assert(callback);
  89
  90     /* Call the specified callback far all records referenced by the one specified in *r */
  91
  92     if (r->key->clazz == AVAHI_DNS_CLASS_IN) {
  93         if (r->key->type == AVAHI_DNS_TYPE_PTR) {
  94             enum_aux_records(s, i, r->data.ptr.name, AVAHI_DNS_TYPE_SRV, callback, userdata);
  95             enum_aux_records(s, i, r->data.ptr.name, AVAHI_DNS_TYPE_TXT, callback, userdata);
  96         } else if (r->key->type == AVAHI_DNS_TYPE_SRV) {
  97             enum_aux_records(s, i, r->data.srv.name, AVAHI_DNS_TYPE_A, callback, userdata);
  98             enum_aux_records(s, i, r->data.srv.name, AVAHI_DNS_TYPE_AAAA, callback, userdata);
  99         } else if (r->key->type == AVAHI_DNS_TYPE_CNAME)
 100             enum_aux_records(s, i, r->data.cname.name, AVAHI_DNS_TYPE_ANY, callback, userdata);
 101     }
 102 }
 103
 104 void avahi_server_prepare_response(AvahiServer *s, AvahiInterface *i, AvahiEntry *e, int unicast_response, int auxiliary) {
 105     assert(s);
 106     assert(i);
 107     assert(e);
 108
 109     avahi_record_list_push(s->record_list, e->record, e->flags & AVAHI_PUBLISH_UNIQUE, unicast_response, auxiliary);
 110 }
 111
 112 void avahi_server_prepare_matching_responses(AvahiServer *s, AvahiInterface *i, AvahiKey *k, int unicast_response) {
 113     assert(s);
 114     assert(i);
 115     assert(k);
 116
 117     /* Push all records that match the specified key to the record list */
 118
 119     if (avahi_key_is_pattern(k)) {
 120         AvahiEntry *e;
 121
 122         /* Handle ANY query */
 123
 124         for (e = s->entries; e; e = e->entries_next)
 125             if (!e->dead && avahi_key_pattern_match(k, e->record->key) && avahi_entry_is_registered(s, e, i))
 126                 avahi_server_prepare_response(s, i, e, unicast_response, 0);
 127
 128     } else {
 129         AvahiEntry *e;
 130
 131         /* Handle all other queries */
 132
 133         for (e = avahi_hashmap_lookup(s->entries_by_key, k); e; e = e->by_key_next)
 134             if (!e->dead && avahi_entry_is_registered(s, e, i))
 135                 avahi_server_prepare_response(s, i, e, unicast_response, 0);
 136     }
 137
 138     /* Look for CNAME records */
 139
 140     if ((k->clazz == AVAHI_DNS_CLASS_IN || k->clazz == AVAHI_DNS_CLASS_ANY)
 141         && k->type != AVAHI_DNS_TYPE_CNAME && k->type != AVAHI_DNS_TYPE_ANY) {
 142
 143         AvahiKey *cname_key;
 144
 145         if (!(cname_key = avahi_key_new(k->name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_CNAME)))
 146             return;
 147
 148         avahi_server_prepare_matching_responses(s, i, cname_key, unicast_response);
 149         avahi_key_unref(cname_key);
 150     }
 151 }
 152
 153 static void withdraw_entry(AvahiServer *s, AvahiEntry *e) {
 154     assert(s);
 155     assert(e);
 156
 157     /* Withdraw the specified entry, and if is part of an entry group,
 158      * put that into COLLISION state */
 159
 160     if (e->dead)
 161         return;
 162
 163     if (e->group) {
 164         AvahiEntry *k;
 165
 166         for (k = e->group->entries; k; k = k->by_group_next)
 167             if (!k->dead) {
 168                 avahi_goodbye_entry(s, k, 0, 1);
 169                 k->dead = 1;
 170             }
 171
 172         e->group->n_probing = 0;
 173
 174         avahi_s_entry_group_change_state(e->group, AVAHI_ENTRY_GROUP_COLLISION);
 175     } else {
 176         avahi_goodbye_entry(s, e, 0, 1);
 177         e->dead = 1;
 178     }
 179
 180     s->need_entry_cleanup = 1;
 181 }
 182
 183 static void withdraw_rrset(AvahiServer *s, AvahiKey *key) {
 184     AvahiEntry *e;
 185
 186     assert(s);
 187     assert(key);
 188
 189     /* Withdraw an entry RRSset */
 190
 191     for (e = avahi_hashmap_lookup(s->entries_by_key, key); e; e = e->by_key_next)
 192         withdraw_entry(s, e);
 193 }
 194
 195 static void incoming_probe(AvahiServer *s, AvahiRecord *record, AvahiInterface *i) {
 196     AvahiEntry *e, *n;
 197     int ours = 0, won = 0, lost = 0;
 198
 199     assert(s);
 200     assert(record);
 201     assert(i);
 202
 203     /* Handle incoming probes and check if they conflict our own probes */
 204
 205     for (e = avahi_hashmap_lookup(s->entries_by_key, record->key); e; e = n) {
 206         int cmp;
 207         n = e->by_key_next;
 208
 209         if (e->dead)
 210             continue;
 211
 212         if ((cmp = avahi_record_lexicographical_compare(e->record, record)) == 0) {
 213             ours = 1;
 214             break;
 215         } else {
 216
 217             if (avahi_entry_is_probing(s, e, i)) {
 218                 if (cmp > 0)
 219                     won = 1;
 220                 else /* cmp < 0 */
 221                     lost = 1;
 222             }
 223         }
 224     }
 225
 226     if (!ours) {
 227         char *t = avahi_record_to_string(record);
 228
 229         if (won)
 230             avahi_log_debug("Recieved conflicting probe [%s]. Local host won.", t);
 231         else if (lost) {
 232             avahi_log_debug("Recieved conflicting probe [%s]. Local host lost. Withdrawing.", t);
 233             withdraw_rrset(s, record->key);
 234         }
 235
 236         avahi_free(t);
 237     }
 238 }
 239
 240 static int handle_conflict(AvahiServer *s, AvahiInterface *i, AvahiRecord *record, int unique) {
 241     int valid = 1, ours = 0, conflict = 0, withdraw_immediately = 0;
 242     AvahiEntry *e, *n, *conflicting_entry = NULL;
 243
 244     assert(s);
 245     assert(i);
 246     assert(record);
 247
 248     /* Check whether an incoming record conflicts with one of our own */
 249
 250     for (e = avahi_hashmap_lookup(s->entries_by_key, record->key); e; e = n) {
 251         n = e->by_key_next;
 252
 253         if (e->dead)
 254             continue;
 255
 256         /* Check if the incoming is a goodbye record */
 257         if (avahi_record_is_goodbye(record)) {
 258
 259             if (avahi_record_equal_no_ttl(e->record, record)) {
 260                 char *t;
 261
 262                 /* Refresh */
 263                 t = avahi_record_to_string(record);
 264                 avahi_log_debug("Recieved goodbye record for one of our records [%s]. Refreshing.", t);
 265                 avahi_server_prepare_matching_responses(s, i, e->record->key, 0);
 266
 267                 valid = 0;
 268                 avahi_free(t);
 269                 break;
 270             }
 271
 272             /* If the goodybe packet doesn't match one of our own RRs, we simply ignore it. */
 273             continue;
 274         }
 275
 276         if (!(e->flags & AVAHI_PUBLISH_UNIQUE) && !unique)
 277             continue;
 278
 279         /* Either our entry or the other is intended to be unique, so let's check */
 280
 281         if (avahi_record_equal_no_ttl(e->record, record)) {
 282             ours = 1; /* We have an identical record, so this is no conflict */
 283
 284             /* Check wheter there is a TTL conflict */
 285             if (record->ttl <= e->record->ttl/2 &&
 286                 avahi_entry_is_registered(s, e, i)) {
 287                 char *t;
 288                 /* Refresh */
 289                 t = avahi_record_to_string(record);
 290
 291                 avahi_log_debug("Recieved record with bad TTL [%s]. Refreshing.", t);
 292                 avahi_server_prepare_matching_responses(s, i, e->record->key, 0);
 293                 valid = 0;
 294
 295                 avahi_free(t);
 296             }
 297
 298             /* There's no need to check the other entries of this RRset */
 299             break;
 300
 301         } else {
 302
 303             if (avahi_entry_is_registered(s, e, i)) {
 304
 305                 /* A conflict => we have to return to probe mode */
 306                 conflict = 1;
 307                 conflicting_entry = e;
 308
 309             } else if (avahi_entry_is_probing(s, e, i)) {
 310
 311                 /* We are currently registering a matching record, but
 312                  * someone else already claimed it, so let's
 313                  * withdraw */
 314                 conflict = 1;
 315                 withdraw_immediately = 1;
 316             }
 317         }
 318     }
 319
 320     if (!ours && conflict) {
 321         char *t;
 322
 323         valid = 0;
 324
 325         t = avahi_record_to_string(record);
 326
 327         if (withdraw_immediately) {
 328             avahi_log_debug("Recieved conflicting record [%s] with local record to be. Withdrawing.", t);
 329             withdraw_rrset(s, record->key);
 330         } else {
 331             assert(conflicting_entry);
 332             avahi_log_debug("Recieved conflicting record [%s]. Resetting our record.", t);
 333             avahi_entry_return_to_initial_state(s, conflicting_entry, i);
 334
 335             /* Local unique records are returned to probing
 336              * state. Local shared records are reannounced. */
 337         }
 338
 339         avahi_free(t);
 340     }
 341
 342     return valid;
 343 }
 344
 345 static void append_aux_callback(AvahiServer *s, AvahiRecord *r, int flush_cache, void* userdata) {
 346     int *unicast_response = userdata;
 347
 348     assert(s);
 349     assert(r);
 350     assert(unicast_response);
 351
 352     avahi_record_list_push(s->record_list, r, flush_cache, *unicast_response, 1);
 353 }
 354
 355 static void append_aux_records_to_list(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, int unicast_response) {
 356     assert(s);
 357     assert(r);
 358
 359     avahi_server_enumerate_aux_records(s, i, r, append_aux_callback, &unicast_response);
 360 }
 361
 362 void avahi_server_generate_response(AvahiServer *s, AvahiInterface *i, AvahiDnsPacket *p, const AvahiAddress *a, uint16_t port, int legacy_unicast, int immediately) {
 363
 364     assert(s);
 365     assert(i);
 366     assert(!legacy_unicast || (a && port > 0 && p));
 367
 368     if (legacy_unicast) {
 369         AvahiDnsPacket *reply;
 370         AvahiRecord *r;
 371
 372         if (!(reply = avahi_dns_packet_new_reply(p, 512 /* unicast DNS maximum packet size is 512 */ , 1, 1)))
 373             return; /* OOM */
 374
 375         while ((r = avahi_record_list_next(s->record_list, NULL, NULL, NULL))) {
 376
 377             append_aux_records_to_list(s, i, r, 0);
 378
 379             if (avahi_dns_packet_append_record(reply, r, 0, 10))
 380                 avahi_dns_packet_inc_field(reply, AVAHI_DNS_FIELD_ANCOUNT);
 381             else {
 382                 char *t = avahi_record_to_string(r);
 383                 avahi_log_warn("Record [%s] not fitting in legacy unicast packet, dropping.", t);
 384                 avahi_free(t);
 385             }
 386
 387             avahi_record_unref(r);
 388         }
 389
 390         if (avahi_dns_packet_get_field(reply, AVAHI_DNS_FIELD_ANCOUNT) != 0)
 391             avahi_interface_send_packet_unicast(i, reply, a, port);
 392
 393         avahi_dns_packet_free(reply);
 394
 395     } else {
 396         int unicast_response, flush_cache, auxiliary;
 397         AvahiDnsPacket *reply = NULL;
 398         AvahiRecord *r;
 399
 400         /* In case the query packet was truncated never respond
 401         immediately, because known answer suppression records might be
 402         contained in later packets */
 403         int tc = p && !!(avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & AVAHI_DNS_FLAG_TC);
 404
 405         while ((r = avahi_record_list_next(s->record_list, &flush_cache, &unicast_response, &auxiliary))) {
 406
 407             if (!avahi_interface_post_response(i, r, flush_cache, a, immediately || (flush_cache && !tc && !auxiliary)) && unicast_response) {
 408
 409                 append_aux_records_to_list(s, i, r, unicast_response);
 410
 411                 /* Due to some reasons the record has not been scheduled.
 412                  * The client requested an unicast response in that
 413                  * case. Therefore we prepare such a response */
 414
 415                 for (;;) {
 416
 417                     if (!reply) {
 418                         assert(p);
 419
 420                         if (!(reply = avahi_dns_packet_new_reply(p, i->hardware->mtu, 0, 0)))
 421                             break; /* OOM */
 422                     }
 423
 424                     if (avahi_dns_packet_append_record(reply, r, flush_cache, 0)) {
 425
 426                         /* Appending this record succeeded, so incremeant
 427                          * the specific header field, and return to the caller */
 428
 429                         avahi_dns_packet_inc_field(reply, AVAHI_DNS_FIELD_ANCOUNT);
 430
 431                         break;
 432                     }
 433
 434                     if (avahi_dns_packet_get_field(reply, AVAHI_DNS_FIELD_ANCOUNT) == 0) {
 435                         size_t size;
 436
 437                         /* The record is too large for one packet, so create a larger packet */
 438
 439                         avahi_dns_packet_free(reply);
 440                         size = avahi_record_get_estimate_size(r) + AVAHI_DNS_PACKET_HEADER_SIZE;
 441                         if (size > AVAHI_DNS_PACKET_SIZE_MAX)
 442                             size = AVAHI_DNS_PACKET_SIZE_MAX;
 443
 444                         if (!(reply = avahi_dns_packet_new_reply(p, size, 0, 1)))
 445                             break; /* OOM */
 446
 447                         if (!avahi_dns_packet_append_record(reply, r, flush_cache, 0)) {
 448                             char *t;
 449                             avahi_dns_packet_free(reply);
 450                             t = avahi_record_to_string(r);
 451                             avahi_log_warn("Record [%s] too large, doesn't fit in any packet!", t);
 452                             avahi_free(t);
 453                             break;
 454                         } else
 455                             avahi_dns_packet_inc_field(reply, AVAHI_DNS_FIELD_ANCOUNT);
 456                     }
 457
 458                     /* Appending the record didn't succeeed, so let's send this packet, and create a new one */
 459                     avahi_interface_send_packet_unicast(i, reply, a, port);
 460                     avahi_dns_packet_free(reply);
 461                     reply = NULL;
 462                 }
 463             }
 464
 465             avahi_record_unref(r);
 466         }
 467
 468         if (reply) {
 469             if (avahi_dns_packet_get_field(reply, AVAHI_DNS_FIELD_ANCOUNT) != 0)
 470                 avahi_interface_send_packet_unicast(i, reply, a, port);
 471             avahi_dns_packet_free(reply);
 472         }
 473     }
 474
 475     avahi_record_list_flush(s->record_list);
 476 }
 477
 478
 479 static void reflect_response(AvahiServer *s, AvahiInterface *i, AvahiRecord *r, int flush_cache) {
 480     AvahiInterface *j;
 481
 482     assert(s);
 483     assert(i);
 484     assert(r);
 485
 486     if (!s->config.enable_reflector)
 487         return;
 488
 489     for (j = s->monitor->interfaces; j; j = j->interface_next)
 490         if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol))
 491             avahi_interface_post_response(j, r, flush_cache, NULL, 1);
 492 }
 493
 494 static void* reflect_cache_walk_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void* userdata) {
 495     AvahiServer *s = userdata;
 496
 497     assert(c);
 498     assert(pattern);
 499     assert(e);
 500     assert(s);
 501
 502     avahi_record_list_push(s->record_list, e->record, e->cache_flush, 0, 0);
 503     return NULL;
 504 }
 505
 506 static void reflect_query(AvahiServer *s, AvahiInterface *i, AvahiKey *k) {
 507     AvahiInterface *j;
 508
 509     assert(s);
 510     assert(i);
 511     assert(k);
 512
 513     if (!s->config.enable_reflector)
 514         return;
 515
 516     for (j = s->monitor->interfaces; j; j = j->interface_next)
 517         if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol)) {
 518             /* Post the query to other networks */
 519             avahi_interface_post_query(j, k, 1);
 520
 521             /* Reply from caches of other network. This is needed to
 522              * "work around" known answer suppression. */
 523
 524             avahi_cache_walk(j->cache, k, reflect_cache_walk_callback, s);
 525         }
 526 }
 527
 528 static void reflect_probe(AvahiServer *s, AvahiInterface *i, AvahiRecord *r) {
 529     AvahiInterface *j;
 530
 531     assert(s);
 532     assert(i);
 533     assert(r);
 534
 535     if (!s->config.enable_reflector)
 536         return;
 537
 538     for (j = s->monitor->interfaces; j; j = j->interface_next)
 539         if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol))
 540             avahi_interface_post_probe(j, r, 1);
 541 }
 542
 543 static void handle_query_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, uint16_t port, int legacy_unicast, int from_local_iface) {
 544     size_t n;
 545     int is_probe;
 546
 547     assert(s);
 548     assert(p);
 549     assert(i);
 550     assert(a);
 551
 552 /*     avahi_log_debug("query"); */
 553
 554     assert(avahi_record_list_is_empty(s->record_list));
 555
 556     is_probe = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_NSCOUNT) > 0;
 557
 558     /* Handle the questions */
 559     for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_QDCOUNT); n > 0; n --) {
 560         AvahiKey *key;
 561         int unicast_response = 0;
 562
 563         if (!(key = avahi_dns_packet_consume_key(p, &unicast_response))) {
 564             avahi_log_warn("Packet too short (1)");
 565             goto fail;
 566         }
 567
 568         if (!legacy_unicast && !from_local_iface) {
 569             reflect_query(s, i, key);
 570             avahi_cache_start_poof(i->cache, key, a);
 571         }
 572
 573         if (avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) == 0 &&
 574             !(avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) & AVAHI_DNS_FLAG_TC))
 575             /* Allow our own queries to be suppressed by incoming
 576              * queries only when they do not include known answers */
 577             avahi_query_scheduler_incoming(i->query_scheduler, key);
 578
 579         avahi_server_prepare_matching_responses(s, i, key, unicast_response);
 580         avahi_key_unref(key);
 581     }
 582
 583     if (!legacy_unicast) {
 584
 585         /* Known Answer Suppression */
 586         for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT); n > 0; n --) {
 587             AvahiRecord *record;
 588             int unique = 0;
 589
 590             if (!(record = avahi_dns_packet_consume_record(p, &unique))) {
 591                 avahi_log_warn("Packet too short (2)");
 592                 goto fail;
 593             }
 594
 595             if (handle_conflict(s, i, record, unique)) {
 596                 avahi_response_scheduler_suppress(i->response_scheduler, record, a);
 597                 avahi_record_list_drop(s->record_list, record);
 598                 avahi_cache_stop_poof(i->cache, record, a);
 599             }
 600
 601             avahi_record_unref(record);
 602         }
 603
 604         /* Probe record */
 605         for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_NSCOUNT); n > 0; n --) {
 606             AvahiRecord *record;
 607             int unique = 0;
 608
 609             if (!(record = avahi_dns_packet_consume_record(p, &unique))) {
 610                 avahi_log_warn("Packet too short (3)");
 611                 goto fail;
 612             }
 613
 614             if (!avahi_key_is_pattern(record->key)) {
 615                 if (!from_local_iface)
 616                     reflect_probe(s, i, record);
 617                 incoming_probe(s, record, i);
 618             }
 619
 620             avahi_record_unref(record);
 621         }
 622     }
 623
 624     if (!avahi_record_list_is_empty(s->record_list))
 625         avahi_server_generate_response(s, i, p, a, port, legacy_unicast, is_probe);
 626
 627     return;
 628
 629 fail:
 630     avahi_record_list_flush(s->record_list);
 631 }
 632
 633 static void handle_response_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, int from_local_iface) {
 634     unsigned n;
 635
 636     assert(s);
 637     assert(p);
 638     assert(i);
 639     assert(a);
 640
 641 /*     avahi_log_debug("response"); */
 642
 643     for (n = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) +
 644              avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ARCOUNT); n > 0; n--) {
 645         AvahiRecord *record;
 646         int cache_flush = 0;
 647 /*         char *txt; */
 648
 649         if (!(record = avahi_dns_packet_consume_record(p, &cache_flush))) {
 650             avahi_log_warn("Packet too short (4)");
 651             break;
 652         }
 653
 654         if (!avahi_key_is_pattern(record->key)) {
 655
 656 /*             avahi_log_debug("Handling response: %s", txt = avahi_record_to_string(record)); */
 657 /*             avahi_free(txt); */
 658
 659             if (handle_conflict(s, i, record, cache_flush)) {
 660                 if (!from_local_iface)
 661                     reflect_response(s, i, record, cache_flush);
 662                 avahi_cache_update(i->cache, record, cache_flush, a);
 663                 avahi_response_scheduler_incoming(i->response_scheduler, record, cache_flush);
 664             }
 665         }
 666
 667         avahi_record_unref(record);
 668     }
 669
 670     /* If the incoming response contained a conflicting record, some
 671        records have been scheduling for sending. We need to flush them
 672        here. */
 673     if (!avahi_record_list_is_empty(s->record_list))
 674         avahi_server_generate_response(s, i, NULL, NULL, 0, 0, 1);
 675 }
 676
 677 static AvahiLegacyUnicastReflectSlot* allocate_slot(AvahiServer *s) {
 678     unsigned n, idx = (unsigned) -1;
 679     AvahiLegacyUnicastReflectSlot *slot;
 680
 681     assert(s);
 682
 683     if (!s->legacy_unicast_reflect_slots)
 684         s->legacy_unicast_reflect_slots = avahi_new0(AvahiLegacyUnicastReflectSlot*, AVAHI_LEGACY_UNICAST_REFLECT_SLOTS_MAX);
 685
 686     for (n = 0; n < AVAHI_LEGACY_UNICAST_REFLECT_SLOTS_MAX; n++, s->legacy_unicast_reflect_id++) {
 687         idx = s->legacy_unicast_reflect_id % AVAHI_LEGACY_UNICAST_REFLECT_SLOTS_MAX;
 688
 689         if (!s->legacy_unicast_reflect_slots[idx])
 690             break;
 691     }
 692
 693     if (idx == (unsigned) -1 || s->legacy_unicast_reflect_slots[idx])
 694         return NULL;
 695
 696     if (!(slot = avahi_new(AvahiLegacyUnicastReflectSlot, 1)))
 697         return NULL; /* OOM */
 698
 699     s->legacy_unicast_reflect_slots[idx] = slot;
 700     slot->id = s->legacy_unicast_reflect_id++;
 701     slot->server = s;
 702
 703     return slot;
 704 }
 705
 706 static void deallocate_slot(AvahiServer *s, AvahiLegacyUnicastReflectSlot *slot) {
 707     unsigned idx;
 708
 709     assert(s);
 710     assert(slot);
 711
 712     idx = slot->id % AVAHI_LEGACY_UNICAST_REFLECT_SLOTS_MAX;
 713
 714     assert(s->legacy_unicast_reflect_slots[idx] == slot);
 715
 716     avahi_time_event_free(slot->time_event);
 717
 718     avahi_free(slot);
 719     s->legacy_unicast_reflect_slots[idx] = NULL;
 720 }
 721
 722 static void free_slots(AvahiServer *s) {
 723     unsigned idx;
 724     assert(s);
 725
 726     if (!s->legacy_unicast_reflect_slots)
 727         return;
 728
 729     for (idx = 0; idx < AVAHI_LEGACY_UNICAST_REFLECT_SLOTS_MAX; idx ++)
 730         if (s->legacy_unicast_reflect_slots[idx])
 731             deallocate_slot(s, s->legacy_unicast_reflect_slots[idx]);
 732
 733     avahi_free(s->legacy_unicast_reflect_slots);
 734     s->legacy_unicast_reflect_slots = NULL;
 735 }
 736
 737 static AvahiLegacyUnicastReflectSlot* find_slot(AvahiServer *s, uint16_t id) {
 738     unsigned idx;
 739
 740     assert(s);
 741
 742     if (!s->legacy_unicast_reflect_slots)
 743         return NULL;
 744
 745     idx = id % AVAHI_LEGACY_UNICAST_REFLECT_SLOTS_MAX;
 746
 747     if (!s->legacy_unicast_reflect_slots[idx] || s->legacy_unicast_reflect_slots[idx]->id != id)
 748         return NULL;
 749
 750     return s->legacy_unicast_reflect_slots[idx];
 751 }
 752
 753 static void legacy_unicast_reflect_slot_timeout(AvahiTimeEvent *e, void *userdata) {
 754     AvahiLegacyUnicastReflectSlot *slot = userdata;
 755
 756     assert(e);
 757     assert(slot);
 758     assert(slot->time_event == e);
 759
 760     deallocate_slot(slot->server, slot);
 761 }
 762
 763 static void reflect_legacy_unicast_query_packet(AvahiServer *s, AvahiDnsPacket *p, AvahiInterface *i, const AvahiAddress *a, uint16_t port) {
 764     AvahiLegacyUnicastReflectSlot *slot;
 765     AvahiInterface *j;
 766
 767     assert(s);
 768     assert(p);
 769     assert(i);
 770     assert(a);
 771     assert(port > 0);
 772     assert(i->protocol == a->proto);
 773
 774     if (!s->config.enable_reflector)
 775         return;
 776
 777 /*     avahi_log_debug("legacy unicast reflector"); */
 778
 779     /* Reflecting legacy unicast queries is a little more complicated
 780        than reflecting normal queries, since we must route the
 781        responses back to the right client. Therefore we must store
 782        some information for finding the right client contact data for
 783        response packets. In contrast to normal queries legacy
 784        unicast query and response packets are reflected untouched and
 785        are not reassembled into larger packets */
 786
 787     if (!(slot = allocate_slot(s))) {
 788         /* No slot available, we drop this legacy unicast query */
 789         avahi_log_warn("No slot available for legacy unicast reflection, dropping query packet.");
 790         return;
 791     }
 792
 793     slot->original_id = avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ID);
 794     slot->address = *a;
 795     slot->port = port;
 796     slot->interface = i->hardware->index;
 797
 798     avahi_elapse_time(&slot->elapse_time, 2000, 0);
 799     slot->time_event = avahi_time_event_new(s->time_event_queue, &slot->elapse_time, legacy_unicast_reflect_slot_timeout, slot);
 800
 801     /* Patch the packet with our new locally generatet id */
 802     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ID, slot->id);
 803
 804     for (j = s->monitor->interfaces; j; j = j->interface_next)
 805         if (avahi_interface_is_relevant(j) &&
 806             j != i &&
 807             (s->config.reflect_ipv || j->protocol == i->protocol)) {
 808
 809             if (j->protocol == AVAHI_PROTO_INET && s->fd_legacy_unicast_ipv4 >= 0) {
 810                 avahi_send_dns_packet_ipv4(s->fd_legacy_unicast_ipv4, j->hardware->index, p, NULL, NULL, 0);
 811             } else if (j->protocol == AVAHI_PROTO_INET6 && s->fd_legacy_unicast_ipv6 >= 0)
 812                 avahi_send_dns_packet_ipv6(s->fd_legacy_unicast_ipv6, j->hardware->index, p, NULL, NULL, 0);
 813         }
 814
 815     /* Reset the id */
 816     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ID, slot->original_id);
 817 }
 818
 819 static int originates_from_local_legacy_unicast_socket(AvahiServer *s, const AvahiAddress *address, uint16_t port) {
 820     assert(s);
 821     assert(address);
 822     assert(port > 0);
 823
 824     if (!s->config.enable_reflector)
 825         return 0;
 826
 827     if (!avahi_address_is_local(s->monitor, address))
 828         return 0;
 829
 830     if (address->proto == AVAHI_PROTO_INET && s->fd_legacy_unicast_ipv4 >= 0) {
 831         struct sockaddr_in lsa;
 832         socklen_t l = sizeof(lsa);
 833
 834         if (getsockname(s->fd_legacy_unicast_ipv4, (struct sockaddr*) &lsa, &l) != 0)
 835             avahi_log_warn("getsockname(): %s", strerror(errno));
 836         else
 837             return lsa.sin_port == port;
 838
 839     }
 840
 841     if (address->proto == AVAHI_PROTO_INET6 && s->fd_legacy_unicast_ipv6 >= 0) {
 842         struct sockaddr_in6 lsa;
 843         socklen_t l = sizeof(lsa);
 844
 845         if (getsockname(s->fd_legacy_unicast_ipv6, (struct sockaddr*) &lsa, &l) != 0)
 846             avahi_log_warn("getsockname(): %s", strerror(errno));
 847         else
 848             return lsa.sin6_port == port;
 849     }
 850
 851     return 0;
 852 }
 853
 854 static int is_mdns_mcast_address(const AvahiAddress *a) {
 855     AvahiAddress b;
 856     assert(a);
 857
 858     avahi_address_parse(a->proto == AVAHI_PROTO_INET ? AVAHI_IPV4_MCAST_GROUP : AVAHI_IPV6_MCAST_GROUP, a->proto, &b);
 859     return avahi_address_cmp(a, &b) == 0;
 860 }
 861
 862 static int originates_from_local_iface(AvahiServer *s, AvahiIfIndex iface, const AvahiAddress *a, uint16_t port) {
 863     assert(s);
 864     assert(iface != AVAHI_IF_UNSPEC);
 865     assert(a);
 866
 867     /* If it isn't the MDNS port it can't be generated by us */
 868     if (port != AVAHI_MDNS_PORT)
 869         return 0;
 870
 871     return avahi_interface_has_address(s->monitor, iface, a);
 872 }
 873
 874 static void dispatch_packet(AvahiServer *s, AvahiDnsPacket *p, const AvahiAddress *src_address, uint16_t port, const AvahiAddress *dst_address, AvahiIfIndex iface, int ttl) {
 875     AvahiInterface *i;
 876     int from_local_iface = 0;
 877
 878     assert(s);
 879     assert(p);
 880     assert(src_address);
 881     assert(dst_address);
 882     assert(iface > 0);
 883     assert(src_address->proto == dst_address->proto);
 884
 885     if (!(i = avahi_interface_monitor_get_interface(s->monitor, iface, src_address->proto)) ||
 886         !avahi_interface_is_relevant(i)) {
 887         avahi_log_warn("Recieved packet from invalid interface.");
 888         return;
 889     }
 890
 891 /*     avahi_log_debug("new packet received on interface '%s.%i'.", i->hardware->name, i->protocol); */
 892
 893     if (avahi_address_is_ipv4_in_ipv6(src_address))
 894         /* This is an IPv4 address encapsulated in IPv6, so let's ignore it. */
 895         return;
 896
 897     if (originates_from_local_legacy_unicast_socket(s, src_address, port))
 898         /* This originates from our local reflector, so let's ignore it */
 899         return;
 900
 901     /* We don't want to reflect local traffic, so we check if this packet is generated locally. */
 902     if (s->config.enable_reflector)
 903         from_local_iface = originates_from_local_iface(s, iface, src_address, port);
 904
 905     if (avahi_dns_packet_check_valid_multicast(p) < 0) {
 906         avahi_log_warn("Recieved invalid packet.");
 907         return;
 908     }
 909
 910     if (avahi_dns_packet_is_query(p)) {
 911         int legacy_unicast = 0;
 912
 913         if (avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ARCOUNT) != 0) {
 914             avahi_log_warn("Invalid query packet.");
 915             return;
 916         }
 917
 918         if (port != AVAHI_MDNS_PORT) {
 919             /* Legacy Unicast */
 920
 921             if ((avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) != 0 ||
 922                  avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_NSCOUNT) != 0)) {
 923                 avahi_log_warn("Invalid legacy unicast query packet.");
 924                 return;
 925             }
 926
 927             legacy_unicast = 1;
 928         }
 929
 930         if (legacy_unicast)
 931             reflect_legacy_unicast_query_packet(s, p, i, src_address, port);
 932
 933         handle_query_packet(s, p, i, src_address, port, legacy_unicast, from_local_iface);
 934
 935 /*         avahi_log_debug("Handled query"); */
 936     } else {
 937         if (port != AVAHI_MDNS_PORT) {
 938             avahi_log_warn("Recieved repsonse with invalid source port %u on interface '%s.%i'", port, i->hardware->name, i->protocol);
 939             return;
 940         }
 941
 942         if (ttl != 255 && s->config.check_response_ttl) {
 943             avahi_log_warn("Recieved response with invalid TTL %u on interface '%s.%i'.", ttl, i->hardware->name, i->protocol);
 944             return;
 945         }
 946
 947         if (!is_mdns_mcast_address(dst_address) &&
 948             !avahi_interface_address_on_link(i, src_address)) {
 949             avahi_log_warn("Received non-local response on interface '%s.%i'.", i->hardware->name, i->protocol);
 950             return;
 951         }
 952
 953         if (avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_QDCOUNT) != 0 ||
 954             avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ANCOUNT) == 0 ||
 955             avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_NSCOUNT) != 0) {
 956             avahi_log_warn("Invalid response packet.");
 957             return;
 958         }
 959
 960         handle_response_packet(s, p, i, src_address, from_local_iface);
 961 /*         avahi_log_debug("Handled response"); */
 962     }
 963 }
 964
 965 static void dispatch_legacy_unicast_packet(AvahiServer *s, AvahiDnsPacket *p) {
 966     AvahiInterface *j;
 967     AvahiLegacyUnicastReflectSlot *slot;
 968
 969     assert(s);
 970     assert(p);
 971
 972     if (avahi_dns_packet_check_valid(p) < 0 || avahi_dns_packet_is_query(p)) {
 973         avahi_log_warn("Recieved invalid packet.");
 974         return;
 975     }
 976
 977     if (!(slot = find_slot(s, avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_ID)))) {
 978         avahi_log_warn("Recieved legacy unicast response with unknown id");
 979         return;
 980     }
 981
 982     if (!(j = avahi_interface_monitor_get_interface(s->monitor, slot->interface, slot->address.proto)) ||
 983         !avahi_interface_is_relevant(j))
 984         return;
 985
 986     /* Patch the original ID into this response */
 987     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ID, slot->original_id);
 988
 989     /* Forward the response to the correct client */
 990     avahi_interface_send_packet_unicast(j, p, &slot->address, slot->port);
 991
 992     /* Undo changes to packet */
 993     avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ID, slot->id);
 994 }
 995
 996 static void cleanup_dead(AvahiServer *s) {
 997     assert(s);
 998
 999     avahi_cleanup_dead_entries(s);
1000     avahi_browser_cleanup(s);
1001 }
1002
1003 static void mcast_socket_event(AvahiWatch *w, int fd, AvahiWatchEvent events, void *userdata) {
1004     AvahiServer *s = userdata;
1005     AvahiAddress dest, src;
1006     AvahiDnsPacket *p = NULL;
1007     AvahiIfIndex iface;
1008     uint16_t port;
1009     uint8_t ttl;
1010
1011     assert(w);
1012     assert(fd >= 0);
1013     assert(events & AVAHI_WATCH_IN);
1014
1015     if (fd == s->fd_ipv4) {
1016         dest.proto = src.proto = AVAHI_PROTO_INET;
1017         p = avahi_recv_dns_packet_ipv4(s->fd_ipv4, &src.data.ipv4, &port, &dest.data.ipv4, &iface, &ttl);
1018     } else {
1019         assert(fd == s->fd_ipv6);
1020         dest.proto = src.proto = AVAHI_PROTO_INET6;
1021         p = avahi_recv_dns_packet_ipv6(s->fd_ipv6, &src.data.ipv6, &port, &dest.data.ipv6, &iface, &ttl);
1022     }
1023
1024     if (p) {
1025         if (iface == AVAHI_IF_UNSPEC)
1026             iface = avahi_find_interface_for_address(s->monitor, &dest);
1027
1028         if (iface != AVAHI_IF_UNSPEC)
1029             dispatch_packet(s, p, &src, port, &dest, iface, ttl);
1030         else
1031             avahi_log_error("Incoming packet recieved on address that isn't local.");
1032
1033         avahi_dns_packet_free(p);
1034
1035         cleanup_dead(s);
1036     }
1037 }
1038
1039 static void legacy_unicast_socket_event(AvahiWatch *w, int fd, AvahiWatchEvent events, void *userdata) {
1040     AvahiServer *s = userdata;
1041     AvahiDnsPacket *p = NULL;
1042
1043     assert(w);
1044     assert(fd >= 0);
1045     assert(events & AVAHI_WATCH_IN);
1046
1047     if (fd == s->fd_legacy_unicast_ipv4)
1048         p = avahi_recv_dns_packet_ipv4(s->fd_legacy_unicast_ipv4, NULL, NULL, NULL, NULL, NULL);
1049     else {
1050         assert(fd == s->fd_legacy_unicast_ipv6);
1051         p = avahi_recv_dns_packet_ipv6(s->fd_legacy_unicast_ipv6, NULL, NULL, NULL, NULL, NULL);
1052     }
1053
1054     if (p) {
1055         dispatch_legacy_unicast_packet(s, p);
1056         avahi_dns_packet_free(p);
1057
1058         cleanup_dead(s);
1059     }
1060 }
1061
1062 static void server_set_state(AvahiServer *s, AvahiServerState state) {
1063     assert(s);
1064
1065     if (s->state == state)
1066         return;
1067
1068     s->state = state;
1069
1070     if (s->callback)
1071         s->callback(s, state, s->userdata);
1072 }
1073
1074 static void withdraw_host_rrs(AvahiServer *s) {
1075     assert(s);
1076
1077     if (s->hinfo_entry_group)
1078         avahi_s_entry_group_reset(s->hinfo_entry_group);
1079
1080     if (s->browse_domain_entry_group)
1081         avahi_s_entry_group_reset(s->browse_domain_entry_group);
1082
1083     avahi_interface_monitor_update_rrs(s->monitor, 1);
1084     s->n_host_rr_pending = 0;
1085 }
1086
1087 void avahi_server_decrease_host_rr_pending(AvahiServer *s) {
1088     assert(s);
1089
1090     assert(s->n_host_rr_pending > 0);
1091
1092     if (--s->n_host_rr_pending == 0)
1093         server_set_state(s, AVAHI_SERVER_RUNNING);
1094 }
1095
1096 void avahi_host_rr_entry_group_callback(AvahiServer *s, AvahiSEntryGroup *g, AvahiEntryGroupState state, AVAHI_GCC_UNUSED void *userdata) {
1097     assert(s);
1098     assert(g);
1099
1100     if (state == AVAHI_ENTRY_GROUP_REGISTERING &&
1101         s->state == AVAHI_SERVER_REGISTERING)
1102         s->n_host_rr_pending ++;
1103
1104     else if (state == AVAHI_ENTRY_GROUP_COLLISION &&
1105         (s->state == AVAHI_SERVER_REGISTERING || s->state == AVAHI_SERVER_RUNNING)) {
1106         withdraw_host_rrs(s);
1107         server_set_state(s, AVAHI_SERVER_COLLISION);
1108
1109     } else if (state == AVAHI_ENTRY_GROUP_ESTABLISHED &&
1110                s->state == AVAHI_SERVER_REGISTERING)
1111         avahi_server_decrease_host_rr_pending(s);
1112 }
1113
1114 static void register_hinfo(AvahiServer *s) {
1115     struct utsname utsname;
1116     AvahiRecord *r;
1117
1118     assert(s);
1119
1120     if (!s->config.publish_hinfo)
1121         return;
1122
1123     if (s->hinfo_entry_group)
1124         assert(avahi_s_entry_group_is_empty(s->hinfo_entry_group));
1125     else
1126         s->hinfo_entry_group = avahi_s_entry_group_new(s, avahi_host_rr_entry_group_callback, NULL);
1127
1128     if (!s->hinfo_entry_group) {
1129         avahi_log_warn("Failed to create HINFO entry group: %s", avahi_strerror(s->error));
1130         return;
1131     }
1132
1133     /* Fill in HINFO rr */
1134     if ((r = avahi_record_new_full(s->host_name_fqdn, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_HINFO, AVAHI_DEFAULT_TTL_HOST_NAME))) {
1135         uname(&utsname);
1136         r->data.hinfo.cpu = avahi_strdup(avahi_strup(utsname.machine));
1137         r->data.hinfo.os = avahi_strdup(avahi_strup(utsname.sysname));
1138
1139         if (avahi_server_add(s, s->hinfo_entry_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_PUBLISH_UNIQUE, r) < 0) {
1140             avahi_log_warn("Failed to add HINFO RR: %s", avahi_strerror(s->error));
1141             return;
1142         }
1143
1144         avahi_record_unref(r);
1145     }
1146
1147     if (avahi_s_entry_group_commit(s->hinfo_entry_group) < 0)
1148         avahi_log_warn("Failed to commit HINFO entry group: %s", avahi_strerror(s->error));
1149
1150 }
1151
1152 static void register_localhost(AvahiServer *s) {
1153     AvahiAddress a;
1154     assert(s);
1155
1156     /* Add localhost entries */
1157     avahi_address_parse("127.0.0.1", AVAHI_PROTO_INET, &a);
1158     avahi_server_add_address(s, NULL, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_PUBLISH_NO_PROBE|AVAHI_PUBLISH_NO_ANNOUNCE, "localhost", &a);
1159
1160     avahi_address_parse("::1", AVAHI_PROTO_INET6, &a);
1161     avahi_server_add_address(s, NULL, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, AVAHI_PUBLISH_NO_PROBE|AVAHI_PUBLISH_NO_ANNOUNCE, "ip6-localhost", &a);
1162 }
1163
1164 static void register_browse_domain(AvahiServer *s) {
1165     assert(s);
1166
1167     if (!s->config.publish_domain)
1168         return;
1169
1170     if (s->browse_domain_entry_group)
1171         assert(avahi_s_entry_group_is_empty(s->browse_domain_entry_group));
1172     else
1173         s->browse_domain_entry_group = avahi_s_entry_group_new(s, NULL, NULL);
1174
1175     if (!s->browse_domain_entry_group) {
1176         avahi_log_warn("Failed to create browse domain entry group: %s", avahi_strerror(s->error));
1177         return;
1178     }
1179
1180     if (avahi_server_add_ptr(s, s->browse_domain_entry_group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, 0, AVAHI_DEFAULT_TTL, "b._dns-sd._udp.local", s->domain_name) < 0) {
1181         avahi_log_warn("Failed to add browse domain RR: %s", avahi_strerror(s->error));
1182         return;
1183     }
1184
1185     if (avahi_s_entry_group_commit(s->browse_domain_entry_group) < 0)
1186         avahi_log_warn("Failed to commit browse domain entry group: %s", avahi_strerror(s->error));
1187 }
1188
1189 static void register_stuff(AvahiServer *s) {
1190     assert(s);
1191
1192     server_set_state(s, AVAHI_SERVER_REGISTERING);
1193     s->n_host_rr_pending ++; /** Make sure that the state isn't changed tp AVAHI_SERVER_RUNNING too early */
1194
1195     register_hinfo(s);
1196     register_browse_domain(s);
1197     avahi_interface_monitor_update_rrs(s->monitor, 0);
1198
1199     s->n_host_rr_pending --;
1200
1201     if (s->n_host_rr_pending == 0)
1202         server_set_state(s, AVAHI_SERVER_RUNNING);
1203 }
1204
1205 static void update_fqdn(AvahiServer *s) {
1206     char *n;
1207
1208     assert(s);
1209     assert(s->host_name);
1210     assert(s->domain_name);
1211
1212     if (!(n = avahi_strdup_printf("%s.%s", s->host_name, s->domain_name)))
1213         return; /* OOM */
1214
1215     avahi_free(s->host_name_fqdn);
1216     s->host_name_fqdn = n;
1217 }
1218
1219 int avahi_server_set_host_name(AvahiServer *s, const char *host_name) {
1220     assert(s);
1221     assert(host_name);
1222
1223     if (host_name && !avahi_is_valid_host_name(host_name))
1224         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_HOST_NAME);
1225
1226     withdraw_host_rrs(s);
1227
1228     avahi_free(s->host_name);
1229     s->host_name = host_name ? avahi_normalize_name_strdup(host_name) : avahi_get_host_name_strdup();
1230     s->host_name[strcspn(s->host_name, ".")] = 0;
1231     update_fqdn(s);
1232
1233     register_stuff(s);
1234     return AVAHI_OK;
1235 }
1236
1237 int avahi_server_set_domain_name(AvahiServer *s, const char *domain_name) {
1238     assert(s);
1239     assert(domain_name);
1240
1241     if (domain_name && !avahi_is_valid_domain_name(domain_name))
1242         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME);
1243
1244     withdraw_host_rrs(s);
1245
1246     avahi_free(s->domain_name);
1247     s->domain_name = domain_name ? avahi_normalize_name_strdup(domain_name) : avahi_strdup("local");
1248     update_fqdn(s);
1249
1250     register_stuff(s);
1251     return AVAHI_OK;
1252 }
1253
1254 static int valid_server_config(const AvahiServerConfig *sc) {
1255
1256     if (sc->host_name && !avahi_is_valid_host_name(sc->host_name))
1257         return AVAHI_ERR_INVALID_HOST_NAME;
1258
1259     if (sc->domain_name && !avahi_is_valid_domain_name(sc->domain_name))
1260         return AVAHI_ERR_INVALID_DOMAIN_NAME;
1261
1262     return AVAHI_OK;
1263 }
1264
1265 static int setup_sockets(AvahiServer *s) {
1266     assert(s);
1267
1268     s->fd_ipv4 = s->config.use_ipv4 ? avahi_open_socket_ipv4(s->config.disallow_other_stacks) : -1;
1269     s->fd_ipv6 = s->config.use_ipv6 ? avahi_open_socket_ipv6(s->config.disallow_other_stacks) : -1;
1270
1271     if (s->fd_ipv6 < 0 && s->fd_ipv4 < 0)
1272         return AVAHI_ERR_NO_NETWORK;
1273
1274     if (s->fd_ipv4 < 0 && s->config.use_ipv4)
1275         avahi_log_notice("Failed to create IPv4 socket, proceeding in IPv6 only mode");
1276     else if (s->fd_ipv6 < 0 && s->config.use_ipv6)
1277         avahi_log_notice("Failed to create IPv6 socket, proceeding in IPv4 only mode");
1278
1279     s->fd_legacy_unicast_ipv4 = s->fd_ipv4 >= 0 && s->config.enable_reflector ? avahi_open_unicast_socket_ipv4() : -1;
1280     s->fd_legacy_unicast_ipv6 = s->fd_ipv6 >= 0 && s->config.enable_reflector ? avahi_open_unicast_socket_ipv6() : -1;
1281
1282     s->watch_ipv4 =
1283         s->watch_ipv6 =
1284         s->watch_legacy_unicast_ipv4 =
1285         s->watch_legacy_unicast_ipv6 = NULL;
1286
1287     if (s->fd_ipv4 >= 0)
1288         s->watch_ipv4 = s->poll_api->watch_new(s->poll_api, s->fd_ipv4, AVAHI_WATCH_IN, mcast_socket_event, s);
1289     if (s->fd_ipv6 >= 0)
1290         s->watch_ipv6 = s->poll_api->watch_new(s->poll_api, s->fd_ipv6, AVAHI_WATCH_IN, mcast_socket_event, s);
1291
1292     if (s->fd_legacy_unicast_ipv4 >= 0)
1293         s->watch_legacy_unicast_ipv4 = s->poll_api->watch_new(s->poll_api, s->fd_legacy_unicast_ipv4, AVAHI_WATCH_IN, legacy_unicast_socket_event, s);
1294     if (s->fd_legacy_unicast_ipv6 >= 0)
1295         s->watch_legacy_unicast_ipv6 = s->poll_api->watch_new(s->poll_api, s->fd_legacy_unicast_ipv6, AVAHI_WATCH_IN, legacy_unicast_socket_event, s);
1296
1297     return 0;
1298 }
1299
1300 AvahiServer *avahi_server_new(const AvahiPoll *poll_api, const AvahiServerConfig *sc, AvahiServerCallback callback, void* userdata, int *error) {
1301     AvahiServer *s;
1302     int e;
1303
1304     if (sc && (e = valid_server_config(sc)) < 0) {
1305         if (error)
1306             *error = e;
1307         return NULL;
1308     }
1309
1310     if (!(s = avahi_new(AvahiServer, 1))) {
1311         if (error)
1312             *error = AVAHI_ERR_NO_MEMORY;
1313
1314         return NULL;
1315     }
1316
1317     s->poll_api = poll_api;
1318
1319     if (sc)
1320         avahi_server_config_copy(&s->config, sc);
1321     else
1322         avahi_server_config_init(&s->config);
1323
1324     if ((e = setup_sockets(s)) < 0) {
1325         if (error)
1326             *error = e;
1327
1328         avahi_server_config_free(&s->config);
1329         avahi_free(s);
1330
1331         return NULL;
1332     }
1333
1334     s->n_host_rr_pending = 0;
1335     s->need_entry_cleanup = 0;
1336     s->need_group_cleanup = 0;
1337     s->need_browser_cleanup = 0;
1338     s->hinfo_entry_group = NULL;
1339     s->browse_domain_entry_group = NULL;
1340     s->error = AVAHI_OK;
1341     s->state = AVAHI_SERVER_INVALID;
1342
1343     s->callback = callback;
1344     s->userdata = userdata;
1345
1346     s->time_event_queue = avahi_time_event_queue_new(poll_api);
1347
1348     s->entries_by_key = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, NULL, NULL);
1349     AVAHI_LLIST_HEAD_INIT(AvahiEntry, s->entries);
1350     AVAHI_LLIST_HEAD_INIT(AvahiGroup, s->groups);
1351
1352     s->record_browser_hashmap = avahi_hashmap_new((AvahiHashFunc) avahi_key_hash, (AvahiEqualFunc) avahi_key_equal, NULL, NULL);
1353     AVAHI_LLIST_HEAD_INIT(AvahiSRecordBrowser, s->record_browsers);
1354     AVAHI_LLIST_HEAD_INIT(AvahiSHostNameResolver, s->host_name_resolvers);
1355     AVAHI_LLIST_HEAD_INIT(AvahiSAddressResolver, s->address_resolvers);
1356     AVAHI_LLIST_HEAD_INIT(AvahiSDomainBrowser, s->domain_browsers);
1357     AVAHI_LLIST_HEAD_INIT(AvahiSServiceTypeBrowser, s->service_type_browsers);
1358     AVAHI_LLIST_HEAD_INIT(AvahiSServiceBrowser, s->service_browsers);
1359     AVAHI_LLIST_HEAD_INIT(AvahiSServiceResolver, s->service_resolvers);
1360     AVAHI_LLIST_HEAD_INIT(AvahiSDNSServerBrowser, s->dns_server_browsers);
1361
1362     s->legacy_unicast_reflect_slots = NULL;
1363     s->legacy_unicast_reflect_id = 0;
1364
1365     s->record_list = avahi_record_list_new();
1366
1367     /* Get host name */
1368     s->host_name = s->config.host_name ? avahi_normalize_name_strdup(s->config.host_name) : avahi_get_host_name_strdup();
1369     s->host_name[strcspn(s->host_name, ".")] = 0;
1370     s->domain_name = s->config.domain_name ? avahi_normalize_name_strdup(s->config.domain_name) : avahi_strdup("local");
1371     s->host_name_fqdn = NULL;
1372     update_fqdn(s);
1373
1374     do {
1375         s->local_service_cookie = (uint32_t) rand() * (uint32_t) rand();
1376     } while (s->local_service_cookie == AVAHI_SERVICE_COOKIE_INVALID);
1377
1378     if (s->config.enable_wide_area) {
1379         s->wide_area_lookup_engine = avahi_wide_area_engine_new(s);
1380         avahi_wide_area_set_servers(s->wide_area_lookup_engine, s->config.wide_area_servers, s->config.n_wide_area_servers);
1381     } else
1382         s->wide_area_lookup_engine = NULL;
1383
1384     s->multicast_lookup_engine = avahi_multicast_lookup_engine_new(s);
1385
1386     s->monitor = avahi_interface_monitor_new(s);
1387     avahi_interface_monitor_sync(s->monitor);
1388
1389     register_localhost(s);
1390     register_stuff(s);
1391
1392     return s;
1393 }
1394
1395 void avahi_server_free(AvahiServer* s) {
1396     assert(s);
1397
1398     /* Remove all browsers */
1399
1400     while (s->dns_server_browsers)
1401         avahi_s_dns_server_browser_free(s->dns_server_browsers);
1402     while (s->host_name_resolvers)
1403         avahi_s_host_name_resolver_free(s->host_name_resolvers);
1404     while (s->address_resolvers)
1405         avahi_s_address_resolver_free(s->address_resolvers);
1406     while (s->domain_browsers)
1407         avahi_s_domain_browser_free(s->domain_browsers);
1408     while (s->service_type_browsers)
1409         avahi_s_service_type_browser_free(s->service_type_browsers);
1410     while (s->service_browsers)
1411         avahi_s_service_browser_free(s->service_browsers);
1412     while (s->service_resolvers)
1413         avahi_s_service_resolver_free(s->service_resolvers);
1414     while (s->record_browsers)
1415         avahi_s_record_browser_destroy(s->record_browsers);
1416
1417     /* Remove all locally rgeistered stuff */
1418
1419     while(s->entries)
1420         avahi_entry_free(s, s->entries);
1421
1422     avahi_interface_monitor_free(s->monitor);
1423
1424     while (s->groups)
1425         avahi_entry_group_free(s, s->groups);
1426
1427     free_slots(s);
1428
1429     avahi_hashmap_free(s->entries_by_key);
1430     avahi_record_list_free(s->record_list);
1431     avahi_hashmap_free(s->record_browser_hashmap);
1432
1433     if (s->wide_area_lookup_engine)
1434         avahi_wide_area_engine_free(s->wide_area_lookup_engine);
1435     avahi_multicast_lookup_engine_free(s->multicast_lookup_engine);
1436
1437     avahi_time_event_queue_free(s->time_event_queue);
1438
1439     /* Free watches */
1440
1441     if (s->watch_ipv4)
1442         s->poll_api->watch_free(s->watch_ipv4);
1443     if (s->watch_ipv6)
1444         s->poll_api->watch_free(s->watch_ipv6);
1445
1446     if (s->watch_legacy_unicast_ipv4)
1447         s->poll_api->watch_free(s->watch_legacy_unicast_ipv4);
1448     if (s->watch_legacy_unicast_ipv6)
1449         s->poll_api->watch_free(s->watch_legacy_unicast_ipv6);
1450
1451     /* Free sockets */
1452
1453     if (s->fd_ipv4 >= 0)
1454         close(s->fd_ipv4);
1455     if (s->fd_ipv6 >= 0)
1456         close(s->fd_ipv6);
1457
1458     if (s->fd_legacy_unicast_ipv4 >= 0)
1459         close(s->fd_legacy_unicast_ipv4);
1460     if (s->fd_legacy_unicast_ipv6 >= 0)
1461         close(s->fd_legacy_unicast_ipv6);
1462
1463     /* Free other stuff */
1464
1465     avahi_free(s->host_name);
1466     avahi_free(s->domain_name);
1467     avahi_free(s->host_name_fqdn);
1468
1469     avahi_server_config_free(&s->config);
1470
1471     avahi_free(s);
1472 }
1473
1474 const char* avahi_server_get_domain_name(AvahiServer *s) {
1475     assert(s);
1476
1477     return s->domain_name;
1478 }
1479
1480 const char* avahi_server_get_host_name(AvahiServer *s) {
1481     assert(s);
1482
1483     return s->host_name;
1484 }
1485
1486 const char* avahi_server_get_host_name_fqdn(AvahiServer *s) {
1487     assert(s);
1488
1489     return s->host_name_fqdn;
1490 }
1491
1492 void* avahi_server_get_data(AvahiServer *s) {
1493     assert(s);
1494
1495     return s->userdata;
1496 }
1497
1498 void avahi_server_set_data(AvahiServer *s, void* userdata) {
1499     assert(s);
1500
1501     s->userdata = userdata;
1502 }
1503
1504 AvahiServerState avahi_server_get_state(AvahiServer *s) {
1505     assert(s);
1506
1507     return s->state;
1508 }
1509
1510 AvahiServerConfig* avahi_server_config_init(AvahiServerConfig *c) {
1511     assert(c);
1512
1513     memset(c, 0, sizeof(AvahiServerConfig));
1514     c->use_ipv6 = 1;
1515     c->use_ipv4 = 1;
1516     c->host_name = NULL;
1517     c->domain_name = NULL;
1518     c->check_response_ttl = 0;
1519     c->publish_hinfo = 1;
1520     c->publish_addresses = 1;
1521     c->publish_workstation = 1;
1522     c->publish_domain = 1;
1523     c->use_iff_running = 0;
1524     c->enable_reflector = 0;
1525     c->reflect_ipv = 0;
1526     c->add_service_cookie = 1;
1527     c->enable_wide_area = 0;
1528     c->n_wide_area_servers = 0;
1529     c->disallow_other_stacks = 0;
1530
1531     return c;
1532 }
1533
1534 void avahi_server_config_free(AvahiServerConfig *c) {
1535     assert(c);
1536
1537     avahi_free(c->host_name);
1538     avahi_free(c->domain_name);
1539 }
1540
1541 AvahiServerConfig* avahi_server_config_copy(AvahiServerConfig *ret, const AvahiServerConfig *c) {
1542     char *d = NULL, *h = NULL;
1543     assert(ret);
1544     assert(c);
1545
1546     if (c->host_name)
1547         if (!(h = avahi_strdup(c->host_name)))
1548             return NULL;
1549
1550     if (c->domain_name)
1551         if (!(d = avahi_strdup(c->domain_name))) {
1552             avahi_free(h);
1553             return NULL;
1554         }
1555
1556     *ret = *c;
1557     ret->host_name = h;
1558     ret->domain_name = d;
1559
1560     return ret;
1561 }
1562
1563 int avahi_server_errno(AvahiServer *s) {
1564     assert(s);
1565
1566     return s->error;
1567 }
1568
1569 /* Just for internal use */
1570 int avahi_server_set_errno(AvahiServer *s, int error) {
1571     assert(s);
1572
1573     return s->error = error;
1574 }
1575
1576 uint32_t avahi_server_get_local_service_cookie(AvahiServer *s) {
1577     assert(s);
1578
1579     return s->local_service_cookie;
1580 }
1581
1582 static AvahiEntry *find_entry(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiKey *key) {
1583     AvahiEntry *e;
1584
1585     assert(s);
1586     assert(key);
1587
1588     for (e = avahi_hashmap_lookup(s->entries_by_key, key); e; e = e->by_key_next)
1589
1590         if ((e->interface == interface || e->interface <= 0 || interface <= 0) &&
1591             (e->protocol == protocol || e->protocol == AVAHI_PROTO_UNSPEC || protocol == AVAHI_PROTO_UNSPEC) &&
1592             (!e->group || e->group->state == AVAHI_ENTRY_GROUP_ESTABLISHED || e->group->state == AVAHI_ENTRY_GROUP_REGISTERING))
1593
1594             return e;
1595
1596     return NULL;
1597 }
1598
1599 int avahi_server_get_group_of_service(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, const char *name, const char *type, const char *domain, AvahiSEntryGroup** ret_group) {
1600     AvahiKey *key = NULL;
1601     AvahiEntry *e;
1602     int ret;
1603     char n[AVAHI_DOMAIN_NAME_MAX];
1604
1605     assert(s);
1606     assert(name);
1607     assert(type);
1608     assert(ret_group);
1609
1610     if (!AVAHI_IF_VALID(interface))
1611         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_INTERFACE);
1612
1613     if (!AVAHI_IF_VALID(protocol))
1614         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_PROTOCOL);
1615
1616     if (!avahi_is_valid_service_name(name))
1617         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_SERVICE_NAME);
1618
1619     if (!avahi_is_valid_service_type_strict(type))
1620         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_SERVICE_TYPE);
1621
1622     if (domain && !avahi_is_valid_domain_name(domain))
1623         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_DOMAIN_NAME);
1624
1625     if ((ret = avahi_service_name_join(n, sizeof(n), name, type, domain) < 0))
1626         return avahi_server_set_errno(s, ret);
1627
1628     if (!(key = avahi_key_new(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV)))
1629         return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
1630
1631     e = find_entry(s, interface, protocol, key);
1632     avahi_key_unref(key);
1633
1634     if (e) {
1635         *ret_group = e->group;
1636         return AVAHI_OK;
1637     }
1638
1639     return avahi_server_set_errno(s, AVAHI_ERR_NOT_FOUND);
1640 }
1641
1642 int avahi_server_is_service_local(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, const char *name) {
1643     AvahiKey *key = NULL;
1644     AvahiEntry *e;
1645
1646     assert(s);
1647     assert(name);
1648
1649     if (!s->host_name_fqdn)
1650         return 0;
1651
1652     if (!(key = avahi_key_new(name, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_SRV)))
1653         return 0;
1654
1655     e = find_entry(s, interface, protocol, key);
1656     avahi_key_unref(key);
1657
1658     if (!e)
1659         return 0;
1660
1661     return avahi_domain_equal(s->host_name_fqdn, e->record->data.srv.name);
1662 }
1663
1664 int avahi_server_is_record_local(AvahiServer *s, AvahiIfIndex interface, AvahiProtocol protocol, AvahiRecord *record) {
1665     AvahiEntry *e;
1666
1667     assert(s);
1668     assert(record);
1669
1670     for (e = avahi_hashmap_lookup(s->entries_by_key, record->key); e; e = e->by_key_next)
1671
1672         if ((e->interface == interface || e->interface <= 0 || interface <= 0) &&
1673             (e->protocol == protocol || e->protocol == AVAHI_PROTO_UNSPEC || protocol == AVAHI_PROTO_UNSPEC) &&
1674             (!e->group || e->group->state == AVAHI_ENTRY_GROUP_ESTABLISHED || e->group->state == AVAHI_ENTRY_GROUP_REGISTERING) &&
1675             avahi_record_equal_no_ttl(record, e->record))
1676             return 1;
1677
1678     return 0;
1679 }
1680
1681 /** Set the wide area DNS servers */
1682 int avahi_server_set_wide_area_servers(AvahiServer *s, const AvahiAddress *a, unsigned n) {
1683     assert(s);
1684
1685     if (!s->wide_area_lookup_engine)
1686         return avahi_server_set_errno(s, AVAHI_ERR_INVALID_CONFIG);
1687
1688     avahi_wide_area_set_servers(s->wide_area_lookup_engine, a, n);
1689     return AVAHI_OK;
1690 }