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
   6 #include "server.h"
   7 #include "util.h"
   8 #include "iface.h"
   9
  10 static void add_default_entries(flxServer *s) {
  11     gint length = 0;
  12     struct utsname utsname;
  13     gchar *hinfo;
  14     flxAddress a;
  15
  16     g_assert(s);
  17
  18     /* Fill in HINFO rr */
  19     uname(&utsname);
  20     hinfo = g_strdup_printf("%s%c%s%n", g_strup(utsname.machine), 0, g_strup(utsname.sysname), &length);
  21
  22     flx_server_add_full(s, 0, 0, AF_UNSPEC, TRUE,
  23                         s->hostname, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_HINFO, hinfo, length+1, FLX_DEFAULT_TTL);
  24
  25     g_free(hinfo);
  26
  27     /* Add localhost entries */
  28     flx_address_parse("127.0.0.1", AF_INET, &a);
  29     flx_server_add_address(s, 0, 0, AF_UNSPEC, TRUE, "localhost", &a);
  30
  31     flx_address_parse("::1", AF_INET6, &a);
  32     flx_server_add_address(s, 0, 0, AF_UNSPEC, TRUE, "ip6-localhost", &a);
  33 }
  34
  35 flxServer *flx_server_new(GMainContext *c) {
  36     gchar *hn, *e;
  37     flxServer *s;
  38
  39     s = g_new(flxServer, 1);
  40
  41     if (c)
  42         g_main_context_ref(s->context = c);
  43     else
  44         s->context = g_main_context_default();
  45
  46     s->current_id = 1;
  47     s->rrset_by_id = g_hash_table_new(g_int_hash, g_int_equal);
  48     s->rrset_by_name = g_hash_table_new((GHashFunc) flx_key_hash, (GEqualFunc) flx_key_equal);
  49
  50     FLX_LLIST_HEAD_INIT(flxEntry, s->entries);
  51
  52     s->monitor = flx_interface_monitor_new(s);
  53     s->time_event_queue = flx_time_event_queue_new(s->context);
  54
  55     /* Get host name */
  56     hn = flx_get_host_name();
  57     if ((e = strchr(hn, '.')))
  58         *e = 0;
  59
  60     s->hostname = g_strdup_printf("%s.local.", hn);
  61     g_free(hn);
  62
  63     add_default_entries(s);
  64
  65     return s;
  66 }
  67
  68 void flx_server_free(flxServer* s) {
  69     g_assert(s);
  70
  71     flx_interface_monitor_free(s->monitor);
  72
  73     flx_server_remove(s, 0);
  74
  75     g_hash_table_destroy(s->rrset_by_id);
  76     g_hash_table_destroy(s->rrset_by_name);
  77
  78     flx_time_event_queue_free(s->time_event_queue);
  79     g_main_context_unref(s->context);
  80
  81     g_free(s->hostname);
  82     g_free(s);
  83 }
  84
  85 gint flx_server_get_next_id(flxServer *s) {
  86     g_assert(s);
  87
  88     return s->current_id++;
  89 }
  90
  91 void flx_server_add(
  92     flxServer *s,
  93     gint id,
  94     gint interface,
  95     guchar protocol,
  96     gboolean unique,
  97     flxRecord *r) {
  98
  99     flxEntry *e, *t;
 100     g_assert(s);
 101     g_assert(r);
 102
 103     e = g_new(flxEntry, 1);
 104     e->record = flx_record_ref(r);
 105     e->id = id;
 106     e->interface = interface;
 107     e->protocol = protocol;
 108     e->unique = unique;
 109
 110     FLX_LLIST_PREPEND(flxEntry, entry, s->entries, e);
 111
 112     /* Insert into hash table indexed by id */
 113     t = g_hash_table_lookup(s->rrset_by_id, &e->id);
 114     FLX_LLIST_PREPEND(flxEntry, by_id, t, e);
 115     g_hash_table_replace(s->rrset_by_id, &e->id, t);
 116
 117     /* Insert into hash table indexed by name */
 118     t = g_hash_table_lookup(s->rrset_by_name, e->record->key);
 119     FLX_LLIST_PREPEND(flxEntry, by_name, t, e);
 120     g_hash_table_replace(s->rrset_by_name, e->record->key, t);
 121 }
 122
 123 void flx_server_add_full(
 124     flxServer *s,
 125     gint id,
 126     gint interface,
 127     guchar protocol,
 128     gboolean unique,
 129     const gchar *name,
 130     guint16 class,
 131     guint16 type,
 132     gconstpointer data,
 133     guint size,
 134     guint32 ttl) {
 135
 136     flxRecord *r;
 137     g_assert(s);
 138     g_assert(data);
 139     g_assert(size);
 140
 141     r = flx_record_new_full(name ? name : s->hostname, class, type, data, size, ttl);
 142     flx_server_add(s, id, interface, protocol, unique, r);
 143     flx_record_unref(r);
 144 }
 145
 146 const flxRecord *flx_server_iterate(flxServer *s, gint id, void **state) {
 147     flxEntry **e = (flxEntry**) state;
 148     g_assert(s);
 149     g_assert(e);
 150
 151     if (e)
 152         *e = id > 0 ? (*e)->by_id_next : (*e)->entry_next;
 153     else
 154         *e = id > 0 ? g_hash_table_lookup(s->rrset_by_id, &id) : s->entries;
 155
 156     if (!*e)
 157         return NULL;
 158
 159     return flx_record_ref((*e)->record);
 160 }
 161
 162 static void free_entry(flxServer*s, flxEntry *e) {
 163     flxEntry *t;
 164
 165     g_assert(e);
 166
 167     /* Remove from linked list */
 168     FLX_LLIST_REMOVE(flxEntry, entry, s->entries, e);
 169
 170     /* Remove from hash table indexed by id */
 171     t = g_hash_table_lookup(s->rrset_by_id, &e->id);
 172     FLX_LLIST_REMOVE(flxEntry, by_id, t, e);
 173     if (t)
 174         g_hash_table_replace(s->rrset_by_id, &t->id, t);
 175     else
 176         g_hash_table_remove(s->rrset_by_id, &e->id);
 177
 178     /* Remove from hash table indexed by name */
 179     t = g_hash_table_lookup(s->rrset_by_name, e->record->key);
 180     FLX_LLIST_REMOVE(flxEntry, by_name, t, e);
 181     if (t)
 182         g_hash_table_replace(s->rrset_by_name, t->record->key, t);
 183     else
 184         g_hash_table_remove(s->rrset_by_name, e->record->key);
 185
 186     flx_record_unref(e->record);
 187     g_free(e);
 188 }
 189
 190 void flx_server_remove(flxServer *s, gint id) {
 191     g_assert(s);
 192
 193     if (id <= 0) {
 194         while (s->entries)
 195             free_entry(s, s->entries);
 196     } else {
 197         flxEntry *e;
 198
 199         while ((e = g_hash_table_lookup(s->rrset_by_id, &id)))
 200             free_entry(s, e);
 201     }
 202 }
 203
 204 void flx_server_dump(flxServer *s, FILE *f) {
 205     flxEntry *e;
 206     g_assert(s);
 207     g_assert(f);
 208
 209     for (e = s->entries; e; e = e->entry_next) {
 210         gchar *t;
 211
 212         t = flx_record_to_string(e->record);
 213         fprintf(f, "%s\n", t);
 214         g_free(t);
 215     }
 216 }
 217
 218 void flx_server_add_address(
 219     flxServer *s,
 220     gint id,
 221     gint interface,
 222     guchar protocol,
 223     gboolean unique,
 224     const gchar *name,
 225     flxAddress *a) {
 226
 227     gchar *n;
 228     g_assert(s);
 229     g_assert(a);
 230
 231     n = name ? flx_normalize_name(name) : s->hostname;
 232
 233     if (a->family == AF_INET) {
 234         gchar *r;
 235
 236         flx_server_add_full(s, id, interface, protocol, unique, n, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_A, &a->ipv4, sizeof(a->ipv4), FLX_DEFAULT_TTL);
 237
 238         r = flx_reverse_lookup_name_ipv4(&a->ipv4);
 239         g_assert(r);
 240         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);
 241         g_free(r);
 242
 243     } else {
 244         gchar *r;
 245
 246         flx_server_add_full(s, id, interface, protocol, unique, n, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_AAAA, &a->ipv6, sizeof(a->ipv6), FLX_DEFAULT_TTL);
 247
 248         r = flx_reverse_lookup_name_ipv6_arpa(&a->ipv6);
 249         g_assert(r);
 250         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);
 251         g_free(r);
 252
 253         r = flx_reverse_lookup_name_ipv6_int(&a->ipv6);
 254         g_assert(r);
 255         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);
 256         g_free(r);
 257     }
 258
 259     g_free(n);
 260 }
 261
 262 void flx_server_add_text(
 263     flxServer *s,
 264     gint id,
 265     gint interface,
 266     guchar protocol,
 267     gboolean unique,
 268     const gchar *name,
 269     const gchar *text) {
 270
 271     g_assert(s);
 272     g_assert(text);
 273
 274     flx_server_add_full(s, id, interface, protocol, unique, name, FLX_DNS_CLASS_IN, FLX_DNS_TYPE_TXT, text, strlen(text), FLX_DEFAULT_TTL);
 275 }
 276
 277 void flx_server_send_query(flxServer *s, gint interface, guchar protocol, flxKey *k) {
 278     g_assert(s);
 279     g_assert(k);
 280
 281     if (interface <= 0) {
 282         flxInterface *i;
 283
 284         for (i = flx_interface_monitor_get_first(s->monitor); i; i = i->interface_next)
 285             flx_interface_send_query(i, protocol, k);
 286
 287     } else {
 288         flxInterface *i;
 289
 290         if (!(i = flx_interface_monitor_get_interface(s->monitor, interface)))
 291             return;
 292
 293         flx_interface_send_query(i, protocol, k);
 294     }
 295 }