]> git.meshlink.io Git - catta/blob - avahi-core/cache.c
2f0c1667c70ca63a1fcd5950249a72acbc2a2d6b
[catta] / avahi-core / cache.c
1 /* $Id$ */
2
3 /***
4   This file is part of avahi.
5  
6   avahi is free software; you can redistribute it and/or modify it
7   under the terms of the GNU Lesser General Public License as
8   published by the Free Software Foundation; either version 2.1 of the
9   License, or (at your option) any later version.
10  
11   avahi is distributed in the hope that it will be useful, but WITHOUT
12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
14   Public License for more details.
15  
16   You should have received a copy of the GNU Lesser General Public
17   License along with avahi; if not, write to the Free Software
18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19   USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <string.h>
27
28 #include "util.h"
29 #include "cache.h"
30
31 static void remove_entry(AvahiCache *c, AvahiCacheEntry *e) {
32     AvahiCacheEntry *t;
33
34     g_assert(c);
35     g_assert(e);
36
37 /*     g_message("removing from cache: %p %p", c, e); */
38
39     /* Remove from hash table */
40     t = g_hash_table_lookup(c->hash_table, e->record->key);
41     AVAHI_LLIST_REMOVE(AvahiCacheEntry, by_key, t, e);
42     if (t)
43         g_hash_table_replace(c->hash_table, t->record->key, t);
44     else
45         g_hash_table_remove(c->hash_table, e->record->key);
46
47     /* Remove from linked list */
48     AVAHI_LLIST_REMOVE(AvahiCacheEntry, entry, c->entries, e);
49         
50     if (e->time_event)
51         avahi_time_event_queue_remove(c->server->time_event_queue, e->time_event);
52
53     avahi_subscription_notify(c->server, c->interface, e->record, AVAHI_SUBSCRIPTION_REMOVE);
54
55     avahi_record_unref(e->record);
56     
57     g_free(e);
58 }
59
60 AvahiCache *avahi_cache_new(AvahiServer *server, AvahiInterface *iface) {
61     AvahiCache *c;
62     g_assert(server);
63
64     c = g_new(AvahiCache, 1);
65     c->server = server;
66     c->interface = iface;
67     c->hash_table = g_hash_table_new((GHashFunc) avahi_key_hash, (GEqualFunc) avahi_key_equal);
68
69     AVAHI_LLIST_HEAD_INIT(AvahiCacheEntry, c->entries);
70     
71     return c;
72 }
73
74 void avahi_cache_free(AvahiCache *c) {
75     g_assert(c);
76
77     while (c->entries)
78         remove_entry(c, c->entries);
79     
80     g_hash_table_destroy(c->hash_table);
81     
82     g_free(c);
83 }
84
85 AvahiCacheEntry *avahi_cache_lookup_key(AvahiCache *c, AvahiKey *k) {
86     g_assert(c);
87     g_assert(k);
88
89     g_assert(!avahi_key_is_pattern(k));
90     
91     return g_hash_table_lookup(c->hash_table, k);
92 }
93
94 gpointer avahi_cache_walk(AvahiCache *c, AvahiKey *pattern, AvahiCacheWalkCallback cb, gpointer userdata) {
95     gpointer ret;
96     
97     g_assert(c);
98     g_assert(pattern);
99     g_assert(cb);
100     
101     if (avahi_key_is_pattern(pattern)) {
102         AvahiCacheEntry *e, *n;
103         
104         for (e = c->entries; e; e = n) {
105             n = e->entry_next;
106             
107             if (avahi_key_pattern_match(pattern, e->record->key))
108                 if ((ret = cb(c, pattern, e, userdata)))
109                     return ret;
110         }
111         
112     } else {
113         AvahiCacheEntry *e, *n;
114
115         for (e = avahi_cache_lookup_key(c, pattern); e; e = n) {
116             n = e->by_key_next;
117                 
118             if ((ret = cb(c, pattern, e, userdata)))
119                 return ret;
120         }
121     }
122
123     return NULL;
124 }
125
126 static gpointer lookup_record_callback(AvahiCache *c, AvahiKey *pattern, AvahiCacheEntry *e, void *userdata) {
127     g_assert(c);
128     g_assert(pattern);
129     g_assert(e);
130
131     if (avahi_record_equal_no_ttl(e->record, userdata))
132         return e;
133
134     return NULL;
135 }
136
137 AvahiCacheEntry *avahi_cache_lookup_record(AvahiCache *c, AvahiRecord *r) {
138     g_assert(c);
139     g_assert(r);
140
141     return avahi_cache_walk(c, r->key, lookup_record_callback, r);
142 }
143
144 static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, guint percent);
145
146 static void elapse_func(AvahiTimeEvent *t, void *userdata) {
147     AvahiCacheEntry *e = userdata;
148     
149     g_assert(t);
150     g_assert(e);
151
152     if (e->state == AVAHI_CACHE_FINAL) {
153         remove_entry(e->cache, e);
154         g_message("Removing entry from cache due to expiration");
155     } else {
156         guint percent = 0;
157     
158         switch (e->state) {
159             case AVAHI_CACHE_VALID:
160                 e->state = AVAHI_CACHE_EXPIRY1;
161                 percent = 85;
162                 break;
163                 
164             case AVAHI_CACHE_EXPIRY1:
165                 e->state = AVAHI_CACHE_EXPIRY2;
166                 percent = 90;
167                 break;
168             case AVAHI_CACHE_EXPIRY2:
169                 e->state = AVAHI_CACHE_EXPIRY3;
170                 percent = 95;
171                 break;
172                 
173             case AVAHI_CACHE_EXPIRY3:
174                 e->state = AVAHI_CACHE_FINAL;
175                 percent = 100;
176                 break;
177
178             default:
179                 ;
180         }
181
182         g_assert(percent > 0);
183
184         /* Request a cache update, if we are subscribed to this entry */
185         if (avahi_is_subscribed(e->cache->server, e->record->key)) {
186             g_message("Requesting cache entry update at %i%%.", percent);
187             avahi_interface_post_query(e->cache->interface, e->record->key, TRUE);
188         }
189
190         /* Check again later */
191         next_expiry(e->cache, e, percent);
192     }
193 }
194
195 static void update_time_event(AvahiCache *c, AvahiCacheEntry *e) {
196     g_assert(c);
197     g_assert(e);
198     
199     if (e->time_event)
200         avahi_time_event_queue_update(c->server->time_event_queue, e->time_event, &e->expiry);
201     else
202         e->time_event = avahi_time_event_queue_add(c->server->time_event_queue, &e->expiry, elapse_func, e);
203 }
204
205 static void next_expiry(AvahiCache *c, AvahiCacheEntry *e, guint percent) {
206     gulong usec;
207
208     g_assert(c);
209     g_assert(e);
210     g_assert(percent > 0 && percent <= 100);
211
212     e->expiry = e->timestamp;
213
214     usec = e->record->ttl * 10000;
215
216     /* 2% jitter */
217     usec = g_random_int_range(usec*percent, usec*(percent+2));
218     
219     g_time_val_add(&e->expiry, usec);
220     update_time_event(c, e);
221 }
222
223 static void expire_in_one_second(AvahiCache *c, AvahiCacheEntry *e) {
224     g_assert(c);
225     g_assert(e);
226     
227     e->state = AVAHI_CACHE_FINAL;
228     g_get_current_time(&e->expiry);
229     g_time_val_add(&e->expiry, 1000000); /* 1s */
230     update_time_event(c, e);
231 }
232
233 void avahi_cache_update(AvahiCache *c, AvahiRecord *r, gboolean unique, const AvahiAddress *a) {
234 /*     gchar *txt; */
235     
236     g_assert(c);
237     g_assert(r && r->ref >= 1);
238
239 /*     g_message("cache update: %s", (txt = avahi_record_to_string(r))); */
240 /*     g_free(txt); */
241
242     if (r->ttl == 0) {
243         /* This is a goodbye request */
244
245         AvahiCacheEntry *e;
246
247         if ((e = avahi_cache_lookup_record(c, r)))
248             expire_in_one_second(c, e);
249
250     } else {
251         AvahiCacheEntry *e = NULL, *first;
252         GTimeVal now;
253
254         g_get_current_time(&now);
255
256         /* This is an update request */
257
258         if ((first = avahi_cache_lookup_key(c, r->key))) {
259             
260             if (unique) {
261
262                 /* For unique entries drop all entries older than one second */
263                 for (e = first; e; e = e->by_key_next) {
264                     glong t;
265
266                     t = avahi_timeval_diff(&now, &e->timestamp);
267
268                     if (t > 1000000)
269                         expire_in_one_second(c, e);
270                 }
271             }
272                 
273             /* Look for exactly the same entry */
274             for (e = first; e; e = e->by_key_next)
275                 if (avahi_record_equal_no_ttl(e->record, r))
276                     break;
277         }
278     
279         if (e) {
280             
281 /*             g_message("found matching cache entry");  */
282
283             /* We need to update the hash table key if we replace the
284              * record */
285             if (e->by_key_prev == NULL)
286                 g_hash_table_replace(c->hash_table, r->key, e);
287             
288             /* Update the record */
289             avahi_record_unref(e->record);
290             e->record = avahi_record_ref(r);
291             
292         } else {
293             /* No entry found, therefore we create a new one */
294             
295 /*             g_message("couldn't find matching cache entry");  */
296             
297             e = g_new(AvahiCacheEntry, 1);
298             e->cache = c;
299             e->time_event = NULL;
300             e->record = avahi_record_ref(r);
301
302             /* Append to hash table */
303             AVAHI_LLIST_PREPEND(AvahiCacheEntry, by_key, first, e);
304             g_hash_table_replace(c->hash_table, e->record->key, first);
305
306             /* Append to linked list */
307             AVAHI_LLIST_PREPEND(AvahiCacheEntry, entry, c->entries, e);
308
309             /* Notify subscribers */
310             avahi_subscription_notify(c->server, c->interface, e->record, AVAHI_SUBSCRIPTION_NEW);
311         } 
312         
313         e->origin = *a;
314         e->timestamp = now;
315         next_expiry(c, e, 80);
316         e->state = AVAHI_CACHE_VALID;
317     }
318 }
319
320 static void dump_callback(gpointer key, gpointer data, gpointer userdata) {
321     AvahiCacheEntry *e = data;
322     AvahiKey *k = key;
323
324     g_assert(k);
325     g_assert(e);
326
327     for (; e; e = e->by_key_next) {
328         gchar *t = avahi_record_to_string(e->record);
329         fprintf((FILE*) userdata, "%s\n", t);
330         g_free(t);
331     }
332 }
333
334 void avahi_cache_dump(AvahiCache *c, FILE *f) {
335     g_assert(c);
336     g_assert(f);
337
338     fprintf(f, ";;; CACHE DUMP FOLLOWS ;;;\n");
339     g_hash_table_foreach(c->hash_table, dump_callback, f);
340 }
341
342 gboolean avahi_cache_entry_half_ttl(AvahiCache *c, AvahiCacheEntry *e) {
343     GTimeVal now;
344     guint age;
345     
346     g_assert(c);
347     g_assert(e);
348
349     g_get_current_time(&now);
350
351     age = avahi_timeval_diff(&now, &e->timestamp)/1000000;
352
353 /*     g_message("age: %u, ttl/2: %u", age, e->record->ttl); */
354     
355     return age >= e->record->ttl/2;
356 }
357
358 void avahi_cache_flush(AvahiCache *c) {
359     g_assert(c);
360
361     while (c->entries)
362         remove_entry(c, c->entries);
363 }