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/timeval.h>
27 #include "avahi-common/avahi-malloc.h"
28 
29 #include "announce.h"
30 #include "log.h"
31 #include "rr-util.h"
32 
33 #define AVAHI_ANNOUNCEMENT_JITTER_MSEC 250
34 #define AVAHI_PROBE_JITTER_MSEC 250
35 #define AVAHI_PROBE_INTERVAL_MSEC 250
36 
remove_announcer(AvahiServer * s,AvahiAnnouncer * a)37 static void remove_announcer(AvahiServer *s, AvahiAnnouncer *a) {
38     assert(s);
39     assert(a);
40 
41     if (a->time_event)
42         avahi_time_event_free(a->time_event);
43 
44     AVAHI_LLIST_REMOVE(AvahiAnnouncer, by_interface, a->interface->announcers, a);
45     AVAHI_LLIST_REMOVE(AvahiAnnouncer, by_entry, a->entry->announcers, a);
46 
47     avahi_free(a);
48 }
49 
50 static void elapse_announce(AvahiTimeEvent *e, void *userdata);
51 
set_timeout(AvahiAnnouncer * a,const struct timeval * tv)52 static void set_timeout(AvahiAnnouncer *a, const struct timeval *tv) {
53     assert(a);
54 
55     if (!tv) {
56         if (a->time_event) {
57             avahi_time_event_free(a->time_event);
58             a->time_event = NULL;
59         }
60     } else {
61 
62         if (a->time_event)
63             avahi_time_event_update(a->time_event, tv);
64         else
65             a->time_event = avahi_time_event_new(a->server->time_event_queue, tv, elapse_announce, a);
66     }
67 }
68 
69 static void next_state(AvahiAnnouncer *a);
70 
avahi_s_entry_group_check_probed(AvahiSEntryGroup * g,int immediately)71 void avahi_s_entry_group_check_probed(AvahiSEntryGroup *g, int immediately) {
72     AvahiEntry *e;
73     assert(g);
74     assert(!g->dead);
75 
76     /* Check whether all group members have been probed */
77 
78     if (g->state != AVAHI_ENTRY_GROUP_REGISTERING || g->n_probing > 0)
79         return;
80 
81     avahi_s_entry_group_change_state(g, AVAHI_ENTRY_GROUP_ESTABLISHED);
82 
83     if (g->dead)
84         return;
85 
86     for (e = g->entries; e; e = e->by_group_next) {
87         AvahiAnnouncer *a;
88 
89         for (a = e->announcers; a; a = a->by_entry_next) {
90 
91             if (a->state != AVAHI_WAITING)
92                 continue;
93 
94             a->state = AVAHI_ANNOUNCING;
95 
96             if (immediately) {
97                 /* Shortcut */
98 
99                 a->n_iteration = 1;
100                 next_state(a);
101             } else {
102                 struct timeval tv;
103                 a->n_iteration = 0;
104                 avahi_elapse_time(&tv, 0, AVAHI_ANNOUNCEMENT_JITTER_MSEC);
105                 set_timeout(a, &tv);
106             }
107         }
108     }
109 }
110 
next_state(AvahiAnnouncer * a)111 static void next_state(AvahiAnnouncer *a) {
112     assert(a);
113 
114     if (a->state == AVAHI_WAITING) {
115 
116         assert(a->entry->group);
117 
118         avahi_s_entry_group_check_probed(a->entry->group, 1);
119 
120     } else if (a->state == AVAHI_PROBING) {
121 
122         if (a->n_iteration >= 4) {
123             /* Probing done */
124 
125             if (a->entry->group) {
126                 assert(a->entry->group->n_probing);
127                 a->entry->group->n_probing--;
128             }
129 
130             if (a->entry->group && a->entry->group->state == AVAHI_ENTRY_GROUP_REGISTERING)
131                 a->state = AVAHI_WAITING;
132             else {
133                 a->state = AVAHI_ANNOUNCING;
134                 a->n_iteration = 1;
135             }
136 
137             set_timeout(a, NULL);
138             next_state(a);
139         } else {
140             struct timeval tv;
141 
142             avahi_interface_post_probe(a->interface, a->entry->record, 0);
143 
144             avahi_elapse_time(&tv, AVAHI_PROBE_INTERVAL_MSEC, 0);
145             set_timeout(a, &tv);
146 
147             a->n_iteration++;
148         }
149 
150     } else if (a->state == AVAHI_ANNOUNCING) {
151 
152         if (a->entry->flags & AVAHI_PUBLISH_UNIQUE)
153             /* Send the whole rrset at once */
154             avahi_server_prepare_matching_responses(a->server, a->interface, a->entry->record->key, 0);
155         else
156             avahi_server_prepare_response(a->server, a->interface, a->entry, 0, 0);
157 
158         avahi_server_generate_response(a->server, a->interface, NULL, NULL, 0, 0, 0);
159 
160         if (++a->n_iteration >= 4) {
161             /* Announcing done */
162 
163             a->state = AVAHI_ESTABLISHED;
164 
165             set_timeout(a, NULL);
166         } else {
167             struct timeval tv;
168             avahi_elapse_time(&tv, a->sec_delay*1000, AVAHI_ANNOUNCEMENT_JITTER_MSEC);
169 
170             if (a->n_iteration < 10)
171                 a->sec_delay *= 2;
172 
173             set_timeout(a, &tv);
174         }
175     }
176 }
177 
elapse_announce(AvahiTimeEvent * e,void * userdata)178 static void elapse_announce(AvahiTimeEvent *e, void *userdata) {
179     assert(e);
180 
181     next_state(userdata);
182 }
183 
get_announcer(AvahiServer * s,AvahiEntry * e,AvahiInterface * i)184 static AvahiAnnouncer *get_announcer(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) {
185     AvahiAnnouncer *a;
186 
187     assert(s);
188     assert(e);
189     assert(i);
190 
191     for (a = e->announcers; a; a = a->by_entry_next)
192         if (a->interface == i)
193             return a;
194 
195     return NULL;
196 }
197 
go_to_initial_state(AvahiAnnouncer * a)198 static void go_to_initial_state(AvahiAnnouncer *a) {
199     AvahiEntry *e;
200     struct timeval tv;
201 
202     assert(a);
203     e = a->entry;
204 
205     if ((e->flags & AVAHI_PUBLISH_UNIQUE) && !(e->flags & AVAHI_PUBLISH_NO_PROBE))
206         a->state = AVAHI_PROBING;
207     else if (!(e->flags & AVAHI_PUBLISH_NO_ANNOUNCE)) {
208 
209         if (!e->group || e->group->state == AVAHI_ENTRY_GROUP_ESTABLISHED)
210             a->state = AVAHI_ANNOUNCING;
211         else
212             a->state = AVAHI_WAITING;
213 
214     } else
215         a->state = AVAHI_ESTABLISHED;
216 
217     a->n_iteration = 1;
218     a->sec_delay = 1;
219 
220     if (a->state == AVAHI_PROBING && e->group)
221         e->group->n_probing++;
222 
223     if (a->state == AVAHI_PROBING)
224         set_timeout(a, avahi_elapse_time(&tv, 0, AVAHI_PROBE_JITTER_MSEC));
225     else if (a->state == AVAHI_ANNOUNCING)
226         set_timeout(a, avahi_elapse_time(&tv, 0, AVAHI_ANNOUNCEMENT_JITTER_MSEC));
227     else
228         set_timeout(a, NULL);
229 }
230 
new_announcer(AvahiServer * s,AvahiInterface * i,AvahiEntry * e)231 static void new_announcer(AvahiServer *s, AvahiInterface *i, AvahiEntry *e) {
232     AvahiAnnouncer *a;
233 
234     assert(s);
235     assert(i);
236     assert(e);
237     assert(!e->dead);
238 
239     if (!avahi_interface_match(i, e->interface, e->protocol) || !i->announcing || !avahi_entry_is_commited(e))
240         return;
241 
242     /* We don't want duplicate announcers */
243     if (get_announcer(s, e, i))
244         return;
245 
246     if ((!(a = avahi_new(AvahiAnnouncer, 1)))) {
247         avahi_log_error(__FILE__": Out of memory.");
248         return;
249     }
250 
251     a->server = s;
252     a->interface = i;
253     a->entry = e;
254     a->time_event = NULL;
255 
256     AVAHI_LLIST_PREPEND(AvahiAnnouncer, by_interface, i->announcers, a);
257     AVAHI_LLIST_PREPEND(AvahiAnnouncer, by_entry, e->announcers, a);
258 
259     go_to_initial_state(a);
260 }
261 
avahi_announce_interface(AvahiServer * s,AvahiInterface * i)262 void avahi_announce_interface(AvahiServer *s, AvahiInterface *i) {
263     AvahiEntry *e;
264 
265     assert(s);
266     assert(i);
267 
268     if (!i->announcing)
269         return;
270 
271     for (e = s->entries; e; e = e->entries_next)
272         if (!e->dead)
273             new_announcer(s, i, e);
274 }
275 
announce_walk_callback(AvahiInterfaceMonitor * m,AvahiInterface * i,void * userdata)276 static void announce_walk_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) {
277     AvahiEntry *e = userdata;
278 
279     assert(m);
280     assert(i);
281     assert(e);
282     assert(!e->dead);
283 
284     new_announcer(m->server, i, e);
285 }
286 
avahi_announce_entry(AvahiServer * s,AvahiEntry * e)287 void avahi_announce_entry(AvahiServer *s, AvahiEntry *e) {
288     assert(s);
289     assert(e);
290     assert(!e->dead);
291 
292     avahi_interface_monitor_walk(s->monitor, e->interface, e->protocol, announce_walk_callback, e);
293 }
294 
avahi_announce_group(AvahiServer * s,AvahiSEntryGroup * g)295 void avahi_announce_group(AvahiServer *s, AvahiSEntryGroup *g) {
296     AvahiEntry *e;
297 
298     assert(s);
299     assert(g);
300 
301     for (e = g->entries; e; e = e->by_group_next)
302         if (!e->dead)
303             avahi_announce_entry(s, e);
304 }
305 
avahi_entry_is_registered(AvahiServer * s,AvahiEntry * e,AvahiInterface * i)306 int avahi_entry_is_registered(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) {
307     AvahiAnnouncer *a;
308 
309     assert(s);
310     assert(e);
311     assert(i);
312     assert(!e->dead);
313 
314     if (!(a = get_announcer(s, e, i)))
315         return 0;
316 
317     return
318         a->state == AVAHI_ANNOUNCING ||
319         a->state == AVAHI_ESTABLISHED ||
320         (a->state == AVAHI_WAITING && !(e->flags & AVAHI_PUBLISH_UNIQUE));
321 }
322 
avahi_entry_is_probing(AvahiServer * s,AvahiEntry * e,AvahiInterface * i)323 int avahi_entry_is_probing(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) {
324     AvahiAnnouncer *a;
325 
326     assert(s);
327     assert(e);
328     assert(i);
329     assert(!e->dead);
330 
331     if (!(a = get_announcer(s, e, i)))
332         return 0;
333 
334     return
335         a->state == AVAHI_PROBING ||
336         (a->state == AVAHI_WAITING && (e->flags & AVAHI_PUBLISH_UNIQUE));
337 }
338 
avahi_entry_return_to_initial_state(AvahiServer * s,AvahiEntry * e,AvahiInterface * i)339 void avahi_entry_return_to_initial_state(AvahiServer *s, AvahiEntry *e, AvahiInterface *i) {
340     AvahiAnnouncer *a;
341 
342     assert(s);
343     assert(e);
344     assert(i);
345 
346     if (!(a = get_announcer(s, e, i)))
347         return;
348 
349     if (a->state == AVAHI_PROBING && a->entry->group)
350         a->entry->group->n_probing--;
351 
352     go_to_initial_state(a);
353 }
354 
make_goodbye_record(AvahiRecord * r)355 static AvahiRecord *make_goodbye_record(AvahiRecord *r) {
356     AvahiRecord *g;
357 
358     assert(r);
359 
360     if (!(g = avahi_record_copy(r)))
361         return NULL; /* OOM */
362 
363     assert(g->ref == 1);
364     g->ttl = 0;
365 
366     return g;
367 }
368 
is_duplicate_entry(AvahiServer * s,AvahiEntry * e)369 static int is_duplicate_entry(AvahiServer *s, AvahiEntry *e) {
370     AvahiEntry *i;
371 
372     assert(s);
373     assert(e);
374 
375     for (i = avahi_hashmap_lookup(s->entries_by_key, e->record->key); i; i = i->by_key_next) {
376 
377         if ((i == e) || (i->dead))
378             continue;
379 
380         if (!avahi_record_equal_no_ttl(i->record, e->record))
381             continue;
382 
383         return 1;
384     }
385 
386     return 0;
387 }
388 
send_goodbye_callback(AvahiInterfaceMonitor * m,AvahiInterface * i,void * userdata)389 static void send_goodbye_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) {
390     AvahiEntry *e = userdata;
391     AvahiRecord *g;
392 
393     assert(m);
394     assert(i);
395     assert(e);
396     assert(!e->dead);
397 
398     if (!avahi_interface_match(i, e->interface, e->protocol))
399         return;
400 
401     if (e->flags & AVAHI_PUBLISH_NO_ANNOUNCE)
402         return;
403 
404     if (!avahi_entry_is_registered(m->server, e, i))
405         return;
406 
407     if (is_duplicate_entry(m->server, e))
408         return;
409 
410     if (!(g = make_goodbye_record(e->record)))
411         return; /* OOM */
412 
413     avahi_interface_post_response(i, g, e->flags & AVAHI_PUBLISH_UNIQUE, NULL, 1);
414     avahi_record_unref(g);
415 }
416 
reannounce(AvahiAnnouncer * a)417 static void reannounce(AvahiAnnouncer *a) {
418     AvahiEntry *e;
419     struct timeval tv;
420 
421     assert(a);
422     e = a->entry;
423 
424     /* If the group this entry belongs to is not even commited, there's nothing to reannounce */
425     if (e->group && (e->group->state == AVAHI_ENTRY_GROUP_UNCOMMITED || e->group->state == AVAHI_ENTRY_GROUP_COLLISION))
426         return;
427 
428     /* Because we might change state we decrease the probing counter first */
429     if (a->state == AVAHI_PROBING && a->entry->group)
430         a->entry->group->n_probing--;
431 
432     if (a->state == AVAHI_PROBING ||
433         (a->state == AVAHI_WAITING && (e->flags & AVAHI_PUBLISH_UNIQUE) && !(e->flags & AVAHI_PUBLISH_NO_PROBE)))
434 
435         /* We were probing or waiting after probe, so we restart probing from the beginning here */
436 
437         a->state = AVAHI_PROBING;
438     else if (a->state == AVAHI_WAITING)
439 
440         /* We were waiting, but were not probing before, so we continue waiting  */
441         a->state = AVAHI_WAITING;
442 
443     else if (e->flags & AVAHI_PUBLISH_NO_ANNOUNCE)
444 
445         /* No announcer needed */
446         a->state = AVAHI_ESTABLISHED;
447 
448     else {
449 
450         /* Ok, let's restart announcing */
451         a->state = AVAHI_ANNOUNCING;
452     }
453 
454     /* Now let's increase the probing counter again */
455     if (a->state == AVAHI_PROBING && e->group)
456         e->group->n_probing++;
457 
458     a->n_iteration = 1;
459     a->sec_delay = 1;
460 
461     if (a->state == AVAHI_PROBING)
462         set_timeout(a, avahi_elapse_time(&tv, 0, AVAHI_PROBE_JITTER_MSEC));
463     else if (a->state == AVAHI_ANNOUNCING)
464         set_timeout(a, avahi_elapse_time(&tv, 0, AVAHI_ANNOUNCEMENT_JITTER_MSEC));
465     else
466         set_timeout(a, NULL);
467 }
468 
469 
reannounce_walk_callback(AvahiInterfaceMonitor * m,AvahiInterface * i,void * userdata)470 static void reannounce_walk_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) {
471     AvahiEntry *e = userdata;
472     AvahiAnnouncer *a;
473 
474     assert(m);
475     assert(i);
476     assert(e);
477     assert(!e->dead);
478 
479     if (!(a = get_announcer(m->server, e, i)))
480         return;
481 
482     reannounce(a);
483 }
484 
avahi_reannounce_entry(AvahiServer * s,AvahiEntry * e)485 void avahi_reannounce_entry(AvahiServer *s, AvahiEntry *e) {
486 
487     assert(s);
488     assert(e);
489     assert(!e->dead);
490 
491     avahi_interface_monitor_walk(s->monitor, e->interface, e->protocol, reannounce_walk_callback, e);
492 }
493 
avahi_goodbye_interface(AvahiServer * s,AvahiInterface * i,int send_goodbye,int remove)494 void avahi_goodbye_interface(AvahiServer *s, AvahiInterface *i, int send_goodbye, int remove) {
495     assert(s);
496     assert(i);
497 
498     if (send_goodbye)
499         if (i->announcing) {
500             AvahiEntry *e;
501 
502             for (e = s->entries; e; e = e->entries_next)
503                 if (!e->dead)
504                     send_goodbye_callback(s->monitor, i, e);
505         }
506 
507     if (remove)
508         while (i->announcers)
509             remove_announcer(s, i->announcers);
510 }
511 
avahi_goodbye_entry(AvahiServer * s,AvahiEntry * e,int send_goodbye,int remove)512 void avahi_goodbye_entry(AvahiServer *s, AvahiEntry *e, int send_goodbye, int remove) {
513     assert(s);
514     assert(e);
515 
516     if (send_goodbye)
517         if (!e->dead)
518             avahi_interface_monitor_walk(s->monitor, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, send_goodbye_callback, e);
519 
520     if (remove)
521         while (e->announcers)
522             remove_announcer(s, e->announcers);
523 }
524 
525