6 #define FLX_QUERY_HISTORY_MSEC 700
7 #define FLX_QUERY_DEFER_MSEC 100
8 #define FLX_RESPONSE_HISTORY_MSEC 700
9 #define FLX_RESPONSE_DEFER_MSEC 20
10 #define FLX_RESPONSE_JITTER_MSEC 100
12 flxPacketScheduler *flx_packet_scheduler_new(flxServer *server, flxInterface *i) {
13 flxPacketScheduler *s;
18 s = g_new(flxPacketScheduler, 1);
22 FLX_LLIST_HEAD_INIT(flxQueryJob, s->query_jobs);
23 FLX_LLIST_HEAD_INIT(flxResponseJob, s->response_jobs);
24 FLX_LLIST_HEAD_INIT(flxKnownAnswer, s->known_answers);
29 static void query_job_free(flxPacketScheduler *s, flxQueryJob *qj) {
33 flx_time_event_queue_remove(qj->scheduler->server->time_event_queue, qj->time_event);
35 FLX_LLIST_REMOVE(flxQueryJob, jobs, s->query_jobs, qj);
37 flx_key_unref(qj->key);
41 static void response_job_free(flxPacketScheduler *s, flxResponseJob *rj) {
45 flx_time_event_queue_remove(rj->scheduler->server->time_event_queue, rj->time_event);
47 FLX_LLIST_REMOVE(flxResponseJob, jobs, s->response_jobs, rj);
49 flx_record_unref(rj->record);
53 void flx_packet_scheduler_free(flxPacketScheduler *s) {
60 g_assert(!s->known_answers);
62 while ((qj = s->query_jobs))
63 query_job_free(s, qj);
64 while ((rj = s->response_jobs))
65 response_job_free(s, rj);
70 static gpointer known_answer_walk_callback(flxCache *c, flxKey *pattern, flxCacheEntry *e, gpointer userdata) {
71 flxPacketScheduler *s = userdata;
79 if (flx_cache_entry_half_ttl(c, e))
82 ka = g_new0(flxKnownAnswer, 1);
84 ka->record = flx_record_ref(e->record);
86 FLX_LLIST_PREPEND(flxKnownAnswer, known_answer, s->known_answers, ka);
90 static guint8* packet_add_query_job(flxPacketScheduler *s, flxDnsPacket *p, flxQueryJob *qj) {
97 if ((d = flx_dns_packet_append_key(p, qj->key))) {
102 /* Drop query after some time from history from history */
103 flx_elapse_time(&tv, FLX_QUERY_HISTORY_MSEC, 0);
104 flx_time_event_queue_update(s->server->time_event_queue, qj->time_event, &tv);
106 g_get_current_time(&qj->delivery);
108 /* Add all matching known answers to the list */
109 flx_cache_walk(s->interface->cache, qj->key, known_answer_walk_callback, s);
115 static void append_known_answers_and_send(flxPacketScheduler *s, flxDnsPacket *p) {
123 while ((ka = s->known_answers)) {
125 while (!flx_dns_packet_append_record(p, ka->record, FALSE)) {
127 g_assert(!flx_dns_packet_is_empty(p));
129 flx_dns_packet_set_field(p, DNS_FIELD_FLAGS, flx_dns_packet_get_field(p, DNS_FIELD_FLAGS) | DNS_FLAG_TC);
130 flx_dns_packet_set_field(p, DNS_FIELD_ANCOUNT, n);
131 flx_interface_send_packet(s->interface, p);
132 flx_dns_packet_free(p);
134 p = flx_dns_packet_new_query(s->interface->hardware->mtu - 48);
138 FLX_LLIST_REMOVE(flxKnownAnswer, known_answer, s->known_answers, ka);
139 flx_record_unref(ka->record);
145 flx_dns_packet_set_field(p, DNS_FIELD_ANCOUNT, n);
146 flx_interface_send_packet(s->interface, p);
147 flx_dns_packet_free(p);
150 static void query_elapse(flxTimeEvent *e, gpointer data) {
151 flxQueryJob *qj = data;
152 flxPacketScheduler *s;
161 /* Lets remove it from the history */
162 query_job_free(s, qj);
166 g_assert(!s->known_answers);
168 p = flx_dns_packet_new_query(s->interface->hardware->mtu - 48);
169 d = packet_add_query_job(s, p, qj);
173 /* Try to fill up packet with more queries, if available */
174 for (qj = s->query_jobs; qj; qj = qj->jobs_next) {
179 if (!packet_add_query_job(s, p, qj))
185 flx_dns_packet_set_field(p, DNS_FIELD_QDCOUNT, n);
187 /* Now add known answers */
188 append_known_answers_and_send(s, p);
191 flxQueryJob* query_job_new(flxPacketScheduler *s, flxKey *key) {
197 qj = g_new(flxQueryJob, 1);
199 qj->key = flx_key_ref(key);
201 qj->time_event = NULL;
203 FLX_LLIST_PREPEND(flxQueryJob, jobs, s->query_jobs, qj);
208 void flx_packet_scheduler_post_query(flxPacketScheduler *s, flxKey *key, gboolean immediately) {
215 flx_elapse_time(&tv, immediately ? 0 : FLX_QUERY_DEFER_MSEC, 0);
217 for (qj = s->query_jobs; qj; qj = qj->jobs_next)
219 if (flx_key_equal(qj->key, key)) {
221 glong d = flx_timeval_diff(&tv, &qj->delivery);
223 /* Duplicate questions suppression */
224 if (d >= 0 && d <= FLX_QUERY_HISTORY_MSEC*1000) {
225 g_message("WARNING! DUPLICATE QUERY SUPPRESSION ACTIVE!");
229 query_job_free(s, qj);
233 qj = query_job_new(s, key);
235 qj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &qj->delivery, query_elapse, qj);
238 static guint8* packet_add_response_job(flxPacketScheduler *s, flxDnsPacket *p, flxResponseJob *rj) {
245 if ((d = flx_dns_packet_append_record(p, rj->record, FALSE))) {
250 /* Drop response after some time from history */
251 flx_elapse_time(&tv, FLX_RESPONSE_HISTORY_MSEC, 0);
252 flx_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
254 g_get_current_time(&rj->delivery);
260 static void send_response_packet(flxPacketScheduler *s, flxResponseJob *rj) {
266 p = flx_dns_packet_new_response(s->interface->hardware->mtu - 200);
269 /* If a job was specified, put it in the packet. */
272 d = packet_add_response_job(s, p, rj);
277 /* Try to fill up packet with more responses, if available */
278 for (rj = s->response_jobs; rj; rj = rj->jobs_next) {
283 if (!packet_add_response_job(s, p, rj))
289 flx_dns_packet_set_field(p, DNS_FIELD_ANCOUNT, n);
290 flx_interface_send_packet(s->interface, p);
291 flx_dns_packet_free(p);
294 static void response_elapse(flxTimeEvent *e, gpointer data) {
295 flxResponseJob *rj = data;
296 flxPacketScheduler *s;
302 /* Lets remove it from the history */
303 response_job_free(s, rj);
307 send_response_packet(s, rj);
310 static flxResponseJob* look_for_response(flxPacketScheduler *s, flxRecord *record) {
316 for (rj = s->response_jobs; rj; rj = rj->jobs_next)
317 if (flx_record_equal_no_ttl(rj->record, record))
323 static flxResponseJob* response_job_new(flxPacketScheduler *s, flxRecord *record) {
329 rj = g_new(flxResponseJob, 1);
331 rj->record = flx_record_ref(record);
333 rj->time_event = NULL;
335 FLX_LLIST_PREPEND(flxResponseJob, jobs, s->response_jobs, rj);
340 void flx_packet_scheduler_post_response(flxPacketScheduler *s, const flxAddress *a, flxRecord *record, gboolean immediately) {
348 g_assert(!flx_key_is_pattern(record->key));
350 flx_elapse_time(&tv, immediately ? 0 : FLX_RESPONSE_DEFER_MSEC, immediately ? 0 : FLX_RESPONSE_JITTER_MSEC);
352 /* Don't send out duplicates */
354 if ((rj = look_for_response(s, record))) {
357 d = flx_timeval_diff(&tv, &rj->delivery);
359 /* If there's already a matching packet in our history or in
360 * the schedule, we do nothing. */
361 if (!!record->ttl == !!rj->record->ttl &&
362 d >= 0 && d <= FLX_RESPONSE_HISTORY_MSEC*1000) {
363 g_message("WARNING! DUPLICATE RESPONSE SUPPRESSION ACTIVE!");
365 /* This job is no longer specific to a single querier, so
366 * make sure it isn't suppressed by known answer
368 rj->address_valid = FALSE;
373 /* Either one was a goodbye packet, but the other was not, so
374 * let's drop the older one. */
375 response_job_free(s, rj);
378 g_message("ACCEPTED NEW RESPONSE [%s]", t = flx_record_to_string(record));
381 /* Create a new job and schedule it */
382 rj = response_job_new(s, record);
384 rj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &rj->delivery, response_elapse, rj);
386 /* Store the address of the host this messages is intended to, so
387 that we can drop this job in case a truncated message with
388 known answer suppresion entries is recieved */
390 if ((rj->address_valid = !!a))
394 void flx_packet_scheduler_incoming_query(flxPacketScheduler *s, flxKey *key) {
401 /* This function is called whenever an incoming query was
402 * receieved. We drop all scheduled queries which match here. The
403 * keyword is "DUPLICATE QUESTION SUPPRESION". */
405 for (qj = s->query_jobs; qj; qj = qj->jobs_next)
406 if (flx_key_equal(qj->key, key)) {
415 /* No matching job was found. Add the query to the history */
416 qj = query_job_new(s, key);
421 /* Drop the query after some time */
422 flx_elapse_time(&tv, FLX_QUERY_HISTORY_MSEC, 0);
423 qj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &tv, query_elapse, qj);
425 g_get_current_time(&qj->delivery);
428 void response_job_set_elapse_time(flxPacketScheduler *s, flxResponseJob *rj, guint msec, guint jitter) {
434 flx_elapse_time(&tv, msec, jitter);
437 flx_time_event_queue_update(s->server->time_event_queue, rj->time_event, &tv);
439 rj->time_event = flx_time_event_queue_add(s->server->time_event_queue, &tv, response_elapse, rj);
443 void flx_packet_scheduler_incoming_response(flxPacketScheduler *s, flxRecord *record) {
449 /* This function is called whenever an incoming response was
450 * receieved. We drop all scheduled responses which match
451 * here. The keyword is "DUPLICATE ANSWER SUPPRESION". */
453 for (rj = s->response_jobs; rj; rj = rj->jobs_next)
454 if (flx_record_equal_no_ttl(rj->record, record)) {
458 if (!!record->ttl == !!rj->record->ttl) {
459 /* An entry like this is already in our history,
460 * so let's get out of here! */
465 /* Either one was a goodbye packet but other was
466 * none. We remove the history entry, and add a
469 response_job_free(s, rj);
475 if (!!record->ttl == !!rj->record->ttl) {
477 /* The incoming packet matches our scheduled
478 * record, so let's mark that one as done */
484 /* Either one was a goodbye packet but other was
485 * none. We ignore the incoming packet. */
492 /* No matching job was found. Add the query to the history */
493 rj = response_job_new(s, record);
498 /* Drop response after 500ms from history */
499 response_job_set_elapse_time(s, rj, FLX_RESPONSE_HISTORY_MSEC, 0);
501 g_get_current_time(&rj->delivery);
504 void flx_packet_scheduler_incoming_known_answer(flxPacketScheduler *s, flxRecord *record, const flxAddress *a) {
511 for (rj = s->response_jobs; rj; rj = rj->jobs_next)
512 if (flx_record_equal_no_ttl(rj->record, record) &&
514 flx_address_cmp(&rj->address, a) &&
515 record->ttl >= rj->record->ttl/2) {
517 /* Let's suppress it */
519 response_job_free(s, rj);
525 void flx_packet_scheduler_flush_responses(flxPacketScheduler *s) {
530 /* Send all scheduled responses, ignoring the scheduled time */
532 for (rj = s->response_jobs; rj; rj = rj->jobs_next)
534 send_response_packet(s, rj);