git.meshlink.io Git - catta/blob - src/server.c

   1 /***
   2   This file is part of catta.
   3
   4   catta is free software; you can redistribute it and/or modify it
   5   under the terms of the GNU Lesser General Public License as
   6   published by the Free Software Foundation; either version 2.1 of the
   7   License, or (at your option) any later version.
   8
   9   catta is distributed in the hope that it will be useful, but WITHOUT
  10   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  11   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  12   Public License for more details.
  13
  14   You should have received a copy of the GNU Lesser General Public
  15   License along with catta; if not, write to the Free Software
  16   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  17   USA.
  18 ***/
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <sys/types.h>
  25 #include <sys/socket.h>
  26 #include <netinet/in.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 <catta/domain.h>
  37 #include <catta/timeval.h>
  38 #include <catta/malloc.h>
  39 #include <catta/error.h>
  40 #include <catta/log.h>
  41
  42 #include "internal.h"
  43 #include "iface.h"
  44 #include "socket.h"
  45 #include "browse.h"
  46 #include "util.h"
  47 #include "dns-srv-rr.h"
  48 #include "addr-util.h"
  49 #include "domain-util.h"
  50 #include "rr-util.h"
  51
  52 #define CATTA_DEFAULT_CACHE_ENTRIES_MAX 4096
  53
  54 static void enum_aux_records(CattaServer *s, CattaInterface *i, const char *name, uint16_t type, void (*callback)(CattaServer *s, CattaRecord *r, int flush_cache, void* userdata), void* userdata) {
  55     assert(s);
  56     assert(i);
  57     assert(name);
  58     assert(callback);
  59
  60     if (type == CATTA_DNS_TYPE_ANY) {
  61         CattaEntry *e;
  62
  63         for (e = s->entries; e; e = e->entries_next)
  64             if (!e->dead &&
  65                 catta_entry_is_registered(s, e, i) &&
  66                 e->record->key->clazz == CATTA_DNS_CLASS_IN &&
  67                 catta_domain_equal(name, e->record->key->name))
  68                 callback(s, e->record, e->flags & CATTA_PUBLISH_UNIQUE, userdata);
  69
  70     } else {
  71         CattaEntry *e;
  72         CattaKey *k;
  73
  74         if (!(k = catta_key_new(name, CATTA_DNS_CLASS_IN, type)))
  75             return; /** OOM */
  76
  77         for (e = catta_hashmap_lookup(s->entries_by_key, k); e; e = e->by_key_next)
  78             if (!e->dead && catta_entry_is_registered(s, e, i))
  79                 callback(s, e->record, e->flags & CATTA_PUBLISH_UNIQUE, userdata);
  80
  81         catta_key_unref(k);
  82     }
  83 }
  84
  85 void catta_server_enumerate_aux_records(CattaServer *s, CattaInterface *i, CattaRecord *r, void (*callback)(CattaServer *s, CattaRecord *r, int flush_cache, void* userdata), void* userdata) {
  86     assert(s);
  87     assert(i);
  88     assert(r);
  89     assert(callback);
  90
  91     /* Call the specified callback far all records referenced by the one specified in *r */
  92
  93     if (r->key->clazz == CATTA_DNS_CLASS_IN) {
  94         if (r->key->type == CATTA_DNS_TYPE_PTR) {
  95             enum_aux_records(s, i, r->data.ptr.name, CATTA_DNS_TYPE_SRV, callback, userdata);
  96             enum_aux_records(s, i, r->data.ptr.name, CATTA_DNS_TYPE_TXT, callback, userdata);
  97         } else if (r->key->type == CATTA_DNS_TYPE_SRV) {
  98             enum_aux_records(s, i, r->data.srv.name, CATTA_DNS_TYPE_A, callback, userdata);
  99             enum_aux_records(s, i, r->data.srv.name, CATTA_DNS_TYPE_AAAA, callback, userdata);
 100         } else if (r->key->type == CATTA_DNS_TYPE_CNAME)
 101             enum_aux_records(s, i, r->data.cname.name, CATTA_DNS_TYPE_ANY, callback, userdata);
 102     }
 103 }
 104
 105 void catta_server_prepare_response(CattaServer *s, CattaInterface *i, CattaEntry *e, int unicast_response, int auxiliary) {
 106     assert(s);
 107     assert(i);
 108     assert(e);
 109
 110     catta_record_list_push(s->record_list, e->record, e->flags & CATTA_PUBLISH_UNIQUE, unicast_response, auxiliary);
 111 }
 112
 113 void catta_server_prepare_matching_responses(CattaServer *s, CattaInterface *i, CattaKey *k, int unicast_response) {
 114     assert(s);
 115     assert(i);
 116     assert(k);
 117
 118     /* Push all records that match the specified key to the record list */
 119
 120     if (catta_key_is_pattern(k)) {
 121         CattaEntry *e;
 122
 123         /* Handle ANY query */
 124
 125         for (e = s->entries; e; e = e->entries_next)
 126             if (!e->dead && catta_key_pattern_match(k, e->record->key) && catta_entry_is_registered(s, e, i))
 127                 catta_server_prepare_response(s, i, e, unicast_response, 0);
 128
 129     } else {
 130         CattaEntry *e;
 131
 132         /* Handle all other queries */
 133
 134         for (e = catta_hashmap_lookup(s->entries_by_key, k); e; e = e->by_key_next)
 135             if (!e->dead && catta_entry_is_registered(s, e, i))
 136                 catta_server_prepare_response(s, i, e, unicast_response, 0);
 137     }
 138
 139     /* Look for CNAME records */
 140
 141     if ((k->clazz == CATTA_DNS_CLASS_IN || k->clazz == CATTA_DNS_CLASS_ANY)
 142         && k->type != CATTA_DNS_TYPE_CNAME && k->type != CATTA_DNS_TYPE_ANY) {
 143
 144         CattaKey *cname_key;
 145
 146         if (!(cname_key = catta_key_new(k->name, CATTA_DNS_CLASS_IN, CATTA_DNS_TYPE_CNAME)))
 147             return;
 148
 149         catta_server_prepare_matching_responses(s, i, cname_key, unicast_response);
 150         catta_key_unref(cname_key);
 151     }
 152 }
 153
 154 static void withdraw_entry(CattaServer *s, CattaEntry *e) {
 155     assert(s);
 156     assert(e);
 157
 158     /* Withdraw the specified entry, and if is part of an entry group,
 159      * put that into COLLISION state */
 160
 161     if (e->dead)
 162         return;
 163
 164     if (e->group) {
 165         CattaEntry *k;
 166
 167         for (k = e->group->entries; k; k = k->by_group_next)
 168             if (!k->dead) {
 169                 catta_goodbye_entry(s, k, 0, 1);
 170                 k->dead = 1;
 171             }
 172
 173         e->group->n_probing = 0;
 174
 175         catta_s_entry_group_change_state(e->group, CATTA_ENTRY_GROUP_COLLISION);
 176     } else {
 177         catta_goodbye_entry(s, e, 0, 1);
 178         e->dead = 1;
 179     }
 180
 181     s->need_entry_cleanup = 1;
 182 }
 183
 184 static void withdraw_rrset(CattaServer *s, CattaKey *key) {
 185     CattaEntry *e;
 186
 187     assert(s);
 188     assert(key);
 189
 190     /* Withdraw an entry RRSset */
 191
 192     for (e = catta_hashmap_lookup(s->entries_by_key, key); e; e = e->by_key_next)
 193         withdraw_entry(s, e);
 194 }
 195
 196 static void incoming_probe(CattaServer *s, CattaRecord *record, CattaInterface *i) {
 197     CattaEntry *e, *n;
 198     int ours = 0, won = 0, lost = 0;
 199
 200     assert(s);
 201     assert(record);
 202     assert(i);
 203
 204     /* Handle incoming probes and check if they conflict our own probes */
 205
 206     for (e = catta_hashmap_lookup(s->entries_by_key, record->key); e; e = n) {
 207         int cmp;
 208         n = e->by_key_next;
 209
 210         if (e->dead)
 211             continue;
 212
 213         if ((cmp = catta_record_lexicographical_compare(e->record, record)) == 0) {
 214             ours = 1;
 215             break;
 216         } else {
 217
 218             if (catta_entry_is_probing(s, e, i)) {
 219                 if (cmp > 0)
 220                     won = 1;
 221                 else /* cmp < 0 */
 222                     lost = 1;
 223             }
 224         }
 225     }
 226
 227     if (!ours) {
 228         char *t = catta_record_to_string(record);
 229
 230         if (won)
 231             catta_log_debug("Received conflicting probe [%s]. Local host won.", t);
 232         else if (lost) {
 233             catta_log_debug("Received conflicting probe [%s]. Local host lost. Withdrawing.", t);
 234             withdraw_rrset(s, record->key);
 235         }
 236
 237         catta_free(t);
 238     }
 239 }
 240
 241 static int handle_conflict(CattaServer *s, CattaInterface *i, CattaRecord *record, int unique) {
 242     int valid = 1, ours = 0, conflict = 0, withdraw_immediately = 0;
 243     CattaEntry *e, *n, *conflicting_entry = NULL;
 244
 245     assert(s);
 246     assert(i);
 247     assert(record);
 248
 249     /* Check whether an incoming record conflicts with one of our own */
 250
 251     for (e = catta_hashmap_lookup(s->entries_by_key, record->key); e; e = n) {
 252         n = e->by_key_next;
 253
 254         if (e->dead)
 255             continue;
 256
 257         /* Check if the incoming is a goodbye record */
 258         if (catta_record_is_goodbye(record)) {
 259
 260             if (catta_record_equal_no_ttl(e->record, record)) {
 261                 char *t;
 262
 263                 /* Refresh */
 264                 t = catta_record_to_string(record);
 265                 catta_log_debug("Received goodbye record for one of our records [%s]. Refreshing.", t);
 266                 catta_server_prepare_matching_responses(s, i, e->record->key, 0);
 267
 268                 valid = 0;
 269                 catta_free(t);
 270                 break;
 271             }
 272
 273             /* If the goodybe packet doesn't match one of our own RRs, we simply ignore it. */
 274             continue;
 275         }
 276
 277         if (!(e->flags & CATTA_PUBLISH_UNIQUE) && !unique)
 278             continue;
 279
 280         /* Either our entry or the other is intended to be unique, so let's check */
 281
 282         if (catta_record_equal_no_ttl(e->record, record)) {
 283             ours = 1; /* We have an identical record, so this is no conflict */
 284
 285             /* Check wheter there is a TTL conflict */
 286             if (record->ttl <= e->record->ttl/2 &&
 287                 catta_entry_is_registered(s, e, i)) {
 288                 char *t;
 289                 /* Refresh */
 290                 t = catta_record_to_string(record);
 291
 292                 catta_log_debug("Received record with bad TTL [%s]. Refreshing.", t);
 293                 catta_server_prepare_matching_responses(s, i, e->record->key, 0);
 294                 valid = 0;
 295
 296                 catta_free(t);
 297             }
 298
 299             /* There's no need to check the other entries of this RRset */
 300             break;
 301
 302         } else {
 303
 304             if (catta_entry_is_registered(s, e, i)) {
 305
 306                 /* A conflict => we have to return to probe mode */
 307                 conflict = 1;
 308                 conflicting_entry = e;
 309
 310             } else if (catta_entry_is_probing(s, e, i)) {
 311
 312                 /* We are currently registering a matching record, but
 313                  * someone else already claimed it, so let's
 314                  * withdraw */
 315                 conflict = 1;
 316                 withdraw_immediately = 1;
 317             }
 318         }
 319     }
 320
 321     if (!ours && conflict) {
 322         char *t;
 323
 324         valid = 0;
 325
 326         t = catta_record_to_string(record);
 327
 328         if (withdraw_immediately) {
 329             catta_log_debug("Received conflicting record [%s] with local record to be. Withdrawing.", t);
 330             withdraw_rrset(s, record->key);
 331         } else {
 332             assert(conflicting_entry);
 333             catta_log_debug("Received conflicting record [%s]. Resetting our record.", t);
 334             catta_entry_return_to_initial_state(s, conflicting_entry, i);
 335
 336             /* Local unique records are returned to probing
 337              * state. Local shared records are reannounced. */
 338         }
 339
 340         catta_free(t);
 341     }
 342
 343     return valid;
 344 }
 345
 346 static void append_aux_callback(CattaServer *s, CattaRecord *r, int flush_cache, void* userdata) {
 347     int *unicast_response = userdata;
 348
 349     assert(s);
 350     assert(r);
 351     assert(unicast_response);
 352
 353     catta_record_list_push(s->record_list, r, flush_cache, *unicast_response, 1);
 354 }
 355
 356 static void append_aux_records_to_list(CattaServer *s, CattaInterface *i, CattaRecord *r, int unicast_response) {
 357     assert(s);
 358     assert(r);
 359
 360     catta_server_enumerate_aux_records(s, i, r, append_aux_callback, &unicast_response);
 361 }
 362
 363 void catta_server_generate_response(CattaServer *s, CattaInterface *i, CattaDnsPacket *p, const CattaAddress *a, uint16_t port, int legacy_unicast, int immediately) {
 364
 365     assert(s);
 366     assert(i);
 367     assert(!legacy_unicast || (a && port > 0 && p));
 368
 369     if (legacy_unicast) {
 370         CattaDnsPacket *reply;
 371         CattaRecord *r;
 372
 373         if (!(reply = catta_dns_packet_new_reply(p, 512 + CATTA_DNS_PACKET_EXTRA_SIZE /* unicast DNS maximum packet size is 512 */ , 1, 1)))
 374             return; /* OOM */
 375
 376         while ((r = catta_record_list_next(s->record_list, NULL, NULL, NULL))) {
 377
 378             append_aux_records_to_list(s, i, r, 0);
 379
 380             if (catta_dns_packet_append_record(reply, r, 0, 10))
 381                 catta_dns_packet_inc_field(reply, CATTA_DNS_FIELD_ANCOUNT);
 382             else {
 383                 char *t = catta_record_to_string(r);
 384                 catta_log_warn("Record [%s] not fitting in legacy unicast packet, dropping.", t);
 385                 catta_free(t);
 386             }
 387
 388             catta_record_unref(r);
 389         }
 390
 391         if (catta_dns_packet_get_field(reply, CATTA_DNS_FIELD_ANCOUNT) != 0)
 392             catta_interface_send_packet_unicast(i, reply, a, port);
 393
 394         catta_dns_packet_free(reply);
 395
 396     } else {
 397         int unicast_response, flush_cache, auxiliary;
 398         CattaDnsPacket *reply = NULL;
 399         CattaRecord *r;
 400
 401         /* In case the query packet was truncated never respond
 402         immediately, because known answer suppression records might be
 403         contained in later packets */
 404         int tc = p && !!(catta_dns_packet_get_field(p, CATTA_DNS_FIELD_FLAGS) & CATTA_DNS_FLAG_TC);
 405
 406         while ((r = catta_record_list_next(s->record_list, &flush_cache, &unicast_response, &auxiliary))) {
 407
 408             int im = immediately;
 409
 410             /* Only send the response immediately if it contains a
 411              * unique entry AND it is not in reply to a truncated
 412              * packet AND it is not an auxiliary record AND all other
 413              * responses for this record are unique too. */
 414
 415             if (flush_cache && !tc && !auxiliary && catta_record_list_all_flush_cache(s->record_list))
 416                 im = 1;
 417
 418             if (!catta_interface_post_response(i, r, flush_cache, a, im) && unicast_response) {
 419
 420                 /* Due to some reasons the record has not been scheduled.
 421                  * The client requested an unicast response in that
 422                  * case. Therefore we prepare such a response */
 423
 424                 append_aux_records_to_list(s, i, r, unicast_response);
 425
 426                 for (;;) {
 427
 428                     if (!reply) {
 429                         assert(p);
 430
 431                         if (!(reply = catta_dns_packet_new_reply(p, i->hardware->mtu, 0, 0)))
 432                             break; /* OOM */
 433                     }
 434
 435                     if (catta_dns_packet_append_record(reply, r, flush_cache, 0)) {
 436
 437                         /* Appending this record succeeded, so incremeant
 438                          * the specific header field, and return to the caller */
 439
 440                         catta_dns_packet_inc_field(reply, CATTA_DNS_FIELD_ANCOUNT);
 441                         break;
 442                     }
 443
 444                     if (catta_dns_packet_get_field(reply, CATTA_DNS_FIELD_ANCOUNT) == 0) {
 445                         size_t size;
 446
 447                         /* The record is too large for one packet, so create a larger packet */
 448
 449                         catta_dns_packet_free(reply);
 450                         size = catta_record_get_estimate_size(r) + CATTA_DNS_PACKET_HEADER_SIZE;
 451
 452                         if (!(reply = catta_dns_packet_new_reply(p, size + CATTA_DNS_PACKET_EXTRA_SIZE, 0, 1)))
 453                             break; /* OOM */
 454
 455                         if (catta_dns_packet_append_record(reply, r, flush_cache, 0)) {
 456
 457                             /* Appending this record succeeded, so incremeant
 458                              * the specific header field, and return to the caller */
 459
 460                             catta_dns_packet_inc_field(reply, CATTA_DNS_FIELD_ANCOUNT);
 461                             break;
 462
 463                         }  else {
 464
 465                             /* We completely fucked up, there's
 466                              * nothing we can do. The RR just doesn't
 467                              * fit in. Let's ignore it. */
 468
 469                             char *t;
 470                             catta_dns_packet_free(reply);
 471                             reply = NULL;
 472                             t = catta_record_to_string(r);
 473                             catta_log_warn("Record [%s] too large, doesn't fit in any packet!", t);
 474                             catta_free(t);
 475                             break;
 476                         }
 477                     }
 478
 479                     /* Appending the record didn't succeeed, so let's send this packet, and create a new one */
 480                     catta_interface_send_packet_unicast(i, reply, a, port);
 481                     catta_dns_packet_free(reply);
 482                     reply = NULL;
 483                 }
 484             }
 485
 486             catta_record_unref(r);
 487         }
 488
 489         if (reply) {
 490             if (catta_dns_packet_get_field(reply, CATTA_DNS_FIELD_ANCOUNT) != 0)
 491                 catta_interface_send_packet_unicast(i, reply, a, port);
 492             catta_dns_packet_free(reply);
 493         }
 494     }
 495
 496     catta_record_list_flush(s->record_list);
 497 }
 498
 499 static void reflect_response(CattaServer *s, CattaInterface *i, CattaRecord *r, int flush_cache) {
 500     CattaInterface *j;
 501
 502     assert(s);
 503     assert(i);
 504     assert(r);
 505
 506     if (!s->config.enable_reflector)
 507         return;
 508
 509     for (j = s->monitor->interfaces; j; j = j->iface_next)
 510         if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol))
 511             catta_interface_post_response(j, r, flush_cache, NULL, 1);
 512 }
 513
 514 static void* reflect_cache_walk_callback(CattaCache *c, CattaKey *pattern, CattaCacheEntry *e, void* userdata) {
 515     CattaServer *s = userdata;
 516     CattaRecord* r;
 517
 518     assert(c);
 519     assert(pattern);
 520     assert(e);
 521     assert(s);
 522
 523     /* Don't reflect cache entry with ipv6 link-local addresses. */
 524     r = e->record;
 525     if ((r->key->type == CATTA_DNS_TYPE_AAAA) &&
 526             (r->data.aaaa.address.address[0] == 0xFE) &&
 527             (r->data.aaaa.address.address[1] == 0x80))
 528       return NULL;
 529
 530     catta_record_list_push(s->record_list, e->record, e->cache_flush, 0, 0);
 531     return NULL;
 532 }
 533
 534 static void reflect_query(CattaServer *s, CattaInterface *i, CattaKey *k) {
 535     CattaInterface *j;
 536
 537     assert(s);
 538     assert(i);
 539     assert(k);
 540
 541     if (!s->config.enable_reflector)
 542         return;
 543
 544     for (j = s->monitor->interfaces; j; j = j->iface_next)
 545         if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol)) {
 546             /* Post the query to other networks */
 547             catta_interface_post_query(j, k, 1, NULL);
 548
 549             /* Reply from caches of other network. This is needed to
 550              * "work around" known answer suppression. */
 551
 552             catta_cache_walk(j->cache, k, reflect_cache_walk_callback, s);
 553         }
 554 }
 555
 556 static void reflect_probe(CattaServer *s, CattaInterface *i, CattaRecord *r) {
 557     CattaInterface *j;
 558
 559     assert(s);
 560     assert(i);
 561     assert(r);
 562
 563     if (!s->config.enable_reflector)
 564         return;
 565
 566     for (j = s->monitor->interfaces; j; j = j->iface_next)
 567         if (j != i && (s->config.reflect_ipv || j->protocol == i->protocol))
 568             catta_interface_post_probe(j, r, 1);
 569 }
 570
 571 static void handle_query_packet(CattaServer *s, CattaDnsPacket *p, CattaInterface *i, const CattaAddress *a, uint16_t port, int legacy_unicast, int from_local_iface) {
 572     size_t n;
 573     int is_probe;
 574
 575     assert(s);
 576     assert(p);
 577     assert(i);
 578     assert(a);
 579
 580     assert(catta_record_list_is_empty(s->record_list));
 581
 582     is_probe = catta_dns_packet_get_field(p, CATTA_DNS_FIELD_NSCOUNT) > 0;
 583
 584     /* Handle the questions */
 585     for (n = catta_dns_packet_get_field(p, CATTA_DNS_FIELD_QDCOUNT); n > 0; n --) {
 586         CattaKey *key;
 587         int unicast_response = 0;
 588
 589         if (!(key = catta_dns_packet_consume_key(p, &unicast_response))) {
 590             catta_log_warn(__FILE__": Packet too short or invalid while reading question key. (Maybe a UTF-8 problem?)");
 591             goto fail;
 592         }
 593
 594         if (!legacy_unicast && !from_local_iface) {
 595             reflect_query(s, i, key);
 596             if (!unicast_response)
 597               catta_cache_start_poof(i->cache, key, a);
 598         }
 599
 600         if (catta_dns_packet_get_field(p, CATTA_DNS_FIELD_ANCOUNT) == 0 &&
 601             !(catta_dns_packet_get_field(p, CATTA_DNS_FIELD_FLAGS) & CATTA_DNS_FLAG_TC))
 602             /* Allow our own queries to be suppressed by incoming
 603              * queries only when they do not include known answers */
 604             catta_query_scheduler_incoming(i->query_scheduler, key);
 605
 606         catta_server_prepare_matching_responses(s, i, key, unicast_response);
 607         catta_key_unref(key);
 608     }
 609
 610     if (!legacy_unicast) {
 611
 612         /* Known Answer Suppression */
 613         for (n = catta_dns_packet_get_field(p, CATTA_DNS_FIELD_ANCOUNT); n > 0; n --) {
 614             CattaRecord *record;
 615             int unique = 0;
 616
 617             if (!(record = catta_dns_packet_consume_record(p, &unique))) {
 618                 catta_log_warn(__FILE__": Packet too short or invalid while reading known answer record. (Maybe a UTF-8 problem?)");
 619                 goto fail;
 620             }
 621
 622             catta_response_scheduler_suppress(i->response_scheduler, record, a);
 623             catta_record_list_drop(s->record_list, record);
 624             catta_cache_stop_poof(i->cache, record, a);
 625
 626             catta_record_unref(record);
 627         }
 628
 629         /* Probe record */
 630         for (n = catta_dns_packet_get_field(p, CATTA_DNS_FIELD_NSCOUNT); n > 0; n --) {
 631             CattaRecord *record;
 632             int unique = 0;
 633
 634             if (!(record = catta_dns_packet_consume_record(p, &unique))) {
 635                 catta_log_warn(__FILE__": Packet too short or invalid while reading probe record. (Maybe a UTF-8 problem?)");
 636                 goto fail;
 637             }
 638
 639             if (!catta_key_is_pattern(record->key)) {
 640                 if (!from_local_iface)
 641                     reflect_probe(s, i, record);
 642                 incoming_probe(s, record, i);
 643             }
 644
 645             catta_record_unref(record);
 646         }
 647     }
 648
 649     if (!catta_record_list_is_empty(s->record_list))
 650         catta_server_generate_response(s, i, p, a, port, legacy_unicast, is_probe);
 651
 652     return;
 653
 654 fail:
 655     catta_record_list_flush(s->record_list);
 656 }
 657
 658 static void handle_response_packet(CattaServer *s, CattaDnsPacket *p, CattaInterface *i, const CattaAddress *a, int from_local_iface) {
 659     unsigned n;
 660
 661     assert(s);
 662     assert(p);
 663     assert(i);
 664     assert(a);
 665
 666     for (n = catta_dns_packet_get_field(p, CATTA_DNS_FIELD_ANCOUNT) +
 667              catta_dns_packet_get_field(p, CATTA_DNS_FIELD_ARCOUNT); n > 0; n--) {
 668         CattaRecord *record;
 669         int cache_flush = 0;
 670
 671         if (!(record = catta_dns_packet_consume_record(p, &cache_flush))) {
 672             catta_log_warn(__FILE__": Packet too short or invalid while reading response record. (Maybe a UTF-8 problem?)");
 673             break;
 674         }
 675
 676         if (!catta_key_is_pattern(record->key)) {
 677
 678             if (handle_conflict(s, i, record, cache_flush)) {
 679                 if (!from_local_iface && !catta_record_is_link_local_address(record))
 680                     reflect_response(s, i, record, cache_flush);
 681                 catta_cache_update(i->cache, record, cache_flush, a);
 682                 catta_response_scheduler_incoming(i->response_scheduler, record, cache_flush);
 683             }
 684         }
 685
 686         catta_record_unref(record);
 687     }
 688
 689     /* If the incoming response contained a conflicting record, some
 690        records have been scheduled for sending. We need to flush them
 691        here. */
 692     if (!catta_record_list_is_empty(s->record_list))
 693         catta_server_generate_response(s, i, NULL, NULL, 0, 0, 1);
 694 }
 695
 696 static CattaLegacyUnicastReflectSlot* allocate_slot(CattaServer *s) {
 697     unsigned n, idx = (unsigned) -1;
 698     CattaLegacyUnicastReflectSlot *slot;
 699
 700     assert(s);
 701
 702     if (!s->legacy_unicast_reflect_slots)
 703         s->legacy_unicast_reflect_slots = catta_new0(CattaLegacyUnicastReflectSlot*, CATTA_LEGACY_UNICAST_REFLECT_SLOTS_MAX);
 704
 705     for (n = 0; n < CATTA_LEGACY_UNICAST_REFLECT_SLOTS_MAX; n++, s->legacy_unicast_reflect_id++) {
 706         idx = s->legacy_unicast_reflect_id % CATTA_LEGACY_UNICAST_REFLECT_SLOTS_MAX;
 707
 708         if (!s->legacy_unicast_reflect_slots[idx])
 709             break;
 710     }
 711
 712     if (idx == (unsigned) -1 || s->legacy_unicast_reflect_slots[idx])
 713         return NULL;
 714
 715     if (!(slot = catta_new(CattaLegacyUnicastReflectSlot, 1)))
 716         return NULL; /* OOM */
 717
 718     s->legacy_unicast_reflect_slots[idx] = slot;
 719     slot->id = s->legacy_unicast_reflect_id++;
 720     slot->server = s;
 721
 722     return slot;
 723 }
 724
 725 static void deallocate_slot(CattaServer *s, CattaLegacyUnicastReflectSlot *slot) {
 726     unsigned idx;
 727
 728     assert(s);
 729     assert(slot);
 730
 731     idx = slot->id % CATTA_LEGACY_UNICAST_REFLECT_SLOTS_MAX;
 732
 733     assert(s->legacy_unicast_reflect_slots[idx] == slot);
 734
 735     catta_time_event_free(slot->time_event);
 736
 737     catta_free(slot);
 738     s->legacy_unicast_reflect_slots[idx] = NULL;
 739 }
 740
 741 static void free_slots(CattaServer *s) {
 742     unsigned idx;
 743     assert(s);
 744
 745     if (!s->legacy_unicast_reflect_slots)
 746         return;
 747
 748     for (idx = 0; idx < CATTA_LEGACY_UNICAST_REFLECT_SLOTS_MAX; idx ++)
 749         if (s->legacy_unicast_reflect_slots[idx])
 750             deallocate_slot(s, s->legacy_unicast_reflect_slots[idx]);
 751
 752     catta_free(s->legacy_unicast_reflect_slots);
 753     s->legacy_unicast_reflect_slots = NULL;
 754 }
 755
 756 static CattaLegacyUnicastReflectSlot* find_slot(CattaServer *s, uint16_t id) {
 757     unsigned idx;
 758
 759     assert(s);
 760
 761     if (!s->legacy_unicast_reflect_slots)
 762         return NULL;
 763
 764     idx = id % CATTA_LEGACY_UNICAST_REFLECT_SLOTS_MAX;
 765
 766     if (!s->legacy_unicast_reflect_slots[idx] || s->legacy_unicast_reflect_slots[idx]->id != id)
 767         return NULL;
 768
 769     return s->legacy_unicast_reflect_slots[idx];
 770 }
 771
 772 static void legacy_unicast_reflect_slot_timeout(CattaTimeEvent *e, void *userdata) {
 773     CattaLegacyUnicastReflectSlot *slot = userdata;
 774
 775     assert(e);
 776     assert(slot);
 777     assert(slot->time_event == e);
 778
 779     deallocate_slot(slot->server, slot);
 780 }
 781
 782 static void reflect_legacy_unicast_query_packet(CattaServer *s, CattaDnsPacket *p, CattaInterface *i, const CattaAddress *a, uint16_t port) {
 783     CattaLegacyUnicastReflectSlot *slot;
 784     CattaInterface *j;
 785
 786     assert(s);
 787     assert(p);
 788     assert(i);
 789     assert(a);
 790     assert(port > 0);
 791     assert(i->protocol == a->proto);
 792
 793     if (!s->config.enable_reflector)
 794         return;
 795
 796     /* Reflecting legacy unicast queries is a little more complicated
 797        than reflecting normal queries, since we must route the
 798        responses back to the right client. Therefore we must store
 799        some information for finding the right client contact data for
 800        response packets. In contrast to normal queries legacy
 801        unicast query and response packets are reflected untouched and
 802        are not reassembled into larger packets */
 803
 804     if (!(slot = allocate_slot(s))) {
 805         /* No slot available, we drop this legacy unicast query */
 806         catta_log_warn("No slot available for legacy unicast reflection, dropping query packet.");
 807         return;
 808     }
 809
 810     slot->original_id = catta_dns_packet_get_field(p, CATTA_DNS_FIELD_ID);
 811     slot->address = *a;
 812     slot->port = port;
 813     slot->iface = i->hardware->index;
 814
 815     catta_elapse_time(&slot->elapse_time, 2000, 0);
 816     slot->time_event = catta_time_event_new(s->time_event_queue, &slot->elapse_time, legacy_unicast_reflect_slot_timeout, slot);
 817
 818     /* Patch the packet with our new locally generatet id */
 819     catta_dns_packet_set_field(p, CATTA_DNS_FIELD_ID, slot->id);
 820
 821     for (j = s->monitor->interfaces; j; j = j->iface_next)
 822         if (j->announcing &&
 823             j != i &&
 824             (s->config.reflect_ipv || j->protocol == i->protocol)) {
 825
 826             if (j->protocol == CATTA_PROTO_INET && s->fd_legacy_unicast_ipv4 >= 0) {
 827                 catta_send_dns_packet_ipv4(s->fd_legacy_unicast_ipv4, j->hardware->index, p, NULL, NULL, 0);
 828             } else if (j->protocol == CATTA_PROTO_INET6 && s->fd_legacy_unicast_ipv6 >= 0)
 829                 catta_send_dns_packet_ipv6(s->fd_legacy_unicast_ipv6, j->hardware->index, p, NULL, NULL, 0);
 830         }
 831
 832     /* Reset the id */
 833     catta_dns_packet_set_field(p, CATTA_DNS_FIELD_ID, slot->original_id);
 834 }
 835
 836 static int originates_from_local_legacy_unicast_socket(CattaServer *s, const CattaAddress *address, uint16_t port) {
 837     assert(s);
 838     assert(address);
 839     assert(port > 0);
 840
 841     if (!s->config.enable_reflector)
 842         return 0;
 843
 844     if (!catta_address_is_local(s->monitor, address))
 845         return 0;
 846
 847     if (address->proto == CATTA_PROTO_INET && s->fd_legacy_unicast_ipv4 >= 0) {
 848         struct sockaddr_in lsa;
 849         socklen_t l = sizeof(lsa);
 850
 851         if (getsockname(s->fd_legacy_unicast_ipv4, (struct sockaddr*) &lsa, &l) != 0)
 852             catta_log_warn("getsockname(): %s", strerror(errno));
 853         else
 854             return catta_port_from_sockaddr((struct sockaddr*) &lsa) == port;
 855
 856     }
 857
 858     if (address->proto == CATTA_PROTO_INET6 && s->fd_legacy_unicast_ipv6 >= 0) {
 859         struct sockaddr_in6 lsa;
 860         socklen_t l = sizeof(lsa);
 861
 862         if (getsockname(s->fd_legacy_unicast_ipv6, (struct sockaddr*) &lsa, &l) != 0)
 863             catta_log_warn("getsockname(): %s", strerror(errno));
 864         else
 865             return catta_port_from_sockaddr((struct sockaddr*) &lsa) == port;
 866     }
 867
 868     return 0;
 869 }
 870
 871 static int is_mdns_mcast_address(const CattaAddress *a) {
 872     CattaAddress b;
 873     assert(a);
 874
 875     catta_address_parse(a->proto == CATTA_PROTO_INET ? CATTA_IPV4_MCAST_GROUP : CATTA_IPV6_MCAST_GROUP, a->proto, &b);
 876     return catta_address_cmp(a, &b) == 0;
 877 }
 878
 879 static int originates_from_local_iface(CattaServer *s, CattaIfIndex iface, const CattaAddress *a, uint16_t port) {
 880     assert(s);
 881     assert(iface != CATTA_IF_UNSPEC);
 882     assert(a);
 883
 884     /* If it isn't the MDNS port it can't be generated by us */
 885     if (port != CATTA_MDNS_PORT)
 886         return 0;
 887
 888     return catta_interface_has_address(s->monitor, iface, a);
 889 }
 890
 891 static void dispatch_packet(CattaServer *s, CattaDnsPacket *p, const CattaAddress *src_address, uint16_t port, const CattaAddress *dst_address, CattaIfIndex iface, int ttl) {
 892     CattaInterface *i;
 893     int from_local_iface = 0;
 894
 895     assert(s);
 896     assert(p);
 897     assert(src_address);
 898     assert(dst_address);
 899     assert(iface > 0);
 900     assert(src_address->proto == dst_address->proto);
 901
 902     if (!(i = catta_interface_monitor_get_interface(s->monitor, iface, src_address->proto)) ||
 903         !i->announcing) {
 904         catta_log_warn("Received packet from invalid interface.");
 905         return;
 906     }
 907
 908     if (port <= 0) {
 909         /* This fixes RHBZ #475394 */
 910         catta_log_warn("Received packet from invalid source port %u.", (unsigned) port);
 911         return;
 912     }
 913
 914     if (catta_address_is_ipv4_in_ipv6(src_address))
 915         /* This is an IPv4 address encapsulated in IPv6, so let's ignore it. */
 916         return;
 917
 918     if (originates_from_local_legacy_unicast_socket(s, src_address, port))
 919         /* This originates from our local reflector, so let's ignore it */
 920         return;
 921
 922     /* We don't want to reflect local traffic, so we check if this packet is generated locally. */
 923     if (s->config.enable_reflector)
 924         from_local_iface = originates_from_local_iface(s, iface, src_address, port);
 925
 926     if (catta_dns_packet_check_valid_multicast(p) < 0) {
 927         catta_log_warn("Received invalid packet.");
 928         return;
 929     }
 930
 931     if (catta_dns_packet_is_query(p)) {
 932         int legacy_unicast = 0;
 933
 934         /* For queries EDNS0 might allow ARCOUNT != 0. We ignore the
 935          * AR section completely here, so far. Until the day we add
 936          * EDNS0 support. */
 937
 938         if (port != CATTA_MDNS_PORT) {
 939             /* Legacy Unicast */
 940
 941             if ((catta_dns_packet_get_field(p, CATTA_DNS_FIELD_ANCOUNT) != 0 ||
 942                  catta_dns_packet_get_field(p, CATTA_DNS_FIELD_NSCOUNT) != 0)) {
 943                 catta_log_warn("Invalid legacy unicast query packet.");
 944                 return;
 945             }
 946
 947             legacy_unicast = 1;
 948         }
 949
 950         if (legacy_unicast)
 951             reflect_legacy_unicast_query_packet(s, p, i, src_address, port);
 952
 953         handle_query_packet(s, p, i, src_address, port, legacy_unicast, from_local_iface);
 954
 955     } else {
 956         char t[CATTA_ADDRESS_STR_MAX];
 957
 958         if (port != CATTA_MDNS_PORT) {
 959             catta_log_warn("Received response from host %s with invalid source port %u on interface '%s.%i'", catta_address_snprint(t, sizeof(t), src_address), port, i->hardware->name, i->protocol);
 960             return;
 961         }
 962
 963         if (ttl != 255 && s->config.check_response_ttl) {
 964             catta_log_warn("Received response from host %s with invalid TTL %u on interface '%s.%i'.", catta_address_snprint(t, sizeof(t), src_address), ttl, i->hardware->name, i->protocol);
 965             return;
 966         }
 967
 968         if (!is_mdns_mcast_address(dst_address) &&
 969             !catta_interface_address_on_link(i, src_address)) {
 970
 971             catta_log_warn("Received non-local response from host %s on interface '%s.%i'.", catta_address_snprint(t, sizeof(t), src_address), i->hardware->name, i->protocol);
 972             return;
 973         }
 974
 975         if (catta_dns_packet_get_field(p, CATTA_DNS_FIELD_QDCOUNT) != 0 ||
 976             catta_dns_packet_get_field(p, CATTA_DNS_FIELD_ANCOUNT) == 0 ||
 977             catta_dns_packet_get_field(p, CATTA_DNS_FIELD_NSCOUNT) != 0) {
 978
 979             catta_log_warn("Invalid response packet from host %s.", catta_address_snprint(t, sizeof(t), src_address));
 980             return;
 981         }
 982
 983         handle_response_packet(s, p, i, src_address, from_local_iface);
 984     }
 985 }
 986
 987 static void dispatch_legacy_unicast_packet(CattaServer *s, CattaDnsPacket *p) {
 988     CattaInterface *j;
 989     CattaLegacyUnicastReflectSlot *slot;
 990
 991     assert(s);
 992     assert(p);
 993
 994     if (catta_dns_packet_check_valid(p) < 0 || catta_dns_packet_is_query(p)) {
 995         catta_log_warn("Received invalid packet.");
 996         return;
 997     }
 998
 999     if (!(slot = find_slot(s, catta_dns_packet_get_field(p, CATTA_DNS_FIELD_ID)))) {
1000         catta_log_warn("Received legacy unicast response with unknown id");
1001         return;
1002     }
1003
1004     if (!(j = catta_interface_monitor_get_interface(s->monitor, slot->iface, slot->address.proto)) ||
1005         !j->announcing)
1006         return;
1007
1008     /* Patch the original ID into this response */
1009     catta_dns_packet_set_field(p, CATTA_DNS_FIELD_ID, slot->original_id);
1010
1011     /* Forward the response to the correct client */
1012     catta_interface_send_packet_unicast(j, p, &slot->address, slot->port);
1013
1014     /* Undo changes to packet */
1015     catta_dns_packet_set_field(p, CATTA_DNS_FIELD_ID, slot->id);
1016 }
1017
1018 static void mcast_socket_event(CattaWatch *w, int fd, CattaWatchEvent events, void *userdata) {
1019     CattaServer *s = userdata;
1020     CattaAddress dest, src;
1021     CattaDnsPacket *p = NULL;
1022     CattaIfIndex iface;
1023     uint16_t port;
1024     uint8_t ttl;
1025
1026     assert(w);
1027     assert(fd >= 0);
1028     assert(events & CATTA_WATCH_IN);
1029
1030     if (fd == s->fd_ipv4) {
1031         dest.proto = src.proto = CATTA_PROTO_INET;
1032         p = catta_recv_dns_packet_ipv4(s->fd_ipv4, &src.data.ipv4, &port, &dest.data.ipv4, &iface, &ttl);
1033     } else {
1034         assert(fd == s->fd_ipv6);
1035         dest.proto = src.proto = CATTA_PROTO_INET6;
1036         p = catta_recv_dns_packet_ipv6(s->fd_ipv6, &src.data.ipv6, &port, &dest.data.ipv6, &iface, &ttl);
1037     }
1038
1039     if (p) {
1040         if (iface == CATTA_IF_UNSPEC)
1041             iface = catta_find_interface_for_address(s->monitor, &dest);
1042
1043         if (iface != CATTA_IF_UNSPEC)
1044             dispatch_packet(s, p, &src, port, &dest, iface, ttl);
1045         else
1046             catta_log_error("Incoming packet received on address that isn't local.");
1047
1048         catta_dns_packet_free(p);
1049
1050         catta_cleanup_dead_entries(s);
1051     }
1052 }
1053
1054 static void legacy_unicast_socket_event(CattaWatch *w, int fd, CattaWatchEvent events, void *userdata) {
1055     CattaServer *s = userdata;
1056     CattaDnsPacket *p = NULL;
1057
1058     assert(w);
1059     assert(fd >= 0);
1060     assert(events & CATTA_WATCH_IN);
1061
1062     if (fd == s->fd_legacy_unicast_ipv4)
1063         p = catta_recv_dns_packet_ipv4(s->fd_legacy_unicast_ipv4, NULL, NULL, NULL, NULL, NULL);
1064     else {
1065         assert(fd == s->fd_legacy_unicast_ipv6);
1066         p = catta_recv_dns_packet_ipv6(s->fd_legacy_unicast_ipv6, NULL, NULL, NULL, NULL, NULL);
1067     }
1068
1069     if (p) {
1070         dispatch_legacy_unicast_packet(s, p);
1071         catta_dns_packet_free(p);
1072
1073         catta_cleanup_dead_entries(s);
1074     }
1075 }
1076
1077 static void server_set_state(CattaServer *s, CattaServerState state) {
1078     assert(s);
1079
1080     if (s->state == state)
1081         return;
1082
1083     s->state = state;
1084
1085     catta_interface_monitor_update_rrs(s->monitor, 0);
1086
1087     if (s->callback)
1088         s->callback(s, state, s->userdata);
1089 }
1090
1091 static void withdraw_host_rrs(CattaServer *s) {
1092     assert(s);
1093
1094     if (s->hinfo_entry_group)
1095         catta_s_entry_group_reset(s->hinfo_entry_group);
1096
1097     if (s->browse_domain_entry_group)
1098         catta_s_entry_group_reset(s->browse_domain_entry_group);
1099
1100     catta_interface_monitor_update_rrs(s->monitor, 1);
1101     s->n_host_rr_pending = 0;
1102 }
1103
1104 void catta_server_decrease_host_rr_pending(CattaServer *s) {
1105     assert(s);
1106
1107     assert(s->n_host_rr_pending > 0);
1108
1109     if (--s->n_host_rr_pending == 0)
1110         server_set_state(s, CATTA_SERVER_RUNNING);
1111 }
1112
1113 void catta_host_rr_entry_group_callback(CattaServer *s, CattaSEntryGroup *g, CattaEntryGroupState state, CATTA_GCC_UNUSED void *userdata) {
1114     assert(s);
1115     assert(g);
1116
1117     if (state == CATTA_ENTRY_GROUP_REGISTERING &&
1118         s->state == CATTA_SERVER_REGISTERING)
1119         s->n_host_rr_pending ++;
1120
1121     else if (state == CATTA_ENTRY_GROUP_COLLISION &&
1122         (s->state == CATTA_SERVER_REGISTERING || s->state == CATTA_SERVER_RUNNING)) {
1123         withdraw_host_rrs(s);
1124         server_set_state(s, CATTA_SERVER_COLLISION);
1125
1126     } else if (state == CATTA_ENTRY_GROUP_ESTABLISHED &&
1127                s->state == CATTA_SERVER_REGISTERING)
1128         catta_server_decrease_host_rr_pending(s);
1129 }
1130
1131 static void register_hinfo(CattaServer *s) {
1132     struct utsname utsname;
1133     CattaRecord *r;
1134
1135     assert(s);
1136
1137     if (!s->config.publish_hinfo)
1138         return;
1139
1140     if (s->hinfo_entry_group)
1141         assert(catta_s_entry_group_is_empty(s->hinfo_entry_group));
1142     else
1143         s->hinfo_entry_group = catta_s_entry_group_new(s, catta_host_rr_entry_group_callback, NULL);
1144
1145     if (!s->hinfo_entry_group) {
1146         catta_log_warn("Failed to create HINFO entry group: %s", catta_strerror(s->error));
1147         return;
1148     }
1149
1150     /* Fill in HINFO rr */
1151     if ((r = catta_record_new_full(s->host_name_fqdn, CATTA_DNS_CLASS_IN, CATTA_DNS_TYPE_HINFO, CATTA_DEFAULT_TTL_HOST_NAME))) {
1152
1153         if (uname(&utsname) < 0)
1154             catta_log_warn("uname() failed: %s\n", catta_strerror(errno));
1155         else {
1156
1157             r->data.hinfo.cpu = catta_strdup(catta_strup(utsname.machine));
1158             r->data.hinfo.os = catta_strdup(catta_strup(utsname.sysname));
1159
1160             catta_log_info("Registering HINFO record with values '%s'/'%s'.", r->data.hinfo.cpu, r->data.hinfo.os);
1161
1162             if (catta_server_add(s, s->hinfo_entry_group, CATTA_IF_UNSPEC, CATTA_PROTO_UNSPEC, CATTA_PUBLISH_UNIQUE, r) < 0) {
1163                 catta_log_warn("Failed to add HINFO RR: %s", catta_strerror(s->error));
1164                 return;
1165             }
1166         }
1167
1168         catta_record_unref(r);
1169     }
1170
1171     if (catta_s_entry_group_commit(s->hinfo_entry_group) < 0)
1172         catta_log_warn("Failed to commit HINFO entry group: %s", catta_strerror(s->error));
1173
1174 }
1175
1176 static void register_localhost(CattaServer *s) {
1177     CattaAddress a;
1178     assert(s);
1179
1180     /* Add localhost entries */
1181     catta_address_parse("127.0.0.1", CATTA_PROTO_INET, &a);
1182     catta_server_add_address(s, NULL, CATTA_IF_UNSPEC, CATTA_PROTO_UNSPEC, CATTA_PUBLISH_NO_PROBE|CATTA_PUBLISH_NO_ANNOUNCE, "localhost", &a);
1183
1184     catta_address_parse("::1", CATTA_PROTO_INET6, &a);
1185     catta_server_add_address(s, NULL, CATTA_IF_UNSPEC, CATTA_PROTO_UNSPEC, CATTA_PUBLISH_NO_PROBE|CATTA_PUBLISH_NO_ANNOUNCE, "ip6-localhost", &a);
1186 }
1187
1188 static void register_browse_domain(CattaServer *s) {
1189     assert(s);
1190
1191     if (!s->config.publish_domain)
1192         return;
1193
1194     if (catta_domain_equal(s->domain_name, "local"))
1195         return;
1196
1197     if (s->browse_domain_entry_group)
1198         assert(catta_s_entry_group_is_empty(s->browse_domain_entry_group));
1199     else
1200         s->browse_domain_entry_group = catta_s_entry_group_new(s, NULL, NULL);
1201
1202     if (!s->browse_domain_entry_group) {
1203         catta_log_warn("Failed to create browse domain entry group: %s", catta_strerror(s->error));
1204         return;
1205     }
1206
1207     if (catta_server_add_ptr(s, s->browse_domain_entry_group, CATTA_IF_UNSPEC, CATTA_PROTO_UNSPEC, 0, CATTA_DEFAULT_TTL, "b._dns-sd._udp.local", s->domain_name) < 0) {
1208         catta_log_warn("Failed to add browse domain RR: %s", catta_strerror(s->error));
1209         return;
1210     }
1211
1212     if (catta_s_entry_group_commit(s->browse_domain_entry_group) < 0)
1213         catta_log_warn("Failed to commit browse domain entry group: %s", catta_strerror(s->error));
1214 }
1215
1216 static void register_stuff(CattaServer *s) {
1217     assert(s);
1218
1219     server_set_state(s, CATTA_SERVER_REGISTERING);
1220     s->n_host_rr_pending ++; /** Make sure that the state isn't changed tp CATTA_SERVER_RUNNING too early */
1221
1222     register_hinfo(s);
1223     register_browse_domain(s);
1224     catta_interface_monitor_update_rrs(s->monitor, 0);
1225
1226     assert(s->n_host_rr_pending > 0);
1227     s->n_host_rr_pending --;
1228
1229     if (s->n_host_rr_pending == 0)
1230         server_set_state(s, CATTA_SERVER_RUNNING);
1231 }
1232
1233 static void update_fqdn(CattaServer *s) {
1234     char *n;
1235
1236     assert(s);
1237     assert(s->host_name);
1238     assert(s->domain_name);
1239
1240     if (!(n = catta_strdup_printf("%s.%s", s->host_name, s->domain_name)))
1241         return; /* OOM */
1242
1243     catta_free(s->host_name_fqdn);
1244     s->host_name_fqdn = n;
1245 }
1246
1247 int catta_server_set_host_name(CattaServer *s, const char *host_name) {
1248     char *hn = NULL;
1249     assert(s);
1250
1251     CATTA_CHECK_VALIDITY(s, !host_name || catta_is_valid_host_name(host_name), CATTA_ERR_INVALID_HOST_NAME);
1252
1253     if (!host_name)
1254         hn = catta_get_host_name_strdup();
1255     else
1256         hn = catta_normalize_name_strdup(host_name);
1257
1258     hn[strcspn(hn, ".")] = 0;
1259
1260     if (catta_domain_equal(s->host_name, hn) && s->state != CATTA_SERVER_COLLISION) {
1261         catta_free(hn);
1262         return catta_server_set_errno(s, CATTA_ERR_NO_CHANGE);
1263     }
1264
1265     withdraw_host_rrs(s);
1266
1267     catta_free(s->host_name);
1268     s->host_name = hn;
1269
1270     update_fqdn(s);
1271
1272     register_stuff(s);
1273     return CATTA_OK;
1274 }
1275
1276 int catta_server_set_domain_name(CattaServer *s, const char *domain_name) {
1277     char *dn = NULL;
1278     assert(s);
1279
1280     CATTA_CHECK_VALIDITY(s, !domain_name || catta_is_valid_domain_name(domain_name), CATTA_ERR_INVALID_DOMAIN_NAME);
1281
1282     if (!domain_name)
1283         dn = catta_strdup("local");
1284     else
1285         dn = catta_normalize_name_strdup(domain_name);
1286
1287     if (catta_domain_equal(s->domain_name, domain_name)) {
1288         catta_free(dn);
1289         return catta_server_set_errno(s, CATTA_ERR_NO_CHANGE);
1290     }
1291
1292     withdraw_host_rrs(s);
1293
1294     catta_free(s->domain_name);
1295     s->domain_name = dn;
1296     update_fqdn(s);
1297
1298     register_stuff(s);
1299
1300     catta_free(dn);
1301     return CATTA_OK;
1302 }
1303
1304 static int valid_server_config(const CattaServerConfig *sc) {
1305     CattaStringList *l;
1306
1307     assert(sc);
1308
1309     if (sc->n_wide_area_servers > CATTA_WIDE_AREA_SERVERS_MAX)
1310         return CATTA_ERR_INVALID_CONFIG;
1311
1312     if (sc->host_name && !catta_is_valid_host_name(sc->host_name))
1313         return CATTA_ERR_INVALID_HOST_NAME;
1314
1315     if (sc->domain_name && !catta_is_valid_domain_name(sc->domain_name))
1316         return CATTA_ERR_INVALID_DOMAIN_NAME;
1317
1318     for (l = sc->browse_domains; l; l = l->next)
1319         if (!catta_is_valid_domain_name((char*) l->text))
1320             return CATTA_ERR_INVALID_DOMAIN_NAME;
1321
1322     return CATTA_OK;
1323 }
1324
1325 static int setup_sockets(CattaServer *s) {
1326     assert(s);
1327
1328     s->fd_ipv4 = s->config.use_ipv4 ? catta_open_socket_ipv4(s->config.disallow_other_stacks) : -1;
1329     s->fd_ipv6 = s->config.use_ipv6 ? catta_open_socket_ipv6(s->config.disallow_other_stacks) : -1;
1330
1331     if (s->fd_ipv6 < 0 && s->fd_ipv4 < 0)
1332         return CATTA_ERR_NO_NETWORK;
1333
1334     if (s->fd_ipv4 < 0 && s->config.use_ipv4)
1335         catta_log_notice("Failed to create IPv4 socket, proceeding in IPv6 only mode");
1336     else if (s->fd_ipv6 < 0 && s->config.use_ipv6)
1337         catta_log_notice("Failed to create IPv6 socket, proceeding in IPv4 only mode");
1338
1339     s->fd_legacy_unicast_ipv4 = s->fd_ipv4 >= 0 && s->config.enable_reflector ? catta_open_unicast_socket_ipv4() : -1;
1340     s->fd_legacy_unicast_ipv6 = s->fd_ipv6 >= 0 && s->config.enable_reflector ? catta_open_unicast_socket_ipv6() : -1;
1341
1342     s->watch_ipv4 =
1343         s->watch_ipv6 =
1344         s->watch_legacy_unicast_ipv4 =
1345         s->watch_legacy_unicast_ipv6 = NULL;
1346
1347     if (s->fd_ipv4 >= 0)
1348         s->watch_ipv4 = s->poll_api->watch_new(s->poll_api, s->fd_ipv4, CATTA_WATCH_IN, mcast_socket_event, s);
1349     if (s->fd_ipv6 >= 0)
1350         s->watch_ipv6 = s->poll_api->watch_new(s->poll_api, s->fd_ipv6, CATTA_WATCH_IN, mcast_socket_event, s);
1351
1352     if (s->fd_legacy_unicast_ipv4 >= 0)
1353         s->watch_legacy_unicast_ipv4 = s->poll_api->watch_new(s->poll_api, s->fd_legacy_unicast_ipv4, CATTA_WATCH_IN, legacy_unicast_socket_event, s);
1354     if (s->fd_legacy_unicast_ipv6 >= 0)
1355         s->watch_legacy_unicast_ipv6 = s->poll_api->watch_new(s->poll_api, s->fd_legacy_unicast_ipv6, CATTA_WATCH_IN, legacy_unicast_socket_event, s);
1356
1357     return 0;
1358 }
1359
1360 CattaServer *catta_server_new(const CattaPoll *poll_api, const CattaServerConfig *sc, CattaServerCallback callback, void* userdata, int *error) {
1361     CattaServer *s;
1362     int e;
1363
1364     if (sc && (e = valid_server_config(sc)) < 0) {
1365         if (error)
1366             *error = e;
1367         return NULL;
1368     }
1369
1370     if (!(s = catta_new(CattaServer, 1))) {
1371         if (error)
1372             *error = CATTA_ERR_NO_MEMORY;
1373
1374         return NULL;
1375     }
1376
1377     s->poll_api = poll_api;
1378
1379     if (sc)
1380         catta_server_config_copy(&s->config, sc);
1381     else
1382         catta_server_config_init(&s->config);
1383
1384     if ((e = setup_sockets(s)) < 0) {
1385         if (error)
1386             *error = e;
1387
1388         catta_server_config_free(&s->config);
1389         catta_free(s);
1390
1391         return NULL;
1392     }
1393
1394     s->n_host_rr_pending = 0;
1395     s->need_entry_cleanup = 0;
1396     s->need_group_cleanup = 0;
1397     s->need_browser_cleanup = 0;
1398     s->cleanup_time_event = NULL;
1399     s->hinfo_entry_group = NULL;
1400     s->browse_domain_entry_group = NULL;
1401     s->error = CATTA_OK;
1402     s->state = CATTA_SERVER_INVALID;
1403
1404     s->callback = callback;
1405     s->userdata = userdata;
1406
1407     s->time_event_queue = catta_time_event_queue_new(poll_api);
1408
1409     s->entries_by_key = catta_hashmap_new((CattaHashFunc) catta_key_hash, (CattaEqualFunc) catta_key_equal, NULL, NULL);
1410     CATTA_LLIST_HEAD_INIT(CattaEntry, s->entries);
1411     CATTA_LLIST_HEAD_INIT(CattaGroup, s->groups);
1412
1413     s->record_browser_hashmap = catta_hashmap_new((CattaHashFunc) catta_key_hash, (CattaEqualFunc) catta_key_equal, NULL, NULL);
1414     CATTA_LLIST_HEAD_INIT(CattaSRecordBrowser, s->record_browsers);
1415     CATTA_LLIST_HEAD_INIT(CattaSHostNameResolver, s->host_name_resolvers);
1416     CATTA_LLIST_HEAD_INIT(CattaSAddressResolver, s->address_resolvers);
1417     CATTA_LLIST_HEAD_INIT(CattaSDomainBrowser, s->domain_browsers);
1418     CATTA_LLIST_HEAD_INIT(CattaSServiceTypeBrowser, s->service_type_browsers);
1419     CATTA_LLIST_HEAD_INIT(CattaSServiceBrowser, s->service_browsers);
1420     CATTA_LLIST_HEAD_INIT(CattaSServiceResolver, s->service_resolvers);
1421     CATTA_LLIST_HEAD_INIT(CattaSDNSServerBrowser, s->dns_server_browsers);
1422
1423     s->legacy_unicast_reflect_slots = NULL;
1424     s->legacy_unicast_reflect_id = 0;
1425
1426     s->record_list = catta_record_list_new();
1427
1428     /* Get host name */
1429     s->host_name = s->config.host_name ? catta_normalize_name_strdup(s->config.host_name) : catta_get_host_name_strdup();
1430     s->host_name[strcspn(s->host_name, ".")] = 0;
1431     s->domain_name = s->config.domain_name ? catta_normalize_name_strdup(s->config.domain_name) : catta_strdup("local");
1432     s->host_name_fqdn = NULL;
1433     update_fqdn(s);
1434
1435     do {
1436         s->local_service_cookie = (uint32_t) rand() * (uint32_t) rand();
1437     } while (s->local_service_cookie == CATTA_SERVICE_COOKIE_INVALID);
1438
1439     if (s->config.enable_wide_area) {
1440         s->wide_area_lookup_engine = catta_wide_area_engine_new(s);
1441         catta_wide_area_set_servers(s->wide_area_lookup_engine, s->config.wide_area_servers, s->config.n_wide_area_servers);
1442     } else
1443         s->wide_area_lookup_engine = NULL;
1444
1445     s->multicast_lookup_engine = catta_multicast_lookup_engine_new(s);
1446
1447     s->monitor = catta_interface_monitor_new(s);
1448     catta_interface_monitor_sync(s->monitor);
1449
1450     register_localhost(s);
1451     register_stuff(s);
1452
1453     return s;
1454 }
1455
1456 void catta_server_free(CattaServer* s) {
1457     assert(s);
1458
1459     /* Remove all browsers */
1460
1461     while (s->dns_server_browsers)
1462         catta_s_dns_server_browser_free(s->dns_server_browsers);
1463     while (s->host_name_resolvers)
1464         catta_s_host_name_resolver_free(s->host_name_resolvers);
1465     while (s->address_resolvers)
1466         catta_s_address_resolver_free(s->address_resolvers);
1467     while (s->domain_browsers)
1468         catta_s_domain_browser_free(s->domain_browsers);
1469     while (s->service_type_browsers)
1470         catta_s_service_type_browser_free(s->service_type_browsers);
1471     while (s->service_browsers)
1472         catta_s_service_browser_free(s->service_browsers);
1473     while (s->service_resolvers)
1474         catta_s_service_resolver_free(s->service_resolvers);
1475     while (s->record_browsers)
1476         catta_s_record_browser_destroy(s->record_browsers);
1477
1478     /* Remove all locally rgeistered stuff */
1479
1480     while(s->entries)
1481         catta_entry_free(s, s->entries);
1482
1483     catta_interface_monitor_free(s->monitor);
1484
1485     while (s->groups)
1486         catta_entry_group_free(s, s->groups);
1487
1488     free_slots(s);
1489
1490     catta_hashmap_free(s->entries_by_key);
1491     catta_record_list_free(s->record_list);
1492     catta_hashmap_free(s->record_browser_hashmap);
1493
1494     if (s->wide_area_lookup_engine)
1495         catta_wide_area_engine_free(s->wide_area_lookup_engine);
1496     catta_multicast_lookup_engine_free(s->multicast_lookup_engine);
1497
1498     if (s->cleanup_time_event)
1499         catta_time_event_free(s->cleanup_time_event);
1500
1501     catta_time_event_queue_free(s->time_event_queue);
1502
1503     /* Free watches */
1504
1505     if (s->watch_ipv4)
1506         s->poll_api->watch_free(s->watch_ipv4);
1507     if (s->watch_ipv6)
1508         s->poll_api->watch_free(s->watch_ipv6);
1509
1510     if (s->watch_legacy_unicast_ipv4)
1511         s->poll_api->watch_free(s->watch_legacy_unicast_ipv4);
1512     if (s->watch_legacy_unicast_ipv6)
1513         s->poll_api->watch_free(s->watch_legacy_unicast_ipv6);
1514
1515     /* Free sockets */
1516
1517     if (s->fd_ipv4 >= 0)
1518         closesocket(s->fd_ipv4);
1519     if (s->fd_ipv6 >= 0)
1520         closesocket(s->fd_ipv6);
1521
1522     if (s->fd_legacy_unicast_ipv4 >= 0)
1523         closesocket(s->fd_legacy_unicast_ipv4);
1524     if (s->fd_legacy_unicast_ipv6 >= 0)
1525         closesocket(s->fd_legacy_unicast_ipv6);
1526
1527     /* Free other stuff */
1528
1529     catta_free(s->host_name);
1530     catta_free(s->domain_name);
1531     catta_free(s->host_name_fqdn);
1532
1533     catta_server_config_free(&s->config);
1534
1535     catta_free(s);
1536 }
1537
1538 const char* catta_server_get_domain_name(CattaServer *s) {
1539     assert(s);
1540
1541     return s->domain_name;
1542 }
1543
1544 const char* catta_server_get_host_name(CattaServer *s) {
1545     assert(s);
1546
1547     return s->host_name;
1548 }
1549
1550 const char* catta_server_get_host_name_fqdn(CattaServer *s) {
1551     assert(s);
1552
1553     return s->host_name_fqdn;
1554 }
1555
1556 void* catta_server_get_data(CattaServer *s) {
1557     assert(s);
1558
1559     return s->userdata;
1560 }
1561
1562 void catta_server_set_data(CattaServer *s, void* userdata) {
1563     assert(s);
1564
1565     s->userdata = userdata;
1566 }
1567
1568 CattaServerState catta_server_get_state(CattaServer *s) {
1569     assert(s);
1570
1571     return s->state;
1572 }
1573
1574 CattaServerConfig* catta_server_config_init(CattaServerConfig *c) {
1575     assert(c);
1576
1577     memset(c, 0, sizeof(CattaServerConfig));
1578     c->use_ipv6 = 1;
1579     c->use_ipv4 = 1;
1580     c->allow_interfaces = NULL;
1581     c->deny_interfaces = NULL;
1582     c->host_name = NULL;
1583     c->domain_name = NULL;
1584     c->check_response_ttl = 0;
1585     c->publish_hinfo = 0;
1586     c->publish_addresses = 1;
1587     c->publish_no_reverse = 0;
1588     c->publish_workstation = 0;
1589     c->publish_domain = 1;
1590     c->use_iff_running = 0;
1591     c->enable_reflector = 0;
1592     c->reflect_ipv = 0;
1593     c->add_service_cookie = 0;
1594     c->enable_wide_area = 0;
1595     c->n_wide_area_servers = 0;
1596     c->disallow_other_stacks = 0;
1597     c->browse_domains = NULL;
1598     c->disable_publishing = 0;
1599     c->allow_point_to_point = 0;
1600     c->publish_aaaa_on_ipv4 = 1;
1601     c->publish_a_on_ipv6 = 0;
1602     c->n_cache_entries_max = CATTA_DEFAULT_CACHE_ENTRIES_MAX;
1603     c->ratelimit_interval = 0;
1604     c->ratelimit_burst = 0;
1605
1606     return c;
1607 }
1608
1609 void catta_server_config_free(CattaServerConfig *c) {
1610     assert(c);
1611
1612     catta_free(c->host_name);
1613     catta_free(c->domain_name);
1614     catta_string_list_free(c->browse_domains);
1615     catta_string_list_free(c->allow_interfaces);
1616     catta_string_list_free(c->deny_interfaces);
1617 }
1618
1619 CattaServerConfig* catta_server_config_copy(CattaServerConfig *ret, const CattaServerConfig *c) {
1620     char *d = NULL, *h = NULL;
1621     CattaStringList *browse = NULL, *allow = NULL, *deny = NULL;
1622     assert(ret);
1623     assert(c);
1624
1625     if (c->host_name)
1626         if (!(h = catta_strdup(c->host_name)))
1627             return NULL;
1628
1629     if (c->domain_name)
1630         if (!(d = catta_strdup(c->domain_name))) {
1631             catta_free(h);
1632             return NULL;
1633         }
1634
1635     if (!(browse = catta_string_list_copy(c->browse_domains)) && c->browse_domains) {
1636         catta_free(h);
1637         catta_free(d);
1638         return NULL;
1639     }
1640
1641     if (!(allow = catta_string_list_copy(c->allow_interfaces)) && c->allow_interfaces) {
1642         catta_string_list_free(browse);
1643         catta_free(h);
1644         catta_free(d);
1645         return NULL;
1646     }
1647
1648     if (!(deny = catta_string_list_copy(c->deny_interfaces)) && c->deny_interfaces) {
1649         catta_string_list_free(allow);
1650         catta_string_list_free(browse);
1651         catta_free(h);
1652         catta_free(d);
1653         return NULL;
1654     }
1655
1656     *ret = *c;
1657     ret->host_name = h;
1658     ret->domain_name = d;
1659     ret->browse_domains = browse;
1660     ret->allow_interfaces = allow;
1661     ret->deny_interfaces = deny;
1662
1663     return ret;
1664 }
1665
1666 int catta_server_errno(CattaServer *s) {
1667     assert(s);
1668
1669     return s->error;
1670 }
1671
1672 /* Just for internal use */
1673 int catta_server_set_errno(CattaServer *s, int error) {
1674     assert(s);
1675
1676     return s->error = error;
1677 }
1678
1679 uint32_t catta_server_get_local_service_cookie(CattaServer *s) {
1680     assert(s);
1681
1682     return s->local_service_cookie;
1683 }
1684
1685 static CattaEntry *find_entry(CattaServer *s, CattaIfIndex iface, CattaProtocol protocol, CattaKey *key) {
1686     CattaEntry *e;
1687
1688     assert(s);
1689     assert(key);
1690
1691     for (e = catta_hashmap_lookup(s->entries_by_key, key); e; e = e->by_key_next)
1692
1693         if ((e->iface == iface || e->iface <= 0 || iface <= 0) &&
1694             (e->protocol == protocol || e->protocol == CATTA_PROTO_UNSPEC || protocol == CATTA_PROTO_UNSPEC) &&
1695             (!e->group || e->group->state == CATTA_ENTRY_GROUP_ESTABLISHED || e->group->state == CATTA_ENTRY_GROUP_REGISTERING))
1696
1697             return e;
1698
1699     return NULL;
1700 }
1701
1702 int catta_server_get_group_of_service(CattaServer *s, CattaIfIndex iface, CattaProtocol protocol, const char *name, const char *type, const char *domain, CattaSEntryGroup** ret_group) {
1703     CattaKey *key = NULL;
1704     CattaEntry *e;
1705     int ret;
1706     char n[CATTA_DOMAIN_NAME_MAX];
1707
1708     assert(s);
1709     assert(name);
1710     assert(type);
1711     assert(ret_group);
1712
1713     CATTA_CHECK_VALIDITY(s, CATTA_IF_VALID(iface), CATTA_ERR_INVALID_INTERFACE);
1714     CATTA_CHECK_VALIDITY(s, CATTA_PROTO_VALID(protocol), CATTA_ERR_INVALID_PROTOCOL);
1715     CATTA_CHECK_VALIDITY(s, catta_is_valid_service_name(name), CATTA_ERR_INVALID_SERVICE_NAME);
1716     CATTA_CHECK_VALIDITY(s, catta_is_valid_service_type_strict(type), CATTA_ERR_INVALID_SERVICE_TYPE);
1717     CATTA_CHECK_VALIDITY(s, !domain || catta_is_valid_domain_name(domain), CATTA_ERR_INVALID_DOMAIN_NAME);
1718
1719     if ((ret = catta_service_name_join(n, sizeof(n), name, type, domain) < 0))
1720         return catta_server_set_errno(s, ret);
1721
1722     if (!(key = catta_key_new(n, CATTA_DNS_CLASS_IN, CATTA_DNS_TYPE_SRV)))
1723         return catta_server_set_errno(s, CATTA_ERR_NO_MEMORY);
1724
1725     e = find_entry(s, iface, protocol, key);
1726     catta_key_unref(key);
1727
1728     if (e) {
1729         *ret_group = e->group;
1730         return CATTA_OK;
1731     }
1732
1733     return catta_server_set_errno(s, CATTA_ERR_NOT_FOUND);
1734 }
1735
1736 int catta_server_is_service_local(CattaServer *s, CattaIfIndex iface, CattaProtocol protocol, const char *name) {
1737     CattaKey *key = NULL;
1738     CattaEntry *e;
1739
1740     assert(s);
1741     assert(name);
1742
1743     if (!s->host_name_fqdn)
1744         return 0;
1745
1746     if (!(key = catta_key_new(name, CATTA_DNS_CLASS_IN, CATTA_DNS_TYPE_SRV)))
1747         return 0;
1748
1749     e = find_entry(s, iface, protocol, key);
1750     catta_key_unref(key);
1751
1752     if (!e)
1753         return 0;
1754
1755     return catta_domain_equal(s->host_name_fqdn, e->record->data.srv.name);
1756 }
1757
1758 int catta_server_is_record_local(CattaServer *s, CattaIfIndex iface, CattaProtocol protocol, CattaRecord *record) {
1759     CattaEntry *e;
1760
1761     assert(s);
1762     assert(record);
1763
1764     for (e = catta_hashmap_lookup(s->entries_by_key, record->key); e; e = e->by_key_next)
1765
1766         if ((e->iface == iface || e->iface <= 0 || iface <= 0) &&
1767             (e->protocol == protocol || e->protocol == CATTA_PROTO_UNSPEC || protocol == CATTA_PROTO_UNSPEC) &&
1768             (!e->group || e->group->state == CATTA_ENTRY_GROUP_ESTABLISHED || e->group->state == CATTA_ENTRY_GROUP_REGISTERING) &&
1769             catta_record_equal_no_ttl(record, e->record))
1770             return 1;
1771
1772     return 0;
1773 }
1774
1775 /** Set the wide area DNS servers */
1776 int catta_server_set_wide_area_servers(CattaServer *s, const CattaAddress *a, unsigned n) {
1777     assert(s);
1778
1779     if (!s->wide_area_lookup_engine)
1780         return catta_server_set_errno(s, CATTA_ERR_INVALID_CONFIG);
1781
1782     catta_wide_area_set_servers(s->wide_area_lookup_engine, a, n);
1783     return CATTA_OK;
1784 }
1785
1786 const CattaServerConfig* catta_server_get_config(CattaServer *s) {
1787     assert(s);
1788
1789     return &s->config;
1790 }
1791
1792 /** Set the browsing domains */
1793 int catta_server_set_browse_domains(CattaServer *s, CattaStringList *domains) {
1794     CattaStringList *l;
1795
1796     assert(s);
1797
1798     for (l = s->config.browse_domains; l; l = l->next)
1799         if (!catta_is_valid_domain_name((char*) l->text))
1800             return catta_server_set_errno(s, CATTA_ERR_INVALID_DOMAIN_NAME);
1801
1802     catta_string_list_free(s->config.browse_domains);
1803     s->config.browse_domains = catta_string_list_copy(domains);
1804
1805     return CATTA_OK;
1806 }