Add missing INTLTOOL_DESKTOP_RULE

[catta] / avahi-core / cache.c

diff --git a/avahi-core/cache.c b/avahi-core/cache.c
index 23e9036f48beda9256b43bcd3d39530ac3168fcb..9d97b6cd0a55ab01fbb609ba164529e848112cbf 100644 (file)
--- a/avahi-core/cache.c
+++ b/avahi-core/cache.c
@@ -25,14 +25,16 @@
 
 #include <string.h>
 #include <stdlib.h>
+#include <time.h>
 
 #include <avahi-common/timeval.h>
 #include <avahi-common/malloc.h>
 
 #include "cache.h"
 #include "log.h"
+#include "rr-util.h"
 
-#define AVAHI_MAX_CACHE_ENTRIES 500
+#define AVAHI_CACHE_ENTRIES_MAX 500
 
 static void remove_entry(AvahiCache *c, AvahiCacheEntry *e) {
     AvahiCacheEntry *t;
@@ -85,6 +87,8 @@ AvahiCache *avahi_cache_new(AvahiServer *server, AvahiInterface *iface) {
 
     AVAHI_LLIST_HEAD_INIT(AvahiCacheEntry, c->entries);
     c->n_entries = 0;
+
+    c->last_rand_timestamp = 0;
     
     return c;
 }
@@ -101,7 +105,7 @@ void avahi_cache_free(AvahiCache *c) {
     avahi_free(c);
 }
 
-AvahiCacheEntry *avahi_cache_lookup_key(AvahiCache *c, AvahiKey *k) {
+static AvahiCacheEntry *lookup_key(AvahiCache *c, AvahiKey *k) {
     assert(c);
     assert(k);
 
@@ -131,7 +135,7 @@ void* avahi_cache_walk(AvahiCache *c, AvahiKey *pattern, AvahiCacheWalkCallback
     } else {
         AvahiCacheEntry *e, *n;
 
-        for (e = avahi_cache_lookup_key(c, pattern); e; e = n) {
+        for (e = lookup_key(c, pattern); e; e = n) {
             n = e->by_key_next;
                 
             if ((ret = cb(c, pattern, e, userdata)))
@@ -153,7 +157,7 @@ static void* lookup_record_callback(AvahiCache *c, AvahiKey *pattern, AvahiCache
     return NULL;
 }
 
-AvahiCacheEntry *avahi_cache_lookup_record(AvahiCache *c, AvahiRecord *r) {
+static AvahiCacheEntry *lookup_record(AvahiCache *c, AvahiRecord *r) {
     assert(c);
     assert(r);
 
@@ -210,11 +214,9 @@ static void elapse_func(AvahiTimeEvent *t, void *userdata) {
 
         assert(percent > 0);
 
-        /* Request a cache update, if we are subscribed to this entry */
-        if (avahi_querier_exists(e->cache->interface, e->record->key)) {
-/*             avahi_log_debug("Requesting cache entry update at %i%% for %s.", percent, txt);   */
-            avahi_interface_post_query(e->cache->interface, e->record->key, 1);
-        }
+        /* Request a cache update if we are subscribed to this entry */
+        if (avahi_querier_shall_refresh_cache(e->cache->interface, e->record->key))
+            avahi_interface_post_query(e->cache->interface, e->record->key, 0, NULL);
         
         /* Check again later */
         next_expiry(e->cache, e, percent);
@@ -236,6 +238,7 @@ static void update_time_event(AvahiCache *c, AvahiCacheEntry *e) {
 
 static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, unsigned percent) {
     AvahiUsec usec, left, right;
+    time_t now;
     
     assert(c);
     assert(e);
@@ -246,7 +249,14 @@ static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, unsigned percent) {
     left = usec * percent;
     right = usec * (percent+2); /* 2% jitter */
 
-    usec = left + (AvahiUsec) ((double) (right-left) * rand() / (RAND_MAX+1.0));
+    now = time(NULL);
+
+    if (now >= c->last_rand_timestamp + 10) {
+        c->last_rand = rand();
+        c->last_rand_timestamp = now;
+    }
+
+    usec = left + (AvahiUsec) ((double) (right-left) * c->last_rand / (RAND_MAX+1.0));
     
     e->expiry = e->timestamp;
     avahi_timeval_add(&e->expiry, usec);
@@ -279,7 +289,7 @@ void avahi_cache_update(AvahiCache *c, AvahiRecord *r, int cache_flush, const Av
 
         AvahiCacheEntry *e;
 
-        if ((e = avahi_cache_lookup_record(c, r)))
+        if ((e = lookup_record(c, r)))
             expire_in_one_second(c, e, AVAHI_CACHE_GOODBYE_FINAL);
 
     } else {
@@ -290,7 +300,7 @@ void avahi_cache_update(AvahiCache *c, AvahiRecord *r, int cache_flush, const Av
 
         /* This is an update request */
 
-        if ((first = avahi_cache_lookup_key(c, r->key))) {
+        if ((first = lookup_key(c, r->key))) {
             
             if (cache_flush) {
 
@@ -331,7 +341,7 @@ void avahi_cache_update(AvahiCache *c, AvahiRecord *r, int cache_flush, const Av
             
 /*             avahi_log_debug("cache: couldn't find matching cache entry for %s", txt);   */
 
-            if (c->n_entries >= AVAHI_MAX_CACHE_ENTRIES)
+            if (c->n_entries >= AVAHI_CACHE_ENTRIES_MAX)
                 return;
 
             if (!(e = avahi_new(AvahiCacheEntry, 1))) {
@@ -434,12 +444,15 @@ void avahi_cache_flush(AvahiCache *c) {
 
 static void* start_poof_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void *userdata) {
     AvahiAddress *a = userdata;
+    struct timeval now;
 
     assert(c);
     assert(pattern);
     assert(e);
     assert(a);
-    
+
+    gettimeofday(&now, NULL);
+
     switch (e->state) {
         case AVAHI_CACHE_VALID:
 
@@ -448,15 +461,23 @@ static void* start_poof_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEnt
 
             e->state = AVAHI_CACHE_POOF;
             e->poof_address = *a;
-            
+            e->poof_timestamp = now;
+            e->poof_num = 0;
+
             break;
 
         case AVAHI_CACHE_POOF:
+            if (avahi_timeval_diff(&now, &e->poof_timestamp) < 1000000)
+              break;
 
-            /* This is the second time we got no response, so let's
+            e->poof_timestamp = now;
+            e->poof_address = *a;
+            e->poof_num ++;
+
+            /* This is the 4th time we got no response, so let's
              * fucking remove this entry. */
-            
-            expire_in_one_second(c, e, AVAHI_CACHE_POOF_FINAL);
+            if (e->poof_num > 3)
+              expire_in_one_second(c, e, AVAHI_CACHE_POOF_FINAL);
             break;
 
         default:
@@ -470,7 +491,7 @@ void avahi_cache_start_poof(AvahiCache *c, AvahiKey *key, const AvahiAddress *a)
     assert(c);
     assert(key);
 
-    avahi_cache_walk(c, key, start_poof_callback, a);
+    avahi_cache_walk(c, key, start_poof_callback, (void*) a);
 }
 
 void avahi_cache_stop_poof(AvahiCache *c, AvahiRecord *record, const AvahiAddress *a) {
@@ -480,7 +501,7 @@ void avahi_cache_stop_poof(AvahiCache *c, AvahiRecord *record, const AvahiAddres
     assert(record);
     assert(a);
 
-    if (!(e = avahi_cache_lookup_record(c, record)))
+    if (!(e = lookup_record(c, record)))
         return;
 
     /* This function is called for each response suppression