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

   1 #include <string.h>
   2 #include <stdio.h>
   3 #include <sys/types.h>
   4 #include <sys/socket.h>
   5 #include <arpa/inet.h>
   6
   7 #include "util.h"
   8 #include "rr.h"
   9
  10 flxKey *flx_key_new(const gchar *name, guint16 class, guint16 type) {
  11     flxKey *k;
  12     g_assert(name);
  13
  14     k = g_new(flxKey, 1);
  15     k->ref = 1;
  16     k->name = flx_normalize_name(name);
  17     k->class = class;
  18     k->type = type;
  19
  20 /*     g_message("%p %% ref=1", k); */
  21
  22     return k;
  23 }
  24
  25 flxKey *flx_key_ref(flxKey *k) {
  26     g_assert(k);
  27     g_assert(k->ref >= 1);
  28
  29     k->ref++;
  30
  31 /*     g_message("%p ++ ref=%i", k, k->ref); */
  32
  33     return k;
  34 }
  35
  36 void flx_key_unref(flxKey *k) {
  37     g_assert(k);
  38     g_assert(k->ref >= 1);
  39
  40 /*     g_message("%p -- ref=%i", k, k->ref-1); */
  41
  42     if ((--k->ref) <= 0) {
  43         g_free(k->name);
  44         g_free(k);
  45     }
  46 }
  47
  48 flxRecord *flx_record_new(flxKey *k, gconstpointer data, guint16 size, guint32 ttl) {
  49     flxRecord *r;
  50
  51     g_assert(k);
  52     g_assert(size == 0 || data);
  53
  54     r = g_new(flxRecord, 1);
  55     r->ref = 1;
  56     r->key = flx_key_ref(k);
  57     r->data = size > 0 ? g_memdup(data, size) : NULL;
  58     r->size = size;
  59     r->ttl = ttl;
  60
  61     return r;
  62 }
  63
  64 flxRecord *flx_record_new_full(const gchar *name, guint16 class, guint16 type, gconstpointer data, guint16 size, guint32 ttl) {
  65     flxRecord *r;
  66     flxKey *k;
  67
  68     g_assert(name);
  69     g_assert(size == 0 || data);
  70
  71     k = flx_key_new(name, class, type);
  72     r = flx_record_new(k, data, size, ttl);
  73     flx_key_unref(k);
  74
  75     return r;
  76 }
  77
  78 flxRecord *flx_record_ref(flxRecord *r) {
  79     g_assert(r);
  80     g_assert(r->ref >= 1);
  81
  82     r->ref++;
  83     return r;
  84 }
  85
  86 void flx_record_unref(flxRecord *r) {
  87     g_assert(r);
  88     g_assert(r->ref >= 1);
  89
  90     if ((--r->ref) <= 0) {
  91         flx_key_unref(r->key);
  92         g_free(r->data);
  93         g_free(r);
  94     }
  95 }
  96
  97 const gchar *flx_dns_class_to_string(guint16 class) {
  98     if (class == FLX_DNS_CLASS_IN)
  99         return "IN";
 100
 101     return NULL;
 102 }
 103
 104 const gchar *flx_dns_type_to_string(guint16 type) {
 105     switch (type) {
 106         case FLX_DNS_TYPE_CNAME:
 107             return "CNAME";
 108         case FLX_DNS_TYPE_A:
 109             return "A";
 110         case FLX_DNS_TYPE_AAAA:
 111             return "AAAA";
 112         case FLX_DNS_TYPE_PTR:
 113             return "PTR";
 114         case FLX_DNS_TYPE_HINFO:
 115             return "HINFO";
 116         case FLX_DNS_TYPE_TXT:
 117             return "TXT";
 118         case FLX_DNS_TYPE_SRV:
 119             return "SRV";
 120         default:
 121             return NULL;
 122     }
 123 }
 124
 125
 126 gchar *flx_key_to_string(flxKey *k) {
 127     return g_strdup_printf("%s\t%s\t%s",
 128                            k->name,
 129                            flx_dns_class_to_string(k->class),
 130                            flx_dns_type_to_string(k->type));
 131 }
 132
 133 gchar *flx_record_to_string(flxRecord *r) {
 134     gchar *p, *s;
 135     char t[257] = "<unparsable>";
 136
 137     switch (r->key->type) {
 138         case FLX_DNS_TYPE_A:
 139             inet_ntop(AF_INET, r->data, t, sizeof(t));
 140             break;
 141
 142         case FLX_DNS_TYPE_AAAA:
 143             inet_ntop(AF_INET6, r->data, t, sizeof(t));
 144             break;
 145
 146         case FLX_DNS_TYPE_PTR: {
 147             size_t l;
 148
 149             l = r->size;
 150             if (l > sizeof(t)-1)
 151                 l = sizeof(t)-1;
 152
 153             memcpy(t, r->data, l);
 154             t[l] = 0;
 155             break;
 156         }
 157
 158         case FLX_DNS_TYPE_TXT: {
 159
 160             if (r->size == 0)
 161                 t[0] = 0;
 162             else {
 163                 guchar l = ((guchar*) r->data)[0];
 164
 165                 if ((size_t) l+1 <= r->size) {
 166                     memcpy(t, r->data+1, ((guchar*) r->data)[0]);
 167                     t[((guchar*) r->data)[0]] = 0;
 168                 }
 169             }
 170             break;
 171         }
 172
 173         case FLX_DNS_TYPE_HINFO: {
 174             gchar *s2;
 175             gchar hi1[256], hi2[256];
 176             guchar len;
 177
 178             if ((size_t) (len = ((guchar*) r->data)[0]) + 2 <= r->size) {
 179                 guchar len2;
 180                 memcpy(hi1, (gchar*) r->data +1, len);
 181                 hi1[len] = 0;
 182
 183                 if ((size_t) (len2 = ((guchar*) r->data)[len+1]) + len + 2 <= r->size) {
 184                     memcpy(hi2, (gchar*) r->data+len+2, len2);
 185                     hi2[len2] = 0;
 186                     snprintf(t, sizeof(t), "'%s' '%s'", hi1, hi2);
 187                 }
 188
 189             }
 190
 191             break;
 192         }
 193
 194         case FLX_DNS_TYPE_SRV: {
 195             char k[257];
 196             size_t l;
 197
 198             l = r->size-6;
 199             if (l > sizeof(k)-1)
 200                 l = sizeof(k)-1;
 201
 202             memcpy(k, r->data+6, l);
 203             k[l] = 0;
 204
 205             snprintf(t, sizeof(t), "%u %u %u %s",
 206                      ntohs(((guint16*) r->data)[0]),
 207                      ntohs(((guint16*) r->data)[1]),
 208                      ntohs(((guint16*) r->data)[2]),
 209                      k);
 210             break;
 211         }
 212     }
 213
 214     p = flx_key_to_string(r->key);
 215     s = g_strdup_printf("%s %s ; ttl=%u", p, t, r->ttl);
 216     g_free(p);
 217
 218     return s;
 219 }
 220
 221 gboolean flx_key_equal(const flxKey *a, const flxKey *b) {
 222     g_assert(a);
 223     g_assert(b);
 224
 225 /*     g_message("equal: %p %p", a, b); */
 226
 227     return strcmp(a->name, b->name) == 0 && a->type == b->type && a->class == b->class;
 228 }
 229
 230 guint flx_key_hash(const flxKey *k) {
 231     g_assert(k);
 232
 233     return g_str_hash(k->name) + k->type + k->class;
 234 }
 235
 236 gboolean flx_record_equal_no_ttl(const flxRecord *a, const flxRecord *b) {
 237     g_assert(a);
 238     g_assert(b);
 239
 240     return flx_key_equal(a->key, b->key) &&
 241 /*        a->ttl == b->ttl && */
 242         a->size == b->size &&
 243         (a->size == 0 || memcmp(a->data, b->data, a->size) == 0);
 244 }