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

   1 #include <sys/socket.h>
   2 #include <arpa/inet.h>
   3 #include <string.h>
   4 #include <sys/utsname.h>
   5 #include <unistd.h>
   6
   7 #include "server.h"
   8 #include "util.h"
   9 #include "iface.h"
  10 #include "socket.h"
  11 #include "subscribe.h"
  12
  13 static void handle_query_key(flxServer *s, flxKey *k, flxInterface *i, const flxAddress *a) {
  14     flxServerEntry *e;
  15     gchar *txt;
  16
  17     g_assert(s);
  18     g_assert(k);
  19     g_assert(i);
  20     g_assert(a);
  21
  22     g_message("Handling query: %s", txt = flx_key_to_string(k));
  23     g_free(txt);
  24
  25     flx_packet_scheduler_incoming_query(i->scheduler, k);
  26
  27     if (k->type == FLX_DNS_TYPE_ANY) {
  28
  29         /* Handle ANY query */
  30
  31         for (e = s->entries; e; e = e->entry_next)
  32             if (flx_key_pattern_match(k, e->record->key))
  33                 if (flx_interface_match(i, e->interface, e->protocol))
  34                     flx_interface_post_response(i, e->record, FALSE);
  35     } else {
  36
  37         /* Handle all other queries */
  38
  39         for (e = g_hash_table_lookup(s->rrset_by_key, k); e; e = e->by_key_next)
  40             if (flx_interface_match(i, e->interface, e->protocol))
  41                 flx_interface_post_response(i, e->record, FALSE);
  42     }
  43 }
  44
  45 static void handle_query(flxServer *s, flxDnsPacket *p, flxInterface *i, const flxAddress *a) {
  46     guint n;
  47
  48     g_assert(s);
  49     g_assert(p);
  50     g_assert(i);
  51     g_assert(a);
  52
  53     for (n = flx_dns_packet_get_field(p, DNS_FIELD_QDCOUNT); n > 0; n --) {
  54         flxKey *key;
  55
  56         if (!(key = flx_dns_packet_consume_key(p))) {
  57             g_warning("Packet too short");
  58             return;
  59         }
  60
  61         handle_query_key(s, key, i, a);
  62         flx_key_unref(key);
  63     }
  64 }
  65
  66 static void handle_response(flxServer *s, flxDnsPacket *p, flxInterface *i, const flxAddress *a) {
  67     guint n;
  68
  69     g_assert(s);
  70     g_assert(p);
  71     g_assert(i);
  72     g_assert(a);
  73
  74     for (n = flx_dns_packet_get_field(p, DNS_FIELD_ANCOUNT) +
  75              flx_dns_packet_get_field(p, DNS_FIELD_ARCOUNT); n > 0; n--) {
  76         flxRecord *record;
  77         gboolean cache_flush = FALSE;
  78         gchar *txt;
  79
  80         if (!(record = flx_dns_packet_consume_record(p, &cache_flush))) {
  81             g_warning("Packet too short");
  82             return;
  83         }
  84
  85         if (record->key->type != FLX_DNS_TYPE_ANY) {
  86             g_message("Handling response: %s", txt = flx_record_to_string(record));
  87             g_free(txt);
  88
  89             flx_cache_update(i->cache, record, cache_flush, a);
  90
  91             flx_packet_scheduler_incoming_response(i->scheduler, record);
  92             flx_record_unref(record);
  93         }
  94     }
  95 }
  96
  97 static void dispatch_packet(flxServer *s, flxDnsPacket *p, struct sockaddr *sa, gint iface, gint ttl) {
  98     flxInterface *i;
  99     flxAddress a;
 100
 101     g_assert(s);
 102     g_assert(p);
 103     g_assert(sa);
 104     g_assert(iface > 0);
 105
 106     g_message("new packet recieved.");
 107
 108     if (!(i = flx_interface_monitor_get_interface(s->monitor, iface, sa->sa_family))) {
 109         g_warning("Recieved packet from invalid interface.");
 110         return;
 111     }
 112
 113     if (ttl != 255) {
 114         g_warning("Recieved packet with invalid TTL on interface '%s.%i'.", i->hardware->name, i->protocol);
 115         return;
 116     }
 117
 118     if (sa->sa_family == AF_INET6) {
 119         static const unsigned char ipv4_in_ipv6[] = {
 120             0x00, 0x00, 0x00, 0x00,
 121             0x00, 0x00, 0x00, 0x00,
 122             0xFF, 0xFF, 0xFF, 0xFF };
 123
 124         if (memcmp(((struct sockaddr_in6*) sa)->sin6_addr.s6_addr, ipv4_in_ipv6, sizeof(ipv4_in_ipv6)) == 0) {
 125
 126             /* This is an IPv4 address encapsulated in IPv6, so let's ignore it. */
 127             return;
 128         }
 129     }
 130
 131     if (flx_dns_packet_check_valid(p) < 0) {
 132         g_warning("Recieved invalid packet.");
 133         return;
 134     }
 135
 136     flx_address_from_sockaddr(sa, &a);
 137
 138     if (flx_dns_packet_is_query(p)) {
 139
 140         if (flx_dns_packet_get_field(p, DNS_FIELD_QDCOUNT) == 0 ||
 141             flx_dns_packet_get_field(p, DNS_FIELD_ARCOUNT) != 0 ||
 142             flx_dns_packet_get_field(p, DNS_FIELD_NSCOUNT) != 0) {
 143             g_warning("Invalid query packet.");
 144             return;
 145         }
 146
 147         handle_query(s, p, i, &a);
 148         g_message("Handled query");
 149     } else {
 150         if (flx_dns_packet_get_field(p, DNS_FIELD_QDCOUNT) != 0 ||
 151             flx_dns_packet_get_field(p, DNS_FIELD_ANCOUNT) == 0 ||
 152             flx_dns_packet_get_field(p, DNS_FIELD_NSCOUNT) != 0) {
 153             g_warning("Invalid response packet.");
 154             return;
 155         }
 156
 157         handle_response(s, p, i, &a);
 158         g_message("Handled response");
 159     }
 160 }
 161
 162 static gboolean work(flxServer *s) {
 163     struct sockaddr_in6 sa6;
 164     struct sockaddr_in sa;
 165     flxDnsPacket *p;
 166     gint iface = -1;
 167     guint8 ttl;
 168
 169     g_assert(s);
 170
 171     if (s->pollfd_ipv4.revents & G_IO_IN) {
 172         if ((p = flx_recv_dns_packet_ipv4(s->fd_ipv4, &sa, &iface, &ttl))) {
 173             dispatch_packet(s, p, (struct sockaddr*) &sa, iface, ttl);
 174             flx_dns_packet_free(p);
 175         }
 176     }
 177
 178     if (s->pollfd_ipv6.revents & G_IO_IN) {
 179         if ((p = flx_recv_dns_packet_ipv6(s->fd_ipv6, &sa6, &iface, &ttl))) {
 180             dispatch_packet(s, p, (struct sockaddr*) &sa6, iface, ttl);
 181             flx_dns_packet_free(p);
 182         }
 183     }
 184
 185     return TRUE;
 186 }
 187
 188 static gboolean prepare_func(GSource *source, gint *timeout) {
 189     g_assert(source);
 190     g_assert(timeout);
 191
 192     *timeout = -1;
 193     return FALSE;
 194 }
 195
 196 static gboolean check_func(GSource *source) {
 197     flxServer* s;
 198     g_assert(source);
 199
 200     s = *((flxServer**) (((guint8*) source) + sizeof(GSource)));
 201     g_assert(s);
 202
 203     return (s->pollfd_ipv4.revents | s->pollfd_ipv6.revents) & (G_IO_IN | G_IO_HUP | G_IO_ERR);
 204 }
 205
 206 static gboolean dispatch_func(GSource *source, GSourceFunc callback, gpointer user_data) {
 207     flxServer* s;
 208     g_assert(source);
 209
 210     s = *((flxServer**) (((guint8*) source) + sizeof(GSource)));
 211     g_assert(s);
 212
 213     return work(s);
 214 }
 215
 216 static void add_default_entries(flxServer *s) {
 217     gint length = 0;
 218     struct utsname utsname;
 219     gchar *hinfo;
 220     flxAddress a;
 221
 222     g_assert(s);
 223
 224     /* Fill in HINFO rr */
 225     uname(&utsname);
 226     hinfo = g_strdup_printf("%c%s%c%s%n",
 227                             strlen(utsname.machine), g_strup(utsname.machine),
 228                             strlen(utsname.sysname), g_strup(utsname.sysname),
 229                             &length);
 230
 231     flx_server_add_full(s, 0, 0, AF_UNSPEC, TRUE,
 232                         s->hostname, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_HINFO, hinfo, length, FLX_DEFAULT_TTL);
 233
 234     g_free(hinfo);
 235
 236     /* Add localhost entries */
 237     flx_address_parse("127.0.0.1", AF_INET, &a);
 238     flx_server_add_address(s, 0, 0, AF_UNSPEC, TRUE, "localhost", &a);
 239
 240     flx_address_parse("::1", AF_INET6, &a);
 241     flx_server_add_address(s, 0, 0, AF_UNSPEC, TRUE, "ip6-localhost", &a);
 242 }
 243
 244 flxServer *flx_server_new(GMainContext *c) {
 245     gchar *hn, *e;
 246     flxServer *s;
 247
 248     static GSourceFuncs source_funcs = {
 249         prepare_func,
 250         check_func,
 251         dispatch_func,
 252         NULL,
 253         NULL,
 254         NULL
 255     };
 256
 257     s = g_new(flxServer, 1);
 258
 259     s->fd_ipv4 = flx_open_socket_ipv4();
 260     s->fd_ipv6 = flx_open_socket_ipv6();
 261
 262     if (s->fd_ipv6 < 0 && s->fd_ipv4 < 0) {
 263         g_critical("Failed to create sockets.\n");
 264         g_free(s);
 265         return NULL;
 266     }
 267
 268     if (s->fd_ipv4 < 0)
 269         g_message("Failed to create IPv4 socket, proceeding in IPv6 only mode");
 270     else if (s->fd_ipv6 < 0)
 271         g_message("Failed to create IPv6 socket, proceeding in IPv4 only mode");
 272
 273     if (c)
 274         g_main_context_ref(s->context = c);
 275     else
 276         s->context = g_main_context_default();
 277
 278     s->current_id = 1;
 279
 280     FLX_LLIST_HEAD_INIT(flxServerEntry, s->entries);
 281     s->rrset_by_id = g_hash_table_new(g_int_hash, g_int_equal);
 282     s->rrset_by_key = g_hash_table_new((GHashFunc) flx_key_hash, (GEqualFunc) flx_key_equal);
 283
 284     FLX_LLIST_HEAD_INIT(flxSubscription, s->subscriptions);
 285     s->subscription_hashtable = g_hash_table_new((GHashFunc) flx_key_hash, (GEqualFunc) flx_key_equal);
 286
 287     s->monitor = flx_interface_monitor_new(s);
 288     s->time_event_queue = flx_time_event_queue_new(s->context);
 289
 290     /* Get host name */
 291     hn = flx_get_host_name();
 292     if ((e = strchr(hn, '.')))
 293         *e = 0;
 294
 295     s->hostname = g_strdup_printf("%s.local.", hn);
 296     g_free(hn);
 297
 298     add_default_entries(s);
 299
 300     s->source = g_source_new(&source_funcs, sizeof(GSource) + sizeof(flxServer*));
 301     *((flxServer**) (((guint8*) s->source) + sizeof(GSource))) = s;
 302
 303     memset(&s->pollfd_ipv4, 0, sizeof(s->pollfd_ipv4));
 304     s->pollfd_ipv4.fd = s->fd_ipv4;
 305     s->pollfd_ipv4.events = G_IO_IN|G_IO_ERR|G_IO_HUP;
 306     g_source_add_poll(s->source, &s->pollfd_ipv4);
 307
 308     memset(&s->pollfd_ipv6, 0, sizeof(s->pollfd_ipv6));
 309     s->pollfd_ipv6.fd = s->fd_ipv6;
 310     s->pollfd_ipv6.events = G_IO_IN|G_IO_ERR|G_IO_HUP;
 311     g_source_add_poll(s->source, &s->pollfd_ipv6);
 312
 313     g_source_attach(s->source, s->context);
 314
 315     return s;
 316 }
 317
 318 void flx_server_free(flxServer* s) {
 319     g_assert(s);
 320
 321     flx_interface_monitor_free(s->monitor);
 322
 323     flx_server_remove(s, 0);
 324
 325     while (s->subscriptions)
 326         flx_subscription_free(s->subscriptions);
 327     g_hash_table_destroy(s->subscription_hashtable);
 328
 329     g_hash_table_destroy(s->rrset_by_id);
 330     g_hash_table_destroy(s->rrset_by_key);
 331
 332     flx_time_event_queue_free(s->time_event_queue);
 333
 334     if (s->fd_ipv4 >= 0)
 335         close(s->fd_ipv4);
 336     if (s->fd_ipv6 >= 0)
 337         close(s->fd_ipv6);
 338
 339     g_free(s->hostname);
 340
 341     g_source_destroy(s->source);
 342     g_source_unref(s->source);
 343     g_main_context_unref(s->context);
 344
 345     g_free(s);
 346 }
 347
 348 gint flx_server_get_next_id(flxServer *s) {
 349     g_assert(s);
 350
 351     return s->current_id++;
 352 }
 353
 354 void flx_server_add(
 355     flxServer *s,
 356     gint id,
 357     gint interface,
 358     guchar protocol,
 359     gboolean unique,
 360     flxRecord *r) {
 361
 362     flxServerEntry *e, *t;
 363     g_assert(s);
 364     g_assert(r);
 365
 366     g_assert(r->key->type != FLX_DNS_TYPE_ANY);
 367
 368     e = g_new(flxServerEntry, 1);
 369     e->record = flx_record_ref(r);
 370     e->id = id;
 371     e->interface = interface;
 372     e->protocol = protocol;
 373     e->unique = unique;
 374
 375     FLX_LLIST_HEAD_INIT(flxAnnouncement, e->announcements);
 376
 377     FLX_LLIST_PREPEND(flxServerEntry, entry, s->entries, e);
 378
 379     /* Insert into hash table indexed by id */
 380     t = g_hash_table_lookup(s->rrset_by_id, &e->id);
 381     FLX_LLIST_PREPEND(flxServerEntry, by_id, t, e);
 382     g_hash_table_replace(s->rrset_by_id, &e->id, t);
 383
 384     /* Insert into hash table indexed by name */
 385     t = g_hash_table_lookup(s->rrset_by_key, e->record->key);
 386     FLX_LLIST_PREPEND(flxServerEntry, by_key, t, e);
 387     g_hash_table_replace(s->rrset_by_key, e->record->key, t);
 388
 389     flx_announce_entry(s, e);
 390 }
 391
 392 void flx_server_add_full(
 393     flxServer *s,
 394     gint id,
 395     gint interface,
 396     guchar protocol,
 397     gboolean unique,
 398     const gchar *name,
 399     guint16 class,
 400     guint16 type,
 401     gconstpointer data,
 402     guint size,
 403     guint32 ttl) {
 404
 405     flxRecord *r;
 406     g_assert(s);
 407     g_assert(data);
 408     g_assert(size);
 409
 410     r = flx_record_new_full(name ? name : s->hostname, class, type, data, size, ttl);
 411     flx_server_add(s, id, interface, protocol, unique, r);
 412     flx_record_unref(r);
 413 }
 414
 415 const flxRecord *flx_server_iterate(flxServer *s, gint id, void **state) {
 416     flxServerEntry **e = (flxServerEntry**) state;
 417     g_assert(s);
 418     g_assert(e);
 419
 420     if (e)
 421         *e = id > 0 ? (*e)->by_id_next : (*e)->entry_next;
 422     else
 423         *e = id > 0 ? g_hash_table_lookup(s->rrset_by_id, &id) : s->entries;
 424
 425     if (!*e)
 426         return NULL;
 427
 428     return flx_record_ref((*e)->record);
 429 }
 430
 431 static void free_entry(flxServer*s, flxServerEntry *e) {
 432     flxServerEntry *t;
 433
 434     g_assert(e);
 435
 436     flx_goodbye_entry(s, e, TRUE);
 437
 438     /* Remove from linked list */
 439     FLX_LLIST_REMOVE(flxServerEntry, entry, s->entries, e);
 440
 441     /* Remove from hash table indexed by id */
 442     t = g_hash_table_lookup(s->rrset_by_id, &e->id);
 443     FLX_LLIST_REMOVE(flxServerEntry, by_id, t, e);
 444     if (t)
 445         g_hash_table_replace(s->rrset_by_id, &t->id, t);
 446     else
 447         g_hash_table_remove(s->rrset_by_id, &e->id);
 448
 449     /* Remove from hash table indexed by name */
 450     t = g_hash_table_lookup(s->rrset_by_key, e->record->key);
 451     FLX_LLIST_REMOVE(flxServerEntry, by_key, t, e);
 452     if (t)
 453         g_hash_table_replace(s->rrset_by_key, t->record->key, t);
 454     else
 455         g_hash_table_remove(s->rrset_by_key, e->record->key);
 456
 457     flx_record_unref(e->record);
 458     g_free(e);
 459 }
 460
 461 void flx_server_remove(flxServer *s, gint id) {
 462     g_assert(s);
 463
 464     if (id <= 0) {
 465         while (s->entries)
 466             free_entry(s, s->entries);
 467     } else {
 468         flxServerEntry *e;
 469
 470         while ((e = g_hash_table_lookup(s->rrset_by_id, &id)))
 471             free_entry(s, e);
 472     }
 473 }
 474
 475 void flx_server_dump(flxServer *s, FILE *f) {
 476     flxServerEntry *e;
 477     g_assert(s);
 478     g_assert(f);
 479
 480     fprintf(f, "\n;;; ZONE DUMP FOLLOWS ;;;\n");
 481
 482     for (e = s->entries; e; e = e->entry_next) {
 483         gchar *t;
 484
 485         t = flx_record_to_string(e->record);
 486         fprintf(f, "%s\n", t);
 487         g_free(t);
 488     }
 489
 490     flx_dump_caches(s->monitor, f);
 491 }
 492
 493 void flx_server_add_address(
 494     flxServer *s,
 495     gint id,
 496     gint interface,
 497     guchar protocol,
 498     gboolean unique,
 499     const gchar *name,
 500     flxAddress *a) {
 501
 502     gchar *n;
 503     g_assert(s);
 504     g_assert(a);
 505
 506     n = name ? flx_normalize_name(name) : s->hostname;
 507
 508     if (a->family == AF_INET) {
 509         gchar *r;
 510
 511         flx_server_add_full(s, id, interface, protocol, unique, n, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_A, &a->data.ipv4, sizeof(a->data.ipv4), FLX_DEFAULT_TTL);
 512
 513         r = flx_reverse_lookup_name_ipv4(&a->data.ipv4);
 514         g_assert(r);
 515         flx_server_add_full(s, id, interface, protocol, unique, r, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_PTR, n, strlen(n)+1, FLX_DEFAULT_TTL);
 516         g_free(r);
 517
 518     } else {
 519         gchar *r;
 520
 521         flx_server_add_full(s, id, interface, protocol, unique, n, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_AAAA, &a->data.ipv6, sizeof(a->data.ipv6), FLX_DEFAULT_TTL);
 522
 523         r = flx_reverse_lookup_name_ipv6_arpa(&a->data.ipv6);
 524         g_assert(r);
 525         flx_server_add_full(s, id, interface, protocol, unique, r, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_PTR, n, strlen(n)+1, FLX_DEFAULT_TTL);
 526         g_free(r);
 527
 528         r = flx_reverse_lookup_name_ipv6_int(&a->data.ipv6);
 529         g_assert(r);
 530         flx_server_add_full(s, id, interface, protocol, unique, r, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_PTR, n, strlen(n)+1, FLX_DEFAULT_TTL);
 531         g_free(r);
 532     }
 533
 534     g_free(n);
 535 }
 536
 537 void flx_server_add_text(
 538     flxServer *s,
 539     gint id,
 540     gint interface,
 541     guchar protocol,
 542     gboolean unique,
 543     const gchar *name,
 544     const gchar *text) {
 545
 546     gchar buf[256];
 547     guint l;
 548
 549     g_assert(s);
 550     g_assert(text);
 551
 552     if ((l = strlen(text)) > 255)
 553         buf[0] = 255;
 554     else
 555         buf[0] = (gchar) l;
 556
 557     memcpy(buf+1, text, l);
 558
 559     flx_server_add_full(s, id, interface, protocol, unique, name, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_TXT, buf, l+1, FLX_DEFAULT_TTL);
 560 }
 561
 562 static void post_query_callback(flxInterfaceMonitor *m, flxInterface *i, gpointer userdata) {
 563     flxKey *k = userdata;
 564
 565     g_assert(m);
 566     g_assert(i);
 567     g_assert(k);
 568
 569     flx_interface_post_query(i, k, FALSE);
 570 }
 571
 572 void flx_server_post_query(flxServer *s, gint interface, guchar protocol, flxKey *key) {
 573     g_assert(s);
 574     g_assert(key);
 575
 576     flx_interface_monitor_walk(s->monitor, interface, protocol, post_query_callback, key);
 577 }
 578
 579 static void post_response_callback(flxInterfaceMonitor *m, flxInterface *i, gpointer userdata) {
 580     flxRecord *r = userdata;
 581
 582     g_assert(m);
 583     g_assert(i);
 584     g_assert(r);
 585
 586     flx_interface_post_response(i, r, FALSE);
 587 }
 588
 589 void flx_server_post_response(flxServer *s, gint interface, guchar protocol, flxRecord *record) {
 590     g_assert(s);
 591     g_assert(record);
 592
 593     flx_interface_monitor_walk(s->monitor, interface, protocol, post_response_callback, record);
 594 }