#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 100
+#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);
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 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);
+ /* Drop query after some time from history */
+ 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);
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;
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;
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)
+ 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;
}
break;
}
+ }
+
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);
}
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. */
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;
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;
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
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);
* 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;
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);
* 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) {
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);
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 */
}
}
-void flx_packet_scheduler_flush_responses(flxPacketScheduler *s) {
- flxResponseJob *rj;
+void avahi_packet_scheduler_flush_responses(AvahiPacketScheduler *s) {
+ AvahiResponseJob *rj;
g_assert(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);
/* 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 */
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;
}
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;
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 */
}
probe_job_free(s, pj);
+
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);
- /* No duplication check here... */
/* 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);
}
projects / catta / blobdiff