source4/dns_server/dlz_bind9.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    bind9 dlz driver for Samba
   5
   6    Copyright (C) 2010 Andrew Tridgell
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "talloc.h"
  24 #include "param/param.h"
  25 #include "lib/events/events.h"
  26 #include "dsdb/samdb/samdb.h"
  27 #include "dsdb/common/util.h"
  28 #include "auth/auth.h"
  29 #include "auth/session.h"
  30 #include "auth/gensec/gensec.h"
  31 #include "librpc/gen_ndr/security.h"
  32 #include "auth/credentials/credentials.h"
  33 #include "system/kerberos.h"
  34 #include "auth/kerberos/kerberos.h"
  35 #include "gen_ndr/ndr_dnsp.h"
  36 #include "gen_ndr/server_id.h"
  37 #include "messaging/messaging.h"
  38 #include "lib/cmdline/popt_common.h"
  39 #include "lib/util/dlinklist.h"
  40 #include "dlz_minimal.h"
  41 #include "dns_server/dnsserver_common.h"
  42
  43 struct b9_options {
  44         const char *url;
  45         const char *debug;
  46 };
  47
  48 struct b9_zone {
  49         char *name;
  50         struct b9_zone *prev, *next;
  51 };
  52
  53 struct dlz_bind9_data {
  54         struct b9_options options;
  55         struct ldb_context *samdb;
  56         struct tevent_context *ev_ctx;
  57         struct loadparm_context *lp;
  58         int *transaction_token;
  59         uint32_t soa_serial;
  60         struct b9_zone *zonelist;
  61
  62         /* Used for dynamic update */
  63         struct smb_krb5_context *smb_krb5_ctx;
  64         struct auth4_context *auth_context;
  65         struct auth_session_info *session_info;
  66         char *update_name;
  67
  68         /* helper functions from the dlz_dlopen driver */
  69         log_t *log;
  70         dns_sdlz_putrr_t *putrr;
  71         dns_sdlz_putnamedrr_t *putnamedrr;
  72         dns_dlz_writeablezone_t *writeable_zone;
  73 };
  74
  75 static struct dlz_bind9_data *dlz_bind9_state = NULL;
  76 static int dlz_bind9_state_ref_count = 0;
  77
  78 static const char *zone_prefixes[] = {
  79         "CN=MicrosoftDNS,DC=DomainDnsZones",
  80         "CN=MicrosoftDNS,DC=ForestDnsZones",
  81         "CN=MicrosoftDNS,CN=System",
  82         NULL
  83 };
  84
  85 /*
  86   return the version of the API
  87  */
  88 _PUBLIC_ int dlz_version(unsigned int *flags)
  89 {
  90         return DLZ_DLOPEN_VERSION;
  91 }
  92
  93 /*
  94    remember a helper function from the bind9 dlz_dlopen driver
  95  */
  96 static void b9_add_helper(struct dlz_bind9_data *state, const char *helper_name, void *ptr)
  97 {
  98         if (strcmp(helper_name, "log") == 0) {
  99                 state->log = ptr;
 100         }
 101         if (strcmp(helper_name, "putrr") == 0) {
 102                 state->putrr = ptr;
 103         }
 104         if (strcmp(helper_name, "putnamedrr") == 0) {
 105                 state->putnamedrr = ptr;
 106         }
 107         if (strcmp(helper_name, "writeable_zone") == 0) {
 108                 state->writeable_zone = ptr;
 109         }
 110 }
 111
 112 /*
 113   format a record for bind9
 114  */
 115 static bool b9_format(struct dlz_bind9_data *state,
 116                       TALLOC_CTX *mem_ctx,
 117                       struct dnsp_DnssrvRpcRecord *rec,
 118                       const char **type, const char **data)
 119 {
 120         uint32_t i;
 121         char *tmp;
 122
 123         switch (rec->wType) {
 124         case DNS_TYPE_A:
 125                 *type = "a";
 126                 *data = rec->data.ipv4;
 127                 break;
 128
 129         case DNS_TYPE_AAAA:
 130                 *type = "aaaa";
 131                 *data = rec->data.ipv6;
 132                 break;
 133
 134         case DNS_TYPE_CNAME:
 135                 *type = "cname";
 136                 *data = rec->data.cname;
 137                 break;
 138
 139         case DNS_TYPE_TXT:
 140                 *type = "txt";
 141                 tmp = talloc_asprintf(mem_ctx, "\"%s\"", rec->data.txt.str[0]);
 142                 for (i=1; i<rec->data.txt.count; i++) {
 143                         tmp = talloc_asprintf_append(tmp, " \"%s\"", rec->data.txt.str[i]);
 144                 }
 145                 *data = tmp;
 146                 break;
 147
 148         case DNS_TYPE_PTR:
 149                 *type = "ptr";
 150                 *data = rec->data.ptr;
 151                 break;
 152
 153         case DNS_TYPE_SRV:
 154                 *type = "srv";
 155                 *data = talloc_asprintf(mem_ctx, "%u %u %u %s",
 156                                         rec->data.srv.wPriority,
 157                                         rec->data.srv.wWeight,
 158                                         rec->data.srv.wPort,
 159                                         rec->data.srv.nameTarget);
 160                 break;
 161
 162         case DNS_TYPE_MX:
 163                 *type = "mx";
 164                 *data = talloc_asprintf(mem_ctx, "%u %s",
 165                                         rec->data.mx.wPriority,
 166                                         rec->data.mx.nameTarget);
 167                 break;
 168
 169         case DNS_TYPE_HINFO:
 170                 *type = "hinfo";
 171                 *data = talloc_asprintf(mem_ctx, "%s %s",
 172                                         rec->data.hinfo.cpu,
 173                                         rec->data.hinfo.os);
 174                 break;
 175
 176         case DNS_TYPE_NS:
 177                 *type = "ns";
 178                 *data = rec->data.ns;
 179                 break;
 180
 181         case DNS_TYPE_SOA: {
 182                 const char *mname;
 183                 *type = "soa";
 184
 185                 /* we need to fake the authoritative nameserver to
 186                  * point at ourselves. This is how AD DNS servers
 187                  * force clients to send updates to the right local DC
 188                  */
 189                 mname = talloc_asprintf(mem_ctx, "%s.%s",
 190                                         lpcfg_netbios_name(state->lp), lpcfg_dnsdomain(state->lp));
 191                 if (mname == NULL) {
 192                         return false;
 193                 }
 194                 mname = strlower_talloc(mem_ctx, mname);
 195                 if (mname == NULL) {
 196                         return false;
 197                 }
 198
 199                 state->soa_serial = rec->data.soa.serial;
 200
 201                 *data = talloc_asprintf(mem_ctx, "%s %s %u %u %u %u %u",
 202                                         mname,
 203                                         rec->data.soa.rname,
 204                                         rec->data.soa.serial,
 205                                         rec->data.soa.refresh,
 206                                         rec->data.soa.retry,
 207                                         rec->data.soa.expire,
 208                                         rec->data.soa.minimum);
 209                 break;
 210         }
 211
 212         default:
 213                 state->log(ISC_LOG_ERROR, "samba_dlz b9_format: unhandled record type %u",
 214                            rec->wType);
 215                 return false;
 216         }
 217
 218         return true;
 219 }
 220
 221 static const struct {
 222         enum dns_record_type dns_type;
 223         const char *typestr;
 224         bool single_valued;
 225 } dns_typemap[] = {
 226         { DNS_TYPE_A,     "A"     , false},
 227         { DNS_TYPE_AAAA,  "AAAA"  , false},
 228         { DNS_TYPE_CNAME, "CNAME" , true},
 229         { DNS_TYPE_TXT,   "TXT"   , false},
 230         { DNS_TYPE_PTR,   "PTR"   , false},
 231         { DNS_TYPE_SRV,   "SRV"   , false},
 232         { DNS_TYPE_MX,    "MX"    , false},
 233         { DNS_TYPE_HINFO, "HINFO" , false},
 234         { DNS_TYPE_NS,    "NS"    , false},
 235         { DNS_TYPE_SOA,   "SOA"   , true},
 236 };
 237
 238
 239 /*
 240   see if a DNS type is single valued
 241  */
 242 static bool b9_single_valued(enum dns_record_type dns_type)
 243 {
 244         int i;
 245         for (i=0; i<ARRAY_SIZE(dns_typemap); i++) {
 246                 if (dns_typemap[i].dns_type == dns_type) {
 247                         return dns_typemap[i].single_valued;
 248                 }
 249         }
 250         return false;
 251 }
 252
 253 /*
 254   see if a DNS type is single valued
 255  */
 256 static bool b9_dns_type(const char *type, enum dns_record_type *dtype)
 257 {
 258         int i;
 259         for (i=0; i<ARRAY_SIZE(dns_typemap); i++) {
 260                 if (strcasecmp(dns_typemap[i].typestr, type) == 0) {
 261                         *dtype = dns_typemap[i].dns_type;
 262                         return true;
 263                 }
 264         }
 265         return false;
 266 }
 267
 268
 269 #define DNS_PARSE_STR(ret, str, sep, saveptr) do {      \
 270         (ret) = strtok_r(str, sep, &saveptr); \
 271         if ((ret) == NULL) return false; \
 272         } while (0)
 273
 274 #define DNS_PARSE_UINT(ret, str, sep, saveptr) do {  \
 275         char *istr = strtok_r(str, sep, &saveptr); \
 276         if ((istr) == NULL) return false; \
 277         (ret) = strtoul(istr, NULL, 10); \
 278         } while (0)
 279
 280 /*
 281   parse a record from bind9
 282  */
 283 static bool b9_parse(struct dlz_bind9_data *state,
 284                      const char *rdatastr,
 285                      struct dnsp_DnssrvRpcRecord *rec)
 286 {
 287         char *full_name, *dclass, *type;
 288         char *str, *tmp, *saveptr=NULL;
 289         int i;
 290
 291         str = talloc_strdup(rec, rdatastr);
 292         if (str == NULL) {
 293                 return false;
 294         }
 295
 296         /* parse the SDLZ string form */
 297         DNS_PARSE_STR(full_name, str, "\t", saveptr);
 298         DNS_PARSE_UINT(rec->dwTtlSeconds, NULL, "\t", saveptr);
 299         DNS_PARSE_STR(dclass, NULL, "\t", saveptr);
 300         DNS_PARSE_STR(type, NULL, "\t", saveptr);
 301
 302         /* construct the record */
 303         for (i=0; i<ARRAY_SIZE(dns_typemap); i++) {
 304                 if (strcasecmp(type, dns_typemap[i].typestr) == 0) {
 305                         rec->wType = dns_typemap[i].dns_type;
 306                         break;
 307                 }
 308         }
 309         if (i == ARRAY_SIZE(dns_typemap)) {
 310                 state->log(ISC_LOG_ERROR, "samba_dlz: unsupported record type '%s' for '%s'",
 311                            type, full_name);
 312                 return false;
 313         }
 314
 315         switch (rec->wType) {
 316         case DNS_TYPE_A:
 317                 DNS_PARSE_STR(rec->data.ipv4, NULL, " ", saveptr);
 318                 break;
 319
 320         case DNS_TYPE_AAAA:
 321                 DNS_PARSE_STR(rec->data.ipv6, NULL, " ", saveptr);
 322                 break;
 323
 324         case DNS_TYPE_CNAME:
 325                 DNS_PARSE_STR(rec->data.cname, NULL, " ", saveptr);
 326                 break;
 327
 328         case DNS_TYPE_TXT:
 329                 rec->data.txt.count = 0;
 330                 rec->data.txt.str = talloc_array(rec, const char *, rec->data.txt.count);
 331                 tmp = strtok_r(NULL, "\t", &saveptr);
 332                 while (tmp) {
 333                         rec->data.txt.str = talloc_realloc(rec, rec->data.txt.str, const char *,
 334                                                         rec->data.txt.count+1);
 335                         if (tmp[0] == '"') {
 336                                 /* Strip quotes */
 337                                 rec->data.txt.str[rec->data.txt.count] = talloc_strndup(rec, &tmp[1], strlen(tmp)-2);
 338                         } else {
 339                                 rec->data.txt.str[rec->data.txt.count] = talloc_strdup(rec, tmp);
 340                         }
 341                         rec->data.txt.count++;
 342                         tmp = strtok_r(NULL, " ", &saveptr);
 343                 }
 344                 break;
 345
 346         case DNS_TYPE_PTR:
 347                 DNS_PARSE_STR(rec->data.ptr, NULL, " ", saveptr);
 348                 break;
 349
 350         case DNS_TYPE_SRV:
 351                 DNS_PARSE_UINT(rec->data.srv.wPriority, NULL, " ", saveptr);
 352                 DNS_PARSE_UINT(rec->data.srv.wWeight, NULL, " ", saveptr);
 353                 DNS_PARSE_UINT(rec->data.srv.wPort, NULL, " ", saveptr);
 354                 DNS_PARSE_STR(rec->data.srv.nameTarget, NULL, " ", saveptr);
 355                 break;
 356
 357         case DNS_TYPE_MX:
 358                 DNS_PARSE_UINT(rec->data.mx.wPriority, NULL, " ", saveptr);
 359                 DNS_PARSE_STR(rec->data.mx.nameTarget, NULL, " ", saveptr);
 360                 break;
 361
 362         case DNS_TYPE_HINFO:
 363                 DNS_PARSE_STR(rec->data.hinfo.cpu, NULL, " ", saveptr);
 364                 DNS_PARSE_STR(rec->data.hinfo.os, NULL, " ", saveptr);
 365                 break;
 366
 367         case DNS_TYPE_NS:
 368                 DNS_PARSE_STR(rec->data.ns, NULL, " ", saveptr);
 369                 break;
 370
 371         case DNS_TYPE_SOA:
 372                 DNS_PARSE_STR(rec->data.soa.mname, NULL, " ", saveptr);
 373                 DNS_PARSE_STR(rec->data.soa.rname, NULL, " ", saveptr);
 374                 DNS_PARSE_UINT(rec->data.soa.serial, NULL, " ", saveptr);
 375                 DNS_PARSE_UINT(rec->data.soa.refresh, NULL, " ", saveptr);
 376                 DNS_PARSE_UINT(rec->data.soa.retry, NULL, " ", saveptr);
 377                 DNS_PARSE_UINT(rec->data.soa.expire, NULL, " ", saveptr);
 378                 DNS_PARSE_UINT(rec->data.soa.minimum, NULL, " ", saveptr);
 379                 break;
 380
 381         default:
 382                 state->log(ISC_LOG_ERROR, "samba_dlz b9_parse: unhandled record type %u",
 383                            rec->wType);
 384                 return false;
 385         }
 386
 387         /* we should be at the end of the buffer now */
 388         if (strtok_r(NULL, "\t ", &saveptr) != NULL) {
 389                 state->log(ISC_LOG_ERROR, "samba_dlz b9_parse: unexpected data at end of string for '%s'",
 390                            rdatastr);
 391                 return false;
 392         }
 393
 394         return true;
 395 }
 396
 397 /*
 398   send a resource record to bind9
 399  */
 400 static isc_result_t b9_putrr(struct dlz_bind9_data *state,
 401                              void *handle, struct dnsp_DnssrvRpcRecord *rec,
 402                              const char **types)
 403 {
 404         isc_result_t result;
 405         const char *type, *data;
 406         TALLOC_CTX *tmp_ctx = talloc_new(state);
 407
 408         if (!b9_format(state, tmp_ctx, rec, &type, &data)) {
 409                 return ISC_R_FAILURE;
 410         }
 411
 412         if (data == NULL) {
 413                 talloc_free(tmp_ctx);
 414                 return ISC_R_NOMEMORY;
 415         }
 416
 417         if (types) {
 418                 int i;
 419                 for (i=0; types[i]; i++) {
 420                         if (strcmp(types[i], type) == 0) break;
 421                 }
 422                 if (types[i] == NULL) {
 423                         /* skip it */
 424                         return ISC_R_SUCCESS;
 425                 }
 426         }
 427
 428         result = state->putrr(handle, type, rec->dwTtlSeconds, data);
 429         if (result != ISC_R_SUCCESS) {
 430                 state->log(ISC_LOG_ERROR, "Failed to put rr");
 431         }
 432         talloc_free(tmp_ctx);
 433         return result;
 434 }
 435
 436
 437 /*
 438   send a named resource record to bind9
 439  */
 440 static isc_result_t b9_putnamedrr(struct dlz_bind9_data *state,
 441                                   void *handle, const char *name,
 442                                   struct dnsp_DnssrvRpcRecord *rec)
 443 {
 444         isc_result_t result;
 445         const char *type, *data;
 446         TALLOC_CTX *tmp_ctx = talloc_new(state);
 447
 448         if (!b9_format(state, tmp_ctx, rec, &type, &data)) {
 449                 return ISC_R_FAILURE;
 450         }
 451
 452         if (data == NULL) {
 453                 talloc_free(tmp_ctx);
 454                 return ISC_R_NOMEMORY;
 455         }
 456
 457         result = state->putnamedrr(handle, name, type, rec->dwTtlSeconds, data);
 458         if (result != ISC_R_SUCCESS) {
 459                 state->log(ISC_LOG_ERROR, "Failed to put named rr '%s'", name);
 460         }
 461         talloc_free(tmp_ctx);
 462         return result;
 463 }
 464
 465 /*
 466    parse options
 467  */
 468 static isc_result_t parse_options(struct dlz_bind9_data *state,
 469                                   unsigned int argc, const char **argv,
 470                                   struct b9_options *options)
 471 {
 472         int opt;
 473         poptContext pc;
 474         struct poptOption long_options[] = {
 475                 { "url", 'H', POPT_ARG_STRING, &options->url, 0, "database URL", "URL" },
 476                 { "debug", 'd', POPT_ARG_STRING, &options->debug, 0, "debug level", "DEBUG" },
 477                 { NULL }
 478         };
 479
 480         pc = poptGetContext("dlz_bind9", argc, argv, long_options,
 481                         POPT_CONTEXT_KEEP_FIRST);
 482         while ((opt = poptGetNextOpt(pc)) != -1) {
 483                 switch (opt) {
 484                 default:
 485                         state->log(ISC_LOG_ERROR, "dlz_bind9: Invalid option %s: %s",
 486                                    poptBadOption(pc, 0), poptStrerror(opt));
 487                         return ISC_R_FAILURE;
 488                 }
 489         }
 490
 491         return ISC_R_SUCCESS;
 492 }
 493
 494
 495 /*
 496  * Create session info from PAC
 497  * This is called as auth_context->generate_session_info_pac()
 498  */
 499 static NTSTATUS b9_generate_session_info_pac(struct auth4_context *auth_context,
 500                                              TALLOC_CTX *mem_ctx,
 501                                              struct smb_krb5_context *smb_krb5_context,
 502                                              DATA_BLOB *pac_blob,
 503                                              const char *principal_name,
 504                                              const struct tsocket_address *remote_addr,
 505                                              uint32_t session_info_flags,
 506                                              struct auth_session_info **session_info)
 507 {
 508         NTSTATUS status;
 509         struct auth_user_info_dc *user_info_dc;
 510         TALLOC_CTX *tmp_ctx;
 511
 512         tmp_ctx = talloc_new(mem_ctx);
 513         NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
 514
 515         status = kerberos_pac_blob_to_user_info_dc(tmp_ctx,
 516                                                    *pac_blob,
 517                                                    smb_krb5_context->krb5_context,
 518                                                    &user_info_dc,
 519                                                    NULL,
 520                                                    NULL);
 521         if (!NT_STATUS_IS_OK(status)) {
 522                 talloc_free(tmp_ctx);
 523                 return status;
 524         }
 525
 526         if (user_info_dc->info->authenticated) {
 527                 session_info_flags |= AUTH_SESSION_INFO_AUTHENTICATED;
 528         }
 529
 530         session_info_flags |= AUTH_SESSION_INFO_SIMPLE_PRIVILEGES;
 531
 532         status = auth_generate_session_info(mem_ctx, NULL, NULL, user_info_dc,
 533                                             session_info_flags, session_info);
 534         if (!NT_STATUS_IS_OK(status)) {
 535                 talloc_free(tmp_ctx);
 536                 return status;
 537         }
 538
 539         talloc_free(tmp_ctx);
 540         return status;
 541 }
 542
 543 /* Callback for the DEBUG() system, to catch the remaining messages */
 544 static void b9_debug(void *private_ptr, int msg_level, const char *msg)
 545 {
 546         static const int isc_log_map[] = {
 547                 ISC_LOG_CRITICAL, /* 0 */
 548                 ISC_LOG_ERROR,    /* 1 */
 549                 ISC_LOG_WARNING,   /* 2 */
 550                 ISC_LOG_NOTICE    /* 3 */
 551         };
 552         struct dlz_bind9_data *state = private_ptr;
 553         int     isc_log_level;
 554
 555         if (msg_level >= ARRAY_SIZE(isc_log_map) || msg_level < 0) {
 556                 isc_log_level = ISC_LOG_INFO;
 557         } else {
 558                 isc_log_level = isc_log_map[msg_level];
 559         }
 560         state->log(isc_log_level, "samba_dlz: %s", msg);
 561 }
 562
 563 static int dlz_state_debug_unregister(struct dlz_bind9_data *state)
 564 {
 565         /* Stop logging (to the bind9 logs) */
 566         debug_set_callback(NULL, NULL);
 567         return 0;
 568 }
 569
 570 /*
 571   called to initialise the driver
 572  */
 573 _PUBLIC_ isc_result_t dlz_create(const char *dlzname,
 574                                  unsigned int argc, const char **argv,
 575                                  void **dbdata, ...)
 576 {
 577         struct dlz_bind9_data *state;
 578         const char *helper_name;
 579         va_list ap;
 580         isc_result_t result;
 581         struct ldb_dn *dn;
 582         NTSTATUS nt_status;
 583
 584         if (dlz_bind9_state != NULL) {
 585                 *dbdata = dlz_bind9_state;
 586                 dlz_bind9_state_ref_count++;
 587                 return ISC_R_SUCCESS;
 588         }
 589
 590         state = talloc_zero(NULL, struct dlz_bind9_data);
 591         if (state == NULL) {
 592                 return ISC_R_NOMEMORY;
 593         }
 594
 595         talloc_set_destructor(state, dlz_state_debug_unregister);
 596
 597         /* fill in the helper functions */
 598         va_start(ap, dbdata);
 599         while ((helper_name = va_arg(ap, const char *)) != NULL) {
 600                 b9_add_helper(state, helper_name, va_arg(ap, void*));
 601         }
 602         va_end(ap);
 603
 604         /* Do not install samba signal handlers */
 605         fault_setup_disable();
 606
 607         /* Start logging (to the bind9 logs) */
 608         debug_set_callback(state, b9_debug);
 609
 610         state->ev_ctx = s4_event_context_init(state);
 611         if (state->ev_ctx == NULL) {
 612                 result = ISC_R_NOMEMORY;
 613                 goto failed;
 614         }
 615
 616         result = parse_options(state, argc, argv, &state->options);
 617         if (result != ISC_R_SUCCESS) {
 618                 goto failed;
 619         }
 620
 621         state->lp = loadparm_init_global(true);
 622         if (state->lp == NULL) {
 623                 result = ISC_R_NOMEMORY;
 624                 goto failed;
 625         }
 626
 627         if (state->options.debug) {
 628                 lpcfg_do_global_parameter(state->lp, "log level", state->options.debug);
 629         } else {
 630                 lpcfg_do_global_parameter(state->lp, "log level", "0");
 631         }
 632
 633         if (smb_krb5_init_context(state, state->lp, &state->smb_krb5_ctx) != 0) {
 634                 result = ISC_R_NOMEMORY;
 635                 goto failed;
 636         }
 637
 638         nt_status = gensec_init();
 639         if (!NT_STATUS_IS_OK(nt_status)) {
 640                 result = ISC_R_NOMEMORY;
 641                 goto failed;
 642         }
 643
 644         state->auth_context = talloc_zero(state, struct auth4_context);
 645         if (state->auth_context == NULL) {
 646                 result = ISC_R_NOMEMORY;
 647                 goto failed;
 648         }
 649
 650         if (state->options.url == NULL) {
 651                 state->options.url = lpcfg_private_path(state, state->lp, "dns/sam.ldb");
 652                 if (state->options.url == NULL) {
 653                         result = ISC_R_NOMEMORY;
 654                         goto failed;
 655                 }
 656         }
 657
 658         state->samdb = samdb_connect_url(state, state->ev_ctx, state->lp,
 659                                         system_session(state->lp), 0, state->options.url);
 660         if (state->samdb == NULL) {
 661                 state->log(ISC_LOG_ERROR, "samba_dlz: Failed to connect to %s",
 662                         state->options.url);
 663                 result = ISC_R_FAILURE;
 664                 goto failed;
 665         }
 666
 667         dn = ldb_get_default_basedn(state->samdb);
 668         if (dn == NULL) {
 669                 state->log(ISC_LOG_ERROR, "samba_dlz: Unable to get basedn for %s - %s",
 670                            state->options.url, ldb_errstring(state->samdb));
 671                 result = ISC_R_FAILURE;
 672                 goto failed;
 673         }
 674
 675         state->log(ISC_LOG_INFO, "samba_dlz: started for DN %s",
 676                    ldb_dn_get_linearized(dn));
 677
 678         state->auth_context->event_ctx = state->ev_ctx;
 679         state->auth_context->lp_ctx = state->lp;
 680         state->auth_context->sam_ctx = state->samdb;
 681         state->auth_context->generate_session_info_pac = b9_generate_session_info_pac;
 682
 683         *dbdata = state;
 684         dlz_bind9_state = state;
 685         dlz_bind9_state_ref_count++;
 686
 687         return ISC_R_SUCCESS;
 688
 689 failed:
 690         talloc_free(state);
 691         return result;
 692 }
 693
 694 /*
 695   shutdown the backend
 696  */
 697 _PUBLIC_ void dlz_destroy(void *dbdata)
 698 {
 699         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
 700         state->log(ISC_LOG_INFO, "samba_dlz: shutting down");
 701
 702         dlz_bind9_state_ref_count--;
 703         if (dlz_bind9_state_ref_count == 0) {
 704                 talloc_unlink(state, state->samdb);
 705                 talloc_free(state);
 706                 dlz_bind9_state = NULL;
 707         }
 708 }
 709
 710
 711 /*
 712   return the base DN for a zone
 713  */
 714 static isc_result_t b9_find_zone_dn(struct dlz_bind9_data *state, const char *zone_name,
 715                                     TALLOC_CTX *mem_ctx, struct ldb_dn **zone_dn)
 716 {
 717         int ret;
 718         TALLOC_CTX *tmp_ctx = talloc_new(state);
 719         const char *attrs[] = { NULL };
 720         int i;
 721
 722         for (i=0; zone_prefixes[i]; i++) {
 723                 struct ldb_dn *dn;
 724                 struct ldb_result *res;
 725
 726                 dn = ldb_dn_copy(tmp_ctx, ldb_get_default_basedn(state->samdb));
 727                 if (dn == NULL) {
 728                         talloc_free(tmp_ctx);
 729                         return ISC_R_NOMEMORY;
 730                 }
 731
 732                 if (!ldb_dn_add_child_fmt(dn, "DC=%s,%s", zone_name, zone_prefixes[i])) {
 733                         talloc_free(tmp_ctx);
 734                         return ISC_R_NOMEMORY;
 735                 }
 736
 737                 ret = ldb_search(state->samdb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, attrs, "objectClass=dnsZone");
 738                 if (ret == LDB_SUCCESS) {
 739                         if (zone_dn != NULL) {
 740                                 *zone_dn = talloc_steal(mem_ctx, dn);
 741                         }
 742                         talloc_free(tmp_ctx);
 743                         return ISC_R_SUCCESS;
 744                 }
 745                 talloc_free(dn);
 746         }
 747
 748         talloc_free(tmp_ctx);
 749         return ISC_R_NOTFOUND;
 750 }
 751
 752
 753 /*
 754   return the DN for a name. The record does not need to exist, but the
 755   zone must exist
 756  */
 757 static isc_result_t b9_find_name_dn(struct dlz_bind9_data *state, const char *name,
 758                                     TALLOC_CTX *mem_ctx, struct ldb_dn **dn)
 759 {
 760         const char *p;
 761
 762         /* work through the name piece by piece, until we find a zone */
 763         for (p=name; p; ) {
 764                 isc_result_t result;
 765                 result = b9_find_zone_dn(state, p, mem_ctx, dn);
 766                 if (result == ISC_R_SUCCESS) {
 767                         /* we found a zone, now extend the DN to get
 768                          * the full DN
 769                          */
 770                         bool ret;
 771                         if (p == name) {
 772                                 ret = ldb_dn_add_child_fmt(*dn, "DC=@");
 773                         } else {
 774                                 ret = ldb_dn_add_child_fmt(*dn, "DC=%.*s", (int)(p-name)-1, name);
 775                         }
 776                         if (!ret) {
 777                                 talloc_free(*dn);
 778                                 return ISC_R_NOMEMORY;
 779                         }
 780                         return ISC_R_SUCCESS;
 781                 }
 782                 p = strchr(p, '.');
 783                 if (p == NULL) {
 784                         break;
 785                 }
 786                 p++;
 787         }
 788         return ISC_R_NOTFOUND;
 789 }
 790
 791
 792 /*
 793   see if we handle a given zone
 794  */
 795 _PUBLIC_ isc_result_t dlz_findzonedb(void *dbdata, const char *name)
 796 {
 797         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
 798         return b9_find_zone_dn(state, name, NULL, NULL);
 799 }
 800
 801
 802 /*
 803   lookup one record
 804  */
 805 static isc_result_t dlz_lookup_types(struct dlz_bind9_data *state,
 806                                      const char *zone, const char *name,
 807                                      dns_sdlzlookup_t *lookup,
 808                                      const char **types)
 809 {
 810         TALLOC_CTX *tmp_ctx = talloc_new(state);
 811         struct ldb_dn *dn;
 812         WERROR werr = WERR_DNS_ERROR_NAME_DOES_NOT_EXIST;
 813         struct dnsp_DnssrvRpcRecord *records = NULL;
 814         uint16_t num_records = 0, i;
 815
 816         for (i=0; zone_prefixes[i]; i++) {
 817                 dn = ldb_dn_copy(tmp_ctx, ldb_get_default_basedn(state->samdb));
 818                 if (dn == NULL) {
 819                         talloc_free(tmp_ctx);
 820                         return ISC_R_NOMEMORY;
 821                 }
 822
 823                 if (!ldb_dn_add_child_fmt(dn, "DC=%s,DC=%s,%s", name, zone, zone_prefixes[i])) {
 824                         talloc_free(tmp_ctx);
 825                         return ISC_R_NOMEMORY;
 826                 }
 827
 828                 werr = dns_common_lookup(state->samdb, tmp_ctx, dn,
 829                                          &records, &num_records, NULL);
 830                 if (W_ERROR_IS_OK(werr)) {
 831                         break;
 832                 }
 833         }
 834         if (!W_ERROR_IS_OK(werr)) {
 835                 talloc_free(tmp_ctx);
 836                 return ISC_R_NOTFOUND;
 837         }
 838
 839         for (i=0; i < num_records; i++) {
 840                 isc_result_t result;
 841
 842                 result = b9_putrr(state, lookup, &records[i], types);
 843                 if (result != ISC_R_SUCCESS) {
 844                         talloc_free(tmp_ctx);
 845                         return result;
 846                 }
 847         }
 848
 849         talloc_free(tmp_ctx);
 850         return ISC_R_SUCCESS;
 851 }
 852
 853 /*
 854   lookup one record
 855  */
 856 #ifdef BIND_VERSION_9_8
 857 _PUBLIC_ isc_result_t dlz_lookup(const char *zone, const char *name,
 858                                  void *dbdata, dns_sdlzlookup_t *lookup)
 859 #else
 860 _PUBLIC_ isc_result_t dlz_lookup(const char *zone, const char *name,
 861                                  void *dbdata, dns_sdlzlookup_t *lookup,
 862                                  dns_clientinfomethods_t *methods,
 863                                  dns_clientinfo_t *clientinfo)
 864 #endif
 865 {
 866         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
 867         return dlz_lookup_types(state, zone, name, lookup, NULL);
 868 }
 869
 870
 871 /*
 872   see if a zone transfer is allowed
 873  */
 874 _PUBLIC_ isc_result_t dlz_allowzonexfr(void *dbdata, const char *name, const char *client)
 875 {
 876         /* just say yes for all our zones for now */
 877         return dlz_findzonedb(dbdata, name);
 878 }
 879
 880 /*
 881   perform a zone transfer
 882  */
 883 _PUBLIC_ isc_result_t dlz_allnodes(const char *zone, void *dbdata,
 884                                    dns_sdlzallnodes_t *allnodes)
 885 {
 886         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
 887         const char *attrs[] = { "dnsRecord", NULL };
 888         int ret = LDB_SUCCESS, i, j;
 889         struct ldb_dn *dn;
 890         struct ldb_result *res;
 891         TALLOC_CTX *tmp_ctx = talloc_new(state);
 892
 893         for (i=0; zone_prefixes[i]; i++) {
 894                 dn = ldb_dn_copy(tmp_ctx, ldb_get_default_basedn(state->samdb));
 895                 if (dn == NULL) {
 896                         talloc_free(tmp_ctx);
 897                         return ISC_R_NOMEMORY;
 898                 }
 899
 900                 if (!ldb_dn_add_child_fmt(dn, "DC=%s,%s", zone, zone_prefixes[i])) {
 901                         talloc_free(tmp_ctx);
 902                         return ISC_R_NOMEMORY;
 903                 }
 904
 905                 ret = ldb_search(state->samdb, tmp_ctx, &res, dn, LDB_SCOPE_SUBTREE,
 906                                  attrs, "objectClass=dnsNode");
 907                 if (ret == LDB_SUCCESS) {
 908                         break;
 909                 }
 910         }
 911         if (ret != LDB_SUCCESS) {
 912                 talloc_free(tmp_ctx);
 913                 return ISC_R_NOTFOUND;
 914         }
 915
 916         for (i=0; i<res->count; i++) {
 917                 struct ldb_message_element *el;
 918                 TALLOC_CTX *el_ctx = talloc_new(tmp_ctx);
 919                 const char *rdn, *name;
 920                 const struct ldb_val *v;
 921
 922                 el = ldb_msg_find_element(res->msgs[i], "dnsRecord");
 923                 if (el == NULL || el->num_values == 0) {
 924                         state->log(ISC_LOG_INFO, "failed to find dnsRecord for %s",
 925                                    ldb_dn_get_linearized(dn));
 926                         talloc_free(el_ctx);
 927                         continue;
 928                 }
 929
 930                 v = ldb_dn_get_rdn_val(res->msgs[i]->dn);
 931                 if (v == NULL) {
 932                         state->log(ISC_LOG_INFO, "failed to find RDN for %s",
 933                                    ldb_dn_get_linearized(dn));
 934                         talloc_free(el_ctx);
 935                         continue;
 936                 }
 937
 938                 rdn = talloc_strndup(el_ctx, (char *)v->data, v->length);
 939                 if (rdn == NULL) {
 940                         talloc_free(tmp_ctx);
 941                         return ISC_R_NOMEMORY;
 942                 }
 943
 944                 if (strcmp(rdn, "@") == 0) {
 945                         name = zone;
 946                 } else {
 947                         name = talloc_asprintf(el_ctx, "%s.%s", rdn, zone);
 948                 }
 949                 if (name == NULL) {
 950                         talloc_free(tmp_ctx);
 951                         return ISC_R_NOMEMORY;
 952                 }
 953
 954                 for (j=0; j<el->num_values; j++) {
 955                         struct dnsp_DnssrvRpcRecord rec;
 956                         enum ndr_err_code ndr_err;
 957                         isc_result_t result;
 958
 959                         ndr_err = ndr_pull_struct_blob(&el->values[j], el_ctx, &rec,
 960                                                        (ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
 961                         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 962                                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to parse dnsRecord for %s",
 963                                            ldb_dn_get_linearized(dn));
 964                                 continue;
 965                         }
 966
 967                         result = b9_putnamedrr(state, allnodes, name, &rec);
 968                         if (result != ISC_R_SUCCESS) {
 969                                 continue;
 970                         }
 971                 }
 972
 973                 talloc_free(el_ctx);
 974         }
 975
 976         talloc_free(tmp_ctx);
 977
 978         return ISC_R_SUCCESS;
 979 }
 980
 981
 982 /*
 983   start a transaction
 984  */
 985 _PUBLIC_ isc_result_t dlz_newversion(const char *zone, void *dbdata, void **versionp)
 986 {
 987         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
 988
 989         state->log(ISC_LOG_INFO, "samba_dlz: starting transaction on zone %s", zone);
 990
 991         if (state->transaction_token != NULL) {
 992                 state->log(ISC_LOG_INFO, "samba_dlz: transaction already started for zone %s", zone);
 993                 return ISC_R_FAILURE;
 994         }
 995
 996         state->transaction_token = talloc_zero(state, int);
 997         if (state->transaction_token == NULL) {
 998                 return ISC_R_NOMEMORY;
 999         }
1000
1001         if (ldb_transaction_start(state->samdb) != LDB_SUCCESS) {
1002                 state->log(ISC_LOG_INFO, "samba_dlz: failed to start a transaction for zone %s", zone);
1003                 talloc_free(state->transaction_token);
1004                 state->transaction_token = NULL;
1005                 return ISC_R_FAILURE;
1006         }
1007
1008         *versionp = (void *)state->transaction_token;
1009
1010         return ISC_R_SUCCESS;
1011 }
1012
1013 /*
1014   end a transaction
1015  */
1016 _PUBLIC_ void dlz_closeversion(const char *zone, isc_boolean_t commit,
1017                                void *dbdata, void **versionp)
1018 {
1019         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1020
1021         if (state->transaction_token != (int *)*versionp) {
1022                 state->log(ISC_LOG_INFO, "samba_dlz: transaction not started for zone %s", zone);
1023                 return;
1024         }
1025
1026         if (commit) {
1027                 if (ldb_transaction_commit(state->samdb) != LDB_SUCCESS) {
1028                         state->log(ISC_LOG_INFO, "samba_dlz: failed to commit a transaction for zone %s", zone);
1029                         return;
1030                 }
1031                 state->log(ISC_LOG_INFO, "samba_dlz: committed transaction on zone %s", zone);
1032         } else {
1033                 if (ldb_transaction_cancel(state->samdb) != LDB_SUCCESS) {
1034                         state->log(ISC_LOG_INFO, "samba_dlz: failed to cancel a transaction for zone %s", zone);
1035                         return;
1036                 }
1037                 state->log(ISC_LOG_INFO, "samba_dlz: cancelling transaction on zone %s", zone);
1038         }
1039
1040         talloc_free(state->transaction_token);
1041         state->transaction_token = NULL;
1042         *versionp = NULL;
1043 }
1044
1045
1046 /*
1047   see if there is a SOA record for a zone
1048  */
1049 static bool b9_has_soa(struct dlz_bind9_data *state, struct ldb_dn *dn, const char *zone)
1050 {
1051         TALLOC_CTX *tmp_ctx = talloc_new(state);
1052         WERROR werr;
1053         struct dnsp_DnssrvRpcRecord *records = NULL;
1054         uint16_t num_records = 0, i;
1055
1056         if (!ldb_dn_add_child_fmt(dn, "DC=@,DC=%s", zone)) {
1057                 talloc_free(tmp_ctx);
1058                 return false;
1059         }
1060
1061         werr = dns_common_lookup(state->samdb, tmp_ctx, dn,
1062                                  &records, &num_records, NULL);
1063         if (!W_ERROR_IS_OK(werr)) {
1064                 talloc_free(tmp_ctx);
1065                 return false;
1066         }
1067
1068         for (i=0; i < num_records; i++) {
1069                 if (records[i].wType == DNS_TYPE_SOA) {
1070                         talloc_free(tmp_ctx);
1071                         return true;
1072                 }
1073         }
1074
1075         talloc_free(tmp_ctx);
1076         return false;
1077 }
1078
1079 static bool b9_zone_add(struct dlz_bind9_data *state, const char *name)
1080 {
1081         struct b9_zone *zone;
1082
1083         zone = talloc_zero(state, struct b9_zone);
1084         if (zone == NULL) {
1085                 return false;
1086         }
1087
1088         zone->name = talloc_strdup(zone, name);
1089         if (zone->name == NULL) {
1090                 talloc_free(zone);
1091                 return false;
1092         }
1093
1094         DLIST_ADD(state->zonelist, zone);
1095         return true;
1096 }
1097
1098 static bool b9_zone_exists(struct dlz_bind9_data *state, const char *name)
1099 {
1100         struct b9_zone *zone = state->zonelist;
1101         bool found = false;
1102
1103         while (zone != NULL) {
1104                 if (strcasecmp(name, zone->name) == 0) {
1105                         found = true;
1106                         break;
1107                 }
1108                 zone = zone->next;
1109         }
1110
1111         return found;
1112 }
1113
1114
1115 /*
1116   configure a writeable zone
1117  */
1118 _PUBLIC_ isc_result_t dlz_configure(dns_view_t *view, void *dbdata)
1119 {
1120         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1121         TALLOC_CTX *tmp_ctx;
1122         struct ldb_dn *dn;
1123         int i;
1124
1125         state->log(ISC_LOG_INFO, "samba_dlz: starting configure");
1126         if (state->writeable_zone == NULL) {
1127                 state->log(ISC_LOG_INFO, "samba_dlz: no writeable_zone method available");
1128                 return ISC_R_FAILURE;
1129         }
1130
1131         tmp_ctx = talloc_new(state);
1132
1133         for (i=0; zone_prefixes[i]; i++) {
1134                 const char *attrs[] = { "name", NULL };
1135                 int j, ret;
1136                 struct ldb_result *res;
1137
1138                 dn = ldb_dn_copy(tmp_ctx, ldb_get_default_basedn(state->samdb));
1139                 if (dn == NULL) {
1140                         talloc_free(tmp_ctx);
1141                         return ISC_R_NOMEMORY;
1142                 }
1143
1144                 if (!ldb_dn_add_child_fmt(dn, "%s", zone_prefixes[i])) {
1145                         talloc_free(tmp_ctx);
1146                         return ISC_R_NOMEMORY;
1147                 }
1148
1149                 ret = ldb_search(state->samdb, tmp_ctx, &res, dn, LDB_SCOPE_SUBTREE,
1150                                  attrs, "objectClass=dnsZone");
1151                 if (ret != LDB_SUCCESS) {
1152                         continue;
1153                 }
1154
1155                 for (j=0; j<res->count; j++) {
1156                         isc_result_t result;
1157                         const char *zone = ldb_msg_find_attr_as_string(res->msgs[j], "name", NULL);
1158                         struct ldb_dn *zone_dn;
1159
1160                         if (zone == NULL) {
1161                                 continue;
1162                         }
1163                         /* Ignore zones that are not handled in BIND */
1164                         if ((strcmp(zone, "RootDNSServers") == 0) ||
1165                             (strcmp(zone, "..TrustAnchors") == 0)) {
1166                                 continue;
1167                         }
1168                         zone_dn = ldb_dn_copy(tmp_ctx, dn);
1169                         if (zone_dn == NULL) {
1170                                 talloc_free(tmp_ctx);
1171                                 return ISC_R_NOMEMORY;
1172                         }
1173
1174                         if (!b9_has_soa(state, zone_dn, zone)) {
1175                                 continue;
1176                         }
1177
1178                         if (b9_zone_exists(state, zone)) {
1179                                 state->log(ISC_LOG_WARNING, "samba_dlz: Ignoring duplicate zone '%s' from '%s'",
1180                                            zone, ldb_dn_get_linearized(zone_dn));
1181                                 continue;
1182                         }
1183
1184                         if (!b9_zone_add(state, zone)) {
1185                                 talloc_free(tmp_ctx);
1186                                 return ISC_R_NOMEMORY;
1187                         }
1188
1189                         result = state->writeable_zone(view, zone);
1190                         if (result != ISC_R_SUCCESS) {
1191                                 state->log(ISC_LOG_ERROR, "samba_dlz: Failed to configure zone '%s'",
1192                                            zone);
1193                                 talloc_free(tmp_ctx);
1194                                 return result;
1195                         }
1196                         state->log(ISC_LOG_INFO, "samba_dlz: configured writeable zone '%s'", zone);
1197                 }
1198         }
1199
1200         talloc_free(tmp_ctx);
1201         return ISC_R_SUCCESS;
1202 }
1203
1204 /*
1205   authorize a zone update
1206  */
1207 _PUBLIC_ isc_boolean_t dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
1208                                     const char *type, const char *key, uint32_t keydatalen, uint8_t *keydata,
1209                                     void *dbdata)
1210 {
1211         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1212         TALLOC_CTX *tmp_ctx;
1213         DATA_BLOB ap_req;
1214         struct cli_credentials *server_credentials;
1215         char *keytab_name;
1216         int ret;
1217         int ldb_ret;
1218         NTSTATUS nt_status;
1219         struct gensec_security *gensec_ctx;
1220         struct auth_session_info *session_info;
1221         struct ldb_dn *dn;
1222         isc_result_t result;
1223         struct ldb_result *res;
1224         const char * attrs[] = { NULL };
1225         uint32_t access_mask;
1226
1227         /* Remove cached credentials, if any */
1228         if (state->session_info) {
1229                 talloc_free(state->session_info);
1230                 state->session_info = NULL;
1231         }
1232         if (state->update_name) {
1233                 talloc_free(state->update_name);
1234                 state->update_name = NULL;
1235         }
1236
1237         tmp_ctx = talloc_new(NULL);
1238         if (tmp_ctx == NULL) {
1239                 state->log(ISC_LOG_ERROR, "samba_dlz: no memory");
1240                 return ISC_FALSE;
1241         }
1242
1243         ap_req = data_blob_const(keydata, keydatalen);
1244         server_credentials = cli_credentials_init(tmp_ctx);
1245         if (!server_credentials) {
1246                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to init server credentials");
1247                 talloc_free(tmp_ctx);
1248                 return ISC_FALSE;
1249         }
1250
1251         cli_credentials_set_krb5_context(server_credentials, state->smb_krb5_ctx);
1252         cli_credentials_set_conf(server_credentials, state->lp);
1253
1254         keytab_name = talloc_asprintf(tmp_ctx, "file:%s/dns.keytab",
1255                                         lpcfg_private_dir(state->lp));
1256         ret = cli_credentials_set_keytab_name(server_credentials, state->lp, keytab_name,
1257                                                 CRED_SPECIFIED);
1258         if (ret != 0) {
1259                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to obtain server credentials from %s",
1260                            keytab_name);
1261                 talloc_free(tmp_ctx);
1262                 return ISC_FALSE;
1263         }
1264         talloc_free(keytab_name);
1265
1266         nt_status = gensec_server_start(tmp_ctx,
1267                                         lpcfg_gensec_settings(tmp_ctx, state->lp),
1268                                         state->auth_context, &gensec_ctx);
1269         if (!NT_STATUS_IS_OK(nt_status)) {
1270                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to start gensec server");
1271                 talloc_free(tmp_ctx);
1272                 return ISC_FALSE;
1273         }
1274
1275         gensec_set_credentials(gensec_ctx, server_credentials);
1276
1277         nt_status = gensec_start_mech_by_name(gensec_ctx, "spnego");
1278         if (!NT_STATUS_IS_OK(nt_status)) {
1279                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to start spnego");
1280                 talloc_free(tmp_ctx);
1281                 return ISC_FALSE;
1282         }
1283
1284         nt_status = gensec_update_ev(gensec_ctx, tmp_ctx, state->ev_ctx, ap_req, &ap_req);
1285         if (!NT_STATUS_IS_OK(nt_status)) {
1286                 state->log(ISC_LOG_ERROR, "samba_dlz: spnego update failed");
1287                 talloc_free(tmp_ctx);
1288                 return ISC_FALSE;
1289         }
1290
1291         nt_status = gensec_session_info(gensec_ctx, tmp_ctx, &session_info);
1292         if (!NT_STATUS_IS_OK(nt_status)) {
1293                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to create session info");
1294                 talloc_free(tmp_ctx);
1295                 return ISC_FALSE;
1296         }
1297
1298         /* Get the DN from name */
1299         result = b9_find_name_dn(state, name, tmp_ctx, &dn);
1300         if (result != ISC_R_SUCCESS) {
1301                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to find name %s", name);
1302                 talloc_free(tmp_ctx);
1303                 return ISC_FALSE;
1304         }
1305
1306         /* make sure the dn exists, or find parent dn in case new object is being added */
1307         ldb_ret = ldb_search(state->samdb, tmp_ctx, &res, dn, LDB_SCOPE_BASE,
1308                                 attrs, "objectClass=dnsNode");
1309         if (ldb_ret == LDB_ERR_NO_SUCH_OBJECT) {
1310                 ldb_dn_remove_child_components(dn, 1);
1311                 access_mask = SEC_ADS_CREATE_CHILD;
1312                 talloc_free(res);
1313         } else if (ldb_ret == LDB_SUCCESS) {
1314                 access_mask = SEC_STD_REQUIRED | SEC_ADS_SELF_WRITE;
1315                 talloc_free(res);
1316         } else {
1317                 talloc_free(tmp_ctx);
1318                 return ISC_FALSE;
1319         }
1320
1321         /* Do ACL check */
1322         ldb_ret = dsdb_check_access_on_dn(state->samdb, tmp_ctx, dn,
1323                                                 session_info->security_token,
1324                                                 access_mask, NULL);
1325         if (ldb_ret != LDB_SUCCESS) {
1326                 state->log(ISC_LOG_INFO,
1327                         "samba_dlz: disallowing update of signer=%s name=%s type=%s error=%s",
1328                         signer, name, type, ldb_strerror(ldb_ret));
1329                 talloc_free(tmp_ctx);
1330                 return ISC_FALSE;
1331         }
1332
1333         /* Cache session_info, so it can be used in the actual add/delete operation */
1334         state->update_name = talloc_strdup(state, name);
1335         if (state->update_name == NULL) {
1336                 state->log(ISC_LOG_ERROR, "samba_dlz: memory allocation error");
1337                 talloc_free(tmp_ctx);
1338                 return ISC_FALSE;
1339         }
1340         state->session_info = talloc_steal(state, session_info);
1341
1342         state->log(ISC_LOG_INFO, "samba_dlz: allowing update of signer=%s name=%s tcpaddr=%s type=%s key=%s",
1343                    signer, name, tcpaddr, type, key);
1344
1345         talloc_free(tmp_ctx);
1346         return ISC_TRUE;
1347 }
1348
1349
1350 /*
1351   add a new record
1352  */
1353 static isc_result_t b9_add_record(struct dlz_bind9_data *state, const char *name,
1354                                   struct ldb_dn *dn,
1355                                   struct dnsp_DnssrvRpcRecord *rec)
1356 {
1357         struct ldb_message *msg;
1358         enum ndr_err_code ndr_err;
1359         struct ldb_val v;
1360         int ret;
1361
1362         msg = ldb_msg_new(rec);
1363         if (msg == NULL) {
1364                 return ISC_R_NOMEMORY;
1365         }
1366         msg->dn = dn;
1367         ret = ldb_msg_add_string(msg, "objectClass", "dnsNode");
1368         if (ret != LDB_SUCCESS) {
1369                 return ISC_R_FAILURE;
1370         }
1371
1372         ndr_err = ndr_push_struct_blob(&v, rec, rec, (ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
1373         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1374                 return ISC_R_FAILURE;
1375         }
1376         ret = ldb_msg_add_value(msg, "dnsRecord", &v, NULL);
1377         if (ret != LDB_SUCCESS) {
1378                 return ISC_R_FAILURE;
1379         }
1380
1381         ret = ldb_add(state->samdb, msg);
1382         if (ret != LDB_SUCCESS) {
1383                 return ISC_R_FAILURE;
1384         }
1385
1386         return ISC_R_SUCCESS;
1387 }
1388
1389 /*
1390   see if two DNS names are the same
1391  */
1392 static bool dns_name_equal(const char *name1, const char *name2)
1393 {
1394         size_t len1 = strlen(name1);
1395         size_t len2 = strlen(name2);
1396         if (name1[len1-1] == '.') len1--;
1397         if (name2[len2-1] == '.') len2--;
1398         if (len1 != len2) {
1399                 return false;
1400         }
1401         return strncasecmp_m(name1, name2, len1) == 0;
1402 }
1403
1404
1405 /*
1406   see if two dns records match
1407  */
1408 static bool b9_record_match(struct dlz_bind9_data *state,
1409                             struct dnsp_DnssrvRpcRecord *rec1, struct dnsp_DnssrvRpcRecord *rec2)
1410 {
1411         bool status;
1412         int i;
1413         struct in6_addr rec1_in_addr6;
1414         struct in6_addr rec2_in_addr6;
1415
1416         if (rec1->wType != rec2->wType) {
1417                 return false;
1418         }
1419         /* see if this type is single valued */
1420         if (b9_single_valued(rec1->wType)) {
1421                 return true;
1422         }
1423
1424         /* see if the data matches */
1425         switch (rec1->wType) {
1426         case DNS_TYPE_A:
1427                 return strcmp(rec1->data.ipv4, rec2->data.ipv4) == 0;
1428         case DNS_TYPE_AAAA:
1429                 inet_pton(AF_INET6, rec1->data.ipv6, &rec1_in_addr6);
1430                 inet_pton(AF_INET6, rec2->data.ipv6, &rec2_in_addr6);
1431                 return memcmp(&rec1_in_addr6, &rec2_in_addr6, sizeof(rec1_in_addr6)) == 0;
1432         case DNS_TYPE_CNAME:
1433                 return dns_name_equal(rec1->data.cname, rec2->data.cname);
1434         case DNS_TYPE_TXT:
1435                 status = (rec1->data.txt.count == rec2->data.txt.count);
1436                 if (!status) return status;
1437                 for (i=0; i<rec1->data.txt.count; i++) {
1438                         status &= (strcmp(rec1->data.txt.str[i], rec2->data.txt.str[i]) == 0);
1439                 }
1440                 return status;
1441         case DNS_TYPE_PTR:
1442                 return dns_name_equal(rec1->data.ptr, rec2->data.ptr);
1443         case DNS_TYPE_NS:
1444                 return dns_name_equal(rec1->data.ns, rec2->data.ns);
1445
1446         case DNS_TYPE_SRV:
1447                 return rec1->data.srv.wPriority == rec2->data.srv.wPriority &&
1448                         rec1->data.srv.wWeight  == rec2->data.srv.wWeight &&
1449                         rec1->data.srv.wPort    == rec2->data.srv.wPort &&
1450                         dns_name_equal(rec1->data.srv.nameTarget, rec2->data.srv.nameTarget);
1451
1452         case DNS_TYPE_MX:
1453                 return rec1->data.mx.wPriority == rec2->data.mx.wPriority &&
1454                         dns_name_equal(rec1->data.mx.nameTarget, rec2->data.mx.nameTarget);
1455
1456         case DNS_TYPE_HINFO:
1457                 return strcmp(rec1->data.hinfo.cpu, rec2->data.hinfo.cpu) == 0 &&
1458                         strcmp(rec1->data.hinfo.os, rec2->data.hinfo.os) == 0;
1459
1460         case DNS_TYPE_SOA:
1461                 return dns_name_equal(rec1->data.soa.mname, rec2->data.soa.mname) &&
1462                         dns_name_equal(rec1->data.soa.rname, rec2->data.soa.rname) &&
1463                         rec1->data.soa.serial == rec2->data.soa.serial &&
1464                         rec1->data.soa.refresh == rec2->data.soa.refresh &&
1465                         rec1->data.soa.retry == rec2->data.soa.retry &&
1466                         rec1->data.soa.expire == rec2->data.soa.expire &&
1467                         rec1->data.soa.minimum == rec2->data.soa.minimum;
1468         default:
1469                 state->log(ISC_LOG_ERROR, "samba_dlz b9_record_match: unhandled record type %u",
1470                            rec1->wType);
1471                 break;
1472         }
1473
1474         return false;
1475 }
1476
1477 /*
1478  * Update session_info on samdb using the cached credentials
1479  */
1480 static bool b9_set_session_info(struct dlz_bind9_data *state, const char *name)
1481 {
1482         int ret;
1483
1484         if (state->update_name == NULL || state->session_info == NULL) {
1485                 state->log(ISC_LOG_ERROR, "samba_dlz: invalid credentials");
1486                 return false;
1487         }
1488
1489         /* Do not use client credentials, if we're not updating the client specified name */
1490         if (strcmp(state->update_name, name) != 0) {
1491                 return true;
1492         }
1493
1494         ret = ldb_set_opaque(state->samdb, "sessionInfo", state->session_info);
1495         if (ret != LDB_SUCCESS) {
1496                 state->log(ISC_LOG_ERROR, "samba_dlz: unable to set session info");
1497                 return false;
1498         }
1499
1500         return true;
1501 }
1502
1503 /*
1504  * Reset session_info on samdb as system session
1505  */
1506 static void b9_reset_session_info(struct dlz_bind9_data *state)
1507 {
1508         ldb_set_opaque(state->samdb, "sessionInfo", system_session(state->lp));
1509 }
1510
1511 /*
1512   add or modify a rdataset
1513  */
1514 _PUBLIC_ isc_result_t dlz_addrdataset(const char *name, const char *rdatastr, void *dbdata, void *version)
1515 {
1516         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1517         struct dnsp_DnssrvRpcRecord *rec;
1518         struct ldb_dn *dn;
1519         isc_result_t result;
1520         struct ldb_result *res;
1521         const char *attrs[] = { "dnsRecord", NULL };
1522         int ret, i;
1523         struct ldb_message_element *el;
1524         enum ndr_err_code ndr_err;
1525         NTTIME t;
1526
1527         if (state->transaction_token != (void*)version) {
1528                 state->log(ISC_LOG_INFO, "samba_dlz: bad transaction version");
1529                 return ISC_R_FAILURE;
1530         }
1531
1532         rec = talloc_zero(state, struct dnsp_DnssrvRpcRecord);
1533         if (rec == NULL) {
1534                 return ISC_R_NOMEMORY;
1535         }
1536
1537         unix_to_nt_time(&t, time(NULL));
1538         t /= 10*1000*1000; /* convert to seconds (NT time is in 100ns units) */
1539         t /= 3600;         /* convert to hours */
1540
1541         rec->rank        = DNS_RANK_ZONE;
1542         rec->dwSerial    = state->soa_serial;
1543         rec->dwTimeStamp = (uint32_t)t;
1544
1545         if (!b9_parse(state, rdatastr, rec)) {
1546                 state->log(ISC_LOG_INFO, "samba_dlz: failed to parse rdataset '%s'", rdatastr);
1547                 talloc_free(rec);
1548                 return ISC_R_FAILURE;
1549         }
1550
1551         /* find the DN of the record */
1552         result = b9_find_name_dn(state, name, rec, &dn);
1553         if (result != ISC_R_SUCCESS) {
1554                 talloc_free(rec);
1555                 return result;
1556         }
1557
1558         /* get any existing records */
1559         ret = ldb_search(state->samdb, rec, &res, dn, LDB_SCOPE_BASE, attrs, "objectClass=dnsNode");
1560         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1561                 if (!b9_set_session_info(state, name)) {
1562                         talloc_free(rec);
1563                         return ISC_R_FAILURE;
1564                 }
1565                 result = b9_add_record(state, name, dn, rec);
1566                 b9_reset_session_info(state);
1567                 talloc_free(rec);
1568                 if (result == ISC_R_SUCCESS) {
1569                         state->log(ISC_LOG_INFO, "samba_dlz: added %s %s", name, rdatastr);
1570                 }
1571                 return result;
1572         }
1573
1574         el = ldb_msg_find_element(res->msgs[0], "dnsRecord");
1575         if (el == NULL) {
1576                 ret = ldb_msg_add_empty(res->msgs[0], "dnsRecord", LDB_FLAG_MOD_ADD, &el);
1577                 if (ret != LDB_SUCCESS) {
1578                         state->log(ISC_LOG_ERROR, "samba_dlz: failed to add dnsRecord for %s",
1579                                    ldb_dn_get_linearized(dn));
1580                         talloc_free(rec);
1581                         return ISC_R_FAILURE;
1582                 }
1583         }
1584
1585         /* there are existing records. We need to see if this will
1586          * replace a record or add to it
1587          */
1588         for (i=0; i<el->num_values; i++) {
1589                 struct dnsp_DnssrvRpcRecord rec2;
1590
1591                 ndr_err = ndr_pull_struct_blob(&el->values[i], rec, &rec2,
1592                                                (ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
1593                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1594                         state->log(ISC_LOG_ERROR, "samba_dlz: failed to parse dnsRecord for %s",
1595                                    ldb_dn_get_linearized(dn));
1596                         talloc_free(rec);
1597                         return ISC_R_FAILURE;
1598                 }
1599
1600                 if (b9_record_match(state, rec, &rec2)) {
1601                         break;
1602                 }
1603         }
1604         if (i == el->num_values) {
1605                 /* adding a new value */
1606                 el->values = talloc_realloc(el, el->values, struct ldb_val, el->num_values+1);
1607                 if (el->values == NULL) {
1608                         talloc_free(rec);
1609                         return ISC_R_NOMEMORY;
1610                 }
1611                 el->num_values++;
1612         }
1613
1614         ndr_err = ndr_push_struct_blob(&el->values[i], rec, rec,
1615                                        (ndr_push_flags_fn_t)ndr_push_dnsp_DnssrvRpcRecord);
1616         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1617                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to push dnsRecord for %s",
1618                            ldb_dn_get_linearized(dn));
1619                 talloc_free(rec);
1620                 return ISC_R_FAILURE;
1621         }
1622
1623
1624         if (!b9_set_session_info(state, name)) {
1625                 talloc_free(rec);
1626                 return ISC_R_FAILURE;
1627         }
1628
1629         /* modify the record */
1630         el->flags = LDB_FLAG_MOD_REPLACE;
1631         ret = ldb_modify(state->samdb, res->msgs[0]);
1632         b9_reset_session_info(state);
1633         if (ret != LDB_SUCCESS) {
1634                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to modify %s - %s",
1635                            ldb_dn_get_linearized(dn), ldb_errstring(state->samdb));
1636                 talloc_free(rec);
1637                 return ISC_R_FAILURE;
1638         }
1639
1640         state->log(ISC_LOG_INFO, "samba_dlz: added rdataset %s '%s'", name, rdatastr);
1641
1642         talloc_free(rec);
1643         return ISC_R_SUCCESS;
1644 }
1645
1646 /*
1647   remove a rdataset
1648  */
1649 _PUBLIC_ isc_result_t dlz_subrdataset(const char *name, const char *rdatastr, void *dbdata, void *version)
1650 {
1651         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1652         struct dnsp_DnssrvRpcRecord *rec;
1653         struct ldb_dn *dn;
1654         isc_result_t result;
1655         struct ldb_result *res;
1656         const char *attrs[] = { "dnsRecord", NULL };
1657         int ret, i;
1658         struct ldb_message_element *el;
1659         enum ndr_err_code ndr_err;
1660
1661         if (state->transaction_token != (void*)version) {
1662                 state->log(ISC_LOG_ERROR, "samba_dlz: bad transaction version");
1663                 return ISC_R_FAILURE;
1664         }
1665
1666         rec = talloc_zero(state, struct dnsp_DnssrvRpcRecord);
1667         if (rec == NULL) {
1668                 return ISC_R_NOMEMORY;
1669         }
1670
1671         if (!b9_parse(state, rdatastr, rec)) {
1672                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to parse rdataset '%s'", rdatastr);
1673                 talloc_free(rec);
1674                 return ISC_R_FAILURE;
1675         }
1676
1677         /* find the DN of the record */
1678         result = b9_find_name_dn(state, name, rec, &dn);
1679         if (result != ISC_R_SUCCESS) {
1680                 talloc_free(rec);
1681                 return result;
1682         }
1683
1684         /* get the existing records */
1685         ret = ldb_search(state->samdb, rec, &res, dn, LDB_SCOPE_BASE, attrs, "objectClass=dnsNode");
1686         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1687                 talloc_free(rec);
1688                 return ISC_R_NOTFOUND;
1689         }
1690
1691         /* there are existing records. We need to see if any match
1692          */
1693         el = ldb_msg_find_element(res->msgs[0], "dnsRecord");
1694         if (el == NULL || el->num_values == 0) {
1695                 state->log(ISC_LOG_ERROR, "samba_dlz: no dnsRecord attribute for %s",
1696                            ldb_dn_get_linearized(dn));
1697                 talloc_free(rec);
1698                 return ISC_R_FAILURE;
1699         }
1700
1701         for (i=0; i<el->num_values; i++) {
1702                 struct dnsp_DnssrvRpcRecord rec2;
1703
1704                 ndr_err = ndr_pull_struct_blob(&el->values[i], rec, &rec2,
1705                                                (ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
1706                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1707                         state->log(ISC_LOG_ERROR, "samba_dlz: failed to parse dnsRecord for %s",
1708                                    ldb_dn_get_linearized(dn));
1709                         talloc_free(rec);
1710                         return ISC_R_FAILURE;
1711                 }
1712
1713                 if (b9_record_match(state, rec, &rec2)) {
1714                         break;
1715                 }
1716         }
1717         if (i == el->num_values) {
1718                 talloc_free(rec);
1719                 return ISC_R_NOTFOUND;
1720         }
1721
1722         if (i < el->num_values-1) {
1723                 memmove(&el->values[i], &el->values[i+1], sizeof(el->values[0])*((el->num_values-1)-i));
1724         }
1725         el->num_values--;
1726
1727         if (!b9_set_session_info(state, name)) {
1728                 talloc_free(rec);
1729                 return ISC_R_FAILURE;
1730         }
1731
1732         if (el->num_values == 0) {
1733                 el->flags = LDB_FLAG_MOD_DELETE;
1734         } else {
1735                 el->flags = LDB_FLAG_MOD_REPLACE;
1736         }
1737         ret = ldb_modify(state->samdb, res->msgs[0]);
1738
1739         b9_reset_session_info(state);
1740         if (ret != LDB_SUCCESS) {
1741                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to modify %s - %s",
1742                            ldb_dn_get_linearized(dn), ldb_errstring(state->samdb));
1743                 talloc_free(rec);
1744                 return ISC_R_FAILURE;
1745         }
1746
1747         state->log(ISC_LOG_INFO, "samba_dlz: subtracted rdataset %s '%s'", name, rdatastr);
1748
1749         talloc_free(rec);
1750         return ISC_R_SUCCESS;
1751 }
1752
1753
1754 /*
1755   delete all records of the given type
1756  */
1757 _PUBLIC_ isc_result_t dlz_delrdataset(const char *name, const char *type, void *dbdata, void *version)
1758 {
1759         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1760         TALLOC_CTX *tmp_ctx;
1761         struct ldb_dn *dn;
1762         isc_result_t result;
1763         struct ldb_result *res;
1764         const char *attrs[] = { "dnsRecord", NULL };
1765         int ret, i;
1766         struct ldb_message_element *el;
1767         enum ndr_err_code ndr_err;
1768         enum dns_record_type dns_type;
1769         bool found = false;
1770
1771         if (state->transaction_token != (void*)version) {
1772                 state->log(ISC_LOG_ERROR, "samba_dlz: bad transaction version");
1773                 return ISC_R_FAILURE;
1774         }
1775
1776         if (!b9_dns_type(type, &dns_type)) {
1777                 state->log(ISC_LOG_ERROR, "samba_dlz: bad dns type %s in delete", type);
1778                 return ISC_R_FAILURE;
1779         }
1780
1781         tmp_ctx = talloc_new(state);
1782
1783         /* find the DN of the record */
1784         result = b9_find_name_dn(state, name, tmp_ctx, &dn);
1785         if (result != ISC_R_SUCCESS) {
1786                 talloc_free(tmp_ctx);
1787                 return result;
1788         }
1789
1790         /* get the existing records */
1791         ret = ldb_search(state->samdb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, attrs, "objectClass=dnsNode");
1792         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1793                 talloc_free(tmp_ctx);
1794                 return ISC_R_NOTFOUND;
1795         }
1796
1797         /* there are existing records. We need to see if any match the type
1798          */
1799         el = ldb_msg_find_element(res->msgs[0], "dnsRecord");
1800         if (el == NULL || el->num_values == 0) {
1801                 talloc_free(tmp_ctx);
1802                 return ISC_R_NOTFOUND;
1803         }
1804
1805         for (i=0; i<el->num_values; i++) {
1806                 struct dnsp_DnssrvRpcRecord rec2;
1807
1808                 ndr_err = ndr_pull_struct_blob(&el->values[i], tmp_ctx, &rec2,
1809                                                (ndr_pull_flags_fn_t)ndr_pull_dnsp_DnssrvRpcRecord);
1810                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1811                         state->log(ISC_LOG_ERROR, "samba_dlz: failed to parse dnsRecord for %s",
1812                                    ldb_dn_get_linearized(dn));
1813                         talloc_free(tmp_ctx);
1814                         return ISC_R_FAILURE;
1815                 }
1816
1817                 if (dns_type == rec2.wType) {
1818                         if (i < el->num_values-1) {
1819                                 memmove(&el->values[i], &el->values[i+1],
1820                                         sizeof(el->values[0])*((el->num_values-1)-i));
1821                         }
1822                         el->num_values--;
1823                         i--;
1824                         found = true;
1825                 }
1826         }
1827
1828         if (!found) {
1829                 talloc_free(tmp_ctx);
1830                 return ISC_R_FAILURE;
1831         }
1832
1833         if (!b9_set_session_info(state, name)) {
1834                 talloc_free(tmp_ctx);
1835                 return ISC_R_FAILURE;
1836         }
1837
1838         if (el->num_values == 0) {
1839                 el->flags = LDB_FLAG_MOD_DELETE;
1840         } else {
1841                 el->flags = LDB_FLAG_MOD_REPLACE;
1842         }
1843         ret = ldb_modify(state->samdb, res->msgs[0]);
1844
1845         b9_reset_session_info(state);
1846         if (ret != LDB_SUCCESS) {
1847                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to delete type %s in %s - %s",
1848                            type, ldb_dn_get_linearized(dn), ldb_errstring(state->samdb));
1849                 talloc_free(tmp_ctx);
1850                 return ISC_R_FAILURE;
1851         }
1852
1853         state->log(ISC_LOG_INFO, "samba_dlz: deleted rdataset %s of type %s", name, type);
1854
1855         talloc_free(tmp_ctx);
1856         return ISC_R_SUCCESS;
1857 }