X-Git-Url: http://git.meshlink.io/?a=blobdiff_plain;f=avahi-core%2Fquerier.c;h=d9dc1fb0fbfd6f15c1c72aa5923e7ab188b1d550;hb=9c0f9c65093cfa53d45f9b68782321eb8063a032;hp=51b2ce663233c8942d53e1d6c1d75c644aad5779;hpb=1ffedb586bd2fb6daa3970304fac7c5b415cd38f;p=catta diff --git a/avahi-core/querier.c b/avahi-core/querier.c index 51b2ce6..d9dc1fb 100644 --- a/avahi-core/querier.c +++ b/avahi-core/querier.c @@ -1,18 +1,16 @@ -/* $Id$ */ - /*** This file is part of avahi. - + avahi is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. - + avahi is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. - + You should have received a copy of the GNU Lesser General Public License along with avahi; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 @@ -23,6 +21,8 @@ #include #endif +#include + #include #include #include @@ -42,7 +42,10 @@ struct AvahiQuerier { AvahiTimeEvent *time_event; struct timeval creation_time; - + + unsigned post_id; + int post_id_valid; + AVAHI_LLIST_FIELDS(AvahiQuerier, queriers); }; @@ -54,23 +57,40 @@ void avahi_querier_free(AvahiQuerier *q) { avahi_key_unref(q->key); avahi_time_event_free(q->time_event); - + avahi_free(q); } -static void querier_elapse_callback(AvahiTimeEvent *e, void *userdata) { +static void querier_elapse_callback(AVAHI_GCC_UNUSED AvahiTimeEvent *e, void *userdata) { AvahiQuerier *q = userdata; struct timeval tv; - + assert(q); - avahi_interface_post_query(q->interface, q->key, 0); + if (q->n_used <= 0) { + + /* We are not referenced by anyone anymore, so let's free + * ourselves. We should not send out any further queries from + * this querier object anymore. */ + + avahi_querier_free(q); + return; + } + + if (avahi_interface_post_query(q->interface, q->key, 0, &q->post_id)) { + + /* The queue accepted our query. We store the query id here, + * that allows us to drop the query at a later point if the + * query is very short-lived. */ + + q->post_id_valid = 1; + } q->sec_delay *= 2; - + if (q->sec_delay >= 60*60) /* 1h */ q->sec_delay = 60*60; - + avahi_elapse_time(&tv, q->sec_delay*1000, 0); avahi_time_event_update(q->time_event, &tv); } @@ -78,15 +98,18 @@ static void querier_elapse_callback(AvahiTimeEvent *e, void *userdata) { void avahi_querier_add(AvahiInterface *i, AvahiKey *key, struct timeval *ret_ctime) { AvahiQuerier *q; struct timeval tv; - + assert(i); assert(key); if ((q = avahi_hashmap_lookup(i->queriers_by_key, key))) { + /* Someone is already browsing for records of this RR key */ q->n_used++; - /* Return the creation time */ + /* Return the creation time. This is used for generating the + * ALL_FOR_NOW event one second after the querier was + * initially created. */ if (ret_ctime) *ret_ctime = q->creation_time; return; @@ -95,15 +118,17 @@ void avahi_querier_add(AvahiInterface *i, AvahiKey *key, struct timeval *ret_cti /* No one is browsing for this RR key, so we add a new querier */ if (!(q = avahi_new(AvahiQuerier, 1))) return; /* OOM */ - + q->key = avahi_key_ref(key); q->interface = i; q->n_used = 1; q->sec_delay = 1; + q->post_id_valid = 0; gettimeofday(&q->creation_time, NULL); /* Do the initial query */ - avahi_interface_post_query(i, key, 0); + if (avahi_interface_post_query(i, key, 0, &q->post_id)) + q->post_id_valid = 1; /* Schedule next queries */ q->time_event = avahi_time_event_new(i->monitor->server->time_event_queue, avahi_elapse_time(&tv, q->sec_delay*1000, 0), querier_elapse_callback, q); @@ -111,7 +136,9 @@ void avahi_querier_add(AvahiInterface *i, AvahiKey *key, struct timeval *ret_cti AVAHI_LLIST_PREPEND(AvahiQuerier, queriers, i->queriers, q); avahi_hashmap_insert(i->queriers_by_key, q->key, q); - /* Return the creation time */ + /* Return the creation time. This is used for generating the + * ALL_FOR_NOW event one second after the querier was initially + * created. */ if (ret_ctime) *ret_ctime = q->creation_time; } @@ -119,15 +146,28 @@ void avahi_querier_add(AvahiInterface *i, AvahiKey *key, struct timeval *ret_cti void avahi_querier_remove(AvahiInterface *i, AvahiKey *key) { AvahiQuerier *q; - if (!(q = avahi_hashmap_lookup(i->queriers_by_key, key))) { - /* The was no querier for this RR key */ - avahi_log_warn(__FILE__": querier_remove() called but no querier to remove"); + /* There was no querier for this RR key, or it wasn't referenced + * by anyone. */ + if (!(q = avahi_hashmap_lookup(i->queriers_by_key, key)) || q->n_used <= 0) return; - } - assert(q->n_used >= 1); - if ((--q->n_used) <= 0) - avahi_querier_free(q); + if ((--q->n_used) <= 0) { + + /* Nobody references us anymore. */ + + if (q->post_id_valid && avahi_interface_withraw_query(i, q->post_id)) { + + /* We succeeded in withdrawing our query from the queue, + * so let's drop dead. */ + + avahi_querier_free(q); + } + + /* If we failed to withdraw our query from the queue, we stay + * alive, in case someone else might recycle our querier at a + * later point. We are freed at our next expiry, in case + * nobody recycled us. */ + } } static void remove_querier_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) { @@ -142,7 +182,7 @@ static void remove_querier_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void avahi_querier_remove_for_all(AvahiServer *s, AvahiIfIndex idx, AvahiProtocol protocol, AvahiKey *key) { assert(s); assert(key); - + avahi_interface_monitor_walk(s->monitor, idx, protocol, remove_querier_callback, key); } @@ -153,7 +193,7 @@ struct cbdata { static void add_querier_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, void* userdata) { struct cbdata *cbdata = userdata; - + assert(m); assert(i); assert(cbdata); @@ -169,7 +209,7 @@ static void add_querier_callback(AvahiInterfaceMonitor *m, AvahiInterface *i, vo void avahi_querier_add_for_all(AvahiServer *s, AvahiIfIndex idx, AvahiProtocol protocol, AvahiKey *key, struct timeval *ret_ctime) { struct cbdata cbdata; - + assert(s); assert(key); @@ -178,23 +218,51 @@ void avahi_querier_add_for_all(AvahiServer *s, AvahiIfIndex idx, AvahiProtocol p if (ret_ctime) ret_ctime->tv_sec = ret_ctime->tv_usec = 0; - + avahi_interface_monitor_walk(s->monitor, idx, protocol, add_querier_callback, &cbdata); } -int avahi_querier_exists(AvahiInterface *i, AvahiKey *key) { +int avahi_querier_shall_refresh_cache(AvahiInterface *i, AvahiKey *key) { + AvahiQuerier *q; + assert(i); assert(key); - if (avahi_hashmap_lookup(i->queriers_by_key, key)) - return 1; + /* Called by the cache maintainer */ + + if (!(q = avahi_hashmap_lookup(i->queriers_by_key, key))) + /* This key is currently not subscribed at all, so no cache + * refresh is needed */ + return 0; + + if (q->n_used <= 0) { + + /* If this is an entry nobody references right now, don't + * consider it "existing". */ + + /* Remove this querier since it is referenced by nobody + * and the cached data will soon be out of date */ + avahi_querier_free(q); - return 0; + /* Tell the cache that no refresh is needed */ + return 0; + + } else { + struct timeval tv; + + /* We can defer our query a little, since the cache will now + * issue a refresh query anyway. */ + avahi_elapse_time(&tv, q->sec_delay*1000, 0); + avahi_time_event_update(q->time_event, &tv); + + /* Tell the cache that a refresh should be issued */ + return 1; + } } void avahi_querier_free_all(AvahiInterface *i) { assert(i); - while (i->queriers) + while (i->queriers) avahi_querier_free(i->queriers); }