1 /* 2 * util/module.c - module interface 3 * 4 * Copyright (c) 2007, NLnet Labs. All rights reserved. 5 * 6 * This software is open source. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * Neither the name of the NLNET LABS nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 25 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 27 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 28 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED 29 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 30 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 31 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 32 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 33 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 34 */ 35 /** 36 * \file 37 * Implementation of module.h. 38 */ 39 40 #include "config.h" 41 #include "util/module.h" 42 #include "sldns/wire2str.h" 43 #include "util/config_file.h" 44 #include "util/regional.h" 45 #include "util/data/dname.h" 46 #include "util/net_help.h" 47 48 const char* 49 strextstate(enum module_ext_state s) 50 { 51 switch(s) { 52 case module_state_initial: return "module_state_initial"; 53 case module_wait_reply: return "module_wait_reply"; 54 case module_wait_module: return "module_wait_module"; 55 case module_restart_next: return "module_restart_next"; 56 case module_wait_subquery: return "module_wait_subquery"; 57 case module_error: return "module_error"; 58 case module_finished: return "module_finished"; 59 } 60 return "bad_extstate_value"; 61 } 62 63 const char* 64 strmodulevent(enum module_ev e) 65 { 66 switch(e) { 67 case module_event_new: return "module_event_new"; 68 case module_event_pass: return "module_event_pass"; 69 case module_event_reply: return "module_event_reply"; 70 case module_event_noreply: return "module_event_noreply"; 71 case module_event_capsfail: return "module_event_capsfail"; 72 case module_event_moddone: return "module_event_moddone"; 73 case module_event_error: return "module_event_error"; 74 } 75 return "bad_event_value"; 76 } 77 78 void errinf(struct module_qstate* qstate, const char* str) 79 { 80 errinf_ede(qstate, str, LDNS_EDE_NONE); 81 } 82 83 void errinf_ede(struct module_qstate* qstate, 84 const char* str, sldns_ede_code reason_bogus) 85 { 86 struct errinf_strlist* p; 87 if(!str || (qstate->env->cfg->val_log_level < 2 && 88 !qstate->env->cfg->log_servfail)) { 89 return; 90 } 91 p = (struct errinf_strlist*)regional_alloc(qstate->region, sizeof(*p)); 92 if(!p) { 93 log_err("malloc failure in validator-error-info string"); 94 return; 95 } 96 p->next = NULL; 97 p->str = regional_strdup(qstate->region, str); 98 p->reason_bogus = reason_bogus; 99 if(!p->str) { 100 log_err("malloc failure in validator-error-info string"); 101 return; 102 } 103 /* add at end */ 104 if(qstate->errinf) { 105 struct errinf_strlist* q = qstate->errinf; 106 while(q->next) 107 q = q->next; 108 q->next = p; 109 } else qstate->errinf = p; 110 } 111 112 void errinf_origin(struct module_qstate* qstate, struct sock_list *origin) 113 { 114 struct sock_list* p; 115 if(qstate->env->cfg->val_log_level < 2 && !qstate->env->cfg->log_servfail) 116 return; 117 for(p=origin; p; p=p->next) { 118 char buf[256]; 119 if(p == origin) 120 snprintf(buf, sizeof(buf), "from "); 121 else snprintf(buf, sizeof(buf), "and "); 122 if(p->len == 0) 123 snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf), 124 "cache"); 125 else 126 addr_to_str(&p->addr, p->len, buf+strlen(buf), 127 sizeof(buf)-strlen(buf)); 128 errinf(qstate, buf); 129 } 130 } 131 132 char* errinf_to_str_bogus(struct module_qstate* qstate) 133 { 134 char buf[20480]; 135 char* p = buf; 136 size_t left = sizeof(buf); 137 struct errinf_strlist* s; 138 char dname[LDNS_MAX_DOMAINLEN+1]; 139 char t[16], c[16]; 140 sldns_wire2str_type_buf(qstate->qinfo.qtype, t, sizeof(t)); 141 sldns_wire2str_class_buf(qstate->qinfo.qclass, c, sizeof(c)); 142 dname_str(qstate->qinfo.qname, dname); 143 snprintf(p, left, "validation failure <%s %s %s>:", dname, t, c); 144 left -= strlen(p); p += strlen(p); 145 if(!qstate->errinf) 146 snprintf(p, left, " misc failure"); 147 else for(s=qstate->errinf; s; s=s->next) { 148 snprintf(p, left, " %s", s->str); 149 left -= strlen(p); p += strlen(p); 150 } 151 p = strdup(buf); 152 if(!p) 153 log_err("malloc failure in errinf_to_str"); 154 return p; 155 } 156 157 /* Try to find the latest (most specific) dnssec failure */ 158 sldns_ede_code errinf_to_reason_bogus(struct module_qstate* qstate) 159 { 160 struct errinf_strlist* s; 161 sldns_ede_code ede = LDNS_EDE_NONE; 162 for(s=qstate->errinf; s; s=s->next) { 163 if(s->reason_bogus == LDNS_EDE_NONE) continue; 164 if(ede != LDNS_EDE_NONE 165 && ede != LDNS_EDE_DNSSEC_BOGUS 166 && s->reason_bogus == LDNS_EDE_DNSSEC_BOGUS) continue; 167 ede = s->reason_bogus; 168 } 169 return ede; 170 } 171 172 char* errinf_to_str_servfail(struct module_qstate* qstate) 173 { 174 char buf[20480]; 175 char* p = buf; 176 size_t left = sizeof(buf); 177 struct errinf_strlist* s; 178 char dname[LDNS_MAX_DOMAINLEN+1]; 179 char t[16], c[16]; 180 sldns_wire2str_type_buf(qstate->qinfo.qtype, t, sizeof(t)); 181 sldns_wire2str_class_buf(qstate->qinfo.qclass, c, sizeof(c)); 182 dname_str(qstate->qinfo.qname, dname); 183 snprintf(p, left, "SERVFAIL <%s %s %s>:", dname, t, c); 184 left -= strlen(p); p += strlen(p); 185 if(!qstate->errinf) 186 snprintf(p, left, " misc failure"); 187 else for(s=qstate->errinf; s; s=s->next) { 188 snprintf(p, left, " %s", s->str); 189 left -= strlen(p); p += strlen(p); 190 } 191 p = strdup(buf); 192 if(!p) 193 log_err("malloc failure in errinf_to_str"); 194 return p; 195 } 196 197 char* errinf_to_str_misc(struct module_qstate* qstate) 198 { 199 char buf[20480]; 200 char* p = buf; 201 size_t left = sizeof(buf); 202 struct errinf_strlist* s; 203 if(!qstate->errinf) 204 snprintf(p, left, "misc failure"); 205 else for(s=qstate->errinf; s; s=s->next) { 206 snprintf(p, left, "%s%s", (s==qstate->errinf?"":" "), s->str); 207 left -= strlen(p); p += strlen(p); 208 } 209 p = strdup(buf); 210 if(!p) 211 log_err("malloc failure in errinf_to_str"); 212 return p; 213 } 214 215 void errinf_rrset(struct module_qstate* qstate, struct ub_packed_rrset_key *rr) 216 { 217 char buf[1024]; 218 char dname[LDNS_MAX_DOMAINLEN+1]; 219 char t[16], c[16]; 220 if((qstate->env->cfg->val_log_level < 2 && !qstate->env->cfg->log_servfail) || !rr) 221 return; 222 sldns_wire2str_type_buf(ntohs(rr->rk.type), t, sizeof(t)); 223 sldns_wire2str_class_buf(ntohs(rr->rk.rrset_class), c, sizeof(c)); 224 dname_str(rr->rk.dname, dname); 225 snprintf(buf, sizeof(buf), "for <%s %s %s>", dname, t, c); 226 errinf(qstate, buf); 227 } 228 229 void errinf_dname(struct module_qstate* qstate, const char* str, uint8_t* dname) 230 { 231 char b[1024]; 232 char buf[LDNS_MAX_DOMAINLEN+1]; 233 if((qstate->env->cfg->val_log_level < 2 && !qstate->env->cfg->log_servfail) || !str || !dname) 234 return; 235 dname_str(dname, buf); 236 snprintf(b, sizeof(b), "%s %s", str, buf); 237 errinf(qstate, b); 238 } 239 240 int 241 edns_known_options_init(struct module_env* env) 242 { 243 env->edns_known_options_num = 0; 244 env->edns_known_options = (struct edns_known_option*)calloc( 245 MAX_KNOWN_EDNS_OPTS, sizeof(struct edns_known_option)); 246 if(!env->edns_known_options) return 0; 247 return 1; 248 } 249 250 void 251 edns_known_options_delete(struct module_env* env) 252 { 253 free(env->edns_known_options); 254 env->edns_known_options = NULL; 255 env->edns_known_options_num = 0; 256 } 257 258 int 259 edns_register_option(uint16_t opt_code, int bypass_cache_stage, 260 int no_aggregation, struct module_env* env) 261 { 262 size_t i; 263 if(env->worker) { 264 log_err("invalid edns registration: " 265 "trying to register option after module init phase"); 266 return 0; 267 } 268 269 /** 270 * Checking if we are full first is faster but it does not provide 271 * the option to change the flags when the array is full. 272 * It only impacts unbound initialization, leave it for now. 273 */ 274 /* Check if the option is already registered. */ 275 for(i=0; i<env->edns_known_options_num; i++) 276 if(env->edns_known_options[i].opt_code == opt_code) 277 break; 278 /* If it is not yet registered check if we have space to add a new one. */ 279 if(i == env->edns_known_options_num) { 280 if(env->edns_known_options_num >= MAX_KNOWN_EDNS_OPTS) { 281 log_err("invalid edns registration: maximum options reached"); 282 return 0; 283 } 284 env->edns_known_options_num++; 285 } 286 env->edns_known_options[i].opt_code = opt_code; 287 env->edns_known_options[i].bypass_cache_stage = bypass_cache_stage; 288 env->edns_known_options[i].no_aggregation = no_aggregation; 289 return 1; 290 } 291 292 int 293 inplace_cb_register(void* cb, enum inplace_cb_list_type type, void* cbarg, 294 struct module_env* env, int id) 295 { 296 struct inplace_cb* callback; 297 struct inplace_cb** prevp; 298 if(env->worker) { 299 log_err("invalid edns callback registration: " 300 "trying to register callback after module init phase"); 301 return 0; 302 } 303 304 callback = (struct inplace_cb*)calloc(1, sizeof(*callback)); 305 if(callback == NULL) { 306 log_err("out of memory during edns callback registration."); 307 return 0; 308 } 309 callback->id = id; 310 callback->next = NULL; 311 callback->cb = cb; 312 callback->cb_arg = cbarg; 313 314 prevp = (struct inplace_cb**) &env->inplace_cb_lists[type]; 315 /* append at end of list */ 316 while(*prevp != NULL) 317 prevp = &((*prevp)->next); 318 *prevp = callback; 319 return 1; 320 } 321 322 void 323 inplace_cb_delete(struct module_env* env, enum inplace_cb_list_type type, 324 int id) 325 { 326 struct inplace_cb* temp = env->inplace_cb_lists[type]; 327 struct inplace_cb* prev = NULL; 328 329 while(temp) { 330 if(temp->id == id) { 331 if(!prev) { 332 env->inplace_cb_lists[type] = temp->next; 333 free(temp); 334 temp = env->inplace_cb_lists[type]; 335 } 336 else { 337 prev->next = temp->next; 338 free(temp); 339 temp = prev->next; 340 } 341 } 342 else { 343 prev = temp; 344 temp = temp->next; 345 } 346 } 347 } 348 349 struct edns_known_option* 350 edns_option_is_known(uint16_t opt_code, struct module_env* env) 351 { 352 size_t i; 353 for(i=0; i<env->edns_known_options_num; i++) 354 if(env->edns_known_options[i].opt_code == opt_code) 355 return env->edns_known_options + i; 356 return NULL; 357 } 358 359 int 360 edns_bypass_cache_stage(struct edns_option* list, struct module_env* env) 361 { 362 size_t i; 363 for(; list; list=list->next) 364 for(i=0; i<env->edns_known_options_num; i++) 365 if(env->edns_known_options[i].opt_code == list->opt_code && 366 env->edns_known_options[i].bypass_cache_stage == 1) 367 return 1; 368 return 0; 369 } 370 371 int 372 unique_mesh_state(struct edns_option* list, struct module_env* env) 373 { 374 size_t i; 375 if(env->unique_mesh) 376 return 1; 377 for(; list; list=list->next) 378 for(i=0; i<env->edns_known_options_num; i++) 379 if(env->edns_known_options[i].opt_code == list->opt_code && 380 env->edns_known_options[i].no_aggregation == 1) 381 return 1; 382 return 0; 383 } 384 385 void 386 log_edns_known_options(enum verbosity_value level, struct module_env* env) 387 { 388 size_t i; 389 char str[32], *s; 390 size_t slen; 391 if(env->edns_known_options_num > 0 && verbosity >= level) { 392 verbose(level, "EDNS known options:"); 393 verbose(level, " Code: Bypass_cache_stage: Aggregate_mesh:"); 394 for(i=0; i<env->edns_known_options_num; i++) { 395 s = str; 396 slen = sizeof(str); 397 (void)sldns_wire2str_edns_option_code_print(&s, &slen, 398 env->edns_known_options[i].opt_code); 399 verbose(level, " %-8.8s %-19s %-15s", str, 400 env->edns_known_options[i].bypass_cache_stage?"YES":"NO", 401 env->edns_known_options[i].no_aggregation?"NO":"YES"); 402 } 403 } 404 } 405 406 void 407 copy_state_to_super(struct module_qstate* qstate, int ATTR_UNUSED(id), 408 struct module_qstate* super) 409 { 410 /* Overwrite super's was_ratelimited only when it was not set */ 411 if(!super->was_ratelimited) { 412 super->was_ratelimited = qstate->was_ratelimited; 413 } 414 } 415