6 #define AVAHI_QUERY_HISTORY_MSEC 100
7 #define AVAHI_QUERY_DEFER_MSEC 100
8 #define AVAHI_RESPONSE_HISTORY_MSEC 700
9 #define AVAHI_RESPONSE_DEFER_MSEC 20
10 #define AVAHI_RESPONSE_JITTER_MSEC 100
11 #define AVAHI_PROBE_DEFER_MSEC 70
13 AvahiPacketScheduler *avahi_packet_scheduler_new(AvahiServer *server, AvahiInterface *i) {
14 AvahiPacketScheduler *s;
19 s = g_new(AvahiPacketScheduler, 1);
23 AVAHI_LLIST_HEAD_INIT(AvahiQueryJob, s->query_jobs);
24 AVAHI_LLIST_HEAD_INIT(AvahiResponseJob, s->response_jobs);
25 AVAHI_LLIST_HEAD_INIT(AvahiKnownAnswer, s->known_answers);
26 AVAHI_LLIST_HEAD_INIT(AvahiProbeJob, s->probe_jobs);
31 static void query_job_free(AvahiPacketScheduler *s, AvahiQueryJob *qj) {
35 avahi_time_event_queue_remove(qj->scheduler->server->time_event_queue, qj->time_event);
37 AVAHI_LLIST_REMOVE(AvahiQueryJob, jobs, s->query_jobs, qj);
39 avahi_key_unref(qj->key);
43 static void response_job_free(AvahiPacketScheduler *s, AvahiResponseJob *rj) {
47 avahi_time_event_queue_remove(rj->scheduler->server->time_event_queue, rj->time_event);
49 AVAHI_LLIST_REMOVE(AvahiResponseJob, jobs, s->response_jobs, rj);
51 avahi_record_unref(rj->record);
55 static void probe_job_free(AvahiPacketScheduler *s, AvahiProbeJob *pj) {
59 avahi_time_event_queue_remove(pj->scheduler->server->time_event_queue, pj->time_event);
61 AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->probe_jobs, pj);
63 avahi_record_unref(pj->record);
67 void avahi_packet_scheduler_free(AvahiPacketScheduler *s) {
75 g_assert(!s->known_answers);
77 while ((qj = s->query_jobs))
78 query_job_free(s, qj);
79 while ((rj = s->response_jobs))
80 response_job_free(s, rj);
81 while ((pj = s->probe_jobs))
82 probe_job_free(s, pj);
87 static gpointer known_answer_walk_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, gpointer userdata) {
88 AvahiPacketScheduler *s = userdata;
96 if (avahi_cache_entry_half_ttl(c, e))
99 ka = g_new0(AvahiKnownAnswer, 1);
101 ka->record = avahi_record_ref(e->record);
103 AVAHI_LLIST_PREPEND(AvahiKnownAnswer, known_answer, s->known_answers, ka);
107 static guint8* packet_add_query_job(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiQueryJob *qj) {
114 if ((d = avahi_dns_packet_append_key(p, qj->key, FALSE))) {
119 /* Drop query after some time from history */
120 avahi_elapse_time(&tv, AVAHI_QUERY_HISTORY_MSEC, 0);
121 avahi_time_event_queue_update(s->server->time_event_queue, qj->time_event, &tv);
123 g_get_current_time(&qj->delivery);
125 /* Add all matching known answers to the list */
126 avahi_cache_walk(s->interface->cache, qj->key, known_answer_walk_callback, s);
132 static void append_known_answers_and_send(AvahiPacketScheduler *s, AvahiDnsPacket *p) {
133 AvahiKnownAnswer *ka;
140 while ((ka = s->known_answers)) {
142 while (!avahi_dns_packet_append_record(p, ka->record, FALSE)) {
144 g_assert(!avahi_dns_packet_is_empty(p));
146 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_FLAGS, avahi_dns_packet_get_field(p, AVAHI_DNS_FIELD_FLAGS) | AVAHI_DNS_FLAG_TC);
147 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
148 avahi_interface_send_packet(s->interface, p);
149 avahi_dns_packet_free(p);
151 p = avahi_dns_packet_new_query(s->interface->hardware->mtu - 48);
155 AVAHI_LLIST_REMOVE(AvahiKnownAnswer, known_answer, s->known_answers, ka);
156 avahi_record_unref(ka->record);
162 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
163 avahi_interface_send_packet(s->interface, p);
164 avahi_dns_packet_free(p);
167 static void query_elapse(AvahiTimeEvent *e, gpointer data) {
168 AvahiQueryJob *qj = data;
169 AvahiPacketScheduler *s;
178 /* Lets remove it from the history */
179 query_job_free(s, qj);
183 g_assert(!s->known_answers);
185 p = avahi_dns_packet_new_query(s->interface->hardware->mtu - 48);
186 d = packet_add_query_job(s, p, qj);
190 /* Try to fill up packet with more queries, if available */
191 for (qj = s->query_jobs; qj; qj = qj->jobs_next) {
196 if (!packet_add_query_job(s, p, qj))
202 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
204 /* Now add known answers */
205 append_known_answers_and_send(s, p);
208 AvahiQueryJob* query_job_new(AvahiPacketScheduler *s, AvahiKey *key) {
214 qj = g_new(AvahiQueryJob, 1);
216 qj->key = avahi_key_ref(key);
218 qj->time_event = NULL;
220 AVAHI_LLIST_PREPEND(AvahiQueryJob, jobs, s->query_jobs, qj);
225 void avahi_packet_scheduler_post_query(AvahiPacketScheduler *s, AvahiKey *key, gboolean immediately) {
232 avahi_elapse_time(&tv, immediately ? 0 : AVAHI_QUERY_DEFER_MSEC, 0);
234 for (qj = s->query_jobs; qj; qj = qj->jobs_next) {
236 if (avahi_key_equal(qj->key, key)) {
238 glong d = avahi_timeval_diff(&tv, &qj->delivery);
240 /* Duplicate questions suppression */
241 if (d >= 0 && d <= AVAHI_QUERY_HISTORY_MSEC*1000) {
242 g_message("WARNING! DUPLICATE QUERY SUPPRESSION ACTIVE!");
246 query_job_free(s, qj);
252 qj = query_job_new(s, key);
254 qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &qj->delivery, query_elapse, qj);
257 static guint8* packet_add_response_job(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiResponseJob *rj) {
264 if ((d = avahi_dns_packet_append_record(p, rj->record, rj->flush_cache))) {
269 /* Drop response after some time from history */
270 avahi_elapse_time(&tv, AVAHI_RESPONSE_HISTORY_MSEC, 0);
271 avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
273 g_get_current_time(&rj->delivery);
279 static void send_response_packet(AvahiPacketScheduler *s, AvahiResponseJob *rj) {
285 p = avahi_dns_packet_new_response(s->interface->hardware->mtu - 200);
288 /* If a job was specified, put it in the packet. */
291 d = packet_add_response_job(s, p, rj);
296 /* Try to fill up packet with more responses, if available */
297 for (rj = s->response_jobs; rj; rj = rj->jobs_next) {
302 if (!packet_add_response_job(s, p, rj))
308 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_ANCOUNT, n);
309 avahi_interface_send_packet(s->interface, p);
310 avahi_dns_packet_free(p);
313 static void response_elapse(AvahiTimeEvent *e, gpointer data) {
314 AvahiResponseJob *rj = data;
315 AvahiPacketScheduler *s;
321 /* Lets remove it from the history */
322 response_job_free(s, rj);
326 send_response_packet(s, rj);
329 static AvahiResponseJob* look_for_response(AvahiPacketScheduler *s, AvahiRecord *record) {
330 AvahiResponseJob *rj;
335 for (rj = s->response_jobs; rj; rj = rj->jobs_next)
336 if (avahi_record_equal_no_ttl(rj->record, record))
342 static AvahiResponseJob* response_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
343 AvahiResponseJob *rj;
348 rj = g_new(AvahiResponseJob, 1);
350 rj->record = avahi_record_ref(record);
352 rj->time_event = NULL;
353 rj->address_valid = FALSE;
354 rj->flush_cache = FALSE;
356 AVAHI_LLIST_PREPEND(AvahiResponseJob, jobs, s->response_jobs, rj);
361 void avahi_packet_scheduler_post_response(AvahiPacketScheduler *s, const AvahiAddress *a, AvahiRecord *record, gboolean flush_cache, gboolean immediately) {
362 AvahiResponseJob *rj;
369 g_assert(!avahi_key_is_pattern(record->key));
371 avahi_elapse_time(&tv, immediately ? 0 : AVAHI_RESPONSE_DEFER_MSEC, immediately ? 0 : AVAHI_RESPONSE_JITTER_MSEC);
373 /* Don't send out duplicates */
375 if ((rj = look_for_response(s, record))) {
378 d = avahi_timeval_diff(&tv, &rj->delivery);
380 /* If there's already a matching packet in our history or in
381 * the schedule, we do nothing. */
382 if (!!record->ttl == !!rj->record->ttl &&
383 d >= 0 && d <= AVAHI_RESPONSE_HISTORY_MSEC*1000) {
384 g_message("WARNING! DUPLICATE RESPONSE SUPPRESSION ACTIVE!");
386 /* This job is no longer specific to a single querier, so
387 * make sure it isn't suppressed by known answer
390 if (rj->address_valid && (!a || avahi_address_cmp(a, &rj->address) != 0))
391 rj->address_valid = FALSE;
393 rj->flush_cache = flush_cache;
398 /* Either one was a goodbye packet, but the other was not, so
399 * let's drop the older one. */
400 response_job_free(s, rj);
403 /* g_message("ACCEPTED NEW RESPONSE [%s]", t = avahi_record_to_string(record)); */
406 /* Create a new job and schedule it */
407 rj = response_job_new(s, record);
408 rj->flush_cache = flush_cache;
410 rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &rj->delivery, response_elapse, rj);
412 /* Store the address of the host this messages is intended to, so
413 that we can drop this job in case a truncated message with
414 known answer suppresion entries is recieved */
416 if ((rj->address_valid = !!a))
420 void avahi_packet_scheduler_incoming_query(AvahiPacketScheduler *s, AvahiKey *key) {
427 /* This function is called whenever an incoming query was
428 * receieved. We drop all scheduled queries which match here. The
429 * keyword is "DUPLICATE QUESTION SUPPRESION". */
431 for (qj = s->query_jobs; qj; qj = qj->jobs_next)
432 if (avahi_key_equal(qj->key, key)) {
441 /* No matching job was found. Add the query to the history */
442 qj = query_job_new(s, key);
447 /* Drop the query after some time */
448 avahi_elapse_time(&tv, AVAHI_QUERY_HISTORY_MSEC, 0);
449 qj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, query_elapse, qj);
451 g_get_current_time(&qj->delivery);
454 void response_job_set_elapse_time(AvahiPacketScheduler *s, AvahiResponseJob *rj, guint msec, guint jitter) {
460 avahi_elapse_time(&tv, msec, jitter);
463 avahi_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
465 rj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &tv, response_elapse, rj);
469 void avahi_packet_scheduler_incoming_response(AvahiPacketScheduler *s, AvahiRecord *record) {
470 AvahiResponseJob *rj;
475 /* This function is called whenever an incoming response was
476 * receieved. We drop all scheduled responses which match
477 * here. The keyword is "DUPLICATE ANSWER SUPPRESION". */
479 for (rj = s->response_jobs; rj; rj = rj->jobs_next)
480 if (avahi_record_equal_no_ttl(rj->record, record)) {
484 if (!!record->ttl == !!rj->record->ttl) {
485 /* An entry like this is already in our history,
486 * so let's get out of here! */
491 /* Either one was a goodbye packet but other was
492 * none. We remove the history entry, and add a
495 response_job_free(s, rj);
501 if (!!record->ttl == !!rj->record->ttl) {
503 /* The incoming packet matches our scheduled
504 * record, so let's mark that one as done */
510 /* Either one was a goodbye packet but other was
511 * none. We ignore the incoming packet. */
518 /* No matching job was found. Add the query to the history */
519 rj = response_job_new(s, record);
524 /* Drop response after 500ms from history */
525 response_job_set_elapse_time(s, rj, AVAHI_RESPONSE_HISTORY_MSEC, 0);
527 g_get_current_time(&rj->delivery);
530 void avahi_packet_scheduler_incoming_known_answer(AvahiPacketScheduler *s, AvahiRecord *record, const AvahiAddress *a) {
531 AvahiResponseJob *rj;
537 for (rj = s->response_jobs; rj; rj = rj->jobs_next) {
539 g_assert(record->ttl > 0);
540 g_assert(rj->record->ttl/2);
542 if (avahi_record_equal_no_ttl(rj->record, record))
543 if (rj->address_valid)
544 if (avahi_address_cmp(&rj->address, a))
545 if (record->ttl >= rj->record->ttl/2) {
547 /* Let's suppress it */
549 response_job_free(s, rj);
555 void avahi_packet_scheduler_flush_responses(AvahiPacketScheduler *s) {
556 AvahiResponseJob *rj;
560 /* Send all scheduled responses, ignoring the scheduled time */
562 for (rj = s->response_jobs; rj; rj = rj->jobs_next)
564 send_response_packet(s, rj);
567 static AvahiProbeJob* probe_job_new(AvahiPacketScheduler *s, AvahiRecord *record) {
573 pj = g_new(AvahiProbeJob, 1);
575 pj->record = avahi_record_ref(record);
576 pj->time_event = NULL;
579 AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->probe_jobs, pj);
584 static guint8* packet_add_probe_query(AvahiPacketScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) {
593 g_assert(!pj->chosen);
595 /* Estimate the size for this record */
597 avahi_key_get_estimate_size(pj->record->key) +
598 avahi_record_get_estimate_size(pj->record);
601 if (size > avahi_dns_packet_space(p))
604 /* Create the probe query */
605 k = avahi_key_new(pj->record->key->name, pj->record->key->class, AVAHI_DNS_TYPE_ANY);
606 ret = avahi_dns_packet_append_key(p, k, FALSE);
609 /* Mark this job for addition to the packet */
612 /* Scan for more jobs whith matching key pattern */
613 for (pj = s->probe_jobs; pj; pj = pj->jobs_next) {
617 /* Does the record match the probe? */
618 if (k->class != pj->record->key->class || !avahi_domain_equal(k->name, pj->record->key->name))
621 /* This job wouldn't fit in */
622 if (avahi_record_get_estimate_size(pj->record) > avahi_dns_packet_space(p))
625 /* Mark this job for addition to the packet */
634 static void probe_elapse(AvahiTimeEvent *e, gpointer data) {
635 AvahiProbeJob *pj = data, *next;
636 AvahiPacketScheduler *s;
644 p = avahi_dns_packet_new_query(s->interface->hardware->mtu - 48);
646 /* Add the import probe */
647 if (!packet_add_probe_query(s, p, pj)) {
648 g_warning("Record too large! ---");
649 avahi_dns_packet_free(p);
655 /* Try to fill up packet with more probes, if available */
656 for (pj = s->probe_jobs; pj; pj = pj->jobs_next) {
661 if (!packet_add_probe_query(s, p, pj))
667 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
671 /* Now add the chosen records to the authorative section */
672 for (pj = s->probe_jobs; pj; pj = next) {
674 next = pj->jobs_next;
679 if (!avahi_dns_packet_append_record(p, pj->record, TRUE)) {
680 g_warning("Bad probe size estimate!");
682 /* Unmark all following jobs */
683 for (; pj; pj = pj->jobs_next)
689 probe_job_free(s, pj);
694 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_NSCOUNT, n);
697 avahi_interface_send_packet(s->interface, p);
698 avahi_dns_packet_free(p);
701 void avahi_packet_scheduler_post_probe(AvahiPacketScheduler *s, AvahiRecord *record, gboolean immediately) {
707 g_assert(!avahi_key_is_pattern(record->key));
709 avahi_elapse_time(&tv, immediately ? 0 : AVAHI_PROBE_DEFER_MSEC, 0);
711 /* Create a new job and schedule it */
712 pj = probe_job_new(s, record);
714 pj->time_event = avahi_time_event_queue_add(s->server->time_event_queue, &pj->delivery, probe_elapse, pj);