X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=psched.c;h=faa2fa9344f9dd9f043aa688c8b14a0738b71a90;hb=7dce450bdc23ea306a61e00f914481e29ebcb176;hp=22474f3f2692351b05d88163eaf9e0f6cbd7b156;hpb=bf2db17686a0e29b4e855cadbbaa5e5e4ed2def8;p=catta

diff --git a/psched.c b/psched.c
index 22474f3..faa2fa9 100644
--- a/psched.c
+++ b/psched.c
@@ -3,72 +3,72 @@
 #include "util.h"
 #include "psched.h"
 
-#define FLX_QUERY_HISTORY_MSEC 100
-#define FLX_QUERY_DEFER_MSEC 100
-#define FLX_RESPONSE_HISTORY_MSEC 700
-#define FLX_RESPONSE_DEFER_MSEC 20
-#define FLX_RESPONSE_JITTER_MSEC 100
-#define FLX_PROBE_DEFER_MSEC 20
+#define AVAHI_QUERY_HISTORY_MSEC 100
+#define AVAHI_QUERY_DEFER_MSEC 100
+#define AVAHI_RESPONSE_HISTORY_MSEC 700
+#define AVAHI_RESPONSE_DEFER_MSEC 20
+#define AVAHI_RESPONSE_JITTER_MSEC 100
+#define AVAHI_PROBE_DEFER_MSEC 70
 
-flxPacketScheduler *flx_packet_scheduler_new(flxServer *server, flxInterface *i) {
-    flxPacketScheduler *s;
+AvahiPacketScheduler *avahi_packet_scheduler_new(AvahiServer *server, AvahiInterface *i) {
+    AvahiPacketScheduler *s;
 
     g_assert(server);
     g_assert(i);
 
-    s = g_new(flxPacketScheduler, 1);
+    s = g_new(AvahiPacketScheduler, 1);
     s->server = server;
     s->interface = i;
 
-    FLX_LLIST_HEAD_INIT(flxQueryJob, s->query_jobs);
-    FLX_LLIST_HEAD_INIT(flxResponseJob, s->response_jobs);
-    FLX_LLIST_HEAD_INIT(flxKnownAnswer, s->known_answers);
-    FLX_LLIST_HEAD_INIT(flxProbeJob, s->probe_jobs);
+    AVAHI_LLIST_HEAD_INIT(AvahiQueryJob, s->query_jobs);
+    AVAHI_LLIST_HEAD_INIT(AvahiResponseJob, s->response_jobs);
+    AVAHI_LLIST_HEAD_INIT(AvahiKnownAnswer, s->known_answers);
+    AVAHI_LLIST_HEAD_INIT(AvahiProbeJob, s->probe_jobs);
     
     return s;
 }
 
-static void query_job_free(flxPacketScheduler *s, flxQueryJob *qj) {
+static void query_job_free(AvahiPacketScheduler *s, AvahiQueryJob *qj) {
     g_assert(qj);
 
     if (qj->time_event)
-        flx_time_event_queue_remove(qj->scheduler->server->time_event_queue, qj->time_event);
+        avahi_time_event_queue_remove(qj->scheduler->server->time_event_queue, qj->time_event);
 
-    FLX_LLIST_REMOVE(flxQueryJob, jobs, s->query_jobs, qj);
+    AVAHI_LLIST_REMOVE(AvahiQueryJob, jobs, s->query_jobs, qj);
     
-    flx_key_unref(qj->key);
+    avahi_key_unref(qj->key);
     g_free(qj);
 }
 
-static void response_job_free(flxPacketScheduler *s, flxResponseJob *rj) {
+static void response_job_free(AvahiPacketScheduler *s, AvahiResponseJob *rj) {
     g_assert(rj);
 
     if (rj->time_event)
-        flx_time_event_queue_remove(rj->scheduler->server->time_event_queue, rj->time_event);
+        avahi_time_event_queue_remove(rj->scheduler->server->time_event_queue, rj->time_event);
 
-    FLX_LLIST_REMOVE(flxResponseJob, jobs, s->response_jobs, rj);
+    AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->response_jobs, rj);
 
-    flx_record_unref(rj->record);
+    avahi_record_unref(rj->record);
     g_free(rj);
 }
 
-static void probe_job_free(flxPacketScheduler *s, flxProbeJob *pj) {
+static void probe_job_free(AvahiPacketScheduler *s, AvahiProbeJob *pj) {
     g_assert(pj);
 
     if (pj->time_event)
-        flx_time_event_queue_remove(pj->scheduler->server->time_event_queue, pj->time_event);
+        avahi_time_event_queue_remove(pj->scheduler->server->time_event_queue, pj->time_event);
 
-    FLX_LLIST_REMOVE(flxProbeJob, jobs, s->probe_jobs, pj);
+    AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->probe_jobs, pj);
 
-    flx_record_unref(pj->record);
+    avahi_record_unref(pj->record);
     g_free(pj);
 }
 
-void flx_packet_scheduler_free(flxPacketScheduler *s) {
-    flxQueryJob *qj;
-    flxResponseJob *rj;
-    flxProbeJob *pj;
-    flxTimeEvent *e;
+void avahi_packet_scheduler_free(AvahiPacketScheduler *s) {
+    AvahiQueryJob *qj;
+    AvahiResponseJob *rj;
+    AvahiProbeJob *pj;
+    AvahiTimeEvent *e;
 
     g_assert(s);
 
@@ -84,53 +84,53 @@ void flx_packet_scheduler_free(flxPacketScheduler *s) {
     g_free(s);
 }
 
-static gpointer known_answer_walk_callback(flxCache *c, flxKey *pattern, flxCacheEntry *e, gpointer userdata) {
-    flxPacketScheduler *s = userdata;
-    flxKnownAnswer *ka;
+static gpointer known_answer_walk_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, gpointer userdata) {
+    AvahiPacketScheduler *s = userdata;
+    AvahiKnownAnswer *ka;
     
     g_assert(c);
     g_assert(pattern);
     g_assert(e);
     g_assert(s);
 
-    if (flx_cache_entry_half_ttl(c, e))
+    if (avahi_cache_entry_half_ttl(c, e))
         return NULL;
     
-    ka = g_new0(flxKnownAnswer, 1);
+    ka = g_new0(AvahiKnownAnswer, 1);
     ka->scheduler = s;
-    ka->record = flx_record_ref(e->record);
+    ka->record = avahi_record_ref(e->record);
 
-    FLX_LLIST_PREPEND(flxKnownAnswer, known_answer, s->known_answers, ka);
+    AVAHI_LLIST_PREPEND(AvahiKnownAnswer, known_answer, s->known_answers, ka);
     return NULL;
 }
 
-static guint8* packet_add_query_job(flxPacketScheduler *s, flxDnsPacket *p, flxQueryJob *qj) {
+static guint8* packet_add_query_job(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiQueryJob *qj) {
     guint8 *d;
 
     g_assert(s);
     g_assert(p);
     g_assert(qj);
 
-    if ((d = flx_dns_packet_append_key(p, qj->key))) {
+    if ((d = avahi_dns_packet_append_key(p, qj->key, FALSE))) {
         GTimeVal tv;
 
         qj->done = 1;
 
         /* Drop query after some time from history */
-        flx_elapse_time(&tv, FLX_QUERY_HISTORY_MSEC, 0);
-        flx_time_event_queue_update(s->server->time_event_queue, qj->time_event, &tv);
+        avahi_elapse_time(&tv, AVAHI_QUERY_HISTORY_MSEC, 0);
+        avahi_time_event_queue_update(s->server->time_event_queue, qj->time_event, &tv);
 
         g_get_current_time(&qj->delivery);
 
         /* Add all matching known answers to the list */
-        flx_cache_walk(s->interface->cache, qj->key, known_answer_walk_callback, s);
+        avahi_cache_walk(s->interface->cache, qj->key, known_answer_walk_callback, s);
     }
 
     return d;
 }
 
-static void append_known_answers_and_send(flxPacketScheduler *s, flxDnsPacket *p) {
-    flxKnownAnswer *ka;
+static void append_known_answers_and_send(AvahiPacketScheduler *s, AvahiDnsPacket *p) {
+    AvahiKnownAnswer *ka;
     guint n;
     g_assert(s);
     g_assert(p);
@@ -139,35 +139,35 @@ static void append_known_answers_and_send(flxPacketScheduler *s, flxDnsPacket *p
     
     while ((ka = s->known_answers)) {
 
-        while (!flx_dns_packet_append_record(p, ka->record, FALSE)) {
+        while (!avahi_dns_packet_append_record(p, ka->record, FALSE)) {
 
-            g_assert(!flx_dns_packet_is_empty(p));
+            g_assert(!avahi_dns_packet_is_empty(p));
 
-            flx_dns_packet_set_field(p, FLX_DNS_FIELD_FLAGS, flx_dns_packet_get_field(p, FLX_DNS_FIELD_FLAGS) | FLX_DNS_FLAG_TC);
-            flx_dns_packet_set_field(p, FLX_DNS_FIELD_ANCOUNT, n);
-            flx_interface_send_packet(s->interface, p);
-            flx_dns_packet_free(p);
+            avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_FLAGS, avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) | AVAHI_DNS_FLAG_TC);
+            avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
+            avahi_interface_send_packet(s->interface, p);
+            avahi_dns_packet_free(p);
 
-            p = flx_dns_packet_new_query(s->interface->hardware->mtu - 48);
+            p = avahi_dns_packet_new_query(s->interface->hardware->mtu - 48);
             n = 0;
         }
 
-        FLX_LLIST_REMOVE(flxKnownAnswer, known_answer, s->known_answers, ka);
-        flx_record_unref(ka->record);
+        AVAHI_LLIST_REMOVE(AvahiKnownAnswer, known_answer, s->known_answers, ka);
+        avahi_record_unref(ka->record);
         g_free(ka);
         
         n++;
     }
     
-    flx_dns_packet_set_field(p, FLX_DNS_FIELD_ANCOUNT, n);
-    flx_interface_send_packet(s->interface, p);
-    flx_dns_packet_free(p);
+    avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
+    avahi_interface_send_packet(s->interface, p);
+    avahi_dns_packet_free(p);
 }
 
-static void query_elapse(flxTimeEvent *e, gpointer data) {
-    flxQueryJob *qj = data;
-    flxPacketScheduler *s;
-    flxDnsPacket *p;
+static void query_elapse(AvahiTimeEvent *e, gpointer data) {
+    AvahiQueryJob *qj = data;
+    AvahiPacketScheduler *s;
+    AvahiDnsPacket *p;
     guint n;
     guint8 *d;
 
@@ -182,7 +182,7 @@ static void query_elapse(flxTimeEvent *e, gpointer data) {
 
     g_assert(!s->known_answers);
     
-    p = flx_dns_packet_new_query(s->interface->hardware->mtu - 48);
+    p = avahi_dns_packet_new_query(s->interface->hardware->mtu - 48);
     d = packet_add_query_job(s, p, qj);
     g_assert(d);
     n = 1;
@@ -199,46 +199,46 @@ static void query_elapse(flxTimeEvent *e, gpointer data) {
         n++;
     }
 
-    flx_dns_packet_set_field(p, FLX_DNS_FIELD_QDCOUNT, n);
+    avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
 
     /* Now add known answers */
     append_known_answers_and_send(s, p);
 }
 
-flxQueryJob* query_job_new(flxPacketScheduler *s, flxKey *key) {
-    flxQueryJob *qj;
+AvahiQueryJob* query_job_new(AvahiPacketScheduler *s, AvahiKey *key) {
+    AvahiQueryJob *qj;
     
     g_assert(s);
     g_assert(key);
 
-    qj = g_new(flxQueryJob, 1);
+    qj = g_new(AvahiQueryJob, 1);
     qj->scheduler = s;
-    qj->key = flx_key_ref(key);
+    qj->key = avahi_key_ref(key);
     qj->done = FALSE;
     qj->time_event = NULL;
     
-    FLX_LLIST_PREPEND(flxQueryJob, jobs, s->query_jobs, qj);
+    AVAHI_LLIST_PREPEND(AvahiQueryJob, jobs, s->query_jobs, qj);
 
     return qj;
 }
 
-void flx_packet_scheduler_post_query(flxPacketScheduler *s, flxKey *key, gboolean immediately) {
+void avahi_packet_scheduler_post_query(AvahiPacketScheduler *s, AvahiKey *key, gboolean immediately) {
     GTimeVal tv;
-    flxQueryJob *qj;
+    AvahiQueryJob *qj;
     
     g_assert(s);
     g_assert(key);
 
-    flx_elapse_time(&tv, immediately ? 0 : FLX_QUERY_DEFER_MSEC, 0);
+    avahi_elapse_time(&tv, immediately ? 0 : AVAHI_QUERY_DEFER_MSEC, 0);
 
     for (qj = s->query_jobs; qj; qj = qj->jobs_next) {
 
-        if (flx_key_equal(qj->key, key)) {
+        if (avahi_key_equal(qj->key, key)) {
 
-            glong d = flx_timeval_diff(&tv, &qj->delivery);
+            glong d = avahi_timeval_diff(&tv, &qj->delivery);
 
             /* Duplicate questions suppression */
-            if (d >= 0 && d <= FLX_QUERY_HISTORY_MSEC*1000) {
+            if (d >= 0 && d <= AVAHI_QUERY_HISTORY_MSEC*1000) {
                 g_message("WARNING! DUPLICATE QUERY SUPPRESSION ACTIVE!");
                 return;
             }
@@ -251,24 +251,24 @@ void flx_packet_scheduler_post_query(flxPacketScheduler *s, flxKey *key, gboolea
     
     qj = query_job_new(s, key);
     qj->delivery = tv;
-    qj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &qj->delivery, query_elapse, qj);
+    qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &qj->delivery, query_elapse, qj);
 }
 
-static guint8* packet_add_response_job(flxPacketScheduler *s, flxDnsPacket *p, flxResponseJob *rj) {
+static guint8* packet_add_response_job(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiResponseJob *rj) {
     guint8 *d;
 
     g_assert(s);
     g_assert(p);
     g_assert(rj);
 
-    if ((d = flx_dns_packet_append_record(p, rj->record, rj->flush_cache))) {
+    if ((d = avahi_dns_packet_append_record(p, rj->record, rj->flush_cache))) {
         GTimeVal tv;
 
         rj->done = 1;
 
         /* Drop response after some time from history */
-        flx_elapse_time(&tv, FLX_RESPONSE_HISTORY_MSEC, 0);
-        flx_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
+        avahi_elapse_time(&tv, AVAHI_RESPONSE_HISTORY_MSEC, 0);
+        avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
 
         g_get_current_time(&rj->delivery);
     }
@@ -276,13 +276,13 @@ static guint8* packet_add_response_job(flxPacketScheduler *s, flxDnsPacket *p, f
     return d;
 }
 
-static void send_response_packet(flxPacketScheduler *s, flxResponseJob *rj) {
-    flxDnsPacket *p;
+static void send_response_packet(AvahiPacketScheduler *s, AvahiResponseJob *rj) {
+    AvahiDnsPacket *p;
     guint n;
 
     g_assert(s);
 
-    p = flx_dns_packet_new_response(s->interface->hardware->mtu - 200);
+    p = avahi_dns_packet_new_response(s->interface->hardware->mtu - 200);
     n = 0;
 
     /* If a job was specified, put it in the packet. */
@@ -305,14 +305,14 @@ static void send_response_packet(flxPacketScheduler *s, flxResponseJob *rj) {
         n++;
     }
 
-    flx_dns_packet_set_field(p, FLX_DNS_FIELD_ANCOUNT, n);
-    flx_interface_send_packet(s->interface, p);
-    flx_dns_packet_free(p);
+    avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
+    avahi_interface_send_packet(s->interface, p);
+    avahi_dns_packet_free(p);
 }
 
-static void response_elapse(flxTimeEvent *e, gpointer data) {
-    flxResponseJob *rj = data;
-    flxPacketScheduler *s;
+static void response_elapse(AvahiTimeEvent *e, gpointer data) {
+    AvahiResponseJob *rj = data;
+    AvahiPacketScheduler *s;
 
     g_assert(rj);
     s = rj->scheduler;
@@ -326,68 +326,68 @@ static void response_elapse(flxTimeEvent *e, gpointer data) {
     send_response_packet(s, rj);
 }
 
-static flxResponseJob* look_for_response(flxPacketScheduler *s, flxRecord *record) {
-    flxResponseJob *rj;
+static AvahiResponseJob* look_for_response(AvahiPacketScheduler *s, AvahiRecord *record) {
+    AvahiResponseJob *rj;
 
     g_assert(s);
     g_assert(record);
 
     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
-        if (flx_record_equal_no_ttl(rj->record, record))
+        if (avahi_record_equal_no_ttl(rj->record, record))
             return rj;
 
     return NULL;
 }
 
-static flxResponseJob* response_job_new(flxPacketScheduler *s, flxRecord *record) {
-    flxResponseJob *rj;
+static AvahiResponseJob* response_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
+    AvahiResponseJob *rj;
     
     g_assert(s);
     g_assert(record);
 
-    rj = g_new(flxResponseJob, 1);
+    rj = g_new(AvahiResponseJob, 1);
     rj->scheduler = s;
-    rj->record = flx_record_ref(record);
+    rj->record = avahi_record_ref(record);
     rj->done = FALSE;
     rj->time_event = NULL;
     rj->address_valid = FALSE;
     rj->flush_cache = FALSE;
     
-    FLX_LLIST_PREPEND(flxResponseJob, jobs, s->response_jobs, rj);
+    AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->response_jobs, rj);
 
     return rj;
 }
 
-void flx_packet_scheduler_post_response(flxPacketScheduler *s, const flxAddress *a, flxRecord *record, gboolean flush_cache, gboolean immediately) {
-    flxResponseJob *rj;
+void avahi_packet_scheduler_post_response(AvahiPacketScheduler *s, const AvahiAddress *a, AvahiRecord *record, gboolean flush_cache, gboolean immediately) {
+    AvahiResponseJob *rj;
     GTimeVal tv;
     gchar *t;
     
     g_assert(s);
     g_assert(record);
 
-    g_assert(!flx_key_is_pattern(record->key));
+    g_assert(!avahi_key_is_pattern(record->key));
     
-    flx_elapse_time(&tv, immediately ? 0 : FLX_RESPONSE_DEFER_MSEC, immediately ? 0 : FLX_RESPONSE_JITTER_MSEC);
+    avahi_elapse_time(&tv, immediately ? 0 : AVAHI_RESPONSE_DEFER_MSEC, immediately ? 0 : AVAHI_RESPONSE_JITTER_MSEC);
     
     /* Don't send out duplicates */
     
     if ((rj = look_for_response(s, record))) {
         glong d;
 
-        d = flx_timeval_diff(&tv, &rj->delivery);
+        d = avahi_timeval_diff(&tv, &rj->delivery);
         
         /* If there's already a matching packet in our history or in
          * the schedule, we do nothing. */
         if (!!record->ttl == !!rj->record->ttl &&
-            d >= 0 && d <= FLX_RESPONSE_HISTORY_MSEC*1000) {
+            d >= 0 && d <= AVAHI_RESPONSE_HISTORY_MSEC*1000) {
             g_message("WARNING! DUPLICATE RESPONSE SUPPRESSION ACTIVE!");
 
             /* This job is no longer specific to a single querier, so
              * make sure it isn't suppressed by known answer
              * suppresion */
 
-            if (rj->address_valid && (!a || flx_address_cmp(a, &rj->address) != 0))
+            if (rj->address_valid && (!a || avahi_address_cmp(a, &rj->address) != 0))
                 rj->address_valid = FALSE;
 
             rj->flush_cache = flush_cache;
@@ -400,14 +400,14 @@ void flx_packet_scheduler_post_response(flxPacketScheduler *s, const flxAddress
         response_job_free(s, rj);
     }
 
-    g_message("ACCEPTED NEW RESPONSE [%s]", t = flx_record_to_string(record));
-    g_free(t);
+/*     g_message("ACCEPTED NEW RESPONSE [%s]", t = avahi_record_to_string(record)); */
+/*     g_free(t); */
 
     /* Create a new job and schedule it */
     rj = response_job_new(s, record);
     rj->flush_cache = flush_cache;
     rj->delivery = tv;
-    rj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &rj->delivery, response_elapse, rj);
+    rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &rj->delivery, response_elapse, rj);
 
     /* Store the address of the host this messages is intended to, so
        that we can drop this job in case a truncated message with
@@ -417,9 +417,9 @@ void flx_packet_scheduler_post_response(flxPacketScheduler *s, const flxAddress
         rj->address = *a;
 }
 
-void flx_packet_scheduler_incoming_query(flxPacketScheduler *s, flxKey *key) {
+void avahi_packet_scheduler_incoming_query(AvahiPacketScheduler *s, AvahiKey *key) {
     GTimeVal tv;
-    flxQueryJob *qj;
+    AvahiQueryJob *qj;
     
     g_assert(s);
     g_assert(key);
@@ -429,7 +429,7 @@ void flx_packet_scheduler_incoming_query(flxPacketScheduler *s, flxKey *key) {
      * keyword is "DUPLICATE QUESTION SUPPRESION". */
 
     for (qj = s->query_jobs; qj; qj = qj->jobs_next)
-        if (flx_key_equal(qj->key, key)) {
+        if (avahi_key_equal(qj->key, key)) {
 
             if (qj->done)
                 return;
@@ -445,29 +445,29 @@ mark_done:
     qj->done = TRUE;
 
     /* Drop the query after some time */
-    flx_elapse_time(&tv, FLX_QUERY_HISTORY_MSEC, 0);
-    qj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &tv, query_elapse, qj);
+    avahi_elapse_time(&tv, AVAHI_QUERY_HISTORY_MSEC, 0);
+    qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, query_elapse, qj);
 
     g_get_current_time(&qj->delivery);
 }
 
-void response_job_set_elapse_time(flxPacketScheduler *s, flxResponseJob *rj, guint msec, guint jitter) {
+void response_job_set_elapse_time(AvahiPacketScheduler *s, AvahiResponseJob *rj, guint msec, guint jitter) {
     GTimeVal tv;
 
     g_assert(s);
     g_assert(rj);
 
-    flx_elapse_time(&tv, msec, jitter);
+    avahi_elapse_time(&tv, msec, jitter);
 
     if (rj->time_event)
-        flx_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
+        avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
     else
-        rj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &tv, response_elapse, rj);
+        rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, response_elapse, rj);
     
 }
 
-void flx_packet_scheduler_incoming_response(flxPacketScheduler *s, flxRecord *record) {
-    flxResponseJob *rj;
+void avahi_packet_scheduler_incoming_response(AvahiPacketScheduler *s, AvahiRecord *record) {
+    AvahiResponseJob *rj;
     
     g_assert(s);
     g_assert(record);
@@ -477,7 +477,7 @@ void flx_packet_scheduler_incoming_response(flxPacketScheduler *s, flxRecord *re
      * here. The keyword is "DUPLICATE ANSWER SUPPRESION". */
     
     for (rj = s->response_jobs; rj; rj = rj->jobs_next)
-        if (flx_record_equal_no_ttl(rj->record, record)) {
+        if (avahi_record_equal_no_ttl(rj->record, record)) {
 
             if (rj->done) {
 
@@ -522,13 +522,13 @@ mark_done:
     rj->done = TRUE;
                     
     /* Drop response after 500ms from history */
-    response_job_set_elapse_time(s, rj, FLX_RESPONSE_HISTORY_MSEC, 0);
+    response_job_set_elapse_time(s, rj, AVAHI_RESPONSE_HISTORY_MSEC, 0);
 
     g_get_current_time(&rj->delivery);
 }
 
-void flx_packet_scheduler_incoming_known_answer(flxPacketScheduler *s, flxRecord *record, const flxAddress *a) {
-    flxResponseJob *rj;
+void avahi_packet_scheduler_incoming_known_answer(AvahiPacketScheduler *s, AvahiRecord *record, const AvahiAddress *a) {
+    AvahiResponseJob *rj;
     
     g_assert(s);
     g_assert(record);
@@ -539,9 +539,9 @@ void flx_packet_scheduler_incoming_known_answer(flxPacketScheduler *s, flxRecord
         g_assert(record->ttl > 0);
         g_assert(rj->record->ttl/2);
         
-        if (flx_record_equal_no_ttl(rj->record, record))
+        if (avahi_record_equal_no_ttl(rj->record, record))
             if (rj->address_valid)
-                if (flx_address_cmp(&rj->address, a))
+                if (avahi_address_cmp(&rj->address, a))
                     if (record->ttl >= rj->record->ttl/2) {
 
             /* Let's suppress it */
@@ -552,8 +552,8 @@ void flx_packet_scheduler_incoming_known_answer(flxPacketScheduler *s, flxRecord
     }
 }
 
-void flx_packet_scheduler_flush_responses(flxPacketScheduler *s) {
-    flxResponseJob *rj;
+void avahi_packet_scheduler_flush_responses(AvahiPacketScheduler *s) {
+    AvahiResponseJob *rj;
     
     g_assert(s);
 
@@ -564,27 +564,27 @@ void flx_packet_scheduler_flush_responses(flxPacketScheduler *s) {
             send_response_packet(s, rj);
 }
 
-static flxProbeJob* probe_job_new(flxPacketScheduler *s, flxRecord *record) {
-    flxProbeJob *pj;
+static AvahiProbeJob* probe_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
+    AvahiProbeJob *pj;
     
     g_assert(s);
     g_assert(record);
 
-    pj = g_new(flxProbeJob, 1);
+    pj = g_new(AvahiProbeJob, 1);
     pj->scheduler = s;
-    pj->record = flx_record_ref(record);
+    pj->record = avahi_record_ref(record);
     pj->time_event = NULL;
     pj->chosen = FALSE;
     
-    FLX_LLIST_PREPEND(flxProbeJob, jobs, s->probe_jobs, pj);
+    AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->probe_jobs, pj);
 
     return pj;
 }
 
-static guint8* packet_add_probe_query(flxPacketScheduler *s, flxDnsPacket *p, flxProbeJob *pj) {
+static guint8* packet_add_probe_query(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) {
     guint size;
     guint8 *ret;
-    flxKey *k;
+    AvahiKey *k;
 
     g_assert(s);
     g_assert(p);
@@ -594,16 +594,16 @@ static guint8* packet_add_probe_query(flxPacketScheduler *s, flxDnsPacket *p, fl
     
     /* Estimate the size for this record */
     size =
-        flx_key_get_estimate_size(pj->record->key) +
-        flx_record_get_estimate_size(pj->record);
+        avahi_key_get_estimate_size(pj->record->key) +
+        avahi_record_get_estimate_size(pj->record);
 
     /* Too large */
-    if (size > flx_dns_packet_space(p))
+    if (size > avahi_dns_packet_space(p))
         return NULL;
 
     /* Create the probe query */
-    k = flx_key_new(pj->record->key->name, pj->record->key->class, FLX_DNS_TYPE_ANY);
-    ret = flx_dns_packet_append_key(p, k);
+    k = avahi_key_new(pj->record->key->name, pj->record->key->class, AVAHI_DNS_TYPE_ANY);
+    ret = avahi_dns_packet_append_key(p, k, FALSE);
     g_assert(ret);
 
     /* Mark this job for addition to the packet */
@@ -615,38 +615,38 @@ static guint8* packet_add_probe_query(flxPacketScheduler *s, flxDnsPacket *p, fl
             continue;
 
         /* Does the record match the probe? */
-        if (k->class != pj->record->key->class || flx_domain_equal(k->name, pj->record->key->name))
+        if (k->class != pj->record->key->class || !avahi_domain_equal(k->name, pj->record->key->name))
             continue;
         
         /* This job wouldn't fit in */
-        if (flx_record_get_estimate_size(pj->record) > flx_dns_packet_space(p))
+        if (avahi_record_get_estimate_size(pj->record) > avahi_dns_packet_space(p))
             break;
 
         /* Mark this job for addition to the packet */
         pj->chosen = TRUE;
     }
 
-    flx_key_unref(k);
+    avahi_key_unref(k);
             
     return ret;
 }
 
-static void probe_elapse(flxTimeEvent *e, gpointer data) {
-    flxProbeJob *pj = data, *next;
-    flxPacketScheduler *s;
-    flxDnsPacket *p;
+static void probe_elapse(AvahiTimeEvent *e, gpointer data) {
+    AvahiProbeJob *pj = data, *next;
+    AvahiPacketScheduler *s;
+    AvahiDnsPacket *p;
     guint n;
     guint8 *d;
 
     g_assert(pj);
     s = pj->scheduler;
 
-    p = flx_dns_packet_new_query(s->interface->hardware->mtu - 48);
+    p = avahi_dns_packet_new_query(s->interface->hardware->mtu - 48);
 
     /* Add the import probe */
     if (!packet_add_probe_query(s, p, pj)) {
         g_warning("Record too large! ---");
-        flx_dns_packet_free(p);
+        avahi_dns_packet_free(p);
         return;
     }
 
@@ -664,7 +664,7 @@ static void probe_elapse(flxTimeEvent *e, gpointer data) {
         n++;
     }
 
-    flx_dns_packet_set_field(p, FLX_DNS_FIELD_QDCOUNT, n);
+    avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
 
     n = 0;
 
@@ -676,7 +676,7 @@ static void probe_elapse(flxTimeEvent *e, gpointer data) {
         if (!pj->chosen)
             continue;
 
-        if (!flx_dns_packet_append_record(p, pj->record, TRUE)) {
+        if (!avahi_dns_packet_append_record(p, pj->record, TRUE)) {
             g_warning("Bad probe size estimate!");
 
             /* Unmark all following jobs */
@@ -691,25 +691,25 @@ static void probe_elapse(flxTimeEvent *e, gpointer data) {
         n ++;
     }
     
-    flx_dns_packet_set_field(p, FLX_DNS_FIELD_NSCOUNT, n);
+    avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_NSCOUNT, n);
 
     /* Send it now */
-    flx_interface_send_packet(s->interface, p);
-    flx_dns_packet_free(p);
+    avahi_interface_send_packet(s->interface, p);
+    avahi_dns_packet_free(p);
 }
 
-void flx_packet_scheduler_post_probe(flxPacketScheduler *s, flxRecord *record, gboolean immediately) {
-    flxProbeJob *pj;
+void avahi_packet_scheduler_post_probe(AvahiPacketScheduler *s, AvahiRecord *record, gboolean immediately) {
+    AvahiProbeJob *pj;
     GTimeVal tv;
     
     g_assert(s);
     g_assert(record);
-    g_assert(!flx_key_is_pattern(record->key));
+    g_assert(!avahi_key_is_pattern(record->key));
     
-    flx_elapse_time(&tv, immediately ? 0 : FLX_PROBE_DEFER_MSEC, 0);
+    avahi_elapse_time(&tv, immediately ? 0 : AVAHI_PROBE_DEFER_MSEC, 0);
 
     /* Create a new job and schedule it */
     pj = probe_job_new(s, record);
     pj->delivery = tv;
-    pj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &pj->delivery, probe_elapse, pj);
+    pj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &pj->delivery, probe_elapse, pj);
 }