165b390aaSDag-Erling Smørgrav /* 265b390aaSDag-Erling Smørgrav * edns-subnet/subnetmod.c - edns subnet module. Must be called before validator 365b390aaSDag-Erling Smørgrav * and iterator. 465b390aaSDag-Erling Smørgrav * 565b390aaSDag-Erling Smørgrav * Copyright (c) 2013, NLnet Labs. All rights reserved. 665b390aaSDag-Erling Smørgrav * 765b390aaSDag-Erling Smørgrav * This software is open source. 865b390aaSDag-Erling Smørgrav * 965b390aaSDag-Erling Smørgrav * Redistribution and use in source and binary forms, with or without 1065b390aaSDag-Erling Smørgrav * modification, are permitted provided that the following conditions 1165b390aaSDag-Erling Smørgrav * are met: 1265b390aaSDag-Erling Smørgrav * 1365b390aaSDag-Erling Smørgrav * Redistributions of source code must retain the above copyright notice, 1465b390aaSDag-Erling Smørgrav * this list of conditions and the following disclaimer. 1565b390aaSDag-Erling Smørgrav * 1665b390aaSDag-Erling Smørgrav * Redistributions in binary form must reproduce the above copyright notice, 1765b390aaSDag-Erling Smørgrav * this list of conditions and the following disclaimer in the documentation 1865b390aaSDag-Erling Smørgrav * and/or other materials provided with the distribution. 1965b390aaSDag-Erling Smørgrav * 2065b390aaSDag-Erling Smørgrav * Neither the name of the NLNET LABS nor the names of its contributors may 2165b390aaSDag-Erling Smørgrav * be used to endorse or promote products derived from this software without 2265b390aaSDag-Erling Smørgrav * specific prior written permission. 2365b390aaSDag-Erling Smørgrav * 2465b390aaSDag-Erling Smørgrav * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 2565b390aaSDag-Erling Smørgrav * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 2665b390aaSDag-Erling Smørgrav * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 2765b390aaSDag-Erling Smørgrav * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 2865b390aaSDag-Erling Smørgrav * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 2965b390aaSDag-Erling Smørgrav * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 3065b390aaSDag-Erling Smørgrav * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 3165b390aaSDag-Erling Smørgrav * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 3265b390aaSDag-Erling Smørgrav * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 3365b390aaSDag-Erling Smørgrav * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 3465b390aaSDag-Erling Smørgrav * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 3565b390aaSDag-Erling Smørgrav */ 3665b390aaSDag-Erling Smørgrav /** 3765b390aaSDag-Erling Smørgrav * \file 3865b390aaSDag-Erling Smørgrav * subnet module for unbound. 3965b390aaSDag-Erling Smørgrav */ 4065b390aaSDag-Erling Smørgrav 4165b390aaSDag-Erling Smørgrav #include "config.h" 4265b390aaSDag-Erling Smørgrav 4365b390aaSDag-Erling Smørgrav #ifdef CLIENT_SUBNET /* keeps splint happy */ 4465b390aaSDag-Erling Smørgrav 4565b390aaSDag-Erling Smørgrav #include "edns-subnet/subnetmod.h" 4665b390aaSDag-Erling Smørgrav #include "edns-subnet/edns-subnet.h" 4765b390aaSDag-Erling Smørgrav #include "edns-subnet/addrtree.h" 4865b390aaSDag-Erling Smørgrav #include "edns-subnet/subnet-whitelist.h" 4965b390aaSDag-Erling Smørgrav 5065b390aaSDag-Erling Smørgrav #include "services/mesh.h" 5165b390aaSDag-Erling Smørgrav #include "services/cache/dns.h" 5265b390aaSDag-Erling Smørgrav #include "util/module.h" 5365b390aaSDag-Erling Smørgrav #include "util/regional.h" 5465b390aaSDag-Erling Smørgrav #include "util/storage/slabhash.h" 5565b390aaSDag-Erling Smørgrav #include "util/config_file.h" 5665b390aaSDag-Erling Smørgrav #include "util/data/msgreply.h" 5765b390aaSDag-Erling Smørgrav #include "sldns/sbuffer.h" 58865f46b2SCy Schubert #include "sldns/wire2str.h" 59e86b9096SDag-Erling Smørgrav #include "iterator/iter_utils.h" 6065b390aaSDag-Erling Smørgrav 6165b390aaSDag-Erling Smørgrav /** externally called */ 6265b390aaSDag-Erling Smørgrav void 6365b390aaSDag-Erling Smørgrav subnet_data_delete(void *d, void *ATTR_UNUSED(arg)) 6465b390aaSDag-Erling Smørgrav { 6565b390aaSDag-Erling Smørgrav struct subnet_msg_cache_data *r; 6665b390aaSDag-Erling Smørgrav r = (struct subnet_msg_cache_data*)d; 6765b390aaSDag-Erling Smørgrav addrtree_delete(r->tree4); 6865b390aaSDag-Erling Smørgrav addrtree_delete(r->tree6); 6965b390aaSDag-Erling Smørgrav free(r); 7065b390aaSDag-Erling Smørgrav } 7165b390aaSDag-Erling Smørgrav 7265b390aaSDag-Erling Smørgrav /** externally called */ 7365b390aaSDag-Erling Smørgrav size_t 7465b390aaSDag-Erling Smørgrav msg_cache_sizefunc(void *k, void *d) 7565b390aaSDag-Erling Smørgrav { 7665b390aaSDag-Erling Smørgrav struct msgreply_entry *q = (struct msgreply_entry*)k; 7765b390aaSDag-Erling Smørgrav struct subnet_msg_cache_data *r = (struct subnet_msg_cache_data*)d; 7865b390aaSDag-Erling Smørgrav size_t s = sizeof(struct msgreply_entry) 7965b390aaSDag-Erling Smørgrav + sizeof(struct subnet_msg_cache_data) 8065b390aaSDag-Erling Smørgrav + q->key.qname_len + lock_get_mem(&q->entry.lock); 8165b390aaSDag-Erling Smørgrav s += addrtree_size(r->tree4); 8265b390aaSDag-Erling Smørgrav s += addrtree_size(r->tree6); 8365b390aaSDag-Erling Smørgrav return s; 8465b390aaSDag-Erling Smørgrav } 8565b390aaSDag-Erling Smørgrav 8665b390aaSDag-Erling Smørgrav /** new query for ecs module */ 8765b390aaSDag-Erling Smørgrav static int 8865b390aaSDag-Erling Smørgrav subnet_new_qstate(struct module_qstate *qstate, int id) 8965b390aaSDag-Erling Smørgrav { 9065b390aaSDag-Erling Smørgrav struct subnet_qstate *sq = (struct subnet_qstate*)regional_alloc( 9165b390aaSDag-Erling Smørgrav qstate->region, sizeof(struct subnet_qstate)); 9265b390aaSDag-Erling Smørgrav if(!sq) 9365b390aaSDag-Erling Smørgrav return 0; 9465b390aaSDag-Erling Smørgrav qstate->minfo[id] = sq; 9565b390aaSDag-Erling Smørgrav memset(sq, 0, sizeof(*sq)); 96e86b9096SDag-Erling Smørgrav sq->started_no_cache_store = qstate->no_cache_store; 970a92a9fcSCy Schubert sq->started_no_cache_lookup = qstate->no_cache_lookup; 9865b390aaSDag-Erling Smørgrav return 1; 9965b390aaSDag-Erling Smørgrav } 10065b390aaSDag-Erling Smørgrav 10165b390aaSDag-Erling Smørgrav /** Add ecs struct to edns list, after parsing it to wire format. */ 102a39a5a69SCy Schubert void 103a39a5a69SCy Schubert subnet_ecs_opt_list_append(struct ecs_data* ecs, struct edns_option** list, 1040a92a9fcSCy Schubert struct module_qstate *qstate, struct regional *region) 10565b390aaSDag-Erling Smørgrav { 10665b390aaSDag-Erling Smørgrav size_t sn_octs, sn_octs_remainder; 10765b390aaSDag-Erling Smørgrav sldns_buffer* buf = qstate->env->scratch_buffer; 10865b390aaSDag-Erling Smørgrav 10965b390aaSDag-Erling Smørgrav if(ecs->subnet_validdata) { 11065b390aaSDag-Erling Smørgrav log_assert(ecs->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4 || 11165b390aaSDag-Erling Smørgrav ecs->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP6); 11265b390aaSDag-Erling Smørgrav log_assert(ecs->subnet_addr_fam != EDNSSUBNET_ADDRFAM_IP4 || 11365b390aaSDag-Erling Smørgrav ecs->subnet_source_mask <= INET_SIZE*8); 11465b390aaSDag-Erling Smørgrav log_assert(ecs->subnet_addr_fam != EDNSSUBNET_ADDRFAM_IP6 || 11565b390aaSDag-Erling Smørgrav ecs->subnet_source_mask <= INET6_SIZE*8); 11665b390aaSDag-Erling Smørgrav 11765b390aaSDag-Erling Smørgrav sn_octs = ecs->subnet_source_mask / 8; 11865b390aaSDag-Erling Smørgrav sn_octs_remainder = 11965b390aaSDag-Erling Smørgrav (size_t)((ecs->subnet_source_mask % 8)>0?1:0); 12065b390aaSDag-Erling Smørgrav 12165b390aaSDag-Erling Smørgrav log_assert(sn_octs + sn_octs_remainder <= INET6_SIZE); 12265b390aaSDag-Erling Smørgrav 12365b390aaSDag-Erling Smørgrav sldns_buffer_clear(buf); 12465b390aaSDag-Erling Smørgrav sldns_buffer_write_u16(buf, ecs->subnet_addr_fam); 12565b390aaSDag-Erling Smørgrav sldns_buffer_write_u8(buf, ecs->subnet_source_mask); 12665b390aaSDag-Erling Smørgrav sldns_buffer_write_u8(buf, ecs->subnet_scope_mask); 12765b390aaSDag-Erling Smørgrav sldns_buffer_write(buf, ecs->subnet_addr, sn_octs); 12865b390aaSDag-Erling Smørgrav if(sn_octs_remainder) 12965b390aaSDag-Erling Smørgrav sldns_buffer_write_u8(buf, ecs->subnet_addr[sn_octs] & 13065b390aaSDag-Erling Smørgrav ~(0xFF >> (ecs->subnet_source_mask % 8))); 13165b390aaSDag-Erling Smørgrav sldns_buffer_flip(buf); 13265b390aaSDag-Erling Smørgrav 13365b390aaSDag-Erling Smørgrav edns_opt_list_append(list, 13465b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode, 13565b390aaSDag-Erling Smørgrav sn_octs + sn_octs_remainder + 4, 1360a92a9fcSCy Schubert sldns_buffer_begin(buf), region); 13765b390aaSDag-Erling Smørgrav } 13865b390aaSDag-Erling Smørgrav } 13965b390aaSDag-Erling Smørgrav 140c7f4d7adSDag-Erling Smørgrav int ecs_whitelist_check(struct query_info* qinfo, 14165b390aaSDag-Erling Smørgrav uint16_t ATTR_UNUSED(flags), struct module_qstate* qstate, 14265b390aaSDag-Erling Smørgrav struct sockaddr_storage* addr, socklen_t addrlen, 14365b390aaSDag-Erling Smørgrav uint8_t* ATTR_UNUSED(zone), size_t ATTR_UNUSED(zonelen), 1440a92a9fcSCy Schubert struct regional *region, int id, void* ATTR_UNUSED(cbargs)) 14565b390aaSDag-Erling Smørgrav { 14665b390aaSDag-Erling Smørgrav struct subnet_qstate *sq; 14765b390aaSDag-Erling Smørgrav struct subnet_env *sn_env; 14865b390aaSDag-Erling Smørgrav 14965b390aaSDag-Erling Smørgrav if(!(sq=(struct subnet_qstate*)qstate->minfo[id])) 15065b390aaSDag-Erling Smørgrav return 1; 15165b390aaSDag-Erling Smørgrav sn_env = (struct subnet_env*)qstate->env->modinfo[id]; 15265b390aaSDag-Erling Smørgrav 15365b390aaSDag-Erling Smørgrav /* Cache by default, might be disabled after parsing EDNS option 15465b390aaSDag-Erling Smørgrav * received from nameserver. */ 1555469a995SCy Schubert if(!iter_stub_fwd_no_cache(qstate, &qstate->qinfo, NULL, NULL)) { 15665b390aaSDag-Erling Smørgrav qstate->no_cache_store = 0; 157e86b9096SDag-Erling Smørgrav } 15865b390aaSDag-Erling Smørgrav 15965b390aaSDag-Erling Smørgrav if(sq->ecs_server_out.subnet_validdata && ((sq->subnet_downstream && 16065b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_always_forward) || 161c7f4d7adSDag-Erling Smørgrav ecs_is_whitelisted(sn_env->whitelist, 162c7f4d7adSDag-Erling Smørgrav addr, addrlen, qinfo->qname, qinfo->qname_len, 163c7f4d7adSDag-Erling Smørgrav qinfo->qclass))) { 16465b390aaSDag-Erling Smørgrav /* Address on whitelist or client query contains ECS option, we 16565b390aaSDag-Erling Smørgrav * want to sent out ECS. Only add option if it is not already 16665b390aaSDag-Erling Smørgrav * set. */ 167a39a5a69SCy Schubert if(!edns_opt_list_find(qstate->edns_opts_back_out, 168a39a5a69SCy Schubert qstate->env->cfg->client_subnet_opcode)) { 169a39a5a69SCy Schubert subnet_ecs_opt_list_append(&sq->ecs_server_out, 1700a92a9fcSCy Schubert &qstate->edns_opts_back_out, qstate, region); 171a39a5a69SCy Schubert } 17265b390aaSDag-Erling Smørgrav sq->subnet_sent = 1; 17365b390aaSDag-Erling Smørgrav } 174a39a5a69SCy Schubert else { 17565b390aaSDag-Erling Smørgrav /* Outgoing ECS option is set, but we don't want to sent it to 17665b390aaSDag-Erling Smørgrav * this address, remove option. */ 177a39a5a69SCy Schubert if(edns_opt_list_find(qstate->edns_opts_back_out, 178a39a5a69SCy Schubert qstate->env->cfg->client_subnet_opcode)) { 17965b390aaSDag-Erling Smørgrav edns_opt_list_remove(&qstate->edns_opts_back_out, 18065b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode); 181a39a5a69SCy Schubert } 18265b390aaSDag-Erling Smørgrav sq->subnet_sent = 0; 18365b390aaSDag-Erling Smørgrav } 18465b390aaSDag-Erling Smørgrav return 1; 18565b390aaSDag-Erling Smørgrav } 18665b390aaSDag-Erling Smørgrav 18765b390aaSDag-Erling Smørgrav 188e86b9096SDag-Erling Smørgrav void 189e86b9096SDag-Erling Smørgrav subnet_markdel(void* key) 190e86b9096SDag-Erling Smørgrav { 191e86b9096SDag-Erling Smørgrav struct msgreply_entry *e = (struct msgreply_entry*)key; 192e86b9096SDag-Erling Smørgrav e->key.qtype = 0; 193e86b9096SDag-Erling Smørgrav e->key.qclass = 0; 194e86b9096SDag-Erling Smørgrav } 195e86b9096SDag-Erling Smørgrav 19665b390aaSDag-Erling Smørgrav int 19765b390aaSDag-Erling Smørgrav subnetmod_init(struct module_env *env, int id) 19865b390aaSDag-Erling Smørgrav { 19965b390aaSDag-Erling Smørgrav struct subnet_env *sn_env = (struct subnet_env*)calloc(1, 20065b390aaSDag-Erling Smørgrav sizeof(struct subnet_env)); 20165b390aaSDag-Erling Smørgrav if(!sn_env) { 20265b390aaSDag-Erling Smørgrav log_err("malloc failure"); 20365b390aaSDag-Erling Smørgrav return 0; 20465b390aaSDag-Erling Smørgrav } 20565b390aaSDag-Erling Smørgrav alloc_init(&sn_env->alloc, NULL, 0); 20665b390aaSDag-Erling Smørgrav env->modinfo[id] = (void*)sn_env; 207*1838dec3SCy Schubert 208*1838dec3SCy Schubert /* Warn that serve-expired and prefetch do not work with the subnet 209*1838dec3SCy Schubert * module cache. */ 210*1838dec3SCy Schubert if(env->cfg->serve_expired) 211*1838dec3SCy Schubert log_warn( 212*1838dec3SCy Schubert "subnetcache: serve-expired is set but not working " 213*1838dec3SCy Schubert "for data originating from the subnet module cache."); 214*1838dec3SCy Schubert if(env->cfg->prefetch) 215*1838dec3SCy Schubert log_warn( 216*1838dec3SCy Schubert "subnetcache: prefetch is set but not working " 217*1838dec3SCy Schubert "for data originating from the subnet module cache."); 21865b390aaSDag-Erling Smørgrav /* Copy msg_cache settings */ 21965b390aaSDag-Erling Smørgrav sn_env->subnet_msg_cache = slabhash_create(env->cfg->msg_cache_slabs, 22065b390aaSDag-Erling Smørgrav HASH_DEFAULT_STARTARRAY, env->cfg->msg_cache_size, 22165b390aaSDag-Erling Smørgrav msg_cache_sizefunc, query_info_compare, query_entry_delete, 22265b390aaSDag-Erling Smørgrav subnet_data_delete, NULL); 223e86b9096SDag-Erling Smørgrav slabhash_setmarkdel(sn_env->subnet_msg_cache, &subnet_markdel); 22465b390aaSDag-Erling Smørgrav if(!sn_env->subnet_msg_cache) { 2255469a995SCy Schubert log_err("subnetcache: could not create cache"); 22665b390aaSDag-Erling Smørgrav free(sn_env); 22765b390aaSDag-Erling Smørgrav env->modinfo[id] = NULL; 22865b390aaSDag-Erling Smørgrav return 0; 22965b390aaSDag-Erling Smørgrav } 23065b390aaSDag-Erling Smørgrav /* whitelist for edns subnet capable servers */ 231c7f4d7adSDag-Erling Smørgrav sn_env->whitelist = ecs_whitelist_create(); 232c7f4d7adSDag-Erling Smørgrav if(!sn_env->whitelist || 233c7f4d7adSDag-Erling Smørgrav !ecs_whitelist_apply_cfg(sn_env->whitelist, env->cfg)) { 2345469a995SCy Schubert log_err("subnetcache: could not create ECS whitelist"); 23565b390aaSDag-Erling Smørgrav slabhash_delete(sn_env->subnet_msg_cache); 23665b390aaSDag-Erling Smørgrav free(sn_env); 23765b390aaSDag-Erling Smørgrav env->modinfo[id] = NULL; 23865b390aaSDag-Erling Smørgrav return 0; 23965b390aaSDag-Erling Smørgrav } 24065b390aaSDag-Erling Smørgrav 2415469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: option registered (%d)", 24265b390aaSDag-Erling Smørgrav env->cfg->client_subnet_opcode); 24365b390aaSDag-Erling Smørgrav /* Create new mesh state for all queries. */ 24465b390aaSDag-Erling Smørgrav env->unique_mesh = 1; 24565b390aaSDag-Erling Smørgrav if(!edns_register_option(env->cfg->client_subnet_opcode, 24665b390aaSDag-Erling Smørgrav env->cfg->client_subnet_always_forward /* bypass cache */, 247a39a5a69SCy Schubert 1 /* no aggregation */, env)) { 2485469a995SCy Schubert log_err("subnetcache: could not register opcode"); 249c7f4d7adSDag-Erling Smørgrav ecs_whitelist_delete(sn_env->whitelist); 25065b390aaSDag-Erling Smørgrav slabhash_delete(sn_env->subnet_msg_cache); 25165b390aaSDag-Erling Smørgrav free(sn_env); 25265b390aaSDag-Erling Smørgrav env->modinfo[id] = NULL; 25365b390aaSDag-Erling Smørgrav return 0; 25465b390aaSDag-Erling Smørgrav } 25565b390aaSDag-Erling Smørgrav inplace_cb_register((void*)ecs_whitelist_check, inplace_cb_query, NULL, 25665b390aaSDag-Erling Smørgrav env, id); 25765b390aaSDag-Erling Smørgrav inplace_cb_register((void*)ecs_edns_back_parsed, 25865b390aaSDag-Erling Smørgrav inplace_cb_edns_back_parsed, NULL, env, id); 25965b390aaSDag-Erling Smørgrav inplace_cb_register((void*)ecs_query_response, 26065b390aaSDag-Erling Smørgrav inplace_cb_query_response, NULL, env, id); 26165b390aaSDag-Erling Smørgrav lock_rw_init(&sn_env->biglock); 26265b390aaSDag-Erling Smørgrav return 1; 26365b390aaSDag-Erling Smørgrav } 26465b390aaSDag-Erling Smørgrav 26565b390aaSDag-Erling Smørgrav void 26665b390aaSDag-Erling Smørgrav subnetmod_deinit(struct module_env *env, int id) 26765b390aaSDag-Erling Smørgrav { 26865b390aaSDag-Erling Smørgrav struct subnet_env *sn_env; 26965b390aaSDag-Erling Smørgrav if(!env || !env->modinfo[id]) 27065b390aaSDag-Erling Smørgrav return; 27165b390aaSDag-Erling Smørgrav sn_env = (struct subnet_env*)env->modinfo[id]; 27265b390aaSDag-Erling Smørgrav lock_rw_destroy(&sn_env->biglock); 27365b390aaSDag-Erling Smørgrav inplace_cb_delete(env, inplace_cb_edns_back_parsed, id); 27465b390aaSDag-Erling Smørgrav inplace_cb_delete(env, inplace_cb_query, id); 275c7f4d7adSDag-Erling Smørgrav inplace_cb_delete(env, inplace_cb_query_response, id); 276c7f4d7adSDag-Erling Smørgrav ecs_whitelist_delete(sn_env->whitelist); 27765b390aaSDag-Erling Smørgrav slabhash_delete(sn_env->subnet_msg_cache); 27865b390aaSDag-Erling Smørgrav alloc_clear(&sn_env->alloc); 27965b390aaSDag-Erling Smørgrav free(sn_env); 28065b390aaSDag-Erling Smørgrav env->modinfo[id] = NULL; 28165b390aaSDag-Erling Smørgrav } 28265b390aaSDag-Erling Smørgrav 28365b390aaSDag-Erling Smørgrav /** Tells client that upstream has no/improper support */ 28465b390aaSDag-Erling Smørgrav static void 28565b390aaSDag-Erling Smørgrav cp_edns_bad_response(struct ecs_data *target, struct ecs_data *source) 28665b390aaSDag-Erling Smørgrav { 28765b390aaSDag-Erling Smørgrav target->subnet_scope_mask = 0; 28865b390aaSDag-Erling Smørgrav target->subnet_source_mask = source->subnet_source_mask; 28965b390aaSDag-Erling Smørgrav target->subnet_addr_fam = source->subnet_addr_fam; 29065b390aaSDag-Erling Smørgrav memcpy(target->subnet_addr, source->subnet_addr, INET6_SIZE); 29165b390aaSDag-Erling Smørgrav target->subnet_validdata = 1; 29265b390aaSDag-Erling Smørgrav } 29365b390aaSDag-Erling Smørgrav 29465b390aaSDag-Erling Smørgrav static void 29565b390aaSDag-Erling Smørgrav delfunc(void *envptr, void *elemptr) { 29665b390aaSDag-Erling Smørgrav struct reply_info *elem = (struct reply_info *)elemptr; 29765b390aaSDag-Erling Smørgrav struct subnet_env *env = (struct subnet_env *)envptr; 29865b390aaSDag-Erling Smørgrav reply_info_parsedelete(elem, &env->alloc); 29965b390aaSDag-Erling Smørgrav } 30065b390aaSDag-Erling Smørgrav 30165b390aaSDag-Erling Smørgrav static size_t 30265b390aaSDag-Erling Smørgrav sizefunc(void *elemptr) { 30365b390aaSDag-Erling Smørgrav struct reply_info *elem = (struct reply_info *)elemptr; 30465b390aaSDag-Erling Smørgrav return sizeof (struct reply_info) - sizeof (struct rrset_ref) 30565b390aaSDag-Erling Smørgrav + elem->rrset_count * sizeof (struct rrset_ref) 30665b390aaSDag-Erling Smørgrav + elem->rrset_count * sizeof (struct ub_packed_rrset_key *); 30765b390aaSDag-Erling Smørgrav } 30865b390aaSDag-Erling Smørgrav 30965b390aaSDag-Erling Smørgrav /** 31065b390aaSDag-Erling Smørgrav * Select tree from cache entry based on edns data. 31165b390aaSDag-Erling Smørgrav * If for address family not present it will create a new one. 31265b390aaSDag-Erling Smørgrav * NULL on failure to create. */ 31365b390aaSDag-Erling Smørgrav static struct addrtree* 31465b390aaSDag-Erling Smørgrav get_tree(struct subnet_msg_cache_data *data, struct ecs_data *edns, 31565b390aaSDag-Erling Smørgrav struct subnet_env *env, struct config_file* cfg) 31665b390aaSDag-Erling Smørgrav { 31765b390aaSDag-Erling Smørgrav struct addrtree *tree; 31865b390aaSDag-Erling Smørgrav if (edns->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4) { 31965b390aaSDag-Erling Smørgrav if (!data->tree4) 32065b390aaSDag-Erling Smørgrav data->tree4 = addrtree_create( 32165b390aaSDag-Erling Smørgrav cfg->max_client_subnet_ipv4, &delfunc, 322e86b9096SDag-Erling Smørgrav &sizefunc, env, cfg->max_ecs_tree_size_ipv4); 32365b390aaSDag-Erling Smørgrav tree = data->tree4; 32465b390aaSDag-Erling Smørgrav } else { 32565b390aaSDag-Erling Smørgrav if (!data->tree6) 32665b390aaSDag-Erling Smørgrav data->tree6 = addrtree_create( 32765b390aaSDag-Erling Smørgrav cfg->max_client_subnet_ipv6, &delfunc, 328e86b9096SDag-Erling Smørgrav &sizefunc, env, cfg->max_ecs_tree_size_ipv6); 32965b390aaSDag-Erling Smørgrav tree = data->tree6; 33065b390aaSDag-Erling Smørgrav } 33165b390aaSDag-Erling Smørgrav return tree; 33265b390aaSDag-Erling Smørgrav } 33365b390aaSDag-Erling Smørgrav 33465b390aaSDag-Erling Smørgrav static void 33565b390aaSDag-Erling Smørgrav update_cache(struct module_qstate *qstate, int id) 33665b390aaSDag-Erling Smørgrav { 33765b390aaSDag-Erling Smørgrav struct msgreply_entry *mrep_entry; 33865b390aaSDag-Erling Smørgrav struct addrtree *tree; 33965b390aaSDag-Erling Smørgrav struct reply_info *rep; 34065b390aaSDag-Erling Smørgrav struct query_info qinf; 34165b390aaSDag-Erling Smørgrav struct subnet_env *sne = qstate->env->modinfo[id]; 34265b390aaSDag-Erling Smørgrav struct subnet_qstate *sq = (struct subnet_qstate*)qstate->minfo[id]; 34365b390aaSDag-Erling Smørgrav struct slabhash *subnet_msg_cache = sne->subnet_msg_cache; 34465b390aaSDag-Erling Smørgrav struct ecs_data *edns = &sq->ecs_client_in; 34565b390aaSDag-Erling Smørgrav size_t i; 346865f46b2SCy Schubert int only_match_scope_zero; 34765b390aaSDag-Erling Smørgrav 3480a92a9fcSCy Schubert /* We already calculated hash upon lookup (lookup_and_reply) if we were 3490a92a9fcSCy Schubert * allowed to look in the ECS cache */ 3500a92a9fcSCy Schubert hashvalue_type h = qstate->minfo[id] && 3510a92a9fcSCy Schubert ((struct subnet_qstate*)qstate->minfo[id])->qinfo_hash_calculated? 35265b390aaSDag-Erling Smørgrav ((struct subnet_qstate*)qstate->minfo[id])->qinfo_hash : 35365b390aaSDag-Erling Smørgrav query_info_hash(&qstate->qinfo, qstate->query_flags); 35465b390aaSDag-Erling Smørgrav /* Step 1, general qinfo lookup */ 35565b390aaSDag-Erling Smørgrav struct lruhash_entry *lru_entry = slabhash_lookup(subnet_msg_cache, h, 35665b390aaSDag-Erling Smørgrav &qstate->qinfo, 1); 357e86b9096SDag-Erling Smørgrav int need_to_insert = (lru_entry == NULL); 35865b390aaSDag-Erling Smørgrav if (!lru_entry) { 359e86b9096SDag-Erling Smørgrav void* data = calloc(1, 360e86b9096SDag-Erling Smørgrav sizeof(struct subnet_msg_cache_data)); 361e86b9096SDag-Erling Smørgrav if(!data) { 362e86b9096SDag-Erling Smørgrav log_err("malloc failed"); 363e86b9096SDag-Erling Smørgrav return; 364e86b9096SDag-Erling Smørgrav } 36565b390aaSDag-Erling Smørgrav qinf = qstate->qinfo; 36665b390aaSDag-Erling Smørgrav qinf.qname = memdup(qstate->qinfo.qname, 36765b390aaSDag-Erling Smørgrav qstate->qinfo.qname_len); 36865b390aaSDag-Erling Smørgrav if(!qinf.qname) { 369e86b9096SDag-Erling Smørgrav free(data); 37065b390aaSDag-Erling Smørgrav log_err("memdup failed"); 37165b390aaSDag-Erling Smørgrav return; 37265b390aaSDag-Erling Smørgrav } 373e86b9096SDag-Erling Smørgrav mrep_entry = query_info_entrysetup(&qinf, data, h); 37465b390aaSDag-Erling Smørgrav free(qinf.qname); /* if qname 'consumed', it is set to NULL */ 37565b390aaSDag-Erling Smørgrav if (!mrep_entry) { 376e86b9096SDag-Erling Smørgrav free(data); 37765b390aaSDag-Erling Smørgrav log_err("query_info_entrysetup failed"); 37865b390aaSDag-Erling Smørgrav return; 37965b390aaSDag-Erling Smørgrav } 38065b390aaSDag-Erling Smørgrav lru_entry = &mrep_entry->entry; 38157bddd21SDag-Erling Smørgrav lock_rw_wrlock(&lru_entry->lock); 38265b390aaSDag-Erling Smørgrav } 383e86b9096SDag-Erling Smørgrav /* lru_entry->lock is locked regardless of how we got here, 384e86b9096SDag-Erling Smørgrav * either from the slabhash_lookup, or above in the new allocated */ 38565b390aaSDag-Erling Smørgrav /* Step 2, find the correct tree */ 38665b390aaSDag-Erling Smørgrav if (!(tree = get_tree(lru_entry->data, edns, sne, qstate->env->cfg))) { 387e86b9096SDag-Erling Smørgrav lock_rw_unlock(&lru_entry->lock); 3885469a995SCy Schubert log_err("subnetcache: cache insertion failed"); 38965b390aaSDag-Erling Smørgrav return; 39065b390aaSDag-Erling Smørgrav } 39157bddd21SDag-Erling Smørgrav lock_quick_lock(&sne->alloc.lock); 39265b390aaSDag-Erling Smørgrav rep = reply_info_copy(qstate->return_msg->rep, &sne->alloc, NULL); 39357bddd21SDag-Erling Smørgrav lock_quick_unlock(&sne->alloc.lock); 39465b390aaSDag-Erling Smørgrav if (!rep) { 395e86b9096SDag-Erling Smørgrav lock_rw_unlock(&lru_entry->lock); 3965469a995SCy Schubert log_err("subnetcache: cache insertion failed"); 39765b390aaSDag-Erling Smørgrav return; 39865b390aaSDag-Erling Smørgrav } 39965b390aaSDag-Erling Smørgrav 40065b390aaSDag-Erling Smørgrav /* store RRsets */ 40165b390aaSDag-Erling Smørgrav for(i=0; i<rep->rrset_count; i++) { 40265b390aaSDag-Erling Smørgrav rep->ref[i].key = rep->rrsets[i]; 40365b390aaSDag-Erling Smørgrav rep->ref[i].id = rep->rrsets[i]->id; 40465b390aaSDag-Erling Smørgrav } 40565b390aaSDag-Erling Smørgrav reply_info_set_ttls(rep, *qstate->env->now); 40665b390aaSDag-Erling Smørgrav rep->flags |= (BIT_RA | BIT_QR); /* fix flags to be sensible for */ 40765b390aaSDag-Erling Smørgrav rep->flags &= ~(BIT_AA | BIT_CD);/* a reply based on the cache */ 408865f46b2SCy Schubert if(edns->subnet_source_mask == 0 && edns->subnet_scope_mask == 0) 409865f46b2SCy Schubert only_match_scope_zero = 1; 410865f46b2SCy Schubert else only_match_scope_zero = 0; 41165b390aaSDag-Erling Smørgrav addrtree_insert(tree, (addrkey_t*)edns->subnet_addr, 41225039b37SCy Schubert edns->subnet_source_mask, sq->max_scope, rep, 413865f46b2SCy Schubert rep->ttl, *qstate->env->now, only_match_scope_zero); 414e86b9096SDag-Erling Smørgrav 41565b390aaSDag-Erling Smørgrav lock_rw_unlock(&lru_entry->lock); 416e86b9096SDag-Erling Smørgrav if (need_to_insert) { 41765b390aaSDag-Erling Smørgrav slabhash_insert(subnet_msg_cache, h, lru_entry, lru_entry->data, 41865b390aaSDag-Erling Smørgrav NULL); 41965b390aaSDag-Erling Smørgrav } 42065b390aaSDag-Erling Smørgrav } 42165b390aaSDag-Erling Smørgrav 42265b390aaSDag-Erling Smørgrav /** Lookup in cache and reply true iff reply is sent. */ 42365b390aaSDag-Erling Smørgrav static int 42465b390aaSDag-Erling Smørgrav lookup_and_reply(struct module_qstate *qstate, int id, struct subnet_qstate *sq) 42565b390aaSDag-Erling Smørgrav { 42665b390aaSDag-Erling Smørgrav struct lruhash_entry *e; 42765b390aaSDag-Erling Smørgrav struct module_env *env = qstate->env; 42865b390aaSDag-Erling Smørgrav struct subnet_env *sne = (struct subnet_env*)env->modinfo[id]; 42965b390aaSDag-Erling Smørgrav hashvalue_type h = query_info_hash(&qstate->qinfo, qstate->query_flags); 43065b390aaSDag-Erling Smørgrav struct subnet_msg_cache_data *data; 43165b390aaSDag-Erling Smørgrav struct ecs_data *ecs = &sq->ecs_client_in; 43265b390aaSDag-Erling Smørgrav struct addrtree *tree; 43365b390aaSDag-Erling Smørgrav struct addrnode *node; 43465b390aaSDag-Erling Smørgrav uint8_t scope; 43565b390aaSDag-Erling Smørgrav 43665b390aaSDag-Erling Smørgrav memset(&sq->ecs_client_out, 0, sizeof(sq->ecs_client_out)); 43765b390aaSDag-Erling Smørgrav 4380a92a9fcSCy Schubert if (sq) { 4390a92a9fcSCy Schubert sq->qinfo_hash = h; /* Might be useful on cache miss */ 4400a92a9fcSCy Schubert sq->qinfo_hash_calculated = 1; 4410a92a9fcSCy Schubert } 44265b390aaSDag-Erling Smørgrav e = slabhash_lookup(sne->subnet_msg_cache, h, &qstate->qinfo, 1); 44365b390aaSDag-Erling Smørgrav if (!e) return 0; /* qinfo not in cache */ 44465b390aaSDag-Erling Smørgrav data = e->data; 44565b390aaSDag-Erling Smørgrav tree = (ecs->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4)? 44665b390aaSDag-Erling Smørgrav data->tree4 : data->tree6; 44765b390aaSDag-Erling Smørgrav if (!tree) { /* qinfo in cache but not for this family */ 44865b390aaSDag-Erling Smørgrav lock_rw_unlock(&e->lock); 44965b390aaSDag-Erling Smørgrav return 0; 45065b390aaSDag-Erling Smørgrav } 45165b390aaSDag-Erling Smørgrav node = addrtree_find(tree, (addrkey_t*)ecs->subnet_addr, 45265b390aaSDag-Erling Smørgrav ecs->subnet_source_mask, *env->now); 45365b390aaSDag-Erling Smørgrav if (!node) { /* plain old cache miss */ 45465b390aaSDag-Erling Smørgrav lock_rw_unlock(&e->lock); 45565b390aaSDag-Erling Smørgrav return 0; 45665b390aaSDag-Erling Smørgrav } 45765b390aaSDag-Erling Smørgrav 45865b390aaSDag-Erling Smørgrav qstate->return_msg = tomsg(NULL, &qstate->qinfo, 459091e9e46SCy Schubert (struct reply_info *)node->elem, qstate->region, *env->now, 0, 46065b390aaSDag-Erling Smørgrav env->scratch); 46165b390aaSDag-Erling Smørgrav scope = (uint8_t)node->scope; 46265b390aaSDag-Erling Smørgrav lock_rw_unlock(&e->lock); 46365b390aaSDag-Erling Smørgrav 46465b390aaSDag-Erling Smørgrav if (!qstate->return_msg) { /* Failed allocation or expired TTL */ 46565b390aaSDag-Erling Smørgrav return 0; 46665b390aaSDag-Erling Smørgrav } 46765b390aaSDag-Erling Smørgrav 46865b390aaSDag-Erling Smørgrav if (sq->subnet_downstream) { /* relay to interested client */ 46965b390aaSDag-Erling Smørgrav sq->ecs_client_out.subnet_scope_mask = scope; 47065b390aaSDag-Erling Smørgrav sq->ecs_client_out.subnet_addr_fam = ecs->subnet_addr_fam; 47165b390aaSDag-Erling Smørgrav sq->ecs_client_out.subnet_source_mask = ecs->subnet_source_mask; 47265b390aaSDag-Erling Smørgrav memcpy(&sq->ecs_client_out.subnet_addr, &ecs->subnet_addr, 47365b390aaSDag-Erling Smørgrav INET6_SIZE); 47465b390aaSDag-Erling Smørgrav sq->ecs_client_out.subnet_validdata = 1; 47565b390aaSDag-Erling Smørgrav } 47665b390aaSDag-Erling Smørgrav return 1; 47765b390aaSDag-Erling Smørgrav } 47865b390aaSDag-Erling Smørgrav 47965b390aaSDag-Erling Smørgrav /** 48065b390aaSDag-Erling Smørgrav * Test first bits of addresses for equality. Caller is responsible 48165b390aaSDag-Erling Smørgrav * for making sure that both a and b are at least net/8 octets long. 48265b390aaSDag-Erling Smørgrav * @param a: first address. 48365b390aaSDag-Erling Smørgrav * @param a: seconds address. 48465b390aaSDag-Erling Smørgrav * @param net: Number of bits to test. 48565b390aaSDag-Erling Smørgrav * @return: 1 if equal, 0 otherwise. 48665b390aaSDag-Erling Smørgrav */ 48765b390aaSDag-Erling Smørgrav static int 48865b390aaSDag-Erling Smørgrav common_prefix(uint8_t *a, uint8_t *b, uint8_t net) 48965b390aaSDag-Erling Smørgrav { 49065b390aaSDag-Erling Smørgrav size_t n = (size_t)net / 8; 49165b390aaSDag-Erling Smørgrav return !memcmp(a, b, n) && ((net % 8) == 0 || a[n] == b[n]); 49265b390aaSDag-Erling Smørgrav } 49365b390aaSDag-Erling Smørgrav 49465b390aaSDag-Erling Smørgrav static enum module_ext_state 49565b390aaSDag-Erling Smørgrav eval_response(struct module_qstate *qstate, int id, struct subnet_qstate *sq) 49665b390aaSDag-Erling Smørgrav { 49765b390aaSDag-Erling Smørgrav struct subnet_env *sne = qstate->env->modinfo[id]; 49865b390aaSDag-Erling Smørgrav 49965b390aaSDag-Erling Smørgrav struct ecs_data *c_in = &sq->ecs_client_in; /* rcvd from client */ 50065b390aaSDag-Erling Smørgrav struct ecs_data *c_out = &sq->ecs_client_out;/* will send to client */ 50165b390aaSDag-Erling Smørgrav struct ecs_data *s_in = &sq->ecs_server_in; /* rcvd from auth */ 50265b390aaSDag-Erling Smørgrav struct ecs_data *s_out = &sq->ecs_server_out;/* sent to auth */ 50365b390aaSDag-Erling Smørgrav 50465b390aaSDag-Erling Smørgrav memset(c_out, 0, sizeof(*c_out)); 50565b390aaSDag-Erling Smørgrav 5064c75e3aaSDag-Erling Smørgrav if (!qstate->return_msg) { 5074c75e3aaSDag-Erling Smørgrav /* already an answer and its not a message, but retain 5084c75e3aaSDag-Erling Smørgrav * the actual rcode, instead of module_error, so send 5094c75e3aaSDag-Erling Smørgrav * module_finished */ 5104c75e3aaSDag-Erling Smørgrav return module_finished; 5114c75e3aaSDag-Erling Smørgrav } 51265b390aaSDag-Erling Smørgrav 51365b390aaSDag-Erling Smørgrav /* We have not asked for subnet data */ 51465b390aaSDag-Erling Smørgrav if (!sq->subnet_sent) { 51565b390aaSDag-Erling Smørgrav if (s_in->subnet_validdata) 5165469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: received spurious data"); 51765b390aaSDag-Erling Smørgrav if (sq->subnet_downstream) /* Copy back to client */ 51865b390aaSDag-Erling Smørgrav cp_edns_bad_response(c_out, c_in); 51965b390aaSDag-Erling Smørgrav return module_finished; 52065b390aaSDag-Erling Smørgrav } 52165b390aaSDag-Erling Smørgrav 52265b390aaSDag-Erling Smørgrav /* subnet sent but nothing came back */ 52365b390aaSDag-Erling Smørgrav if (!s_in->subnet_validdata) { 52465b390aaSDag-Erling Smørgrav /* The authority indicated no support for edns subnet. As a 52565b390aaSDag-Erling Smørgrav * consequence the answer ended up in the regular cache. It 52624e36522SCy Schubert * is still useful to put it in the edns subnet cache for 52765b390aaSDag-Erling Smørgrav * when a client explicitly asks for subnet specific answer. */ 5285469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: Authority indicates no support"); 529e86b9096SDag-Erling Smørgrav if(!sq->started_no_cache_store) { 53065b390aaSDag-Erling Smørgrav lock_rw_wrlock(&sne->biglock); 53165b390aaSDag-Erling Smørgrav update_cache(qstate, id); 53265b390aaSDag-Erling Smørgrav lock_rw_unlock(&sne->biglock); 533e86b9096SDag-Erling Smørgrav } 53465b390aaSDag-Erling Smørgrav if (sq->subnet_downstream) 53565b390aaSDag-Erling Smørgrav cp_edns_bad_response(c_out, c_in); 53665b390aaSDag-Erling Smørgrav return module_finished; 53765b390aaSDag-Erling Smørgrav } 53865b390aaSDag-Erling Smørgrav 53965b390aaSDag-Erling Smørgrav /* Being here means we have asked for and got a subnet specific 54065b390aaSDag-Erling Smørgrav * answer. Also, the answer from the authority is not yet cached 54165b390aaSDag-Erling Smørgrav * anywhere. */ 54265b390aaSDag-Erling Smørgrav 54365b390aaSDag-Erling Smørgrav /* can we accept response? */ 54465b390aaSDag-Erling Smørgrav if(s_out->subnet_addr_fam != s_in->subnet_addr_fam || 54565b390aaSDag-Erling Smørgrav s_out->subnet_source_mask != s_in->subnet_source_mask || 54665b390aaSDag-Erling Smørgrav !common_prefix(s_out->subnet_addr, s_in->subnet_addr, 54765b390aaSDag-Erling Smørgrav s_out->subnet_source_mask)) 54865b390aaSDag-Erling Smørgrav { 54965b390aaSDag-Erling Smørgrav /* we can not accept, restart query without option */ 5505469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: forged data"); 55165b390aaSDag-Erling Smørgrav s_out->subnet_validdata = 0; 55265b390aaSDag-Erling Smørgrav (void)edns_opt_list_remove(&qstate->edns_opts_back_out, 55365b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode); 55465b390aaSDag-Erling Smørgrav sq->subnet_sent = 0; 55565b390aaSDag-Erling Smørgrav return module_restart_next; 55665b390aaSDag-Erling Smørgrav } 55765b390aaSDag-Erling Smørgrav 55865b390aaSDag-Erling Smørgrav lock_rw_wrlock(&sne->biglock); 559e86b9096SDag-Erling Smørgrav if(!sq->started_no_cache_store) { 56065b390aaSDag-Erling Smørgrav update_cache(qstate, id); 561e86b9096SDag-Erling Smørgrav } 5624c75e3aaSDag-Erling Smørgrav sne->num_msg_nocache++; 56365b390aaSDag-Erling Smørgrav lock_rw_unlock(&sne->biglock); 56465b390aaSDag-Erling Smørgrav 56565b390aaSDag-Erling Smørgrav if (sq->subnet_downstream) { 56665b390aaSDag-Erling Smørgrav /* Client wants to see the answer, echo option back 56765b390aaSDag-Erling Smørgrav * and adjust the scope. */ 56865b390aaSDag-Erling Smørgrav c_out->subnet_addr_fam = c_in->subnet_addr_fam; 56965b390aaSDag-Erling Smørgrav c_out->subnet_source_mask = c_in->subnet_source_mask; 57065b390aaSDag-Erling Smørgrav memcpy(&c_out->subnet_addr, &c_in->subnet_addr, INET6_SIZE); 57125039b37SCy Schubert c_out->subnet_scope_mask = sq->max_scope; 572e86b9096SDag-Erling Smørgrav /* Limit scope returned to client to scope used for caching. */ 573e86b9096SDag-Erling Smørgrav if(c_out->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4) { 574e86b9096SDag-Erling Smørgrav if(c_out->subnet_scope_mask > 575e86b9096SDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv4) { 576e86b9096SDag-Erling Smørgrav c_out->subnet_scope_mask = 577e86b9096SDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv4; 578e86b9096SDag-Erling Smørgrav } 579e86b9096SDag-Erling Smørgrav } 580e86b9096SDag-Erling Smørgrav else if(c_out->subnet_scope_mask > 581e86b9096SDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv6) { 582e86b9096SDag-Erling Smørgrav c_out->subnet_scope_mask = 583e86b9096SDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv6; 584e86b9096SDag-Erling Smørgrav } 58565b390aaSDag-Erling Smørgrav c_out->subnet_validdata = 1; 58665b390aaSDag-Erling Smørgrav } 58765b390aaSDag-Erling Smørgrav return module_finished; 58865b390aaSDag-Erling Smørgrav } 58965b390aaSDag-Erling Smørgrav 59065b390aaSDag-Erling Smørgrav /** Parse EDNS opt data containing ECS */ 59165b390aaSDag-Erling Smørgrav static int 59265b390aaSDag-Erling Smørgrav parse_subnet_option(struct edns_option* ecs_option, struct ecs_data* ecs) 59365b390aaSDag-Erling Smørgrav { 59465b390aaSDag-Erling Smørgrav memset(ecs, 0, sizeof(*ecs)); 59565b390aaSDag-Erling Smørgrav if (ecs_option->opt_len < 4) 59665b390aaSDag-Erling Smørgrav return 0; 59765b390aaSDag-Erling Smørgrav 59865b390aaSDag-Erling Smørgrav ecs->subnet_addr_fam = sldns_read_uint16(ecs_option->opt_data); 59965b390aaSDag-Erling Smørgrav ecs->subnet_source_mask = ecs_option->opt_data[2]; 60065b390aaSDag-Erling Smørgrav ecs->subnet_scope_mask = ecs_option->opt_data[3]; 6018a384985SDag-Erling Smørgrav /* remaining bytes indicate address */ 60265b390aaSDag-Erling Smørgrav 60365b390aaSDag-Erling Smørgrav /* validate input*/ 60465b390aaSDag-Erling Smørgrav /* option length matches calculated length? */ 60565b390aaSDag-Erling Smørgrav if (ecs_option->opt_len != (size_t)((ecs->subnet_source_mask+7)/8 + 4)) 60665b390aaSDag-Erling Smørgrav return 0; 60765b390aaSDag-Erling Smørgrav if (ecs_option->opt_len - 4 > INET6_SIZE || ecs_option->opt_len == 0) 60865b390aaSDag-Erling Smørgrav return 0; 60965b390aaSDag-Erling Smørgrav if (ecs->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4) { 61065b390aaSDag-Erling Smørgrav if (ecs->subnet_source_mask > 32 || ecs->subnet_scope_mask > 32) 61165b390aaSDag-Erling Smørgrav return 0; 61265b390aaSDag-Erling Smørgrav } else if (ecs->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP6) { 61365b390aaSDag-Erling Smørgrav if (ecs->subnet_source_mask > 128 || 61465b390aaSDag-Erling Smørgrav ecs->subnet_scope_mask > 128) 61565b390aaSDag-Erling Smørgrav return 0; 61665b390aaSDag-Erling Smørgrav } else 61765b390aaSDag-Erling Smørgrav return 0; 61865b390aaSDag-Erling Smørgrav 61965b390aaSDag-Erling Smørgrav /* valid ECS data, write to ecs_data */ 62065b390aaSDag-Erling Smørgrav if (copy_clear(ecs->subnet_addr, INET6_SIZE, ecs_option->opt_data + 4, 62165b390aaSDag-Erling Smørgrav ecs_option->opt_len - 4, ecs->subnet_source_mask)) 62265b390aaSDag-Erling Smørgrav return 0; 62365b390aaSDag-Erling Smørgrav ecs->subnet_validdata = 1; 62465b390aaSDag-Erling Smørgrav return 1; 62565b390aaSDag-Erling Smørgrav } 62665b390aaSDag-Erling Smørgrav 627a39a5a69SCy Schubert void 62865b390aaSDag-Erling Smørgrav subnet_option_from_ss(struct sockaddr_storage *ss, struct ecs_data* ecs, 62965b390aaSDag-Erling Smørgrav struct config_file* cfg) 63065b390aaSDag-Erling Smørgrav { 63165b390aaSDag-Erling Smørgrav void* sinaddr; 63265b390aaSDag-Erling Smørgrav 63365b390aaSDag-Erling Smørgrav /* Construct subnet option from original query */ 63465b390aaSDag-Erling Smørgrav if(((struct sockaddr_in*)ss)->sin_family == AF_INET) { 63565b390aaSDag-Erling Smørgrav ecs->subnet_source_mask = cfg->max_client_subnet_ipv4; 63665b390aaSDag-Erling Smørgrav ecs->subnet_addr_fam = EDNSSUBNET_ADDRFAM_IP4; 63765b390aaSDag-Erling Smørgrav sinaddr = &((struct sockaddr_in*)ss)->sin_addr; 63865b390aaSDag-Erling Smørgrav if (!copy_clear( ecs->subnet_addr, INET6_SIZE, 63965b390aaSDag-Erling Smørgrav (uint8_t *)sinaddr, INET_SIZE, 64065b390aaSDag-Erling Smørgrav ecs->subnet_source_mask)) { 64165b390aaSDag-Erling Smørgrav ecs->subnet_validdata = 1; 64265b390aaSDag-Erling Smørgrav } 64365b390aaSDag-Erling Smørgrav } 64465b390aaSDag-Erling Smørgrav #ifdef INET6 64565b390aaSDag-Erling Smørgrav else { 64665b390aaSDag-Erling Smørgrav ecs->subnet_source_mask = cfg->max_client_subnet_ipv6; 64765b390aaSDag-Erling Smørgrav ecs->subnet_addr_fam = EDNSSUBNET_ADDRFAM_IP6; 64865b390aaSDag-Erling Smørgrav sinaddr = &((struct sockaddr_in6*)ss)->sin6_addr; 64965b390aaSDag-Erling Smørgrav if (!copy_clear( ecs->subnet_addr, INET6_SIZE, 65065b390aaSDag-Erling Smørgrav (uint8_t *)sinaddr, INET6_SIZE, 65165b390aaSDag-Erling Smørgrav ecs->subnet_source_mask)) { 65265b390aaSDag-Erling Smørgrav ecs->subnet_validdata = 1; 65365b390aaSDag-Erling Smørgrav } 65465b390aaSDag-Erling Smørgrav } 65565b390aaSDag-Erling Smørgrav #else 65665b390aaSDag-Erling Smørgrav /* We don't know how to handle ip6, just pass */ 65765b390aaSDag-Erling Smørgrav #endif /* INET6 */ 65865b390aaSDag-Erling Smørgrav } 65965b390aaSDag-Erling Smørgrav 66065b390aaSDag-Erling Smørgrav int 66165b390aaSDag-Erling Smørgrav ecs_query_response(struct module_qstate* qstate, struct dns_msg* response, 66265b390aaSDag-Erling Smørgrav int id, void* ATTR_UNUSED(cbargs)) 66365b390aaSDag-Erling Smørgrav { 66465b390aaSDag-Erling Smørgrav struct subnet_qstate *sq; 66565b390aaSDag-Erling Smørgrav 66665b390aaSDag-Erling Smørgrav if(!response || !(sq=(struct subnet_qstate*)qstate->minfo[id])) 66765b390aaSDag-Erling Smørgrav return 1; 66865b390aaSDag-Erling Smørgrav 66965b390aaSDag-Erling Smørgrav if(sq->subnet_sent && 67065b390aaSDag-Erling Smørgrav FLAGS_GET_RCODE(response->rep->flags) == LDNS_RCODE_REFUSED) { 6718a384985SDag-Erling Smørgrav /* REFUSED response to ECS query, remove ECS option. */ 67265b390aaSDag-Erling Smørgrav edns_opt_list_remove(&qstate->edns_opts_back_out, 67365b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode); 67465b390aaSDag-Erling Smørgrav sq->subnet_sent = 0; 67565b390aaSDag-Erling Smørgrav memset(&sq->ecs_server_out, 0, sizeof(sq->ecs_server_out)); 67625039b37SCy Schubert } else if (!sq->track_max_scope && 67725039b37SCy Schubert FLAGS_GET_RCODE(response->rep->flags) == LDNS_RCODE_NOERROR && 67825039b37SCy Schubert response->rep->an_numrrsets > 0 67925039b37SCy Schubert ) { 68025039b37SCy Schubert struct ub_packed_rrset_key* s = response->rep->rrsets[0]; 68125039b37SCy Schubert if(ntohs(s->rk.type) == LDNS_RR_TYPE_CNAME && 68225039b37SCy Schubert query_dname_compare(qstate->qinfo.qname, 68325039b37SCy Schubert s->rk.dname) == 0) { 68425039b37SCy Schubert /* CNAME response for QNAME. From now on keep track of 68525039b37SCy Schubert * longest received ECS prefix for all queries on this 68625039b37SCy Schubert * qstate. */ 68725039b37SCy Schubert sq->track_max_scope = 1; 68825039b37SCy Schubert } 68965b390aaSDag-Erling Smørgrav } 69065b390aaSDag-Erling Smørgrav return 1; 69165b390aaSDag-Erling Smørgrav } 69265b390aaSDag-Erling Smørgrav 693865f46b2SCy Schubert /** verbose print edns subnet option in pretty print */ 694865f46b2SCy Schubert static void 695865f46b2SCy Schubert subnet_log_print(const char* s, struct edns_option* ecs_opt) 696865f46b2SCy Schubert { 697865f46b2SCy Schubert if(verbosity >= VERB_ALGO) { 698865f46b2SCy Schubert char buf[256]; 699865f46b2SCy Schubert char* str = buf; 700865f46b2SCy Schubert size_t str_len = sizeof(buf); 701865f46b2SCy Schubert if(!ecs_opt) { 702865f46b2SCy Schubert verbose(VERB_ALGO, "%s (null)", s); 703865f46b2SCy Schubert return; 704865f46b2SCy Schubert } 705865f46b2SCy Schubert (void)sldns_wire2str_edns_subnet_print(&str, &str_len, 706865f46b2SCy Schubert ecs_opt->opt_data, ecs_opt->opt_len); 707865f46b2SCy Schubert verbose(VERB_ALGO, "%s %s", s, buf); 708865f46b2SCy Schubert } 709865f46b2SCy Schubert } 710865f46b2SCy Schubert 71165b390aaSDag-Erling Smørgrav int 71265b390aaSDag-Erling Smørgrav ecs_edns_back_parsed(struct module_qstate* qstate, int id, 71365b390aaSDag-Erling Smørgrav void* ATTR_UNUSED(cbargs)) 71465b390aaSDag-Erling Smørgrav { 71565b390aaSDag-Erling Smørgrav struct subnet_qstate *sq; 71665b390aaSDag-Erling Smørgrav struct edns_option* ecs_opt; 71765b390aaSDag-Erling Smørgrav 71865b390aaSDag-Erling Smørgrav if(!(sq=(struct subnet_qstate*)qstate->minfo[id])) 71965b390aaSDag-Erling Smørgrav return 1; 72065b390aaSDag-Erling Smørgrav if((ecs_opt = edns_opt_list_find( 72165b390aaSDag-Erling Smørgrav qstate->edns_opts_back_in, 72225039b37SCy Schubert qstate->env->cfg->client_subnet_opcode)) && 72325039b37SCy Schubert parse_subnet_option(ecs_opt, &sq->ecs_server_in) && 72425039b37SCy Schubert sq->subnet_sent && sq->ecs_server_in.subnet_validdata) { 725865f46b2SCy Schubert subnet_log_print("answer has edns subnet", ecs_opt); 72665b390aaSDag-Erling Smørgrav /* Only skip global cache store if we sent an ECS option 72765b390aaSDag-Erling Smørgrav * and received one back. Answers from non-whitelisted 7288a384985SDag-Erling Smørgrav * servers will end up in global cache. Answers for 72965b390aaSDag-Erling Smørgrav * queries with 0 source will not (unless nameserver 73065b390aaSDag-Erling Smørgrav * does not support ECS). */ 73165b390aaSDag-Erling Smørgrav qstate->no_cache_store = 1; 73225039b37SCy Schubert if(!sq->track_max_scope || (sq->track_max_scope && 73325039b37SCy Schubert sq->ecs_server_in.subnet_scope_mask > 73425039b37SCy Schubert sq->max_scope)) 73525039b37SCy Schubert sq->max_scope = sq->ecs_server_in.subnet_scope_mask; 73665b390aaSDag-Erling Smørgrav } 73765b390aaSDag-Erling Smørgrav 73865b390aaSDag-Erling Smørgrav return 1; 73965b390aaSDag-Erling Smørgrav } 74065b390aaSDag-Erling Smørgrav 74165b390aaSDag-Erling Smørgrav void 74265b390aaSDag-Erling Smørgrav subnetmod_operate(struct module_qstate *qstate, enum module_ev event, 74365b390aaSDag-Erling Smørgrav int id, struct outbound_entry* outbound) 74465b390aaSDag-Erling Smørgrav { 74565b390aaSDag-Erling Smørgrav struct subnet_env *sne = qstate->env->modinfo[id]; 74665b390aaSDag-Erling Smørgrav struct subnet_qstate *sq = (struct subnet_qstate*)qstate->minfo[id]; 74765b390aaSDag-Erling Smørgrav 7485469a995SCy Schubert verbose(VERB_QUERY, "subnetcache[module %d] operate: extstate:%s " 74965b390aaSDag-Erling Smørgrav "event:%s", id, strextstate(qstate->ext_state[id]), 75065b390aaSDag-Erling Smørgrav strmodulevent(event)); 7515469a995SCy Schubert log_query_info(VERB_QUERY, "subnetcache operate: query", &qstate->qinfo); 75265b390aaSDag-Erling Smørgrav 75365b390aaSDag-Erling Smørgrav if((event == module_event_new || event == module_event_pass) && 75465b390aaSDag-Erling Smørgrav sq == NULL) { 75565b390aaSDag-Erling Smørgrav struct edns_option* ecs_opt; 75665b390aaSDag-Erling Smørgrav if(!subnet_new_qstate(qstate, id)) { 75765b390aaSDag-Erling Smørgrav qstate->return_msg = NULL; 75865b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 75965b390aaSDag-Erling Smørgrav return; 76065b390aaSDag-Erling Smørgrav } 76165b390aaSDag-Erling Smørgrav 76265b390aaSDag-Erling Smørgrav sq = (struct subnet_qstate*)qstate->minfo[id]; 76365b390aaSDag-Erling Smørgrav 76465b390aaSDag-Erling Smørgrav if((ecs_opt = edns_opt_list_find( 76565b390aaSDag-Erling Smørgrav qstate->edns_opts_front_in, 76665b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode))) { 76765b390aaSDag-Erling Smørgrav if(!parse_subnet_option(ecs_opt, &sq->ecs_client_in)) { 76865b390aaSDag-Erling Smørgrav /* Wrongly formatted ECS option. RFC mandates to 76965b390aaSDag-Erling Smørgrav * return FORMERROR. */ 77065b390aaSDag-Erling Smørgrav qstate->return_rcode = LDNS_RCODE_FORMERR; 77165b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 77265b390aaSDag-Erling Smørgrav return; 77365b390aaSDag-Erling Smørgrav } 774865f46b2SCy Schubert subnet_log_print("query has edns subnet", ecs_opt); 77565b390aaSDag-Erling Smørgrav sq->subnet_downstream = 1; 77665b390aaSDag-Erling Smørgrav } 77765b390aaSDag-Erling Smørgrav else if(qstate->mesh_info->reply_list) { 77865b390aaSDag-Erling Smørgrav subnet_option_from_ss( 779865f46b2SCy Schubert &qstate->mesh_info->reply_list->query_reply.client_addr, 78065b390aaSDag-Erling Smørgrav &sq->ecs_client_in, qstate->env->cfg); 78165b390aaSDag-Erling Smørgrav } 78265b390aaSDag-Erling Smørgrav 78365b390aaSDag-Erling Smørgrav if(sq->ecs_client_in.subnet_validdata == 0) { 78465b390aaSDag-Erling Smørgrav /* No clients are interested in result or we could not 78565b390aaSDag-Erling Smørgrav * parse it, we don't do client subnet */ 78665b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_validdata = 0; 7875469a995SCy Schubert verbose(VERB_ALGO, "subnetcache: pass to next module"); 78865b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_wait_module; 78965b390aaSDag-Erling Smørgrav return; 79065b390aaSDag-Erling Smørgrav } 79165b390aaSDag-Erling Smørgrav 792e86b9096SDag-Erling Smørgrav /* Limit to minimum allowed source mask */ 793e86b9096SDag-Erling Smørgrav if(sq->ecs_client_in.subnet_source_mask != 0 && ( 794e86b9096SDag-Erling Smørgrav (sq->ecs_client_in.subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4 && 795e86b9096SDag-Erling Smørgrav sq->ecs_client_in.subnet_source_mask < qstate->env->cfg->min_client_subnet_ipv4) || 796e86b9096SDag-Erling Smørgrav (sq->ecs_client_in.subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP6 && 797e86b9096SDag-Erling Smørgrav sq->ecs_client_in.subnet_source_mask < qstate->env->cfg->min_client_subnet_ipv6))) { 798e86b9096SDag-Erling Smørgrav qstate->return_rcode = LDNS_RCODE_REFUSED; 799e86b9096SDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 800e86b9096SDag-Erling Smørgrav return; 801e86b9096SDag-Erling Smørgrav } 802e86b9096SDag-Erling Smørgrav 8030a92a9fcSCy Schubert if(!sq->started_no_cache_lookup && !qstate->blacklist) { 80465b390aaSDag-Erling Smørgrav lock_rw_wrlock(&sne->biglock); 80565b390aaSDag-Erling Smørgrav if(lookup_and_reply(qstate, id, sq)) { 8064c75e3aaSDag-Erling Smørgrav sne->num_msg_cache++; 80765b390aaSDag-Erling Smørgrav lock_rw_unlock(&sne->biglock); 8085469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: answered from cache"); 80965b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 81065b390aaSDag-Erling Smørgrav 811a39a5a69SCy Schubert subnet_ecs_opt_list_append(&sq->ecs_client_out, 8120a92a9fcSCy Schubert &qstate->edns_opts_front_out, qstate, 8130a92a9fcSCy Schubert qstate->region); 814865f46b2SCy Schubert if(verbosity >= VERB_ALGO) { 815865f46b2SCy Schubert subnet_log_print("reply has edns subnet", 816865f46b2SCy Schubert edns_opt_list_find( 817865f46b2SCy Schubert qstate->edns_opts_front_out, 818865f46b2SCy Schubert qstate->env->cfg-> 819865f46b2SCy Schubert client_subnet_opcode)); 820865f46b2SCy Schubert } 82165b390aaSDag-Erling Smørgrav return; 82265b390aaSDag-Erling Smørgrav } 82365b390aaSDag-Erling Smørgrav lock_rw_unlock(&sne->biglock); 8240a92a9fcSCy Schubert } 82565b390aaSDag-Erling Smørgrav 82665b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_addr_fam = 82765b390aaSDag-Erling Smørgrav sq->ecs_client_in.subnet_addr_fam; 82865b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_source_mask = 82965b390aaSDag-Erling Smørgrav sq->ecs_client_in.subnet_source_mask; 83065b390aaSDag-Erling Smørgrav /* Limit source prefix to configured maximum */ 83165b390aaSDag-Erling Smørgrav if(sq->ecs_server_out.subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4 83265b390aaSDag-Erling Smørgrav && sq->ecs_server_out.subnet_source_mask > 83365b390aaSDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv4) 83465b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_source_mask = 83565b390aaSDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv4; 83665b390aaSDag-Erling Smørgrav else if(sq->ecs_server_out.subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP6 83765b390aaSDag-Erling Smørgrav && sq->ecs_server_out.subnet_source_mask > 83865b390aaSDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv6) 83965b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_source_mask = 84065b390aaSDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv6; 84165b390aaSDag-Erling Smørgrav /* Safe to copy completely, even if the source is limited by the 842a39a5a69SCy Schubert * configuration. subnet_ecs_opt_list_append() will limit the address. 84365b390aaSDag-Erling Smørgrav * */ 84465b390aaSDag-Erling Smørgrav memcpy(&sq->ecs_server_out.subnet_addr, 84565b390aaSDag-Erling Smørgrav sq->ecs_client_in.subnet_addr, INET6_SIZE); 84665b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_scope_mask = 0; 84765b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_validdata = 1; 84865b390aaSDag-Erling Smørgrav if(sq->ecs_server_out.subnet_source_mask != 0 && 8498a384985SDag-Erling Smørgrav qstate->env->cfg->client_subnet_always_forward && 85065b390aaSDag-Erling Smørgrav sq->subnet_downstream) 85165b390aaSDag-Erling Smørgrav /* ECS specific data required, do not look at the global 85265b390aaSDag-Erling Smørgrav * cache in other modules. */ 85365b390aaSDag-Erling Smørgrav qstate->no_cache_lookup = 1; 85465b390aaSDag-Erling Smørgrav 85565b390aaSDag-Erling Smørgrav /* pass request to next module */ 85665b390aaSDag-Erling Smørgrav verbose(VERB_ALGO, 8575469a995SCy Schubert "subnetcache: not found in cache. pass to next module"); 85865b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_wait_module; 85965b390aaSDag-Erling Smørgrav return; 86065b390aaSDag-Erling Smørgrav } 86165b390aaSDag-Erling Smørgrav /* Query handed back by next module, we have a 'final' answer */ 86265b390aaSDag-Erling Smørgrav if(sq && event == module_event_moddone) { 86365b390aaSDag-Erling Smørgrav qstate->ext_state[id] = eval_response(qstate, id, sq); 8644c75e3aaSDag-Erling Smørgrav if(qstate->ext_state[id] == module_finished && 8654c75e3aaSDag-Erling Smørgrav qstate->return_msg) { 866a39a5a69SCy Schubert subnet_ecs_opt_list_append(&sq->ecs_client_out, 8670a92a9fcSCy Schubert &qstate->edns_opts_front_out, qstate, 8680a92a9fcSCy Schubert qstate->region); 869865f46b2SCy Schubert if(verbosity >= VERB_ALGO) { 870865f46b2SCy Schubert subnet_log_print("reply has edns subnet", 871865f46b2SCy Schubert edns_opt_list_find( 872865f46b2SCy Schubert qstate->edns_opts_front_out, 873865f46b2SCy Schubert qstate->env->cfg-> 874865f46b2SCy Schubert client_subnet_opcode)); 875865f46b2SCy Schubert } 87665b390aaSDag-Erling Smørgrav } 877e86b9096SDag-Erling Smørgrav qstate->no_cache_store = sq->started_no_cache_store; 8780a92a9fcSCy Schubert qstate->no_cache_lookup = sq->started_no_cache_lookup; 87965b390aaSDag-Erling Smørgrav return; 88065b390aaSDag-Erling Smørgrav } 88165b390aaSDag-Erling Smørgrav if(sq && outbound) { 88265b390aaSDag-Erling Smørgrav return; 88365b390aaSDag-Erling Smørgrav } 88465b390aaSDag-Erling Smørgrav /* We are being revisited */ 88565b390aaSDag-Erling Smørgrav if(event == module_event_pass || event == module_event_new) { 88665b390aaSDag-Erling Smørgrav /* Just pass it on, we already did the work */ 8875469a995SCy Schubert verbose(VERB_ALGO, "subnetcache: pass to next module"); 88865b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_wait_module; 88965b390aaSDag-Erling Smørgrav return; 89065b390aaSDag-Erling Smørgrav } 89165b390aaSDag-Erling Smørgrav if(!sq && (event == module_event_moddone)) { 89265b390aaSDag-Erling Smørgrav /* during priming, module done but we never started */ 89365b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 89465b390aaSDag-Erling Smørgrav return; 89565b390aaSDag-Erling Smørgrav } 8965469a995SCy Schubert log_err("subnetcache: bad event %s", strmodulevent(event)); 89765b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_error; 89865b390aaSDag-Erling Smørgrav return; 89965b390aaSDag-Erling Smørgrav } 90065b390aaSDag-Erling Smørgrav 90165b390aaSDag-Erling Smørgrav void 90265b390aaSDag-Erling Smørgrav subnetmod_clear(struct module_qstate *ATTR_UNUSED(qstate), 90365b390aaSDag-Erling Smørgrav int ATTR_UNUSED(id)) 90465b390aaSDag-Erling Smørgrav { 90565b390aaSDag-Erling Smørgrav /* qstate has no data outside region */ 90665b390aaSDag-Erling Smørgrav } 90765b390aaSDag-Erling Smørgrav 90865b390aaSDag-Erling Smørgrav void 90965b390aaSDag-Erling Smørgrav subnetmod_inform_super(struct module_qstate *ATTR_UNUSED(qstate), 91065b390aaSDag-Erling Smørgrav int ATTR_UNUSED(id), struct module_qstate *ATTR_UNUSED(super)) 91165b390aaSDag-Erling Smørgrav { 91265b390aaSDag-Erling Smørgrav /* Not used */ 91365b390aaSDag-Erling Smørgrav } 91465b390aaSDag-Erling Smørgrav 91565b390aaSDag-Erling Smørgrav size_t 91665b390aaSDag-Erling Smørgrav subnetmod_get_mem(struct module_env *env, int id) 91765b390aaSDag-Erling Smørgrav { 91865b390aaSDag-Erling Smørgrav struct subnet_env *sn_env = env->modinfo[id]; 91965b390aaSDag-Erling Smørgrav if (!sn_env) return 0; 92065b390aaSDag-Erling Smørgrav return sizeof(*sn_env) + 92165b390aaSDag-Erling Smørgrav slabhash_get_mem(sn_env->subnet_msg_cache) + 922c7f4d7adSDag-Erling Smørgrav ecs_whitelist_get_mem(sn_env->whitelist); 92365b390aaSDag-Erling Smørgrav } 92465b390aaSDag-Erling Smørgrav 92565b390aaSDag-Erling Smørgrav /** 92665b390aaSDag-Erling Smørgrav * The module function block 92765b390aaSDag-Erling Smørgrav */ 92865b390aaSDag-Erling Smørgrav static struct module_func_block subnetmod_block = { 9295469a995SCy Schubert "subnetcache", &subnetmod_init, &subnetmod_deinit, &subnetmod_operate, 93065b390aaSDag-Erling Smørgrav &subnetmod_inform_super, &subnetmod_clear, &subnetmod_get_mem 93165b390aaSDag-Erling Smørgrav }; 93265b390aaSDag-Erling Smørgrav 93365b390aaSDag-Erling Smørgrav struct module_func_block* 93465b390aaSDag-Erling Smørgrav subnetmod_get_funcblock(void) 93565b390aaSDag-Erling Smørgrav { 93665b390aaSDag-Erling Smørgrav return &subnetmod_block; 93765b390aaSDag-Erling Smørgrav } 93865b390aaSDag-Erling Smørgrav 93965b390aaSDag-Erling Smørgrav /** Wrappers for static functions to unit test */ 94065b390aaSDag-Erling Smørgrav size_t 94165b390aaSDag-Erling Smørgrav unittest_wrapper_subnetmod_sizefunc(void *elemptr) 94265b390aaSDag-Erling Smørgrav { 94365b390aaSDag-Erling Smørgrav return sizefunc(elemptr); 94465b390aaSDag-Erling Smørgrav } 94565b390aaSDag-Erling Smørgrav 94665b390aaSDag-Erling Smørgrav #endif /* CLIENT_SUBNET */ 947