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                 WERROR werr;
 922                 struct dnsp_DnssrvRpcRecord *recs = NULL;
 923                 uint16_t num_recs = 0;
 924
 925                 el = ldb_msg_find_element(res->msgs[i], "dnsRecord");
 926                 if (el == NULL || el->num_values == 0) {
 927                         state->log(ISC_LOG_INFO, "failed to find dnsRecord for %s",
 928                                    ldb_dn_get_linearized(dn));
 929                         talloc_free(el_ctx);
 930                         continue;
 931                 }
 932
 933                 v = ldb_dn_get_rdn_val(res->msgs[i]->dn);
 934                 if (v == NULL) {
 935                         state->log(ISC_LOG_INFO, "failed to find RDN for %s",
 936                                    ldb_dn_get_linearized(dn));
 937                         talloc_free(el_ctx);
 938                         continue;
 939                 }
 940
 941                 rdn = talloc_strndup(el_ctx, (char *)v->data, v->length);
 942                 if (rdn == NULL) {
 943                         talloc_free(tmp_ctx);
 944                         return ISC_R_NOMEMORY;
 945                 }
 946
 947                 if (strcmp(rdn, "@") == 0) {
 948                         name = zone;
 949                 } else {
 950                         name = talloc_asprintf(el_ctx, "%s.%s", rdn, zone);
 951                 }
 952                 if (name == NULL) {
 953                         talloc_free(tmp_ctx);
 954                         return ISC_R_NOMEMORY;
 955                 }
 956
 957                 werr = dns_common_extract(el, el_ctx, &recs, &num_recs);
 958                 if (!W_ERROR_IS_OK(werr)) {
 959                         state->log(ISC_LOG_ERROR, "samba_dlz: failed to parse dnsRecord for %s, %s",
 960                                    ldb_dn_get_linearized(dn), win_errstr(werr));
 961                         talloc_free(el_ctx);
 962                         continue;
 963                 }
 964
 965                 for (j=0; j < num_recs; j++) {
 966                         isc_result_t result;
 967
 968                         result = b9_putnamedrr(state, allnodes, name, &recs[j]);
 969                         if (result != ISC_R_SUCCESS) {
 970                                 continue;
 971                         }
 972                 }
 973
 974                 talloc_free(el_ctx);
 975         }
 976
 977         talloc_free(tmp_ctx);
 978
 979         return ISC_R_SUCCESS;
 980 }
 981
 982
 983 /*
 984   start a transaction
 985  */
 986 _PUBLIC_ isc_result_t dlz_newversion(const char *zone, void *dbdata, void **versionp)
 987 {
 988         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
 989
 990         state->log(ISC_LOG_INFO, "samba_dlz: starting transaction on zone %s", zone);
 991
 992         if (state->transaction_token != NULL) {
 993                 state->log(ISC_LOG_INFO, "samba_dlz: transaction already started for zone %s", zone);
 994                 return ISC_R_FAILURE;
 995         }
 996
 997         state->transaction_token = talloc_zero(state, int);
 998         if (state->transaction_token == NULL) {
 999                 return ISC_R_NOMEMORY;
1000         }
1001
1002         if (ldb_transaction_start(state->samdb) != LDB_SUCCESS) {
1003                 state->log(ISC_LOG_INFO, "samba_dlz: failed to start a transaction for zone %s", zone);
1004                 talloc_free(state->transaction_token);
1005                 state->transaction_token = NULL;
1006                 return ISC_R_FAILURE;
1007         }
1008
1009         *versionp = (void *)state->transaction_token;
1010
1011         return ISC_R_SUCCESS;
1012 }
1013
1014 /*
1015   end a transaction
1016  */
1017 _PUBLIC_ void dlz_closeversion(const char *zone, isc_boolean_t commit,
1018                                void *dbdata, void **versionp)
1019 {
1020         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1021
1022         if (state->transaction_token != (int *)*versionp) {
1023                 state->log(ISC_LOG_INFO, "samba_dlz: transaction not started for zone %s", zone);
1024                 return;
1025         }
1026
1027         if (commit) {
1028                 if (ldb_transaction_commit(state->samdb) != LDB_SUCCESS) {
1029                         state->log(ISC_LOG_INFO, "samba_dlz: failed to commit a transaction for zone %s", zone);
1030                         return;
1031                 }
1032                 state->log(ISC_LOG_INFO, "samba_dlz: committed transaction on zone %s", zone);
1033         } else {
1034                 if (ldb_transaction_cancel(state->samdb) != LDB_SUCCESS) {
1035                         state->log(ISC_LOG_INFO, "samba_dlz: failed to cancel a transaction for zone %s", zone);
1036                         return;
1037                 }
1038                 state->log(ISC_LOG_INFO, "samba_dlz: cancelling transaction on zone %s", zone);
1039         }
1040
1041         talloc_free(state->transaction_token);
1042         state->transaction_token = NULL;
1043         *versionp = NULL;
1044 }
1045
1046
1047 /*
1048   see if there is a SOA record for a zone
1049  */
1050 static bool b9_has_soa(struct dlz_bind9_data *state, struct ldb_dn *dn, const char *zone)
1051 {
1052         TALLOC_CTX *tmp_ctx = talloc_new(state);
1053         WERROR werr;
1054         struct dnsp_DnssrvRpcRecord *records = NULL;
1055         uint16_t num_records = 0, i;
1056
1057         if (!ldb_dn_add_child_fmt(dn, "DC=@,DC=%s", zone)) {
1058                 talloc_free(tmp_ctx);
1059                 return false;
1060         }
1061
1062         werr = dns_common_lookup(state->samdb, tmp_ctx, dn,
1063                                  &records, &num_records, NULL);
1064         if (!W_ERROR_IS_OK(werr)) {
1065                 talloc_free(tmp_ctx);
1066                 return false;
1067         }
1068
1069         for (i=0; i < num_records; i++) {
1070                 if (records[i].wType == DNS_TYPE_SOA) {
1071                         talloc_free(tmp_ctx);
1072                         return true;
1073                 }
1074         }
1075
1076         talloc_free(tmp_ctx);
1077         return false;
1078 }
1079
1080 static bool b9_zone_add(struct dlz_bind9_data *state, const char *name)
1081 {
1082         struct b9_zone *zone;
1083
1084         zone = talloc_zero(state, struct b9_zone);
1085         if (zone == NULL) {
1086                 return false;
1087         }
1088
1089         zone->name = talloc_strdup(zone, name);
1090         if (zone->name == NULL) {
1091                 talloc_free(zone);
1092                 return false;
1093         }
1094
1095         DLIST_ADD(state->zonelist, zone);
1096         return true;
1097 }
1098
1099 static bool b9_zone_exists(struct dlz_bind9_data *state, const char *name)
1100 {
1101         struct b9_zone *zone = state->zonelist;
1102         bool found = false;
1103
1104         while (zone != NULL) {
1105                 if (strcasecmp(name, zone->name) == 0) {
1106                         found = true;
1107                         break;
1108                 }
1109                 zone = zone->next;
1110         }
1111
1112         return found;
1113 }
1114
1115
1116 /*
1117   configure a writeable zone
1118  */
1119 _PUBLIC_ isc_result_t dlz_configure(dns_view_t *view, void *dbdata)
1120 {
1121         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1122         TALLOC_CTX *tmp_ctx;
1123         struct ldb_dn *dn;
1124         int i;
1125
1126         state->log(ISC_LOG_INFO, "samba_dlz: starting configure");
1127         if (state->writeable_zone == NULL) {
1128                 state->log(ISC_LOG_INFO, "samba_dlz: no writeable_zone method available");
1129                 return ISC_R_FAILURE;
1130         }
1131
1132         tmp_ctx = talloc_new(state);
1133
1134         for (i=0; zone_prefixes[i]; i++) {
1135                 const char *attrs[] = { "name", NULL };
1136                 int j, ret;
1137                 struct ldb_result *res;
1138
1139                 dn = ldb_dn_copy(tmp_ctx, ldb_get_default_basedn(state->samdb));
1140                 if (dn == NULL) {
1141                         talloc_free(tmp_ctx);
1142                         return ISC_R_NOMEMORY;
1143                 }
1144
1145                 if (!ldb_dn_add_child_fmt(dn, "%s", zone_prefixes[i])) {
1146                         talloc_free(tmp_ctx);
1147                         return ISC_R_NOMEMORY;
1148                 }
1149
1150                 ret = ldb_search(state->samdb, tmp_ctx, &res, dn, LDB_SCOPE_SUBTREE,
1151                                  attrs, "objectClass=dnsZone");
1152                 if (ret != LDB_SUCCESS) {
1153                         continue;
1154                 }
1155
1156                 for (j=0; j<res->count; j++) {
1157                         isc_result_t result;
1158                         const char *zone = ldb_msg_find_attr_as_string(res->msgs[j], "name", NULL);
1159                         struct ldb_dn *zone_dn;
1160
1161                         if (zone == NULL) {
1162                                 continue;
1163                         }
1164                         /* Ignore zones that are not handled in BIND */
1165                         if ((strcmp(zone, "RootDNSServers") == 0) ||
1166                             (strcmp(zone, "..TrustAnchors") == 0)) {
1167                                 continue;
1168                         }
1169                         zone_dn = ldb_dn_copy(tmp_ctx, dn);
1170                         if (zone_dn == NULL) {
1171                                 talloc_free(tmp_ctx);
1172                                 return ISC_R_NOMEMORY;
1173                         }
1174
1175                         if (!b9_has_soa(state, zone_dn, zone)) {
1176                                 continue;
1177                         }
1178
1179                         if (b9_zone_exists(state, zone)) {
1180                                 state->log(ISC_LOG_WARNING, "samba_dlz: Ignoring duplicate zone '%s' from '%s'",
1181                                            zone, ldb_dn_get_linearized(zone_dn));
1182                                 continue;
1183                         }
1184
1185                         if (!b9_zone_add(state, zone)) {
1186                                 talloc_free(tmp_ctx);
1187                                 return ISC_R_NOMEMORY;
1188                         }
1189
1190                         result = state->writeable_zone(view, zone);
1191                         if (result != ISC_R_SUCCESS) {
1192                                 state->log(ISC_LOG_ERROR, "samba_dlz: Failed to configure zone '%s'",
1193                                            zone);
1194                                 talloc_free(tmp_ctx);
1195                                 return result;
1196                         }
1197                         state->log(ISC_LOG_INFO, "samba_dlz: configured writeable zone '%s'", zone);
1198                 }
1199         }
1200
1201         talloc_free(tmp_ctx);
1202         return ISC_R_SUCCESS;
1203 }
1204
1205 /*
1206   authorize a zone update
1207  */
1208 _PUBLIC_ isc_boolean_t dlz_ssumatch(const char *signer, const char *name, const char *tcpaddr,
1209                                     const char *type, const char *key, uint32_t keydatalen, uint8_t *keydata,
1210                                     void *dbdata)
1211 {
1212         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1213         TALLOC_CTX *tmp_ctx;
1214         DATA_BLOB ap_req;
1215         struct cli_credentials *server_credentials;
1216         char *keytab_name;
1217         int ret;
1218         int ldb_ret;
1219         NTSTATUS nt_status;
1220         struct gensec_security *gensec_ctx;
1221         struct auth_session_info *session_info;
1222         struct ldb_dn *dn;
1223         isc_result_t result;
1224         struct ldb_result *res;
1225         const char * attrs[] = { NULL };
1226         uint32_t access_mask;
1227
1228         /* Remove cached credentials, if any */
1229         if (state->session_info) {
1230                 talloc_free(state->session_info);
1231                 state->session_info = NULL;
1232         }
1233         if (state->update_name) {
1234                 talloc_free(state->update_name);
1235                 state->update_name = NULL;
1236         }
1237
1238         tmp_ctx = talloc_new(NULL);
1239         if (tmp_ctx == NULL) {
1240                 state->log(ISC_LOG_ERROR, "samba_dlz: no memory");
1241                 return ISC_FALSE;
1242         }
1243
1244         ap_req = data_blob_const(keydata, keydatalen);
1245         server_credentials = cli_credentials_init(tmp_ctx);
1246         if (!server_credentials) {
1247                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to init server credentials");
1248                 talloc_free(tmp_ctx);
1249                 return ISC_FALSE;
1250         }
1251
1252         cli_credentials_set_krb5_context(server_credentials, state->smb_krb5_ctx);
1253         cli_credentials_set_conf(server_credentials, state->lp);
1254
1255         keytab_name = talloc_asprintf(tmp_ctx, "file:%s/dns.keytab",
1256                                         lpcfg_private_dir(state->lp));
1257         ret = cli_credentials_set_keytab_name(server_credentials, state->lp, keytab_name,
1258                                                 CRED_SPECIFIED);
1259         if (ret != 0) {
1260                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to obtain server credentials from %s",
1261                            keytab_name);
1262                 talloc_free(tmp_ctx);
1263                 return ISC_FALSE;
1264         }
1265         talloc_free(keytab_name);
1266
1267         nt_status = gensec_server_start(tmp_ctx,
1268                                         lpcfg_gensec_settings(tmp_ctx, state->lp),
1269                                         state->auth_context, &gensec_ctx);
1270         if (!NT_STATUS_IS_OK(nt_status)) {
1271                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to start gensec server");
1272                 talloc_free(tmp_ctx);
1273                 return ISC_FALSE;
1274         }
1275
1276         gensec_set_credentials(gensec_ctx, server_credentials);
1277
1278         nt_status = gensec_start_mech_by_name(gensec_ctx, "spnego");
1279         if (!NT_STATUS_IS_OK(nt_status)) {
1280                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to start spnego");
1281                 talloc_free(tmp_ctx);
1282                 return ISC_FALSE;
1283         }
1284
1285         nt_status = gensec_update_ev(gensec_ctx, tmp_ctx, state->ev_ctx, ap_req, &ap_req);
1286         if (!NT_STATUS_IS_OK(nt_status)) {
1287                 state->log(ISC_LOG_ERROR, "samba_dlz: spnego update failed");
1288                 talloc_free(tmp_ctx);
1289                 return ISC_FALSE;
1290         }
1291
1292         nt_status = gensec_session_info(gensec_ctx, tmp_ctx, &session_info);
1293         if (!NT_STATUS_IS_OK(nt_status)) {
1294                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to create session info");
1295                 talloc_free(tmp_ctx);
1296                 return ISC_FALSE;
1297         }
1298
1299         /* Get the DN from name */
1300         result = b9_find_name_dn(state, name, tmp_ctx, &dn);
1301         if (result != ISC_R_SUCCESS) {
1302                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to find name %s", name);
1303                 talloc_free(tmp_ctx);
1304                 return ISC_FALSE;
1305         }
1306
1307         /* make sure the dn exists, or find parent dn in case new object is being added */
1308         ldb_ret = ldb_search(state->samdb, tmp_ctx, &res, dn, LDB_SCOPE_BASE,
1309                                 attrs, "objectClass=dnsNode");
1310         if (ldb_ret == LDB_ERR_NO_SUCH_OBJECT) {
1311                 ldb_dn_remove_child_components(dn, 1);
1312                 access_mask = SEC_ADS_CREATE_CHILD;
1313                 talloc_free(res);
1314         } else if (ldb_ret == LDB_SUCCESS) {
1315                 access_mask = SEC_STD_REQUIRED | SEC_ADS_SELF_WRITE;
1316                 talloc_free(res);
1317         } else {
1318                 talloc_free(tmp_ctx);
1319                 return ISC_FALSE;
1320         }
1321
1322         /* Do ACL check */
1323         ldb_ret = dsdb_check_access_on_dn(state->samdb, tmp_ctx, dn,
1324                                                 session_info->security_token,
1325                                                 access_mask, NULL);
1326         if (ldb_ret != LDB_SUCCESS) {
1327                 state->log(ISC_LOG_INFO,
1328                         "samba_dlz: disallowing update of signer=%s name=%s type=%s error=%s",
1329                         signer, name, type, ldb_strerror(ldb_ret));
1330                 talloc_free(tmp_ctx);
1331                 return ISC_FALSE;
1332         }
1333
1334         /* Cache session_info, so it can be used in the actual add/delete operation */
1335         state->update_name = talloc_strdup(state, name);
1336         if (state->update_name == NULL) {
1337                 state->log(ISC_LOG_ERROR, "samba_dlz: memory allocation error");
1338                 talloc_free(tmp_ctx);
1339                 return ISC_FALSE;
1340         }
1341         state->session_info = talloc_steal(state, session_info);
1342
1343         state->log(ISC_LOG_INFO, "samba_dlz: allowing update of signer=%s name=%s tcpaddr=%s type=%s key=%s",
1344                    signer, name, tcpaddr, type, key);
1345
1346         talloc_free(tmp_ctx);
1347         return ISC_TRUE;
1348 }
1349
1350 /*
1351   see if two DNS names are the same
1352  */
1353 static bool dns_name_equal(const char *name1, const char *name2)
1354 {
1355         size_t len1 = strlen(name1);
1356         size_t len2 = strlen(name2);
1357         if (name1[len1-1] == '.') len1--;
1358         if (name2[len2-1] == '.') len2--;
1359         if (len1 != len2) {
1360                 return false;
1361         }
1362         return strncasecmp_m(name1, name2, len1) == 0;
1363 }
1364
1365
1366 /*
1367   see if two dns records match
1368  */
1369 static bool b9_record_match(struct dlz_bind9_data *state,
1370                             struct dnsp_DnssrvRpcRecord *rec1, struct dnsp_DnssrvRpcRecord *rec2)
1371 {
1372         bool status;
1373         int i;
1374         struct in6_addr rec1_in_addr6;
1375         struct in6_addr rec2_in_addr6;
1376
1377         if (rec1->wType != rec2->wType) {
1378                 return false;
1379         }
1380         /* see if this type is single valued */
1381         if (b9_single_valued(rec1->wType)) {
1382                 return true;
1383         }
1384
1385         /* see if the data matches */
1386         switch (rec1->wType) {
1387         case DNS_TYPE_A:
1388                 return strcmp(rec1->data.ipv4, rec2->data.ipv4) == 0;
1389         case DNS_TYPE_AAAA:
1390                 inet_pton(AF_INET6, rec1->data.ipv6, &rec1_in_addr6);
1391                 inet_pton(AF_INET6, rec2->data.ipv6, &rec2_in_addr6);
1392                 return memcmp(&rec1_in_addr6, &rec2_in_addr6, sizeof(rec1_in_addr6)) == 0;
1393         case DNS_TYPE_CNAME:
1394                 return dns_name_equal(rec1->data.cname, rec2->data.cname);
1395         case DNS_TYPE_TXT:
1396                 status = (rec1->data.txt.count == rec2->data.txt.count);
1397                 if (!status) return status;
1398                 for (i=0; i<rec1->data.txt.count; i++) {
1399                         status &= (strcmp(rec1->data.txt.str[i], rec2->data.txt.str[i]) == 0);
1400                 }
1401                 return status;
1402         case DNS_TYPE_PTR:
1403                 return dns_name_equal(rec1->data.ptr, rec2->data.ptr);
1404         case DNS_TYPE_NS:
1405                 return dns_name_equal(rec1->data.ns, rec2->data.ns);
1406
1407         case DNS_TYPE_SRV:
1408                 return rec1->data.srv.wPriority == rec2->data.srv.wPriority &&
1409                         rec1->data.srv.wWeight  == rec2->data.srv.wWeight &&
1410                         rec1->data.srv.wPort    == rec2->data.srv.wPort &&
1411                         dns_name_equal(rec1->data.srv.nameTarget, rec2->data.srv.nameTarget);
1412
1413         case DNS_TYPE_MX:
1414                 return rec1->data.mx.wPriority == rec2->data.mx.wPriority &&
1415                         dns_name_equal(rec1->data.mx.nameTarget, rec2->data.mx.nameTarget);
1416
1417         case DNS_TYPE_HINFO:
1418                 return strcmp(rec1->data.hinfo.cpu, rec2->data.hinfo.cpu) == 0 &&
1419                         strcmp(rec1->data.hinfo.os, rec2->data.hinfo.os) == 0;
1420
1421         case DNS_TYPE_SOA:
1422                 return dns_name_equal(rec1->data.soa.mname, rec2->data.soa.mname) &&
1423                         dns_name_equal(rec1->data.soa.rname, rec2->data.soa.rname) &&
1424                         rec1->data.soa.serial == rec2->data.soa.serial &&
1425                         rec1->data.soa.refresh == rec2->data.soa.refresh &&
1426                         rec1->data.soa.retry == rec2->data.soa.retry &&
1427                         rec1->data.soa.expire == rec2->data.soa.expire &&
1428                         rec1->data.soa.minimum == rec2->data.soa.minimum;
1429         default:
1430                 state->log(ISC_LOG_ERROR, "samba_dlz b9_record_match: unhandled record type %u",
1431                            rec1->wType);
1432                 break;
1433         }
1434
1435         return false;
1436 }
1437
1438 /*
1439  * Update session_info on samdb using the cached credentials
1440  */
1441 static bool b9_set_session_info(struct dlz_bind9_data *state, const char *name)
1442 {
1443         int ret;
1444
1445         if (state->update_name == NULL || state->session_info == NULL) {
1446                 state->log(ISC_LOG_ERROR, "samba_dlz: invalid credentials");
1447                 return false;
1448         }
1449
1450         /* Do not use client credentials, if we're not updating the client specified name */
1451         if (strcmp(state->update_name, name) != 0) {
1452                 return true;
1453         }
1454
1455         ret = ldb_set_opaque(state->samdb, "sessionInfo", state->session_info);
1456         if (ret != LDB_SUCCESS) {
1457                 state->log(ISC_LOG_ERROR, "samba_dlz: unable to set session info");
1458                 return false;
1459         }
1460
1461         return true;
1462 }
1463
1464 /*
1465  * Reset session_info on samdb as system session
1466  */
1467 static void b9_reset_session_info(struct dlz_bind9_data *state)
1468 {
1469         ldb_set_opaque(state->samdb, "sessionInfo", system_session(state->lp));
1470 }
1471
1472 /*
1473   add or modify a rdataset
1474  */
1475 _PUBLIC_ isc_result_t dlz_addrdataset(const char *name, const char *rdatastr, void *dbdata, void *version)
1476 {
1477         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1478         struct dnsp_DnssrvRpcRecord *rec;
1479         struct ldb_dn *dn;
1480         isc_result_t result;
1481         bool tombstoned = false;
1482         bool needs_add = false;
1483         struct dnsp_DnssrvRpcRecord *recs = NULL;
1484         uint16_t num_recs = 0;
1485         uint16_t first = 0;
1486         uint16_t i;
1487         NTTIME t;
1488         WERROR werr;
1489
1490         if (state->transaction_token != (void*)version) {
1491                 state->log(ISC_LOG_INFO, "samba_dlz: bad transaction version");
1492                 return ISC_R_FAILURE;
1493         }
1494
1495         rec = talloc_zero(state, struct dnsp_DnssrvRpcRecord);
1496         if (rec == NULL) {
1497                 return ISC_R_NOMEMORY;
1498         }
1499
1500         unix_to_nt_time(&t, time(NULL));
1501         t /= 10*1000*1000; /* convert to seconds (NT time is in 100ns units) */
1502         t /= 3600;         /* convert to hours */
1503
1504         rec->rank        = DNS_RANK_ZONE;
1505         rec->dwTimeStamp = (uint32_t)t;
1506
1507         if (!b9_parse(state, rdatastr, rec)) {
1508                 state->log(ISC_LOG_INFO, "samba_dlz: failed to parse rdataset '%s'", rdatastr);
1509                 talloc_free(rec);
1510                 return ISC_R_FAILURE;
1511         }
1512
1513         /* find the DN of the record */
1514         result = b9_find_name_dn(state, name, rec, &dn);
1515         if (result != ISC_R_SUCCESS) {
1516                 talloc_free(rec);
1517                 return result;
1518         }
1519
1520         /* get any existing records */
1521         werr = dns_common_lookup(state->samdb, rec, dn,
1522                                  &recs, &num_recs, &tombstoned);
1523         if (W_ERROR_EQUAL(werr, WERR_DNS_ERROR_NAME_DOES_NOT_EXIST)) {
1524                 needs_add = true;
1525                 werr = WERR_OK;
1526         }
1527         if (!W_ERROR_IS_OK(werr)) {
1528                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to parse dnsRecord for %s, %s",
1529                            ldb_dn_get_linearized(dn), win_errstr(werr));
1530                 talloc_free(rec);
1531                 return ISC_R_FAILURE;
1532         }
1533
1534         if (tombstoned) {
1535                 /*
1536                  * we need to keep the existing tombstone record
1537                  * and ignore it
1538                  */
1539                 first = num_recs;
1540         }
1541
1542         /* there are existing records. We need to see if this will
1543          * replace a record or add to it
1544          */
1545         for (i=first; i < num_recs; i++) {
1546                 if (b9_record_match(state, rec, &recs[i])) {
1547                         break;
1548                 }
1549         }
1550         if (i == UINT16_MAX) {
1551                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to already %u dnsRecord values for %s",
1552                            i, ldb_dn_get_linearized(dn));
1553                 talloc_free(rec);
1554                 return ISC_R_FAILURE;
1555         }
1556
1557         if (i == num_recs) {
1558                 /* adding a new value */
1559                 recs = talloc_realloc(rec, recs,
1560                                       struct dnsp_DnssrvRpcRecord,
1561                                       num_recs + 1);
1562                 if (recs == NULL) {
1563                         talloc_free(rec);
1564                         return ISC_R_NOMEMORY;
1565                 }
1566                 num_recs++;
1567         }
1568
1569         recs[i] = *rec;
1570
1571         if (!b9_set_session_info(state, name)) {
1572                 talloc_free(rec);
1573                 return ISC_R_FAILURE;
1574         }
1575
1576         /* modify the record */
1577         werr = dns_common_replace(state->samdb, rec, dn,
1578                                   needs_add,
1579                                   state->soa_serial,
1580                                   recs, num_recs);
1581         b9_reset_session_info(state);
1582         if (!W_ERROR_IS_OK(werr)) {
1583                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to %s %s - %s",
1584                            needs_add ? "add" : "modify",
1585                            ldb_dn_get_linearized(dn), win_errstr(werr));
1586                 talloc_free(rec);
1587                 return ISC_R_FAILURE;
1588         }
1589
1590         state->log(ISC_LOG_INFO, "samba_dlz: added rdataset %s '%s'", name, rdatastr);
1591
1592         talloc_free(rec);
1593         return ISC_R_SUCCESS;
1594 }
1595
1596 /*
1597   remove a rdataset
1598  */
1599 _PUBLIC_ isc_result_t dlz_subrdataset(const char *name, const char *rdatastr, void *dbdata, void *version)
1600 {
1601         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1602         struct dnsp_DnssrvRpcRecord *rec;
1603         struct ldb_dn *dn;
1604         isc_result_t result;
1605         struct dnsp_DnssrvRpcRecord *recs = NULL;
1606         uint16_t num_recs = 0;
1607         uint16_t i;
1608         WERROR werr;
1609
1610         if (state->transaction_token != (void*)version) {
1611                 state->log(ISC_LOG_ERROR, "samba_dlz: bad transaction version");
1612                 return ISC_R_FAILURE;
1613         }
1614
1615         rec = talloc_zero(state, struct dnsp_DnssrvRpcRecord);
1616         if (rec == NULL) {
1617                 return ISC_R_NOMEMORY;
1618         }
1619
1620         if (!b9_parse(state, rdatastr, rec)) {
1621                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to parse rdataset '%s'", rdatastr);
1622                 talloc_free(rec);
1623                 return ISC_R_FAILURE;
1624         }
1625
1626         /* find the DN of the record */
1627         result = b9_find_name_dn(state, name, rec, &dn);
1628         if (result != ISC_R_SUCCESS) {
1629                 talloc_free(rec);
1630                 return result;
1631         }
1632
1633         /* get the existing records */
1634         werr = dns_common_lookup(state->samdb, rec, dn,
1635                                  &recs, &num_recs, NULL);
1636         if (!W_ERROR_IS_OK(werr)) {
1637                 talloc_free(rec);
1638                 return ISC_R_NOTFOUND;
1639         }
1640
1641         for (i=0; i < num_recs; i++) {
1642                 if (b9_record_match(state, rec, &recs[i])) {
1643                         recs[i] = (struct dnsp_DnssrvRpcRecord) {
1644                                 .wType = DNS_TYPE_TOMBSTONE,
1645                         };
1646                         break;
1647                 }
1648         }
1649         if (i == num_recs) {
1650                 talloc_free(rec);
1651                 return ISC_R_NOTFOUND;
1652         }
1653
1654         if (!b9_set_session_info(state, name)) {
1655                 talloc_free(rec);
1656                 return ISC_R_FAILURE;
1657         }
1658
1659         /* modify the record */
1660         werr = dns_common_replace(state->samdb, rec, dn,
1661                                   false,/* needs_add */
1662                                   state->soa_serial,
1663                                   recs, num_recs);
1664         b9_reset_session_info(state);
1665         if (!W_ERROR_IS_OK(werr)) {
1666                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to modify %s - %s",
1667                            ldb_dn_get_linearized(dn), win_errstr(werr));
1668                 talloc_free(rec);
1669                 return ISC_R_FAILURE;
1670         }
1671
1672         state->log(ISC_LOG_INFO, "samba_dlz: subtracted rdataset %s '%s'", name, rdatastr);
1673
1674         talloc_free(rec);
1675         return ISC_R_SUCCESS;
1676 }
1677
1678
1679 /*
1680   delete all records of the given type
1681  */
1682 _PUBLIC_ isc_result_t dlz_delrdataset(const char *name, const char *type, void *dbdata, void *version)
1683 {
1684         struct dlz_bind9_data *state = talloc_get_type_abort(dbdata, struct dlz_bind9_data);
1685         TALLOC_CTX *tmp_ctx;
1686         struct ldb_dn *dn;
1687         isc_result_t result;
1688         enum dns_record_type dns_type;
1689         bool found = false;
1690         struct dnsp_DnssrvRpcRecord *recs = NULL;
1691         uint16_t num_recs = 0;
1692         uint16_t ri = 0;
1693         WERROR werr;
1694
1695         if (state->transaction_token != (void*)version) {
1696                 state->log(ISC_LOG_ERROR, "samba_dlz: bad transaction version");
1697                 return ISC_R_FAILURE;
1698         }
1699
1700         if (!b9_dns_type(type, &dns_type)) {
1701                 state->log(ISC_LOG_ERROR, "samba_dlz: bad dns type %s in delete", type);
1702                 return ISC_R_FAILURE;
1703         }
1704
1705         tmp_ctx = talloc_new(state);
1706
1707         /* find the DN of the record */
1708         result = b9_find_name_dn(state, name, tmp_ctx, &dn);
1709         if (result != ISC_R_SUCCESS) {
1710                 talloc_free(tmp_ctx);
1711                 return result;
1712         }
1713
1714         /* get the existing records */
1715         werr = dns_common_lookup(state->samdb, tmp_ctx, dn,
1716                                  &recs, &num_recs, NULL);
1717         if (!W_ERROR_IS_OK(werr)) {
1718                 talloc_free(tmp_ctx);
1719                 return ISC_R_NOTFOUND;
1720         }
1721
1722         for (ri=0; ri < num_recs; ri++) {
1723                 if (dns_type != recs[ri].wType) {
1724                         continue;
1725                 }
1726
1727                 found = true;
1728                 recs[ri] = (struct dnsp_DnssrvRpcRecord) {
1729                         .wType = DNS_TYPE_TOMBSTONE,
1730                 };
1731         }
1732
1733         if (!found) {
1734                 talloc_free(tmp_ctx);
1735                 return ISC_R_FAILURE;
1736         }
1737
1738         if (!b9_set_session_info(state, name)) {
1739                 talloc_free(tmp_ctx);
1740                 return ISC_R_FAILURE;
1741         }
1742
1743         /* modify the record */
1744         werr = dns_common_replace(state->samdb, tmp_ctx, dn,
1745                                   false,/* needs_add */
1746                                   state->soa_serial,
1747                                   recs, num_recs);
1748         b9_reset_session_info(state);
1749         if (!W_ERROR_IS_OK(werr)) {
1750                 state->log(ISC_LOG_ERROR, "samba_dlz: failed to modify %s - %s",
1751                            ldb_dn_get_linearized(dn), win_errstr(werr));
1752                 talloc_free(tmp_ctx);
1753                 return ISC_R_FAILURE;
1754         }
1755
1756         state->log(ISC_LOG_INFO, "samba_dlz: deleted rdataset %s of type %s", name, type);
1757
1758         talloc_free(tmp_ctx);
1759         return ISC_R_SUCCESS;
1760 }