contrib/bind-9.2.4rc7/bin/named/lwdgrbn.c

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