k->class = class;
k->type = type;
+/* g_message("%p %% ref=1", k); */
+
return k;
}
g_assert(k->ref >= 1);
k->ref++;
+
+/* g_message("%p ++ ref=%i", k, k->ref); */
+
return k;
}
g_assert(k);
g_assert(k->ref >= 1);
+/* g_message("%p -- ref=%i", k, k->ref-1); */
+
if ((--k->ref) <= 0) {
g_free(k->name);
g_free(k);
flxRecord *r;
g_assert(k);
- g_assert(data);
- g_assert(size > 0);
- g_assert(ttl > 0);
-
+ g_assert(size == 0 || data);
+
r = g_new(flxRecord, 1);
r->ref = 1;
r->key = flx_key_ref(k);
- r->data = g_memdup(data, size);
+ r->data = size > 0 ? g_memdup(data, size) : NULL;
r->size = size;
r->ttl = ttl;
flxRecord *flx_record_new_full(const gchar *name, guint16 class, guint16 type, gconstpointer data, guint16 size, guint32 ttl) {
flxRecord *r;
flxKey *k;
+
+ g_assert(name);
+ g_assert(size == 0 || data);
k = flx_key_new(name, class, type);
r = flx_record_new(k, data, size, ttl);
const gchar *flx_dns_type_to_string(guint16 type) {
switch (type) {
+ case FLX_DNS_TYPE_CNAME:
+ return "CNAME";
case FLX_DNS_TYPE_A:
return "A";
case FLX_DNS_TYPE_AAAA:
return "HINFO";
case FLX_DNS_TYPE_TXT:
return "TXT";
+ case FLX_DNS_TYPE_SRV:
+ return "SRV";
default:
return NULL;
}
gchar *flx_record_to_string(flxRecord *r) {
gchar *p, *s;
- char t[256] = "<unparsable>";
-
- if (r->key->type == FLX_DNS_TYPE_A)
- inet_ntop(AF_INET, r->data, t, sizeof(t));
- else if (r->key->type == FLX_DNS_TYPE_AAAA)
- inet_ntop(AF_INET6, r->data, t, sizeof(t));
- else if (r->key->type == FLX_DNS_TYPE_PTR || r->key->type == FLX_DNS_TYPE_TXT) {
- size_t l;
-
- l = r->size;
- if (l > sizeof(t)-1)
- l = sizeof(t)-1;
-
- memcpy(t, r->data, l);
- t[l] = 0;
- } else if (r->key->type == FLX_DNS_TYPE_HINFO) {
- char *s2;
+ char t[257] = "<unparsable>";
+
+ switch (r->key->type) {
+ case FLX_DNS_TYPE_A:
+ inet_ntop(AF_INET, r->data, t, sizeof(t));
+ break;
+
+ case FLX_DNS_TYPE_AAAA:
+ inet_ntop(AF_INET6, r->data, t, sizeof(t));
+ break;
+
+ case FLX_DNS_TYPE_PTR: {
+ size_t l;
- if ((s2 = memchr(r->data, 0, r->size))) {
- s2++;
- if (memchr(s2, 0, r->size - ((char*) s2 - (char*) r->data)))
- snprintf(t, sizeof(t), "'%s' '%s'", (char*) r->data, s2);
+ l = r->size;
+ if (l > sizeof(t)-1)
+ l = sizeof(t)-1;
+
+ memcpy(t, r->data, l);
+ t[l] = 0;
+ break;
+ }
+
+ case FLX_DNS_TYPE_TXT: {
+
+ if (r->size == 0)
+ t[0] = 0;
+ else {
+ guchar l = ((guchar*) r->data)[0];
+
+ if ((size_t) l+1 <= r->size) {
+ memcpy(t, r->data+1, ((guchar*) r->data)[0]);
+ t[((guchar*) r->data)[0]] = 0;
+ }
+ }
+ break;
+ }
+
+ case FLX_DNS_TYPE_HINFO: {
+ gchar *s2;
+ gchar hi1[256], hi2[256];
+ guchar len;
+
+ if ((size_t) (len = ((guchar*) r->data)[0]) + 2 <= r->size) {
+ guchar len2;
+ memcpy(hi1, (gchar*) r->data +1, len);
+ hi1[len] = 0;
+
+ if ((size_t) (len2 = ((guchar*) r->data)[len+1]) + len + 2 <= r->size) {
+ memcpy(hi2, (gchar*) r->data+len+2, len2);
+ hi2[len2] = 0;
+ snprintf(t, sizeof(t), "'%s' '%s'", hi1, hi2);
+ }
+
+ }
+
+ break;
+ }
+
+ case FLX_DNS_TYPE_SRV: {
+ char k[257];
+ size_t l;
+
+ l = r->size-6;
+ if (l > sizeof(k)-1)
+ l = sizeof(k)-1;
+
+ memcpy(k, r->data+6, l);
+ k[l] = 0;
+
+ snprintf(t, sizeof(t), "%u %u %u %s",
+ ntohs(((guint16*) r->data)[0]),
+ ntohs(((guint16*) r->data)[1]),
+ ntohs(((guint16*) r->data)[2]),
+ k);
+ break;
}
}
p = flx_key_to_string(r->key);
- s = g_strdup_printf("%s %s", p, t);
+ s = g_strdup_printf("%s %s ; ttl=%u", p, t, r->ttl);
g_free(p);
return s;
gboolean flx_key_equal(const flxKey *a, const flxKey *b) {
g_assert(a);
g_assert(b);
+
+/* g_message("equal: %p %p", a, b); */
+
+ return strcmp(a->name, b->name) == 0 &&
+ a->type == b->type &&
+ a->class == b->class;
+}
+
+gboolean flx_key_pattern_match(const flxKey *pattern, const flxKey *k) {
+ g_assert(pattern);
+ g_assert(k);
+
+/* g_message("equal: %p %p", a, b); */
+
+ g_assert(!flx_key_is_pattern(k));
- return strcmp(a->name, b->name) == 0 && a->type == b->type && a->class == b->class;
+ return strcmp(pattern->name, k->name) == 0 &&
+ (pattern->type == k->type || pattern->type == FLX_DNS_TYPE_ANY) &&
+ pattern->class == k->class;
}
+gboolean flx_key_is_pattern(const flxKey *k) {
+ g_assert(k);
+
+ return k->type == FLX_DNS_TYPE_ANY;
+}
+
+
guint flx_key_hash(const flxKey *k) {
g_assert(k);
return g_str_hash(k->name) + k->type + k->class;
}
-gboolean flx_record_equal(const flxRecord *a, const flxRecord *b) {
+gboolean flx_record_equal_no_ttl(const flxRecord *a, const flxRecord *b) {
g_assert(a);
g_assert(b);
return flx_key_equal(a->key, b->key) &&
- a->ttl == b->ttl &&
+/* a->ttl == b->ttl && */
a->size == b->size &&
- memcmp(a->data, b->data, a->size) == 0;
+ (a->size == 0 || memcmp(a->data, b->data, a->size) == 0);
}