2 address_cache.c -- Manage cache of recently seen addresses
3 Copyright (C) 2018 Guus Sliepen <guus@tinc-vpn.org>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License along
16 with this program; if not, write to the Free Software Foundation, Inc.,
17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 #include "address_cache.h"
28 static const unsigned int NOT_CACHED = -1;
30 // Find edges pointing to this node, and use them to build a list of unique, known addresses.
31 static struct addrinfo *get_known_addresses(node_t *n) {
32 struct addrinfo *ai = NULL;
33 struct addrinfo *oai = NULL;
35 for splay_each(edge_t, e, n->edge_tree) {
42 for(struct addrinfo *aip = ai; aip; aip = aip->ai_next) {
43 if(!sockaddrcmp(&e->reverse->address, (sockaddr_t *)aip->ai_addr)) {
54 ai = xzalloc(sizeof(*ai));
55 ai->ai_family = e->reverse->address.sa.sa_family;
56 ai->ai_socktype = SOCK_STREAM;
57 ai->ai_protocol = IPPROTO_TCP;
58 ai->ai_addrlen = SALEN(e->reverse->address.sa);
59 ai->ai_addr = xmalloc(ai->ai_addrlen);
60 memcpy(ai->ai_addr, &e->reverse->address, ai->ai_addrlen);
67 static void free_known_addresses(struct addrinfo *ai) {
68 for(struct addrinfo *aip = ai, *next; aip; aip = next) {
74 static unsigned int find_cached(address_cache_t *cache, const sockaddr_t *sa) {
75 for(unsigned int i = 0; i < cache->data.used; i++)
76 if(!sockaddrcmp(&cache->data.address[i], sa)) {
83 void add_recent_address(address_cache_t *cache, const sockaddr_t *sa) {
84 // Check if it's already cached
85 unsigned int pos = find_cached(cache, sa);
87 // It's in the first spot, so nothing to do
92 // Shift everything, move/add the address to the first slot
93 if(pos == NOT_CACHED) {
94 if(cache->data.used < MAX_CACHED_ADDRESSES) {
98 pos = cache->data.used - 1;
101 memmove(&cache->data.address[1], &cache->data.address[0], pos * sizeof(cache->data.address[0]));
103 cache->data.address[0] = *sa;
106 char fname[PATH_MAX];
107 snprintf(fname, sizeof(fname), "%s" SLASH "cache" SLASH "%s", confbase, cache->node->name);
108 FILE *fp = fopen(fname, "wb");
111 fwrite(&cache->data, sizeof(cache->data), 1, fp);
116 const sockaddr_t *get_recent_address(address_cache_t *cache) {
117 // Check if there is an address in our cache of recently seen addresses
118 if(cache->tried < cache->data.used) {
119 return &cache->data.address[cache->tried++];
122 // Next, check any recently seen addresses not in our cache
123 while(cache->tried == cache->data.used) {
125 cache->aip = cache->ai = get_known_addresses(cache->node);
130 sockaddr_t *sa = (sockaddr_t *)cache->aip->ai_addr;
131 cache->aip = cache->aip->ai_next;
133 if(find_cached(cache, sa) != NOT_CACHED) {
139 free_known_addresses(cache->ai);
147 // Otherwise, check if there are any known Address statements
148 if(!cache->config_tree) {
149 init_configuration(&cache->config_tree);
150 read_host_config(cache->config_tree, cache->node->name, false);
151 cache->cfg = lookup_config(cache->config_tree, "Address");
154 while(cache->cfg && !cache->aip) {
155 char *address, *port;
157 get_config_string(cache->cfg, &address);
159 char *space = strchr(address, ' ');
162 port = xstrdup(space + 1);
165 if(!get_config_string(lookup_config(cache->config_tree, "Port"), &port)) {
166 port = xstrdup("655");
171 free_known_addresses(cache->ai);
174 cache->aip = cache->ai = str2addrinfo(address, port, SOCK_STREAM);
177 struct addrinfo *ai = NULL;
179 for(; cache->aip; cache->aip = cache->aip->ai_next) {
180 struct addrinfo *oai = ai;
182 ai = xzalloc(sizeof(*ai));
183 ai->ai_family = cache->aip->ai_family;
184 ai->ai_socktype = cache->aip->ai_socktype;
185 ai->ai_protocol = cache->aip->ai_protocol;
186 ai->ai_addrlen = cache->aip->ai_addrlen;
187 ai->ai_addr = xmalloc(ai->ai_addrlen);
188 memcpy(ai->ai_addr, cache->aip->ai_addr, ai->ai_addrlen);
192 freeaddrinfo(cache->ai);
193 cache->aip = cache->ai = ai;
199 cache->cfg = lookup_config_next(cache->config_tree, cache->cfg);
204 sockaddr_t *sa = (sockaddr_t *)cache->aip->ai_addr;
206 cache->aip = cache->aip->ai_next;
209 free_known_addresses(cache->ai);
214 // We're all out of addresses.
215 exit_configuration(&cache->config_tree);
219 address_cache_t *open_address_cache(node_t *node) {
220 address_cache_t *cache = xmalloc(sizeof(*cache));
223 // Try to open an existing address cache
224 char fname[PATH_MAX];
225 snprintf(fname, sizeof(fname), "%s" SLASH "cache" SLASH "%s", confbase, node->name);
226 FILE *fp = fopen(fname, "rb");
228 if(!fp || fread(&cache->data, sizeof(cache->data), 1, fp) != 1 || cache->data.version != ADDRESS_CACHE_VERSION) {
229 memset(&cache->data, 0, sizeof(cache->data));
236 // Ensure we have a valid state
237 cache->config_tree = NULL;
242 cache->data.version = ADDRESS_CACHE_VERSION;
244 if(cache->data.used > MAX_CACHED_ADDRESSES) {
245 cache->data.used = 0;
251 void reset_address_cache(address_cache_t *cache, const sockaddr_t *sa) {
253 add_recent_address(cache, sa);
256 if(cache->config_tree) {
257 exit_configuration(&cache->config_tree);
261 free_known_addresses(cache->ai);
264 cache->config_tree = NULL;
271 void close_address_cache(address_cache_t *cache) {
272 if(cache->config_tree) {
273 exit_configuration(&cache->config_tree);
277 free_known_addresses(cache->ai);