source4/dns_server/dnsserver_common.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    DNS server utils
   5
   6    Copyright (C) 2010 Kai Blin
   7    Copyright (C) 2014 Stefan Metzmacher
   8    Copyright (C) 2015 Andrew Bartlett
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "libcli/util/ntstatus.h"
  26 #include "libcli/util/werror.h"
  27 #include "librpc/ndr/libndr.h"
  28 #include "librpc/gen_ndr/ndr_dns.h"
  29 #include "librpc/gen_ndr/ndr_dnsp.h"
  30 #include <ldb.h>
  31 #include "dsdb/samdb/samdb.h"
  32 #include "dsdb/common/util.h"
  33 #include "dns_server/dnsserver_common.h"
  34 #include "lib/util/dlinklist.h"
  35
  36 #undef DBGC_CLASS
  37 #define DBGC_CLASS DBGC_DNS
  38
  39 uint8_t werr_to_dns_err(WERROR werr)
  40 {
  41         if (W_ERROR_EQUAL(WERR_OK, werr)) {
  42                 return DNS_RCODE_OK;
  43         } else if (W_ERROR_EQUAL(DNS_ERR(FORMAT_ERROR), werr)) {
  44                 return DNS_RCODE_FORMERR;
  45         } else if (W_ERROR_EQUAL(DNS_ERR(SERVER_FAILURE), werr)) {
  46                 return DNS_RCODE_SERVFAIL;
  47         } else if (W_ERROR_EQUAL(DNS_ERR(NAME_ERROR), werr)) {
  48                 return DNS_RCODE_NXDOMAIN;
  49         } else if (W_ERROR_EQUAL(WERR_DNS_ERROR_NAME_DOES_NOT_EXIST, werr)) {
  50                 return DNS_RCODE_NXDOMAIN;
  51         } else if (W_ERROR_EQUAL(DNS_ERR(NOT_IMPLEMENTED), werr)) {
  52                 return DNS_RCODE_NOTIMP;
  53         } else if (W_ERROR_EQUAL(DNS_ERR(REFUSED), werr)) {
  54                 return DNS_RCODE_REFUSED;
  55         } else if (W_ERROR_EQUAL(DNS_ERR(YXDOMAIN), werr)) {
  56                 return DNS_RCODE_YXDOMAIN;
  57         } else if (W_ERROR_EQUAL(DNS_ERR(YXRRSET), werr)) {
  58                 return DNS_RCODE_YXRRSET;
  59         } else if (W_ERROR_EQUAL(DNS_ERR(NXRRSET), werr)) {
  60                 return DNS_RCODE_NXRRSET;
  61         } else if (W_ERROR_EQUAL(DNS_ERR(NOTAUTH), werr)) {
  62                 return DNS_RCODE_NOTAUTH;
  63         } else if (W_ERROR_EQUAL(DNS_ERR(NOTZONE), werr)) {
  64                 return DNS_RCODE_NOTZONE;
  65         } else if (W_ERROR_EQUAL(DNS_ERR(BADKEY), werr)) {
  66                 return DNS_RCODE_BADKEY;
  67         }
  68         DEBUG(5, ("No mapping exists for %s\n", win_errstr(werr)));
  69         return DNS_RCODE_SERVFAIL;
  70 }
  71
  72 WERROR dns_common_extract(struct ldb_context *samdb,
  73                           const struct ldb_message_element *el,
  74                           TALLOC_CTX *mem_ctx,
  75                           struct dnsp_DnssrvRpcRecord **records,
  76                           uint16_t *num_records)
  77 {
  78         uint16_t ri;
  79         struct dnsp_DnssrvRpcRecord *recs;
  80
  81         *records = NULL;
  82         *num_records = 0;
  83
  84         recs = talloc_zero_array(mem_ctx, struct dnsp_DnssrvRpcRecord,
  85                                  el->num_values);
  86         if (recs == NULL) {
  87                 return WERR_NOT_ENOUGH_MEMORY;
  88         }
  89         for (ri = 0; ri < el->num_values; ri++) {
  90                 bool am_rodc;
  91                 int ret;
  92                 const char *dnsHostName = NULL;
  93                 struct ldb_val *v = &el->values[ri];
  94                 enum ndr_err_code ndr_err;
  95                 ndr_err = ndr_pull_struct_blob(v, recs, &recs[ri],
  96                                 (ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
  97                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  98                         TALLOC_FREE(recs);
  99                         DEBUG(0, ("Failed to grab dnsp_DnssrvRpcRecord\n"));
 100                         return DNS_ERR(SERVER_FAILURE);
 101                 }
 102
 103                 /*
 104                  * In AD, except on an RODC (where we should list a random RWDC,
 105                  * we should over-stamp the MNAME with our own hostname
 106                  */
 107                 if (recs[ri].wType != DNS_TYPE_SOA) {
 108                         continue;
 109                 }
 110
 111                 ret = samdb_rodc(samdb, &am_rodc);
 112                 if (ret != LDB_SUCCESS) {
 113                         DEBUG(0, ("Failed to confirm we are not an RODC: %s\n",
 114                                   ldb_errstring(samdb)));
 115                         return DNS_ERR(SERVER_FAILURE);
 116                 }
 117
 118                 if (am_rodc) {
 119                         continue;
 120                 }
 121
 122                 ret = samdb_dns_host_name(samdb, &dnsHostName);
 123                 if (ret != LDB_SUCCESS || dnsHostName == NULL) {
 124                         DEBUG(0, ("Failed to get dnsHostName from rootDSE"));
 125                         return DNS_ERR(SERVER_FAILURE);
 126                 }
 127
 128                 recs[ri].data.soa.mname = talloc_strdup(recs, dnsHostName);
 129         }
 130
 131         *records = recs;
 132         *num_records = el->num_values;
 133         return WERR_OK;
 134 }
 135
 136 /*
 137  * Lookup a DNS record, performing an exact match.
 138  * i.e. DNS wild card records are not considered.
 139  */
 140 WERROR dns_common_lookup(struct ldb_context *samdb,
 141                          TALLOC_CTX *mem_ctx,
 142                          struct ldb_dn *dn,
 143                          struct dnsp_DnssrvRpcRecord **records,
 144                          uint16_t *num_records,
 145                          bool *tombstoned)
 146 {
 147         static const char * const attrs[] = {
 148                 "dnsRecord",
 149                 "dNSTombstoned",
 150                 NULL
 151         };
 152         int ret;
 153         WERROR werr;
 154         struct ldb_message *msg = NULL;
 155         struct ldb_message_element *el;
 156
 157         *records = NULL;
 158         *num_records = 0;
 159
 160         if (tombstoned != NULL) {
 161                 *tombstoned = false;
 162                 ret = dsdb_search_one(samdb, mem_ctx, &msg, dn,
 163                         LDB_SCOPE_BASE, attrs, 0,
 164                         "(objectClass=dnsNode)");
 165         } else {
 166                 ret = dsdb_search_one(samdb, mem_ctx, &msg, dn,
 167                         LDB_SCOPE_BASE, attrs, 0,
 168                         "(&(objectClass=dnsNode)(!(dNSTombstoned=TRUE)))");
 169         }
 170         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 171                 return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
 172         }
 173         if (ret != LDB_SUCCESS) {
 174                 /* TODO: we need to check if there's a glue record we need to
 175                  * create a referral to */
 176                 return DNS_ERR(NAME_ERROR);
 177         }
 178
 179         if (tombstoned != NULL) {
 180                 *tombstoned = ldb_msg_find_attr_as_bool(msg,
 181                                         "dNSTombstoned", false);
 182         }
 183
 184         el = ldb_msg_find_element(msg, "dnsRecord");
 185         if (el == NULL) {
 186                 TALLOC_FREE(msg);
 187                 /*
 188                  * records produced by older Samba releases
 189                  * keep dnsNode objects without dnsRecord and
 190                  * without setting dNSTombstoned=TRUE.
 191                  *
 192                  * We just pretend they're tombstones.
 193                  */
 194                 if (tombstoned != NULL) {
 195                         struct dnsp_DnssrvRpcRecord *recs;
 196                         recs = talloc_array(mem_ctx,
 197                                             struct dnsp_DnssrvRpcRecord,
 198                                             1);
 199                         if (recs == NULL) {
 200                                 return WERR_NOT_ENOUGH_MEMORY;
 201                         }
 202                         recs[0] = (struct dnsp_DnssrvRpcRecord) {
 203                                 .wType = DNS_TYPE_TOMBSTONE,
 204                                 /*
 205                                  * A value of timestamp != 0
 206                                  * indicated that the object was already
 207                                  * a tombstone, this will be used
 208                                  * in dns_common_replace()
 209                                  */
 210                                 .data.timestamp = 1,
 211                         };
 212
 213                         *tombstoned = true;
 214                         *records = recs;
 215                         *num_records = 1;
 216                         return WERR_OK;
 217                 } else {
 218                         /*
 219                          * Because we are not looking for a tombstone
 220                          * in this codepath, we just pretend it does
 221                          * not exist at all.
 222                          */
 223                         return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
 224                 }
 225         }
 226
 227         werr = dns_common_extract(samdb, el, mem_ctx, records, num_records);
 228         TALLOC_FREE(msg);
 229         if (!W_ERROR_IS_OK(werr)) {
 230                 return werr;
 231         }
 232
 233         return WERR_OK;
 234 }
 235
 236 /*
 237  * Build an ldb_parse_tree node for an equality check
 238  *
 239  * Note: name is assumed to have been validated by dns_name_check
 240  *       so will be zero terminated and of a reasonable size.
 241  */
 242 static struct ldb_parse_tree *build_equality_operation(
 243         TALLOC_CTX *mem_ctx,
 244         bool add_asterix,     /* prepend an '*' to the name          */
 245         const uint8_t *name,  /* the value being matched             */
 246         const char *attr,     /* the attribute to check name against */
 247         size_t size)          /* length of name                      */
 248 {
 249
 250         struct ldb_parse_tree *el = NULL;  /* Equality node being built */
 251         struct ldb_val *value = NULL;      /* Value the attr will be compared
 252                                               with */
 253         size_t length = 0;                 /* calculated length of the value
 254                                               including option '*' prefix and
 255                                               '\0' string terminator */
 256
 257         el = talloc(mem_ctx, struct ldb_parse_tree);
 258         if (el == NULL) {
 259                 DBG_ERR("Unable to allocate ldb_parse_tree\n");
 260                 return NULL;
 261         }
 262
 263         el->operation = LDB_OP_EQUALITY;
 264         el->u.equality.attr = talloc_strdup(mem_ctx, attr);
 265         value = &el->u.equality.value;
 266         length = (add_asterix) ? size + 2 : size + 1;
 267         value->data = talloc_zero_array(el, uint8_t, length);
 268         if (el == NULL) {
 269                 DBG_ERR("Unable to allocate value->data\n");
 270                 TALLOC_FREE(el);
 271                 return NULL;
 272         }
 273
 274         value->length = length;
 275         if (add_asterix) {
 276                 value->data[0] = '*';
 277                 memcpy(&value->data[1], name, size);
 278         } else {
 279                 memcpy(value->data, name, size);
 280         }
 281         return el;
 282 }
 283
 284 /*
 285  * Determine the number of levels in name
 286  * essentially the number of '.'s in the name + 1
 287  *
 288  * name is assumed to have been validated by dns_name_check
 289  */
 290 static unsigned int number_of_labels(const struct ldb_val *name) {
 291         int x  = 0;
 292         unsigned int labels = 1;
 293         for (x = 0; x < name->length; x++) {
 294                 if (name->data[x] == '.') {
 295                         labels++;
 296                 }
 297         }
 298         return labels;
 299 }
 300 /*
 301  * Build a query that matches the target name, and any possible
 302  * DNS wild card entries
 303  *
 304  * Builds a parse tree equivalent to the example query.
 305  *
 306  * x.y.z -> (|(name=x.y.z)(name=\2a.y.z)(name=\2a.z)(name=\2a))
 307  *
 308  * The attribute 'name' is used as this is what the LDB index is on
 309  * (the RDN, being 'dc' in this use case, does not have an index in
 310  * the AD schema).
 311  *
 312  * Returns NULL if unable to build the query.
 313  *
 314  * The first component of the DN is assumed to be the name being looked up
 315  * and also that it has been validated by dns_name_check
 316  *
 317  */
 318 #define BASE "(&(objectClass=dnsNode)(!(dNSTombstoned=TRUE))(|(a=b)(c=d)))"
 319 static struct ldb_parse_tree *build_wildcard_query(
 320         TALLOC_CTX *mem_ctx,
 321         struct ldb_dn *dn)
 322 {
 323         const struct ldb_val *name = NULL;            /* The DNS name being
 324                                                          queried */
 325         const char *attr = "name";                    /* The attribute name */
 326         struct ldb_parse_tree *query = NULL;          /* The constructed query
 327                                                          parse tree*/
 328         struct ldb_parse_tree *wildcard_query = NULL; /* The parse tree for the
 329                                                          name and wild card
 330                                                          entries */
 331         int labels = 0;         /* The number of labels in the name */
 332
 333         name = ldb_dn_get_rdn_val(dn);
 334         if (name == NULL) {
 335                 DBG_ERR("Unable to get domain name value\n");
 336                 return NULL;
 337         }
 338         labels = number_of_labels(name);
 339
 340         query = ldb_parse_tree(mem_ctx, BASE);
 341         if (query == NULL) {
 342                 DBG_ERR("Unable to parse query %s\n", BASE);
 343                 return NULL;
 344         }
 345
 346         /*
 347          * The 3rd element of BASE is a place holder which is replaced with
 348          * the actual wild card query
 349          */
 350         wildcard_query = query->u.list.elements[2];
 351         TALLOC_FREE(wildcard_query->u.list.elements);
 352
 353         wildcard_query->u.list.num_elements = labels + 1;
 354         wildcard_query->u.list.elements = talloc_array(
 355                 wildcard_query,
 356                 struct ldb_parse_tree *,
 357                 labels + 1);
 358         /*
 359          * Build the wild card query
 360          */
 361         {
 362                 int x = 0;   /* current character in the name               */
 363                 int l = 0;   /* current equality operator index in elements */
 364                 struct ldb_parse_tree *el = NULL; /* Equality operator being
 365                                                      built */
 366                 bool add_asterix = true;  /* prepend an '*' to the value    */
 367                 for (l = 0, x = 0; l < labels && x < name->length; l++) {
 368                         unsigned int size = name->length - x;
 369                         add_asterix = (name->data[x] == '.');
 370                         el = build_equality_operation(
 371                                 mem_ctx,
 372                                 add_asterix,
 373                                 &name->data[x],
 374                                 attr,
 375                                 size);
 376                         if (el == NULL) {
 377                                 return NULL;  /* Reason will have been logged */
 378                         }
 379                         wildcard_query->u.list.elements[l] = el;
 380
 381                         /* skip to the start of the next label */
 382                         for (;x < name->length && name->data[x] != '.'; x++);
 383                 }
 384
 385                 /* Add the base level "*" only query */
 386                 el = build_equality_operation(mem_ctx, true, NULL, attr, 0);
 387                 if (el == NULL) {
 388                         TALLOC_FREE(query);
 389                         return NULL;  /* Reason will have been logged */
 390                 }
 391                 wildcard_query->u.list.elements[l] = el;
 392         }
 393         return query;
 394 }
 395
 396 /*
 397  * Scan the list of records matching a dns wildcard query and return the
 398  * best match.
 399  *
 400  * The best match is either an exact name match, or the longest wild card
 401  * entry returned
 402  *
 403  * i.e. name = a.b.c candidates *.b.c, *.c,        - *.b.c would be selected
 404  *      name = a.b.c candidates a.b.c, *.b.c, *.c  - a.b.c would be selected
 405  */
 406 static struct ldb_message *get_best_match(struct ldb_dn *dn,
 407                                           struct ldb_result *result)
 408 {
 409         int matched = 0;    /* Index of the current best match in result */
 410         size_t length = 0;  /* The length of the current candidate       */
 411         const struct ldb_val *target = NULL;    /* value we're looking for */
 412         const struct ldb_val *candidate = NULL; /* current candidate value */
 413         int x = 0;
 414
 415         target = ldb_dn_get_rdn_val(dn);
 416         for(x = 0; x < result->count; x++) {
 417                 candidate = ldb_dn_get_rdn_val(result->msgs[x]->dn);
 418                 if (strncasecmp((char *) target->data,
 419                                 (char *) candidate->data,
 420                                 target->length) == 0) {
 421                         /* Exact match stop searching and return */
 422                         return result->msgs[x];
 423                 }
 424                 if (candidate->length > length) {
 425                         matched = x;
 426                         length  = candidate->length;
 427                 }
 428         }
 429         return result->msgs[matched];
 430 }
 431
 432 /*
 433  * Look up a DNS entry, if an exact match does not exist, return the
 434  * closest matching DNS wildcard entry if available
 435  *
 436  * Returns: LDB_ERR_NO_SUCH_OBJECT     If no matching record exists
 437  *          LDB_ERR_OPERATIONS_ERROR   If the query fails
 438  *          LDB_SUCCESS                If a matching record was retrieved
 439  *
 440  */
 441 static int dns_wildcard_lookup(struct ldb_context *samdb,
 442                                TALLOC_CTX *mem_ctx,
 443                                struct ldb_dn *dn,
 444                                struct ldb_message **msg)
 445 {
 446         static const char * const attrs[] = {
 447                 "dnsRecord",
 448                 "dNSTombstoned",
 449                 NULL
 450         };
 451         struct ldb_dn *parent = NULL;     /* The parent dn                    */
 452         struct ldb_result *result = NULL; /* Results of the search            */
 453         int ret;                          /* Return code                      */
 454         struct ldb_parse_tree *query = NULL; /* The query to run              */
 455         struct ldb_request *request = NULL;  /* LDB request for the query op  */
 456         struct ldb_message *match = NULL;    /* the best matching DNS record  */
 457         TALLOC_CTX *frame = talloc_stackframe();
 458
 459         parent = ldb_dn_get_parent(frame, dn);
 460         if (parent == NULL) {
 461                 DBG_ERR("Unable to extract parent from dn\n");
 462                 TALLOC_FREE(frame);
 463                 return LDB_ERR_OPERATIONS_ERROR;
 464         }
 465
 466         query = build_wildcard_query(frame, dn);
 467         if (query == NULL) {
 468                 TALLOC_FREE(frame);
 469                 return LDB_ERR_OPERATIONS_ERROR;
 470         }
 471
 472         result = talloc_zero(mem_ctx, struct ldb_result);
 473         if (result == NULL) {
 474                 TALLOC_FREE(frame);
 475                 DBG_ERR("Unable to allocate ldb_result\n");
 476                 return LDB_ERR_OPERATIONS_ERROR;
 477         }
 478
 479         ret = ldb_build_search_req_ex(&request,
 480                                       samdb,
 481                                       frame,
 482                                       parent,
 483                                       LDB_SCOPE_ONELEVEL,
 484                                       query,
 485                                       attrs,
 486                                       NULL,
 487                                       result,
 488                                       ldb_search_default_callback,
 489                                       NULL);
 490         if (ret != LDB_SUCCESS) {
 491                 TALLOC_FREE(frame);
 492                 DBG_ERR("ldb_build_search_req_ex returned %d\n", ret);
 493                 return ret;
 494         }
 495
 496         ret = ldb_request(samdb, request);
 497         if (ret != LDB_SUCCESS) {
 498                 TALLOC_FREE(frame);
 499                 return ret;
 500         }
 501
 502         ret = ldb_wait(request->handle, LDB_WAIT_ALL);
 503         if (ret != LDB_SUCCESS) {
 504                 TALLOC_FREE(frame);
 505                 return ret;
 506         }
 507
 508         if (result->count == 0) {
 509                 TALLOC_FREE(frame);
 510                 return LDB_ERR_NO_SUCH_OBJECT;
 511         }
 512
 513         match = get_best_match(dn, result);
 514         if (match == NULL) {
 515                 TALLOC_FREE(frame);
 516                 return LDB_ERR_OPERATIONS_ERROR;
 517         }
 518
 519         *msg = talloc_move(mem_ctx, &match);
 520         TALLOC_FREE(frame);
 521         return LDB_SUCCESS;
 522 }
 523
 524 /*
 525  * Lookup a DNS record, will match DNS wild card records if an exact match
 526  * is not found.
 527  */
 528 WERROR dns_common_wildcard_lookup(struct ldb_context *samdb,
 529                                   TALLOC_CTX *mem_ctx,
 530                                   struct ldb_dn *dn,
 531                                   struct dnsp_DnssrvRpcRecord **records,
 532                                   uint16_t *num_records)
 533 {
 534         int ret;
 535         WERROR werr;
 536         struct ldb_message *msg = NULL;
 537         struct ldb_message_element *el = NULL;
 538         const struct ldb_val *name = NULL;
 539
 540         *records = NULL;
 541         *num_records = 0;
 542
 543         name = ldb_dn_get_rdn_val(dn);
 544         if (name == NULL) {
 545                 return DNS_ERR(NAME_ERROR);
 546         }
 547
 548         /* Don't look for a wildcard for @ */
 549         if (name->length == 1 && name->data[0] == '@') {
 550                 return dns_common_lookup(samdb,
 551                                          mem_ctx,
 552                                          dn,
 553                                          records,
 554                                          num_records,
 555                                          NULL);
 556         }
 557
 558         werr =  dns_name_check(
 559                         mem_ctx,
 560                         strlen((const char*)name->data),
 561                         (const char*) name->data);
 562         if (!W_ERROR_IS_OK(werr)) {
 563                 return werr;
 564         }
 565
 566         /*
 567          * Do a point search first, then fall back to a wildcard
 568          * lookup if it does not exist
 569          */
 570         werr = dns_common_lookup(samdb,
 571                                  mem_ctx,
 572                                  dn,
 573                                  records,
 574                                  num_records,
 575                                  NULL);
 576         if (!W_ERROR_EQUAL(werr, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST)) {
 577                 return werr;
 578         }
 579
 580         ret = dns_wildcard_lookup(samdb, mem_ctx, dn, &msg);
 581         if (ret == LDB_ERR_OPERATIONS_ERROR) {
 582                 return DNS_ERR(SERVER_FAILURE);
 583         }
 584         if (ret != LDB_SUCCESS) {
 585                 return DNS_ERR(NAME_ERROR);
 586         }
 587
 588         el = ldb_msg_find_element(msg, "dnsRecord");
 589         if (el == NULL) {
 590                 return WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
 591         }
 592
 593         werr = dns_common_extract(samdb, el, mem_ctx, records, num_records);
 594         TALLOC_FREE(msg);
 595         if (!W_ERROR_IS_OK(werr)) {
 596                 return werr;
 597         }
 598
 599         return WERR_OK;
 600 }
 601
 602 static int rec_cmp(const struct dnsp_DnssrvRpcRecord *r1,
 603                    const struct dnsp_DnssrvRpcRecord *r2)
 604 {
 605         if (r1->wType != r2->wType) {
 606                 /*
 607                  * The records are sorted with higher types first
 608                  */
 609                 return r2->wType - r1->wType;
 610         }
 611
 612         /*
 613          * Then we need to sort from the oldest to newest timestamp
 614          */
 615         return r1->dwTimeStamp - r2->dwTimeStamp;
 616 }
 617
 618 /*
 619  * Check for valid DNS names. These are names which:
 620  *   - are non-empty
 621  *   - do not start with a dot
 622  *   - do not have any empty labels
 623  *   - have no more than 127 labels
 624  *   - are no longer than 253 characters
 625  *   - none of the labels exceed 63 characters
 626  */
 627 WERROR dns_name_check(TALLOC_CTX *mem_ctx, size_t len, const char *name)
 628 {
 629         size_t i;
 630         unsigned int labels    = 0;
 631         unsigned int label_len = 0;
 632
 633         if (len == 0) {
 634                 return WERR_DS_INVALID_DN_SYNTAX;
 635         }
 636
 637         if (len > 1 && name[0] == '.') {
 638                 return WERR_DS_INVALID_DN_SYNTAX;
 639         }
 640
 641         if ((len - 1) > DNS_MAX_DOMAIN_LENGTH) {
 642                 return WERR_DS_INVALID_DN_SYNTAX;
 643         }
 644
 645         for (i = 0; i < len - 1; i++) {
 646                 if (name[i] == '.' && name[i+1] == '.') {
 647                         return WERR_DS_INVALID_DN_SYNTAX;
 648                 }
 649                 if (name[i] == '.') {
 650                         labels++;
 651                         if (labels > DNS_MAX_LABELS) {
 652                                 return WERR_DS_INVALID_DN_SYNTAX;
 653                         }
 654                         label_len = 0;
 655                 } else {
 656                         label_len++;
 657                         if (label_len > DNS_MAX_LABEL_LENGTH) {
 658                                 return WERR_DS_INVALID_DN_SYNTAX;
 659                         }
 660                 }
 661         }
 662
 663         return WERR_OK;
 664 }
 665
 666 static WERROR check_name_list(TALLOC_CTX *mem_ctx, uint16_t rec_count,
 667                               struct dnsp_DnssrvRpcRecord *records)
 668 {
 669         WERROR werr;
 670         uint16_t i;
 671         size_t len;
 672         struct dnsp_DnssrvRpcRecord record;
 673
 674         werr = WERR_OK;
 675         for (i = 0; i < rec_count; i++) {
 676                 record = records[i];
 677
 678                 switch (record.wType) {
 679
 680                 case DNS_TYPE_NS:
 681                         len = strlen(record.data.ns);
 682                         werr = dns_name_check(mem_ctx, len, record.data.ns);
 683                         break;
 684                 case DNS_TYPE_CNAME:
 685                         len = strlen(record.data.cname);
 686                         werr = dns_name_check(mem_ctx, len, record.data.cname);
 687                         break;
 688                 case DNS_TYPE_SOA:
 689                         len = strlen(record.data.soa.mname);
 690                         werr = dns_name_check(mem_ctx, len, record.data.soa.mname);
 691                         if (!W_ERROR_IS_OK(werr)) {
 692                                 break;
 693                         }
 694                         len = strlen(record.data.soa.rname);
 695                         werr = dns_name_check(mem_ctx, len, record.data.soa.rname);
 696                         break;
 697                 case DNS_TYPE_PTR:
 698                         len = strlen(record.data.ptr);
 699                         werr = dns_name_check(mem_ctx, len, record.data.ptr);
 700                         break;
 701                 case DNS_TYPE_MX:
 702                         len = strlen(record.data.mx.nameTarget);
 703                         werr = dns_name_check(mem_ctx, len, record.data.mx.nameTarget);
 704                         break;
 705                 case DNS_TYPE_SRV:
 706                         len = strlen(record.data.srv.nameTarget);
 707                         werr = dns_name_check(mem_ctx, len,
 708                                               record.data.srv.nameTarget);
 709                         break;
 710                 /*
 711                  * In the default case, the record doesn't have a DN, so it
 712                  * must be ok.
 713                  */
 714                 default:
 715                         break;
 716                 }
 717
 718                 if (!W_ERROR_IS_OK(werr)) {
 719                         return werr;
 720                 }
 721         }
 722
 723         return WERR_OK;
 724 }
 725
 726 WERROR dns_common_replace(struct ldb_context *samdb,
 727                           TALLOC_CTX *mem_ctx,
 728                           struct ldb_dn *dn,
 729                           bool needs_add,
 730                           uint32_t serial,
 731                           struct dnsp_DnssrvRpcRecord *records,
 732                           uint16_t rec_count)
 733 {
 734         struct ldb_message_element *el;
 735         uint16_t i;
 736         int ret;
 737         WERROR werr;
 738         struct ldb_message *msg = NULL;
 739         bool was_tombstoned = false;
 740         bool become_tombstoned = false;
 741
 742         msg = ldb_msg_new(mem_ctx);
 743         W_ERROR_HAVE_NO_MEMORY(msg);
 744
 745         msg->dn = dn;
 746
 747         werr = check_name_list(mem_ctx, rec_count, records);
 748         if (!W_ERROR_IS_OK(werr)) {
 749                 return werr;
 750         }
 751
 752         ret = ldb_msg_add_empty(msg, "dnsRecord", LDB_FLAG_MOD_REPLACE, &el);
 753         if (ret != LDB_SUCCESS) {
 754                 return DNS_ERR(SERVER_FAILURE);
 755         }
 756
 757         /*
 758          * we have at least one value,
 759          * which might be used for the tombstone marker
 760          */
 761         el->values = talloc_zero_array(el, struct ldb_val, MAX(1, rec_count));
 762         if (rec_count > 0) {
 763                 W_ERROR_HAVE_NO_MEMORY(el->values);
 764
 765                 /*
 766                  * We store a sorted list with the high wType values first
 767                  * that's what windows does. It also simplifies the
 768                  * filtering of DNS_TYPE_TOMBSTONE records
 769                  */
 770                 TYPESAFE_QSORT(records, rec_count, rec_cmp);
 771         }
 772
 773         for (i = 0; i < rec_count; i++) {
 774                 struct ldb_val *v = &el->values[el->num_values];
 775                 enum ndr_err_code ndr_err;
 776
 777                 if (records[i].wType == DNS_TYPE_TOMBSTONE) {
 778                         if (records[i].data.timestamp != 0) {
 779                                 was_tombstoned = true;
 780                         }
 781                         continue;
 782                 }
 783
 784                 records[i].dwSerial = serial;
 785                 ndr_err = ndr_push_struct_blob(v, el->values, &records[i],
 786                                 (ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
 787                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 788                         DEBUG(0, ("Failed to push dnsp_DnssrvRpcRecord\n"));
 789                         return DNS_ERR(SERVER_FAILURE);
 790                 }
 791                 el->num_values++;
 792         }
 793
 794         if (needs_add) {
 795                 if (el->num_values == 0) {
 796                         return WERR_OK;
 797                 }
 798
 799                 ret = ldb_msg_add_string(msg, "objectClass", "dnsNode");
 800                 if (ret != LDB_SUCCESS) {
 801                         return DNS_ERR(SERVER_FAILURE);
 802                 }
 803
 804                 ret = ldb_add(samdb, msg);
 805                 if (ret != LDB_SUCCESS) {
 806                         return DNS_ERR(SERVER_FAILURE);
 807                 }
 808
 809                 return WERR_OK;
 810         }
 811
 812         if (el->num_values == 0) {
 813                 struct dnsp_DnssrvRpcRecord tbs;
 814                 struct ldb_val *v = &el->values[el->num_values];
 815                 enum ndr_err_code ndr_err;
 816                 struct timeval tv;
 817
 818                 if (was_tombstoned) {
 819                         /*
 820                          * This is already a tombstoned object.
 821                          * Just leave it instead of updating the time stamp.
 822                          */
 823                         return WERR_OK;
 824                 }
 825
 826                 tv = timeval_current();
 827                 tbs = (struct dnsp_DnssrvRpcRecord) {
 828                         .wType = DNS_TYPE_TOMBSTONE,
 829                         .dwSerial = serial,
 830                         .data.timestamp = timeval_to_nttime(&tv),
 831                 };
 832
 833                 ndr_err = ndr_push_struct_blob(v, el->values, &tbs,
 834                                 (ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
 835                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 836                         DEBUG(0, ("Failed to push dnsp_DnssrvRpcRecord\n"));
 837                         return DNS_ERR(SERVER_FAILURE);
 838                 }
 839                 el->num_values++;
 840
 841                 become_tombstoned = true;
 842         }
 843
 844         if (was_tombstoned || become_tombstoned) {
 845                 ret = ldb_msg_add_empty(msg, "dNSTombstoned",
 846                                         LDB_FLAG_MOD_REPLACE, NULL);
 847                 if (ret != LDB_SUCCESS) {
 848                         return DNS_ERR(SERVER_FAILURE);
 849                 }
 850
 851                 ret = ldb_msg_add_fmt(msg, "dNSTombstoned", "%s",
 852                                       become_tombstoned ? "TRUE" : "FALSE");
 853                 if (ret != LDB_SUCCESS) {
 854                         return DNS_ERR(SERVER_FAILURE);
 855                 }
 856         }
 857
 858         ret = ldb_modify(samdb, msg);
 859         if (ret != LDB_SUCCESS) {
 860                 NTSTATUS nt = dsdb_ldb_err_to_ntstatus(ret);
 861                 return ntstatus_to_werror(nt);
 862         }
 863
 864         return WERR_OK;
 865 }
 866
 867 bool dns_name_match(const char *zone, const char *name, size_t *host_part_len)
 868 {
 869         size_t zl = strlen(zone);
 870         size_t nl = strlen(name);
 871         ssize_t zi, ni;
 872         static const size_t fixup = 'a' - 'A';
 873
 874         if (zl > nl) {
 875                 return false;
 876         }
 877
 878         for (zi = zl, ni = nl; zi >= 0; zi--, ni--) {
 879                 char zc = zone[zi];
 880                 char nc = name[ni];
 881
 882                 /* convert to lower case */
 883                 if (zc >= 'A' && zc <= 'Z') {
 884                         zc += fixup;
 885                 }
 886                 if (nc >= 'A' && nc <= 'Z') {
 887                         nc += fixup;
 888                 }
 889
 890                 if (zc != nc) {
 891                         return false;
 892                 }
 893         }
 894
 895         if (ni >= 0) {
 896                 if (name[ni] != '.') {
 897                         return false;
 898                 }
 899
 900                 ni--;
 901         }
 902
 903         *host_part_len = ni+1;
 904
 905         return true;
 906 }
 907
 908 WERROR dns_common_name2dn(struct ldb_context *samdb,
 909                           struct dns_server_zone *zones,
 910                           TALLOC_CTX *mem_ctx,
 911                           const char *name,
 912                           struct ldb_dn **_dn)
 913 {
 914         struct ldb_dn *base;
 915         struct ldb_dn *dn;
 916         const struct dns_server_zone *z;
 917         size_t host_part_len = 0;
 918         WERROR werr;
 919
 920         if (name == NULL) {
 921                 return DNS_ERR(FORMAT_ERROR);
 922         }
 923
 924         if (strcmp(name, "") == 0) {
 925                 base = ldb_get_default_basedn(samdb);
 926                 dn = ldb_dn_copy(mem_ctx, base);
 927                 ldb_dn_add_child_fmt(dn, "DC=@,DC=RootDNSServers,CN=MicrosoftDNS,CN=System");
 928                 *_dn = dn;
 929                 return WERR_OK;
 930         }
 931
 932         /* Check non-empty names */
 933         werr = dns_name_check(mem_ctx, strlen(name), name);
 934         if (!W_ERROR_IS_OK(werr)) {
 935                 return werr;
 936         }
 937
 938         for (z = zones; z != NULL; z = z->next) {
 939                 bool match;
 940
 941                 match = dns_name_match(z->name, name, &host_part_len);
 942                 if (match) {
 943                         break;
 944                 }
 945         }
 946
 947         if (z == NULL) {
 948                 return DNS_ERR(NAME_ERROR);
 949         }
 950
 951         if (host_part_len == 0) {
 952                 dn = ldb_dn_copy(mem_ctx, z->dn);
 953                 ldb_dn_add_child_fmt(dn, "DC=@");
 954                 *_dn = dn;
 955                 return WERR_OK;
 956         }
 957
 958         dn = ldb_dn_copy(mem_ctx, z->dn);
 959         ldb_dn_add_child_fmt(dn, "DC=%*.*s", (int)host_part_len, (int)host_part_len, name);
 960         *_dn = dn;
 961         return WERR_OK;
 962 }
 963
 964 static int dns_common_sort_zones(struct ldb_message **m1, struct ldb_message **m2)
 965 {
 966         const char *n1, *n2;
 967         size_t l1, l2;
 968
 969         n1 = ldb_msg_find_attr_as_string(*m1, "name", NULL);
 970         n2 = ldb_msg_find_attr_as_string(*m2, "name", NULL);
 971
 972         l1 = strlen(n1);
 973         l2 = strlen(n2);
 974
 975         /* If the string lengths are not equal just sort by length */
 976         if (l1 != l2) {
 977                 /* If m1 is the larger zone name, return it first */
 978                 return l2 - l1;
 979         }
 980
 981         /*TODO: We need to compare DNs here, we want the DomainDNSZones first */
 982         return 0;
 983 }
 984
 985 NTSTATUS dns_common_zones(struct ldb_context *samdb,
 986                           TALLOC_CTX *mem_ctx,
 987                           struct ldb_dn *base_dn,
 988                           struct dns_server_zone **zones_ret)
 989 {
 990         int ret;
 991         static const char * const attrs[] = { "name", NULL};
 992         struct ldb_result *res;
 993         int i;
 994         struct dns_server_zone *new_list = NULL;
 995         TALLOC_CTX *frame = talloc_stackframe();
 996
 997         if (base_dn) {
 998                 /* This search will work against windows */
 999                 ret = dsdb_search(samdb, frame, &res,
1000                                   base_dn, LDB_SCOPE_SUBTREE,
1001                                   attrs, 0, "(objectClass=dnsZone)");
1002         } else {
1003                 /* TODO: this search does not work against windows */
1004                 ret = dsdb_search(samdb, frame, &res, NULL,
1005                                   LDB_SCOPE_SUBTREE,
1006                                   attrs,
1007                                   DSDB_SEARCH_SEARCH_ALL_PARTITIONS,
1008                                   "(objectClass=dnsZone)");
1009         }
1010         if (ret != LDB_SUCCESS) {
1011                 TALLOC_FREE(frame);
1012                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
1013         }
1014
1015         TYPESAFE_QSORT(res->msgs, res->count, dns_common_sort_zones);
1016
1017         for (i=0; i < res->count; i++) {
1018                 struct dns_server_zone *z;
1019
1020                 z = talloc_zero(mem_ctx, struct dns_server_zone);
1021                 if (z == NULL) {
1022                         TALLOC_FREE(frame);
1023                         return NT_STATUS_NO_MEMORY;
1024                 }
1025
1026                 z->name = ldb_msg_find_attr_as_string(res->msgs[i], "name", NULL);
1027                 talloc_steal(z, z->name);
1028                 z->dn = talloc_move(z, &res->msgs[i]->dn);
1029                 /*
1030                  * Ignore the RootDNSServers zone and zones that we don't support yet
1031                  * RootDNSServers should never be returned (Windows DNS server don't)
1032                  * ..TrustAnchors should never be returned as is, (Windows returns
1033                  * TrustAnchors) and for the moment we don't support DNSSEC so we'd better
1034                  * not return this zone.
1035                  */
1036                 if ((strcmp(z->name, "RootDNSServers") == 0) ||
1037                     (strcmp(z->name, "..TrustAnchors") == 0))
1038                 {
1039                         DEBUG(10, ("Ignoring zone %s\n", z->name));
1040                         talloc_free(z);
1041                         continue;
1042                 }
1043                 DLIST_ADD_END(new_list, z);
1044         }
1045
1046         *zones_ret = new_list;
1047         TALLOC_FREE(frame);
1048         return NT_STATUS_OK;
1049 }
1050
1051 /*
1052   see if two DNS names are the same
1053  */
1054 bool dns_name_equal(const char *name1, const char *name2)
1055 {
1056         size_t len1 = strlen(name1);
1057         size_t len2 = strlen(name2);
1058
1059         if (len1 > 0 && name1[len1 - 1] == '.') {
1060                 len1--;
1061         }
1062         if (len2 > 0 && name2[len2 - 1] == '.') {
1063                 len2--;
1064         }
1065         if (len1 != len2) {
1066                 return false;
1067         }
1068         return strncasecmp(name1, name2, len1) == 0;
1069 }