contrib/unbound/respip/respip.c

   1 /*
   2  * respip/respip.c - filtering response IP module
   3  */
   4
   5 /**
   6  * \file
   7  *
   8  * This file contains a module that inspects a result of recursive resolution
   9  * to see if any IP address record should trigger a special action.
  10  * If applicable these actions can modify the original response.
  11  */
  12 #include "config.h"
  13
  14 #include "services/localzone.h"
  15 #include "services/authzone.h"
  16 #include "services/cache/dns.h"
  17 #include "sldns/str2wire.h"
  18 #include "util/config_file.h"
  19 #include "util/fptr_wlist.h"
  20 #include "util/module.h"
  21 #include "util/net_help.h"
  22 #include "util/regional.h"
  23 #include "util/data/msgreply.h"
  24 #include "util/storage/dnstree.h"
  25 #include "respip/respip.h"
  26 #include "services/view.h"
  27 #include "sldns/rrdef.h"
  28
  29
  30 /** Subset of resp_addr.node, used for inform-variant logging */
  31 struct respip_addr_info {
  32         struct sockaddr_storage addr;
  33         socklen_t addrlen;
  34         int net;
  35 };
  36
  37 /** Query state regarding the response-ip module. */
  38 enum respip_state {
  39         /**
  40          * The general state.  Unless CNAME chasing takes place, all processing
  41          * is completed in this state without any other asynchronous event.
  42          */
  43         RESPIP_INIT = 0,
  44
  45         /**
  46          * A subquery for CNAME chasing is completed.
  47          */
  48         RESPIP_SUBQUERY_FINISHED
  49 };
  50
  51 /** Per query state for the response-ip module. */
  52 struct respip_qstate {
  53         enum respip_state state;
  54 };
  55
  56 struct respip_set*
  57 respip_set_create(void)
  58 {
  59         struct respip_set* set = calloc(1, sizeof(*set));
  60         if(!set)
  61                 return NULL;
  62         set->region = regional_create();
  63         if(!set->region) {
  64                 free(set);
  65                 return NULL;
  66         }
  67         addr_tree_init(&set->ip_tree);
  68         lock_rw_init(&set->lock);
  69         return set;
  70 }
  71
  72 /** helper traverse to delete resp_addr nodes */
  73 static void
  74 resp_addr_del(rbnode_type* n, void* ATTR_UNUSED(arg))
  75 {
  76         struct resp_addr* r = (struct resp_addr*)n->key;
  77         lock_rw_destroy(&r->lock);
  78 #ifdef THREADS_DISABLED
  79         (void)r;
  80 #endif
  81 }
  82
  83 void
  84 respip_set_delete(struct respip_set* set)
  85 {
  86         if(!set)
  87                 return;
  88         lock_rw_destroy(&set->lock);
  89         traverse_postorder(&set->ip_tree, resp_addr_del, NULL);
  90         regional_destroy(set->region);
  91         free(set);
  92 }
  93
  94 struct rbtree_type*
  95 respip_set_get_tree(struct respip_set* set)
  96 {
  97         if(!set)
  98                 return NULL;
  99         return &set->ip_tree;
 100 }
 101
 102 struct resp_addr*
 103 respip_sockaddr_find_or_create(struct respip_set* set, struct sockaddr_storage* addr,
 104                 socklen_t addrlen, int net, int create, const char* ipstr)
 105 {
 106         struct resp_addr* node;
 107         node = (struct resp_addr*)addr_tree_find(&set->ip_tree, addr, addrlen, net);
 108         if(!node && create) {
 109                 node = regional_alloc_zero(set->region, sizeof(*node));
 110                 if(!node) {
 111                         log_err("out of memory");
 112                         return NULL;
 113                 }
 114                 lock_rw_init(&node->lock);
 115                 node->action = respip_none;
 116                 if(!addr_tree_insert(&set->ip_tree, &node->node, addr,
 117                         addrlen, net)) {
 118                         /* We know we didn't find it, so this should be
 119                          * impossible. */
 120                         log_warn("unexpected: duplicate address: %s", ipstr);
 121                 }
 122         }
 123         return node;
 124 }
 125
 126 void
 127 respip_sockaddr_delete(struct respip_set* set, struct resp_addr* node)
 128 {
 129         struct resp_addr* prev;
 130         prev = (struct resp_addr*)rbtree_previous((struct rbnode_type*)node);
 131         lock_rw_destroy(&node->lock);
 132         rbtree_delete(&set->ip_tree, node);
 133         /* no free'ing, all allocated in region */
 134         if(!prev)
 135                 addr_tree_init_parents((rbtree_type*)set);
 136         else
 137                 addr_tree_init_parents_node(&prev->node);
 138 }
 139
 140 /** returns the node in the address tree for the specified netblock string;
 141  * non-existent node will be created if 'create' is true */
 142 static struct resp_addr*
 143 respip_find_or_create(struct respip_set* set, const char* ipstr, int create)
 144 {
 145         struct sockaddr_storage addr;
 146         int net;
 147         socklen_t addrlen;
 148
 149         if(!netblockstrtoaddr(ipstr, 0, &addr, &addrlen, &net)) {
 150                 log_err("cannot parse netblock: '%s'", ipstr);
 151                 return NULL;
 152         }
 153         return respip_sockaddr_find_or_create(set, &addr, addrlen, net, create,
 154                 ipstr);
 155 }
 156
 157 static int
 158 respip_tag_cfg(struct respip_set* set, const char* ipstr,
 159         const uint8_t* taglist, size_t taglen)
 160 {
 161         struct resp_addr* node;
 162
 163         if(!(node=respip_find_or_create(set, ipstr, 1)))
 164                 return 0;
 165         if(node->taglist) {
 166                 log_warn("duplicate response-address-tag for '%s', overridden.",
 167                         ipstr);
 168         }
 169         node->taglist = regional_alloc_init(set->region, taglist, taglen);
 170         if(!node->taglist) {
 171                 log_err("out of memory");
 172                 return 0;
 173         }
 174         node->taglen = taglen;
 175         return 1;
 176 }
 177
 178 /** set action for the node specified by the netblock string */
 179 static int
 180 respip_action_cfg(struct respip_set* set, const char* ipstr,
 181         const char* actnstr)
 182 {
 183         struct resp_addr* node;
 184         enum respip_action action;
 185
 186         if(!(node=respip_find_or_create(set, ipstr, 1)))
 187                 return 0;
 188         if(node->action != respip_none) {
 189                 verbose(VERB_QUERY, "duplicate response-ip action for '%s', overridden.",
 190                         ipstr);
 191         }
 192         if(strcmp(actnstr, "deny") == 0)
 193                 action = respip_deny;
 194         else if(strcmp(actnstr, "redirect") == 0)
 195                 action = respip_redirect;
 196         else if(strcmp(actnstr, "inform") == 0)
 197                 action = respip_inform;
 198         else if(strcmp(actnstr, "inform_deny") == 0)
 199                 action = respip_inform_deny;
 200         else if(strcmp(actnstr, "inform_redirect") == 0)
 201                 action = respip_inform_redirect;
 202         else if(strcmp(actnstr, "always_transparent") == 0)
 203                 action = respip_always_transparent;
 204         else if(strcmp(actnstr, "always_refuse") == 0)
 205                 action = respip_always_refuse;
 206         else if(strcmp(actnstr, "always_nxdomain") == 0)
 207                 action = respip_always_nxdomain;
 208         else if(strcmp(actnstr, "always_nodata") == 0)
 209                 action = respip_always_nodata;
 210         else if(strcmp(actnstr, "always_deny") == 0)
 211                 action = respip_always_deny;
 212         else {
 213                 log_err("unknown response-ip action %s", actnstr);
 214                 return 0;
 215         }
 216         node->action = action;
 217         return 1;
 218 }
 219
 220 /** allocate and initialize an rrset structure; this function is based
 221  * on new_local_rrset() from the localzone.c module */
 222 static struct ub_packed_rrset_key*
 223 new_rrset(struct regional* region, uint16_t rrtype, uint16_t rrclass)
 224 {
 225         struct packed_rrset_data* pd;
 226         struct ub_packed_rrset_key* rrset = regional_alloc_zero(
 227                 region, sizeof(*rrset));
 228         if(!rrset) {
 229                 log_err("out of memory");
 230                 return NULL;
 231         }
 232         rrset->entry.key = rrset;
 233         pd = regional_alloc_zero(region, sizeof(*pd));
 234         if(!pd) {
 235                 log_err("out of memory");
 236                 return NULL;
 237         }
 238         pd->trust = rrset_trust_prim_noglue;
 239         pd->security = sec_status_insecure;
 240         rrset->entry.data = pd;
 241         rrset->rk.dname = regional_alloc_zero(region, 1);
 242         if(!rrset->rk.dname) {
 243                 log_err("out of memory");
 244                 return NULL;
 245         }
 246         rrset->rk.dname_len = 1;
 247         rrset->rk.type = htons(rrtype);
 248         rrset->rk.rrset_class = htons(rrclass);
 249         return rrset;
 250 }
 251
 252 /** enter local data as resource records into a response-ip node */
 253
 254 int
 255 respip_enter_rr(struct regional* region, struct resp_addr* raddr,
 256         uint16_t rrtype, uint16_t rrclass, time_t ttl, uint8_t* rdata,
 257         size_t rdata_len, const char* rrstr, const char* netblockstr)
 258 {
 259         struct packed_rrset_data* pd;
 260         struct sockaddr* sa;
 261         sa = (struct sockaddr*)&raddr->node.addr;
 262         if (rrtype == LDNS_RR_TYPE_CNAME && raddr->data) {
 263                 log_err("CNAME response-ip data (%s) can not co-exist with other "
 264                         "response-ip data for netblock %s", rrstr, netblockstr);
 265                 return 0;
 266         } else if (raddr->data &&
 267                 raddr->data->rk.type == htons(LDNS_RR_TYPE_CNAME)) {
 268                 log_err("response-ip data (%s) can not be added; CNAME response-ip "
 269                         "data already in place for netblock %s", rrstr, netblockstr);
 270                 return 0;
 271         } else if((rrtype != LDNS_RR_TYPE_CNAME) &&
 272                 ((sa->sa_family == AF_INET && rrtype != LDNS_RR_TYPE_A) ||
 273                 (sa->sa_family == AF_INET6 && rrtype != LDNS_RR_TYPE_AAAA))) {
 274                 log_err("response-ip data %s record type does not correspond "
 275                         "to netblock %s address family", rrstr, netblockstr);
 276                 return 0;
 277         }
 278
 279         if(!raddr->data) {
 280                 raddr->data = new_rrset(region, rrtype, rrclass);
 281                 if(!raddr->data)
 282                         return 0;
 283         }
 284         pd = raddr->data->entry.data;
 285         return rrset_insert_rr(region, pd, rdata, rdata_len, ttl, rrstr);
 286 }
 287
 288 static int
 289 respip_enter_rrstr(struct regional* region, struct resp_addr* raddr,
 290                 const char* rrstr, const char* netblock)
 291 {
 292         uint8_t* nm;
 293         uint16_t rrtype = 0, rrclass = 0;
 294         time_t ttl = 0;
 295         uint8_t rr[LDNS_RR_BUF_SIZE];
 296         uint8_t* rdata = NULL;
 297         size_t rdata_len = 0;
 298         char buf[65536];
 299         char bufshort[64];
 300         int ret;
 301         if(raddr->action != respip_redirect
 302                 && raddr->action != respip_inform_redirect) {
 303                 log_err("cannot parse response-ip-data %s: response-ip "
 304                         "action for %s is not redirect", rrstr, netblock);
 305                 return 0;
 306         }
 307         ret = snprintf(buf, sizeof(buf), ". %s", rrstr);
 308         if(ret < 0 || ret >= (int)sizeof(buf)) {
 309                 strlcpy(bufshort, rrstr, sizeof(bufshort));
 310                 log_err("bad response-ip-data: %s...", bufshort);
 311                 return 0;
 312         }
 313         if(!rrstr_get_rr_content(buf, &nm, &rrtype, &rrclass, &ttl, rr, sizeof(rr),
 314                 &rdata, &rdata_len)) {
 315                 log_err("bad response-ip-data: %s", rrstr);
 316                 return 0;
 317         }
 318         free(nm);
 319         return respip_enter_rr(region, raddr, rrtype, rrclass, ttl, rdata,
 320                 rdata_len, rrstr, netblock);
 321 }
 322
 323 static int
 324 respip_data_cfg(struct respip_set* set, const char* ipstr, const char* rrstr)
 325 {
 326         struct resp_addr* node;
 327
 328         node=respip_find_or_create(set, ipstr, 0);
 329         if(!node || node->action == respip_none) {
 330                 log_err("cannot parse response-ip-data %s: "
 331                         "response-ip node for %s not found", rrstr, ipstr);
 332                 return 0;
 333         }
 334         return respip_enter_rrstr(set->region, node, rrstr, ipstr);
 335 }
 336
 337 static int
 338 respip_set_apply_cfg(struct respip_set* set, char* const* tagname, int num_tags,
 339         struct config_strbytelist* respip_tags,
 340         struct config_str2list* respip_actions,
 341         struct config_str2list* respip_data)
 342 {
 343         struct config_strbytelist* p;
 344         struct config_str2list* pa;
 345         struct config_str2list* pd;
 346
 347         set->tagname = tagname;
 348         set->num_tags = num_tags;
 349
 350         p = respip_tags;
 351         while(p) {
 352                 struct config_strbytelist* np = p->next;
 353
 354                 log_assert(p->str && p->str2);
 355                 if(!respip_tag_cfg(set, p->str, p->str2, p->str2len)) {
 356                         config_del_strbytelist(p);
 357                         return 0;
 358                 }
 359                 free(p->str);
 360                 free(p->str2);
 361                 free(p);
 362                 p = np;
 363         }
 364
 365         pa = respip_actions;
 366         while(pa) {
 367                 struct config_str2list* np = pa->next;
 368                 log_assert(pa->str && pa->str2);
 369                 if(!respip_action_cfg(set, pa->str, pa->str2)) {
 370                         config_deldblstrlist(pa);
 371                         return 0;
 372                 }
 373                 free(pa->str);
 374                 free(pa->str2);
 375                 free(pa);
 376                 pa = np;
 377         }
 378
 379         pd = respip_data;
 380         while(pd) {
 381                 struct config_str2list* np = pd->next;
 382                 log_assert(pd->str && pd->str2);
 383                 if(!respip_data_cfg(set, pd->str, pd->str2)) {
 384                         config_deldblstrlist(pd);
 385                         return 0;
 386                 }
 387                 free(pd->str);
 388                 free(pd->str2);
 389                 free(pd);
 390                 pd = np;
 391         }
 392         addr_tree_init_parents(&set->ip_tree);
 393
 394         return 1;
 395 }
 396
 397 int
 398 respip_global_apply_cfg(struct respip_set* set, struct config_file* cfg)
 399 {
 400         int ret = respip_set_apply_cfg(set, cfg->tagname, cfg->num_tags,
 401                 cfg->respip_tags, cfg->respip_actions, cfg->respip_data);
 402         cfg->respip_data = NULL;
 403         cfg->respip_actions = NULL;
 404         cfg->respip_tags = NULL;
 405         return ret;
 406 }
 407
 408 /** Iterate through raw view data and apply the view-specific respip
 409  * configuration; at this point we should have already seen all the views,
 410  * so if any of the views that respip data refer to does not exist, that's
 411  * an error.  This additional iteration through view configuration data
 412  * is expected to not have significant performance impact (or rather, its
 413  * performance impact is not expected to be prohibitive in the configuration
 414  * processing phase).
 415  */
 416 int
 417 respip_views_apply_cfg(struct views* vs, struct config_file* cfg,
 418         int* have_view_respip_cfg)
 419 {
 420         struct config_view* cv;
 421         struct view* v;
 422         int ret;
 423
 424         for(cv = cfg->views; cv; cv = cv->next) {
 425
 426                 /** if no respip config for this view then there's
 427                   * nothing to do; note that even though respip data must go
 428                   * with respip action, we're checking for both here because
 429                   * we want to catch the case where the respip action is missing
 430                   * while the data is present */
 431                 if(!cv->respip_actions && !cv->respip_data)
 432                         continue;
 433
 434                 if(!(v = views_find_view(vs, cv->name, 1))) {
 435                         log_err("view '%s' unexpectedly missing", cv->name);
 436                         return 0;
 437                 }
 438                 if(!v->respip_set) {
 439                         v->respip_set = respip_set_create();
 440                         if(!v->respip_set) {
 441                                 log_err("out of memory");
 442                                 lock_rw_unlock(&v->lock);
 443                                 return 0;
 444                         }
 445                 }
 446                 ret = respip_set_apply_cfg(v->respip_set, NULL, 0, NULL,
 447                         cv->respip_actions, cv->respip_data);
 448                 lock_rw_unlock(&v->lock);
 449                 if(!ret) {
 450                         log_err("Error while applying respip configuration "
 451                                 "for view '%s'", cv->name);
 452                         return 0;
 453                 }
 454                 *have_view_respip_cfg = (*have_view_respip_cfg ||
 455                         v->respip_set->ip_tree.count);
 456                 cv->respip_actions = NULL;
 457                 cv->respip_data = NULL;
 458         }
 459         return 1;
 460 }
 461
 462 /**
 463  * make a deep copy of 'key' in 'region'.
 464  * This is largely derived from packed_rrset_copy_region() and
 465  * packed_rrset_ptr_fixup(), but differs in the following points:
 466  *
 467  * - It doesn't assume all data in 'key' are in a contiguous memory region.
 468  *   Although that would be the case in most cases, 'key' can be passed from
 469  *   a lower-level module and it might not build the rrset to meet the
 470  *   assumption.  In fact, an rrset specified as response-ip-data or generated
 471  *   in local_data_find_tag_datas() breaks the assumption.  So it would be
 472  *   safer not to naively rely on the assumption.  On the other hand, this
 473  *   function ensures the copied rrset data are in a contiguous region so
 474  *   that it won't cause a disruption even if an upper layer module naively
 475  *   assumes the memory layout.
 476  * - It doesn't copy RRSIGs (if any) in 'key'.  The rrset will be used in
 477  *   a reply that was already faked, so it doesn't make much sense to provide
 478  *   partial sigs even if they are valid themselves.
 479  * - It doesn't adjust TTLs as it basically has to be a verbatim copy of 'key'
 480  *   just allocated in 'region' (the assumption is necessary TTL adjustment
 481  *   has been already done in 'key').
 482  *
 483  * This function returns the copied rrset key on success, and NULL on memory
 484  * allocation failure.
 485  */
 486 static struct ub_packed_rrset_key*
 487 copy_rrset(const struct ub_packed_rrset_key* key, struct regional* region)
 488 {
 489         struct ub_packed_rrset_key* ck = regional_alloc(region,
 490                 sizeof(struct ub_packed_rrset_key));
 491         struct packed_rrset_data* d;
 492         struct packed_rrset_data* data = key->entry.data;
 493         size_t dsize, i;
 494         uint8_t* nextrdata;
 495
 496         /* derived from packed_rrset_copy_region(), but don't use
 497          * packed_rrset_sizeof() and do exclude RRSIGs */
 498         if(!ck)
 499                 return NULL;
 500         ck->id = key->id;
 501         memset(&ck->entry, 0, sizeof(ck->entry));
 502         ck->entry.hash = key->entry.hash;
 503         ck->entry.key = ck;
 504         ck->rk = key->rk;
 505         if(key->rk.dname) {
 506                 ck->rk.dname = regional_alloc_init(region, key->rk.dname,
 507                         key->rk.dname_len);
 508                 if(!ck->rk.dname)
 509                         return NULL;
 510                 ck->rk.dname_len = key->rk.dname_len;
 511         } else {
 512                 ck->rk.dname = NULL;
 513                 ck->rk.dname_len = 0;
 514         }
 515
 516         if((unsigned)data->count >= 0xffff00U)
 517                 return NULL; /* guard against integer overflow in dsize */
 518         dsize = sizeof(struct packed_rrset_data) + data->count *
 519                 (sizeof(size_t)+sizeof(uint8_t*)+sizeof(time_t));
 520         for(i=0; i<data->count; i++) {
 521                 if((unsigned)dsize >= 0x0fffffffU ||
 522                         (unsigned)data->rr_len[i] >= 0x0fffffffU)
 523                         return NULL; /* guard against integer overflow */
 524                 dsize += data->rr_len[i];
 525         }
 526         d = regional_alloc(region, dsize);
 527         if(!d)
 528                 return NULL;
 529         *d = *data;
 530         d->rrsig_count = 0;
 531         ck->entry.data = d;
 532
 533         /* derived from packed_rrset_ptr_fixup() with copying the data */
 534         d->rr_len = (size_t*)((uint8_t*)d + sizeof(struct packed_rrset_data));
 535         d->rr_data = (uint8_t**)&(d->rr_len[d->count]);
 536         d->rr_ttl = (time_t*)&(d->rr_data[d->count]);
 537         nextrdata = (uint8_t*)&(d->rr_ttl[d->count]);
 538         for(i=0; i<d->count; i++) {
 539                 d->rr_len[i] = data->rr_len[i];
 540                 d->rr_ttl[i] = data->rr_ttl[i];
 541                 d->rr_data[i] = nextrdata;
 542                 memcpy(d->rr_data[i], data->rr_data[i], data->rr_len[i]);
 543                 nextrdata += d->rr_len[i];
 544         }
 545
 546         return ck;
 547 }
 548
 549 int
 550 respip_init(struct module_env* env, int id)
 551 {
 552         (void)env;
 553         (void)id;
 554         return 1;
 555 }
 556
 557 void
 558 respip_deinit(struct module_env* env, int id)
 559 {
 560         (void)env;
 561         (void)id;
 562 }
 563
 564 /** Convert a packed AAAA or A RRset to sockaddr. */
 565 static int
 566 rdata2sockaddr(const struct packed_rrset_data* rd, uint16_t rtype, size_t i,
 567         struct sockaddr_storage* ss, socklen_t* addrlenp)
 568 {
 569         /* unbound can accept and cache odd-length AAAA/A records, so we have
 570          * to validate the length. */
 571         if(rtype == LDNS_RR_TYPE_A && rd->rr_len[i] == 6) {
 572                 struct sockaddr_in* sa4 = (struct sockaddr_in*)ss;
 573
 574                 memset(sa4, 0, sizeof(*sa4));
 575                 sa4->sin_family = AF_INET;
 576                 memcpy(&sa4->sin_addr, rd->rr_data[i] + 2,
 577                         sizeof(sa4->sin_addr));
 578                 *addrlenp = sizeof(*sa4);
 579                 return 1;
 580         } else if(rtype == LDNS_RR_TYPE_AAAA && rd->rr_len[i] == 18) {
 581                 struct sockaddr_in6* sa6 = (struct sockaddr_in6*)ss;
 582
 583                 memset(sa6, 0, sizeof(*sa6));
 584                 sa6->sin6_family = AF_INET6;
 585                 memcpy(&sa6->sin6_addr, rd->rr_data[i] + 2,
 586                         sizeof(sa6->sin6_addr));
 587                 *addrlenp = sizeof(*sa6);
 588                 return 1;
 589         }
 590         return 0;
 591 }
 592
 593 /**
 594  * Search the given 'iptree' for response address information that matches
 595  * any of the IP addresses in an AAAA or A in the answer section of the
 596  * response (stored in 'rep').  If found, a pointer to the matched resp_addr
 597  * structure will be returned, and '*rrset_id' is set to the index in
 598  * rep->rrsets for the RRset that contains the matching IP address record
 599  * (the index is normally 0, but can be larger than that if this is a CNAME
 600  * chain or type-ANY response).
 601  * Returns resp_addr holding read lock.
 602  */
 603 static struct resp_addr*
 604 respip_addr_lookup(const struct reply_info *rep, struct respip_set* rs,
 605         size_t* rrset_id)
 606 {
 607         size_t i;
 608         struct resp_addr* ra;
 609         struct sockaddr_storage ss;
 610         socklen_t addrlen;
 611
 612         lock_rw_rdlock(&rs->lock);
 613         for(i=0; i<rep->an_numrrsets; i++) {
 614                 size_t j;
 615                 const struct packed_rrset_data* rd;
 616                 uint16_t rtype = ntohs(rep->rrsets[i]->rk.type);
 617
 618                 if(rtype != LDNS_RR_TYPE_A && rtype != LDNS_RR_TYPE_AAAA)
 619                         continue;
 620                 rd = rep->rrsets[i]->entry.data;
 621                 for(j = 0; j < rd->count; j++) {
 622                         if(!rdata2sockaddr(rd, rtype, j, &ss, &addrlen))
 623                                 continue;
 624                         ra = (struct resp_addr*)addr_tree_lookup(&rs->ip_tree,
 625                                 &ss, addrlen);
 626                         if(ra) {
 627                                 *rrset_id = i;
 628                                 lock_rw_rdlock(&ra->lock);
 629                                 lock_rw_unlock(&rs->lock);
 630                                 return ra;
 631                         }
 632                 }
 633         }
 634         lock_rw_unlock(&rs->lock);
 635         return NULL;
 636 }
 637
 638 /*
 639  * Create a new reply_info based on 'rep'.  The new info is based on
 640  * the passed 'rep', but ignores any rrsets except for the first 'an_numrrsets'
 641  * RRsets in the answer section.  These answer rrsets are copied to the
 642  * new info, up to 'copy_rrsets' rrsets (which must not be larger than
 643  * 'an_numrrsets').  If an_numrrsets > copy_rrsets, the remaining rrsets array
 644  * entries will be kept empty so the caller can fill them later.  When rrsets
 645  * are copied, they are shallow copied.  The caller must ensure that the
 646  * copied rrsets are valid throughout its lifetime and must provide appropriate
 647  * mutex if it can be shared by multiple threads.
 648  */
 649 static struct reply_info *
 650 make_new_reply_info(const struct reply_info* rep, struct regional* region,
 651         size_t an_numrrsets, size_t copy_rrsets)
 652 {
 653         struct reply_info* new_rep;
 654         size_t i;
 655
 656         /* create a base struct.  we specify 'insecure' security status as
 657          * the modified response won't be DNSSEC-valid.  In our faked response
 658          * the authority and additional sections will be empty (except possible
 659          * EDNS0 OPT RR in the additional section appended on sending it out),
 660          * so the total number of RRsets is an_numrrsets. */
 661         new_rep = construct_reply_info_base(region, rep->flags,
 662                 rep->qdcount, rep->ttl, rep->prefetch_ttl,
 663                 rep->serve_expired_ttl, an_numrrsets, 0, 0, an_numrrsets,
 664                 sec_status_insecure);
 665         if(!new_rep)
 666                 return NULL;
 667         if(!reply_info_alloc_rrset_keys(new_rep, NULL, region))
 668                 return NULL;
 669         for(i=0; i<copy_rrsets; i++)
 670                 new_rep->rrsets[i] = rep->rrsets[i];
 671
 672         return new_rep;
 673 }
 674
 675 /**
 676  * See if response-ip or tag data should override the original answer rrset
 677  * (which is rep->rrsets[rrset_id]) and if so override it.
 678  * This is (mostly) equivalent to localzone.c:local_data_answer() but for
 679  * response-ip actions.
 680  * Note that this function distinguishes error conditions from "success but
 681  * not overridden".  This is because we want to avoid accidentally applying
 682  * the "no data" action in case of error.
 683  * @param action: action to apply
 684  * @param data: RRset to use for override
 685  * @param qtype: original query type
 686  * @param rep: original reply message
 687  * @param rrset_id: the rrset ID in 'rep' to which the action should apply
 688  * @param new_repp: see respip_rewrite_reply
 689  * @param tag: if >= 0 the tag ID used to determine the action and data
 690  * @param tag_datas: data corresponding to 'tag'.
 691  * @param tag_datas_size: size of 'tag_datas'
 692  * @param tagname: array of tag names, used for logging
 693  * @param num_tags: size of 'tagname', used for logging
 694  * @param redirect_rrsetp: ptr to redirect record
 695  * @param region: region for building new reply
 696  * @return 1 if overridden, 0 if not overridden, -1 on error.
 697  */
 698 static int
 699 respip_data_answer(enum respip_action action,
 700         struct ub_packed_rrset_key* data,
 701         uint16_t qtype, const struct reply_info* rep,
 702         size_t rrset_id, struct reply_info** new_repp, int tag,
 703         struct config_strlist** tag_datas, size_t tag_datas_size,
 704         char* const* tagname, int num_tags,
 705         struct ub_packed_rrset_key** redirect_rrsetp, struct regional* region)
 706 {
 707         struct ub_packed_rrset_key* rp = data;
 708         struct reply_info* new_rep;
 709         *redirect_rrsetp = NULL;
 710
 711         if(action == respip_redirect && tag != -1 &&
 712                 (size_t)tag<tag_datas_size && tag_datas[tag]) {
 713                 struct query_info dataqinfo;
 714                 struct ub_packed_rrset_key r;
 715
 716                 /* Extract parameters of the original answer rrset that can be
 717                  * rewritten below, in the form of query_info.  Note that these
 718                  * can be different from the info of the original query if the
 719                  * rrset is a CNAME target.*/
 720                 memset(&dataqinfo, 0, sizeof(dataqinfo));
 721                 dataqinfo.qname = rep->rrsets[rrset_id]->rk.dname;
 722                 dataqinfo.qname_len = rep->rrsets[rrset_id]->rk.dname_len;
 723                 dataqinfo.qtype = ntohs(rep->rrsets[rrset_id]->rk.type);
 724                 dataqinfo.qclass = ntohs(rep->rrsets[rrset_id]->rk.rrset_class);
 725
 726                 memset(&r, 0, sizeof(r));
 727                 if(local_data_find_tag_datas(&dataqinfo, tag_datas[tag], &r,
 728                         region)) {
 729                         verbose(VERB_ALGO,
 730                                 "response-ip redirect with tag data [%d] %s",
 731                                 tag, (tag<num_tags?tagname[tag]:"null"));
 732                         /* use copy_rrset() to 'normalize' memory layout */
 733                         rp = copy_rrset(&r, region);
 734                         if(!rp)
 735                                 return -1;
 736                 }
 737         }
 738         if(!rp)
 739                 return 0;
 740
 741         /* If we are using response-ip-data, we need to make a copy of rrset
 742          * to replace the rrset's dname.  Note that, unlike local data, we
 743          * rename the dname for other actions than redirect.  This is because
 744          * response-ip-data isn't associated to any specific name. */
 745         if(rp == data) {
 746                 rp = copy_rrset(rp, region);
 747                 if(!rp)
 748                         return -1;
 749                 rp->rk.dname = rep->rrsets[rrset_id]->rk.dname;
 750                 rp->rk.dname_len = rep->rrsets[rrset_id]->rk.dname_len;
 751         }
 752
 753         /* Build a new reply with redirect rrset.  We keep any preceding CNAMEs
 754          * and replace the address rrset that triggers the action.  If it's
 755          * type ANY query, however, no other answer records should be kept
 756          * (note that it can't be a CNAME chain in this case due to
 757          * sanitizing). */
 758         if(qtype == LDNS_RR_TYPE_ANY)
 759                 rrset_id = 0;
 760         new_rep = make_new_reply_info(rep, region, rrset_id + 1, rrset_id);
 761         if(!new_rep)
 762                 return -1;
 763         rp->rk.flags |= PACKED_RRSET_FIXEDTTL; /* avoid adjusting TTL */
 764         new_rep->rrsets[rrset_id] = rp;
 765
 766         *redirect_rrsetp = rp;
 767         *new_repp = new_rep;
 768         return 1;
 769 }
 770
 771 /**
 772  * apply response ip action in case where no action data is provided.
 773  * this is similar to localzone.c:lz_zone_answer() but simplified due to
 774  * the characteristics of response ip:
 775  * - 'deny' variants will be handled at the caller side
 776  * - no specific processing for 'transparent' variants: unlike local zones,
 777  *   there is no such a case of 'no data but name existing'.  so all variants
 778  *   just mean 'transparent if no data'.
 779  * @param qtype: query type
 780  * @param action: found action
 781  * @param rep:
 782  * @param new_repp
 783  * @param rrset_id
 784  * @param region: region for building new reply
 785  * @return 1 on success, 0 on error.
 786  */
 787 static int
 788 respip_nodata_answer(uint16_t qtype, enum respip_action action,
 789         const struct reply_info *rep, size_t rrset_id,
 790         struct reply_info** new_repp, struct regional* region)
 791 {
 792         struct reply_info* new_rep;
 793
 794         if(action == respip_refuse || action == respip_always_refuse) {
 795                 new_rep = make_new_reply_info(rep, region, 0, 0);
 796                 if(!new_rep)
 797                         return 0;
 798                 FLAGS_SET_RCODE(new_rep->flags, LDNS_RCODE_REFUSED);
 799                 *new_repp = new_rep;
 800                 return 1;
 801         } else if(action == respip_static || action == respip_redirect ||
 802                 action == respip_always_nxdomain ||
 803                 action == respip_always_nodata ||
 804                 action == respip_inform_redirect) {
 805                 /* Since we don't know about other types of the owner name,
 806                  * we generally return NOERROR/NODATA unless an NXDOMAIN action
 807                  * is explicitly specified. */
 808                 int rcode = (action == respip_always_nxdomain)?
 809                         LDNS_RCODE_NXDOMAIN:LDNS_RCODE_NOERROR;
 810
 811                 /* We should empty the answer section except for any preceding
 812                  * CNAMEs (in that case rrset_id > 0).  Type-ANY case is
 813                  * special as noted in respip_data_answer(). */
 814                 if(qtype == LDNS_RR_TYPE_ANY)
 815                         rrset_id = 0;
 816                 new_rep = make_new_reply_info(rep, region, rrset_id, rrset_id);
 817                 if(!new_rep)
 818                         return 0;
 819                 FLAGS_SET_RCODE(new_rep->flags, rcode);
 820                 *new_repp = new_rep;
 821                 return 1;
 822         }
 823
 824         return 1;
 825 }
 826
 827 /** Populate action info structure with the results of response-ip action
 828  *  processing, iff as the result of response-ip processing we are actually
 829  *  taking some action. Only action is set if action_only is true.
 830  *  Returns true on success, false on failure.
 831  */
 832 static int
 833 populate_action_info(struct respip_action_info* actinfo,
 834         enum respip_action action, const struct resp_addr* raddr,
 835         const struct ub_packed_rrset_key* ATTR_UNUSED(rrset),
 836         int ATTR_UNUSED(tag), const struct respip_set* ATTR_UNUSED(ipset),
 837         int ATTR_UNUSED(action_only), struct regional* region, int rpz_used,
 838         int rpz_log, char* log_name, int rpz_cname_override)
 839 {
 840         if(action == respip_none || !raddr)
 841                 return 1;
 842         actinfo->action = action;
 843         actinfo->rpz_used = rpz_used;
 844         actinfo->rpz_log = rpz_log;
 845         actinfo->log_name = log_name;
 846         actinfo->rpz_cname_override = rpz_cname_override;
 847
 848         /* for inform variants, make a copy of the matched address block for
 849          * later logging.  We make a copy to proactively avoid disruption if
 850          *  and when we allow a dynamic update to the respip tree. */
 851         if(action == respip_inform || action == respip_inform_deny ||
 852                 rpz_used) {
 853                 struct respip_addr_info* a =
 854                         regional_alloc_zero(region, sizeof(*a));
 855                 if(!a) {
 856                         log_err("out of memory");
 857                         return 0;
 858                 }
 859                 a->addr = raddr->node.addr;
 860                 a->addrlen = raddr->node.addrlen;
 861                 a->net = raddr->node.net;
 862                 actinfo->addrinfo = a;
 863         }
 864
 865         return 1;
 866 }
 867
 868 static int
 869 respip_use_rpz(struct resp_addr* raddr, struct rpz* r,
 870         enum respip_action* action,
 871         struct ub_packed_rrset_key** data, int* rpz_log, char** log_name,
 872         int* rpz_cname_override, struct regional* region, int* is_rpz)
 873 {
 874         if(r->action_override == RPZ_DISABLED_ACTION) {
 875                 *is_rpz = 0;
 876                 return 1;
 877         }
 878         else if(r->action_override == RPZ_NO_OVERRIDE_ACTION)
 879                 *action = raddr->action;
 880         else
 881                 *action = rpz_action_to_respip_action(r->action_override);
 882         if(r->action_override == RPZ_CNAME_OVERRIDE_ACTION &&
 883                 r->cname_override) {
 884                 *data = r->cname_override;
 885                 *rpz_cname_override = 1;
 886         }
 887         *rpz_log = r->log;
 888         if(r->log_name)
 889                 if(!(*log_name = regional_strdup(region, r->log_name)))
 890                         return 0;
 891         *is_rpz = 1;
 892         return 1;
 893 }
 894
 895 int
 896 respip_rewrite_reply(const struct query_info* qinfo,
 897         const struct respip_client_info* cinfo, const struct reply_info* rep,
 898         struct reply_info** new_repp, struct respip_action_info* actinfo,
 899         struct ub_packed_rrset_key** alias_rrset, int search_only,
 900         struct regional* region, struct auth_zones* az)
 901 {
 902         const uint8_t* ctaglist;
 903         size_t ctaglen;
 904         const uint8_t* tag_actions;
 905         size_t tag_actions_size;
 906         struct config_strlist** tag_datas;
 907         size_t tag_datas_size;
 908         struct view* view = NULL;
 909         struct respip_set* ipset = NULL;
 910         size_t rrset_id = 0;
 911         enum respip_action action = respip_none;
 912         int tag = -1;
 913         struct resp_addr* raddr = NULL;
 914         int ret = 1;
 915         struct ub_packed_rrset_key* redirect_rrset = NULL;
 916         struct rpz* r;
 917         struct auth_zone* a = NULL;
 918         struct ub_packed_rrset_key* data = NULL;
 919         int rpz_used = 0;
 920         int rpz_log = 0;
 921         int rpz_cname_override = 0;
 922         char* log_name = NULL;
 923
 924         if(!cinfo)
 925                 goto done;
 926         ctaglist = cinfo->taglist;
 927         ctaglen = cinfo->taglen;
 928         tag_actions = cinfo->tag_actions;
 929         tag_actions_size = cinfo->tag_actions_size;
 930         tag_datas = cinfo->tag_datas;
 931         tag_datas_size = cinfo->tag_datas_size;
 932         view = cinfo->view;
 933         ipset = cinfo->respip_set;
 934
 935         log_assert(ipset);
 936
 937         /** Try to use response-ip config from the view first; use
 938           * global response-ip config if we don't have the view or we don't
 939           * have the matching per-view config (and the view allows the use
 940           * of global data in this case).
 941           * Note that we lock the view even if we only use view members that
 942           * currently don't change after creation.  This is for safety for
 943           * future possible changes as the view documentation seems to expect
 944           * any of its member can change in the view's lifetime.
 945           * Note also that we assume 'view' is valid in this function, which
 946           * should be safe (see unbound bug #1191) */
 947         if(view) {
 948                 lock_rw_rdlock(&view->lock);
 949                 if(view->respip_set) {
 950                         if((raddr = respip_addr_lookup(rep,
 951                                 view->respip_set, &rrset_id))) {
 952                                 /** for per-view respip directives the action
 953                                  * can only be direct (i.e. not tag-based) */
 954                                 action = raddr->action;
 955                         }
 956                 }
 957                 if(!raddr && !view->isfirst)
 958                         goto done;
 959                 if(!raddr && view->isfirst) {
 960                         lock_rw_unlock(&view->lock);
 961                         view = NULL;
 962                 }
 963         }
 964         if(!raddr && (raddr = respip_addr_lookup(rep, ipset,
 965                 &rrset_id))) {
 966                 action = (enum respip_action)local_data_find_tag_action(
 967                         raddr->taglist, raddr->taglen, ctaglist, ctaglen,
 968                         tag_actions, tag_actions_size,
 969                         (enum localzone_type)raddr->action, &tag,
 970                         ipset->tagname, ipset->num_tags);
 971         }
 972         lock_rw_rdlock(&az->rpz_lock);
 973         for(a = az->rpz_first; a && !raddr; a = a->rpz_az_next) {
 974                 lock_rw_rdlock(&a->lock);
 975                 r = a->rpz;
 976                 if(!r->taglist || taglist_intersect(r->taglist,
 977                         r->taglistlen, ctaglist, ctaglen)) {
 978                         if((raddr = respip_addr_lookup(rep,
 979                                 r->respip_set, &rrset_id))) {
 980                                 if(!respip_use_rpz(raddr, r, &action, &data,
 981                                         &rpz_log, &log_name, &rpz_cname_override,
 982                                         region, &rpz_used)) {
 983                                         log_err("out of memory");
 984                                         lock_rw_unlock(&raddr->lock);
 985                                         lock_rw_unlock(&a->lock);
 986                                         lock_rw_unlock(&az->rpz_lock);
 987                                         return 0;
 988                                 }
 989                                 if(rpz_used) {
 990                                         /* break to make sure 'a' stays pointed
 991                                          * to used auth_zone, and keeps lock */
 992                                         break;
 993                                 }
 994                                 lock_rw_unlock(&raddr->lock);
 995                                 raddr = NULL;
 996                                 actinfo->rpz_disabled++;
 997                         }
 998                 }
 999                 lock_rw_unlock(&a->lock);
1000         }
1001         lock_rw_unlock(&az->rpz_lock);
1002         if(raddr && !search_only) {
1003                 int result = 0;
1004
1005                 /* first, see if we have response-ip or tag action for the
1006                  * action except for 'always' variants. */
1007                 if(action != respip_always_refuse
1008                         && action != respip_always_transparent
1009                         && action != respip_always_nxdomain
1010                         && action != respip_always_nodata
1011                         && action != respip_always_deny
1012                         && (result = respip_data_answer(action,
1013                         (data) ? data : raddr->data, qinfo->qtype, rep,
1014                         rrset_id, new_repp, tag, tag_datas, tag_datas_size,
1015                         ipset->tagname, ipset->num_tags, &redirect_rrset,
1016                         region)) < 0) {
1017                         ret = 0;
1018                         goto done;
1019                 }
1020
1021                 /* if no action data applied, take action specific to the
1022                  * action without data. */
1023                 if(!result && !respip_nodata_answer(qinfo->qtype, action, rep,
1024                         rrset_id, new_repp, region)) {
1025                         ret = 0;
1026                         goto done;
1027                 }
1028         }
1029   done:
1030         if(view) {
1031                 lock_rw_unlock(&view->lock);
1032         }
1033         if(ret) {
1034                 /* If we're redirecting the original answer to a
1035                  * CNAME, record the CNAME rrset so the caller can take
1036                  * the appropriate action.  Note that we don't check the
1037                  * action type; it should normally be 'redirect', but it
1038                  * can be of other type when a data-dependent tag action
1039                  * uses redirect response-ip data.
1040                  */
1041                 if(redirect_rrset &&
1042                         redirect_rrset->rk.type == ntohs(LDNS_RR_TYPE_CNAME) &&
1043                         qinfo->qtype != LDNS_RR_TYPE_ANY)
1044                         *alias_rrset = redirect_rrset;
1045                 /* on success, populate respip result structure */
1046                 ret = populate_action_info(actinfo, action, raddr,
1047                         redirect_rrset, tag, ipset, search_only, region,
1048                                 rpz_used, rpz_log, log_name, rpz_cname_override);
1049         }
1050         if(raddr) {
1051                 lock_rw_unlock(&raddr->lock);
1052         }
1053         if(rpz_used) {
1054                 lock_rw_unlock(&a->lock);
1055         }
1056         return ret;
1057 }
1058
1059 static int
1060 generate_cname_request(struct module_qstate* qstate,
1061         struct ub_packed_rrset_key* alias_rrset)
1062 {
1063         struct module_qstate* subq = NULL;
1064         struct query_info subqi;
1065
1066         memset(&subqi, 0, sizeof(subqi));
1067         get_cname_target(alias_rrset, &subqi.qname, &subqi.qname_len);
1068         if(!subqi.qname)
1069                 return 0;    /* unexpected: not a valid CNAME RDATA */
1070         subqi.qtype = qstate->qinfo.qtype;
1071         subqi.qclass = qstate->qinfo.qclass;
1072         fptr_ok(fptr_whitelist_modenv_attach_sub(qstate->env->attach_sub));
1073         return (*qstate->env->attach_sub)(qstate, &subqi, BIT_RD, 0, 0, &subq);
1074 }
1075
1076 void
1077 respip_operate(struct module_qstate* qstate, enum module_ev event, int id,
1078         struct outbound_entry* outbound)
1079 {
1080         struct respip_qstate* rq = (struct respip_qstate*)qstate->minfo[id];
1081
1082         log_query_info(VERB_QUERY, "respip operate: query", &qstate->qinfo);
1083         (void)outbound;
1084
1085         if(event == module_event_new || event == module_event_pass) {
1086                 if(!rq) {
1087                         rq = regional_alloc_zero(qstate->region, sizeof(*rq));
1088                         if(!rq)
1089                                 goto servfail;
1090                         rq->state = RESPIP_INIT;
1091                         qstate->minfo[id] = rq;
1092                 }
1093                 if(rq->state == RESPIP_SUBQUERY_FINISHED) {
1094                         qstate->ext_state[id] = module_finished;
1095                         return;
1096                 }
1097                 verbose(VERB_ALGO, "respip: pass to next module");
1098                 qstate->ext_state[id] = module_wait_module;
1099         } else if(event == module_event_moddone) {
1100                 /* If the reply may be subject to response-ip rewriting
1101                  * according to the query type, check the actions.  If a
1102                  * rewrite is necessary, we'll replace the reply in qstate
1103                  * with the new one. */
1104                 enum module_ext_state next_state = module_finished;
1105
1106                 if((qstate->qinfo.qtype == LDNS_RR_TYPE_A ||
1107                         qstate->qinfo.qtype == LDNS_RR_TYPE_AAAA ||
1108                         qstate->qinfo.qtype == LDNS_RR_TYPE_ANY) &&
1109                         qstate->return_msg && qstate->return_msg->rep) {
1110                         struct reply_info* new_rep = qstate->return_msg->rep;
1111                         struct ub_packed_rrset_key* alias_rrset = NULL;
1112                         struct respip_action_info actinfo = {0, 0, 0, 0, NULL, 0, NULL};
1113                         actinfo.action = respip_none;
1114
1115                         if(!respip_rewrite_reply(&qstate->qinfo,
1116                                 qstate->client_info, qstate->return_msg->rep,
1117                                 &new_rep, &actinfo, &alias_rrset, 0,
1118                                 qstate->region, qstate->env->auth_zones)) {
1119                                 goto servfail;
1120                         }
1121                         if(actinfo.action != respip_none) {
1122                                 /* save action info for logging on a
1123                                  * per-front-end-query basis */
1124                                 if(!(qstate->respip_action_info =
1125                                         regional_alloc_init(qstate->region,
1126                                                 &actinfo, sizeof(actinfo))))
1127                                 {
1128                                         log_err("out of memory");
1129                                         goto servfail;
1130                                 }
1131                         } else {
1132                                 qstate->respip_action_info = NULL;
1133                         }
1134                         if (actinfo.action == respip_always_deny ||
1135                                 (new_rep == qstate->return_msg->rep &&
1136                                 (actinfo.action == respip_deny ||
1137                                 actinfo.action == respip_inform_deny))) {
1138                                 /* for deny-variant actions (unless response-ip
1139                                  * data is applied), mark the query state so
1140                                  * the response will be dropped for all
1141                                  * clients. */
1142                                 qstate->is_drop = 1;
1143                         } else if(alias_rrset) {
1144                                 if(!generate_cname_request(qstate, alias_rrset))
1145                                         goto servfail;
1146                                 next_state = module_wait_subquery;
1147                         }
1148                         qstate->return_msg->rep = new_rep;
1149                 }
1150                 qstate->ext_state[id] = next_state;
1151         } else
1152                 qstate->ext_state[id] = module_finished;
1153
1154         return;
1155
1156   servfail:
1157         qstate->return_rcode = LDNS_RCODE_SERVFAIL;
1158         qstate->return_msg = NULL;
1159 }
1160
1161 int
1162 respip_merge_cname(struct reply_info* base_rep,
1163         const struct query_info* qinfo, const struct reply_info* tgt_rep,
1164         const struct respip_client_info* cinfo, int must_validate,
1165         struct reply_info** new_repp, struct regional* region,
1166         struct auth_zones* az)
1167 {
1168         struct reply_info* new_rep;
1169         struct reply_info* tmp_rep = NULL; /* just a placeholder */
1170         struct ub_packed_rrset_key* alias_rrset = NULL; /* ditto */
1171         uint16_t tgt_rcode;
1172         size_t i, j;
1173         struct respip_action_info actinfo = {0, 0, 0, 0, NULL, 0, NULL};
1174         actinfo.action = respip_none;
1175
1176         /* If the query for the CNAME target would result in an unusual rcode,
1177          * we generally translate it as a failure for the base query
1178          * (which would then be translated into SERVFAIL).  The only exception
1179          * is NXDOMAIN and YXDOMAIN, which are passed to the end client(s).
1180          * The YXDOMAIN case would be rare but still possible (when
1181          * DNSSEC-validated DNAME has been cached but synthesizing CNAME
1182          * can't be generated due to length limitation) */
1183         tgt_rcode = FLAGS_GET_RCODE(tgt_rep->flags);
1184         if((tgt_rcode != LDNS_RCODE_NOERROR &&
1185                 tgt_rcode != LDNS_RCODE_NXDOMAIN &&
1186                 tgt_rcode != LDNS_RCODE_YXDOMAIN) ||
1187                 (must_validate && tgt_rep->security <= sec_status_bogus)) {
1188                 return 0;
1189         }
1190
1191         /* see if the target reply would be subject to a response-ip action. */
1192         if(!respip_rewrite_reply(qinfo, cinfo, tgt_rep, &tmp_rep, &actinfo,
1193                 &alias_rrset, 1, region, az))
1194                 return 0;
1195         if(actinfo.action != respip_none) {
1196                 log_info("CNAME target of redirect response-ip action would "
1197                         "be subject to response-ip action, too; stripped");
1198                 *new_repp = base_rep;
1199                 return 1;
1200         }
1201
1202         /* Append target reply to the base.  Since we cannot assume
1203          * tgt_rep->rrsets is valid throughout the lifetime of new_rep
1204          * or it can be safely shared by multiple threads, we need to make a
1205          * deep copy. */
1206         new_rep = make_new_reply_info(base_rep, region,
1207                 base_rep->an_numrrsets + tgt_rep->an_numrrsets,
1208                 base_rep->an_numrrsets);
1209         if(!new_rep)
1210                 return 0;
1211         for(i=0,j=base_rep->an_numrrsets; i<tgt_rep->an_numrrsets; i++,j++) {
1212                 new_rep->rrsets[j] = copy_rrset(tgt_rep->rrsets[i], region);
1213                 if(!new_rep->rrsets[j])
1214                         return 0;
1215         }
1216
1217         FLAGS_SET_RCODE(new_rep->flags, tgt_rcode);
1218         *new_repp = new_rep;
1219         return 1;
1220 }
1221
1222 void
1223 respip_inform_super(struct module_qstate* qstate, int id,
1224         struct module_qstate* super)
1225 {
1226         struct respip_qstate* rq = (struct respip_qstate*)super->minfo[id];
1227         struct reply_info* new_rep = NULL;
1228
1229         rq->state = RESPIP_SUBQUERY_FINISHED;
1230
1231         /* respip subquery should have always been created with a valid reply
1232          * in super. */
1233         log_assert(super->return_msg && super->return_msg->rep);
1234
1235         /* return_msg can be NULL when, e.g., the sub query resulted in
1236          * SERVFAIL, in which case we regard it as a failure of the original
1237          * query.  Other checks are probably redundant, but we check them
1238          * for safety. */
1239         if(!qstate->return_msg || !qstate->return_msg->rep ||
1240                 qstate->return_rcode != LDNS_RCODE_NOERROR)
1241                 goto fail;
1242
1243         if(!respip_merge_cname(super->return_msg->rep, &qstate->qinfo,
1244                 qstate->return_msg->rep, super->client_info,
1245                 super->env->need_to_validate, &new_rep, super->region,
1246                 qstate->env->auth_zones))
1247                 goto fail;
1248         super->return_msg->rep = new_rep;
1249         return;
1250
1251   fail:
1252         super->return_rcode = LDNS_RCODE_SERVFAIL;
1253         super->return_msg = NULL;
1254         return;
1255 }
1256
1257 void
1258 respip_clear(struct module_qstate* qstate, int id)
1259 {
1260         qstate->minfo[id] = NULL;
1261 }
1262
1263 size_t
1264 respip_get_mem(struct module_env* env, int id)
1265 {
1266         (void)env;
1267         (void)id;
1268         return 0;
1269 }
1270
1271 /**
1272  * The response-ip function block
1273  */
1274 static struct module_func_block respip_block = {
1275         "respip",
1276         &respip_init, &respip_deinit, &respip_operate, &respip_inform_super,
1277         &respip_clear, &respip_get_mem
1278 };
1279
1280 struct module_func_block*
1281 respip_get_funcblock(void)
1282 {
1283         return &respip_block;
1284 }
1285
1286 enum respip_action
1287 resp_addr_get_action(const struct resp_addr* addr)
1288 {
1289         return addr ? addr->action : respip_none;
1290 }
1291
1292 struct ub_packed_rrset_key*
1293 resp_addr_get_rrset(struct resp_addr* addr)
1294 {
1295         return addr ? addr->data : NULL;
1296 }
1297
1298 int
1299 respip_set_is_empty(const struct respip_set* set)
1300 {
1301         return set ? set->ip_tree.count == 0 : 1;
1302 }
1303
1304 void
1305 respip_inform_print(struct respip_action_info* respip_actinfo, uint8_t* qname,
1306         uint16_t qtype, uint16_t qclass, struct local_rrset* local_alias,
1307         struct comm_reply* repinfo)
1308 {
1309         char srcip[128], respip[128], txt[512];
1310         unsigned port;
1311         struct respip_addr_info* respip_addr = respip_actinfo->addrinfo;
1312         size_t txtlen = 0;
1313         const char* actionstr = NULL;
1314
1315         if(local_alias)
1316                 qname = local_alias->rrset->rk.dname;
1317         port = (unsigned)((repinfo->addr.ss_family == AF_INET) ?
1318                 ntohs(((struct sockaddr_in*)&repinfo->addr)->sin_port) :
1319                 ntohs(((struct sockaddr_in6*)&repinfo->addr)->sin6_port));
1320         addr_to_str(&repinfo->addr, repinfo->addrlen, srcip, sizeof(srcip));
1321         addr_to_str(&respip_addr->addr, respip_addr->addrlen,
1322                 respip, sizeof(respip));
1323         if(respip_actinfo->rpz_log) {
1324                 txtlen += snprintf(txt+txtlen, sizeof(txt)-txtlen, "%s",
1325                         "RPZ applied ");
1326                 if(respip_actinfo->rpz_cname_override)
1327                         actionstr = rpz_action_to_string(
1328                                 RPZ_CNAME_OVERRIDE_ACTION);
1329                 else
1330                         actionstr = rpz_action_to_string(
1331                                 respip_action_to_rpz_action(
1332                                         respip_actinfo->action));
1333         }
1334         if(respip_actinfo->log_name) {
1335                 txtlen += snprintf(txt+txtlen, sizeof(txt)-txtlen,
1336                         "[%s] ", respip_actinfo->log_name);
1337         }
1338         snprintf(txt+txtlen, sizeof(txt)-txtlen,
1339                 "%s/%d %s %s@%u", respip, respip_addr->net,
1340                 (actionstr) ? actionstr : "inform", srcip, port);
1341         log_nametypeclass(NO_VERBOSE, txt, qname, qtype, qclass);
1342 }