Line data Source code
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 "rpc_server/dnsserver/dnsserver.h"
35 : #include "lib/util/dlinklist.h"
36 : #include "system/network.h"
37 :
38 : #undef DBGC_CLASS
39 : #define DBGC_CLASS DBGC_DNS
40 :
41 : #undef strncasecmp
42 :
43 18681 : uint8_t werr_to_dns_err(WERROR werr)
44 : {
45 18681 : if (W_ERROR_EQUAL(WERR_OK, werr)) {
46 76 : return DNS_RCODE_OK;
47 18681 : } else if (W_ERROR_EQUAL(DNS_ERR(FORMAT_ERROR), werr)) {
48 85 : return DNS_RCODE_FORMERR;
49 18669 : } else if (W_ERROR_EQUAL(DNS_ERR(SERVER_FAILURE), werr)) {
50 73 : return DNS_RCODE_SERVFAIL;
51 18669 : } else if (W_ERROR_EQUAL(DNS_ERR(NAME_ERROR), werr)) {
52 18551 : return DNS_RCODE_NXDOMAIN;
53 163 : } else if (W_ERROR_EQUAL(WERR_DNS_ERROR_NAME_DOES_NOT_EXIST, werr)) {
54 49 : return DNS_RCODE_NXDOMAIN;
55 157 : } else if (W_ERROR_EQUAL(DNS_ERR(NOT_IMPLEMENTED), werr)) {
56 49 : return DNS_RCODE_NOTIMP;
57 149 : } else if (W_ERROR_EQUAL(DNS_ERR(REFUSED), werr)) {
58 114 : return DNS_RCODE_REFUSED;
59 56 : } else if (W_ERROR_EQUAL(DNS_ERR(YXDOMAIN), werr)) {
60 21 : return DNS_RCODE_YXDOMAIN;
61 56 : } else if (W_ERROR_EQUAL(DNS_ERR(YXRRSET), werr)) {
62 21 : return DNS_RCODE_YXRRSET;
63 56 : } else if (W_ERROR_EQUAL(DNS_ERR(NXRRSET), werr)) {
64 41 : return DNS_RCODE_NXRRSET;
65 20 : } else if (W_ERROR_EQUAL(DNS_ERR(NOTAUTH), werr)) {
66 7 : return DNS_RCODE_NOTAUTH;
67 16 : } else if (W_ERROR_EQUAL(DNS_ERR(NOTZONE), werr)) {
68 6 : return DNS_RCODE_NOTZONE;
69 10 : } else if (W_ERROR_EQUAL(DNS_ERR(BADKEY), werr)) {
70 0 : return DNS_RCODE_BADKEY;
71 : }
72 10 : DEBUG(5, ("No mapping exists for %s\n", win_errstr(werr)));
73 10 : return DNS_RCODE_SERVFAIL;
74 : }
75 :
76 47828 : WERROR dns_common_extract(struct ldb_context *samdb,
77 : const struct ldb_message_element *el,
78 : TALLOC_CTX *mem_ctx,
79 : struct dnsp_DnssrvRpcRecord **records,
80 : uint16_t *num_records)
81 : {
82 : uint16_t ri;
83 : struct dnsp_DnssrvRpcRecord *recs;
84 :
85 47828 : *records = NULL;
86 47828 : *num_records = 0;
87 :
88 47828 : recs = talloc_zero_array(mem_ctx, struct dnsp_DnssrvRpcRecord,
89 : el->num_values);
90 47828 : if (recs == NULL) {
91 0 : return WERR_NOT_ENOUGH_MEMORY;
92 : }
93 162822 : for (ri = 0; ri < el->num_values; ri++) {
94 : bool am_rodc;
95 : int ret;
96 114994 : const char *dnsHostName = NULL;
97 114994 : struct ldb_val *v = &el->values[ri];
98 : enum ndr_err_code ndr_err;
99 114994 : ndr_err = ndr_pull_struct_blob(v, recs, &recs[ri],
100 : (ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
101 114994 : if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
102 0 : TALLOC_FREE(recs);
103 0 : DEBUG(0, ("Failed to grab dnsp_DnssrvRpcRecord\n"));
104 0 : return DNS_ERR(SERVER_FAILURE);
105 : }
106 :
107 : /*
108 : * In AD, except on an RODC (where we should list a random RWDC,
109 : * we should over-stamp the MNAME with our own hostname
110 : */
111 114994 : if (recs[ri].wType != DNS_TYPE_SOA) {
112 166404 : continue;
113 : }
114 :
115 30221 : ret = samdb_rodc(samdb, &am_rodc);
116 30221 : if (ret != LDB_SUCCESS) {
117 0 : DEBUG(0, ("Failed to confirm we are not an RODC: %s\n",
118 : ldb_errstring(samdb)));
119 0 : return DNS_ERR(SERVER_FAILURE);
120 : }
121 :
122 30221 : if (am_rodc) {
123 12 : continue;
124 : }
125 :
126 30209 : ret = samdb_dns_host_name(samdb, &dnsHostName);
127 30209 : if (ret != LDB_SUCCESS || dnsHostName == NULL) {
128 0 : DEBUG(0, ("Failed to get dnsHostName from rootDSE"));
129 0 : return DNS_ERR(SERVER_FAILURE);
130 : }
131 :
132 30209 : recs[ri].data.soa.mname = talloc_strdup(recs, dnsHostName);
133 : }
134 :
135 47828 : *records = recs;
136 47828 : *num_records = el->num_values;
137 47828 : return WERR_OK;
138 : }
139 :
140 : /*
141 : * Lookup a DNS record, performing an exact match.
142 : * i.e. DNS wild card records are not considered.
143 : */
144 66883 : WERROR dns_common_lookup(struct ldb_context *samdb,
145 : TALLOC_CTX *mem_ctx,
146 : struct ldb_dn *dn,
147 : struct dnsp_DnssrvRpcRecord **records,
148 : uint16_t *num_records,
149 : bool *tombstoned)
150 : {
151 66883 : const struct timeval start = timeval_current();
152 : static const char * const attrs[] = {
153 : "dnsRecord",
154 : "dNSTombstoned",
155 : NULL
156 : };
157 : int ret;
158 66883 : WERROR werr = WERR_OK;
159 66883 : struct ldb_message *msg = NULL;
160 : struct ldb_message_element *el;
161 :
162 66883 : *records = NULL;
163 66883 : *num_records = 0;
164 :
165 66883 : if (tombstoned != NULL) {
166 1389 : *tombstoned = false;
167 1389 : ret = dsdb_search_one(samdb, mem_ctx, &msg, dn,
168 : LDB_SCOPE_BASE, attrs, 0,
169 : "(objectClass=dnsNode)");
170 : } else {
171 65494 : ret = dsdb_search_one(samdb, mem_ctx, &msg, dn,
172 : LDB_SCOPE_BASE, attrs, 0,
173 : "(&(objectClass=dnsNode)(!(dNSTombstoned=TRUE)))");
174 : }
175 66883 : if (ret == LDB_ERR_NO_SUCH_OBJECT) {
176 19071 : werr = WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
177 19071 : goto exit;
178 : }
179 47812 : if (ret != LDB_SUCCESS) {
180 : /* TODO: we need to check if there's a glue record we need to
181 : * create a referral to */
182 0 : werr = DNS_ERR(NAME_ERROR);
183 0 : goto exit;
184 : }
185 :
186 47812 : if (tombstoned != NULL) {
187 1047 : *tombstoned = ldb_msg_find_attr_as_bool(msg,
188 : "dNSTombstoned", false);
189 : }
190 :
191 47812 : el = ldb_msg_find_element(msg, "dnsRecord");
192 47812 : if (el == NULL) {
193 2 : TALLOC_FREE(msg);
194 : /*
195 : * records produced by older Samba releases
196 : * keep dnsNode objects without dnsRecord and
197 : * without setting dNSTombstoned=TRUE.
198 : *
199 : * We just pretend they're tombstones.
200 : */
201 2 : if (tombstoned != NULL) {
202 : struct dnsp_DnssrvRpcRecord *recs;
203 2 : recs = talloc_array(mem_ctx,
204 : struct dnsp_DnssrvRpcRecord,
205 : 1);
206 2 : if (recs == NULL) {
207 0 : werr = WERR_NOT_ENOUGH_MEMORY;
208 0 : goto exit;
209 : }
210 2 : recs[0] = (struct dnsp_DnssrvRpcRecord) {
211 : .wType = DNS_TYPE_TOMBSTONE,
212 : /*
213 : * A value of timestamp != 0
214 : * indicated that the object was already
215 : * a tombstone, this will be used
216 : * in dns_common_replace()
217 : */
218 : .data.EntombedTime = 1,
219 : };
220 :
221 2 : *tombstoned = true;
222 2 : *records = recs;
223 2 : *num_records = 1;
224 2 : werr = WERR_OK;
225 2 : goto exit;
226 : } else {
227 : /*
228 : * Because we are not looking for a tombstone
229 : * in this codepath, we just pretend it does
230 : * not exist at all.
231 : */
232 0 : werr = WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
233 0 : goto exit;
234 : }
235 : }
236 :
237 47810 : werr = dns_common_extract(samdb, el, mem_ctx, records, num_records);
238 47810 : TALLOC_FREE(msg);
239 47810 : if (!W_ERROR_IS_OK(werr)) {
240 0 : goto exit;
241 : }
242 :
243 47810 : werr = WERR_OK;
244 66883 : exit:
245 66883 : DNS_COMMON_LOG_OPERATION(
246 : win_errstr(werr),
247 : &start,
248 : NULL,
249 : dn == NULL ? NULL : ldb_dn_get_linearized(dn),
250 : NULL);
251 66883 : return werr;
252 : }
253 :
254 : /*
255 : * Build an ldb_parse_tree node for an equality check
256 : *
257 : * Note: name is assumed to have been validated by dns_name_check
258 : * so will be zero terminated and of a reasonable size.
259 : */
260 38060 : static struct ldb_parse_tree *build_equality_operation(
261 : TALLOC_CTX *mem_ctx,
262 : bool add_asterix, /* prepend an '*' to the name */
263 : const uint8_t *name, /* the value being matched */
264 : const char *attr, /* the attribute to check name against */
265 : size_t size) /* length of name */
266 : {
267 :
268 38060 : struct ldb_parse_tree *el = NULL; /* Equality node being built */
269 38060 : struct ldb_val *value = NULL; /* Value the attr will be compared
270 : with */
271 38060 : size_t length = 0; /* calculated length of the value
272 : including option '*' prefix and
273 : '\0' string terminator */
274 :
275 38060 : el = talloc(mem_ctx, struct ldb_parse_tree);
276 38060 : if (el == NULL) {
277 0 : DBG_ERR("Unable to allocate ldb_parse_tree\n");
278 0 : return NULL;
279 : }
280 :
281 38060 : el->operation = LDB_OP_EQUALITY;
282 38060 : el->u.equality.attr = talloc_strdup(mem_ctx, attr);
283 38060 : value = &el->u.equality.value;
284 38060 : length = (add_asterix) ? size + 2 : size + 1;
285 38060 : value->data = talloc_zero_array(el, uint8_t, length);
286 38060 : if (value->data == NULL) {
287 0 : DBG_ERR("Unable to allocate value->data\n");
288 0 : TALLOC_FREE(el);
289 0 : return NULL;
290 : }
291 :
292 38060 : value->length = length;
293 38060 : if (add_asterix) {
294 19512 : value->data[0] = '*';
295 19512 : if (name != NULL) {
296 964 : memcpy(&value->data[1], name, size);
297 : }
298 18548 : } else if (name != NULL) {
299 18548 : memcpy(value->data, name, size);
300 : }
301 38060 : return el;
302 : }
303 :
304 : /*
305 : * Determine the number of levels in name
306 : * essentially the number of '.'s in the name + 1
307 : *
308 : * name is assumed to have been validated by dns_name_check
309 : */
310 18548 : static unsigned int number_of_labels(const struct ldb_val *name) {
311 18548 : int x = 0;
312 18548 : unsigned int labels = 1;
313 680832 : for (x = 0; x < name->length; x++) {
314 662284 : if (name->data[x] == '.') {
315 964 : labels++;
316 : }
317 : }
318 18548 : return labels;
319 : }
320 : /*
321 : * Build a query that matches the target name, and any possible
322 : * DNS wild card entries
323 : *
324 : * Builds a parse tree equivalent to the example query.
325 : *
326 : * x.y.z -> (|(name=x.y.z)(name=\2a.y.z)(name=\2a.z)(name=\2a))
327 : *
328 : * The attribute 'name' is used as this is what the LDB index is on
329 : * (the RDN, being 'dc' in this use case, does not have an index in
330 : * the AD schema).
331 : *
332 : * Returns NULL if unable to build the query.
333 : *
334 : * The first component of the DN is assumed to be the name being looked up
335 : * and also that it has been validated by dns_name_check
336 : *
337 : */
338 : #define BASE "(&(objectClass=dnsNode)(!(dNSTombstoned=TRUE))(|(a=b)(c=d)))"
339 18548 : static struct ldb_parse_tree *build_wildcard_query(
340 : TALLOC_CTX *mem_ctx,
341 : struct ldb_dn *dn)
342 : {
343 18548 : const struct ldb_val *name = NULL; /* The DNS name being
344 : queried */
345 18548 : const char *attr = "name"; /* The attribute name */
346 18548 : struct ldb_parse_tree *query = NULL; /* The constructed query
347 : parse tree*/
348 18548 : struct ldb_parse_tree *wildcard_query = NULL; /* The parse tree for the
349 : name and wild card
350 : entries */
351 18548 : int labels = 0; /* The number of labels in the name */
352 :
353 18548 : name = ldb_dn_get_rdn_val(dn);
354 18548 : if (name == NULL) {
355 0 : DBG_ERR("Unable to get domain name value\n");
356 0 : return NULL;
357 : }
358 18548 : labels = number_of_labels(name);
359 :
360 18548 : query = ldb_parse_tree(mem_ctx, BASE);
361 18548 : if (query == NULL) {
362 0 : DBG_ERR("Unable to parse query %s\n", BASE);
363 0 : return NULL;
364 : }
365 :
366 : /*
367 : * The 3rd element of BASE is a place holder which is replaced with
368 : * the actual wild card query
369 : */
370 18548 : wildcard_query = query->u.list.elements[2];
371 18548 : TALLOC_FREE(wildcard_query->u.list.elements);
372 :
373 18548 : wildcard_query->u.list.num_elements = labels + 1;
374 18548 : wildcard_query->u.list.elements = talloc_array(
375 : wildcard_query,
376 : struct ldb_parse_tree *,
377 : labels + 1);
378 : /*
379 : * Build the wild card query
380 : */
381 : {
382 18548 : int x = 0; /* current character in the name */
383 18548 : int l = 0; /* current equality operator index in elements */
384 18548 : struct ldb_parse_tree *el = NULL; /* Equality operator being
385 : built */
386 18548 : bool add_asterix = true; /* prepend an '*' to the value */
387 38060 : for (l = 0, x = 0; l < labels && x < name->length; l++) {
388 19512 : unsigned int size = name->length - x;
389 19512 : add_asterix = (name->data[x] == '.');
390 58430 : el = build_equality_operation(
391 : mem_ctx,
392 : add_asterix,
393 38971 : &name->data[x],
394 : attr,
395 : size);
396 19512 : if (el == NULL) {
397 0 : return NULL; /* Reason will have been logged */
398 : }
399 19512 : wildcard_query->u.list.elements[l] = el;
400 :
401 : /* skip to the start of the next label */
402 19512 : x++;
403 19760 : for (;x < name->length && name->data[x] != '.'; x++);
404 : }
405 :
406 : /* Add the base level "*" only query */
407 18548 : el = build_equality_operation(mem_ctx, true, NULL, attr, 0);
408 18548 : if (el == NULL) {
409 0 : TALLOC_FREE(query);
410 0 : return NULL; /* Reason will have been logged */
411 : }
412 18548 : wildcard_query->u.list.elements[l] = el;
413 : }
414 18548 : return query;
415 : }
416 :
417 : /*
418 : * Scan the list of records matching a dns wildcard query and return the
419 : * best match.
420 : *
421 : * The best match is either an exact name match, or the longest wild card
422 : * entry returned
423 : *
424 : * i.e. name = a.b.c candidates *.b.c, *.c, - *.b.c would be selected
425 : * name = a.b.c candidates a.b.c, *.b.c, *.c - a.b.c would be selected
426 : */
427 0 : static struct ldb_message *get_best_match(struct ldb_dn *dn,
428 : struct ldb_result *result)
429 : {
430 0 : int matched = 0; /* Index of the current best match in result */
431 0 : size_t length = 0; /* The length of the current candidate */
432 0 : const struct ldb_val *target = NULL; /* value we're looking for */
433 0 : const struct ldb_val *candidate = NULL; /* current candidate value */
434 0 : int x = 0;
435 :
436 0 : target = ldb_dn_get_rdn_val(dn);
437 0 : for(x = 0; x < result->count; x++) {
438 0 : candidate = ldb_dn_get_rdn_val(result->msgs[x]->dn);
439 0 : if (strncasecmp((char *) target->data,
440 0 : (char *) candidate->data,
441 0 : target->length) == 0) {
442 : /* Exact match stop searching and return */
443 0 : return result->msgs[x];
444 : }
445 0 : if (candidate->length > length) {
446 0 : matched = x;
447 0 : length = candidate->length;
448 : }
449 : }
450 0 : return result->msgs[matched];
451 : }
452 :
453 : /*
454 : * Look up a DNS entry, if an exact match does not exist, return the
455 : * closest matching DNS wildcard entry if available
456 : *
457 : * Returns: LDB_ERR_NO_SUCH_OBJECT If no matching record exists
458 : * LDB_ERR_OPERATIONS_ERROR If the query fails
459 : * LDB_SUCCESS If a matching record was retrieved
460 : *
461 : */
462 18548 : static int dns_wildcard_lookup(struct ldb_context *samdb,
463 : TALLOC_CTX *mem_ctx,
464 : struct ldb_dn *dn,
465 : struct ldb_message **msg)
466 : {
467 : static const char * const attrs[] = {
468 : "dnsRecord",
469 : "dNSTombstoned",
470 : NULL
471 : };
472 18548 : struct ldb_dn *parent = NULL; /* The parent dn */
473 18548 : struct ldb_result *result = NULL; /* Results of the search */
474 : int ret; /* Return code */
475 18548 : struct ldb_parse_tree *query = NULL; /* The query to run */
476 18548 : struct ldb_request *request = NULL; /* LDB request for the query op */
477 18548 : struct ldb_message *match = NULL; /* the best matching DNS record */
478 18548 : TALLOC_CTX *frame = talloc_stackframe();
479 :
480 18548 : parent = ldb_dn_get_parent(frame, dn);
481 18548 : if (parent == NULL) {
482 0 : DBG_ERR("Unable to extract parent from dn\n");
483 0 : TALLOC_FREE(frame);
484 0 : return LDB_ERR_OPERATIONS_ERROR;
485 : }
486 :
487 18548 : query = build_wildcard_query(frame, dn);
488 18548 : if (query == NULL) {
489 0 : TALLOC_FREE(frame);
490 0 : return LDB_ERR_OPERATIONS_ERROR;
491 : }
492 :
493 18548 : result = talloc_zero(mem_ctx, struct ldb_result);
494 18548 : if (result == NULL) {
495 0 : TALLOC_FREE(frame);
496 0 : DBG_ERR("Unable to allocate ldb_result\n");
497 0 : return LDB_ERR_OPERATIONS_ERROR;
498 : }
499 :
500 18548 : ret = ldb_build_search_req_ex(&request,
501 : samdb,
502 : frame,
503 : parent,
504 : LDB_SCOPE_SUBTREE,
505 : query,
506 : attrs,
507 : NULL,
508 : result,
509 : ldb_search_default_callback,
510 : NULL);
511 18548 : if (ret != LDB_SUCCESS) {
512 0 : TALLOC_FREE(frame);
513 0 : DBG_ERR("ldb_build_search_req_ex returned %d\n", ret);
514 0 : return ret;
515 : }
516 :
517 18548 : ret = ldb_request(samdb, request);
518 18548 : if (ret != LDB_SUCCESS) {
519 0 : TALLOC_FREE(frame);
520 0 : return ret;
521 : }
522 :
523 18548 : ret = ldb_wait(request->handle, LDB_WAIT_ALL);
524 18548 : if (ret != LDB_SUCCESS) {
525 10 : TALLOC_FREE(frame);
526 10 : return ret;
527 : }
528 :
529 18538 : if (result->count == 0) {
530 18538 : TALLOC_FREE(frame);
531 18538 : return LDB_ERR_NO_SUCH_OBJECT;
532 : }
533 :
534 0 : match = get_best_match(dn, result);
535 0 : if (match == NULL) {
536 0 : TALLOC_FREE(frame);
537 0 : return LDB_ERR_OPERATIONS_ERROR;
538 : }
539 :
540 0 : *msg = talloc_move(mem_ctx, &match);
541 0 : TALLOC_FREE(frame);
542 0 : return LDB_SUCCESS;
543 : }
544 :
545 : /*
546 : * Lookup a DNS record, will match DNS wild card records if an exact match
547 : * is not found.
548 : */
549 35668 : WERROR dns_common_wildcard_lookup(struct ldb_context *samdb,
550 : TALLOC_CTX *mem_ctx,
551 : struct ldb_dn *dn,
552 : struct dnsp_DnssrvRpcRecord **records,
553 : uint16_t *num_records)
554 : {
555 35668 : const struct timeval start = timeval_current();
556 : int ret;
557 35668 : WERROR werr = WERR_OK;
558 35668 : struct ldb_message *msg = NULL;
559 35668 : struct ldb_message_element *el = NULL;
560 35668 : const struct ldb_val *name = NULL;
561 :
562 35668 : *records = NULL;
563 35668 : *num_records = 0;
564 :
565 35668 : name = ldb_dn_get_rdn_val(dn);
566 35668 : if (name == NULL) {
567 0 : werr = DNS_ERR(NAME_ERROR);
568 0 : goto exit;
569 : }
570 :
571 : /* Don't look for a wildcard for @ */
572 35668 : if (name->length == 1 && name->data[0] == '@') {
573 880 : werr = dns_common_lookup(samdb,
574 : mem_ctx,
575 : dn,
576 : records,
577 : num_records,
578 : NULL);
579 880 : goto exit;
580 : }
581 :
582 34788 : werr = dns_name_check(
583 : mem_ctx,
584 34788 : strlen((const char*)name->data),
585 34788 : (const char*) name->data);
586 34788 : if (!W_ERROR_IS_OK(werr)) {
587 0 : goto exit;
588 : }
589 :
590 : /*
591 : * Do a point search first, then fall back to a wildcard
592 : * lookup if it does not exist
593 : */
594 34788 : werr = dns_common_lookup(samdb,
595 : mem_ctx,
596 : dn,
597 : records,
598 : num_records,
599 : NULL);
600 34788 : if (!W_ERROR_EQUAL(werr, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST)) {
601 16240 : goto exit;
602 : }
603 :
604 18548 : ret = dns_wildcard_lookup(samdb, mem_ctx, dn, &msg);
605 18548 : if (ret == LDB_ERR_OPERATIONS_ERROR) {
606 0 : werr = DNS_ERR(SERVER_FAILURE);
607 0 : goto exit;
608 : }
609 18548 : if (ret != LDB_SUCCESS) {
610 18548 : werr = DNS_ERR(NAME_ERROR);
611 18548 : goto exit;
612 : }
613 :
614 0 : el = ldb_msg_find_element(msg, "dnsRecord");
615 0 : if (el == NULL) {
616 0 : werr = WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
617 0 : goto exit;
618 : }
619 :
620 0 : werr = dns_common_extract(samdb, el, mem_ctx, records, num_records);
621 0 : TALLOC_FREE(msg);
622 0 : if (!W_ERROR_IS_OK(werr)) {
623 0 : goto exit;
624 : }
625 :
626 0 : werr = WERR_OK;
627 35668 : exit:
628 35668 : DNS_COMMON_LOG_OPERATION(
629 : win_errstr(werr),
630 : &start,
631 : NULL,
632 : dn == NULL ? NULL : ldb_dn_get_linearized(dn),
633 : NULL);
634 35668 : return werr;
635 : }
636 :
637 7016 : static int rec_cmp(const struct dnsp_DnssrvRpcRecord *r1,
638 : const struct dnsp_DnssrvRpcRecord *r2)
639 : {
640 7016 : if (r1->wType != r2->wType) {
641 : /*
642 : * The records are sorted with higher types first,
643 : * which puts tombstones (type 0) last.
644 : */
645 906 : return r2->wType - r1->wType;
646 : }
647 : /*
648 : * Then we need to sort from the oldest to newest timestamp.
649 : *
650 : * Note that dwTimeStamp == 0 (never expiring) records come first,
651 : * then the ones whose expiry is soonest.
652 : */
653 6110 : return r1->dwTimeStamp - r2->dwTimeStamp;
654 : }
655 :
656 : /*
657 : * Check for valid DNS names. These are names which:
658 : * - are non-empty
659 : * - do not start with a dot
660 : * - do not have any empty labels
661 : * - have no more than 127 labels
662 : * - are no longer than 253 characters
663 : * - none of the labels exceed 63 characters
664 : */
665 104998 : WERROR dns_name_check(TALLOC_CTX *mem_ctx, size_t len, const char *name)
666 : {
667 : size_t i;
668 104998 : unsigned int labels = 0;
669 104998 : unsigned int label_len = 0;
670 :
671 104998 : if (len == 0) {
672 18 : return WERR_DS_INVALID_DN_SYNTAX;
673 : }
674 :
675 104980 : if (len > 1 && name[0] == '.') {
676 60 : return WERR_DS_INVALID_DN_SYNTAX;
677 : }
678 :
679 104920 : if ((len - 1) > DNS_MAX_DOMAIN_LENGTH) {
680 0 : return WERR_DS_INVALID_DN_SYNTAX;
681 : }
682 :
683 3924380 : for (i = 0; i < len - 1; i++) {
684 3819480 : if (name[i] == '.' && name[i+1] == '.') {
685 20 : return WERR_DS_INVALID_DN_SYNTAX;
686 : }
687 3819460 : if (name[i] == '.') {
688 269300 : labels++;
689 269300 : if (labels > DNS_MAX_LABELS) {
690 0 : return WERR_DS_INVALID_DN_SYNTAX;
691 : }
692 269300 : label_len = 0;
693 : } else {
694 3550160 : label_len++;
695 3550160 : if (label_len > DNS_MAX_LABEL_LENGTH) {
696 0 : return WERR_DS_INVALID_DN_SYNTAX;
697 : }
698 : }
699 : }
700 :
701 104900 : return WERR_OK;
702 : }
703 :
704 2064 : static WERROR check_name_list(TALLOC_CTX *mem_ctx, uint16_t rec_count,
705 : struct dnsp_DnssrvRpcRecord *records)
706 : {
707 : WERROR werr;
708 : uint16_t i;
709 : size_t len;
710 : struct dnsp_DnssrvRpcRecord record;
711 :
712 2064 : werr = WERR_OK;
713 7128 : for (i = 0; i < rec_count; i++) {
714 5066 : record = records[i];
715 :
716 5066 : switch (record.wType) {
717 :
718 70 : case DNS_TYPE_NS:
719 70 : len = strlen(record.data.ns);
720 70 : werr = dns_name_check(mem_ctx, len, record.data.ns);
721 70 : break;
722 43 : case DNS_TYPE_CNAME:
723 43 : len = strlen(record.data.cname);
724 43 : werr = dns_name_check(mem_ctx, len, record.data.cname);
725 43 : break;
726 85 : case DNS_TYPE_SOA:
727 85 : len = strlen(record.data.soa.mname);
728 85 : werr = dns_name_check(mem_ctx, len, record.data.soa.mname);
729 85 : if (!W_ERROR_IS_OK(werr)) {
730 0 : break;
731 : }
732 85 : len = strlen(record.data.soa.rname);
733 85 : werr = dns_name_check(mem_ctx, len, record.data.soa.rname);
734 85 : break;
735 33 : case DNS_TYPE_PTR:
736 33 : len = strlen(record.data.ptr);
737 33 : werr = dns_name_check(mem_ctx, len, record.data.ptr);
738 33 : break;
739 34 : case DNS_TYPE_MX:
740 34 : len = strlen(record.data.mx.nameTarget);
741 34 : werr = dns_name_check(mem_ctx, len, record.data.mx.nameTarget);
742 34 : break;
743 919 : case DNS_TYPE_SRV:
744 919 : len = strlen(record.data.srv.nameTarget);
745 919 : werr = dns_name_check(mem_ctx, len,
746 : record.data.srv.nameTarget);
747 919 : break;
748 : /*
749 : * In the default case, the record doesn't have a DN, so it
750 : * must be ok.
751 : */
752 3882 : default:
753 3882 : break;
754 : }
755 :
756 5066 : if (!W_ERROR_IS_OK(werr)) {
757 2 : return werr;
758 : }
759 : }
760 :
761 2062 : return WERR_OK;
762 : }
763 :
764 1395 : bool dns_name_is_static(struct dnsp_DnssrvRpcRecord *records,
765 : uint16_t rec_count)
766 : {
767 1395 : int i = 0;
768 4749 : for (i = 0; i < rec_count; i++) {
769 3614 : if (records[i].wType == DNS_TYPE_TOMBSTONE) {
770 19 : continue;
771 : }
772 :
773 5504 : if (records[i].wType == DNS_TYPE_SOA ||
774 3585 : records[i].dwTimeStamp == 0) {
775 260 : return true;
776 : }
777 : }
778 1135 : return false;
779 : }
780 :
781 : /*
782 : * Helper function to copy a dnsp_ip4_array struct to an IP4_ARRAY struct.
783 : * The new structure and it's data are allocated on the supplied talloc context
784 : */
785 0 : static struct IP4_ARRAY *copy_ip4_array(TALLOC_CTX *ctx,
786 : const char *name,
787 : struct dnsp_ip4_array array)
788 : {
789 :
790 0 : struct IP4_ARRAY *ip4_array = NULL;
791 : unsigned int i;
792 :
793 0 : ip4_array = talloc_zero(ctx, struct IP4_ARRAY);
794 0 : if (ip4_array == NULL) {
795 0 : DBG_ERR("Out of memory copying property [%s]\n", name);
796 0 : return NULL;
797 : }
798 :
799 0 : ip4_array->AddrCount = array.addrCount;
800 0 : if (ip4_array->AddrCount == 0) {
801 0 : return ip4_array;
802 : }
803 :
804 0 : ip4_array->AddrArray =
805 0 : talloc_array(ip4_array, uint32_t, ip4_array->AddrCount);
806 0 : if (ip4_array->AddrArray == NULL) {
807 0 : TALLOC_FREE(ip4_array);
808 0 : DBG_ERR("Out of memory copying property [%s] values\n", name);
809 0 : return NULL;
810 : }
811 :
812 0 : for (i = 0; i < ip4_array->AddrCount; i++) {
813 0 : ip4_array->AddrArray[i] = array.addrArray[i];
814 : }
815 :
816 0 : return ip4_array;
817 : }
818 :
819 40287 : bool dns_zoneinfo_load_zone_property(struct dnsserver_zoneinfo *zoneinfo,
820 : struct dnsp_DnsProperty *prop)
821 : {
822 40287 : switch (prop->id) {
823 5755 : case DSPROPERTY_ZONE_TYPE:
824 5755 : zoneinfo->dwZoneType = prop->data.zone_type;
825 5755 : break;
826 5757 : case DSPROPERTY_ZONE_ALLOW_UPDATE:
827 5757 : zoneinfo->fAllowUpdate = prop->data.allow_update_flag;
828 5757 : break;
829 5755 : case DSPROPERTY_ZONE_NOREFRESH_INTERVAL:
830 5755 : zoneinfo->dwNoRefreshInterval = prop->data.norefresh_hours;
831 5755 : break;
832 5755 : case DSPROPERTY_ZONE_REFRESH_INTERVAL:
833 5755 : zoneinfo->dwRefreshInterval = prop->data.refresh_hours;
834 5755 : break;
835 5755 : case DSPROPERTY_ZONE_AGING_STATE:
836 5755 : zoneinfo->fAging = prop->data.aging_enabled;
837 5755 : break;
838 0 : case DSPROPERTY_ZONE_SCAVENGING_SERVERS:
839 0 : zoneinfo->aipScavengeServers = copy_ip4_array(
840 : zoneinfo, "ZONE_SCAVENGING_SERVERS", prop->data.servers);
841 0 : if (zoneinfo->aipScavengeServers == NULL) {
842 0 : return false;
843 : }
844 0 : break;
845 5755 : case DSPROPERTY_ZONE_AGING_ENABLED_TIME:
846 5755 : zoneinfo->dwAvailForScavengeTime =
847 5755 : prop->data.next_scavenging_cycle_hours;
848 5755 : break;
849 0 : case DSPROPERTY_ZONE_MASTER_SERVERS:
850 0 : zoneinfo->aipLocalMasters = copy_ip4_array(
851 : zoneinfo, "ZONE_MASTER_SERVERS", prop->data.master_servers);
852 0 : if (zoneinfo->aipLocalMasters == NULL) {
853 0 : return false;
854 : }
855 0 : break;
856 5755 : case DSPROPERTY_ZONE_EMPTY:
857 : case DSPROPERTY_ZONE_SECURE_TIME:
858 : case DSPROPERTY_ZONE_DELETED_FROM_HOSTNAME:
859 : case DSPROPERTY_ZONE_AUTO_NS_SERVERS:
860 : case DSPROPERTY_ZONE_DCPROMO_CONVERT:
861 : case DSPROPERTY_ZONE_SCAVENGING_SERVERS_DA:
862 : case DSPROPERTY_ZONE_MASTER_SERVERS_DA:
863 : case DSPROPERTY_ZONE_NS_SERVERS_DA:
864 : case DSPROPERTY_ZONE_NODE_DBFLAGS:
865 5755 : break;
866 : }
867 40287 : return true;
868 : }
869 2082 : WERROR dns_get_zone_properties(struct ldb_context *samdb,
870 : TALLOC_CTX *mem_ctx,
871 : struct ldb_dn *zone_dn,
872 : struct dnsserver_zoneinfo *zoneinfo)
873 : {
874 :
875 : int ret, i;
876 2082 : struct dnsp_DnsProperty *prop = NULL;
877 2082 : struct ldb_message_element *element = NULL;
878 2082 : const char *const attrs[] = {"dNSProperty", NULL};
879 2082 : struct ldb_result *res = NULL;
880 : enum ndr_err_code err;
881 :
882 2082 : ret = ldb_search(samdb,
883 : mem_ctx,
884 : &res,
885 : zone_dn,
886 : LDB_SCOPE_BASE,
887 : attrs,
888 : "(objectClass=dnsZone)");
889 2082 : if (ret != LDB_SUCCESS) {
890 0 : DBG_ERR("dnsserver: Failed to find DNS zone: %s\n",
891 : ldb_dn_get_linearized(zone_dn));
892 0 : return DNS_ERR(SERVER_FAILURE);
893 : }
894 :
895 2082 : element = ldb_msg_find_element(res->msgs[0], "dNSProperty");
896 2082 : if (element == NULL) {
897 264 : return DNS_ERR(NOTZONE);
898 : }
899 :
900 14534 : for (i = 0; i < element->num_values; i++) {
901 : bool valid_property;
902 12716 : prop = talloc_zero(mem_ctx, struct dnsp_DnsProperty);
903 12716 : if (prop == NULL) {
904 0 : return WERR_NOT_ENOUGH_MEMORY;
905 : }
906 12716 : err = ndr_pull_struct_blob(
907 12716 : &(element->values[i]),
908 : mem_ctx,
909 : prop,
910 : (ndr_pull_flags_fn_t)ndr_pull_dnsp_DnsProperty);
911 12716 : if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
912 : /*
913 : * If we can't pull it, then there is no valid
914 : * data to load into the zone, so ignore this
915 : * as Micosoft does. Windows can load an
916 : * invalid property with a zero length into
917 : * the dnsProperty attribute.
918 : */
919 2 : continue;
920 : }
921 :
922 8485 : valid_property =
923 4229 : dns_zoneinfo_load_zone_property(zoneinfo, prop);
924 12714 : if (!valid_property) {
925 0 : return DNS_ERR(SERVER_FAILURE);
926 : }
927 : }
928 :
929 1818 : return WERR_OK;
930 : }
931 :
932 2064 : WERROR dns_common_replace(struct ldb_context *samdb,
933 : TALLOC_CTX *mem_ctx,
934 : struct ldb_dn *dn,
935 : bool needs_add,
936 : uint32_t serial,
937 : struct dnsp_DnssrvRpcRecord *records,
938 : uint16_t rec_count)
939 : {
940 2064 : const struct timeval start = timeval_current();
941 : struct ldb_message_element *el;
942 : uint16_t i;
943 : int ret;
944 : WERROR werr;
945 2064 : struct ldb_message *msg = NULL;
946 2064 : bool was_tombstoned = false;
947 2064 : bool become_tombstoned = false;
948 2064 : struct ldb_dn *zone_dn = NULL;
949 2064 : struct dnsserver_zoneinfo *zoneinfo = NULL;
950 : uint32_t t;
951 :
952 2064 : msg = ldb_msg_new(mem_ctx);
953 2064 : W_ERROR_HAVE_NO_MEMORY(msg);
954 :
955 2064 : msg->dn = dn;
956 :
957 2064 : zone_dn = ldb_dn_copy(mem_ctx, dn);
958 2064 : if (zone_dn == NULL) {
959 0 : werr = WERR_NOT_ENOUGH_MEMORY;
960 0 : goto exit;
961 : }
962 2064 : if (!ldb_dn_remove_child_components(zone_dn, 1)) {
963 0 : werr = DNS_ERR(SERVER_FAILURE);
964 0 : goto exit;
965 : }
966 2064 : zoneinfo = talloc(mem_ctx, struct dnsserver_zoneinfo);
967 2064 : if (zoneinfo == NULL) {
968 0 : werr = WERR_NOT_ENOUGH_MEMORY;
969 0 : goto exit;
970 : }
971 2064 : werr = dns_get_zone_properties(samdb, mem_ctx, zone_dn, zoneinfo);
972 2064 : if (W_ERROR_EQUAL(DNS_ERR(NOTZONE), werr)) {
973 : /*
974 : * We only got zoneinfo for aging so if we didn't find any
975 : * properties then just disable aging and keep going.
976 : */
977 258 : zoneinfo->fAging = 0;
978 1806 : } else if (!W_ERROR_IS_OK(werr)) {
979 0 : goto exit;
980 : }
981 :
982 2064 : werr = check_name_list(mem_ctx, rec_count, records);
983 2064 : if (!W_ERROR_IS_OK(werr)) {
984 2 : goto exit;
985 : }
986 :
987 2062 : ret = ldb_msg_add_empty(msg, "dnsRecord", LDB_FLAG_MOD_REPLACE, &el);
988 2062 : if (ret != LDB_SUCCESS) {
989 0 : werr = DNS_ERR(SERVER_FAILURE);
990 0 : goto exit;
991 : }
992 :
993 : /*
994 : * we have at least one value,
995 : * which might be used for the tombstone marker
996 : */
997 2062 : el->values = talloc_zero_array(el, struct ldb_val, MAX(1, rec_count));
998 2062 : if (el->values == NULL) {
999 0 : werr = WERR_NOT_ENOUGH_MEMORY;
1000 0 : goto exit;
1001 : }
1002 :
1003 2062 : if (rec_count > 1) {
1004 : /*
1005 : * We store a sorted list with the high wType values first
1006 : * that's what windows does. It also simplifies the
1007 : * filtering of DNS_TYPE_TOMBSTONE records
1008 : */
1009 958 : TYPESAFE_QSORT(records, rec_count, rec_cmp);
1010 : }
1011 :
1012 7126 : for (i = 0; i < rec_count; i++) {
1013 5064 : struct ldb_val *v = &el->values[el->num_values];
1014 : enum ndr_err_code ndr_err;
1015 :
1016 5064 : if (records[i].wType == DNS_TYPE_TOMBSTONE) {
1017 : /*
1018 : * There are two things that could be going on here.
1019 : *
1020 : * 1. We use a tombstone with EntombedTime == 0 for
1021 : * passing deletion messages through the stack, and
1022 : * this is the place we filter them out to perform
1023 : * that deletion.
1024 : *
1025 : * 2. This node is tombstoned, with no records except
1026 : * for a single tombstone, and it is just waiting to
1027 : * disappear. In this case, unless the caller has
1028 : * added a record, rec_count should be 1, and
1029 : * el->num_values will end up at 0, and we will make
1030 : * no changes. But if the caller has added a record,
1031 : * we need to un-tombstone the node.
1032 : *
1033 : * It is not possible to add an explicit tombstone
1034 : * record.
1035 : */
1036 183 : if (records[i].data.EntombedTime != 0) {
1037 20 : was_tombstoned = true;
1038 : }
1039 183 : continue;
1040 : }
1041 :
1042 4881 : if (zoneinfo->fAging == 1 && records[i].dwTimeStamp != 0) {
1043 654 : t = unix_to_dns_timestamp(time(NULL));
1044 997 : if (t - records[i].dwTimeStamp >
1045 654 : zoneinfo->dwNoRefreshInterval) {
1046 128 : records[i].dwTimeStamp = t;
1047 : }
1048 : }
1049 :
1050 4881 : records[i].dwSerial = serial;
1051 4881 : ndr_err = ndr_push_struct_blob(v, el->values, &records[i],
1052 : (ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
1053 4881 : if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1054 0 : DEBUG(0, ("Failed to push dnsp_DnssrvRpcRecord\n"));
1055 0 : werr = DNS_ERR(SERVER_FAILURE);
1056 0 : goto exit;
1057 : }
1058 4881 : el->num_values++;
1059 : }
1060 :
1061 2062 : if (needs_add) {
1062 : /*
1063 : * This is a new dnsNode, which simplifies everything as we
1064 : * know there is nothing to delete or change. We add the
1065 : * records and get out.
1066 : */
1067 340 : if (el->num_values == 0) {
1068 28 : werr = WERR_OK;
1069 28 : goto exit;
1070 : }
1071 :
1072 312 : ret = ldb_msg_add_string(msg, "objectClass", "dnsNode");
1073 312 : if (ret != LDB_SUCCESS) {
1074 0 : werr = DNS_ERR(SERVER_FAILURE);
1075 0 : goto exit;
1076 : }
1077 :
1078 312 : ret = ldb_add(samdb, msg);
1079 312 : if (ret != LDB_SUCCESS) {
1080 0 : werr = DNS_ERR(SERVER_FAILURE);
1081 0 : goto exit;
1082 : }
1083 :
1084 312 : werr = WERR_OK;
1085 312 : goto exit;
1086 : }
1087 :
1088 1722 : if (el->num_values == 0) {
1089 : /*
1090 : * We get here if there are no records or all the records were
1091 : * tombstones.
1092 : */
1093 : struct dnsp_DnssrvRpcRecord tbs;
1094 550 : struct ldb_val *v = &el->values[el->num_values];
1095 : enum ndr_err_code ndr_err;
1096 : struct timeval tv;
1097 :
1098 550 : if (was_tombstoned) {
1099 : /*
1100 : * This is already a tombstoned object.
1101 : * Just leave it instead of updating the time stamp.
1102 : */
1103 5 : werr = WERR_OK;
1104 8 : goto exit;
1105 : }
1106 :
1107 545 : tv = timeval_current();
1108 545 : tbs = (struct dnsp_DnssrvRpcRecord) {
1109 : .wType = DNS_TYPE_TOMBSTONE,
1110 : .dwSerial = serial,
1111 545 : .data.EntombedTime = timeval_to_nttime(&tv),
1112 : };
1113 :
1114 545 : ndr_err = ndr_push_struct_blob(v, el->values, &tbs,
1115 : (ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
1116 545 : if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1117 0 : DEBUG(0, ("Failed to push dnsp_DnssrvRpcRecord\n"));
1118 0 : werr = DNS_ERR(SERVER_FAILURE);
1119 0 : goto exit;
1120 : }
1121 545 : el->num_values++;
1122 :
1123 545 : become_tombstoned = true;
1124 : }
1125 :
1126 1717 : if (was_tombstoned || become_tombstoned) {
1127 560 : ret = ldb_msg_append_fmt(msg, LDB_FLAG_MOD_REPLACE,
1128 : "dNSTombstoned", "%s",
1129 : become_tombstoned ? "TRUE" : "FALSE");
1130 560 : if (ret != LDB_SUCCESS) {
1131 0 : werr = DNS_ERR(SERVER_FAILURE);
1132 0 : goto exit;
1133 : }
1134 : }
1135 :
1136 1717 : ret = ldb_modify(samdb, msg);
1137 1717 : if (ret != LDB_SUCCESS) {
1138 2 : NTSTATUS nt = dsdb_ldb_err_to_ntstatus(ret);
1139 2 : werr = ntstatus_to_werror(nt);
1140 2 : goto exit;
1141 : }
1142 :
1143 1715 : werr = WERR_OK;
1144 2064 : exit:
1145 2064 : talloc_free(msg);
1146 2064 : DNS_COMMON_LOG_OPERATION(
1147 : win_errstr(werr),
1148 : &start,
1149 : NULL,
1150 : dn == NULL ? NULL : ldb_dn_get_linearized(dn),
1151 : NULL);
1152 2064 : return werr;
1153 : }
1154 :
1155 163774 : bool dns_name_match(const char *zone, const char *name, size_t *host_part_len)
1156 : {
1157 163774 : size_t zl = strlen(zone);
1158 163774 : size_t nl = strlen(name);
1159 : ssize_t zi, ni;
1160 : static const size_t fixup = 'a' - 'A';
1161 :
1162 163774 : if (zl > nl) {
1163 7570 : return false;
1164 : }
1165 :
1166 4321724 : for (zi = zl, ni = nl; zi >= 0; zi--, ni--) {
1167 4185744 : char zc = zone[zi];
1168 4185744 : char nc = name[ni];
1169 :
1170 : /* convert to lower case */
1171 4185744 : if (zc >= 'A' && zc <= 'Z') {
1172 2024 : zc += fixup;
1173 : }
1174 4185744 : if (nc >= 'A' && nc <= 'Z') {
1175 27593 : nc += fixup;
1176 : }
1177 :
1178 4185744 : if (zc != nc) {
1179 20224 : return false;
1180 : }
1181 : }
1182 :
1183 135980 : if (ni >= 0) {
1184 101271 : if (name[ni] != '.') {
1185 0 : return false;
1186 : }
1187 :
1188 101271 : ni--;
1189 : }
1190 :
1191 135980 : *host_part_len = ni+1;
1192 :
1193 135980 : return true;
1194 : }
1195 :
1196 68198 : WERROR dns_common_name2dn(struct ldb_context *samdb,
1197 : struct dns_server_zone *zones,
1198 : TALLOC_CTX *mem_ctx,
1199 : const char *name,
1200 : struct ldb_dn **_dn)
1201 : {
1202 : struct ldb_dn *base;
1203 : struct ldb_dn *dn;
1204 : const struct dns_server_zone *z;
1205 68198 : size_t host_part_len = 0;
1206 : struct ldb_val host_part;
1207 : WERROR werr;
1208 : bool ok;
1209 68198 : const char *casefold = NULL;
1210 :
1211 68198 : if (name == NULL) {
1212 0 : return DNS_ERR(FORMAT_ERROR);
1213 : }
1214 :
1215 68198 : if (strcmp(name, "") == 0) {
1216 0 : base = ldb_get_default_basedn(samdb);
1217 0 : dn = ldb_dn_copy(mem_ctx, base);
1218 0 : ok = ldb_dn_add_child_fmt(dn,
1219 : "DC=@,DC=RootDNSServers,CN=MicrosoftDNS,CN=System");
1220 0 : if (ok == false) {
1221 0 : TALLOC_FREE(dn);
1222 0 : return WERR_NOT_ENOUGH_MEMORY;
1223 : }
1224 :
1225 0 : *_dn = dn;
1226 0 : return WERR_OK;
1227 : }
1228 :
1229 : /* Check non-empty names */
1230 68198 : werr = dns_name_check(mem_ctx, strlen(name), name);
1231 68198 : if (!W_ERROR_IS_OK(werr)) {
1232 0 : return werr;
1233 : }
1234 :
1235 82631 : for (z = zones; z != NULL; z = z->next) {
1236 : bool match;
1237 :
1238 82619 : match = dns_name_match(z->name, name, &host_part_len);
1239 82619 : if (match) {
1240 68186 : break;
1241 : }
1242 : }
1243 :
1244 68198 : if (z == NULL) {
1245 12 : return DNS_ERR(NAME_ERROR);
1246 : }
1247 :
1248 68186 : if (host_part_len == 0) {
1249 31506 : dn = ldb_dn_copy(mem_ctx, z->dn);
1250 31506 : ok = ldb_dn_add_child_fmt(dn, "DC=@");
1251 31506 : if (! ok) {
1252 0 : TALLOC_FREE(dn);
1253 0 : return WERR_NOT_ENOUGH_MEMORY;
1254 : }
1255 31506 : *_dn = dn;
1256 31506 : return WERR_OK;
1257 : }
1258 :
1259 36680 : dn = ldb_dn_copy(mem_ctx, z->dn);
1260 36680 : if (dn == NULL) {
1261 0 : TALLOC_FREE(dn);
1262 0 : return WERR_NOT_ENOUGH_MEMORY;
1263 : }
1264 :
1265 36680 : host_part = data_blob_const(name, host_part_len);
1266 :
1267 36680 : ok = ldb_dn_add_child_val(dn, "DC", host_part);
1268 :
1269 36680 : if (ok == false) {
1270 0 : TALLOC_FREE(dn);
1271 0 : return WERR_NOT_ENOUGH_MEMORY;
1272 : }
1273 :
1274 : /*
1275 : * Check the new DN here for validity, so as to catch errors
1276 : * early
1277 : */
1278 36680 : ok = ldb_dn_validate(dn);
1279 36680 : if (ok == false) {
1280 0 : TALLOC_FREE(dn);
1281 0 : return DNS_ERR(NAME_ERROR);
1282 : }
1283 :
1284 : /*
1285 : * The value from this check is saved in the DN, and doing
1286 : * this here allows an easy return here.
1287 : */
1288 36680 : casefold = ldb_dn_get_casefold(dn);
1289 36680 : if (casefold == NULL) {
1290 0 : TALLOC_FREE(dn);
1291 0 : return DNS_ERR(NAME_ERROR);
1292 : }
1293 :
1294 36680 : *_dn = dn;
1295 36680 : return WERR_OK;
1296 : }
1297 :
1298 :
1299 : /*
1300 : see if two dns records match
1301 : */
1302 :
1303 :
1304 7818 : bool dns_record_match(struct dnsp_DnssrvRpcRecord *rec1,
1305 : struct dnsp_DnssrvRpcRecord *rec2)
1306 : {
1307 : int i;
1308 : struct in6_addr rec1_in_addr6;
1309 : struct in6_addr rec2_in_addr6;
1310 :
1311 7818 : if (rec1->wType != rec2->wType) {
1312 1691 : return false;
1313 : }
1314 :
1315 : /* see if the data matches */
1316 6127 : switch (rec1->wType) {
1317 1847 : case DNS_TYPE_A:
1318 1847 : return strcmp(rec1->data.ipv4, rec2->data.ipv4) == 0;
1319 1029 : case DNS_TYPE_AAAA: {
1320 : int ret;
1321 :
1322 1029 : ret = inet_pton(AF_INET6, rec1->data.ipv6, &rec1_in_addr6);
1323 1029 : if (ret != 1) {
1324 0 : return false;
1325 : }
1326 1029 : ret = inet_pton(AF_INET6, rec2->data.ipv6, &rec2_in_addr6);
1327 1029 : if (ret != 1) {
1328 0 : return false;
1329 : }
1330 :
1331 1029 : return memcmp(&rec1_in_addr6, &rec2_in_addr6, sizeof(rec1_in_addr6)) == 0;
1332 : }
1333 108 : case DNS_TYPE_CNAME:
1334 108 : return samba_dns_name_equal(rec1->data.cname,
1335 : rec2->data.cname);
1336 1898 : case DNS_TYPE_TXT:
1337 1898 : if (rec1->data.txt.count != rec2->data.txt.count) {
1338 228 : return false;
1339 : }
1340 2901 : for (i = 0; i < rec1->data.txt.count; i++) {
1341 1948 : if (strcmp(rec1->data.txt.str[i], rec2->data.txt.str[i]) != 0) {
1342 717 : return false;
1343 : }
1344 : }
1345 953 : return true;
1346 128 : case DNS_TYPE_PTR:
1347 128 : return samba_dns_name_equal(rec1->data.ptr, rec2->data.ptr);
1348 129 : case DNS_TYPE_NS:
1349 129 : return samba_dns_name_equal(rec1->data.ns, rec2->data.ns);
1350 :
1351 859 : case DNS_TYPE_SRV:
1352 1703 : return rec1->data.srv.wPriority == rec2->data.srv.wPriority &&
1353 1372 : rec1->data.srv.wWeight == rec2->data.srv.wWeight &&
1354 2512 : rec1->data.srv.wPort == rec2->data.srv.wPort &&
1355 825 : samba_dns_name_equal(rec1->data.srv.nameTarget,
1356 : rec2->data.srv.nameTarget);
1357 :
1358 129 : case DNS_TYPE_MX:
1359 252 : return rec1->data.mx.wPriority == rec2->data.mx.wPriority &&
1360 123 : samba_dns_name_equal(rec1->data.mx.nameTarget,
1361 : rec2->data.mx.nameTarget);
1362 :
1363 0 : case DNS_TYPE_SOA:
1364 0 : return samba_dns_name_equal(rec1->data.soa.mname,
1365 0 : rec2->data.soa.mname) &&
1366 0 : samba_dns_name_equal(rec1->data.soa.rname,
1367 0 : rec2->data.soa.rname) &&
1368 0 : rec1->data.soa.serial == rec2->data.soa.serial &&
1369 0 : rec1->data.soa.refresh == rec2->data.soa.refresh &&
1370 0 : rec1->data.soa.retry == rec2->data.soa.retry &&
1371 0 : rec1->data.soa.expire == rec2->data.soa.expire &&
1372 0 : rec1->data.soa.minimum == rec2->data.soa.minimum;
1373 0 : case DNS_TYPE_TOMBSTONE:
1374 0 : return true;
1375 0 : default:
1376 0 : break;
1377 : }
1378 :
1379 0 : return false;
1380 : }
1381 :
1382 :
1383 13248 : static int dns_common_sort_zones(struct ldb_message **m1, struct ldb_message **m2)
1384 : {
1385 : const char *n1, *n2;
1386 : size_t l1, l2;
1387 :
1388 13248 : n1 = ldb_msg_find_attr_as_string(*m1, "name", NULL);
1389 13248 : n2 = ldb_msg_find_attr_as_string(*m2, "name", NULL);
1390 13248 : if (n1 == NULL || n2 == NULL) {
1391 0 : if (n1 != NULL) {
1392 0 : return -1;
1393 0 : } else if (n2 != NULL) {
1394 0 : return 1;
1395 : } else {
1396 0 : return 0;
1397 : }
1398 : }
1399 13248 : l1 = strlen(n1);
1400 13248 : l2 = strlen(n2);
1401 :
1402 : /* If the string lengths are not equal just sort by length */
1403 13248 : if (l1 != l2) {
1404 : /* If m1 is the larger zone name, return it first */
1405 11509 : return l2 - l1;
1406 : }
1407 :
1408 : /*TODO: We need to compare DNs here, we want the DomainDNSZones first */
1409 1739 : return 0;
1410 : }
1411 :
1412 1774 : NTSTATUS dns_common_zones(struct ldb_context *samdb,
1413 : TALLOC_CTX *mem_ctx,
1414 : struct ldb_dn *base_dn,
1415 : struct dns_server_zone **zones_ret)
1416 : {
1417 1774 : const struct timeval start = timeval_current();
1418 : int ret;
1419 : static const char * const attrs[] = { "name", NULL};
1420 : struct ldb_result *res;
1421 : int i;
1422 1774 : struct dns_server_zone *new_list = NULL;
1423 1774 : TALLOC_CTX *frame = talloc_stackframe();
1424 1774 : NTSTATUS result = NT_STATUS_OK;
1425 :
1426 1774 : if (base_dn) {
1427 : /* This search will work against windows */
1428 81 : ret = dsdb_search(samdb, frame, &res,
1429 : base_dn, LDB_SCOPE_SUBTREE,
1430 : attrs, 0, "(objectClass=dnsZone)");
1431 : } else {
1432 : /* TODO: this search does not work against windows */
1433 1693 : ret = dsdb_search(samdb, frame, &res, NULL,
1434 : LDB_SCOPE_SUBTREE,
1435 : attrs,
1436 : DSDB_SEARCH_SEARCH_ALL_PARTITIONS,
1437 : "(objectClass=dnsZone)");
1438 : }
1439 1774 : if (ret != LDB_SUCCESS) {
1440 0 : TALLOC_FREE(frame);
1441 0 : result = NT_STATUS_INTERNAL_DB_CORRUPTION;
1442 0 : goto exit;
1443 : }
1444 :
1445 1774 : TYPESAFE_QSORT(res->msgs, res->count, dns_common_sort_zones);
1446 :
1447 9839 : for (i=0; i < res->count; i++) {
1448 : struct dns_server_zone *z;
1449 :
1450 8065 : z = talloc_zero(mem_ctx, struct dns_server_zone);
1451 8065 : if (z == NULL) {
1452 0 : TALLOC_FREE(frame);
1453 0 : result = NT_STATUS_NO_MEMORY;
1454 0 : goto exit;
1455 : }
1456 :
1457 8065 : z->name = ldb_msg_find_attr_as_string(res->msgs[i], "name", NULL);
1458 8065 : talloc_steal(z, z->name);
1459 8065 : z->dn = talloc_move(z, &res->msgs[i]->dn);
1460 : /*
1461 : * Ignore the RootDNSServers zone and zones that we don't support yet
1462 : * RootDNSServers should never be returned (Windows DNS server don't)
1463 : * ..TrustAnchors should never be returned as is, (Windows returns
1464 : * TrustAnchors) and for the moment we don't support DNSSEC so we'd better
1465 : * not return this zone.
1466 : */
1467 11121 : if ((strcmp(z->name, "RootDNSServers") == 0) ||
1468 4639 : (strcmp(z->name, "..TrustAnchors") == 0))
1469 : {
1470 3426 : DEBUG(10, ("Ignoring zone %s\n", z->name));
1471 3426 : talloc_free(z);
1472 3426 : continue;
1473 : }
1474 4639 : DLIST_ADD_END(new_list, z);
1475 : }
1476 :
1477 1774 : *zones_ret = new_list;
1478 1774 : TALLOC_FREE(frame);
1479 1774 : result = NT_STATUS_OK;
1480 1774 : exit:
1481 1774 : DNS_COMMON_LOG_OPERATION(
1482 : nt_errstr(result),
1483 : &start,
1484 : NULL,
1485 : base_dn == NULL ? NULL : ldb_dn_get_linearized(base_dn),
1486 : NULL);
1487 1774 : return result;
1488 : }
1489 :
1490 : /*
1491 : see if two DNS names are the same
1492 : */
1493 32093 : bool samba_dns_name_equal(const char *name1, const char *name2)
1494 : {
1495 32093 : size_t len1 = strlen(name1);
1496 32093 : size_t len2 = strlen(name2);
1497 :
1498 32093 : if (len1 > 0 && name1[len1 - 1] == '.') {
1499 2635 : len1--;
1500 : }
1501 32093 : if (len2 > 0 && name2[len2 - 1] == '.') {
1502 4740 : len2--;
1503 : }
1504 32093 : if (len1 != len2) {
1505 17151 : return false;
1506 : }
1507 14942 : return strncasecmp(name1, name2, len1) == 0;
1508 : }
1509 :
1510 :
1511 : /*
1512 : * Convert unix time to a DNS timestamp
1513 : * uint32 hours in the NTTIME epoch
1514 : *
1515 : * This uses unix_to_nt_time() which can return special flag NTTIMEs like
1516 : * UINT64_MAX (0xFFF...) or NTTIME_MAX (0x7FF...), which will convert to
1517 : * distant future timestamps; or 0 as a flag value, meaning a 1601 timestamp,
1518 : * which is used to indicate a record does not expire.
1519 : *
1520 : * As we don't generally check for these special values in NTTIME conversions,
1521 : * we also don't check here, but for the benefit of people encountering these
1522 : * timestamps and searching for their origin, here is a list:
1523 : *
1524 : ** TIME_T_MAX
1525 : *
1526 : * Even if time_t is 32 bit, this will become NTTIME_MAX (a.k.a INT64_MAX,
1527 : * 0x7fffffffffffffff) in 100ns units. That translates to 256204778 hours
1528 : * since 1601, which converts back to 9223372008000000000 or
1529 : * 0x7ffffff9481f1000. It will present as 30828-09-14 02:00:00, around 48
1530 : * minutes earlier than NTTIME_MAX.
1531 : *
1532 : ** 0, the start of the unix epoch, 1970-01-01 00:00:00
1533 : *
1534 : * This is converted into 0 in the Windows epoch, 1601-01-01 00:00:00 which is
1535 : * clearly the same whether you count in 100ns units or hours. In DNS record
1536 : * timestamps this is a flag meaning the record will never expire.
1537 : *
1538 : ** (time_t)-1, such as what *might* mean 1969-12-31 23:59:59
1539 : *
1540 : * This becomes (NTTIME)-1ULL a.k.a. UINT64_MAX, 0xffffffffffffffff thence
1541 : * 512409557 in hours since 1601. That in turn is 0xfffffffaf2028800 or
1542 : * 18446744052000000000 in NTTIME (rounded to the hour), which might be
1543 : * presented as -21709551616 or -0x50dfd7800, because NTITME is not completely
1544 : * dedicated to being unsigned. If it gets shown as a year, it will be around
1545 : * 60055.
1546 : *
1547 : ** Other negative time_t values (e.g. 1969-05-29).
1548 : *
1549 : * The meaning of these is somewhat undefined, but in any case they will
1550 : * translate perfectly well into the same dates in NTTIME.
1551 : *
1552 : ** Notes
1553 : *
1554 : * There are dns timestamps that exceed the range of NTTIME (up to 488356 AD),
1555 : * but it is not possible for this function to produce them.
1556 : *
1557 : * It is plausible that it was at midnight on 1601-01-01, in London, that
1558 : * Shakespeare wrote:
1559 : *
1560 : * The time is out of joint. O cursed spite
1561 : * That ever I was born to set it right!
1562 : *
1563 : * and this is why we have this epoch and time zone.
1564 : */
1565 2002 : uint32_t unix_to_dns_timestamp(time_t t)
1566 : {
1567 : NTTIME nt;
1568 2002 : unix_to_nt_time(&nt, t);
1569 2002 : nt /= NTTIME_TO_HOURS;
1570 2002 : return (uint32_t) nt;
1571 : }
1572 :
1573 : /*
1574 : * Convert a DNS timestamp into NTTIME.
1575 : *
1576 : * Because DNS timestamps cover a longer time period than NTTIME, and these
1577 : * would wrap to an arbitrary NTTIME, we saturate at NTTIME_MAX and return an
1578 : * error in this case.
1579 : */
1580 64 : NTSTATUS dns_timestamp_to_nt_time(NTTIME *_nt, uint32_t t)
1581 : {
1582 64 : NTTIME nt = t;
1583 64 : if (nt > NTTIME_MAX / NTTIME_TO_HOURS) {
1584 2 : *_nt = NTTIME_MAX;
1585 2 : return NT_STATUS_INTEGER_OVERFLOW;
1586 : }
1587 62 : *_nt = nt * NTTIME_TO_HOURS;
1588 62 : return NT_STATUS_OK;
1589 : }
|
