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 159*103ba509SCy Schubert sq->subnet_sent_no_subnet = 0; 16065b390aaSDag-Erling Smørgrav if(sq->ecs_server_out.subnet_validdata && ((sq->subnet_downstream && 16165b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_always_forward) || 162c7f4d7adSDag-Erling Smørgrav ecs_is_whitelisted(sn_env->whitelist, 163c7f4d7adSDag-Erling Smørgrav addr, addrlen, qinfo->qname, qinfo->qname_len, 164c7f4d7adSDag-Erling Smørgrav qinfo->qclass))) { 16565b390aaSDag-Erling Smørgrav /* Address on whitelist or client query contains ECS option, we 16665b390aaSDag-Erling Smørgrav * want to sent out ECS. Only add option if it is not already 16765b390aaSDag-Erling Smørgrav * set. */ 168a39a5a69SCy Schubert if(!edns_opt_list_find(qstate->edns_opts_back_out, 169a39a5a69SCy Schubert qstate->env->cfg->client_subnet_opcode)) { 170*103ba509SCy Schubert /* if the client is not wanting an EDNS subnet option, 171*103ba509SCy Schubert * omit it and store that we omitted it but actually 172*103ba509SCy Schubert * are doing EDNS subnet to the server. */ 173*103ba509SCy Schubert if(sq->ecs_server_out.subnet_source_mask == 0) { 174*103ba509SCy Schubert sq->subnet_sent_no_subnet = 1; 175*103ba509SCy Schubert sq->subnet_sent = 0; 176*103ba509SCy Schubert return 1; 177*103ba509SCy Schubert } 178a39a5a69SCy Schubert subnet_ecs_opt_list_append(&sq->ecs_server_out, 1790a92a9fcSCy Schubert &qstate->edns_opts_back_out, qstate, region); 180a39a5a69SCy Schubert } 18165b390aaSDag-Erling Smørgrav sq->subnet_sent = 1; 18265b390aaSDag-Erling Smørgrav } 183a39a5a69SCy Schubert else { 18465b390aaSDag-Erling Smørgrav /* Outgoing ECS option is set, but we don't want to sent it to 18565b390aaSDag-Erling Smørgrav * this address, remove option. */ 186a39a5a69SCy Schubert if(edns_opt_list_find(qstate->edns_opts_back_out, 187a39a5a69SCy Schubert qstate->env->cfg->client_subnet_opcode)) { 18865b390aaSDag-Erling Smørgrav edns_opt_list_remove(&qstate->edns_opts_back_out, 18965b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode); 190a39a5a69SCy Schubert } 19165b390aaSDag-Erling Smørgrav sq->subnet_sent = 0; 19265b390aaSDag-Erling Smørgrav } 19365b390aaSDag-Erling Smørgrav return 1; 19465b390aaSDag-Erling Smørgrav } 19565b390aaSDag-Erling Smørgrav 19665b390aaSDag-Erling Smørgrav 197e86b9096SDag-Erling Smørgrav void 198e86b9096SDag-Erling Smørgrav subnet_markdel(void* key) 199e86b9096SDag-Erling Smørgrav { 200e86b9096SDag-Erling Smørgrav struct msgreply_entry *e = (struct msgreply_entry*)key; 201e86b9096SDag-Erling Smørgrav e->key.qtype = 0; 202e86b9096SDag-Erling Smørgrav e->key.qclass = 0; 203e86b9096SDag-Erling Smørgrav } 204e86b9096SDag-Erling Smørgrav 20565b390aaSDag-Erling Smørgrav int 20665b390aaSDag-Erling Smørgrav subnetmod_init(struct module_env *env, int id) 20765b390aaSDag-Erling Smørgrav { 20865b390aaSDag-Erling Smørgrav struct subnet_env *sn_env = (struct subnet_env*)calloc(1, 20965b390aaSDag-Erling Smørgrav sizeof(struct subnet_env)); 21065b390aaSDag-Erling Smørgrav if(!sn_env) { 21165b390aaSDag-Erling Smørgrav log_err("malloc failure"); 21265b390aaSDag-Erling Smørgrav return 0; 21365b390aaSDag-Erling Smørgrav } 21465b390aaSDag-Erling Smørgrav alloc_init(&sn_env->alloc, NULL, 0); 21565b390aaSDag-Erling Smørgrav env->modinfo[id] = (void*)sn_env; 2161838dec3SCy Schubert 2171838dec3SCy Schubert /* Warn that serve-expired and prefetch do not work with the subnet 2181838dec3SCy Schubert * module cache. */ 2191838dec3SCy Schubert if(env->cfg->serve_expired) 2201838dec3SCy Schubert log_warn( 2211838dec3SCy Schubert "subnetcache: serve-expired is set but not working " 2221838dec3SCy Schubert "for data originating from the subnet module cache."); 2231838dec3SCy Schubert if(env->cfg->prefetch) 2241838dec3SCy Schubert log_warn( 2251838dec3SCy Schubert "subnetcache: prefetch is set but not working " 2261838dec3SCy Schubert "for data originating from the subnet module cache."); 22765b390aaSDag-Erling Smørgrav /* Copy msg_cache settings */ 22865b390aaSDag-Erling Smørgrav sn_env->subnet_msg_cache = slabhash_create(env->cfg->msg_cache_slabs, 22965b390aaSDag-Erling Smørgrav HASH_DEFAULT_STARTARRAY, env->cfg->msg_cache_size, 23065b390aaSDag-Erling Smørgrav msg_cache_sizefunc, query_info_compare, query_entry_delete, 23165b390aaSDag-Erling Smørgrav subnet_data_delete, NULL); 232e86b9096SDag-Erling Smørgrav slabhash_setmarkdel(sn_env->subnet_msg_cache, &subnet_markdel); 23365b390aaSDag-Erling Smørgrav if(!sn_env->subnet_msg_cache) { 2345469a995SCy Schubert log_err("subnetcache: could not create cache"); 23565b390aaSDag-Erling Smørgrav free(sn_env); 23665b390aaSDag-Erling Smørgrav env->modinfo[id] = NULL; 23765b390aaSDag-Erling Smørgrav return 0; 23865b390aaSDag-Erling Smørgrav } 23965b390aaSDag-Erling Smørgrav /* whitelist for edns subnet capable servers */ 240c7f4d7adSDag-Erling Smørgrav sn_env->whitelist = ecs_whitelist_create(); 241c7f4d7adSDag-Erling Smørgrav if(!sn_env->whitelist || 242c7f4d7adSDag-Erling Smørgrav !ecs_whitelist_apply_cfg(sn_env->whitelist, env->cfg)) { 2435469a995SCy Schubert log_err("subnetcache: could not create ECS whitelist"); 24465b390aaSDag-Erling Smørgrav slabhash_delete(sn_env->subnet_msg_cache); 24565b390aaSDag-Erling Smørgrav free(sn_env); 24665b390aaSDag-Erling Smørgrav env->modinfo[id] = NULL; 24765b390aaSDag-Erling Smørgrav return 0; 24865b390aaSDag-Erling Smørgrav } 24965b390aaSDag-Erling Smørgrav 2505469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: option registered (%d)", 25165b390aaSDag-Erling Smørgrav env->cfg->client_subnet_opcode); 25265b390aaSDag-Erling Smørgrav /* Create new mesh state for all queries. */ 25365b390aaSDag-Erling Smørgrav env->unique_mesh = 1; 25465b390aaSDag-Erling Smørgrav if(!edns_register_option(env->cfg->client_subnet_opcode, 25565b390aaSDag-Erling Smørgrav env->cfg->client_subnet_always_forward /* bypass cache */, 256a39a5a69SCy Schubert 1 /* no aggregation */, env)) { 2575469a995SCy Schubert log_err("subnetcache: could not register opcode"); 258c7f4d7adSDag-Erling Smørgrav ecs_whitelist_delete(sn_env->whitelist); 25965b390aaSDag-Erling Smørgrav slabhash_delete(sn_env->subnet_msg_cache); 26065b390aaSDag-Erling Smørgrav free(sn_env); 26165b390aaSDag-Erling Smørgrav env->modinfo[id] = NULL; 26265b390aaSDag-Erling Smørgrav return 0; 26365b390aaSDag-Erling Smørgrav } 26465b390aaSDag-Erling Smørgrav inplace_cb_register((void*)ecs_whitelist_check, inplace_cb_query, NULL, 26565b390aaSDag-Erling Smørgrav env, id); 26665b390aaSDag-Erling Smørgrav inplace_cb_register((void*)ecs_edns_back_parsed, 26765b390aaSDag-Erling Smørgrav inplace_cb_edns_back_parsed, NULL, env, id); 26865b390aaSDag-Erling Smørgrav inplace_cb_register((void*)ecs_query_response, 26965b390aaSDag-Erling Smørgrav inplace_cb_query_response, NULL, env, id); 27065b390aaSDag-Erling Smørgrav lock_rw_init(&sn_env->biglock); 27165b390aaSDag-Erling Smørgrav return 1; 27265b390aaSDag-Erling Smørgrav } 27365b390aaSDag-Erling Smørgrav 27465b390aaSDag-Erling Smørgrav void 27565b390aaSDag-Erling Smørgrav subnetmod_deinit(struct module_env *env, int id) 27665b390aaSDag-Erling Smørgrav { 27765b390aaSDag-Erling Smørgrav struct subnet_env *sn_env; 27865b390aaSDag-Erling Smørgrav if(!env || !env->modinfo[id]) 27965b390aaSDag-Erling Smørgrav return; 28065b390aaSDag-Erling Smørgrav sn_env = (struct subnet_env*)env->modinfo[id]; 28165b390aaSDag-Erling Smørgrav lock_rw_destroy(&sn_env->biglock); 28265b390aaSDag-Erling Smørgrav inplace_cb_delete(env, inplace_cb_edns_back_parsed, id); 28365b390aaSDag-Erling Smørgrav inplace_cb_delete(env, inplace_cb_query, id); 284c7f4d7adSDag-Erling Smørgrav inplace_cb_delete(env, inplace_cb_query_response, id); 285c7f4d7adSDag-Erling Smørgrav ecs_whitelist_delete(sn_env->whitelist); 28665b390aaSDag-Erling Smørgrav slabhash_delete(sn_env->subnet_msg_cache); 28765b390aaSDag-Erling Smørgrav alloc_clear(&sn_env->alloc); 28865b390aaSDag-Erling Smørgrav free(sn_env); 28965b390aaSDag-Erling Smørgrav env->modinfo[id] = NULL; 29065b390aaSDag-Erling Smørgrav } 29165b390aaSDag-Erling Smørgrav 29265b390aaSDag-Erling Smørgrav /** Tells client that upstream has no/improper support */ 29365b390aaSDag-Erling Smørgrav static void 29465b390aaSDag-Erling Smørgrav cp_edns_bad_response(struct ecs_data *target, struct ecs_data *source) 29565b390aaSDag-Erling Smørgrav { 29665b390aaSDag-Erling Smørgrav target->subnet_scope_mask = 0; 29765b390aaSDag-Erling Smørgrav target->subnet_source_mask = source->subnet_source_mask; 29865b390aaSDag-Erling Smørgrav target->subnet_addr_fam = source->subnet_addr_fam; 29965b390aaSDag-Erling Smørgrav memcpy(target->subnet_addr, source->subnet_addr, INET6_SIZE); 30065b390aaSDag-Erling Smørgrav target->subnet_validdata = 1; 30165b390aaSDag-Erling Smørgrav } 30265b390aaSDag-Erling Smørgrav 30365b390aaSDag-Erling Smørgrav static void 30465b390aaSDag-Erling Smørgrav delfunc(void *envptr, void *elemptr) { 30565b390aaSDag-Erling Smørgrav struct reply_info *elem = (struct reply_info *)elemptr; 30665b390aaSDag-Erling Smørgrav struct subnet_env *env = (struct subnet_env *)envptr; 30765b390aaSDag-Erling Smørgrav reply_info_parsedelete(elem, &env->alloc); 30865b390aaSDag-Erling Smørgrav } 30965b390aaSDag-Erling Smørgrav 31065b390aaSDag-Erling Smørgrav static size_t 31165b390aaSDag-Erling Smørgrav sizefunc(void *elemptr) { 31265b390aaSDag-Erling Smørgrav struct reply_info *elem = (struct reply_info *)elemptr; 31365b390aaSDag-Erling Smørgrav return sizeof (struct reply_info) - sizeof (struct rrset_ref) 31465b390aaSDag-Erling Smørgrav + elem->rrset_count * sizeof (struct rrset_ref) 31565b390aaSDag-Erling Smørgrav + elem->rrset_count * sizeof (struct ub_packed_rrset_key *); 31665b390aaSDag-Erling Smørgrav } 31765b390aaSDag-Erling Smørgrav 31865b390aaSDag-Erling Smørgrav /** 31965b390aaSDag-Erling Smørgrav * Select tree from cache entry based on edns data. 32065b390aaSDag-Erling Smørgrav * If for address family not present it will create a new one. 32165b390aaSDag-Erling Smørgrav * NULL on failure to create. */ 32265b390aaSDag-Erling Smørgrav static struct addrtree* 32365b390aaSDag-Erling Smørgrav get_tree(struct subnet_msg_cache_data *data, struct ecs_data *edns, 32465b390aaSDag-Erling Smørgrav struct subnet_env *env, struct config_file* cfg) 32565b390aaSDag-Erling Smørgrav { 32665b390aaSDag-Erling Smørgrav struct addrtree *tree; 32765b390aaSDag-Erling Smørgrav if (edns->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4) { 32865b390aaSDag-Erling Smørgrav if (!data->tree4) 32965b390aaSDag-Erling Smørgrav data->tree4 = addrtree_create( 33065b390aaSDag-Erling Smørgrav cfg->max_client_subnet_ipv4, &delfunc, 331e86b9096SDag-Erling Smørgrav &sizefunc, env, cfg->max_ecs_tree_size_ipv4); 33265b390aaSDag-Erling Smørgrav tree = data->tree4; 33365b390aaSDag-Erling Smørgrav } else { 33465b390aaSDag-Erling Smørgrav if (!data->tree6) 33565b390aaSDag-Erling Smørgrav data->tree6 = addrtree_create( 33665b390aaSDag-Erling Smørgrav cfg->max_client_subnet_ipv6, &delfunc, 337e86b9096SDag-Erling Smørgrav &sizefunc, env, cfg->max_ecs_tree_size_ipv6); 33865b390aaSDag-Erling Smørgrav tree = data->tree6; 33965b390aaSDag-Erling Smørgrav } 34065b390aaSDag-Erling Smørgrav return tree; 34165b390aaSDag-Erling Smørgrav } 34265b390aaSDag-Erling Smørgrav 34365b390aaSDag-Erling Smørgrav static void 34465b390aaSDag-Erling Smørgrav update_cache(struct module_qstate *qstate, int id) 34565b390aaSDag-Erling Smørgrav { 34665b390aaSDag-Erling Smørgrav struct msgreply_entry *mrep_entry; 34765b390aaSDag-Erling Smørgrav struct addrtree *tree; 34865b390aaSDag-Erling Smørgrav struct reply_info *rep; 34965b390aaSDag-Erling Smørgrav struct query_info qinf; 35065b390aaSDag-Erling Smørgrav struct subnet_env *sne = qstate->env->modinfo[id]; 35165b390aaSDag-Erling Smørgrav struct subnet_qstate *sq = (struct subnet_qstate*)qstate->minfo[id]; 35265b390aaSDag-Erling Smørgrav struct slabhash *subnet_msg_cache = sne->subnet_msg_cache; 35365b390aaSDag-Erling Smørgrav struct ecs_data *edns = &sq->ecs_client_in; 35465b390aaSDag-Erling Smørgrav size_t i; 355865f46b2SCy Schubert int only_match_scope_zero; 35665b390aaSDag-Erling Smørgrav 3570a92a9fcSCy Schubert /* We already calculated hash upon lookup (lookup_and_reply) if we were 3580a92a9fcSCy Schubert * allowed to look in the ECS cache */ 3590a92a9fcSCy Schubert hashvalue_type h = qstate->minfo[id] && 3600a92a9fcSCy Schubert ((struct subnet_qstate*)qstate->minfo[id])->qinfo_hash_calculated? 36165b390aaSDag-Erling Smørgrav ((struct subnet_qstate*)qstate->minfo[id])->qinfo_hash : 36265b390aaSDag-Erling Smørgrav query_info_hash(&qstate->qinfo, qstate->query_flags); 36365b390aaSDag-Erling Smørgrav /* Step 1, general qinfo lookup */ 36465b390aaSDag-Erling Smørgrav struct lruhash_entry* lru_entry = slabhash_lookup(subnet_msg_cache, h, 36565b390aaSDag-Erling Smørgrav &qstate->qinfo, 1); 366e86b9096SDag-Erling Smørgrav int need_to_insert = (lru_entry == NULL); 36765b390aaSDag-Erling Smørgrav if (!lru_entry) { 368e86b9096SDag-Erling Smørgrav void* data = calloc(1, 369e86b9096SDag-Erling Smørgrav sizeof(struct subnet_msg_cache_data)); 370e86b9096SDag-Erling Smørgrav if(!data) { 371e86b9096SDag-Erling Smørgrav log_err("malloc failed"); 372e86b9096SDag-Erling Smørgrav return; 373e86b9096SDag-Erling Smørgrav } 37465b390aaSDag-Erling Smørgrav qinf = qstate->qinfo; 37565b390aaSDag-Erling Smørgrav qinf.qname = memdup(qstate->qinfo.qname, 37665b390aaSDag-Erling Smørgrav qstate->qinfo.qname_len); 37765b390aaSDag-Erling Smørgrav if(!qinf.qname) { 378e86b9096SDag-Erling Smørgrav free(data); 37965b390aaSDag-Erling Smørgrav log_err("memdup failed"); 38065b390aaSDag-Erling Smørgrav return; 38165b390aaSDag-Erling Smørgrav } 382e86b9096SDag-Erling Smørgrav mrep_entry = query_info_entrysetup(&qinf, data, h); 38365b390aaSDag-Erling Smørgrav free(qinf.qname); /* if qname 'consumed', it is set to NULL */ 38465b390aaSDag-Erling Smørgrav if (!mrep_entry) { 385e86b9096SDag-Erling Smørgrav free(data); 38665b390aaSDag-Erling Smørgrav log_err("query_info_entrysetup failed"); 38765b390aaSDag-Erling Smørgrav return; 38865b390aaSDag-Erling Smørgrav } 38965b390aaSDag-Erling Smørgrav lru_entry = &mrep_entry->entry; 39057bddd21SDag-Erling Smørgrav lock_rw_wrlock(&lru_entry->lock); 39165b390aaSDag-Erling Smørgrav } 392e86b9096SDag-Erling Smørgrav /* lru_entry->lock is locked regardless of how we got here, 393e86b9096SDag-Erling Smørgrav * either from the slabhash_lookup, or above in the new allocated */ 39465b390aaSDag-Erling Smørgrav /* Step 2, find the correct tree */ 39565b390aaSDag-Erling Smørgrav if (!(tree = get_tree(lru_entry->data, edns, sne, qstate->env->cfg))) { 396e86b9096SDag-Erling Smørgrav lock_rw_unlock(&lru_entry->lock); 3975469a995SCy Schubert log_err("subnetcache: cache insertion failed"); 39865b390aaSDag-Erling Smørgrav return; 39965b390aaSDag-Erling Smørgrav } 40057bddd21SDag-Erling Smørgrav lock_quick_lock(&sne->alloc.lock); 40165b390aaSDag-Erling Smørgrav rep = reply_info_copy(qstate->return_msg->rep, &sne->alloc, NULL); 40257bddd21SDag-Erling Smørgrav lock_quick_unlock(&sne->alloc.lock); 40365b390aaSDag-Erling Smørgrav if (!rep) { 404e86b9096SDag-Erling Smørgrav lock_rw_unlock(&lru_entry->lock); 4055469a995SCy Schubert log_err("subnetcache: cache insertion failed"); 40665b390aaSDag-Erling Smørgrav return; 40765b390aaSDag-Erling Smørgrav } 40865b390aaSDag-Erling Smørgrav 40965b390aaSDag-Erling Smørgrav /* store RRsets */ 41065b390aaSDag-Erling Smørgrav for(i=0; i<rep->rrset_count; i++) { 41165b390aaSDag-Erling Smørgrav rep->ref[i].key = rep->rrsets[i]; 41265b390aaSDag-Erling Smørgrav rep->ref[i].id = rep->rrsets[i]->id; 41365b390aaSDag-Erling Smørgrav } 41465b390aaSDag-Erling Smørgrav reply_info_set_ttls(rep, *qstate->env->now); 41565b390aaSDag-Erling Smørgrav rep->flags |= (BIT_RA | BIT_QR); /* fix flags to be sensible for */ 41665b390aaSDag-Erling Smørgrav rep->flags &= ~(BIT_AA | BIT_CD);/* a reply based on the cache */ 417865f46b2SCy Schubert if(edns->subnet_source_mask == 0 && edns->subnet_scope_mask == 0) 418865f46b2SCy Schubert only_match_scope_zero = 1; 419865f46b2SCy Schubert else only_match_scope_zero = 0; 42065b390aaSDag-Erling Smørgrav addrtree_insert(tree, (addrkey_t*)edns->subnet_addr, 42125039b37SCy Schubert edns->subnet_source_mask, sq->max_scope, rep, 422865f46b2SCy Schubert rep->ttl, *qstate->env->now, only_match_scope_zero); 423e86b9096SDag-Erling Smørgrav 42465b390aaSDag-Erling Smørgrav lock_rw_unlock(&lru_entry->lock); 425e86b9096SDag-Erling Smørgrav if (need_to_insert) { 42665b390aaSDag-Erling Smørgrav slabhash_insert(subnet_msg_cache, h, lru_entry, lru_entry->data, 42765b390aaSDag-Erling Smørgrav NULL); 42865b390aaSDag-Erling Smørgrav } 42965b390aaSDag-Erling Smørgrav } 43065b390aaSDag-Erling Smørgrav 43165b390aaSDag-Erling Smørgrav /** Lookup in cache and reply true iff reply is sent. */ 43265b390aaSDag-Erling Smørgrav static int 4338f76bb7dSCy Schubert lookup_and_reply(struct module_qstate *qstate, int id, struct subnet_qstate *sq, int prefetch) 43465b390aaSDag-Erling Smørgrav { 43565b390aaSDag-Erling Smørgrav struct lruhash_entry *e; 43665b390aaSDag-Erling Smørgrav struct module_env *env = qstate->env; 43765b390aaSDag-Erling Smørgrav struct subnet_env *sne = (struct subnet_env*)env->modinfo[id]; 43865b390aaSDag-Erling Smørgrav hashvalue_type h = query_info_hash(&qstate->qinfo, qstate->query_flags); 43965b390aaSDag-Erling Smørgrav struct subnet_msg_cache_data *data; 44065b390aaSDag-Erling Smørgrav struct ecs_data *ecs = &sq->ecs_client_in; 44165b390aaSDag-Erling Smørgrav struct addrtree *tree; 44265b390aaSDag-Erling Smørgrav struct addrnode *node; 44365b390aaSDag-Erling Smørgrav uint8_t scope; 44465b390aaSDag-Erling Smørgrav 44565b390aaSDag-Erling Smørgrav memset(&sq->ecs_client_out, 0, sizeof(sq->ecs_client_out)); 44665b390aaSDag-Erling Smørgrav 4470a92a9fcSCy Schubert if (sq) { 4480a92a9fcSCy Schubert sq->qinfo_hash = h; /* Might be useful on cache miss */ 4490a92a9fcSCy Schubert sq->qinfo_hash_calculated = 1; 4500a92a9fcSCy Schubert } 45165b390aaSDag-Erling Smørgrav e = slabhash_lookup(sne->subnet_msg_cache, h, &qstate->qinfo, 1); 45265b390aaSDag-Erling Smørgrav if (!e) return 0; /* qinfo not in cache */ 45365b390aaSDag-Erling Smørgrav data = e->data; 45465b390aaSDag-Erling Smørgrav tree = (ecs->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4)? 45565b390aaSDag-Erling Smørgrav data->tree4 : data->tree6; 45665b390aaSDag-Erling Smørgrav if (!tree) { /* qinfo in cache but not for this family */ 45765b390aaSDag-Erling Smørgrav lock_rw_unlock(&e->lock); 45865b390aaSDag-Erling Smørgrav return 0; 45965b390aaSDag-Erling Smørgrav } 46065b390aaSDag-Erling Smørgrav node = addrtree_find(tree, (addrkey_t*)ecs->subnet_addr, 46165b390aaSDag-Erling Smørgrav ecs->subnet_source_mask, *env->now); 46265b390aaSDag-Erling Smørgrav if (!node) { /* plain old cache miss */ 46365b390aaSDag-Erling Smørgrav lock_rw_unlock(&e->lock); 46465b390aaSDag-Erling Smørgrav return 0; 46565b390aaSDag-Erling Smørgrav } 46665b390aaSDag-Erling Smørgrav 46765b390aaSDag-Erling Smørgrav qstate->return_msg = tomsg(NULL, &qstate->qinfo, 468091e9e46SCy Schubert (struct reply_info *)node->elem, qstate->region, *env->now, 0, 46965b390aaSDag-Erling Smørgrav env->scratch); 47065b390aaSDag-Erling Smørgrav scope = (uint8_t)node->scope; 47165b390aaSDag-Erling Smørgrav lock_rw_unlock(&e->lock); 47265b390aaSDag-Erling Smørgrav 47365b390aaSDag-Erling Smørgrav if (!qstate->return_msg) { /* Failed allocation or expired TTL */ 47465b390aaSDag-Erling Smørgrav return 0; 47565b390aaSDag-Erling Smørgrav } 47665b390aaSDag-Erling Smørgrav 47765b390aaSDag-Erling Smørgrav if (sq->subnet_downstream) { /* relay to interested client */ 47865b390aaSDag-Erling Smørgrav sq->ecs_client_out.subnet_scope_mask = scope; 47965b390aaSDag-Erling Smørgrav sq->ecs_client_out.subnet_addr_fam = ecs->subnet_addr_fam; 48065b390aaSDag-Erling Smørgrav sq->ecs_client_out.subnet_source_mask = ecs->subnet_source_mask; 48165b390aaSDag-Erling Smørgrav memcpy(&sq->ecs_client_out.subnet_addr, &ecs->subnet_addr, 48265b390aaSDag-Erling Smørgrav INET6_SIZE); 48365b390aaSDag-Erling Smørgrav sq->ecs_client_out.subnet_validdata = 1; 48465b390aaSDag-Erling Smørgrav } 4858f76bb7dSCy Schubert 4868f76bb7dSCy Schubert if (prefetch && *qstate->env->now >= ((struct reply_info *)node->elem)->prefetch_ttl) { 4878f76bb7dSCy Schubert qstate->need_refetch = 1; 4888f76bb7dSCy Schubert } 48965b390aaSDag-Erling Smørgrav return 1; 49065b390aaSDag-Erling Smørgrav } 49165b390aaSDag-Erling Smørgrav 49265b390aaSDag-Erling Smørgrav /** 49365b390aaSDag-Erling Smørgrav * Test first bits of addresses for equality. Caller is responsible 49465b390aaSDag-Erling Smørgrav * for making sure that both a and b are at least net/8 octets long. 49565b390aaSDag-Erling Smørgrav * @param a: first address. 49665b390aaSDag-Erling Smørgrav * @param a: seconds address. 49765b390aaSDag-Erling Smørgrav * @param net: Number of bits to test. 49865b390aaSDag-Erling Smørgrav * @return: 1 if equal, 0 otherwise. 49965b390aaSDag-Erling Smørgrav */ 50065b390aaSDag-Erling Smørgrav static int 50165b390aaSDag-Erling Smørgrav common_prefix(uint8_t *a, uint8_t *b, uint8_t net) 50265b390aaSDag-Erling Smørgrav { 50365b390aaSDag-Erling Smørgrav size_t n = (size_t)net / 8; 50465b390aaSDag-Erling Smørgrav return !memcmp(a, b, n) && ((net % 8) == 0 || a[n] == b[n]); 50565b390aaSDag-Erling Smørgrav } 50665b390aaSDag-Erling Smørgrav 50765b390aaSDag-Erling Smørgrav static enum module_ext_state 50865b390aaSDag-Erling Smørgrav eval_response(struct module_qstate *qstate, int id, struct subnet_qstate *sq) 50965b390aaSDag-Erling Smørgrav { 51065b390aaSDag-Erling Smørgrav struct subnet_env *sne = qstate->env->modinfo[id]; 51165b390aaSDag-Erling Smørgrav 51265b390aaSDag-Erling Smørgrav struct ecs_data *c_in = &sq->ecs_client_in; /* rcvd from client */ 51365b390aaSDag-Erling Smørgrav struct ecs_data *c_out = &sq->ecs_client_out;/* will send to client */ 51465b390aaSDag-Erling Smørgrav struct ecs_data *s_in = &sq->ecs_server_in; /* rcvd from auth */ 51565b390aaSDag-Erling Smørgrav struct ecs_data *s_out = &sq->ecs_server_out;/* sent to auth */ 51665b390aaSDag-Erling Smørgrav 51765b390aaSDag-Erling Smørgrav memset(c_out, 0, sizeof(*c_out)); 51865b390aaSDag-Erling Smørgrav 5194c75e3aaSDag-Erling Smørgrav if (!qstate->return_msg) { 5204c75e3aaSDag-Erling Smørgrav /* already an answer and its not a message, but retain 5214c75e3aaSDag-Erling Smørgrav * the actual rcode, instead of module_error, so send 5224c75e3aaSDag-Erling Smørgrav * module_finished */ 5234c75e3aaSDag-Erling Smørgrav return module_finished; 5244c75e3aaSDag-Erling Smørgrav } 52565b390aaSDag-Erling Smørgrav 52665b390aaSDag-Erling Smørgrav /* We have not asked for subnet data */ 527*103ba509SCy Schubert if (!sq->subnet_sent && !sq->subnet_sent_no_subnet) { 52865b390aaSDag-Erling Smørgrav if (s_in->subnet_validdata) 5295469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: received spurious data"); 53065b390aaSDag-Erling Smørgrav if (sq->subnet_downstream) /* Copy back to client */ 53165b390aaSDag-Erling Smørgrav cp_edns_bad_response(c_out, c_in); 53265b390aaSDag-Erling Smørgrav return module_finished; 53365b390aaSDag-Erling Smørgrav } 53465b390aaSDag-Erling Smørgrav 53565b390aaSDag-Erling Smørgrav /* subnet sent but nothing came back */ 536*103ba509SCy Schubert if (!s_in->subnet_validdata && !sq->subnet_sent_no_subnet) { 53765b390aaSDag-Erling Smørgrav /* The authority indicated no support for edns subnet. As a 53865b390aaSDag-Erling Smørgrav * consequence the answer ended up in the regular cache. It 53924e36522SCy Schubert * is still useful to put it in the edns subnet cache for 54065b390aaSDag-Erling Smørgrav * when a client explicitly asks for subnet specific answer. */ 5415469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: Authority indicates no support"); 542e86b9096SDag-Erling Smørgrav if(!sq->started_no_cache_store) { 54365b390aaSDag-Erling Smørgrav lock_rw_wrlock(&sne->biglock); 54465b390aaSDag-Erling Smørgrav update_cache(qstate, id); 54565b390aaSDag-Erling Smørgrav lock_rw_unlock(&sne->biglock); 546e86b9096SDag-Erling Smørgrav } 54765b390aaSDag-Erling Smørgrav if (sq->subnet_downstream) 54865b390aaSDag-Erling Smørgrav cp_edns_bad_response(c_out, c_in); 54965b390aaSDag-Erling Smørgrav return module_finished; 55065b390aaSDag-Erling Smørgrav } 55165b390aaSDag-Erling Smørgrav 552*103ba509SCy Schubert /* Purposefully there was no sent subnet, and there is consequently 553*103ba509SCy Schubert * no subnet in the answer. If there was, use the subnet in the answer 554*103ba509SCy Schubert * anyway. But if there is not, treat it as a prefix 0 answer. */ 555*103ba509SCy Schubert if(sq->subnet_sent_no_subnet && !s_in->subnet_validdata) { 556*103ba509SCy Schubert /* Fill in 0.0.0.0/0 scope 0, or ::0/0 scope 0, for caching. */ 557*103ba509SCy Schubert s_in->subnet_addr_fam = s_out->subnet_addr_fam; 558*103ba509SCy Schubert s_in->subnet_source_mask = 0; 559*103ba509SCy Schubert s_in->subnet_scope_mask = 0; 560*103ba509SCy Schubert memset(s_in->subnet_addr, 0, INET6_SIZE); 561*103ba509SCy Schubert s_in->subnet_validdata = 1; 562*103ba509SCy Schubert } 563*103ba509SCy Schubert 56465b390aaSDag-Erling Smørgrav /* Being here means we have asked for and got a subnet specific 56565b390aaSDag-Erling Smørgrav * answer. Also, the answer from the authority is not yet cached 56665b390aaSDag-Erling Smørgrav * anywhere. */ 56765b390aaSDag-Erling Smørgrav 56865b390aaSDag-Erling Smørgrav /* can we accept response? */ 56965b390aaSDag-Erling Smørgrav if(s_out->subnet_addr_fam != s_in->subnet_addr_fam || 57065b390aaSDag-Erling Smørgrav s_out->subnet_source_mask != s_in->subnet_source_mask || 57165b390aaSDag-Erling Smørgrav !common_prefix(s_out->subnet_addr, s_in->subnet_addr, 57265b390aaSDag-Erling Smørgrav s_out->subnet_source_mask)) 57365b390aaSDag-Erling Smørgrav { 57465b390aaSDag-Erling Smørgrav /* we can not accept, restart query without option */ 5755469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: forged data"); 57665b390aaSDag-Erling Smørgrav s_out->subnet_validdata = 0; 57765b390aaSDag-Erling Smørgrav (void)edns_opt_list_remove(&qstate->edns_opts_back_out, 57865b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode); 57965b390aaSDag-Erling Smørgrav sq->subnet_sent = 0; 580*103ba509SCy Schubert sq->subnet_sent_no_subnet = 0; 58165b390aaSDag-Erling Smørgrav return module_restart_next; 58265b390aaSDag-Erling Smørgrav } 58365b390aaSDag-Erling Smørgrav 58465b390aaSDag-Erling Smørgrav lock_rw_wrlock(&sne->biglock); 585e86b9096SDag-Erling Smørgrav if(!sq->started_no_cache_store) { 58665b390aaSDag-Erling Smørgrav update_cache(qstate, id); 587e86b9096SDag-Erling Smørgrav } 5884c75e3aaSDag-Erling Smørgrav sne->num_msg_nocache++; 58965b390aaSDag-Erling Smørgrav lock_rw_unlock(&sne->biglock); 59065b390aaSDag-Erling Smørgrav 59165b390aaSDag-Erling Smørgrav if (sq->subnet_downstream) { 59265b390aaSDag-Erling Smørgrav /* Client wants to see the answer, echo option back 59365b390aaSDag-Erling Smørgrav * and adjust the scope. */ 59465b390aaSDag-Erling Smørgrav c_out->subnet_addr_fam = c_in->subnet_addr_fam; 59565b390aaSDag-Erling Smørgrav c_out->subnet_source_mask = c_in->subnet_source_mask; 59665b390aaSDag-Erling Smørgrav memcpy(&c_out->subnet_addr, &c_in->subnet_addr, INET6_SIZE); 59725039b37SCy Schubert c_out->subnet_scope_mask = sq->max_scope; 598e86b9096SDag-Erling Smørgrav /* Limit scope returned to client to scope used for caching. */ 599e86b9096SDag-Erling Smørgrav if(c_out->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4) { 600e86b9096SDag-Erling Smørgrav if(c_out->subnet_scope_mask > 601e86b9096SDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv4) { 602e86b9096SDag-Erling Smørgrav c_out->subnet_scope_mask = 603e86b9096SDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv4; 604e86b9096SDag-Erling Smørgrav } 605e86b9096SDag-Erling Smørgrav } 606e86b9096SDag-Erling Smørgrav else if(c_out->subnet_scope_mask > 607e86b9096SDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv6) { 608e86b9096SDag-Erling Smørgrav c_out->subnet_scope_mask = 609e86b9096SDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv6; 610e86b9096SDag-Erling Smørgrav } 61165b390aaSDag-Erling Smørgrav c_out->subnet_validdata = 1; 61265b390aaSDag-Erling Smørgrav } 61365b390aaSDag-Erling Smørgrav return module_finished; 61465b390aaSDag-Erling Smørgrav } 61565b390aaSDag-Erling Smørgrav 61665b390aaSDag-Erling Smørgrav /** Parse EDNS opt data containing ECS */ 61765b390aaSDag-Erling Smørgrav static int 61865b390aaSDag-Erling Smørgrav parse_subnet_option(struct edns_option* ecs_option, struct ecs_data* ecs) 61965b390aaSDag-Erling Smørgrav { 62065b390aaSDag-Erling Smørgrav memset(ecs, 0, sizeof(*ecs)); 62165b390aaSDag-Erling Smørgrav if (ecs_option->opt_len < 4) 62265b390aaSDag-Erling Smørgrav return 0; 62365b390aaSDag-Erling Smørgrav 62465b390aaSDag-Erling Smørgrav ecs->subnet_addr_fam = sldns_read_uint16(ecs_option->opt_data); 62565b390aaSDag-Erling Smørgrav ecs->subnet_source_mask = ecs_option->opt_data[2]; 62665b390aaSDag-Erling Smørgrav ecs->subnet_scope_mask = ecs_option->opt_data[3]; 6278a384985SDag-Erling Smørgrav /* remaining bytes indicate address */ 62865b390aaSDag-Erling Smørgrav 62965b390aaSDag-Erling Smørgrav /* validate input*/ 63065b390aaSDag-Erling Smørgrav /* option length matches calculated length? */ 63165b390aaSDag-Erling Smørgrav if (ecs_option->opt_len != (size_t)((ecs->subnet_source_mask+7)/8 + 4)) 63265b390aaSDag-Erling Smørgrav return 0; 63365b390aaSDag-Erling Smørgrav if (ecs_option->opt_len - 4 > INET6_SIZE || ecs_option->opt_len == 0) 63465b390aaSDag-Erling Smørgrav return 0; 63565b390aaSDag-Erling Smørgrav if (ecs->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4) { 63665b390aaSDag-Erling Smørgrav if (ecs->subnet_source_mask > 32 || ecs->subnet_scope_mask > 32) 63765b390aaSDag-Erling Smørgrav return 0; 63865b390aaSDag-Erling Smørgrav } else if (ecs->subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP6) { 63965b390aaSDag-Erling Smørgrav if (ecs->subnet_source_mask > 128 || 64065b390aaSDag-Erling Smørgrav ecs->subnet_scope_mask > 128) 64165b390aaSDag-Erling Smørgrav return 0; 64265b390aaSDag-Erling Smørgrav } else 64365b390aaSDag-Erling Smørgrav return 0; 64465b390aaSDag-Erling Smørgrav 64565b390aaSDag-Erling Smørgrav /* valid ECS data, write to ecs_data */ 64665b390aaSDag-Erling Smørgrav if (copy_clear(ecs->subnet_addr, INET6_SIZE, ecs_option->opt_data + 4, 64765b390aaSDag-Erling Smørgrav ecs_option->opt_len - 4, ecs->subnet_source_mask)) 64865b390aaSDag-Erling Smørgrav return 0; 64965b390aaSDag-Erling Smørgrav ecs->subnet_validdata = 1; 65065b390aaSDag-Erling Smørgrav return 1; 65165b390aaSDag-Erling Smørgrav } 65265b390aaSDag-Erling Smørgrav 653a39a5a69SCy Schubert void 65465b390aaSDag-Erling Smørgrav subnet_option_from_ss(struct sockaddr_storage *ss, struct ecs_data* ecs, 65565b390aaSDag-Erling Smørgrav struct config_file* cfg) 65665b390aaSDag-Erling Smørgrav { 65765b390aaSDag-Erling Smørgrav void* sinaddr; 65865b390aaSDag-Erling Smørgrav 65965b390aaSDag-Erling Smørgrav /* Construct subnet option from original query */ 66065b390aaSDag-Erling Smørgrav if(((struct sockaddr_in*)ss)->sin_family == AF_INET) { 66165b390aaSDag-Erling Smørgrav ecs->subnet_source_mask = cfg->max_client_subnet_ipv4; 66265b390aaSDag-Erling Smørgrav ecs->subnet_addr_fam = EDNSSUBNET_ADDRFAM_IP4; 66365b390aaSDag-Erling Smørgrav sinaddr = &((struct sockaddr_in*)ss)->sin_addr; 66465b390aaSDag-Erling Smørgrav if (!copy_clear( ecs->subnet_addr, INET6_SIZE, 66565b390aaSDag-Erling Smørgrav (uint8_t *)sinaddr, INET_SIZE, 66665b390aaSDag-Erling Smørgrav ecs->subnet_source_mask)) { 66765b390aaSDag-Erling Smørgrav ecs->subnet_validdata = 1; 66865b390aaSDag-Erling Smørgrav } 66965b390aaSDag-Erling Smørgrav } 67065b390aaSDag-Erling Smørgrav #ifdef INET6 67165b390aaSDag-Erling Smørgrav else { 67265b390aaSDag-Erling Smørgrav ecs->subnet_source_mask = cfg->max_client_subnet_ipv6; 67365b390aaSDag-Erling Smørgrav ecs->subnet_addr_fam = EDNSSUBNET_ADDRFAM_IP6; 67465b390aaSDag-Erling Smørgrav sinaddr = &((struct sockaddr_in6*)ss)->sin6_addr; 67565b390aaSDag-Erling Smørgrav if (!copy_clear( ecs->subnet_addr, INET6_SIZE, 67665b390aaSDag-Erling Smørgrav (uint8_t *)sinaddr, INET6_SIZE, 67765b390aaSDag-Erling Smørgrav ecs->subnet_source_mask)) { 67865b390aaSDag-Erling Smørgrav ecs->subnet_validdata = 1; 67965b390aaSDag-Erling Smørgrav } 68065b390aaSDag-Erling Smørgrav } 68165b390aaSDag-Erling Smørgrav #else 68265b390aaSDag-Erling Smørgrav /* We don't know how to handle ip6, just pass */ 68365b390aaSDag-Erling Smørgrav #endif /* INET6 */ 68465b390aaSDag-Erling Smørgrav } 68565b390aaSDag-Erling Smørgrav 68665b390aaSDag-Erling Smørgrav int 68765b390aaSDag-Erling Smørgrav ecs_query_response(struct module_qstate* qstate, struct dns_msg* response, 68865b390aaSDag-Erling Smørgrav int id, void* ATTR_UNUSED(cbargs)) 68965b390aaSDag-Erling Smørgrav { 69065b390aaSDag-Erling Smørgrav struct subnet_qstate *sq; 69165b390aaSDag-Erling Smørgrav 69265b390aaSDag-Erling Smørgrav if(!response || !(sq=(struct subnet_qstate*)qstate->minfo[id])) 69365b390aaSDag-Erling Smørgrav return 1; 69465b390aaSDag-Erling Smørgrav 69565b390aaSDag-Erling Smørgrav if(sq->subnet_sent && 69665b390aaSDag-Erling Smørgrav FLAGS_GET_RCODE(response->rep->flags) == LDNS_RCODE_REFUSED) { 6978a384985SDag-Erling Smørgrav /* REFUSED response to ECS query, remove ECS option. */ 69865b390aaSDag-Erling Smørgrav edns_opt_list_remove(&qstate->edns_opts_back_out, 69965b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode); 70065b390aaSDag-Erling Smørgrav sq->subnet_sent = 0; 701*103ba509SCy Schubert sq->subnet_sent_no_subnet = 0; 70265b390aaSDag-Erling Smørgrav memset(&sq->ecs_server_out, 0, sizeof(sq->ecs_server_out)); 70325039b37SCy Schubert } else if (!sq->track_max_scope && 70425039b37SCy Schubert FLAGS_GET_RCODE(response->rep->flags) == LDNS_RCODE_NOERROR && 70525039b37SCy Schubert response->rep->an_numrrsets > 0 70625039b37SCy Schubert ) { 70725039b37SCy Schubert struct ub_packed_rrset_key* s = response->rep->rrsets[0]; 70825039b37SCy Schubert if(ntohs(s->rk.type) == LDNS_RR_TYPE_CNAME && 70925039b37SCy Schubert query_dname_compare(qstate->qinfo.qname, 71025039b37SCy Schubert s->rk.dname) == 0) { 71125039b37SCy Schubert /* CNAME response for QNAME. From now on keep track of 71225039b37SCy Schubert * longest received ECS prefix for all queries on this 71325039b37SCy Schubert * qstate. */ 71425039b37SCy Schubert sq->track_max_scope = 1; 71525039b37SCy Schubert } 71665b390aaSDag-Erling Smørgrav } 71765b390aaSDag-Erling Smørgrav return 1; 71865b390aaSDag-Erling Smørgrav } 71965b390aaSDag-Erling Smørgrav 720865f46b2SCy Schubert /** verbose print edns subnet option in pretty print */ 721865f46b2SCy Schubert static void 722865f46b2SCy Schubert subnet_log_print(const char* s, struct edns_option* ecs_opt) 723865f46b2SCy Schubert { 724865f46b2SCy Schubert if(verbosity >= VERB_ALGO) { 725865f46b2SCy Schubert char buf[256]; 726865f46b2SCy Schubert char* str = buf; 727865f46b2SCy Schubert size_t str_len = sizeof(buf); 728865f46b2SCy Schubert if(!ecs_opt) { 729865f46b2SCy Schubert verbose(VERB_ALGO, "%s (null)", s); 730865f46b2SCy Schubert return; 731865f46b2SCy Schubert } 732865f46b2SCy Schubert (void)sldns_wire2str_edns_subnet_print(&str, &str_len, 733865f46b2SCy Schubert ecs_opt->opt_data, ecs_opt->opt_len); 734865f46b2SCy Schubert verbose(VERB_ALGO, "%s %s", s, buf); 735865f46b2SCy Schubert } 736865f46b2SCy Schubert } 737865f46b2SCy Schubert 73865b390aaSDag-Erling Smørgrav int 73965b390aaSDag-Erling Smørgrav ecs_edns_back_parsed(struct module_qstate* qstate, int id, 74065b390aaSDag-Erling Smørgrav void* ATTR_UNUSED(cbargs)) 74165b390aaSDag-Erling Smørgrav { 74265b390aaSDag-Erling Smørgrav struct subnet_qstate *sq; 74365b390aaSDag-Erling Smørgrav struct edns_option* ecs_opt; 74465b390aaSDag-Erling Smørgrav 74565b390aaSDag-Erling Smørgrav if(!(sq=(struct subnet_qstate*)qstate->minfo[id])) 74665b390aaSDag-Erling Smørgrav return 1; 74765b390aaSDag-Erling Smørgrav if((ecs_opt = edns_opt_list_find( 74865b390aaSDag-Erling Smørgrav qstate->edns_opts_back_in, 74925039b37SCy Schubert qstate->env->cfg->client_subnet_opcode)) && 75025039b37SCy Schubert parse_subnet_option(ecs_opt, &sq->ecs_server_in) && 75125039b37SCy Schubert sq->subnet_sent && sq->ecs_server_in.subnet_validdata) { 752865f46b2SCy Schubert subnet_log_print("answer has edns subnet", ecs_opt); 75365b390aaSDag-Erling Smørgrav /* Only skip global cache store if we sent an ECS option 75465b390aaSDag-Erling Smørgrav * and received one back. Answers from non-whitelisted 7558a384985SDag-Erling Smørgrav * servers will end up in global cache. Answers for 75665b390aaSDag-Erling Smørgrav * queries with 0 source will not (unless nameserver 75765b390aaSDag-Erling Smørgrav * does not support ECS). */ 75865b390aaSDag-Erling Smørgrav qstate->no_cache_store = 1; 75925039b37SCy Schubert if(!sq->track_max_scope || (sq->track_max_scope && 76025039b37SCy Schubert sq->ecs_server_in.subnet_scope_mask > 76125039b37SCy Schubert sq->max_scope)) 76225039b37SCy Schubert sq->max_scope = sq->ecs_server_in.subnet_scope_mask; 763*103ba509SCy Schubert } else if(sq->subnet_sent_no_subnet) { 764*103ba509SCy Schubert /* The answer can be stored as scope 0, not in global cache. */ 765*103ba509SCy Schubert qstate->no_cache_store = 1; 76665b390aaSDag-Erling Smørgrav } 76765b390aaSDag-Erling Smørgrav 76865b390aaSDag-Erling Smørgrav return 1; 76965b390aaSDag-Erling Smørgrav } 77065b390aaSDag-Erling Smørgrav 77165b390aaSDag-Erling Smørgrav void 77265b390aaSDag-Erling Smørgrav subnetmod_operate(struct module_qstate *qstate, enum module_ev event, 77365b390aaSDag-Erling Smørgrav int id, struct outbound_entry* outbound) 77465b390aaSDag-Erling Smørgrav { 77565b390aaSDag-Erling Smørgrav struct subnet_env *sne = qstate->env->modinfo[id]; 77665b390aaSDag-Erling Smørgrav struct subnet_qstate *sq = (struct subnet_qstate*)qstate->minfo[id]; 77765b390aaSDag-Erling Smørgrav 7785469a995SCy Schubert verbose(VERB_QUERY, "subnetcache[module %d] operate: extstate:%s " 77965b390aaSDag-Erling Smørgrav "event:%s", id, strextstate(qstate->ext_state[id]), 78065b390aaSDag-Erling Smørgrav strmodulevent(event)); 7815469a995SCy Schubert log_query_info(VERB_QUERY, "subnetcache operate: query", &qstate->qinfo); 78265b390aaSDag-Erling Smørgrav 78365b390aaSDag-Erling Smørgrav if((event == module_event_new || event == module_event_pass) && 78465b390aaSDag-Erling Smørgrav sq == NULL) { 78565b390aaSDag-Erling Smørgrav struct edns_option* ecs_opt; 78665b390aaSDag-Erling Smørgrav if(!subnet_new_qstate(qstate, id)) { 78765b390aaSDag-Erling Smørgrav qstate->return_msg = NULL; 78865b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 78965b390aaSDag-Erling Smørgrav return; 79065b390aaSDag-Erling Smørgrav } 79165b390aaSDag-Erling Smørgrav 79265b390aaSDag-Erling Smørgrav sq = (struct subnet_qstate*)qstate->minfo[id]; 79365b390aaSDag-Erling Smørgrav 79465b390aaSDag-Erling Smørgrav if((ecs_opt = edns_opt_list_find( 79565b390aaSDag-Erling Smørgrav qstate->edns_opts_front_in, 79665b390aaSDag-Erling Smørgrav qstate->env->cfg->client_subnet_opcode))) { 79765b390aaSDag-Erling Smørgrav if(!parse_subnet_option(ecs_opt, &sq->ecs_client_in)) { 79865b390aaSDag-Erling Smørgrav /* Wrongly formatted ECS option. RFC mandates to 79965b390aaSDag-Erling Smørgrav * return FORMERROR. */ 80065b390aaSDag-Erling Smørgrav qstate->return_rcode = LDNS_RCODE_FORMERR; 80165b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 80265b390aaSDag-Erling Smørgrav return; 80365b390aaSDag-Erling Smørgrav } 804865f46b2SCy Schubert subnet_log_print("query has edns subnet", ecs_opt); 80565b390aaSDag-Erling Smørgrav sq->subnet_downstream = 1; 80665b390aaSDag-Erling Smørgrav } 80765b390aaSDag-Erling Smørgrav else if(qstate->mesh_info->reply_list) { 80865b390aaSDag-Erling Smørgrav subnet_option_from_ss( 809865f46b2SCy Schubert &qstate->mesh_info->reply_list->query_reply.client_addr, 81065b390aaSDag-Erling Smørgrav &sq->ecs_client_in, qstate->env->cfg); 81165b390aaSDag-Erling Smørgrav } 8128f76bb7dSCy Schubert else if(qstate->client_addr.ss_family != AF_UNSPEC) { 8138f76bb7dSCy Schubert subnet_option_from_ss( 8148f76bb7dSCy Schubert &qstate->client_addr, 8158f76bb7dSCy Schubert &sq->ecs_client_in, qstate->env->cfg); 8168f76bb7dSCy Schubert } 81765b390aaSDag-Erling Smørgrav 81865b390aaSDag-Erling Smørgrav if(sq->ecs_client_in.subnet_validdata == 0) { 81965b390aaSDag-Erling Smørgrav /* No clients are interested in result or we could not 82065b390aaSDag-Erling Smørgrav * parse it, we don't do client subnet */ 82165b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_validdata = 0; 8225469a995SCy Schubert verbose(VERB_ALGO, "subnetcache: pass to next module"); 82365b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_wait_module; 82465b390aaSDag-Erling Smørgrav return; 82565b390aaSDag-Erling Smørgrav } 82665b390aaSDag-Erling Smørgrav 827e86b9096SDag-Erling Smørgrav /* Limit to minimum allowed source mask */ 828e86b9096SDag-Erling Smørgrav if(sq->ecs_client_in.subnet_source_mask != 0 && ( 829e86b9096SDag-Erling Smørgrav (sq->ecs_client_in.subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4 && 830e86b9096SDag-Erling Smørgrav sq->ecs_client_in.subnet_source_mask < qstate->env->cfg->min_client_subnet_ipv4) || 831e86b9096SDag-Erling Smørgrav (sq->ecs_client_in.subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP6 && 832e86b9096SDag-Erling Smørgrav sq->ecs_client_in.subnet_source_mask < qstate->env->cfg->min_client_subnet_ipv6))) { 833e86b9096SDag-Erling Smørgrav qstate->return_rcode = LDNS_RCODE_REFUSED; 834e86b9096SDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 835e86b9096SDag-Erling Smørgrav return; 836e86b9096SDag-Erling Smørgrav } 837e86b9096SDag-Erling Smørgrav 8380a92a9fcSCy Schubert if(!sq->started_no_cache_lookup && !qstate->blacklist) { 83965b390aaSDag-Erling Smørgrav lock_rw_wrlock(&sne->biglock); 8408f76bb7dSCy Schubert if(qstate->mesh_info->reply_list && 8418f76bb7dSCy Schubert lookup_and_reply(qstate, id, sq, 8428f76bb7dSCy Schubert qstate->env->cfg->prefetch)) { 8434c75e3aaSDag-Erling Smørgrav sne->num_msg_cache++; 84465b390aaSDag-Erling Smørgrav lock_rw_unlock(&sne->biglock); 8455469a995SCy Schubert verbose(VERB_QUERY, "subnetcache: answered from cache"); 84665b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 84765b390aaSDag-Erling Smørgrav 848a39a5a69SCy Schubert subnet_ecs_opt_list_append(&sq->ecs_client_out, 8490a92a9fcSCy Schubert &qstate->edns_opts_front_out, qstate, 8500a92a9fcSCy Schubert qstate->region); 851865f46b2SCy Schubert if(verbosity >= VERB_ALGO) { 852865f46b2SCy Schubert subnet_log_print("reply has edns subnet", 853865f46b2SCy Schubert edns_opt_list_find( 854865f46b2SCy Schubert qstate->edns_opts_front_out, 855865f46b2SCy Schubert qstate->env->cfg-> 856865f46b2SCy Schubert client_subnet_opcode)); 857865f46b2SCy Schubert } 85865b390aaSDag-Erling Smørgrav return; 85965b390aaSDag-Erling Smørgrav } 86065b390aaSDag-Erling Smørgrav lock_rw_unlock(&sne->biglock); 8610a92a9fcSCy Schubert } 86265b390aaSDag-Erling Smørgrav 86365b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_addr_fam = 86465b390aaSDag-Erling Smørgrav sq->ecs_client_in.subnet_addr_fam; 86565b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_source_mask = 86665b390aaSDag-Erling Smørgrav sq->ecs_client_in.subnet_source_mask; 86765b390aaSDag-Erling Smørgrav /* Limit source prefix to configured maximum */ 86865b390aaSDag-Erling Smørgrav if(sq->ecs_server_out.subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP4 86965b390aaSDag-Erling Smørgrav && sq->ecs_server_out.subnet_source_mask > 87065b390aaSDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv4) 87165b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_source_mask = 87265b390aaSDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv4; 87365b390aaSDag-Erling Smørgrav else if(sq->ecs_server_out.subnet_addr_fam == EDNSSUBNET_ADDRFAM_IP6 87465b390aaSDag-Erling Smørgrav && sq->ecs_server_out.subnet_source_mask > 87565b390aaSDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv6) 87665b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_source_mask = 87765b390aaSDag-Erling Smørgrav qstate->env->cfg->max_client_subnet_ipv6; 87865b390aaSDag-Erling Smørgrav /* Safe to copy completely, even if the source is limited by the 879a39a5a69SCy Schubert * configuration. subnet_ecs_opt_list_append() will limit the address. 88065b390aaSDag-Erling Smørgrav * */ 88165b390aaSDag-Erling Smørgrav memcpy(&sq->ecs_server_out.subnet_addr, 88265b390aaSDag-Erling Smørgrav sq->ecs_client_in.subnet_addr, INET6_SIZE); 88365b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_scope_mask = 0; 88465b390aaSDag-Erling Smørgrav sq->ecs_server_out.subnet_validdata = 1; 88565b390aaSDag-Erling Smørgrav if(sq->ecs_server_out.subnet_source_mask != 0 && 8868a384985SDag-Erling Smørgrav qstate->env->cfg->client_subnet_always_forward && 88765b390aaSDag-Erling Smørgrav sq->subnet_downstream) 88865b390aaSDag-Erling Smørgrav /* ECS specific data required, do not look at the global 88965b390aaSDag-Erling Smørgrav * cache in other modules. */ 89065b390aaSDag-Erling Smørgrav qstate->no_cache_lookup = 1; 89165b390aaSDag-Erling Smørgrav 89265b390aaSDag-Erling Smørgrav /* pass request to next module */ 89365b390aaSDag-Erling Smørgrav verbose(VERB_ALGO, 8945469a995SCy Schubert "subnetcache: not found in cache. pass to next module"); 89565b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_wait_module; 89665b390aaSDag-Erling Smørgrav return; 89765b390aaSDag-Erling Smørgrav } 89865b390aaSDag-Erling Smørgrav /* Query handed back by next module, we have a 'final' answer */ 89965b390aaSDag-Erling Smørgrav if(sq && event == module_event_moddone) { 90065b390aaSDag-Erling Smørgrav qstate->ext_state[id] = eval_response(qstate, id, sq); 9014c75e3aaSDag-Erling Smørgrav if(qstate->ext_state[id] == module_finished && 9024c75e3aaSDag-Erling Smørgrav qstate->return_msg) { 903a39a5a69SCy Schubert subnet_ecs_opt_list_append(&sq->ecs_client_out, 9040a92a9fcSCy Schubert &qstate->edns_opts_front_out, qstate, 9050a92a9fcSCy Schubert qstate->region); 906865f46b2SCy Schubert if(verbosity >= VERB_ALGO) { 907865f46b2SCy Schubert subnet_log_print("reply has edns subnet", 908865f46b2SCy Schubert edns_opt_list_find( 909865f46b2SCy Schubert qstate->edns_opts_front_out, 910865f46b2SCy Schubert qstate->env->cfg-> 911865f46b2SCy Schubert client_subnet_opcode)); 912865f46b2SCy Schubert } 91365b390aaSDag-Erling Smørgrav } 914e86b9096SDag-Erling Smørgrav qstate->no_cache_store = sq->started_no_cache_store; 9150a92a9fcSCy Schubert qstate->no_cache_lookup = sq->started_no_cache_lookup; 91665b390aaSDag-Erling Smørgrav return; 91765b390aaSDag-Erling Smørgrav } 91865b390aaSDag-Erling Smørgrav if(sq && outbound) { 91965b390aaSDag-Erling Smørgrav return; 92065b390aaSDag-Erling Smørgrav } 92165b390aaSDag-Erling Smørgrav /* We are being revisited */ 92265b390aaSDag-Erling Smørgrav if(event == module_event_pass || event == module_event_new) { 92365b390aaSDag-Erling Smørgrav /* Just pass it on, we already did the work */ 9245469a995SCy Schubert verbose(VERB_ALGO, "subnetcache: pass to next module"); 92565b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_wait_module; 92665b390aaSDag-Erling Smørgrav return; 92765b390aaSDag-Erling Smørgrav } 92865b390aaSDag-Erling Smørgrav if(!sq && (event == module_event_moddone)) { 92965b390aaSDag-Erling Smørgrav /* during priming, module done but we never started */ 93065b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_finished; 93165b390aaSDag-Erling Smørgrav return; 93265b390aaSDag-Erling Smørgrav } 9335469a995SCy Schubert log_err("subnetcache: bad event %s", strmodulevent(event)); 93465b390aaSDag-Erling Smørgrav qstate->ext_state[id] = module_error; 93565b390aaSDag-Erling Smørgrav return; 93665b390aaSDag-Erling Smørgrav } 93765b390aaSDag-Erling Smørgrav 93865b390aaSDag-Erling Smørgrav void 93965b390aaSDag-Erling Smørgrav subnetmod_clear(struct module_qstate *ATTR_UNUSED(qstate), 94065b390aaSDag-Erling Smørgrav int ATTR_UNUSED(id)) 94165b390aaSDag-Erling Smørgrav { 94265b390aaSDag-Erling Smørgrav /* qstate has no data outside region */ 94365b390aaSDag-Erling Smørgrav } 94465b390aaSDag-Erling Smørgrav 94565b390aaSDag-Erling Smørgrav void 94665b390aaSDag-Erling Smørgrav subnetmod_inform_super(struct module_qstate *ATTR_UNUSED(qstate), 94765b390aaSDag-Erling Smørgrav int ATTR_UNUSED(id), struct module_qstate *ATTR_UNUSED(super)) 94865b390aaSDag-Erling Smørgrav { 94965b390aaSDag-Erling Smørgrav /* Not used */ 95065b390aaSDag-Erling Smørgrav } 95165b390aaSDag-Erling Smørgrav 95265b390aaSDag-Erling Smørgrav size_t 95365b390aaSDag-Erling Smørgrav subnetmod_get_mem(struct module_env *env, int id) 95465b390aaSDag-Erling Smørgrav { 95565b390aaSDag-Erling Smørgrav struct subnet_env *sn_env = env->modinfo[id]; 95665b390aaSDag-Erling Smørgrav if (!sn_env) return 0; 95765b390aaSDag-Erling Smørgrav return sizeof(*sn_env) + 95865b390aaSDag-Erling Smørgrav slabhash_get_mem(sn_env->subnet_msg_cache) + 959c7f4d7adSDag-Erling Smørgrav ecs_whitelist_get_mem(sn_env->whitelist); 96065b390aaSDag-Erling Smørgrav } 96165b390aaSDag-Erling Smørgrav 96265b390aaSDag-Erling Smørgrav /** 96365b390aaSDag-Erling Smørgrav * The module function block 96465b390aaSDag-Erling Smørgrav */ 96565b390aaSDag-Erling Smørgrav static struct module_func_block subnetmod_block = { 9665469a995SCy Schubert "subnetcache", &subnetmod_init, &subnetmod_deinit, &subnetmod_operate, 96765b390aaSDag-Erling Smørgrav &subnetmod_inform_super, &subnetmod_clear, &subnetmod_get_mem 96865b390aaSDag-Erling Smørgrav }; 96965b390aaSDag-Erling Smørgrav 97065b390aaSDag-Erling Smørgrav struct module_func_block* 97165b390aaSDag-Erling Smørgrav subnetmod_get_funcblock(void) 97265b390aaSDag-Erling Smørgrav { 97365b390aaSDag-Erling Smørgrav return &subnetmod_block; 97465b390aaSDag-Erling Smørgrav } 97565b390aaSDag-Erling Smørgrav 97665b390aaSDag-Erling Smørgrav /** Wrappers for static functions to unit test */ 97765b390aaSDag-Erling Smørgrav size_t 97865b390aaSDag-Erling Smørgrav unittest_wrapper_subnetmod_sizefunc(void *elemptr) 97965b390aaSDag-Erling Smørgrav { 98065b390aaSDag-Erling Smørgrav return sizefunc(elemptr); 98165b390aaSDag-Erling Smørgrav } 98265b390aaSDag-Erling Smørgrav 98365b390aaSDag-Erling Smørgrav #endif /* CLIENT_SUBNET */ 984