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