1 /***
2 This file is part of avahi.
3
4 avahi is free software; you can redistribute it and/or modify it
5 under the terms of the GNU Lesser General Public License as
6 published by the Free Software Foundation; either version 2.1 of the
7 License, or (at your option) any later version.
8
9 avahi is distributed in the hope that it will be useful, but WITHOUT
10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
12 Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with avahi; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17 USA.
18 ***/
19
20 #ifdef HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include <stdlib.h>
25
26 #include <avahi-common/domain.h>
27 #include <avahi-common/timeval.h>
28 #include "avahi-common/avahi-malloc.h"
29
30 #include "probe-sched.h"
31 #include "log.h"
32 #include "rr-util.h"
33
34 #define AVAHI_PROBE_HISTORY_MSEC 150
35 #define AVAHI_PROBE_DEFER_MSEC 50
36
37 typedef struct AvahiProbeJob AvahiProbeJob;
38
39 struct AvahiProbeJob {
40 AvahiProbeScheduler *scheduler;
41 AvahiTimeEvent *time_event;
42
43 int chosen; /* Use for packet assembling */
44 int done;
45 struct timeval delivery;
46
47 AvahiRecord *record;
48
49 AVAHI_LLIST_FIELDS(AvahiProbeJob, jobs);
50 };
51
52 struct AvahiProbeScheduler {
53 AvahiInterface *interface;
54 AvahiTimeEventQueue *time_event_queue;
55
56 AVAHI_LLIST_HEAD(AvahiProbeJob, jobs);
57 AVAHI_LLIST_HEAD(AvahiProbeJob, history);
58 };
59
job_new(AvahiProbeScheduler * s,AvahiRecord * record,int done)60 static AvahiProbeJob* job_new(AvahiProbeScheduler *s, AvahiRecord *record, int done) {
61 AvahiProbeJob *pj;
62
63 assert(s);
64 assert(record);
65
66 if (!(pj = avahi_new(AvahiProbeJob, 1))) {
67 avahi_log_error(__FILE__": Out of memory");
68 return NULL; /* OOM */
69 }
70
71 pj->scheduler = s;
72 pj->record = avahi_record_ref(record);
73 pj->time_event = NULL;
74 pj->chosen = 0;
75
76 if ((pj->done = done))
77 AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->history, pj);
78 else
79 AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->jobs, pj);
80
81 return pj;
82 }
83
job_free(AvahiProbeScheduler * s,AvahiProbeJob * pj)84 static void job_free(AvahiProbeScheduler *s, AvahiProbeJob *pj) {
85 assert(pj);
86
87 if (pj->time_event)
88 avahi_time_event_free(pj->time_event);
89
90 if (pj->done)
91 AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->history, pj);
92 else
93 AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->jobs, pj);
94
95 avahi_record_unref(pj->record);
96 avahi_free(pj);
97 }
98
99 static void elapse_callback(AvahiTimeEvent *e, void* data);
100
job_set_elapse_time(AvahiProbeScheduler * s,AvahiProbeJob * pj,unsigned msec,unsigned jitter)101 static void job_set_elapse_time(AvahiProbeScheduler *s, AvahiProbeJob *pj, unsigned msec, unsigned jitter) {
102 struct timeval tv;
103
104 assert(s);
105 assert(pj);
106
107 avahi_elapse_time(&tv, msec, jitter);
108
109 if (pj->time_event)
110 avahi_time_event_update(pj->time_event, &tv);
111 else
112 pj->time_event = avahi_time_event_new(s->time_event_queue, &tv, elapse_callback, pj);
113 }
114
job_mark_done(AvahiProbeScheduler * s,AvahiProbeJob * pj)115 static void job_mark_done(AvahiProbeScheduler *s, AvahiProbeJob *pj) {
116 assert(s);
117 assert(pj);
118
119 assert(!pj->done);
120
121 AVAHI_LLIST_REMOVE(AvahiProbeJob, jobs, s->jobs, pj);
122 AVAHI_LLIST_PREPEND(AvahiProbeJob, jobs, s->history, pj);
123
124 pj->done = 1;
125
126 job_set_elapse_time(s, pj, AVAHI_PROBE_HISTORY_MSEC, 0);
127 gettimeofday(&pj->delivery, NULL);
128 }
129
avahi_probe_scheduler_new(AvahiInterface * i)130 AvahiProbeScheduler *avahi_probe_scheduler_new(AvahiInterface *i) {
131 AvahiProbeScheduler *s;
132
133 assert(i);
134
135 if (!(s = avahi_new(AvahiProbeScheduler, 1))) {
136 avahi_log_error(__FILE__": Out of memory");
137 return NULL;
138 }
139
140 s->interface = i;
141 s->time_event_queue = i->monitor->server->time_event_queue;
142
143 AVAHI_LLIST_HEAD_INIT(AvahiProbeJob, s->jobs);
144 AVAHI_LLIST_HEAD_INIT(AvahiProbeJob, s->history);
145
146 return s;
147 }
148
avahi_probe_scheduler_free(AvahiProbeScheduler * s)149 void avahi_probe_scheduler_free(AvahiProbeScheduler *s) {
150 assert(s);
151
152 avahi_probe_scheduler_clear(s);
153 avahi_free(s);
154 }
155
avahi_probe_scheduler_clear(AvahiProbeScheduler * s)156 void avahi_probe_scheduler_clear(AvahiProbeScheduler *s) {
157 assert(s);
158
159 while (s->jobs)
160 job_free(s, s->jobs);
161 while (s->history)
162 job_free(s, s->history);
163 }
164
packet_add_probe_query(AvahiProbeScheduler * s,AvahiDnsPacket * p,AvahiProbeJob * pj)165 static int packet_add_probe_query(AvahiProbeScheduler *s, AvahiDnsPacket *p, AvahiProbeJob *pj) {
166 size_t size;
167 AvahiKey *k;
168 int b;
169
170 assert(s);
171 assert(p);
172 assert(pj);
173
174 assert(!pj->chosen);
175
176 /* Estimate the size for this record */
177 size =
178 avahi_key_get_estimate_size(pj->record->key) +
179 avahi_record_get_estimate_size(pj->record);
180
181 /* Too large */
182 if (size > avahi_dns_packet_space(p))
183 return 0;
184
185 /* Create the probe query */
186 if (!(k = avahi_key_new(pj->record->key->name, pj->record->key->clazz, AVAHI_DNS_TYPE_ANY)))
187 return 0; /* OOM */
188
189 b = !!avahi_dns_packet_append_key(p, k, 0);
190 assert(b);
191
192 /* Mark this job for addition to the packet */
193 pj->chosen = 1;
194
195 /* Scan for more jobs whith matching key pattern */
196 for (pj = s->jobs; pj; pj = pj->jobs_next) {
197 if (pj->chosen)
198 continue;
199
200 /* Does the record match the probe? */
201 if (k->clazz != pj->record->key->clazz || !avahi_domain_equal(k->name, pj->record->key->name))
202 continue;
203
204 /* This job wouldn't fit in */
205 if (avahi_record_get_estimate_size(pj->record) > avahi_dns_packet_space(p))
206 break;
207
208 /* Mark this job for addition to the packet */
209 pj->chosen = 1;
210 }
211
212 avahi_key_unref(k);
213
214 return 1;
215 }
216
elapse_callback(AVAHI_GCC_UNUSED AvahiTimeEvent * e,void * data)217 static void elapse_callback(AVAHI_GCC_UNUSED AvahiTimeEvent *e, void* data) {
218 AvahiProbeJob *pj = data, *next;
219 AvahiProbeScheduler *s;
220 AvahiDnsPacket *p;
221 unsigned n;
222
223 assert(pj);
224 s = pj->scheduler;
225
226 if (pj->done) {
227 /* Lets remove it from the history */
228 job_free(s, pj);
229 return;
230 }
231
232 if (!(p = avahi_dns_packet_new_query(s->interface->hardware->mtu)))
233 return; /* OOM */
234 n = 1;
235
236 /* Add the import probe */
237 if (!packet_add_probe_query(s, p, pj)) {
238 size_t size;
239 AvahiKey *k;
240 int b;
241
242 avahi_dns_packet_free(p);
243
244 /* The probe didn't fit in the package, so let's allocate a larger one */
245
246 size =
247 avahi_key_get_estimate_size(pj->record->key) +
248 avahi_record_get_estimate_size(pj->record) +
249 AVAHI_DNS_PACKET_HEADER_SIZE;
250
251 if (!(p = avahi_dns_packet_new_query(size + AVAHI_DNS_PACKET_EXTRA_SIZE)))
252 return; /* OOM */
253
254 if (!(k = avahi_key_new(pj->record->key->name, pj->record->key->clazz, AVAHI_DNS_TYPE_ANY))) {
255 avahi_dns_packet_free(p);
256 return; /* OOM */
257 }
258
259 b = avahi_dns_packet_append_key(p, k, 0) && avahi_dns_packet_append_record(p, pj->record, 0, 0);
260 avahi_key_unref(k);
261
262 if (b) {
263 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_NSCOUNT, 1);
264 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, 1);
265 avahi_interface_send_packet(s->interface, p);
266 } else
267 avahi_log_warn("Probe record too large, cannot send");
268
269 avahi_dns_packet_free(p);
270 job_mark_done(s, pj);
271
272 return;
273 }
274
275 /* Try to fill up packet with more probes, if available */
276 for (pj = s->jobs; pj; pj = pj->jobs_next) {
277
278 if (pj->chosen)
279 continue;
280
281 if (!packet_add_probe_query(s, p, pj))
282 break;
283
284 n++;
285 }
286
287 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_QDCOUNT, n);
288
289 n = 0;
290
291 /* Now add the chosen records to the authorative section */
292 for (pj = s->jobs; pj; pj = next) {
293
294 next = pj->jobs_next;
295
296 if (!pj->chosen)
297 continue;
298
299 if (!avahi_dns_packet_append_record(p, pj->record, 0, 0)) {
300 /* avahi_log_warn("Bad probe size estimate!"); */
301
302 /* Unmark all following jobs */
303 for (; pj; pj = pj->jobs_next)
304 pj->chosen = 0;
305
306 break;
307 }
308
309 job_mark_done(s, pj);
310
311 n ++;
312 }
313
314 avahi_dns_packet_set_field(p, AVAHI_DNS_FIELD_NSCOUNT, n);
315
316 /* Send it now */
317 avahi_interface_send_packet(s->interface, p);
318 avahi_dns_packet_free(p);
319 }
320
find_scheduled_job(AvahiProbeScheduler * s,AvahiRecord * record)321 static AvahiProbeJob* find_scheduled_job(AvahiProbeScheduler *s, AvahiRecord *record) {
322 AvahiProbeJob *pj;
323
324 assert(s);
325 assert(record);
326
327 for (pj = s->jobs; pj; pj = pj->jobs_next) {
328 assert(!pj->done);
329
330 if (avahi_record_equal_no_ttl(pj->record, record))
331 return pj;
332 }
333
334 return NULL;
335 }
336
find_history_job(AvahiProbeScheduler * s,AvahiRecord * record)337 static AvahiProbeJob* find_history_job(AvahiProbeScheduler *s, AvahiRecord *record) {
338 AvahiProbeJob *pj;
339
340 assert(s);
341 assert(record);
342
343 for (pj = s->history; pj; pj = pj->jobs_next) {
344 assert(pj->done);
345
346 if (avahi_record_equal_no_ttl(pj->record, record)) {
347 /* Check whether this entry is outdated */
348
349 if (avahi_age(&pj->delivery) > AVAHI_PROBE_HISTORY_MSEC*1000) {
350 /* it is outdated, so let's remove it */
351 job_free(s, pj);
352 return NULL;
353 }
354
355 return pj;
356 }
357 }
358
359 return NULL;
360 }
361
avahi_probe_scheduler_post(AvahiProbeScheduler * s,AvahiRecord * record,int immediately)362 int avahi_probe_scheduler_post(AvahiProbeScheduler *s, AvahiRecord *record, int immediately) {
363 AvahiProbeJob *pj;
364 struct timeval tv;
365
366 assert(s);
367 assert(record);
368 assert(!avahi_key_is_pattern(record->key));
369
370 if ((pj = find_history_job(s, record)))
371 return 0;
372
373 avahi_elapse_time(&tv, immediately ? 0 : AVAHI_PROBE_DEFER_MSEC, 0);
374
375 if ((pj = find_scheduled_job(s, record))) {
376
377 if (avahi_timeval_compare(&tv, &pj->delivery) < 0) {
378 /* If the new entry should be scheduled earlier, update the old entry */
379 pj->delivery = tv;
380 avahi_time_event_update(pj->time_event, &pj->delivery);
381 }
382
383 return 1;
384 } else {
385 /* Create a new job and schedule it */
386 if (!(pj = job_new(s, record, 0)))
387 return 0; /* OOM */
388
389 pj->delivery = tv;
390 pj->time_event = avahi_time_event_new(s->time_event_queue, &pj->delivery, elapse_callback, pj);
391
392
393 /* avahi_log_debug("Accepted new probe job."); */
394
395 return 1;
396 }
397 }
398