external/bsd/bind/dist/bin/named/lwdgrbn.c

   1 /*      $NetBSD: lwdgrbn.c,v 1.6 2014/12/10 04:37:51 christos Exp $     */
   2
   3 /*
   4  * Copyright (C) 2004-2007, 2009, 2013, 2014  Internet Systems Consortium, Inc. ("ISC")
   5  * Copyright (C) 2000, 2001, 2003  Internet Software Consortium.
   6  *
   7  * Permission to use, copy, modify, and/or distribute this software for any
   8  * purpose with or without fee is hereby granted, provided that the above
   9  * copyright notice and this permission notice appear in all copies.
  10  *
  11  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  12  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  13  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  14  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  15  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  16  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17  * PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 /* Id: lwdgrbn.c,v 1.22 2009/09/02 23:48:01 tbox Exp  */
  21
  22 /*! \file */
  23
  24 #include <config.h>
  25
  26 #include <isc/mem.h>
  27 #include <isc/socket.h>
  28 #include <isc/string.h>         /* Required for HP/UX (and others?) */
  29 #include <isc/util.h>
  30
  31 #include <dns/db.h>
  32 #include <dns/lookup.h>
  33 #include <dns/rdata.h>
  34 #include <dns/rdataset.h>
  35 #include <dns/rdatasetiter.h>
  36 #include <dns/result.h>
  37 #include <dns/view.h>
  38
  39 #include <named/types.h>
  40 #include <named/lwdclient.h>
  41 #include <named/lwresd.h>
  42 #include <named/lwsearch.h>
  43
  44 static void start_lookup(ns_lwdclient_t *);
  45
  46 static isc_result_t
  47 fill_array(int *pos, dns_rdataset_t *rdataset,
  48            int size, unsigned char **rdatas, lwres_uint16_t *rdatalen)
  49 {
  50         dns_rdata_t rdata;
  51         isc_result_t result;
  52         isc_region_t r;
  53
  54         UNUSED(size);
  55
  56         dns_rdata_init(&rdata);
  57         for (result = dns_rdataset_first(rdataset);
  58              result == ISC_R_SUCCESS;
  59              result = dns_rdataset_next(rdataset))
  60         {
  61                 INSIST(*pos < size);
  62                 dns_rdataset_current(rdataset, &rdata);
  63                 dns_rdata_toregion(&rdata, &r);
  64                 rdatas[*pos] = r.base;
  65                 rdatalen[*pos] = r.length;
  66                 dns_rdata_reset(&rdata);
  67                 (*pos)++;
  68         }
  69         if (result == ISC_R_NOMORE)
  70                 result = ISC_R_SUCCESS;
  71         return (result);
  72 }
  73
  74 static isc_result_t
  75 iterate_node(lwres_grbnresponse_t *grbn, dns_db_t *db, dns_dbnode_t *node,
  76              isc_mem_t *mctx)
  77 {
  78         int used = 0, count;
  79         int size = 8, oldsize = 0;
  80         unsigned char **rdatas = NULL, **oldrdatas = NULL, **newrdatas = NULL;
  81         lwres_uint16_t *lens = NULL, *oldlens = NULL, *newlens = NULL;
  82         dns_rdatasetiter_t *iter = NULL;
  83         dns_rdataset_t set;
  84         dns_ttl_t ttl = ISC_INT32_MAX;
  85         lwres_uint32_t flags = LWRDATA_VALIDATED;
  86         isc_result_t result = ISC_R_NOMEMORY;
  87
  88         result = dns_db_allrdatasets(db, node, NULL, 0, &iter);
  89         if (result != ISC_R_SUCCESS)
  90                 goto out;
  91
  92         rdatas = isc_mem_get(mctx, size * sizeof(*rdatas));
  93         if (rdatas == NULL)
  94                 goto out;
  95         lens = isc_mem_get(mctx, size * sizeof(*lens));
  96         if (lens == NULL)
  97                 goto out;
  98
  99         for (result = dns_rdatasetiter_first(iter);
 100              result == ISC_R_SUCCESS;
 101              result = dns_rdatasetiter_next(iter))
 102         {
 103                 result = ISC_R_NOMEMORY;
 104                 dns_rdataset_init(&set);
 105                 dns_rdatasetiter_current(iter, &set);
 106
 107                 if (set.type != dns_rdatatype_rrsig) {
 108                         dns_rdataset_disassociate(&set);
 109                         continue;
 110                 }
 111
 112                 count = dns_rdataset_count(&set);
 113                 if (used + count > size) {
 114                         /* copy & reallocate */
 115                         oldsize = size;
 116                         oldrdatas = rdatas;
 117                         oldlens = lens;
 118                         rdatas = NULL;
 119                         lens = NULL;
 120
 121                         size *= 2;
 122
 123                         rdatas = isc_mem_get(mctx, size * sizeof(*rdatas));
 124                         if (rdatas == NULL)
 125                                 goto out;
 126                         lens = isc_mem_get(mctx, size * sizeof(*lens));
 127                         if (lens == NULL)
 128                                 goto out;
 129                         memmove(rdatas, oldrdatas, used * sizeof(*rdatas));
 130                         memmove(lens, oldlens, used * sizeof(*lens));
 131                         isc_mem_put(mctx, oldrdatas,
 132                                     oldsize * sizeof(*oldrdatas));
 133                         isc_mem_put(mctx, oldlens, oldsize * sizeof(*oldlens));
 134                         oldrdatas = NULL;
 135                         oldlens = NULL;
 136                 }
 137                 if (set.ttl < ttl)
 138                         ttl = set.ttl;
 139                 if (set.trust != dns_trust_secure)
 140                         flags &= (~LWRDATA_VALIDATED);
 141                 result = fill_array(&used, &set, size, rdatas, lens);
 142                 dns_rdataset_disassociate(&set);
 143                 if (result != ISC_R_SUCCESS)
 144                         goto out;
 145         }
 146         if (result == ISC_R_NOMORE)
 147                 result = ISC_R_SUCCESS;
 148         if (result != ISC_R_SUCCESS)
 149                 goto out;
 150         dns_rdatasetiter_destroy(&iter);
 151
 152         /*
 153          * If necessary, shrink and copy the arrays.
 154          */
 155         if (size != used) {
 156                 result = ISC_R_NOMEMORY;
 157                 newrdatas = isc_mem_get(mctx, used * sizeof(*rdatas));
 158                 if (newrdatas == NULL)
 159                         goto out;
 160                 newlens = isc_mem_get(mctx, used * sizeof(*lens));
 161                 if (newlens == NULL)
 162                         goto out;
 163                 memmove(newrdatas, rdatas, used * sizeof(*rdatas));
 164                 memmove(newlens, lens, used * sizeof(*lens));
 165                 isc_mem_put(mctx, rdatas, size * sizeof(*rdatas));
 166                 isc_mem_put(mctx, lens, size * sizeof(*lens));
 167                 grbn->rdatas = newrdatas;
 168                 grbn->rdatalen = newlens;
 169         } else {
 170                 grbn->rdatas = rdatas;
 171                 grbn->rdatalen = lens;
 172         }
 173         grbn->nrdatas = used;
 174         grbn->ttl = ttl;
 175         grbn->flags = flags;
 176         return (ISC_R_SUCCESS);
 177
 178  out:
 179         dns_rdatasetiter_destroy(&iter);
 180         if (rdatas != NULL)
 181                 isc_mem_put(mctx, rdatas, size * sizeof(*rdatas));
 182         if (lens != NULL)
 183                 isc_mem_put(mctx, lens, size * sizeof(*lens));
 184         if (oldrdatas != NULL)
 185                 isc_mem_put(mctx, oldrdatas, oldsize * sizeof(*oldrdatas));
 186         if (oldlens != NULL)
 187                 isc_mem_put(mctx, oldlens, oldsize * sizeof(*oldlens));
 188         if (newrdatas != NULL)
 189                 isc_mem_put(mctx, newrdatas, used * sizeof(*oldrdatas));
 190         return (result);
 191 }
 192
 193 static void
 194 lookup_done(isc_task_t *task, isc_event_t *event) {
 195         ns_lwdclient_t *client;
 196         ns_lwdclientmgr_t *cm;
 197         dns_lookupevent_t *levent;
 198         lwres_buffer_t lwb;
 199         dns_name_t *name;
 200         dns_rdataset_t *rdataset;
 201         dns_rdataset_t *sigrdataset;
 202         isc_result_t result;
 203         lwres_result_t lwresult;
 204         isc_region_t r;
 205         isc_buffer_t b;
 206         lwres_grbnresponse_t *grbn;
 207         int i;
 208
 209         REQUIRE(event != NULL);
 210
 211         UNUSED(task);
 212
 213         lwb.base = NULL;
 214         client = event->ev_arg;
 215         cm = client->clientmgr;
 216         INSIST(client->lookup == (dns_lookup_t *)event->ev_sender);
 217
 218         levent = (dns_lookupevent_t *)event;
 219         grbn = &client->grbn;
 220
 221         ns_lwdclient_log(50, "lookup event result = %s",
 222                          isc_result_totext(levent->result));
 223
 224         result = levent->result;
 225         if (result != ISC_R_SUCCESS) {
 226                 dns_lookup_destroy(&client->lookup);
 227                 isc_event_free(&event);
 228                 levent = NULL;
 229
 230                 switch (result) {
 231                 case DNS_R_NXDOMAIN:
 232                 case DNS_R_NCACHENXDOMAIN:
 233                         result = ns_lwsearchctx_next(&client->searchctx);
 234                         if (result != ISC_R_SUCCESS)
 235                                 lwresult = LWRES_R_NOTFOUND;
 236                         else {
 237                                 start_lookup(client);
 238                                 return;
 239                         }
 240                         break;
 241                 case DNS_R_NXRRSET:
 242                 case DNS_R_NCACHENXRRSET:
 243                         lwresult = LWRES_R_TYPENOTFOUND;
 244                         break;
 245                 default:
 246                         lwresult = LWRES_R_FAILURE;
 247                 }
 248                 ns_lwdclient_errorpktsend(client, lwresult);
 249                 return;
 250         }
 251
 252         name = levent->name;
 253         b = client->recv_buffer;
 254
 255         grbn->flags = 0;
 256
 257         grbn->nrdatas = 0;
 258         grbn->rdatas = NULL;
 259         grbn->rdatalen = NULL;
 260
 261         grbn->nsigs = 0;
 262         grbn->sigs = NULL;
 263         grbn->siglen = NULL;
 264
 265         result = dns_name_totext(name, ISC_TRUE, &client->recv_buffer);
 266         if (result != ISC_R_SUCCESS)
 267                 goto out;
 268         grbn->realname = (char *)isc_buffer_used(&b);
 269         grbn->realnamelen = isc_buffer_usedlength(&client->recv_buffer) -
 270                             isc_buffer_usedlength(&b);
 271         ns_lwdclient_log(50, "found name '%.*s'", grbn->realnamelen,
 272                          grbn->realname);
 273
 274         grbn->rdclass = cm->view->rdclass;
 275         grbn->rdtype = client->rdtype;
 276
 277         rdataset = levent->rdataset;
 278         if (rdataset != NULL) {
 279                 /* The normal case */
 280                 grbn->nrdatas = dns_rdataset_count(rdataset);
 281                 grbn->rdatas = isc_mem_get(cm->mctx, grbn->nrdatas *
 282                                            sizeof(unsigned char *));
 283                 if (grbn->rdatas == NULL)
 284                         goto out;
 285                 grbn->rdatalen = isc_mem_get(cm->mctx, grbn->nrdatas *
 286                                              sizeof(lwres_uint16_t));
 287                 if (grbn->rdatalen == NULL)
 288                         goto out;
 289
 290                 i = 0;
 291                 result = fill_array(&i, rdataset, grbn->nrdatas, grbn->rdatas,
 292                                     grbn->rdatalen);
 293                 if (result != ISC_R_SUCCESS)
 294                         goto out;
 295                 INSIST(i == grbn->nrdatas);
 296                 grbn->ttl = rdataset->ttl;
 297                 if (rdataset->trust == dns_trust_secure)
 298                         grbn->flags |= LWRDATA_VALIDATED;
 299         } else {
 300                 /* The SIG query case */
 301                 result = iterate_node(grbn, levent->db, levent->node,
 302                                       cm->mctx);
 303                 if (result != ISC_R_SUCCESS)
 304                         goto out;
 305         }
 306         ns_lwdclient_log(50, "filled in %d rdata%s", grbn->nrdatas,
 307                          (grbn->nrdatas == 1) ? "" : "s");
 308
 309         sigrdataset = levent->sigrdataset;
 310         if (sigrdataset != NULL) {
 311                 grbn->nsigs = dns_rdataset_count(sigrdataset);
 312                 grbn->sigs = isc_mem_get(cm->mctx, grbn->nsigs *
 313                                          sizeof(unsigned char *));
 314                 if (grbn->sigs == NULL)
 315                         goto out;
 316                 grbn->siglen = isc_mem_get(cm->mctx, grbn->nsigs *
 317                                            sizeof(lwres_uint16_t));
 318                 if (grbn->siglen == NULL)
 319                         goto out;
 320
 321                 i = 0;
 322                 result = fill_array(&i, sigrdataset, grbn->nsigs, grbn->sigs,
 323                                     grbn->siglen);
 324                 if (result != ISC_R_SUCCESS)
 325                         goto out;
 326                 INSIST(i == grbn->nsigs);
 327                 ns_lwdclient_log(50, "filled in %d signature%s", grbn->nsigs,
 328                                  (grbn->nsigs == 1) ? "" : "s");
 329         }
 330
 331         /*
 332          * Render the packet.
 333          */
 334         client->pkt.recvlength = LWRES_RECVLENGTH;
 335         client->pkt.authtype = 0; /* XXXMLG */
 336         client->pkt.authlength = 0;
 337         client->pkt.result = LWRES_R_SUCCESS;
 338
 339         lwresult = lwres_grbnresponse_render(cm->lwctx,
 340                                              grbn, &client->pkt, &lwb);
 341         if (lwresult != LWRES_R_SUCCESS)
 342                 goto out;
 343
 344         isc_mem_put(cm->mctx, grbn->rdatas,
 345                     grbn->nrdatas * sizeof(unsigned char *));
 346         isc_mem_put(cm->mctx, grbn->rdatalen,
 347                     grbn->nrdatas * sizeof(lwres_uint16_t));
 348
 349         if (grbn->sigs != NULL)
 350                 isc_mem_put(cm->mctx, grbn->sigs,
 351                             grbn->nsigs * sizeof(unsigned char *));
 352         if (grbn->siglen != NULL)
 353                 isc_mem_put(cm->mctx, grbn->siglen,
 354                             grbn->nsigs * sizeof(lwres_uint16_t));
 355
 356         r.base = lwb.base;
 357         r.length = lwb.used;
 358         client->sendbuf = r.base;
 359         client->sendlength = r.length;
 360         result = ns_lwdclient_sendreply(client, &r);
 361         if (result != ISC_R_SUCCESS)
 362                 goto out2;
 363
 364         NS_LWDCLIENT_SETSEND(client);
 365
 366         dns_lookup_destroy(&client->lookup);
 367         isc_event_free(&event);
 368
 369         return;
 370
 371  out:
 372         if (grbn->rdatas != NULL)
 373                 isc_mem_put(cm->mctx, grbn->rdatas,
 374                             grbn->nrdatas * sizeof(unsigned char *));
 375         if (grbn->rdatalen != NULL)
 376                 isc_mem_put(cm->mctx, grbn->rdatalen,
 377                             grbn->nrdatas * sizeof(lwres_uint16_t));
 378
 379         if (grbn->sigs != NULL)
 380                 isc_mem_put(cm->mctx, grbn->sigs,
 381                             grbn->nsigs * sizeof(unsigned char *));
 382         if (grbn->siglen != NULL)
 383                 isc_mem_put(cm->mctx, grbn->siglen,
 384                             grbn->nsigs * sizeof(lwres_uint16_t));
 385  out2:
 386         if (client->lookup != NULL)
 387                 dns_lookup_destroy(&client->lookup);
 388         if (lwb.base != NULL)
 389                 lwres_context_freemem(cm->lwctx, lwb.base, lwb.length);
 390
 391         isc_event_free(&event);
 392
 393         ns_lwdclient_log(50, "error constructing getrrsetbyname response");
 394         ns_lwdclient_errorpktsend(client, LWRES_R_FAILURE);
 395 }
 396
 397 static void
 398 start_lookup(ns_lwdclient_t *client) {
 399         isc_result_t result;
 400         ns_lwdclientmgr_t *cm;
 401         dns_fixedname_t absname;
 402
 403         cm = client->clientmgr;
 404
 405         INSIST(client->lookup == NULL);
 406
 407         dns_fixedname_init(&absname);
 408         result = ns_lwsearchctx_current(&client->searchctx,
 409                                         dns_fixedname_name(&absname));
 410         /*
 411          * This will return failure if relative name + suffix is too long.
 412          * In this case, just go on to the next entry in the search path.
 413          */
 414         if (result != ISC_R_SUCCESS)
 415                 start_lookup(client);
 416
 417         result = dns_lookup_create(cm->mctx,
 418                                    dns_fixedname_name(&absname),
 419                                    client->rdtype, cm->view,
 420                                    client->options, cm->task, lookup_done,
 421                                    client, &client->lookup);
 422         if (result != ISC_R_SUCCESS) {
 423                 ns_lwdclient_errorpktsend(client, LWRES_R_FAILURE);
 424                 return;
 425         }
 426 }
 427
 428 static void
 429 init_grbn(ns_lwdclient_t *client) {
 430         client->grbn.rdclass = 0;
 431         client->grbn.rdtype = 0;
 432         client->grbn.ttl = 0;
 433         client->grbn.nrdatas = 0;
 434         client->grbn.realname = NULL;
 435         client->grbn.realnamelen = 0;
 436         client->grbn.rdatas = 0;
 437         client->grbn.rdatalen = 0;
 438         client->grbn.base = NULL;
 439         client->grbn.baselen = 0;
 440         isc_buffer_init(&client->recv_buffer, client->buffer, LWRES_RECVLENGTH);
 441 }
 442
 443 void
 444 ns_lwdclient_processgrbn(ns_lwdclient_t *client, lwres_buffer_t *b) {
 445         lwres_grbnrequest_t *req;
 446         isc_result_t result;
 447         ns_lwdclientmgr_t *cm;
 448         isc_buffer_t namebuf;
 449
 450         REQUIRE(NS_LWDCLIENT_ISRECVDONE(client));
 451         INSIST(client->byaddr == NULL);
 452
 453         cm = client->clientmgr;
 454         req = NULL;
 455
 456         result = lwres_grbnrequest_parse(cm->lwctx,
 457                                          b, &client->pkt, &req);
 458         if (result != LWRES_R_SUCCESS)
 459                 goto out;
 460         if (req->name == NULL)
 461                 goto out;
 462
 463         client->options = 0;
 464         if (req->rdclass != cm->view->rdclass)
 465                 goto out;
 466
 467         if (req->rdclass == dns_rdataclass_any ||
 468             req->rdtype == dns_rdatatype_any)
 469                 goto out;
 470
 471         client->rdtype = req->rdtype;
 472
 473         isc_buffer_init(&namebuf, req->name, req->namelen);
 474         isc_buffer_add(&namebuf, req->namelen);
 475
 476         dns_fixedname_init(&client->query_name);
 477         result = dns_name_fromtext(dns_fixedname_name(&client->query_name),
 478                                    &namebuf, NULL, 0, NULL);
 479         if (result != ISC_R_SUCCESS)
 480                 goto out;
 481         ns_lwsearchctx_init(&client->searchctx,
 482                             cm->listener->manager->search,
 483                             dns_fixedname_name(&client->query_name),
 484                             cm->listener->manager->ndots);
 485         ns_lwsearchctx_first(&client->searchctx);
 486
 487         ns_lwdclient_log(50, "client %p looking for type %d",
 488                          client, client->rdtype);
 489
 490         /*
 491          * We no longer need to keep this around.
 492          */
 493         lwres_grbnrequest_free(cm->lwctx, &req);
 494
 495         /*
 496          * Initialize the real name and alias arrays in the reply we're
 497          * going to build up.
 498          */
 499         init_grbn(client);
 500
 501         /*
 502          * Start the find.
 503          */
 504         start_lookup(client);
 505
 506         return;
 507
 508         /*
 509          * We're screwed.  Return an error packet to our caller.
 510          */
 511  out:
 512         if (req != NULL)
 513                 lwres_grbnrequest_free(cm->lwctx, &req);
 514
 515         ns_lwdclient_errorpktsend(client, LWRES_R_FAILURE);
 516 }