source4/libnet/libnet_become_dc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Copyright (C) Stefan Metzmacher      2006
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22 #include "libnet/libnet.h"
  23 #include "libcli/composite/composite.h"
  24 #include "libcli/cldap/cldap.h"
  25 #include "lib/ldb/include/ldb.h"
  26 #include "lib/ldb/include/ldb_errors.h"
  27 #include "lib/db_wrap.h"
  28 #include "dsdb/samdb/samdb.h"
  29 #include "dsdb/common/flags.h"
  30 #include "librpc/gen_ndr/ndr_drsuapi_c.h"
  31 #include "libcli/security/security.h"
  32
  33 struct libnet_BecomeDC_state {
  34         struct composite_context *creq;
  35
  36         struct libnet_context *libnet;
  37
  38         struct dom_sid zero_sid;
  39
  40         struct {
  41                 struct cldap_socket *sock;
  42                 struct cldap_netlogon io;
  43                 struct nbt_cldap_netlogon_5 netlogon5;
  44         } cldap;
  45
  46         struct becomeDC_ldap {
  47                 struct ldb_context *ldb;
  48                 const struct ldb_message *rootdse;
  49         } ldap1, ldap2;
  50
  51         struct becomeDC_drsuapi {
  52                 struct libnet_BecomeDC_state *s;
  53                 struct dcerpc_binding *binding;
  54                 struct dcerpc_pipe *pipe;
  55                 struct drsuapi_DsBind bind_r;
  56                 struct GUID bind_guid;
  57                 struct drsuapi_DsBindInfoCtr bind_info_ctr;
  58                 struct drsuapi_DsBindInfo28 local_info28;
  59                 struct drsuapi_DsBindInfo28 remote_info28;
  60                 struct policy_handle bind_handle;
  61         } drsuapi1, drsuapi2, drsuapi3;
  62
  63         struct {
  64                 /* input */
  65                 const char *dns_name;
  66                 const char *netbios_name;
  67                 const struct dom_sid *sid;
  68
  69                 /* constructed */
  70                 struct GUID guid;
  71                 const char *dn_str;
  72         } domain;
  73
  74         struct {
  75                 /* constructed */
  76                 const char *dns_name;
  77                 const char *root_dn_str;
  78                 const char *config_dn_str;
  79                 const char *schema_dn_str;
  80         } forest;
  81
  82         struct {
  83                 /* input */
  84                 const char *address;
  85
  86                 /* constructed */
  87                 const char *dns_name;
  88                 const char *netbios_name;
  89                 const char *site_name;
  90                 const char *server_dn_str;
  91                 const char *ntds_dn_str;
  92         } source_dsa;
  93
  94         struct {
  95                 /* input */
  96                 const char *netbios_name;
  97
  98                 /* constructed */
  99                 const char *dns_name;
 100                 const char *site_name;
 101                 struct GUID site_guid;
 102                 const char *computer_dn_str;
 103                 const char *server_dn_str;
 104                 const char *ntds_dn_str;
 105                 struct GUID ntds_guid;
 106                 struct GUID invocation_id;
 107                 uint32_t user_account_control;
 108         } dest_dsa;
 109
 110         struct {
 111                 uint32_t domain_behavior_version;
 112                 uint32_t config_behavior_version;
 113                 uint32_t schema_object_version;
 114                 uint32_t w2k3_update_revision;
 115         } ads_options;
 116
 117         struct becomeDC_partition {
 118                 struct drsuapi_DsReplicaObjectIdentifier nc;
 119                 struct GUID destination_dsa_guid;
 120                 struct GUID source_dsa_guid;
 121                 struct GUID source_dsa_invocation_id;
 122                 struct drsuapi_DsReplicaHighWaterMark highwatermark;
 123                 struct drsuapi_DsReplicaCoursorCtrEx *uptodateness_vector;
 124                 uint32_t replica_flags;
 125
 126                 struct drsuapi_DsReplicaObjectListItemEx *first_object;
 127                 struct drsuapi_DsReplicaObjectListItemEx *last_object;
 128         } schema_part, config_part, domain_part;
 129
 130         struct becomeDC_fsmo {
 131                 const char *dns_name;
 132                 const char *server_dn_str;
 133                 const char *ntds_dn_str;
 134                 struct GUID ntds_guid;
 135         } infrastructure_fsmo;
 136
 137         struct becomeDC_fsmo rid_manager_fsmo;
 138 };
 139
 140 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s);
 141
 142 static void becomeDC_recv_cldap(struct cldap_request *req)
 143 {
 144         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
 145                                           struct libnet_BecomeDC_state);
 146         struct composite_context *c = s->creq;
 147
 148         c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
 149         if (!composite_is_ok(c)) return;
 150
 151         s->cldap.netlogon5 = s->cldap.io.out.netlogon.logon5;
 152
 153         s->domain.dns_name              = s->cldap.netlogon5.dns_domain;
 154         s->domain.netbios_name          = s->cldap.netlogon5.domain;
 155         s->domain.guid                  = s->cldap.netlogon5.domain_uuid;
 156
 157         s->forest.dns_name              = s->cldap.netlogon5.forest;
 158
 159         s->source_dsa.dns_name          = s->cldap.netlogon5.pdc_dns_name;
 160         s->source_dsa.netbios_name      = s->cldap.netlogon5.pdc_name;
 161         s->source_dsa.site_name         = s->cldap.netlogon5.server_site;
 162
 163         s->dest_dsa.site_name           = s->cldap.netlogon5.client_site;
 164
 165         becomeDC_connect_ldap1(s);
 166 }
 167
 168 static void becomeDC_send_cldap(struct libnet_BecomeDC_state *s)
 169 {
 170         struct composite_context *c = s->creq;
 171         struct cldap_request *req;
 172
 173         s->cldap.io.in.dest_address     = s->source_dsa.address;
 174         s->cldap.io.in.realm            = s->domain.dns_name;
 175         s->cldap.io.in.host             = s->dest_dsa.netbios_name;
 176         s->cldap.io.in.user             = NULL;
 177         s->cldap.io.in.domain_guid      = NULL;
 178         s->cldap.io.in.domain_sid       = NULL;
 179         s->cldap.io.in.acct_control     = -1;
 180         s->cldap.io.in.version          = 6;
 181
 182         s->cldap.sock = cldap_socket_init(s, s->libnet->event_ctx);
 183         if (composite_nomem(s->cldap.sock, c)) return;
 184
 185         req = cldap_netlogon_send(s->cldap.sock, &s->cldap.io);
 186         if (composite_nomem(req, c)) return;
 187         req->async.fn           = becomeDC_recv_cldap;
 188         req->async.private      = s;
 189 }
 190
 191 static NTSTATUS becomeDC_ldap_connect(struct libnet_BecomeDC_state *s, struct becomeDC_ldap *ldap)
 192 {
 193         char *url;
 194
 195         url = talloc_asprintf(s, "ldap://%s/", s->source_dsa.dns_name);
 196         NT_STATUS_HAVE_NO_MEMORY(url);
 197
 198         ldap->ldb = ldb_wrap_connect(s, url,
 199                                      NULL,
 200                                      s->libnet->cred,
 201                                      0, NULL);
 202         talloc_free(url);
 203         if (ldap->ldb == NULL) {
 204                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
 205         }
 206
 207         return NT_STATUS_OK;
 208 }
 209
 210 static NTSTATUS becomeDC_ldap1_rootdse(struct libnet_BecomeDC_state *s)
 211 {
 212         int ret;
 213         struct ldb_result *r;
 214         struct ldb_dn *basedn;
 215         static const char *attrs[] = {
 216                 "*",
 217                 NULL
 218         };
 219
 220         basedn = ldb_dn_new(s, s->ldap1.ldb, NULL);
 221         NT_STATUS_HAVE_NO_MEMORY(basedn);
 222
 223         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 224                          "(objectClass=*)", attrs, &r);
 225         talloc_free(basedn);
 226         if (ret != LDB_SUCCESS) {
 227                 return NT_STATUS_LDAP(ret);
 228         } else if (r->count != 1) {
 229                 talloc_free(r);
 230                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 231         }
 232         talloc_steal(s, r);
 233
 234         s->ldap1.rootdse = r->msgs[0];
 235
 236         s->domain.dn_str        = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "defaultNamingContext", NULL);
 237         if (!s->domain.dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 238
 239         s->forest.root_dn_str   = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "rootDomainNamingContext", NULL);
 240         if (!s->forest.root_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 241         s->forest.config_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "configurationNamingContext", NULL);
 242         if (!s->forest.config_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 243         s->forest.schema_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "schemaNamingContext", NULL);
 244         if (!s->forest.schema_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 245
 246         s->source_dsa.server_dn_str     = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "serverName", NULL);
 247         if (!s->source_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 248         s->source_dsa.ntds_dn_str       = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "dsServiceName", NULL);
 249         if (!s->source_dsa.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 250
 251         return NT_STATUS_OK;
 252 }
 253
 254 static NTSTATUS becomeDC_ldap1_config_behavior_version(struct libnet_BecomeDC_state *s)
 255 {
 256         int ret;
 257         struct ldb_result *r;
 258         struct ldb_dn *basedn;
 259         static const char *attrs[] = {
 260                 "msDs-Behavior-Version",
 261                 NULL
 262         };
 263
 264         basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.config_dn_str);
 265         NT_STATUS_HAVE_NO_MEMORY(basedn);
 266
 267         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_ONELEVEL,
 268                          "(cn=Partitions)", attrs, &r);
 269         talloc_free(basedn);
 270         if (ret != LDB_SUCCESS) {
 271                 return NT_STATUS_LDAP(ret);
 272         } else if (r->count != 1) {
 273                 talloc_free(r);
 274                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 275         }
 276
 277         s->ads_options.config_behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
 278
 279         talloc_free(r);
 280         return NT_STATUS_OK;
 281 }
 282
 283 static NTSTATUS becomeDC_ldap1_domain_behavior_version(struct libnet_BecomeDC_state *s)
 284 {
 285         int ret;
 286         struct ldb_result *r;
 287         struct ldb_dn *basedn;
 288         static const char *attrs[] = {
 289                 "msDs-Behavior-Version",
 290                 NULL
 291         };
 292
 293         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
 294         NT_STATUS_HAVE_NO_MEMORY(basedn);
 295
 296         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 297                          "(objectClass=*)", attrs, &r);
 298         talloc_free(basedn);
 299         if (ret != LDB_SUCCESS) {
 300                 return NT_STATUS_LDAP(ret);
 301         } else if (r->count != 1) {
 302                 talloc_free(r);
 303                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 304         }
 305
 306         s->ads_options.domain_behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
 307
 308         talloc_free(r);
 309         return NT_STATUS_OK;
 310 }
 311
 312 static NTSTATUS becomeDC_ldap1_schema_object_version(struct libnet_BecomeDC_state *s)
 313 {
 314         int ret;
 315         struct ldb_result *r;
 316         struct ldb_dn *basedn;
 317         static const char *attrs[] = {
 318                 "objectVersion",
 319                 NULL
 320         };
 321
 322         basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.schema_dn_str);
 323         NT_STATUS_HAVE_NO_MEMORY(basedn);
 324
 325         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 326                          "(objectClass=*)", attrs, &r);
 327         talloc_free(basedn);
 328         if (ret != LDB_SUCCESS) {
 329                 return NT_STATUS_LDAP(ret);
 330         } else if (r->count != 1) {
 331                 talloc_free(r);
 332                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 333         }
 334
 335         s->ads_options.schema_object_version = ldb_msg_find_attr_as_uint(r->msgs[0], "objectVersion", 0);
 336
 337         talloc_free(r);
 338         return NT_STATUS_OK;
 339 }
 340
 341 static NTSTATUS becomeDC_ldap1_w2k3_update_revision(struct libnet_BecomeDC_state *s)
 342 {
 343         int ret;
 344         struct ldb_result *r;
 345         struct ldb_dn *basedn;
 346         static const char *attrs[] = {
 347                 "revision",
 348                 NULL
 349         };
 350
 351         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=Windows2003Update,CN=DomainUpdates,CN=System,%s",
 352                                 s->domain.dn_str);
 353         NT_STATUS_HAVE_NO_MEMORY(basedn);
 354
 355         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 356                          "(objectClass=*)", attrs, &r);
 357         talloc_free(basedn);
 358         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 359                 /* w2k doesn't have this object */
 360                 s->ads_options.w2k3_update_revision = 0;
 361                 return NT_STATUS_OK;
 362         } else if (ret != LDB_SUCCESS) {
 363                 return NT_STATUS_LDAP(ret);
 364         } else if (r->count != 1) {
 365                 talloc_free(r);
 366                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 367         }
 368
 369         s->ads_options.w2k3_update_revision = ldb_msg_find_attr_as_uint(r->msgs[0], "revision", 0);
 370
 371         talloc_free(r);
 372         return NT_STATUS_OK;
 373 }
 374
 375 static NTSTATUS becomeDC_ldap1_infrastructure_fsmo(struct libnet_BecomeDC_state *s)
 376 {
 377         int ret;
 378         struct ldb_result *r;
 379         struct ldb_dn *basedn;
 380         struct ldb_dn *ntds_dn;
 381         struct ldb_dn *server_dn;
 382         static const char *_1_1_attrs[] = {
 383                 "1.1",
 384                 NULL
 385         };
 386         static const char *fsmo_attrs[] = {
 387                 "fSMORoleOwner",
 388                 NULL
 389         };
 390         static const char *dns_attrs[] = {
 391                 "dnsHostName",
 392                 NULL
 393         };
 394         static const char *guid_attrs[] = {
 395                 "objectGUID",
 396                 NULL
 397         };
 398
 399         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "<WKGUID=2fbac1870ade11d297c400c04fd8d5cd,%s>",
 400                                 s->domain.dn_str);
 401         NT_STATUS_HAVE_NO_MEMORY(basedn);
 402
 403         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 404                          "(objectClass=*)", _1_1_attrs, &r);
 405         talloc_free(basedn);
 406         if (ret != LDB_SUCCESS) {
 407                 return NT_STATUS_LDAP(ret);
 408         } else if (r->count != 1) {
 409                 talloc_free(r);
 410                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 411         }
 412
 413         basedn = talloc_steal(s, r->msgs[0]->dn);
 414         talloc_free(r);
 415
 416         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 417                          "(objectClass=*)", fsmo_attrs, &r);
 418         talloc_free(basedn);
 419         if (ret != LDB_SUCCESS) {
 420                 return NT_STATUS_LDAP(ret);
 421         } else if (r->count != 1) {
 422                 talloc_free(r);
 423                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 424         }
 425
 426         s->infrastructure_fsmo.ntds_dn_str      = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
 427         if (!s->infrastructure_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 428         talloc_steal(s, s->infrastructure_fsmo.ntds_dn_str);
 429
 430         talloc_free(r);
 431
 432         ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->infrastructure_fsmo.ntds_dn_str);
 433         NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
 434
 435         server_dn = ldb_dn_get_parent(s, ntds_dn);
 436         NT_STATUS_HAVE_NO_MEMORY(server_dn);
 437
 438         s->infrastructure_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
 439         NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.server_dn_str);
 440
 441         ret = ldb_search(s->ldap1.ldb, server_dn, LDB_SCOPE_BASE,
 442                          "(objectClass=*)", dns_attrs, &r);
 443         if (ret != LDB_SUCCESS) {
 444                 return NT_STATUS_LDAP(ret);
 445         } else if (r->count != 1) {
 446                 talloc_free(r);
 447                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 448         }
 449
 450         s->infrastructure_fsmo.dns_name = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
 451         if (!s->infrastructure_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 452         talloc_steal(s, s->infrastructure_fsmo.dns_name);
 453
 454         talloc_free(r);
 455
 456         ret = ldb_search(s->ldap1.ldb, ntds_dn, LDB_SCOPE_BASE,
 457                          "(objectClass=*)", guid_attrs, &r);
 458         if (ret != LDB_SUCCESS) {
 459                 return NT_STATUS_LDAP(ret);
 460         } else if (r->count != 1) {
 461                 talloc_free(r);
 462                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 463         }
 464
 465         s->infrastructure_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
 466
 467         talloc_free(r);
 468
 469         return NT_STATUS_OK;
 470 }
 471
 472 static NTSTATUS becomeDC_ldap1_rid_manager_fsmo(struct libnet_BecomeDC_state *s)
 473 {
 474         int ret;
 475         struct ldb_result *r;
 476         struct ldb_dn *basedn;
 477         const char *reference_dn_str;
 478         struct ldb_dn *ntds_dn;
 479         struct ldb_dn *server_dn;
 480         static const char *rid_attrs[] = {
 481                 "rIDManagerReference",
 482                 NULL
 483         };
 484         static const char *fsmo_attrs[] = {
 485                 "fSMORoleOwner",
 486                 NULL
 487         };
 488         static const char *dns_attrs[] = {
 489                 "dnsHostName",
 490                 NULL
 491         };
 492         static const char *guid_attrs[] = {
 493                 "objectGUID",
 494                 NULL
 495         };
 496
 497         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
 498         NT_STATUS_HAVE_NO_MEMORY(basedn);
 499
 500         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 501                          "(objectClass=*)", rid_attrs, &r);
 502         talloc_free(basedn);
 503         if (ret != LDB_SUCCESS) {
 504                 return NT_STATUS_LDAP(ret);
 505         } else if (r->count != 1) {
 506                 talloc_free(r);
 507                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 508         }
 509
 510         reference_dn_str        = samdb_result_string(r->msgs[0], "rIDManagerReference", NULL);
 511         if (!reference_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 512
 513         basedn = ldb_dn_new(s, s->ldap1.ldb, reference_dn_str);
 514         NT_STATUS_HAVE_NO_MEMORY(basedn);
 515
 516         talloc_free(r);
 517
 518         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 519                          "(objectClass=*)", fsmo_attrs, &r);
 520         talloc_free(basedn);
 521         if (ret != LDB_SUCCESS) {
 522                 return NT_STATUS_LDAP(ret);
 523         } else if (r->count != 1) {
 524                 talloc_free(r);
 525                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 526         }
 527
 528         s->rid_manager_fsmo.ntds_dn_str = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
 529         if (!s->rid_manager_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 530         talloc_steal(s, s->rid_manager_fsmo.ntds_dn_str);
 531
 532         talloc_free(r);
 533
 534         ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->rid_manager_fsmo.ntds_dn_str);
 535         NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
 536
 537         server_dn = ldb_dn_get_parent(s, ntds_dn);
 538         NT_STATUS_HAVE_NO_MEMORY(server_dn);
 539
 540         s->rid_manager_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
 541         NT_STATUS_HAVE_NO_MEMORY(s->rid_manager_fsmo.server_dn_str);
 542
 543         ret = ldb_search(s->ldap1.ldb, server_dn, LDB_SCOPE_BASE,
 544                          "(objectClass=*)", dns_attrs, &r);
 545         if (ret != LDB_SUCCESS) {
 546                 return NT_STATUS_LDAP(ret);
 547         } else if (r->count != 1) {
 548                 talloc_free(r);
 549                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 550         }
 551
 552         s->rid_manager_fsmo.dns_name    = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
 553         if (!s->rid_manager_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 554         talloc_steal(s, s->rid_manager_fsmo.dns_name);
 555
 556         talloc_free(r);
 557
 558         ret = ldb_search(s->ldap1.ldb, ntds_dn, LDB_SCOPE_BASE,
 559                          "(objectClass=*)", guid_attrs, &r);
 560         if (ret != LDB_SUCCESS) {
 561                 return NT_STATUS_LDAP(ret);
 562         } else if (r->count != 1) {
 563                 talloc_free(r);
 564                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 565         }
 566
 567         s->rid_manager_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
 568
 569         talloc_free(r);
 570
 571         return NT_STATUS_OK;
 572 }
 573
 574 static NTSTATUS becomeDC_ldap1_site_object(struct libnet_BecomeDC_state *s)
 575 {
 576         int ret;
 577         struct ldb_result *r;
 578         struct ldb_dn *basedn;
 579
 580         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Sites,%s",
 581                                 s->dest_dsa.site_name,
 582                                 s->forest.config_dn_str);
 583         NT_STATUS_HAVE_NO_MEMORY(basedn);
 584
 585         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 586                          "(objectClass=*)", NULL, &r);
 587         talloc_free(basedn);
 588         if (ret != LDB_SUCCESS) {
 589                 return NT_STATUS_LDAP(ret);
 590         } else if (r->count != 1) {
 591                 talloc_free(r);
 592                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 593         }
 594
 595         s->dest_dsa.site_guid = samdb_result_guid(r->msgs[0], "objectGUID");
 596
 597         talloc_free(r);
 598         return NT_STATUS_OK;
 599 }
 600
 601 static NTSTATUS becomeDC_ldap1_computer_object(struct libnet_BecomeDC_state *s)
 602 {
 603         int ret;
 604         struct ldb_result *r;
 605         struct ldb_dn *basedn;
 606         char *filter;
 607         static const char *attrs[] = {
 608                 "distinguishedName",
 609                 "userAccountControl",
 610                 NULL
 611         };
 612
 613         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
 614         NT_STATUS_HAVE_NO_MEMORY(basedn);
 615
 616         filter = talloc_asprintf(basedn, "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
 617                                  s->dest_dsa.netbios_name);
 618         NT_STATUS_HAVE_NO_MEMORY(filter);
 619
 620         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_SUBTREE,
 621                          filter, attrs, &r);
 622         talloc_free(basedn);
 623         if (ret != LDB_SUCCESS) {
 624                 return NT_STATUS_LDAP(ret);
 625         } else if (r->count != 1) {
 626                 talloc_free(r);
 627                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 628         }
 629
 630         s->dest_dsa.computer_dn_str     = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
 631         if (!s->dest_dsa.computer_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 632         talloc_steal(s, s->dest_dsa.computer_dn_str);
 633
 634         s->dest_dsa.user_account_control = samdb_result_uint(r->msgs[0], "userAccountControl", 0);
 635
 636         talloc_free(r);
 637         return NT_STATUS_OK;
 638 }
 639
 640 static NTSTATUS becomeDC_ldap1_server_object_1(struct libnet_BecomeDC_state *s)
 641 {
 642         int ret;
 643         struct ldb_result *r;
 644         struct ldb_dn *basedn;
 645         const char *server_reference_dn_str;
 646         struct ldb_dn *server_reference_dn;
 647         struct ldb_dn *computer_dn;
 648
 649         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
 650                                 s->dest_dsa.netbios_name,
 651                                 s->dest_dsa.site_name,
 652                                 s->forest.config_dn_str);
 653         NT_STATUS_HAVE_NO_MEMORY(basedn);
 654
 655         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 656                          "(objectClass=*)", NULL, &r);
 657         talloc_free(basedn);
 658         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
 659                 /* if the object doesn't exist, we'll create it later */
 660                 return NT_STATUS_OK;
 661         } else if (ret != LDB_SUCCESS) {
 662                 return NT_STATUS_LDAP(ret);
 663         } else if (r->count != 1) {
 664                 talloc_free(r);
 665                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 666         }
 667
 668         server_reference_dn_str = samdb_result_string(r->msgs[0], "serverReference", NULL);
 669         if (server_reference_dn_str) {
 670                 server_reference_dn     = ldb_dn_new(r, s->ldap1.ldb, server_reference_dn_str);
 671                 NT_STATUS_HAVE_NO_MEMORY(server_reference_dn);
 672
 673                 computer_dn             = ldb_dn_new(r, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
 674                 NT_STATUS_HAVE_NO_MEMORY(computer_dn);
 675
 676                 /*
 677                  * if the server object belongs to another DC in another domain in the forest,
 678                  * we should not touch this object!
 679                  */
 680                 if (ldb_dn_compare(computer_dn, server_reference_dn) != 0) {
 681                         talloc_free(r);
 682                         return NT_STATUS_OBJECT_NAME_COLLISION;
 683                 }
 684         }
 685
 686         /* if the server object is already for the dest_dsa, then we don't need to create it */
 687         s->dest_dsa.server_dn_str       = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
 688         if (!s->dest_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 689         talloc_steal(s, s->dest_dsa.server_dn_str);
 690
 691         talloc_free(r);
 692         return NT_STATUS_OK;
 693 }
 694
 695 static NTSTATUS becomeDC_ldap1_server_object_2(struct libnet_BecomeDC_state *s)
 696 {
 697         int ret;
 698         struct ldb_result *r;
 699         struct ldb_dn *basedn;
 700         const char *server_reference_bl_dn_str;
 701         static const char *attrs[] = {
 702                 "serverReferenceBL",
 703                 NULL
 704         };
 705
 706         /* if the server_dn_str has a valid value, we skip this lookup */
 707         if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
 708
 709         basedn = ldb_dn_new(s, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
 710         NT_STATUS_HAVE_NO_MEMORY(basedn);
 711
 712         ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
 713                          "(objectClass=*)", attrs, &r);
 714         talloc_free(basedn);
 715         if (ret != LDB_SUCCESS) {
 716                 return NT_STATUS_LDAP(ret);
 717         } else if (r->count != 1) {
 718                 talloc_free(r);
 719                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 720         }
 721
 722         server_reference_bl_dn_str = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
 723         if (!server_reference_bl_dn_str) {
 724                 /* if no back link is present, we're done for this function */
 725                 talloc_free(r);
 726                 return NT_STATUS_OK;
 727         }
 728
 729         /* if the server object is already for the dest_dsa, then we don't need to create it */
 730         s->dest_dsa.server_dn_str       = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
 731         if (s->dest_dsa.server_dn_str) {
 732                 /* if a back link is present, we know that the server object is present */
 733                 talloc_steal(s, s->dest_dsa.server_dn_str);
 734         }
 735
 736         talloc_free(r);
 737         return NT_STATUS_OK;
 738 }
 739
 740 static NTSTATUS becomeDC_ldap1_server_object_add(struct libnet_BecomeDC_state *s)
 741 {
 742         int ret;
 743         struct ldb_message *msg;
 744         char *server_dn_str;
 745
 746         /* if the server_dn_str has a valid value, we skip this lookup */
 747         if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
 748
 749         msg = ldb_msg_new(s);
 750         NT_STATUS_HAVE_NO_MEMORY(msg);
 751
 752         msg->dn = ldb_dn_new_fmt(msg, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
 753                                  s->dest_dsa.netbios_name,
 754                                  s->dest_dsa.site_name,
 755                                  s->forest.config_dn_str);
 756         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
 757
 758         ret = ldb_msg_add_string(msg, "objectClass", "server");
 759         if (ret != 0) {
 760                 talloc_free(msg);
 761                 return NT_STATUS_NO_MEMORY;
 762         }
 763         ret = ldb_msg_add_string(msg, "systemFlags", "50000000");
 764         if (ret != 0) {
 765                 talloc_free(msg);
 766                 return NT_STATUS_NO_MEMORY;
 767         }
 768         ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
 769         if (ret != 0) {
 770                 talloc_free(msg);
 771                 return NT_STATUS_NO_MEMORY;
 772         }
 773
 774         server_dn_str = ldb_dn_alloc_linearized(s, msg->dn);
 775         NT_STATUS_HAVE_NO_MEMORY(server_dn_str);
 776
 777         ret = ldb_add(s->ldap1.ldb, msg);
 778         talloc_free(msg);
 779         if (ret != LDB_SUCCESS) {
 780                 talloc_free(server_dn_str);
 781                 return NT_STATUS_LDAP(ret);
 782         }
 783
 784         s->dest_dsa.server_dn_str = server_dn_str;
 785
 786         return NT_STATUS_OK;
 787 }
 788
 789 static NTSTATUS becomeDC_ldap1_server_object_modify(struct libnet_BecomeDC_state *s)
 790 {
 791         int ret;
 792         struct ldb_message *msg;
 793         uint32_t i;
 794
 795         /* make a 'modify' msg, and only for serverReference */
 796         msg = ldb_msg_new(s);
 797         NT_STATUS_HAVE_NO_MEMORY(msg);
 798         msg->dn = ldb_dn_new(msg, s->ldap1.ldb, s->dest_dsa.server_dn_str);
 799         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
 800
 801         ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
 802         if (ret != 0) {
 803                 talloc_free(msg);
 804                 return NT_STATUS_NO_MEMORY;
 805         }
 806
 807         /* mark all the message elements (should be just one)
 808            as LDB_FLAG_MOD_ADD */
 809         for (i=0;i<msg->num_elements;i++) {
 810                 msg->elements[i].flags = LDB_FLAG_MOD_ADD;
 811         }
 812
 813         ret = ldb_modify(s->ldap1.ldb, msg);
 814         if (ret == LDB_SUCCESS) {
 815                 talloc_free(msg);
 816                 return NT_STATUS_OK;
 817         } else if (ret == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) {
 818                 /* retry with LDB_FLAG_MOD_REPLACE */
 819         } else {
 820                 talloc_free(msg);
 821                 return NT_STATUS_LDAP(ret);
 822         }
 823
 824         /* mark all the message elements (should be just one)
 825            as LDB_FLAG_MOD_REPLACE */
 826         for (i=0;i<msg->num_elements;i++) {
 827                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
 828         }
 829
 830         ret = ldb_modify(s->ldap1.ldb, msg);
 831         talloc_free(msg);
 832         if (ret != LDB_SUCCESS) {
 833                 return NT_STATUS_LDAP(ret);
 834         }
 835
 836         return NT_STATUS_OK;
 837 }
 838
 839 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
 840                                           struct becomeDC_drsuapi *drsuapi,
 841                                           void (*recv_fn)(struct composite_context *req));
 842 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req);
 843 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s);
 844
 845 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s)
 846 {
 847         struct composite_context *c = s->creq;
 848
 849         c->status = becomeDC_ldap_connect(s, &s->ldap1);
 850         if (!composite_is_ok(c)) return;
 851
 852         c->status = becomeDC_ldap1_rootdse(s);
 853         if (!composite_is_ok(c)) return;
 854
 855         c->status = becomeDC_ldap1_config_behavior_version(s);
 856         if (!composite_is_ok(c)) return;
 857
 858         c->status = becomeDC_ldap1_domain_behavior_version(s);
 859         if (!composite_is_ok(c)) return;
 860
 861         c->status = becomeDC_ldap1_schema_object_version(s);
 862         if (!composite_is_ok(c)) return;
 863
 864         c->status = becomeDC_ldap1_w2k3_update_revision(s);
 865         if (!composite_is_ok(c)) return;
 866
 867         c->status = becomeDC_ldap1_infrastructure_fsmo(s);
 868         if (!composite_is_ok(c)) return;
 869
 870         c->status = becomeDC_ldap1_rid_manager_fsmo(s);
 871         if (!composite_is_ok(c)) return;
 872
 873         c->status = becomeDC_ldap1_site_object(s);
 874         if (!composite_is_ok(c)) return;
 875
 876         c->status = becomeDC_ldap1_computer_object(s);
 877         if (!composite_is_ok(c)) return;
 878
 879         c->status = becomeDC_ldap1_server_object_1(s);
 880         if (!composite_is_ok(c)) return;
 881
 882         c->status = becomeDC_ldap1_server_object_2(s);
 883         if (!composite_is_ok(c)) return;
 884
 885         c->status = becomeDC_ldap1_server_object_add(s);
 886         if (!composite_is_ok(c)) return;
 887
 888         c->status = becomeDC_ldap1_server_object_modify(s);
 889         if (!composite_is_ok(c)) return;
 890
 891         becomeDC_drsuapi_connect_send(s, &s->drsuapi1, becomeDC_drsuapi1_connect_recv);
 892 }
 893
 894 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
 895                                           struct becomeDC_drsuapi *drsuapi,
 896                                           void (*recv_fn)(struct composite_context *req))
 897 {
 898         struct composite_context *c = s->creq;
 899         struct composite_context *creq;
 900         char *binding_str;
 901
 902         drsuapi->s = s;
 903
 904         if (!drsuapi->binding) {
 905                 binding_str = talloc_asprintf(s, "ncacn_ip_tcp:%s[krb5,seal]", s->source_dsa.dns_name);
 906                 if (composite_nomem(binding_str, c)) return;
 907
 908                 c->status = dcerpc_parse_binding(s, binding_str, &drsuapi->binding);
 909                 talloc_free(binding_str);
 910                 if (!composite_is_ok(c)) return;
 911         }
 912
 913         creq = dcerpc_pipe_connect_b_send(s, drsuapi->binding, &dcerpc_table_drsuapi,
 914                                           s->libnet->cred, s->libnet->event_ctx);
 915         composite_continue(c, creq, recv_fn, s);
 916 }
 917
 918 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
 919                                        struct becomeDC_drsuapi *drsuapi,
 920                                        void (*recv_fn)(struct rpc_request *req));
 921 static void becomeDC_drsuapi1_bind_recv(struct rpc_request *req);
 922
 923 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req)
 924 {
 925         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
 926                                           struct libnet_BecomeDC_state);
 927         struct composite_context *c = s->creq;
 928
 929         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi1.pipe);
 930         if (!composite_is_ok(c)) return;
 931
 932         becomeDC_drsuapi_bind_send(s, &s->drsuapi1, becomeDC_drsuapi1_bind_recv);
 933 }
 934
 935 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
 936                                        struct becomeDC_drsuapi *drsuapi,
 937                                        void (*recv_fn)(struct rpc_request *req))
 938 {
 939         struct composite_context *c = s->creq;
 940         struct rpc_request *req;
 941         struct drsuapi_DsBindInfo28 *bind_info28;
 942
 943         GUID_from_string(DRSUAPI_DS_BIND_GUID_W2K3, &drsuapi->bind_guid);
 944
 945         bind_info28                             = &drsuapi->local_info28;
 946         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
 947         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION;
 948         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI;
 949         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2;
 950         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS;
 951         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1;
 952         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
 953         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
 954         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
 955         if (s->ads_options.domain_behavior_version == 2) {
 956                 /* TODO: find out how this is really triggered! */
 957                 bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
 958         }
 959         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2;
 960         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD;
 961         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND;
 962         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO;
 963         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION;
 964         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01;
 965         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP;
 966         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
 967         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
 968         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_00100000;
 969         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
 970         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
 971         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS;
 972         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8;
 973         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5;
 974         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6;
 975         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
 976         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
 977         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
 978 #if 0 /* we don't support XPRESS compression yet */
 979         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS;
 980 #endif
 981         bind_info28->site_guid                  = s->dest_dsa.site_guid;
 982         if (s->ads_options.domain_behavior_version == 2) {
 983                 /* TODO: find out how this is really triggered! */
 984                 bind_info28->u1                         = 528;
 985         } else {
 986                 bind_info28->u1                         = 516;
 987         }
 988         bind_info28->repl_epoch                 = 0;
 989
 990         drsuapi->bind_info_ctr.length           = 28;
 991         drsuapi->bind_info_ctr.info.info28      = *bind_info28;
 992
 993         drsuapi->bind_r.in.bind_guid = &drsuapi->bind_guid;
 994         drsuapi->bind_r.in.bind_info = &drsuapi->bind_info_ctr;
 995         drsuapi->bind_r.out.bind_handle = &drsuapi->bind_handle;
 996
 997         req = dcerpc_drsuapi_DsBind_send(drsuapi->pipe, s, &drsuapi->bind_r);
 998         composite_continue_rpc(c, req, recv_fn, s);
 999 }
1000
1001 static WERROR becomeDC_drsuapi_bind_recv(struct libnet_BecomeDC_state *s,
1002                                          struct becomeDC_drsuapi *drsuapi)
1003 {
1004         if (!W_ERROR_IS_OK(drsuapi->bind_r.out.result)) {
1005                 return drsuapi->bind_r.out.result;
1006         }
1007
1008         ZERO_STRUCT(drsuapi->remote_info28);
1009         if (drsuapi->bind_r.out.bind_info) {
1010                 switch (drsuapi->bind_r.out.bind_info->length) {
1011                 case 24: {
1012                         struct drsuapi_DsBindInfo24 *info24;
1013                         info24 = &drsuapi->bind_r.out.bind_info->info.info24;
1014                         drsuapi->remote_info28.supported_extensions     = info24->supported_extensions;
1015                         drsuapi->remote_info28.site_guid                = info24->site_guid;
1016                         drsuapi->remote_info28.u1                       = info24->u1;
1017                         drsuapi->remote_info28.repl_epoch               = 0;
1018                         break;
1019                 }
1020                 case 28:
1021                         drsuapi->remote_info28 = drsuapi->bind_r.out.bind_info->info.info28;
1022                         break;
1023                 }
1024         }
1025
1026         return WERR_OK;
1027 }
1028
1029 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s);
1030
1031 static void becomeDC_drsuapi1_bind_recv(struct rpc_request *req)
1032 {
1033         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1034                                           struct libnet_BecomeDC_state);
1035         struct composite_context *c = s->creq;
1036         WERROR status;
1037
1038         c->status = dcerpc_ndr_request_recv(req);
1039         if (!composite_is_ok(c)) return;
1040
1041         status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi1);
1042         if (!W_ERROR_IS_OK(status)) {
1043                 composite_error(c, werror_to_ntstatus(status));
1044                 return;
1045         }
1046
1047         becomeDC_drsuapi1_add_entry_send(s);
1048 }
1049
1050 static void becomeDC_drsuapi1_add_entry_recv(struct rpc_request *req);
1051
1052 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s)
1053 {
1054         struct composite_context *c = s->creq;
1055         struct rpc_request *req;
1056         struct drsuapi_DsAddEntry *r;
1057         struct drsuapi_DsReplicaObjectIdentifier *identifier;
1058         uint32_t num_attrs, i = 0;
1059         struct drsuapi_DsReplicaAttribute *attrs;
1060         bool w2k3;
1061
1062         /* choose a random invocationId */
1063         s->dest_dsa.invocation_id = GUID_random();
1064
1065         /*
1066          * if the schema version indicates w2k3, then
1067          * also send some w2k3 specific attributes
1068          */
1069         if (s->ads_options.schema_object_version >= 30) {
1070                 w2k3 = true;
1071         } else {
1072                 w2k3 = false;
1073         }
1074
1075         r = talloc_zero(s, struct drsuapi_DsAddEntry);
1076         if (composite_nomem(r, c)) return;
1077
1078         /* setup identifier */
1079         identifier              = talloc(r, struct drsuapi_DsReplicaObjectIdentifier);
1080         if (composite_nomem(identifier, c)) return;
1081         identifier->guid        = GUID_zero();
1082         identifier->sid         = s->zero_sid;
1083         identifier->dn          = talloc_asprintf(identifier, "CN=NTDS Settings,%s",
1084                                                   s->dest_dsa.server_dn_str);
1085         if (composite_nomem(identifier->dn, c)) return;
1086
1087         /* allocate attribute array */
1088         num_attrs       = 11;
1089         attrs           = talloc_array(r, struct drsuapi_DsReplicaAttribute, num_attrs);
1090         if (composite_nomem(attrs, c)) return;
1091
1092         /* ntSecurityDescriptor */
1093         {
1094                 struct drsuapi_DsAttributeValueSecurityDescriptor *vs;
1095                 struct security_descriptor *v;
1096                 struct dom_sid *domain_admins_sid;
1097                 const char *domain_admins_sid_str;
1098
1099                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueSecurityDescriptor, 1);
1100                 if (composite_nomem(vs, c)) return;
1101
1102                 domain_admins_sid = dom_sid_add_rid(vs, s->domain.sid, DOMAIN_RID_ADMINS);
1103                 if (composite_nomem(domain_admins_sid, c)) return;
1104
1105                 domain_admins_sid_str = dom_sid_string(domain_admins_sid, domain_admins_sid);
1106                 if (composite_nomem(domain_admins_sid_str, c)) return;
1107
1108                 v = security_descriptor_create(vs,
1109                                                /* owner: domain admins */
1110                                                domain_admins_sid_str,
1111                                                /* owner group: domain admins */
1112                                                domain_admins_sid_str,
1113                                                /* authenticated users */
1114                                                SID_NT_AUTHENTICATED_USERS,
1115                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1116                                                SEC_STD_READ_CONTROL |
1117                                                SEC_ADS_LIST |
1118                                                SEC_ADS_READ_PROP |
1119                                                SEC_ADS_LIST_OBJECT,
1120                                                0,
1121                                                /* domain admins */
1122                                                domain_admins_sid_str,
1123                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1124                                                SEC_STD_REQUIRED |
1125                                                SEC_ADS_CREATE_CHILD |
1126                                                SEC_ADS_LIST |
1127                                                SEC_ADS_SELF_WRITE |
1128                                                SEC_ADS_READ_PROP |
1129                                                SEC_ADS_WRITE_PROP |
1130                                                SEC_ADS_DELETE_TREE |
1131                                                SEC_ADS_LIST_OBJECT |
1132                                                SEC_ADS_CONTROL_ACCESS,
1133                                                0,
1134                                                /* system */
1135                                                SID_NT_SYSTEM,
1136                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1137                                                SEC_STD_REQUIRED |
1138                                                SEC_ADS_CREATE_CHILD |
1139                                                SEC_ADS_DELETE_CHILD |
1140                                                SEC_ADS_LIST |
1141                                                SEC_ADS_SELF_WRITE |
1142                                                SEC_ADS_READ_PROP |
1143                                                SEC_ADS_WRITE_PROP |
1144                                                SEC_ADS_DELETE_TREE |
1145                                                SEC_ADS_LIST_OBJECT |
1146                                                SEC_ADS_CONTROL_ACCESS,
1147                                                0,
1148                                                /* end */
1149                                                NULL);
1150                 if (composite_nomem(v, c)) return;
1151
1152                 vs[0].sd                = v;
1153
1154                 attrs[i].attid                                          = DRSUAPI_ATTRIBUTE_ntSecurityDescriptor;
1155                 attrs[i].value_ctr.security_descriptor.num_values       = 1;
1156                 attrs[i].value_ctr.security_descriptor.values           = vs;
1157
1158                 i++;
1159         }
1160
1161         /* objectClass: nTDSDSA */
1162         {
1163                 struct drsuapi_DsAttributeValueObjectClassId *vs;
1164                 enum drsuapi_DsObjectClassId *v;
1165
1166                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueObjectClassId, 1);
1167                 if (composite_nomem(vs, c)) return;
1168
1169                 v = talloc_array(vs, enum drsuapi_DsObjectClassId, 1);
1170                 if (composite_nomem(v, c)) return;
1171
1172                 /* value for nTDSDSA */
1173                 v[0]                    = 0x0017002F;
1174
1175                 vs[0].objectClassId     = &v[0];
1176
1177                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_objectClass;
1178                 attrs[i].value_ctr.object_class_id.num_values   = 1;
1179                 attrs[i].value_ctr.object_class_id.values       = vs;
1180
1181                 i++;
1182         }
1183
1184         /* objectCategory: CN=NTDS-DSA,CN=Schema,... */
1185         {
1186                 struct drsuapi_DsAttributeValueDNString *vs;
1187                 struct drsuapi_DsReplicaObjectIdentifier3 *v;
1188
1189                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueDNString, 1);
1190                 if (composite_nomem(vs, c)) return;
1191
1192                 v = talloc_array(vs, struct drsuapi_DsReplicaObjectIdentifier3, 1);
1193                 if (composite_nomem(v, c)) return;
1194
1195                 v[0].guid               = GUID_zero();
1196                 v[0].sid                = s->zero_sid;
1197                 v[0].dn                 = talloc_asprintf(v, "CN=NTDS-DSA,%s",
1198                                                           s->forest.schema_dn_str);
1199                 if (composite_nomem(v->dn, c)) return;
1200
1201                 vs[0].object            = &v[0];
1202
1203                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_objectCategory;
1204                 attrs[i].value_ctr.dn_string.num_values         = 1;
1205                 attrs[i].value_ctr.dn_string.values             = vs;
1206
1207                 i++;
1208         }
1209
1210         /* invocationId: random guid */
1211         {
1212                 struct drsuapi_DsAttributeValueGUID *vs;
1213                 struct GUID *v;
1214
1215                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueGUID, 1);
1216                 if (composite_nomem(vs, c)) return;
1217
1218                 v = talloc_array(vs, struct GUID, 1);
1219                 if (composite_nomem(v, c)) return;
1220
1221                 v[0]                    = s->dest_dsa.invocation_id;
1222
1223                 vs[0].guid              = &v[0];
1224
1225                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_invocationId;
1226                 attrs[i].value_ctr.guid.num_values              = 1;
1227                 attrs[i].value_ctr.guid.values                  = vs;
1228
1229                 i++;
1230         }
1231
1232         /* hasMasterNCs: ... */
1233         {
1234                 struct drsuapi_DsAttributeValueDNString *vs;
1235                 struct drsuapi_DsReplicaObjectIdentifier3 *v;
1236
1237                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueDNString, 3);
1238                 if (composite_nomem(vs, c)) return;
1239
1240                 v = talloc_array(vs, struct drsuapi_DsReplicaObjectIdentifier3, 3);
1241                 if (composite_nomem(v, c)) return;
1242
1243                 v[0].guid               = GUID_zero();
1244                 v[0].sid                = s->zero_sid;
1245                 v[0].dn                 = s->forest.config_dn_str;
1246
1247                 v[1].guid               = GUID_zero();
1248                 v[1].sid                = s->zero_sid;
1249                 v[1].dn                 = s->domain.dn_str;
1250
1251                 v[2].guid               = GUID_zero();
1252                 v[2].sid                = s->zero_sid;
1253                 v[2].dn                 = s->forest.schema_dn_str;
1254
1255                 vs[0].object            = &v[0];
1256                 vs[1].object            = &v[1];
1257                 vs[2].object            = &v[2];
1258
1259                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_hasMasterNCs;
1260                 attrs[i].value_ctr.dn_string.num_values         = 3;
1261                 attrs[i].value_ctr.dn_string.values             = vs;
1262
1263                 i++;
1264         }
1265
1266         /* msDS-hasMasterNCs: ... */
1267         if (w2k3) {
1268                 struct drsuapi_DsAttributeValueDNString *vs;
1269                 struct drsuapi_DsReplicaObjectIdentifier3 *v;
1270
1271                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueDNString, 3);
1272                 if (composite_nomem(vs, c)) return;
1273
1274                 v = talloc_array(vs, struct drsuapi_DsReplicaObjectIdentifier3, 3);
1275                 if (composite_nomem(v, c)) return;
1276
1277                 v[0].guid               = GUID_zero();
1278                 v[0].sid                = s->zero_sid;
1279                 v[0].dn                 = s->forest.config_dn_str;
1280
1281                 v[1].guid               = GUID_zero();
1282                 v[1].sid                = s->zero_sid;
1283                 v[1].dn                 = s->domain.dn_str;
1284
1285                 v[2].guid               = GUID_zero();
1286                 v[2].sid                = s->zero_sid;
1287                 v[2].dn                 = s->forest.schema_dn_str;
1288
1289                 vs[0].object            = &v[0];
1290                 vs[1].object            = &v[1];
1291                 vs[2].object            = &v[2];
1292
1293                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs;
1294                 attrs[i].value_ctr.dn_string.num_values         = 3;
1295                 attrs[i].value_ctr.dn_string.values             = vs;
1296
1297                 i++;
1298         }
1299
1300         /* dMDLocation: CN=Schema,... */
1301         {
1302                 struct drsuapi_DsAttributeValueDNString *vs;
1303                 struct drsuapi_DsReplicaObjectIdentifier3 *v;
1304
1305                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueDNString, 1);
1306                 if (composite_nomem(vs, c)) return;
1307
1308                 v = talloc_array(vs, struct drsuapi_DsReplicaObjectIdentifier3, 1);
1309                 if (composite_nomem(v, c)) return;
1310
1311                 v[0].guid               = GUID_zero();
1312                 v[0].sid                = s->zero_sid;
1313                 v[0].dn                 = s->forest.schema_dn_str;
1314
1315                 vs[0].object            = &v[0];
1316
1317                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_dMDLocation;
1318                 attrs[i].value_ctr.dn_string.num_values         = 1;
1319                 attrs[i].value_ctr.dn_string.values             = vs;
1320
1321                 i++;
1322         }
1323
1324         /* msDS-HasDomainNCs: <domain_partition> */
1325         if (w2k3) {
1326                 struct drsuapi_DsAttributeValueDNString *vs;
1327                 struct drsuapi_DsReplicaObjectIdentifier3 *v;
1328
1329                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueDNString, 1);
1330                 if (composite_nomem(vs, c)) return;
1331
1332                 v = talloc_array(vs, struct drsuapi_DsReplicaObjectIdentifier3, 1);
1333                 if (composite_nomem(v, c)) return;
1334
1335                 v[0].guid               = GUID_zero();
1336                 v[0].sid                = s->zero_sid;
1337                 v[0].dn                 = s->domain.dn_str;
1338
1339                 vs[0].object            = &v[0];
1340
1341                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs;
1342                 attrs[i].value_ctr.dn_string.num_values         = 1;
1343                 attrs[i].value_ctr.dn_string.values             = vs;
1344
1345                 i++;
1346         }
1347
1348         /* msDS-Behavior-Version */
1349         if (w2k3) {
1350                 struct drsuapi_DsAttributeValueUINT32 *vs;
1351                 uint32_t *v;
1352
1353                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueUINT32, 1);
1354                 if (composite_nomem(vs, c)) return;
1355
1356                 v = talloc_array(vs, uint32_t, 1);
1357                 if (composite_nomem(v, c)) return;
1358
1359                 v[0]                    = 0x00000002;
1360
1361                 vs[0].value             = &v[0];
1362
1363                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_msDS_Behavior_Version;
1364                 attrs[i].value_ctr.uint32.num_values            = 1;
1365                 attrs[i].value_ctr.uint32.values                = vs;
1366
1367                 i++;
1368         }
1369
1370         /* systemFlags */
1371         {
1372                 struct drsuapi_DsAttributeValueUINT32 *vs;
1373                 uint32_t *v;
1374
1375                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueUINT32, 1);
1376                 if (composite_nomem(vs, c)) return;
1377
1378                 v = talloc_array(vs, uint32_t, 1);
1379                 if (composite_nomem(v, c)) return;
1380
1381                 v[0]                    = SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE;
1382
1383                 vs[0].value             = &v[0];
1384
1385                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_systemFlags;
1386                 attrs[i].value_ctr.uint32.num_values            = 1;
1387                 attrs[i].value_ctr.uint32.values                = vs;
1388
1389                 i++;
1390         }
1391
1392         /* serverReference: ... */
1393         {
1394                 struct drsuapi_DsAttributeValueDNString *vs;
1395                 struct drsuapi_DsReplicaObjectIdentifier3 *v;
1396
1397                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValueDNString, 1);
1398                 if (composite_nomem(vs, c)) return;
1399
1400                 v = talloc_array(vs, struct drsuapi_DsReplicaObjectIdentifier3, 1);
1401                 if (composite_nomem(v, c)) return;
1402
1403                 v[0].guid               = GUID_zero();
1404                 v[0].sid                = s->zero_sid;
1405                 v[0].dn                 = s->dest_dsa.computer_dn_str;
1406
1407                 vs[0].object            = &v[0];
1408
1409                 attrs[i].attid                                  = DRSUAPI_ATTRIBUTE_serverReference;
1410                 attrs[i].value_ctr.dn_string.num_values         = 1;
1411                 attrs[i].value_ctr.dn_string.values             = vs;
1412
1413                 i++;
1414         }
1415
1416         /* truncate the attribute list to the attribute count we have filled in */
1417         num_attrs = i;
1418
1419         /* setup request structure */
1420         r->in.bind_handle                                               = &s->drsuapi1.bind_handle;
1421         r->in.level                                                     = 2;
1422         r->in.req.req2.first_object.next_object                         = NULL;
1423         r->in.req.req2.first_object.object.identifier                   = identifier;
1424         r->in.req.req2.first_object.object.unknown1                     = 0x00000000;
1425         r->in.req.req2.first_object.object.attribute_ctr.num_attributes = num_attrs;
1426         r->in.req.req2.first_object.object.attribute_ctr.attributes     = attrs;
1427
1428         req = dcerpc_drsuapi_DsAddEntry_send(s->drsuapi1.pipe, r, r);
1429         composite_continue_rpc(c, req, becomeDC_drsuapi1_add_entry_recv, s);
1430 }
1431
1432 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req);
1433
1434 static void becomeDC_drsuapi1_add_entry_recv(struct rpc_request *req)
1435 {
1436         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1437                                           struct libnet_BecomeDC_state);
1438         struct composite_context *c = s->creq;
1439         struct drsuapi_DsAddEntry *r = talloc_get_type(req->ndr.struct_ptr,
1440                                        struct drsuapi_DsAddEntry);
1441
1442         c->status = dcerpc_ndr_request_recv(req);
1443         if (!composite_is_ok(c)) return;
1444
1445         if (!W_ERROR_IS_OK(r->out.result)) {
1446                 composite_error(c, werror_to_ntstatus(r->out.result));
1447                 return;
1448         }
1449
1450         if (r->out.level == 3) {
1451                 if (r->out.ctr.ctr3.count != 1) {
1452                         WERROR status;
1453
1454                         if (r->out.ctr.ctr3.level != 1) {
1455                                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
1456                                 return;
1457                         }
1458
1459                         if (!r->out.ctr.ctr3.error) {
1460                                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
1461                                 return;
1462                         }
1463
1464                         status = r->out.ctr.ctr3.error->info1.status;
1465
1466                         if (!r->out.ctr.ctr3.error->info1.info) {
1467                                 composite_error(c, werror_to_ntstatus(status));
1468                                 return;
1469                         }
1470
1471                         /* see if we can get a more detailed error */
1472                         switch (r->out.ctr.ctr3.error->info1.level) {
1473                         case 1:
1474                                 status = r->out.ctr.ctr3.error->info1.info->error1.status;
1475                                 break;
1476                         case 4:
1477                         case 5:
1478                         case 6:
1479                         case 7:
1480                                 status = r->out.ctr.ctr3.error->info1.info->errorX.status;
1481                                 break;
1482                         }
1483
1484                         composite_error(c, werror_to_ntstatus(status));
1485                         return;
1486                 }
1487
1488                 s->dest_dsa.ntds_guid   = r->out.ctr.ctr3.objects[0].guid;
1489         } else if (r->out.level == 2) {
1490                 if (r->out.ctr.ctr2.count != 1) {
1491                         composite_error(c, werror_to_ntstatus(r->out.ctr.ctr2.error.status));
1492                         return;
1493                 }
1494
1495                 s->dest_dsa.ntds_guid   = r->out.ctr.ctr2.objects[0].guid;
1496         } else {
1497                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
1498                 return;
1499         }
1500
1501         talloc_free(r);
1502
1503         becomeDC_drsuapi_connect_send(s, &s->drsuapi2, becomeDC_drsuapi2_connect_recv);
1504 }
1505
1506 static void becomeDC_drsuapi2_bind_recv(struct rpc_request *req);
1507
1508 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req)
1509 {
1510         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
1511                                           struct libnet_BecomeDC_state);
1512         struct composite_context *c = s->creq;
1513
1514         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi2.pipe);
1515         if (!composite_is_ok(c)) return;
1516
1517         becomeDC_drsuapi_bind_send(s, &s->drsuapi2, becomeDC_drsuapi2_bind_recv);
1518 }
1519
1520 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req);
1521
1522 static void becomeDC_drsuapi2_bind_recv(struct rpc_request *req)
1523 {
1524         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1525                                           struct libnet_BecomeDC_state);
1526         struct composite_context *c = s->creq;
1527         char *binding_str;
1528         WERROR status;
1529
1530         c->status = dcerpc_ndr_request_recv(req);
1531         if (!composite_is_ok(c)) return;
1532
1533         status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi2);
1534         if (!W_ERROR_IS_OK(status)) {
1535                 composite_error(c, werror_to_ntstatus(status));
1536                 return;
1537         }
1538
1539         /* this avoids the epmapper lookup on the 2nd connection */
1540         binding_str = dcerpc_binding_string(s, s->drsuapi2.binding);
1541         if (composite_nomem(binding_str, c)) return;
1542
1543         c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi3.binding);
1544         talloc_free(binding_str);
1545         if (!composite_is_ok(c)) return;
1546
1547         becomeDC_drsuapi_connect_send(s, &s->drsuapi3, becomeDC_drsuapi3_connect_recv);
1548 }
1549
1550 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s);
1551
1552 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req)
1553 {
1554         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
1555                                           struct libnet_BecomeDC_state);
1556         struct composite_context *c = s->creq;
1557
1558         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi3.pipe);
1559         if (!composite_is_ok(c)) return;
1560
1561         becomeDC_drsuapi3_pull_schema_send(s);
1562 }
1563
1564 static void becomeDC_drsuapi_pull_partition_send(struct libnet_BecomeDC_state *s,
1565                                                  struct becomeDC_drsuapi *drsuapi_h,
1566                                                  struct becomeDC_drsuapi *drsuapi_p,
1567                                                  struct becomeDC_partition *partition,
1568                                                  void (*recv_fn)(struct rpc_request *req))
1569 {
1570         struct composite_context *c = s->creq;
1571         struct rpc_request *req;
1572         struct drsuapi_DsGetNCChanges *r;
1573
1574         r = talloc(s, struct drsuapi_DsGetNCChanges);
1575         if (composite_nomem(r, c)) return;
1576
1577         r->in.bind_handle       = &drsuapi_h->bind_handle;
1578         if (drsuapi_h->remote_info28.supported_extensions & DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8) {
1579                 r->in.level                             = 8;
1580                 r->in.req.req8.destination_dsa_guid     = partition->destination_dsa_guid;
1581                 r->in.req.req8.source_dsa_invocation_id = partition->source_dsa_invocation_id;
1582                 r->in.req.req8.naming_context           = &partition->nc;
1583                 r->in.req.req8.highwatermark            = partition->highwatermark;
1584                 r->in.req.req8.uptodateness_vector      = partition->uptodateness_vector;
1585                 r->in.req.req8.replica_flags            = partition->replica_flags;
1586                 r->in.req.req8.max_object_count         = 133;
1587                 r->in.req.req8.max_ndr_size             = 1336811;
1588                 r->in.req.req8.unknown4                 = 0;
1589                 r->in.req.req8.h1                       = 0;
1590                 r->in.req.req8.unique_ptr1              = 0;
1591                 r->in.req.req8.unique_ptr2              = 0;
1592                 r->in.req.req8.ctr12.count              = 0;
1593                 r->in.req.req8.ctr12.array              = NULL;
1594         } else {
1595                 r->in.level                             = 5;
1596                 r->in.req.req5.destination_dsa_guid     = partition->destination_dsa_guid;
1597                 r->in.req.req5.source_dsa_invocation_id = partition->source_dsa_invocation_id;
1598                 r->in.req.req5.naming_context           = &partition->nc;
1599                 r->in.req.req5.highwatermark            = partition->highwatermark;
1600                 r->in.req.req5.uptodateness_vector      = partition->uptodateness_vector;
1601                 r->in.req.req5.replica_flags            = partition->replica_flags;
1602                 r->in.req.req5.max_object_count         = 133;
1603                 r->in.req.req5.max_ndr_size             = 1336770;
1604                 r->in.req.req5.unknown4                 = 0;
1605                 r->in.req.req5.h1                       = 0;
1606         }
1607
1608 DEBUG(0,("start NC[%s] tmp_highest_usn[%llu] highest_usn[%llu]\n",
1609         partition->nc.dn,
1610         partition->highwatermark.tmp_highest_usn,
1611         partition->highwatermark.highest_usn));
1612
1613         /*
1614          * we should try to use the drsuapi_p->pipe here, as w2k3 does
1615          * but it seems that some extra flags in the DCERPC Bind call
1616          * are needed for it. Or the same KRB5 TGS is needed on both
1617          * connections.
1618          */
1619         req = dcerpc_drsuapi_DsGetNCChanges_send(drsuapi_h->pipe, r, r);
1620         composite_continue_rpc(c, req, recv_fn, s);
1621 }
1622
1623 static WERROR becomeDC_drsuapi_pull_partition_recv(struct libnet_BecomeDC_state *s,
1624                                                    struct becomeDC_partition *partition,
1625                                                    struct drsuapi_DsGetNCChanges *r)
1626 {
1627         struct drsuapi_DsGetNCChangesCtr1 *ctr1 = NULL;
1628         struct drsuapi_DsGetNCChangesCtr6 *ctr6 = NULL;
1629         uint32_t out_level = 0;
1630         struct GUID *source_dsa_guid;
1631         struct GUID *source_dsa_invocation_id;
1632         struct drsuapi_DsReplicaHighWaterMark *new_highwatermark;
1633         struct drsuapi_DsReplicaObjectListItemEx *first_object;
1634         struct drsuapi_DsReplicaObjectListItemEx *cur;
1635
1636         if (!W_ERROR_IS_OK(r->out.result)) {
1637                 return r->out.result;
1638         }
1639
1640         if (r->out.level == 1) {
1641                 out_level = 1;
1642                 ctr1 = &r->out.ctr.ctr1;
1643         } else if (r->out.level == 2) {
1644                 out_level = 1;
1645                 ctr1 = r->out.ctr.ctr2.ctr.mszip1.ctr1;
1646         } else if (r->out.level == 6) {
1647                 out_level = 6;
1648                 ctr6 = &r->out.ctr.ctr6;
1649         } else if (r->out.level == 7 &&
1650                    r->out.ctr.ctr7.level == 6 &&
1651                    r->out.ctr.ctr7.type == DRSUAPI_COMPRESSION_TYPE_MSZIP) {
1652                 out_level = 6;
1653                 ctr6 = r->out.ctr.ctr7.ctr.mszip6.ctr6;
1654         } else {
1655                 return WERR_BAD_NET_RESP;
1656         }
1657
1658         switch (out_level) {
1659         case 1:
1660                 source_dsa_guid                 = &ctr1->source_dsa_guid;
1661                 source_dsa_invocation_id        = &ctr1->source_dsa_invocation_id;
1662                 new_highwatermark               = &ctr1->new_highwatermark;
1663                 first_object                    = ctr1->first_object;
1664                 break;
1665         case 6:
1666                 source_dsa_guid                 = &ctr6->source_dsa_guid;
1667                 source_dsa_invocation_id        = &ctr6->source_dsa_invocation_id;
1668                 new_highwatermark               = &ctr6->new_highwatermark;
1669                 first_object                    = ctr6->first_object;
1670                 break;
1671         }
1672
1673         partition->highwatermark                = *new_highwatermark;
1674         partition->source_dsa_guid              = *source_dsa_guid;
1675         partition->source_dsa_invocation_id     = *source_dsa_invocation_id;
1676
1677         if (!partition->first_object) {
1678                 partition->first_object = talloc_steal(s, first_object);
1679         } else {
1680                 partition->last_object->next_object = talloc_steal(partition->last_object,
1681                                                                    first_object);
1682         }
1683         for (cur = first_object; cur->next_object; cur = cur->next_object) {}
1684         partition->last_object = cur;
1685
1686 DEBUG(0,("end NC[%s] tmp_highest_usn[%llu] highest_usn[%llu]\n",
1687         partition->nc.dn,
1688         partition->highwatermark.tmp_highest_usn,
1689         partition->highwatermark.highest_usn));
1690
1691         return WERR_OK;
1692 }
1693
1694 static void becomeDC_drsuapi3_pull_schema_recv(struct rpc_request *req);
1695
1696 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s)
1697 {
1698         s->schema_part.nc.guid  = GUID_zero();
1699         s->schema_part.nc.sid   = s->zero_sid;
1700         s->schema_part.nc.dn    = s->forest.schema_dn_str;
1701
1702         s->schema_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
1703
1704         s->schema_part.replica_flags    = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
1705                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
1706                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
1707                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
1708                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
1709                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
1710
1711         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
1712                                              becomeDC_drsuapi3_pull_schema_recv);
1713 }
1714
1715 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s);
1716
1717 static void becomeDC_drsuapi3_pull_schema_recv(struct rpc_request *req)
1718 {
1719         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1720                                           struct libnet_BecomeDC_state);
1721         struct composite_context *c = s->creq;
1722         struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
1723                                            struct drsuapi_DsGetNCChanges);
1724         WERROR status;
1725
1726         c->status = dcerpc_ndr_request_recv(req);
1727         if (!composite_is_ok(c)) return;
1728
1729         status = becomeDC_drsuapi_pull_partition_recv(s, &s->schema_part, r);
1730         if (!W_ERROR_IS_OK(status)) {
1731                 composite_error(c, werror_to_ntstatus(status));
1732                 return;
1733         }
1734
1735         talloc_free(r);
1736
1737         if (s->schema_part.highwatermark.tmp_highest_usn > s->schema_part.highwatermark.highest_usn) {
1738                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
1739                                                      becomeDC_drsuapi3_pull_schema_recv);
1740                 return;
1741         }
1742
1743         becomeDC_drsuapi3_pull_config_send(s);
1744 }
1745
1746 static void becomeDC_drsuapi3_pull_config_recv(struct rpc_request *req);
1747
1748 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s)
1749 {
1750         s->config_part.nc.guid  = GUID_zero();
1751         s->config_part.nc.sid   = s->zero_sid;
1752         s->config_part.nc.dn    = s->forest.config_dn_str;
1753
1754         s->config_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
1755
1756         s->config_part.replica_flags    = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
1757                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
1758                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
1759                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
1760                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
1761                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
1762
1763         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
1764                                              becomeDC_drsuapi3_pull_config_recv);
1765 }
1766
1767 static void becomeDC_drsuapi3_pull_config_recv(struct rpc_request *req)
1768 {
1769         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1770                                           struct libnet_BecomeDC_state);
1771         struct composite_context *c = s->creq;
1772         struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
1773                                            struct drsuapi_DsGetNCChanges);
1774         WERROR status;
1775
1776         c->status = dcerpc_ndr_request_recv(req);
1777         if (!composite_is_ok(c)) return;
1778
1779         status = becomeDC_drsuapi_pull_partition_recv(s, &s->config_part, r);
1780         if (!W_ERROR_IS_OK(status)) {
1781                 composite_error(c, werror_to_ntstatus(status));
1782                 return;
1783         }
1784
1785         talloc_free(r);
1786
1787         if (s->config_part.highwatermark.tmp_highest_usn > s->config_part.highwatermark.highest_usn) {
1788                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
1789                                                      becomeDC_drsuapi3_pull_config_recv);
1790                 return;
1791         }
1792
1793         becomeDC_connect_ldap2(s);
1794 }
1795
1796 static void becomeDC_drsuapi3_pull_domain_recv(struct rpc_request *req);
1797
1798 static void becomeDC_drsuapi3_pull_domain_send(struct libnet_BecomeDC_state *s)
1799 {
1800         s->domain_part.nc.guid  = GUID_zero();
1801         s->domain_part.nc.sid   = s->zero_sid;
1802         s->domain_part.nc.dn    = s->domain.dn_str;
1803
1804         s->domain_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
1805
1806         s->domain_part.replica_flags    = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
1807                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
1808                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
1809                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
1810                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
1811                                         | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
1812
1813         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
1814                                              becomeDC_drsuapi3_pull_domain_recv);
1815 }
1816
1817 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
1818                                               struct becomeDC_drsuapi *drsuapi,
1819                                               struct becomeDC_partition *partition,
1820                                               void (*recv_fn)(struct rpc_request *req));
1821 static void becomeDC_drsuapi2_update_refs_schema_recv(struct rpc_request *req);
1822
1823 static void becomeDC_drsuapi3_pull_domain_recv(struct rpc_request *req)
1824 {
1825         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1826                                           struct libnet_BecomeDC_state);
1827         struct composite_context *c = s->creq;
1828         struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
1829                                            struct drsuapi_DsGetNCChanges);
1830         WERROR status;
1831
1832         c->status = dcerpc_ndr_request_recv(req);
1833         if (!composite_is_ok(c)) return;
1834
1835         status = becomeDC_drsuapi_pull_partition_recv(s, &s->domain_part, r);
1836         if (!W_ERROR_IS_OK(status)) {
1837                 composite_error(c, werror_to_ntstatus(status));
1838                 return;
1839         }
1840
1841         talloc_free(r);
1842
1843         if (s->domain_part.highwatermark.tmp_highest_usn > s->domain_part.highwatermark.highest_usn) {
1844                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
1845                                                      becomeDC_drsuapi3_pull_domain_recv);
1846                 return;
1847         }
1848
1849         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->schema_part,
1850                                           becomeDC_drsuapi2_update_refs_schema_recv);
1851 }
1852
1853 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
1854                                               struct becomeDC_drsuapi *drsuapi,
1855                                               struct becomeDC_partition *partition,
1856                                               void (*recv_fn)(struct rpc_request *req))
1857 {
1858         struct composite_context *c = s->creq;
1859         struct rpc_request *req;
1860         struct drsuapi_DsReplicaUpdateRefs *r;
1861         const char *ntds_guid_str;
1862         const char *ntds_dns_name;
1863
1864         r = talloc(s, struct drsuapi_DsReplicaUpdateRefs);
1865         if (composite_nomem(r, c)) return;
1866
1867         ntds_guid_str = GUID_string(r, &s->dest_dsa.ntds_guid);
1868         if (composite_nomem(ntds_guid_str, c)) return;
1869
1870         ntds_dns_name = talloc_asprintf(r, "%s._msdcs.%s",
1871                                         ntds_guid_str,
1872                                         s->domain.dns_name);
1873         if (composite_nomem(ntds_dns_name, c)) return;
1874
1875         r->in.bind_handle               = &drsuapi->bind_handle;
1876         r->in.level                     = 1;
1877         r->in.req.req1.naming_context   = &partition->nc;
1878         r->in.req.req1.dest_dsa_dns_name= ntds_dns_name;
1879         r->in.req.req1.dest_dsa_guid    = s->dest_dsa.ntds_guid;
1880         r->in.req.req1.options          = DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE
1881                                         | DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE
1882                                         | DRSUAPI_DS_REPLICA_UPDATE_0x00000010;
1883
1884         req = dcerpc_drsuapi_DsReplicaUpdateRefs_send(drsuapi->pipe, r, r);
1885         composite_continue_rpc(c, req, recv_fn, s);
1886 }
1887
1888 static void becomeDC_drsuapi2_update_refs_config_recv(struct rpc_request *req);
1889
1890 static void becomeDC_drsuapi2_update_refs_schema_recv(struct rpc_request *req)
1891 {
1892         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1893                                           struct libnet_BecomeDC_state);
1894         struct composite_context *c = s->creq;
1895         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
1896                                            struct drsuapi_DsReplicaUpdateRefs);
1897
1898         c->status = dcerpc_ndr_request_recv(req);
1899         if (!composite_is_ok(c)) return;
1900
1901         if (!W_ERROR_IS_OK(r->out.result)) {
1902                 composite_error(c, werror_to_ntstatus(r->out.result));
1903                 return;
1904         }
1905
1906         talloc_free(r);
1907
1908         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->config_part,
1909                                           becomeDC_drsuapi2_update_refs_config_recv);
1910 }
1911
1912 static void becomeDC_drsuapi2_update_refs_domain_recv(struct rpc_request *req);
1913
1914 static void becomeDC_drsuapi2_update_refs_config_recv(struct rpc_request *req)
1915 {
1916         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1917                                           struct libnet_BecomeDC_state);
1918         struct composite_context *c = s->creq;
1919         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
1920                                            struct drsuapi_DsReplicaUpdateRefs);
1921
1922         c->status = dcerpc_ndr_request_recv(req);
1923         if (!composite_is_ok(c)) return;
1924
1925         if (!W_ERROR_IS_OK(r->out.result)) {
1926                 composite_error(c, werror_to_ntstatus(r->out.result));
1927                 return;
1928         }
1929
1930         talloc_free(r);
1931
1932         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->domain_part,
1933                                           becomeDC_drsuapi2_update_refs_domain_recv);
1934 }
1935
1936 static void becomeDC_drsuapi2_update_refs_domain_recv(struct rpc_request *req)
1937 {
1938         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
1939                                           struct libnet_BecomeDC_state);
1940         struct composite_context *c = s->creq;
1941         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
1942                                            struct drsuapi_DsReplicaUpdateRefs);
1943
1944         c->status = dcerpc_ndr_request_recv(req);
1945         if (!composite_is_ok(c)) return;
1946
1947         if (!W_ERROR_IS_OK(r->out.result)) {
1948                 composite_error(c, werror_to_ntstatus(r->out.result));
1949                 return;
1950         }
1951
1952         talloc_free(r);
1953
1954         /* TODO: use DDNS updates and register dns names */
1955         composite_done(c);
1956 }
1957
1958 static NTSTATUS becomeDC_ldap2_modify_computer(struct libnet_BecomeDC_state *s)
1959 {
1960         int ret;
1961         struct ldb_message *msg;
1962         uint32_t i;
1963         uint32_t user_account_control = UF_SERVER_TRUST_ACCOUNT |
1964                                         UF_TRUSTED_FOR_DELEGATION;
1965
1966         /* as the value is already as we want it to be, we're done */
1967         if (s->dest_dsa.user_account_control == user_account_control) {
1968                 return NT_STATUS_OK;
1969         }
1970
1971         /* make a 'modify' msg, and only for serverReference */
1972         msg = ldb_msg_new(s);
1973         NT_STATUS_HAVE_NO_MEMORY(msg);
1974         msg->dn = ldb_dn_new(msg, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
1975         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1976
1977         ret = ldb_msg_add_fmt(msg, "userAccountControl", "%u", user_account_control);
1978         if (ret != 0) {
1979                 talloc_free(msg);
1980                 return NT_STATUS_NO_MEMORY;
1981         }
1982
1983         /* mark all the message elements (should be just one)
1984            as LDB_FLAG_MOD_REPLACE */
1985         for (i=0;i<msg->num_elements;i++) {
1986                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
1987         }
1988
1989         ret = ldb_modify(s->ldap2.ldb, msg);
1990         talloc_free(msg);
1991         if (ret != LDB_SUCCESS) {
1992                 return NT_STATUS_LDAP(ret);
1993         }
1994
1995         s->dest_dsa.user_account_control = user_account_control;
1996
1997         return NT_STATUS_OK;
1998 }
1999
2000 static NTSTATUS becomeDC_ldap2_move_computer(struct libnet_BecomeDC_state *s)
2001 {
2002         int ret;
2003         struct ldb_result *r;
2004         struct ldb_dn *basedn;
2005         struct ldb_dn *old_dn;
2006         struct ldb_dn *new_dn;
2007         static const char *_1_1_attrs[] = {
2008                 "1.1",
2009                 NULL
2010         };
2011
2012         basedn = ldb_dn_new_fmt(s, s->ldap2.ldb, "<WKGUID=a361b2ffffd211d1aa4b00c04fd7d83a,%s>",
2013                                 s->domain.dn_str);
2014         NT_STATUS_HAVE_NO_MEMORY(basedn);
2015
2016         ret = ldb_search(s->ldap2.ldb, basedn, LDB_SCOPE_BASE,
2017                          "(objectClass=*)", _1_1_attrs, &r);
2018         talloc_free(basedn);
2019         if (ret != LDB_SUCCESS) {
2020                 return NT_STATUS_LDAP(ret);
2021         } else if (r->count != 1) {
2022                 talloc_free(r);
2023                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
2024         }
2025
2026         old_dn = ldb_dn_new(r, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
2027         NT_STATUS_HAVE_NO_MEMORY(old_dn);
2028
2029         new_dn = r->msgs[0]->dn;
2030
2031         if (!ldb_dn_add_child_fmt(new_dn, "CN=%s", s->dest_dsa.netbios_name)) {
2032                 talloc_free(r);
2033                 return NT_STATUS_NO_MEMORY;
2034         }
2035
2036         if (ldb_dn_compare(old_dn, new_dn) == 0) {
2037                 /* we don't need to rename if the old and new dn match */
2038                 talloc_free(r);
2039                 return NT_STATUS_OK;
2040         }
2041
2042         ret = ldb_rename(s->ldap2.ldb, old_dn, new_dn);
2043         if (ret != LDB_SUCCESS) {
2044                 talloc_free(r);
2045                 return NT_STATUS_LDAP(ret);
2046         }
2047
2048         s->dest_dsa.computer_dn_str = ldb_dn_alloc_linearized(s, new_dn);
2049         NT_STATUS_HAVE_NO_MEMORY(s->dest_dsa.computer_dn_str);
2050
2051         talloc_free(r);
2052
2053         return NT_STATUS_OK;
2054 }
2055
2056 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s)
2057 {
2058         struct composite_context *c = s->creq;
2059
2060         c->status = becomeDC_ldap_connect(s, &s->ldap2);
2061         if (!composite_is_ok(c)) return;
2062
2063         c->status = becomeDC_ldap2_modify_computer(s);
2064         if (!composite_is_ok(c)) return;
2065
2066         c->status = becomeDC_ldap2_move_computer(s);
2067         if (!composite_is_ok(c)) return;
2068
2069         becomeDC_drsuapi3_pull_domain_send(s);
2070 }
2071
2072 struct composite_context *libnet_BecomeDC_send(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
2073 {
2074         struct composite_context *c;
2075         struct libnet_BecomeDC_state *s;
2076         char *tmp_name;
2077
2078         c = composite_create(mem_ctx, ctx->event_ctx);
2079         if (c == NULL) return NULL;
2080
2081         s = talloc_zero(c, struct libnet_BecomeDC_state);
2082         if (composite_nomem(s, c)) return c;
2083         c->private_data = s;
2084         s->creq         = c;
2085         s->libnet       = ctx;
2086
2087         /* Domain input */
2088         s->domain.dns_name      = talloc_strdup(s, r->in.domain_dns_name);
2089         if (composite_nomem(s->domain.dns_name, c)) return c;
2090         s->domain.netbios_name  = talloc_strdup(s, r->in.domain_netbios_name);
2091         if (composite_nomem(s->domain.netbios_name, c)) return c;
2092         s->domain.sid           = dom_sid_dup(s, r->in.domain_sid);
2093         if (composite_nomem(s->domain.sid, c)) return c;
2094
2095         /* Source DSA input */
2096         s->source_dsa.address   = talloc_strdup(s, r->in.source_dsa_address);
2097         if (composite_nomem(s->source_dsa.address, c)) return c;
2098
2099         /* Destination DSA input */
2100         s->dest_dsa.netbios_name= talloc_strdup(s, r->in.dest_dsa_netbios_name);
2101         if (composite_nomem(s->dest_dsa.netbios_name, c)) return c;
2102
2103         /* Destination DSA dns_name construction */
2104         tmp_name                = strlower_talloc(s, s->dest_dsa.netbios_name);
2105         if (composite_nomem(tmp_name, c)) return c;
2106         s->dest_dsa.dns_name    = talloc_asprintf_append(tmp_name, ".%s",
2107                                                          s->domain.dns_name);
2108         if (composite_nomem(s->dest_dsa.dns_name, c)) return c;
2109
2110         becomeDC_send_cldap(s);
2111         return c;
2112 }
2113
2114 NTSTATUS libnet_BecomeDC_recv(struct composite_context *c, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
2115 {
2116         NTSTATUS status;
2117
2118         status = composite_wait(c);
2119
2120         ZERO_STRUCT(r->out);
2121
2122         talloc_free(c);
2123         return status;
2124 }
2125
2126 NTSTATUS libnet_BecomeDC(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
2127 {
2128         NTSTATUS status;
2129         struct composite_context *c;
2130         c = libnet_BecomeDC_send(ctx, mem_ctx, r);
2131         status = libnet_BecomeDC_recv(c, mem_ctx, r);
2132         return status;
2133 }