source4/libnet/libnet_become_dc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Copyright (C) Stefan Metzmacher <metze@samba.org> 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 3 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, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "libnet/libnet.h"
  22 #include "libcli/composite/composite.h"
  23 #include "libcli/cldap/cldap.h"
  24 #include <ldb.h>
  25 #include <ldb_errors.h>
  26 #include "ldb_wrap.h"
  27 #include "dsdb/samdb/samdb.h"
  28 #include "../libds/common/flags.h"
  29 #include "librpc/gen_ndr/ndr_drsuapi_c.h"
  30 #include "libcli/security/security.h"
  31 #include "librpc/gen_ndr/ndr_misc.h"
  32 #include "librpc/gen_ndr/ndr_security.h"
  33 #include "librpc/gen_ndr/ndr_nbt.h"
  34 #include "librpc/gen_ndr/ndr_drsuapi.h"
  35 #include "auth/gensec/gensec.h"
  36 #include "param/param.h"
  37 #include "lib/tsocket/tsocket.h"
  38
  39 /*****************************************************************************
  40  * Windows 2003 (w2k3) does the following steps when changing the server role
  41  * from domain member to domain controller
  42  *
  43  * We mostly do the same.
  44  *****************************************************************************/
  45
  46 /*
  47  * lookup DC:
  48  * - using nbt name<1C> request and a samlogon mailslot request
  49  * or
  50  * - using a DNS SRV _ldap._tcp.dc._msdcs. request and a CLDAP netlogon request
  51  *
  52  * see: becomeDC_recv_cldap() and becomeDC_send_cldap()
  53  */
  54
  55 /*
  56  * Open 1st LDAP connection to the DC using admin credentials
  57  *
  58  * see: becomeDC_connect_ldap1() and becomeDC_ldap_connect()
  59  */
  60
  61 /*
  62  * LDAP search 1st LDAP connection:
  63  *
  64  * see: becomeDC_ldap1_rootdse()
  65  *
  66  * Request:
  67  *      basedn: ""
  68  *      scope:  base
  69  *      filter: (objectClass=*)
  70  *      attrs:  *
  71  * Result:
  72  *      ""
  73  *              currentTime:            20061202155100.0Z
  74  *              subschemaSubentry:      CN=Aggregate,CN=Schema,CN=Configuration,<domain_partition>
  75  *              dsServiceName:          CN=<netbios_name>,CN=Servers,CN=<site_name>,CN=Sites,CN=Configuration,<domain_partition>
  76  *              namingContexts:         <domain_partition>
  77  *                                      CN=Configuration,<domain_partition>
  78  *                                      CN=Schema,CN=Configuration,<domain_partition>
  79  *              defaultNamingContext:   <domain_partition>
  80  *              schemaNamingContext:    CN=Schema,CN=Configuration,<domain_partition>
  81  *              configurationNamingContext:CN=Configuration,<domain_partition>
  82  *              rootDomainNamingContext:<domain_partition>
  83  *              supportedControl:       ...
  84  *              supportedLDAPVersion:   3
  85  *                                      2
  86  *              supportedLDAPPolicies:  ...
  87  *              highestCommitedUSN:     ...
  88  *              supportedSASLMechanisms:GSSAPI
  89  *                                      GSS-SPNEGO
  90  *                                      EXTERNAL
  91  *                                      DIGEST-MD5
  92  *              dnsHostName:            <dns_host_name>
  93  *              ldapServiceName:        <domain_dns_name>:<netbios_name>$@<REALM>
  94  *              serverName:             CN=Servers,CN=<site_name>,CN=Sites,CN=Configuration,<domain_partition>
  95  *              supportedCapabilities:  ...
  96  *              isSyncronized:          TRUE
  97  *              isGlobalCatalogReady:   TRUE
  98  *              domainFunctionality:    0
  99  *              forestFunctionality:    0
 100  *              domainControllerFunctionality: 2
 101  */
 102
 103 /*
 104  * LDAP search 1st LDAP connection:
 105  *
 106  * see: becomeDC_ldap1_crossref_behavior_version()
 107  *
 108  * Request:
 109  *      basedn: CN=Configuration,<domain_partition>
 110  *      scope:  one
 111  *      filter: (cn=Partitions)
 112  *      attrs:  msDS-Behavior-Version
 113  * Result:
 114  *      CN=Partitions,CN=Configuration,<domain_partition>
 115  *              msDS-Behavior-Version:  0
 116  */
 117
 118 /*
 119  * LDAP search 1st LDAP connection:
 120  *
 121  * NOTE: this seems to be a bug! as the messageID of the LDAP message is corrupted!
 122  *
 123  * not implemented here
 124  *
 125  * Request:
 126  *      basedn: CN=Schema,CN=Configuration,<domain_partition>
 127  *      scope:  one
 128  *      filter: (cn=Partitions)
 129  *      attrs:  msDS-Behavior-Version
 130  * Result:
 131  *      <none>
 132  *
 133  */
 134
 135 /*
 136  * LDAP search 1st LDAP connection:
 137  *
 138  * see: becomeDC_ldap1_domain_behavior_version()
 139  *
 140  * Request:
 141  *      basedn: <domain_partition>
 142  *      scope:  base
 143  *      filter: (objectClass=*)
 144  *      attrs:  msDS-Behavior-Version
 145  * Result:
 146  *      <domain_partition>
 147  *              msDS-Behavior-Version:  0
 148  */
 149
 150 /*
 151  * LDAP search 1st LDAP connection:
 152  *
 153  * see: becomeDC_ldap1_schema_object_version()
 154  *
 155  * Request:
 156  *      basedn: CN=Schema,CN=Configuration,<domain_partition>
 157  *      scope:  base
 158  *      filter: (objectClass=*)
 159  *      attrs:  objectVersion
 160  * Result:
 161  *      CN=Schema,CN=Configuration,<domain_partition>
 162  *              objectVersion:  30
 163  */
 164
 165 /*
 166  * LDAP search 1st LDAP connection:
 167  *
 168  * not implemented, because the information is already there
 169  *
 170  * Request:
 171  *      basedn: ""
 172  *      scope:  base
 173  *      filter: (objectClass=*)
 174  *      attrs:  defaultNamingContext
 175  *              dnsHostName
 176  * Result:
 177  *      ""
 178  *              defaultNamingContext:   <domain_partition>
 179  *              dnsHostName:            <dns_host_name>
 180  */
 181
 182 /*
 183  * LDAP search 1st LDAP connection:
 184  *
 185  * see: becomeDC_ldap1_infrastructure_fsmo()
 186  *
 187  * Request:
 188  *      basedn: <WKGUID=2fbac1870ade11d297c400c04fd8d5cd,domain_partition>
 189  *      scope:  base
 190  *      filter: (objectClass=*)
 191  *      attrs:  1.1
 192  * Result:
 193  *      CN=Infrastructure,<domain_partition>
 194  */
 195
 196 /*
 197  * LDAP search 1st LDAP connection:
 198  *
 199  * see: becomeDC_ldap1_w2k3_update_revision()
 200  *
 201  * Request:
 202  *      basedn: CN=Windows2003Update,CN=DomainUpdates,CN=System,<domain_partition>
 203  *      scope:  base
 204  *      filter: (objectClass=*)
 205  *      attrs:  revision
 206  * Result:
 207  *      CN=Windows2003Update,CN=DomainUpdates,CN=System,<domain_partition>
 208  *              revision:       8
 209  */
 210
 211 /*
 212  * LDAP search 1st LDAP connection:
 213  *
 214  * see: becomeDC_ldap1_infrastructure_fsmo()
 215  *
 216  * Request:
 217  *      basedn: CN=Infrastructure,<domain_partition>
 218  *      scope:  base
 219  *      filter: (objectClass=*)
 220  *      attrs:  fSMORoleOwner
 221  * Result:
 222  *      CN=Infrastructure,<domain_partition>
 223  *              fSMORoleOwner:  CN=NTDS Settings,<infrastructure_fsmo_server_object>
 224  */
 225
 226 /*
 227  * LDAP search 1st LDAP connection:
 228  *
 229  * see: becomeDC_ldap1_infrastructure_fsmo()
 230  *
 231  * Request:
 232  *      basedn: <infrastructure_fsmo_server_object>
 233  *      scope:  base
 234  *      filter: (objectClass=*)
 235  *      attrs:  dnsHostName
 236  * Result:
 237  *      <infrastructure_fsmo_server_object>
 238  *              dnsHostName:    <dns_host_name>
 239  */
 240
 241 /*
 242  * LDAP search 1st LDAP connection:
 243  *
 244  * see: becomeDC_ldap1_infrastructure_fsmo()
 245  *
 246  * Request:
 247  *      basedn: CN=NTDS Settings,<infrastructure_fsmo_server_object>
 248  *      scope:  base
 249  *      filter: (objectClass=*)
 250  *      attrs:  objectGUID
 251  * Result:
 252  *      CN=NTDS Settings,<infrastructure_fsmo_server_object>
 253  *              objectGUID:     <object_guid>
 254  */
 255
 256 /*
 257  * LDAP search 1st LDAP connection:
 258  *
 259  * see: becomeDC_ldap1_rid_manager_fsmo()
 260  *
 261  * Request:
 262  *      basedn: <domain_partition>
 263  *      scope:  base
 264  *      filter: (objectClass=*)
 265  *      attrs:  rIDManagerReference
 266  * Result:
 267  *      <domain_partition>
 268  *              rIDManagerReference:    CN=RID Manager$,CN=System,<domain_partition>
 269  */
 270
 271 /*
 272  * LDAP search 1st LDAP connection:
 273  *
 274  * see: becomeDC_ldap1_rid_manager_fsmo()
 275  *
 276  * Request:
 277  *      basedn: CN=RID Manager$,CN=System,<domain_partition>
 278  *      scope:  base
 279  *      filter: (objectClass=*)
 280  *      attrs:  fSMORoleOwner
 281  * Result:
 282  *      CN=Infrastructure,<domain_partition>
 283  *              fSMORoleOwner:  CN=NTDS Settings,<rid_manager_fsmo_server_object>
 284  */
 285
 286 /*
 287  * LDAP search 1st LDAP connection:
 288  *
 289  * see: becomeDC_ldap1_rid_manager_fsmo()
 290  *
 291  * Request:
 292  *      basedn: <rid_manager_fsmo_server_object>
 293  *      scope:  base
 294  *      filter: (objectClass=*)
 295  *      attrs:  dnsHostName
 296  * Result:
 297  *      <rid_manager_fsmo_server_object>
 298  *              dnsHostName:    <dns_host_name>
 299  */
 300
 301 /*
 302  * LDAP search 1st LDAP connection:
 303  *
 304  * see: becomeDC_ldap1_rid_manager_fsmo()
 305  *
 306  * Request:
 307  *      basedn: CN=NTDS Settings,<rid_manager_fsmo_server_object>
 308  *      scope:  base
 309  *      filter: (objectClass=*)
 310  *      attrs:  msDs-ReplicationEpoch
 311  * Result:
 312  *      CN=NTDS Settings,<rid_manager_fsmo_server_object>
 313  */
 314
 315 /*
 316  * LDAP search 1st LDAP connection:
 317  *
 318  * see: becomeDC_ldap1_site_object()
 319  *
 320  * Request:
 321  *      basedn: CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
 322  *      scope:  base
 323  *      filter: (objectClass=*)
 324  *      attrs:
 325  * Result:
 326  *      CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
 327  *              objectClass:    top
 328  *                              site
 329  *              cn:             <new_dc_site_name>
 330  *              distinguishedName:CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
 331  *              instanceType:   4
 332  *              whenCreated:    ...
 333  *              whenChanged:    ...
 334  *              uSNCreated:     ...
 335  *              uSNChanged:     ...
 336  *              showInAdvancedViewOnly: TRUE
 337  *              name:           <new_dc_site_name>
 338  *              objectGUID:     <object_guid>
 339  *              systemFlags:    1107296256 <0x42000000>
 340  *              objectCategory: CN=Site,CN=Schema,CN=Configuration,<domain_partition>
 341  */
 342
 343 /***************************************************************
 344  * Add this stage we call the check_options() callback function
 345  * of the caller, to see if he wants us to continue
 346  *
 347  * see: becomeDC_check_options()
 348  ***************************************************************/
 349
 350 /*
 351  * LDAP search 1st LDAP connection:
 352  *
 353  * see: becomeDC_ldap1_computer_object()
 354  *
 355  * Request:
 356  *      basedn: <domain_partition>
 357  *      scope:  sub
 358  *      filter: (&(|(objectClass=user)(objectClass=computer))(sAMAccountName=<new_dc_account_name>))
 359  *      attrs:  distinguishedName
 360  *              userAccountControl
 361  * Result:
 362  *      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 363  *              distinguishedName:      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 364  *              userAccoountControl:    4096 <0x1000>
 365  */
 366
 367 /*
 368  * LDAP search 1st LDAP connection:
 369  *
 370  * see: becomeDC_ldap1_server_object_1()
 371  *
 372  * Request:
 373  *      basedn: CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
 374  *      scope:  base
 375  *      filter: (objectClass=*)
 376  *      attrs:
 377  * Result:
 378  *      <noSuchObject>
 379  *      <matchedDN:CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>>
 380  */
 381
 382 /*
 383  * LDAP search 1st LDAP connection:
 384  *
 385  * see: becomeDC_ldap1_server_object_2()
 386  *
 387  * Request:
 388  *      basedn: CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 389  *      scope:  base
 390  *      filter: (objectClass=*)
 391  *      attrs:  serverReferenceBL
 392  *      typesOnly: TRUE!!!
 393  * Result:
 394  *      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 395  */
 396
 397 /*
 398  * LDAP add 1st LDAP connection:
 399  *
 400  * see: becomeDC_ldap1_server_object_add()
 401  *
 402  * Request:
 403  *      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 404  *      objectClass:    server
 405  *      systemFlags:    50000000 <0x2FAF080>
 406  *      serverReference:CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 407  * Result:
 408  *      <success>
 409  */
 410
 411 /*
 412  * LDAP search 1st LDAP connection:
 413  *
 414  * not implemented, maybe we can add that later
 415  *
 416  * Request:
 417  *      basedn: CN=NTDS Settings,CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
 418  *      scope:  base
 419  *      filter: (objectClass=*)
 420  *      attrs:
 421  * Result:
 422  *      <noSuchObject>
 423  *      <matchedDN:CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>>
 424  */
 425
 426 /*
 427  * LDAP search 1st LDAP connection:
 428  *
 429  * not implemented because it gives no new information
 430  *
 431  * Request:
 432  *      basedn: CN=Partitions,CN=Configuration,<domain_partition>
 433  *      scope:  sub
 434  *      filter: (nCName=<domain_partition>)
 435  *      attrs:  nCName
 436  *              dnsRoot
 437  *      controls: LDAP_SERVER_EXTENDED_DN_OID:critical=false
 438  * Result:
 439  *      <GUID=<hex_guid>>;CN=<domain_netbios_name>,CN=Partitions,<domain_partition>>
 440  *              nCName:         <GUID=<hex_guid>>;<SID=<hex_sid>>;<domain_partition>>
 441  *              dnsRoot:        <domain_dns_name>
 442  */
 443
 444 /*
 445  * LDAP modify 1st LDAP connection:
 446  *
 447  * see: becomeDC_ldap1_server_object_modify()
 448  *
 449  * Request (add):
 450  *      CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>>
 451  *      serverReference:CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 452  * Result:
 453  *      <attributeOrValueExist>
 454  */
 455
 456 /*
 457  * LDAP modify 1st LDAP connection:
 458  *
 459  * see: becomeDC_ldap1_server_object_modify()
 460  *
 461  * Request (replace):
 462  *      CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>>
 463  *      serverReference:CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 464  * Result:
 465  *      <success>
 466  */
 467
 468 /*
 469  * Open 1st DRSUAPI connection to the DC using admin credentials
 470  * DsBind with DRSUAPI_DS_BIND_GUID_W2K3 ("6afab99c-6e26-464a-975f-f58f105218bc")
 471  * (w2k3 does 2 DsBind() calls here..., where is first is unused and contains garbage at the end)
 472  *
 473  * see: becomeDC_drsuapi_connect_send(), becomeDC_drsuapi1_connect_recv(),
 474  *      becomeDC_drsuapi_bind_send(), becomeDC_drsuapi_bind_recv() and becomeDC_drsuapi1_bind_recv()
 475  */
 476
 477 /*
 478  * DsAddEntry to create the CN=NTDS Settings,CN=<machine_name>,CN=Servers,CN=Default-First-Site-Name, ...
 479  * on the 1st DRSUAPI connection
 480  *
 481  * see: becomeDC_drsuapi1_add_entry_send() and becomeDC_drsuapi1_add_entry_recv()
 482  */
 483
 484 /***************************************************************
 485  * Add this stage we call the prepare_db() callback function
 486  * of the caller, to see if he wants us to continue
 487  *
 488  * see: becomeDC_prepare_db()
 489  ***************************************************************/
 490
 491 /*
 492  * Open 2nd and 3rd DRSUAPI connection to the DC using admin credentials
 493  * - a DsBind with DRSUAPI_DS_BIND_GUID_W2K3 ("6afab99c-6e26-464a-975f-f58f105218bc")
 494  *   on the 2nd connection
 495  *
 496  * see: becomeDC_drsuapi_connect_send(), becomeDC_drsuapi2_connect_recv(),
 497  *      becomeDC_drsuapi_bind_send(), becomeDC_drsuapi_bind_recv(), becomeDC_drsuapi2_bind_recv()
 498  *      and becomeDC_drsuapi3_connect_recv()
 499  */
 500
 501 /*
 502  * replicate CN=Schema,CN=Configuration,...
 503  * on the 3rd DRSUAPI connection and the bind_handle from the 2nd connection
 504  *
 505  * see: becomeDC_drsuapi_pull_partition_send(), becomeDC_drsuapi_pull_partition_recv(),
 506  *      becomeDC_drsuapi3_pull_schema_send() and becomeDC_drsuapi3_pull_schema_recv()
 507  *
 508  ***************************************************************
 509  * Add this stage we call the schema_chunk() callback function
 510  * for each replication message
 511  ***************************************************************/
 512
 513 /*
 514  * replicate CN=Configuration,...
 515  * on the 3rd DRSUAPI connection and the bind_handle from the 2nd connection
 516  *
 517  * see: becomeDC_drsuapi_pull_partition_send(), becomeDC_drsuapi_pull_partition_recv(),
 518  *      becomeDC_drsuapi3_pull_config_send() and becomeDC_drsuapi3_pull_config_recv()
 519  *
 520  ***************************************************************
 521  * Add this stage we call the config_chunk() callback function
 522  * for each replication message
 523  ***************************************************************/
 524
 525 /*
 526  * LDAP unbind on the 1st LDAP connection
 527  *
 528  * not implemented, because it's not needed...
 529  */
 530
 531 /*
 532  * Open 2nd LDAP connection to the DC using admin credentials
 533  *
 534  * see: becomeDC_connect_ldap2() and becomeDC_ldap_connect()
 535  */
 536
 537 /*
 538  * LDAP search 2nd LDAP connection:
 539  *
 540  * not implemented because it gives no new information
 541  * same as becomeDC_ldap1_computer_object()
 542  *
 543  * Request:
 544  *      basedn: <domain_partition>
 545  *      scope:  sub
 546  *      filter: (&(|(objectClass=user)(objectClass=computer))(sAMAccountName=<new_dc_account_name>))
 547  *      attrs:  distinguishedName
 548  *              userAccountControl
 549  * Result:
 550  *      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 551  *              distinguishedName:      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 552  *              userAccoountControl:    4096 <0x00001000>
 553  */
 554
 555 /*
 556  * LDAP search 2nd LDAP connection:
 557  *
 558  * not implemented because it gives no new information
 559  * same as becomeDC_ldap1_computer_object()
 560  *
 561  * Request:
 562  *      basedn: CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 563  *      scope:  base
 564  *      filter: (objectClass=*)
 565  *      attrs:  userAccountControl
 566  * Result:
 567  *      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 568  *              userAccoountControl:    4096 <0x00001000>
 569  */
 570
 571 /*
 572  * LDAP modify 2nd LDAP connection:
 573  *
 574  * see: becomeDC_ldap2_modify_computer()
 575  *
 576  * Request (replace):
 577  *      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 578  *      userAccoountControl:    532480 <0x82000>
 579  * Result:
 580  *      <success>
 581  */
 582
 583 /*
 584  * LDAP search 2nd LDAP connection:
 585  *
 586  * see: becomeDC_ldap2_move_computer()
 587  *
 588  * Request:
 589  *      basedn: <WKGUID=2fbac1870ade11d297c400c04fd8d5cd,<domain_partition>>
 590  *      scope:  base
 591  *      filter: (objectClass=*)
 592  *      attrs:  1.1
 593  * Result:
 594  *      CN=Domain Controllers,<domain_partition>
 595  */
 596
 597 /*
 598  * LDAP search 2nd LDAP connection:
 599  *
 600  * not implemented because it gives no new information
 601  *
 602  * Request:
 603  *      basedn: CN=Domain Controllers,<domain_partition>
 604  *      scope:  base
 605  *      filter: (objectClass=*)
 606  *      attrs:  distinguishedName
 607  * Result:
 608  *      CN=Domain Controller,<domain_partition>
 609  *              distinguishedName:      CN=Domain Controllers,<domain_partition>
 610  */
 611
 612 /*
 613  * LDAP modifyRDN 2nd LDAP connection:
 614  *
 615  * see: becomeDC_ldap2_move_computer()
 616  *
 617  * Request:
 618  *      entry:          CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 619  *      newrdn:         CN=<new_dc_netbios_name>
 620  *      deleteoldrdn:   TRUE
 621  *      newparent:      CN=Domain Controllers,<domain_partition>
 622  * Result:
 623  *      <success>
 624  */
 625
 626 /*
 627  * LDAP unbind on the 2nd LDAP connection
 628  *
 629  * not implemented, because it's not needed...
 630  */
 631
 632 /*
 633  * replicate Domain Partition
 634  * on the 3rd DRSUAPI connection and the bind_handle from the 2nd connection
 635  *
 636  * see: becomeDC_drsuapi_pull_partition_send(), becomeDC_drsuapi_pull_partition_recv(),
 637  *      becomeDC_drsuapi3_pull_domain_send() and becomeDC_drsuapi3_pull_domain_recv()
 638  *
 639  ***************************************************************
 640  * Add this stage we call the domain_chunk() callback function
 641  * for each replication message
 642  ***************************************************************/
 643
 644 /* call DsReplicaUpdateRefs() for all partitions like this:
 645  *     req1: struct drsuapi_DsReplicaUpdateRefsRequest1
 646  *
 647  *                 naming_context: struct drsuapi_DsReplicaObjectIdentifier
 648  *                     __ndr_size               : 0x000000ae (174)
 649  *                     __ndr_size_sid           : 0x00000000 (0)
 650  *                     guid                     : 00000000-0000-0000-0000-000000000000
 651  *                     sid                      : S-0-0
 652  *                     dn                       : 'CN=Schema,CN=Configuration,DC=w2k3,DC=vmnet1,DC=vm,DC=base'
 653  *
 654  *                 dest_dsa_dns_name        : '4a0df188-a0b8-47ea-bbe5-e614723f16dd._msdcs.w2k3.vmnet1.vm.base'
 655  *           dest_dsa_guid            : 4a0df188-a0b8-47ea-bbe5-e614723f16dd
 656  *           options                  : 0x0000001c (28)
 657  *                 0: DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION
 658  *                 0: DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE
 659  *                 1: DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE
 660  *                 1: DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE
 661  *                 1: DRSUAPI_DS_REPLICA_UPDATE_0x00000010
 662  *
 663  * 4a0df188-a0b8-47ea-bbe5-e614723f16dd is the objectGUID the DsAddEntry() returned for the
 664  * CN=NTDS Settings,CN=<machine_name>,CN=Servers,CN=Default-First-Site-Name, ...
 665  * on the 2nd!!! DRSUAPI connection
 666  *
 667  * see: becomeDC_drsuapi_update_refs_send(), becomeDC_drsuapi2_update_refs_schema_recv(),
 668  *      becomeDC_drsuapi2_update_refs_config_recv() and becomeDC_drsuapi2_update_refs_domain_recv()
 669  */
 670
 671 /*
 672  * Windows does opens the 4th and 5th DRSUAPI connection...
 673  * and does a DsBind() with the objectGUID from DsAddEntry() as bind_guid
 674  * on the 4th connection
 675  *
 676  * and then 2 full replications of the domain partition on the 5th connection
 677  * with the bind_handle from the 4th connection
 678  *
 679  * not implemented because it gives no new information
 680  */
 681
 682 struct libnet_BecomeDC_state {
 683         struct composite_context *creq;
 684
 685         struct libnet_context *libnet;
 686
 687         struct dom_sid zero_sid;
 688
 689         struct {
 690                 struct cldap_socket *sock;
 691                 struct cldap_netlogon io;
 692                 struct NETLOGON_SAM_LOGON_RESPONSE_EX netlogon;
 693         } cldap;
 694
 695         struct becomeDC_ldap {
 696                 struct ldb_context *ldb;
 697                 const struct ldb_message *rootdse;
 698         } ldap1, ldap2;
 699
 700         struct becomeDC_drsuapi {
 701                 struct libnet_BecomeDC_state *s;
 702                 struct dcerpc_binding *binding;
 703                 struct dcerpc_pipe *pipe;
 704                 struct dcerpc_binding_handle *drsuapi_handle;
 705                 DATA_BLOB gensec_skey;
 706                 struct drsuapi_DsBind bind_r;
 707                 struct GUID bind_guid;
 708                 struct drsuapi_DsBindInfoCtr bind_info_ctr;
 709                 struct drsuapi_DsBindInfo28 local_info28;
 710                 struct drsuapi_DsBindInfo28 remote_info28;
 711                 struct policy_handle bind_handle;
 712         } drsuapi1, drsuapi2, drsuapi3;
 713
 714         void *ndr_struct_ptr;
 715
 716         struct libnet_BecomeDC_Domain domain;
 717         struct libnet_BecomeDC_Forest forest;
 718         struct libnet_BecomeDC_SourceDSA source_dsa;
 719         struct libnet_BecomeDC_DestDSA dest_dsa;
 720
 721         struct libnet_BecomeDC_Partition schema_part, config_part, domain_part;
 722
 723         struct becomeDC_fsmo {
 724                 const char *dns_name;
 725                 const char *server_dn_str;
 726                 const char *ntds_dn_str;
 727                 struct GUID ntds_guid;
 728         } infrastructure_fsmo;
 729
 730         struct becomeDC_fsmo rid_manager_fsmo;
 731
 732         struct libnet_BecomeDC_CheckOptions _co;
 733         struct libnet_BecomeDC_PrepareDB _pp;
 734         struct libnet_BecomeDC_StoreChunk _sc;
 735         struct libnet_BecomeDC_Callbacks callbacks;
 736
 737         bool rodc_join;
 738 };
 739
 740 static int32_t get_dc_function_level(struct loadparm_context *lp_ctx)
 741 {
 742         /* per default we are (Windows) 2008 R2 compatible */
 743         return lpcfg_parm_int(lp_ctx, NULL, "ads", "dc function level",
 744                            DS_DOMAIN_FUNCTION_2008_R2);
 745 }
 746
 747 static void becomeDC_recv_cldap(struct tevent_req *req);
 748
 749 static void becomeDC_send_cldap(struct libnet_BecomeDC_state *s)
 750 {
 751         struct composite_context *c = s->creq;
 752         struct tevent_req *req;
 753         struct tsocket_address *dest_address;
 754         int ret;
 755
 756         s->cldap.io.in.dest_address     = NULL;
 757         s->cldap.io.in.dest_port        = 0;
 758         s->cldap.io.in.realm            = s->domain.dns_name;
 759         s->cldap.io.in.host             = s->dest_dsa.netbios_name;
 760         s->cldap.io.in.user             = NULL;
 761         s->cldap.io.in.domain_guid      = NULL;
 762         s->cldap.io.in.domain_sid       = NULL;
 763         s->cldap.io.in.acct_control     = -1;
 764         s->cldap.io.in.version          = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
 765         s->cldap.io.in.map_response     = true;
 766
 767         ret = tsocket_address_inet_from_strings(s, "ip",
 768                                                 s->source_dsa.address,
 769                                                 lpcfg_cldap_port(s->libnet->lp_ctx),
 770                                                 &dest_address);
 771         if (ret != 0) {
 772                 c->status = map_nt_error_from_unix_common(errno);
 773                 if (!composite_is_ok(c)) return;
 774         }
 775
 776         c->status = cldap_socket_init(s, NULL, dest_address, &s->cldap.sock);
 777         if (!composite_is_ok(c)) return;
 778
 779         req = cldap_netlogon_send(s, s->libnet->event_ctx,
 780                                   s->cldap.sock, &s->cldap.io);
 781         if (composite_nomem(req, c)) return;
 782         tevent_req_set_callback(req, becomeDC_recv_cldap, s);
 783 }
 784
 785 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s);
 786
 787 static void becomeDC_recv_cldap(struct tevent_req *req)
 788 {
 789         struct libnet_BecomeDC_state *s = tevent_req_callback_data(req,
 790                                           struct libnet_BecomeDC_state);
 791         struct composite_context *c = s->creq;
 792
 793         c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
 794         talloc_free(req);
 795         if (!composite_is_ok(c)) {
 796                 DEBUG(0,("Failed to send, receive or parse CLDAP reply from server %s for our host %s: %s\n",
 797                          s->cldap.io.in.dest_address,
 798                          s->cldap.io.in.host,
 799                          nt_errstr(c->status)));
 800                 return;
 801         }
 802         s->cldap.netlogon = s->cldap.io.out.netlogon.data.nt5_ex;
 803
 804         s->domain.dns_name              = s->cldap.netlogon.dns_domain;
 805         s->domain.netbios_name          = s->cldap.netlogon.domain_name;
 806         s->domain.guid                  = s->cldap.netlogon.domain_uuid;
 807
 808         s->forest.dns_name              = s->cldap.netlogon.forest;
 809
 810         s->source_dsa.dns_name          = s->cldap.netlogon.pdc_dns_name;
 811         s->source_dsa.netbios_name      = s->cldap.netlogon.pdc_name;
 812         s->source_dsa.site_name         = s->cldap.netlogon.server_site;
 813
 814         s->dest_dsa.site_name           = s->cldap.netlogon.client_site;
 815
 816         DEBUG(0,("CLDAP response: forest=%s dns=%s netbios=%s server_site=%s  client_site=%s\n",
 817                  s->forest.dns_name, s->domain.dns_name, s->domain.netbios_name,
 818                  s->source_dsa.site_name, s->dest_dsa.site_name));
 819         if (!s->dest_dsa.site_name || strcmp(s->dest_dsa.site_name, "") == 0) {
 820                 DEBUG(0,("Got empty client site - using server site name %s\n",
 821                          s->source_dsa.site_name));
 822                 s->dest_dsa.site_name = s->source_dsa.site_name;
 823         }
 824
 825         becomeDC_connect_ldap1(s);
 826 }
 827
 828 static NTSTATUS becomeDC_ldap_connect(struct libnet_BecomeDC_state *s,
 829                                       struct becomeDC_ldap *ldap)
 830 {
 831         char *url;
 832
 833         url = talloc_asprintf(s, "ldap://%s/", s->source_dsa.dns_name);
 834         NT_STATUS_HAVE_NO_MEMORY(url);
 835
 836         ldap->ldb = ldb_wrap_connect(s, s->libnet->event_ctx, s->libnet->lp_ctx, url,
 837                                      NULL,
 838                                      s->libnet->cred,
 839                                      0);
 840         talloc_free(url);
 841         if (ldap->ldb == NULL) {
 842                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
 843         }
 844
 845         return NT_STATUS_OK;
 846 }
 847
 848 static NTSTATUS becomeDC_ldap1_rootdse(struct libnet_BecomeDC_state *s)
 849 {
 850         int ret;
 851         struct ldb_result *r;
 852         struct ldb_dn *basedn;
 853         static const char *attrs[] = {
 854                 "*",
 855                 NULL
 856         };
 857
 858         basedn = ldb_dn_new(s, s->ldap1.ldb, NULL);
 859         NT_STATUS_HAVE_NO_MEMORY(basedn);
 860
 861         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
 862                          "(objectClass=*)");
 863         talloc_free(basedn);
 864         if (ret != LDB_SUCCESS) {
 865                 return NT_STATUS_LDAP(ret);
 866         } else if (r->count != 1) {
 867                 talloc_free(r);
 868                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 869         }
 870
 871         s->ldap1.rootdse = r->msgs[0];
 872
 873         s->domain.dn_str        = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "defaultNamingContext", NULL);
 874         if (!s->domain.dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 875
 876         s->forest.root_dn_str   = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "rootDomainNamingContext", NULL);
 877         if (!s->forest.root_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 878         s->forest.config_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "configurationNamingContext", NULL);
 879         if (!s->forest.config_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 880         s->forest.schema_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "schemaNamingContext", NULL);
 881         if (!s->forest.schema_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 882
 883         s->source_dsa.server_dn_str     = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "serverName", NULL);
 884         if (!s->source_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 885         s->source_dsa.ntds_dn_str       = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "dsServiceName", NULL);
 886         if (!s->source_dsa.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 887
 888         return NT_STATUS_OK;
 889 }
 890
 891 static NTSTATUS becomeDC_ldap1_crossref_behavior_version(struct libnet_BecomeDC_state *s)
 892 {
 893         int ret;
 894         struct ldb_result *r;
 895         struct ldb_dn *basedn;
 896         static const char *attrs[] = {
 897                 "msDs-Behavior-Version",
 898                 NULL
 899         };
 900
 901         basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.config_dn_str);
 902         NT_STATUS_HAVE_NO_MEMORY(basedn);
 903
 904         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_ONELEVEL, attrs,
 905                          "(cn=Partitions)");
 906         talloc_free(basedn);
 907         if (ret != LDB_SUCCESS) {
 908                 return NT_STATUS_LDAP(ret);
 909         } else if (r->count != 1) {
 910                 talloc_free(r);
 911                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 912         }
 913
 914         s->forest.crossref_behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
 915         if (s->forest.crossref_behavior_version >
 916                         get_dc_function_level(s->libnet->lp_ctx)) {
 917                 talloc_free(r);
 918                 DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n",
 919                          s->forest.crossref_behavior_version,
 920                          get_dc_function_level(s->libnet->lp_ctx)));
 921                 return NT_STATUS_NOT_SUPPORTED;
 922         }
 923
 924         talloc_free(r);
 925         return NT_STATUS_OK;
 926 }
 927
 928 static NTSTATUS becomeDC_ldap1_domain_behavior_version(struct libnet_BecomeDC_state *s)
 929 {
 930         int ret;
 931         struct ldb_result *r;
 932         struct ldb_dn *basedn;
 933         static const char *attrs[] = {
 934                 "msDs-Behavior-Version",
 935                 NULL
 936         };
 937
 938         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
 939         NT_STATUS_HAVE_NO_MEMORY(basedn);
 940
 941         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
 942                          "(objectClass=*)");
 943         talloc_free(basedn);
 944         if (ret != LDB_SUCCESS) {
 945                 return NT_STATUS_LDAP(ret);
 946         } else if (r->count != 1) {
 947                 talloc_free(r);
 948                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 949         }
 950
 951         s->domain.behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
 952         if (s->domain.behavior_version >
 953                         get_dc_function_level(s->libnet->lp_ctx)) {
 954                 talloc_free(r);
 955                 DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n",
 956                          s->forest.crossref_behavior_version,
 957                          get_dc_function_level(s->libnet->lp_ctx)));
 958                 return NT_STATUS_NOT_SUPPORTED;
 959         }
 960
 961         talloc_free(r);
 962         return NT_STATUS_OK;
 963 }
 964
 965 static NTSTATUS becomeDC_ldap1_schema_object_version(struct libnet_BecomeDC_state *s)
 966 {
 967         int ret;
 968         struct ldb_result *r;
 969         struct ldb_dn *basedn;
 970         static const char *attrs[] = {
 971                 "objectVersion",
 972                 NULL
 973         };
 974
 975         basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.schema_dn_str);
 976         NT_STATUS_HAVE_NO_MEMORY(basedn);
 977
 978         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
 979                          "(objectClass=*)");
 980         talloc_free(basedn);
 981         if (ret != LDB_SUCCESS) {
 982                 return NT_STATUS_LDAP(ret);
 983         } else if (r->count != 1) {
 984                 talloc_free(r);
 985                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 986         }
 987
 988         s->forest.schema_object_version = ldb_msg_find_attr_as_uint(r->msgs[0], "objectVersion", 0);
 989
 990         talloc_free(r);
 991         return NT_STATUS_OK;
 992 }
 993
 994 static NTSTATUS becomeDC_ldap1_w2k3_update_revision(struct libnet_BecomeDC_state *s)
 995 {
 996         int ret;
 997         struct ldb_result *r;
 998         struct ldb_dn *basedn;
 999         static const char *attrs[] = {
1000                 "revision",
1001                 NULL
1002         };
1003
1004         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=Windows2003Update,CN=DomainUpdates,CN=System,%s",
1005                                 s->domain.dn_str);
1006         NT_STATUS_HAVE_NO_MEMORY(basedn);
1007
1008         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
1009                          "(objectClass=*)");
1010         talloc_free(basedn);
1011         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1012                 /* w2k doesn't have this object */
1013                 s->domain.w2k3_update_revision = 0;
1014                 return NT_STATUS_OK;
1015         } else if (ret != LDB_SUCCESS) {
1016                 return NT_STATUS_LDAP(ret);
1017         } else if (r->count != 1) {
1018                 talloc_free(r);
1019                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1020         }
1021
1022         s->domain.w2k3_update_revision = ldb_msg_find_attr_as_uint(r->msgs[0], "revision", 0);
1023
1024         talloc_free(r);
1025         return NT_STATUS_OK;
1026 }
1027
1028 static NTSTATUS becomeDC_ldap1_infrastructure_fsmo(struct libnet_BecomeDC_state *s)
1029 {
1030         int ret;
1031         struct ldb_result *r;
1032         struct ldb_dn *basedn;
1033         struct ldb_dn *ntds_dn;
1034         struct ldb_dn *server_dn;
1035         static const char *dns_attrs[] = {
1036                 "dnsHostName",
1037                 NULL
1038         };
1039         static const char *guid_attrs[] = {
1040                 "objectGUID",
1041                 NULL
1042         };
1043
1044         ret = dsdb_wellknown_dn(s->ldap1.ldb, s,
1045                                 ldb_get_default_basedn(s->ldap1.ldb),
1046                                 DS_GUID_INFRASTRUCTURE_CONTAINER,
1047                                 &basedn);
1048         if (ret != LDB_SUCCESS) {
1049                 return NT_STATUS_LDAP(ret);
1050         }
1051
1052         ret = samdb_reference_dn(s->ldap1.ldb, s, basedn, "fSMORoleOwner", &ntds_dn);
1053         if (ret != LDB_SUCCESS) {
1054                 talloc_free(basedn);
1055                 return NT_STATUS_LDAP(ret);
1056         }
1057
1058         s->infrastructure_fsmo.ntds_dn_str = ldb_dn_get_linearized(ntds_dn);
1059         NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.ntds_dn_str);
1060
1061         server_dn = ldb_dn_get_parent(s, ntds_dn);
1062         NT_STATUS_HAVE_NO_MEMORY(server_dn);
1063
1064         s->infrastructure_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
1065         NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.server_dn_str);
1066
1067         ret = ldb_search(s->ldap1.ldb, s, &r, server_dn, LDB_SCOPE_BASE,
1068                          dns_attrs, "(objectClass=*)");
1069         if (ret != LDB_SUCCESS) {
1070                 return NT_STATUS_LDAP(ret);
1071         } else if (r->count != 1) {
1072                 talloc_free(r);
1073                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1074         }
1075
1076         s->infrastructure_fsmo.dns_name = ldb_msg_find_attr_as_string(r->msgs[0], "dnsHostName", NULL);
1077         if (!s->infrastructure_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1078         talloc_steal(s, s->infrastructure_fsmo.dns_name);
1079
1080         talloc_free(r);
1081
1082         ret = ldb_search(s->ldap1.ldb, s, &r, ntds_dn, LDB_SCOPE_BASE,
1083                          guid_attrs, "(objectClass=*)");
1084         if (ret != LDB_SUCCESS) {
1085                 return NT_STATUS_LDAP(ret);
1086         } else if (r->count != 1) {
1087                 talloc_free(r);
1088                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1089         }
1090
1091         s->infrastructure_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1092
1093         talloc_free(r);
1094
1095         return NT_STATUS_OK;
1096 }
1097
1098 static NTSTATUS becomeDC_ldap1_rid_manager_fsmo(struct libnet_BecomeDC_state *s)
1099 {
1100         int ret;
1101         struct ldb_result *r;
1102         struct ldb_dn *basedn;
1103         const char *reference_dn_str;
1104         struct ldb_dn *ntds_dn;
1105         struct ldb_dn *server_dn;
1106         static const char *rid_attrs[] = {
1107                 "rIDManagerReference",
1108                 NULL
1109         };
1110         static const char *fsmo_attrs[] = {
1111                 "fSMORoleOwner",
1112                 NULL
1113         };
1114         static const char *dns_attrs[] = {
1115                 "dnsHostName",
1116                 NULL
1117         };
1118         static const char *guid_attrs[] = {
1119                 "objectGUID",
1120                 NULL
1121         };
1122
1123         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
1124         NT_STATUS_HAVE_NO_MEMORY(basedn);
1125
1126         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1127                          rid_attrs, "(objectClass=*)");
1128         talloc_free(basedn);
1129         if (ret != LDB_SUCCESS) {
1130                 return NT_STATUS_LDAP(ret);
1131         } else if (r->count != 1) {
1132                 talloc_free(r);
1133                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1134         }
1135
1136         reference_dn_str        = ldb_msg_find_attr_as_string(r->msgs[0], "rIDManagerReference", NULL);
1137         if (!reference_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1138
1139         basedn = ldb_dn_new(s, s->ldap1.ldb, reference_dn_str);
1140         NT_STATUS_HAVE_NO_MEMORY(basedn);
1141
1142         talloc_free(r);
1143
1144         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1145                          fsmo_attrs, "(objectClass=*)");
1146         talloc_free(basedn);
1147         if (ret != LDB_SUCCESS) {
1148                 return NT_STATUS_LDAP(ret);
1149         } else if (r->count != 1) {
1150                 talloc_free(r);
1151                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1152         }
1153
1154         s->rid_manager_fsmo.ntds_dn_str = ldb_msg_find_attr_as_string(r->msgs[0], "fSMORoleOwner", NULL);
1155         if (!s->rid_manager_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1156         talloc_steal(s, s->rid_manager_fsmo.ntds_dn_str);
1157
1158         talloc_free(r);
1159
1160         ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->rid_manager_fsmo.ntds_dn_str);
1161         NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
1162
1163         server_dn = ldb_dn_get_parent(s, ntds_dn);
1164         NT_STATUS_HAVE_NO_MEMORY(server_dn);
1165
1166         s->rid_manager_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
1167         NT_STATUS_HAVE_NO_MEMORY(s->rid_manager_fsmo.server_dn_str);
1168
1169         ret = ldb_search(s->ldap1.ldb, s, &r, server_dn, LDB_SCOPE_BASE,
1170                          dns_attrs, "(objectClass=*)");
1171         if (ret != LDB_SUCCESS) {
1172                 return NT_STATUS_LDAP(ret);
1173         } else if (r->count != 1) {
1174                 talloc_free(r);
1175                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1176         }
1177
1178         s->rid_manager_fsmo.dns_name    = ldb_msg_find_attr_as_string(r->msgs[0], "dnsHostName", NULL);
1179         if (!s->rid_manager_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1180         talloc_steal(s, s->rid_manager_fsmo.dns_name);
1181
1182         talloc_free(r);
1183
1184         ret = ldb_search(s->ldap1.ldb, s, &r, ntds_dn, LDB_SCOPE_BASE,
1185                          guid_attrs, "(objectClass=*)");
1186         if (ret != LDB_SUCCESS) {
1187                 return NT_STATUS_LDAP(ret);
1188         } else if (r->count != 1) {
1189                 talloc_free(r);
1190                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1191         }
1192
1193         s->rid_manager_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1194
1195         talloc_free(r);
1196
1197         return NT_STATUS_OK;
1198 }
1199
1200 static NTSTATUS becomeDC_ldap1_site_object(struct libnet_BecomeDC_state *s)
1201 {
1202         int ret;
1203         struct ldb_result *r;
1204         struct ldb_dn *basedn;
1205
1206         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Sites,%s",
1207                                 s->dest_dsa.site_name,
1208                                 s->forest.config_dn_str);
1209         NT_STATUS_HAVE_NO_MEMORY(basedn);
1210
1211         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1212                          NULL, "(objectClass=*)");
1213         talloc_free(basedn);
1214         if (ret != LDB_SUCCESS) {
1215                 return NT_STATUS_LDAP(ret);
1216         } else if (r->count != 1) {
1217                 talloc_free(r);
1218                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1219         }
1220
1221         s->dest_dsa.site_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1222
1223         talloc_free(r);
1224         return NT_STATUS_OK;
1225 }
1226
1227 static NTSTATUS becomeDC_check_options(struct libnet_BecomeDC_state *s)
1228 {
1229         if (!s->callbacks.check_options) return NT_STATUS_OK;
1230
1231         s->_co.domain           = &s->domain;
1232         s->_co.forest           = &s->forest;
1233         s->_co.source_dsa       = &s->source_dsa;
1234
1235         return s->callbacks.check_options(s->callbacks.private_data, &s->_co);
1236 }
1237
1238 static NTSTATUS becomeDC_ldap1_computer_object(struct libnet_BecomeDC_state *s)
1239 {
1240         int ret;
1241         struct ldb_result *r;
1242         struct ldb_dn *basedn;
1243         static const char *attrs[] = {
1244                 "distinguishedName",
1245                 "userAccountControl",
1246                 NULL
1247         };
1248
1249         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
1250         NT_STATUS_HAVE_NO_MEMORY(basedn);
1251
1252         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_SUBTREE, attrs,
1253                          "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
1254                          s->dest_dsa.netbios_name);
1255         talloc_free(basedn);
1256         if (ret != LDB_SUCCESS) {
1257                 return NT_STATUS_LDAP(ret);
1258         } else if (r->count != 1) {
1259                 talloc_free(r);
1260                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1261         }
1262
1263         s->dest_dsa.computer_dn_str     = ldb_msg_find_attr_as_string(r->msgs[0], "distinguishedName", NULL);
1264         if (!s->dest_dsa.computer_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1265         talloc_steal(s, s->dest_dsa.computer_dn_str);
1266
1267         s->dest_dsa.user_account_control = ldb_msg_find_attr_as_uint(r->msgs[0], "userAccountControl", 0);
1268
1269         talloc_free(r);
1270         return NT_STATUS_OK;
1271 }
1272
1273 static NTSTATUS becomeDC_ldap1_server_object_1(struct libnet_BecomeDC_state *s)
1274 {
1275         int ret;
1276         struct ldb_result *r;
1277         struct ldb_dn *basedn;
1278         const char *server_reference_dn_str;
1279         struct ldb_dn *server_reference_dn;
1280         struct ldb_dn *computer_dn;
1281
1282         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
1283                                 s->dest_dsa.netbios_name,
1284                                 s->dest_dsa.site_name,
1285                                 s->forest.config_dn_str);
1286         NT_STATUS_HAVE_NO_MEMORY(basedn);
1287
1288         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1289                          NULL, "(objectClass=*)");
1290         talloc_free(basedn);
1291         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1292                 /* if the object doesn't exist, we'll create it later */
1293                 return NT_STATUS_OK;
1294         } else if (ret != LDB_SUCCESS) {
1295                 return NT_STATUS_LDAP(ret);
1296         } else if (r->count != 1) {
1297                 talloc_free(r);
1298                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1299         }
1300
1301         server_reference_dn_str = ldb_msg_find_attr_as_string(r->msgs[0], "serverReference", NULL);
1302         if (server_reference_dn_str) {
1303                 server_reference_dn     = ldb_dn_new(r, s->ldap1.ldb, server_reference_dn_str);
1304                 NT_STATUS_HAVE_NO_MEMORY(server_reference_dn);
1305
1306                 computer_dn             = ldb_dn_new(r, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
1307                 NT_STATUS_HAVE_NO_MEMORY(computer_dn);
1308
1309                 /*
1310                  * if the server object belongs to another DC in another domain
1311                  * in the forest, we should not touch this object!
1312                  */
1313                 if (ldb_dn_compare(computer_dn, server_reference_dn) != 0) {
1314                         talloc_free(r);
1315                         return NT_STATUS_OBJECT_NAME_COLLISION;
1316                 }
1317         }
1318
1319         /* if the server object is already for the dest_dsa, then we don't need to create it */
1320         s->dest_dsa.server_dn_str       = ldb_msg_find_attr_as_string(r->msgs[0], "distinguishedName", NULL);
1321         if (!s->dest_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1322         talloc_steal(s, s->dest_dsa.server_dn_str);
1323
1324         talloc_free(r);
1325         return NT_STATUS_OK;
1326 }
1327
1328 static NTSTATUS becomeDC_ldap1_server_object_2(struct libnet_BecomeDC_state *s)
1329 {
1330         int ret;
1331         struct ldb_result *r;
1332         struct ldb_dn *basedn;
1333         const char *server_reference_bl_dn_str;
1334         static const char *attrs[] = {
1335                 "serverReferenceBL",
1336                 NULL
1337         };
1338
1339         /* if the server_dn_str has a valid value, we skip this lookup */
1340         if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
1341
1342         basedn = ldb_dn_new(s, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
1343         NT_STATUS_HAVE_NO_MEMORY(basedn);
1344
1345         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1346                          attrs, "(objectClass=*)");
1347         talloc_free(basedn);
1348         if (ret != LDB_SUCCESS) {
1349                 return NT_STATUS_LDAP(ret);
1350         } else if (r->count != 1) {
1351                 talloc_free(r);
1352                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1353         }
1354
1355         server_reference_bl_dn_str = ldb_msg_find_attr_as_string(r->msgs[0], "serverReferenceBL", NULL);
1356         if (!server_reference_bl_dn_str) {
1357                 /* if no back link is present, we're done for this function */
1358                 talloc_free(r);
1359                 return NT_STATUS_OK;
1360         }
1361
1362         /* if the server object is already for the dest_dsa, then we don't need to create it */
1363         s->dest_dsa.server_dn_str       = ldb_msg_find_attr_as_string(r->msgs[0], "serverReferenceBL", NULL);
1364         if (s->dest_dsa.server_dn_str) {
1365                 /* if a back link is present, we know that the server object is present */
1366                 talloc_steal(s, s->dest_dsa.server_dn_str);
1367         }
1368
1369         talloc_free(r);
1370         return NT_STATUS_OK;
1371 }
1372
1373 static NTSTATUS becomeDC_ldap1_server_object_add(struct libnet_BecomeDC_state *s)
1374 {
1375         int ret;
1376         struct ldb_message *msg;
1377         char *server_dn_str;
1378
1379         /* if the server_dn_str has a valid value, we skip this lookup */
1380         if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
1381
1382         msg = ldb_msg_new(s);
1383         NT_STATUS_HAVE_NO_MEMORY(msg);
1384
1385         msg->dn = ldb_dn_new_fmt(msg, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
1386                                  s->dest_dsa.netbios_name,
1387                                  s->dest_dsa.site_name,
1388                                  s->forest.config_dn_str);
1389         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1390
1391         ret = ldb_msg_add_string(msg, "objectClass", "server");
1392         if (ret != 0) {
1393                 talloc_free(msg);
1394                 return NT_STATUS_NO_MEMORY;
1395         }
1396         ret = ldb_msg_add_string(msg, "systemFlags", "50000000");
1397         if (ret != 0) {
1398                 talloc_free(msg);
1399                 return NT_STATUS_NO_MEMORY;
1400         }
1401         ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
1402         if (ret != 0) {
1403                 talloc_free(msg);
1404                 return NT_STATUS_NO_MEMORY;
1405         }
1406
1407         server_dn_str = ldb_dn_alloc_linearized(s, msg->dn);
1408         NT_STATUS_HAVE_NO_MEMORY(server_dn_str);
1409
1410         ret = ldb_add(s->ldap1.ldb, msg);
1411         talloc_free(msg);
1412         if (ret != LDB_SUCCESS) {
1413                 talloc_free(server_dn_str);
1414                 return NT_STATUS_LDAP(ret);
1415         }
1416
1417         s->dest_dsa.server_dn_str = server_dn_str;
1418
1419         return NT_STATUS_OK;
1420 }
1421
1422 static NTSTATUS becomeDC_ldap1_server_object_modify(struct libnet_BecomeDC_state *s)
1423 {
1424         int ret;
1425         struct ldb_message *msg;
1426         unsigned int i;
1427
1428         /* make a 'modify' msg, and only for serverReference */
1429         msg = ldb_msg_new(s);
1430         NT_STATUS_HAVE_NO_MEMORY(msg);
1431         msg->dn = ldb_dn_new(msg, s->ldap1.ldb, s->dest_dsa.server_dn_str);
1432         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1433
1434         ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
1435         if (ret != 0) {
1436                 talloc_free(msg);
1437                 return NT_STATUS_NO_MEMORY;
1438         }
1439
1440         /* mark all the message elements (should be just one)
1441            as LDB_FLAG_MOD_ADD */
1442         for (i=0;i<msg->num_elements;i++) {
1443                 msg->elements[i].flags = LDB_FLAG_MOD_ADD;
1444         }
1445
1446         ret = ldb_modify(s->ldap1.ldb, msg);
1447         if (ret == LDB_SUCCESS) {
1448                 talloc_free(msg);
1449                 return NT_STATUS_OK;
1450         } else if (ret == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) {
1451                 /* retry with LDB_FLAG_MOD_REPLACE */
1452         } else {
1453                 talloc_free(msg);
1454                 return NT_STATUS_LDAP(ret);
1455         }
1456
1457         /* mark all the message elements (should be just one)
1458            as LDB_FLAG_MOD_REPLACE */
1459         for (i=0;i<msg->num_elements;i++) {
1460                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
1461         }
1462
1463         ret = ldb_modify(s->ldap1.ldb, msg);
1464         talloc_free(msg);
1465         if (ret != LDB_SUCCESS) {
1466                 return NT_STATUS_LDAP(ret);
1467         }
1468
1469         return NT_STATUS_OK;
1470 }
1471
1472 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
1473                                           struct becomeDC_drsuapi *drsuapi,
1474                                           void (*recv_fn)(struct composite_context *req));
1475 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req);
1476 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s);
1477
1478 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s)
1479 {
1480         struct composite_context *c = s->creq;
1481
1482         c->status = becomeDC_ldap_connect(s, &s->ldap1);
1483         if (!composite_is_ok(c)) return;
1484
1485         c->status = becomeDC_ldap1_rootdse(s);
1486         if (!composite_is_ok(c)) return;
1487
1488         c->status = becomeDC_ldap1_crossref_behavior_version(s);
1489         if (!composite_is_ok(c)) return;
1490
1491         c->status = becomeDC_ldap1_domain_behavior_version(s);
1492         if (!composite_is_ok(c)) return;
1493
1494         c->status = becomeDC_ldap1_schema_object_version(s);
1495         if (!composite_is_ok(c)) return;
1496
1497         c->status = becomeDC_ldap1_w2k3_update_revision(s);
1498         if (!composite_is_ok(c)) return;
1499
1500         c->status = becomeDC_ldap1_infrastructure_fsmo(s);
1501         if (!composite_is_ok(c)) return;
1502
1503         c->status = becomeDC_ldap1_rid_manager_fsmo(s);
1504         if (!composite_is_ok(c)) return;
1505
1506         c->status = becomeDC_ldap1_site_object(s);
1507         if (!composite_is_ok(c)) return;
1508
1509         c->status = becomeDC_check_options(s);
1510         if (!composite_is_ok(c)) return;
1511
1512         c->status = becomeDC_ldap1_computer_object(s);
1513         if (!composite_is_ok(c)) return;
1514
1515         c->status = becomeDC_ldap1_server_object_1(s);
1516         if (!composite_is_ok(c)) return;
1517
1518         c->status = becomeDC_ldap1_server_object_2(s);
1519         if (!composite_is_ok(c)) return;
1520
1521         c->status = becomeDC_ldap1_server_object_add(s);
1522         if (!composite_is_ok(c)) return;
1523
1524         c->status = becomeDC_ldap1_server_object_modify(s);
1525         if (!composite_is_ok(c)) return;
1526
1527         becomeDC_drsuapi_connect_send(s, &s->drsuapi1, becomeDC_drsuapi1_connect_recv);
1528 }
1529
1530 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
1531                                           struct becomeDC_drsuapi *drsuapi,
1532                                           void (*recv_fn)(struct composite_context *req))
1533 {
1534         struct composite_context *c = s->creq;
1535         struct composite_context *creq;
1536         char *binding_str;
1537
1538         drsuapi->s = s;
1539
1540         if (!drsuapi->binding) {
1541                 const char *krb5_str = "";
1542                 const char *print_str = "";
1543                 /*
1544                  * Note: Replication only works with Windows 2000 when 'krb5' is
1545                  *       passed as auth_type here. If NTLMSSP is used, Windows
1546                  *       2000 returns garbage in the DsGetNCChanges() response
1547                  *       if encrypted password attributes would be in the
1548                  *       response. That means the replication of the schema and
1549                  *       configuration partition works fine, but it fails for
1550                  *       the domain partition.
1551                  */
1552                 if (lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
1553                                  "force krb5", true))
1554                 {
1555                         krb5_str = "krb5,";
1556                 }
1557                 if (lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
1558                                  "print", false))
1559                 {
1560                         print_str = "print,";
1561                 }
1562                 binding_str = talloc_asprintf(s, "ncacn_ip_tcp:%s[%s%sseal]",
1563                                               s->source_dsa.dns_name,
1564                                               krb5_str, print_str);
1565                 if (composite_nomem(binding_str, c)) return;
1566                 c->status = dcerpc_parse_binding(s, binding_str, &drsuapi->binding);
1567                 talloc_free(binding_str);
1568                 if (!composite_is_ok(c)) return;
1569         }
1570
1571         if (DEBUGLEVEL >= 10) {
1572                 drsuapi->binding->flags |= DCERPC_DEBUG_PRINT_BOTH;
1573         }
1574
1575         creq = dcerpc_pipe_connect_b_send(s, drsuapi->binding, &ndr_table_drsuapi,
1576                                           s->libnet->cred, s->libnet->event_ctx,
1577                                           s->libnet->lp_ctx);
1578         composite_continue(c, creq, recv_fn, s);
1579 }
1580
1581 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
1582                                        struct becomeDC_drsuapi *drsuapi,
1583                                        void (*recv_fn)(struct tevent_req *subreq));
1584 static void becomeDC_drsuapi1_bind_recv(struct tevent_req *subreq);
1585
1586 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req)
1587 {
1588         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
1589                                           struct libnet_BecomeDC_state);
1590         struct composite_context *c = s->creq;
1591
1592         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi1.pipe);
1593         if (!composite_is_ok(c)) return;
1594
1595         s->drsuapi1.drsuapi_handle = s->drsuapi1.pipe->binding_handle;
1596
1597         c->status = gensec_session_key(s->drsuapi1.pipe->conn->security_state.generic_state,
1598                                        s,
1599                                        &s->drsuapi1.gensec_skey);
1600         if (!composite_is_ok(c)) return;
1601
1602         becomeDC_drsuapi_bind_send(s, &s->drsuapi1, becomeDC_drsuapi1_bind_recv);
1603 }
1604
1605 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
1606                                        struct becomeDC_drsuapi *drsuapi,
1607                                        void (*recv_fn)(struct tevent_req *subreq))
1608 {
1609         struct composite_context *c = s->creq;
1610         struct drsuapi_DsBindInfo28 *bind_info28;
1611         struct tevent_req *subreq;
1612
1613         GUID_from_string(DRSUAPI_DS_BIND_GUID_W2K3, &drsuapi->bind_guid);
1614
1615         bind_info28                             = &drsuapi->local_info28;
1616         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
1617         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION;
1618         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI;
1619         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2;
1620         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS;
1621         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1;
1622         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
1623         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
1624         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
1625         if (s->domain.behavior_version >= DS_DOMAIN_FUNCTION_2003) {
1626                 /* TODO: find out how this is really triggered! */
1627                 bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
1628         }
1629         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2;
1630         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD;
1631         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND;
1632         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO;
1633         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION;
1634         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01;
1635         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP;
1636         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
1637         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
1638         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5;
1639         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
1640         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
1641         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS;
1642         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8;
1643         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5;
1644         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6;
1645         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
1646         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
1647         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
1648 #if 0 /* we don't support XPRESS compression yet */
1649         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS;
1650 #endif
1651         bind_info28->site_guid                  = s->dest_dsa.site_guid;
1652         bind_info28->pid                        = 0;
1653         bind_info28->repl_epoch                 = 0;
1654
1655         drsuapi->bind_info_ctr.length           = 28;
1656         drsuapi->bind_info_ctr.info.info28      = *bind_info28;
1657
1658         drsuapi->bind_r.in.bind_guid = &drsuapi->bind_guid;
1659         drsuapi->bind_r.in.bind_info = &drsuapi->bind_info_ctr;
1660         drsuapi->bind_r.out.bind_handle = &drsuapi->bind_handle;
1661
1662         subreq = dcerpc_drsuapi_DsBind_r_send(s, c->event_ctx,
1663                                               drsuapi->drsuapi_handle,
1664                                               &drsuapi->bind_r);
1665         if (composite_nomem(subreq, c)) return;
1666         tevent_req_set_callback(subreq, recv_fn, s);
1667 }
1668
1669 static WERROR becomeDC_drsuapi_bind_recv(struct libnet_BecomeDC_state *s,
1670                                          struct becomeDC_drsuapi *drsuapi)
1671 {
1672         if (!W_ERROR_IS_OK(drsuapi->bind_r.out.result)) {
1673                 return drsuapi->bind_r.out.result;
1674         }
1675
1676         ZERO_STRUCT(drsuapi->remote_info28);
1677         if (drsuapi->bind_r.out.bind_info) {
1678                 switch (drsuapi->bind_r.out.bind_info->length) {
1679                 case 24: {
1680                         struct drsuapi_DsBindInfo24 *info24;
1681                         info24 = &drsuapi->bind_r.out.bind_info->info.info24;
1682                         drsuapi->remote_info28.supported_extensions     = info24->supported_extensions;
1683                         drsuapi->remote_info28.site_guid                = info24->site_guid;
1684                         drsuapi->remote_info28.pid                      = info24->pid;
1685                         drsuapi->remote_info28.repl_epoch               = 0;
1686                         break;
1687                 }
1688                 case 48: {
1689                         struct drsuapi_DsBindInfo48 *info48;
1690                         info48 = &drsuapi->bind_r.out.bind_info->info.info48;
1691                         drsuapi->remote_info28.supported_extensions     = info48->supported_extensions;
1692                         drsuapi->remote_info28.site_guid                = info48->site_guid;
1693                         drsuapi->remote_info28.pid                      = info48->pid;
1694                         drsuapi->remote_info28.repl_epoch               = info48->repl_epoch;
1695                         break;
1696                 }
1697                 case 28:
1698                         drsuapi->remote_info28 = drsuapi->bind_r.out.bind_info->info.info28;
1699                         break;
1700                 }
1701         }
1702
1703         return WERR_OK;
1704 }
1705
1706 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s);
1707
1708 static void becomeDC_drsuapi1_bind_recv(struct tevent_req *subreq)
1709 {
1710         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
1711                                           struct libnet_BecomeDC_state);
1712         struct composite_context *c = s->creq;
1713         WERROR status;
1714
1715         c->status = dcerpc_drsuapi_DsBind_r_recv(subreq, s);
1716         TALLOC_FREE(subreq);
1717         if (!composite_is_ok(c)) return;
1718
1719         status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi1);
1720         if (!W_ERROR_IS_OK(status)) {
1721                 composite_error(c, werror_to_ntstatus(status));
1722                 return;
1723         }
1724
1725         becomeDC_drsuapi1_add_entry_send(s);
1726 }
1727
1728 static void becomeDC_drsuapi1_add_entry_recv(struct tevent_req *subreq);
1729
1730 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s)
1731 {
1732         struct composite_context *c = s->creq;
1733         struct drsuapi_DsAddEntry *r;
1734         struct drsuapi_DsReplicaObjectIdentifier *identifier;
1735         uint32_t num_attrs, i = 0;
1736         struct drsuapi_DsReplicaAttribute *attrs;
1737         enum ndr_err_code ndr_err;
1738         bool w2k3;
1739         struct tevent_req *subreq;
1740
1741         /* choose a random invocationId */
1742         s->dest_dsa.invocation_id = GUID_random();
1743
1744         /*
1745          * if the schema version indicates w2k3, then also send some w2k3
1746          * specific attributes.
1747          */
1748         if (s->forest.schema_object_version >= 30) {
1749                 w2k3 = true;
1750         } else {
1751                 w2k3 = false;
1752         }
1753
1754         r = talloc_zero(s, struct drsuapi_DsAddEntry);
1755         if (composite_nomem(r, c)) return;
1756
1757         /* setup identifier */
1758         identifier              = talloc(r, struct drsuapi_DsReplicaObjectIdentifier);
1759         if (composite_nomem(identifier, c)) return;
1760         identifier->guid        = GUID_zero();
1761         identifier->sid         = s->zero_sid;
1762         identifier->dn          = talloc_asprintf(identifier, "CN=NTDS Settings,%s",
1763                                                   s->dest_dsa.server_dn_str);
1764         if (composite_nomem(identifier->dn, c)) return;
1765
1766         /* allocate attribute array */
1767         num_attrs       = 12;
1768         attrs           = talloc_array(r, struct drsuapi_DsReplicaAttribute, num_attrs);
1769         if (composite_nomem(attrs, c)) return;
1770
1771         /* ntSecurityDescriptor */
1772         {
1773                 struct drsuapi_DsAttributeValue *vs;
1774                 DATA_BLOB *vd;
1775                 struct security_descriptor *v;
1776                 struct dom_sid *domain_admins_sid;
1777                 const char *domain_admins_sid_str;
1778
1779                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1780                 if (composite_nomem(vs, c)) return;
1781
1782                 vd = talloc_array(vs, DATA_BLOB, 1);
1783                 if (composite_nomem(vd, c)) return;
1784
1785                 domain_admins_sid = dom_sid_add_rid(vs, s->domain.sid, DOMAIN_RID_ADMINS);
1786                 if (composite_nomem(domain_admins_sid, c)) return;
1787
1788                 domain_admins_sid_str = dom_sid_string(domain_admins_sid, domain_admins_sid);
1789                 if (composite_nomem(domain_admins_sid_str, c)) return;
1790
1791                 v = security_descriptor_dacl_create(vd,
1792                                                0,
1793                                                /* owner: domain admins */
1794                                                domain_admins_sid_str,
1795                                                /* owner group: domain admins */
1796                                                domain_admins_sid_str,
1797                                                /* authenticated users */
1798                                                SID_NT_AUTHENTICATED_USERS,
1799                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1800                                                SEC_STD_READ_CONTROL |
1801                                                SEC_ADS_LIST |
1802                                                SEC_ADS_READ_PROP |
1803                                                SEC_ADS_LIST_OBJECT,
1804                                                0,
1805                                                /* domain admins */
1806                                                domain_admins_sid_str,
1807                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1808                                                SEC_STD_REQUIRED |
1809                                                SEC_ADS_CREATE_CHILD |
1810                                                SEC_ADS_LIST |
1811                                                SEC_ADS_SELF_WRITE |
1812                                                SEC_ADS_READ_PROP |
1813                                                SEC_ADS_WRITE_PROP |
1814                                                SEC_ADS_DELETE_TREE |
1815                                                SEC_ADS_LIST_OBJECT |
1816                                                SEC_ADS_CONTROL_ACCESS,
1817                                                0,
1818                                                /* system */
1819                                                SID_NT_SYSTEM,
1820                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1821                                                SEC_STD_REQUIRED |
1822                                                SEC_ADS_CREATE_CHILD |
1823                                                SEC_ADS_DELETE_CHILD |
1824                                                SEC_ADS_LIST |
1825                                                SEC_ADS_SELF_WRITE |
1826                                                SEC_ADS_READ_PROP |
1827                                                SEC_ADS_WRITE_PROP |
1828                                                SEC_ADS_DELETE_TREE |
1829                                                SEC_ADS_LIST_OBJECT |
1830                                                SEC_ADS_CONTROL_ACCESS,
1831                                                0,
1832                                                /* end */
1833                                                NULL);
1834                 if (composite_nomem(v, c)) return;
1835
1836                 ndr_err = ndr_push_struct_blob(&vd[0], vd, v,
1837                 (ndr_push_flags_fn_t)ndr_push_security_descriptor);
1838                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1839                         c->status = ndr_map_error2ntstatus(ndr_err);
1840                         if (!composite_is_ok(c)) return;
1841                 }
1842
1843                 vs[0].blob              = &vd[0];
1844
1845                 attrs[i].attid                  = DRSUAPI_ATTID_ntSecurityDescriptor;
1846                 attrs[i].value_ctr.num_values   = 1;
1847                 attrs[i].value_ctr.values       = vs;
1848
1849                 i++;
1850         }
1851
1852         /* objectClass: nTDSDSA */
1853         {
1854                 struct drsuapi_DsAttributeValue *vs;
1855                 DATA_BLOB *vd;
1856
1857                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1858                 if (composite_nomem(vs, c)) return;
1859
1860                 vd = talloc_array(vs, DATA_BLOB, 1);
1861                 if (composite_nomem(vd, c)) return;
1862
1863                 vd[0] = data_blob_talloc(vd, NULL, 4);
1864                 if (composite_nomem(vd[0].data, c)) return;
1865
1866                 /* value for nTDSDSA */
1867                 SIVAL(vd[0].data, 0, 0x0017002F);
1868
1869                 vs[0].blob              = &vd[0];
1870
1871                 attrs[i].attid                  = DRSUAPI_ATTID_objectClass;
1872                 attrs[i].value_ctr.num_values   = 1;
1873                 attrs[i].value_ctr.values       = vs;
1874
1875                 i++;
1876         }
1877
1878         /* objectCategory: CN=NTDS-DSA,CN=Schema,... or CN=NTDS-DSA-RO,CN=Schema,... */
1879         {
1880                 struct drsuapi_DsAttributeValue *vs;
1881                 DATA_BLOB *vd;
1882                 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
1883
1884                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1885                 if (composite_nomem(vs, c)) return;
1886
1887                 vd = talloc_array(vs, DATA_BLOB, 1);
1888                 if (composite_nomem(vd, c)) return;
1889
1890                 v[0].guid               = GUID_zero();
1891                 v[0].sid                = s->zero_sid;
1892
1893                 if (s->rodc_join) {
1894                     v[0].dn             = talloc_asprintf(vd, "CN=NTDS-DSA-RO,%s",
1895                                                           s->forest.schema_dn_str);
1896                 } else {
1897                     v[0].dn             = talloc_asprintf(vd, "CN=NTDS-DSA,%s",
1898                                                           s->forest.schema_dn_str);
1899                 }
1900                 if (composite_nomem(v[0].dn, c)) return;
1901
1902                 ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
1903                         (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1904                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1905                         c->status = ndr_map_error2ntstatus(ndr_err);
1906                         if (!composite_is_ok(c)) return;
1907                 }
1908
1909                 vs[0].blob              = &vd[0];
1910
1911                 attrs[i].attid                  = DRSUAPI_ATTID_objectCategory;
1912                 attrs[i].value_ctr.num_values   = 1;
1913                 attrs[i].value_ctr.values       = vs;
1914
1915                 i++;
1916         }
1917
1918         /* invocationId: random guid */
1919         {
1920                 struct drsuapi_DsAttributeValue *vs;
1921                 DATA_BLOB *vd;
1922                 const struct GUID *v;
1923
1924                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1925                 if (composite_nomem(vs, c)) return;
1926
1927                 vd = talloc_array(vs, DATA_BLOB, 1);
1928                 if (composite_nomem(vd, c)) return;
1929
1930                 v = &s->dest_dsa.invocation_id;
1931
1932                 c->status = GUID_to_ndr_blob(v, vd, &vd[0]);
1933                 if (!composite_is_ok(c)) return;
1934
1935                 vs[0].blob              = &vd[0];
1936
1937                 attrs[i].attid                  = DRSUAPI_ATTID_invocationId;
1938                 attrs[i].value_ctr.num_values   = 1;
1939                 attrs[i].value_ctr.values       = vs;
1940
1941                 i++;
1942         }
1943
1944         /* hasMasterNCs: ... */
1945         {
1946                 struct drsuapi_DsAttributeValue *vs;
1947                 DATA_BLOB *vd;
1948                 struct drsuapi_DsReplicaObjectIdentifier3 v[3];
1949
1950                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 3);
1951                 if (composite_nomem(vs, c)) return;
1952
1953                 vd = talloc_array(vs, DATA_BLOB, 3);
1954                 if (composite_nomem(vd, c)) return;
1955
1956                 v[0].guid               = GUID_zero();
1957                 v[0].sid                = s->zero_sid;
1958                 v[0].dn                 = s->forest.config_dn_str;
1959
1960                 v[1].guid               = GUID_zero();
1961                 v[1].sid                = s->zero_sid;
1962                 v[1].dn                 = s->domain.dn_str;
1963
1964                 v[2].guid               = GUID_zero();
1965                 v[2].sid                = s->zero_sid;
1966                 v[2].dn                 = s->forest.schema_dn_str;
1967
1968                 ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
1969                         (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1970                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1971                         c->status = ndr_map_error2ntstatus(ndr_err);
1972                         if (!composite_is_ok(c)) return;
1973                 }
1974
1975                 ndr_err = ndr_push_struct_blob(&vd[1], vd, &v[1],
1976                 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1977                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1978                         c->status = ndr_map_error2ntstatus(ndr_err);
1979                         if (!composite_is_ok(c)) return;
1980                 }
1981
1982                 ndr_err = ndr_push_struct_blob(&vd[2], vd, &v[2],
1983                    (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1984                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1985                         c->status = ndr_map_error2ntstatus(ndr_err);
1986                         if (!composite_is_ok(c)) return;
1987                 }
1988
1989                 vs[0].blob              = &vd[0];
1990                 vs[1].blob              = &vd[1];
1991                 vs[2].blob              = &vd[2];
1992
1993                 attrs[i].attid                  = DRSUAPI_ATTID_hasMasterNCs;
1994                 attrs[i].value_ctr.num_values   = 3;
1995                 attrs[i].value_ctr.values       = vs;
1996
1997                 i++;
1998         }
1999
2000         /* msDS-hasMasterNCs: ... */
2001         if (w2k3) {
2002                 struct drsuapi_DsAttributeValue *vs;
2003                 DATA_BLOB *vd;
2004                 struct drsuapi_DsReplicaObjectIdentifier3 v[3];
2005
2006                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 3);
2007                 if (composite_nomem(vs, c)) return;
2008
2009                 vd = talloc_array(vs, DATA_BLOB, 3);
2010                 if (composite_nomem(vd, c)) return;
2011
2012                 v[0].guid               = GUID_zero();
2013                 v[0].sid                = s->zero_sid;
2014                 v[0].dn                 = s->forest.config_dn_str;
2015
2016                 v[1].guid               = GUID_zero();
2017                 v[1].sid                = s->zero_sid;
2018                 v[1].dn                 = s->domain.dn_str;
2019
2020                 v[2].guid               = GUID_zero();
2021                 v[2].sid                = s->zero_sid;
2022                 v[2].dn                 = s->forest.schema_dn_str;
2023
2024                 ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
2025                         (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2026                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2027                         c->status = ndr_map_error2ntstatus(ndr_err);
2028                         if (!composite_is_ok(c)) return;
2029                 }
2030
2031                 ndr_err = ndr_push_struct_blob(&vd[1], vd, &v[1],
2032                         (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2033                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2034                         c->status = ndr_map_error2ntstatus(ndr_err);
2035                         if (!composite_is_ok(c)) return;
2036                 }
2037
2038                 ndr_err = ndr_push_struct_blob(&vd[2], vd, &v[2],
2039                         (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2040                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2041                         c->status = ndr_map_error2ntstatus(ndr_err);
2042                         if (!composite_is_ok(c)) return;
2043                 }
2044
2045                 vs[0].blob              = &vd[0];
2046                 vs[1].blob              = &vd[1];
2047                 vs[2].blob              = &vd[2];
2048
2049                 attrs[i].attid                  = DRSUAPI_ATTID_msDS_hasMasterNCs;
2050                 attrs[i].value_ctr.num_values   = 3;
2051                 attrs[i].value_ctr.values       = vs;
2052
2053                 i++;
2054         }
2055
2056         /* dMDLocation: CN=Schema,... */
2057         {
2058                 struct drsuapi_DsAttributeValue *vs;
2059                 DATA_BLOB *vd;
2060                 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2061
2062                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2063                 if (composite_nomem(vs, c)) return;
2064
2065                 vd = talloc_array(vs, DATA_BLOB, 1);
2066                 if (composite_nomem(vd, c)) return;
2067
2068                 v[0].guid               = GUID_zero();
2069                 v[0].sid                = s->zero_sid;
2070                 v[0].dn                 = s->forest.schema_dn_str;
2071
2072                 ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
2073                         (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2074                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2075                         c->status = ndr_map_error2ntstatus(ndr_err);
2076                         if (!composite_is_ok(c)) return;
2077                 }
2078
2079                 vs[0].blob              = &vd[0];
2080
2081                 attrs[i].attid                  = DRSUAPI_ATTID_dMDLocation;
2082                 attrs[i].value_ctr.num_values   = 1;
2083                 attrs[i].value_ctr.values       = vs;
2084
2085                 i++;
2086         }
2087
2088         /* msDS-HasDomainNCs: <domain_partition> */
2089         if (w2k3) {
2090                 struct drsuapi_DsAttributeValue *vs;
2091                 DATA_BLOB *vd;
2092                 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2093
2094                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2095                 if (composite_nomem(vs, c)) return;
2096
2097                 vd = talloc_array(vs, DATA_BLOB, 1);
2098                 if (composite_nomem(vd, c)) return;
2099
2100                 v[0].guid               = GUID_zero();
2101                 v[0].sid                = s->zero_sid;
2102                 v[0].dn                 = s->domain.dn_str;
2103
2104                 ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
2105                         (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2106                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2107                         c->status = ndr_map_error2ntstatus(ndr_err);
2108                         if (!composite_is_ok(c)) return;
2109                 }
2110
2111                 vs[0].blob              = &vd[0];
2112
2113                 attrs[i].attid                  = DRSUAPI_ATTID_msDS_HasDomainNCs;
2114                 attrs[i].value_ctr.num_values   = 1;
2115                 attrs[i].value_ctr.values       = vs;
2116
2117                 i++;
2118         }
2119
2120         /* msDS-Behavior-Version */
2121         if (w2k3) {
2122                 struct drsuapi_DsAttributeValue *vs;
2123                 DATA_BLOB *vd;
2124
2125                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2126                 if (composite_nomem(vs, c)) return;
2127
2128                 vd = talloc_array(vs, DATA_BLOB, 1);
2129                 if (composite_nomem(vd, c)) return;
2130
2131                 vd[0] = data_blob_talloc(vd, NULL, 4);
2132                 if (composite_nomem(vd[0].data, c)) return;
2133
2134                 SIVAL(vd[0].data, 0, get_dc_function_level(s->libnet->lp_ctx));
2135
2136                 vs[0].blob              = &vd[0];
2137
2138                 attrs[i].attid                  = DRSUAPI_ATTID_msDS_Behavior_Version;
2139                 attrs[i].value_ctr.num_values   = 1;
2140                 attrs[i].value_ctr.values       = vs;
2141
2142                 i++;
2143         }
2144
2145         /* systemFlags */
2146         {
2147                 struct drsuapi_DsAttributeValue *vs;
2148                 DATA_BLOB *vd;
2149
2150                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2151                 if (composite_nomem(vs, c)) return;
2152
2153                 vd = talloc_array(vs, DATA_BLOB, 1);
2154                 if (composite_nomem(vd, c)) return;
2155
2156                 vd[0] = data_blob_talloc(vd, NULL, 4);
2157                 if (composite_nomem(vd[0].data, c)) return;
2158
2159                 if (s->rodc_join) {
2160                     SIVAL(vd[0].data, 0, SYSTEM_FLAG_CONFIG_ALLOW_RENAME);
2161                 } else {
2162                     SIVAL(vd[0].data, 0, SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
2163                 }
2164
2165                 vs[0].blob              = &vd[0];
2166
2167                 attrs[i].attid                  = DRSUAPI_ATTID_systemFlags;
2168                 attrs[i].value_ctr.num_values   = 1;
2169                 attrs[i].value_ctr.values       = vs;
2170
2171                 i++;
2172         }
2173
2174         /* serverReference: ... */
2175         {
2176                 struct drsuapi_DsAttributeValue *vs;
2177                 DATA_BLOB *vd;
2178                 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2179
2180                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2181                 if (composite_nomem(vs, c)) return;
2182
2183                 vd = talloc_array(vs, DATA_BLOB, 1);
2184                 if (composite_nomem(vd, c)) return;
2185
2186                 v[0].guid               = GUID_zero();
2187                 v[0].sid                = s->zero_sid;
2188                 v[0].dn                 = s->dest_dsa.computer_dn_str;
2189
2190                 ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
2191                         (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2192                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2193                         c->status = ndr_map_error2ntstatus(ndr_err);
2194                         if (!composite_is_ok(c)) return;
2195                 }
2196
2197                 vs[0].blob              = &vd[0];
2198
2199                 attrs[i].attid                  = DRSUAPI_ATTID_serverReference;
2200                 attrs[i].value_ctr.num_values   = 1;
2201                 attrs[i].value_ctr.values       = vs;
2202
2203                 i++;
2204         }
2205
2206         /* options:... */
2207         if (s->rodc_join) {
2208                 struct drsuapi_DsAttributeValue *vs;
2209                 DATA_BLOB *vd;
2210
2211                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2212                 if (composite_nomem(vs, c)) return;
2213
2214                 vd = talloc_array(vs, DATA_BLOB, 1);
2215                 if (composite_nomem(vd, c)) return;
2216
2217                 vd[0] = data_blob_talloc(vd, NULL, 4);
2218                 if (composite_nomem(vd[0].data, c)) return;
2219
2220                 SIVAL(vd[0].data, 0, DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL);
2221
2222                 vs[0].blob              = &vd[0];
2223
2224                 attrs[i].attid                  = DRSUAPI_ATTID_options;
2225                 attrs[i].value_ctr.num_values   = 1;
2226                 attrs[i].value_ctr.values       = vs;
2227
2228                 i++;
2229         }
2230
2231         /* truncate the attribute list to the attribute count we have filled in */
2232         num_attrs = i;
2233
2234         /* setup request structure */
2235         r->in.bind_handle                                               = &s->drsuapi1.bind_handle;
2236         r->in.level                                                     = 2;
2237         r->in.req                                                       = talloc(s, union drsuapi_DsAddEntryRequest);
2238         r->in.req->req2.first_object.next_object                        = NULL;
2239         r->in.req->req2.first_object.object.identifier                  = identifier;
2240         r->in.req->req2.first_object.object.flags                       = 0x00000000;
2241         r->in.req->req2.first_object.object.attribute_ctr.num_attributes= num_attrs;
2242         r->in.req->req2.first_object.object.attribute_ctr.attributes    = attrs;
2243
2244         r->out.level_out        = talloc(s, uint32_t);
2245         r->out.ctr              = talloc(s, union drsuapi_DsAddEntryCtr);
2246
2247         s->ndr_struct_ptr = r;
2248         subreq = dcerpc_drsuapi_DsAddEntry_r_send(s, c->event_ctx,
2249                                                   s->drsuapi1.drsuapi_handle, r);
2250         if (composite_nomem(subreq, c)) return;
2251         tevent_req_set_callback(subreq, becomeDC_drsuapi1_add_entry_recv, s);
2252 }
2253
2254 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req);
2255 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s);
2256
2257 static void becomeDC_drsuapi1_add_entry_recv(struct tevent_req *subreq)
2258 {
2259         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2260                                           struct libnet_BecomeDC_state);
2261         struct composite_context *c = s->creq;
2262         struct drsuapi_DsAddEntry *r = talloc_get_type_abort(s->ndr_struct_ptr,
2263                                        struct drsuapi_DsAddEntry);
2264         char *binding_str;
2265
2266         s->ndr_struct_ptr = NULL;
2267
2268         c->status = dcerpc_drsuapi_DsAddEntry_r_recv(subreq, r);
2269         TALLOC_FREE(subreq);
2270         if (!composite_is_ok(c)) return;
2271
2272         if (!W_ERROR_IS_OK(r->out.result)) {
2273                 composite_error(c, werror_to_ntstatus(r->out.result));
2274                 return;
2275         }
2276
2277         if (*r->out.level_out == 3) {
2278                 WERROR status;
2279                 union drsuapi_DsAddEntry_ErrData *err_data = r->out.ctr->ctr3.err_data;
2280
2281                 /* check for errors */
2282                 status = err_data ? err_data->v1.status : WERR_OK;
2283                 if (!W_ERROR_IS_OK(status)) {
2284                         struct drsuapi_DsAddEntryErrorInfo_Attr_V1 *attr_err;
2285                         struct drsuapi_DsAddEntry_AttrErrListItem_V1 *attr_err_li;
2286                         struct drsuapi_DsAddEntryErrorInfo_Name_V1 *name_err;
2287                         struct drsuapi_DsAddEntryErrorInfo_Referr_V1 *ref_err;
2288                         struct drsuapi_DsAddEntry_RefErrListItem_V1 *ref_li;
2289
2290                         if (r->out.ctr->ctr3.err_ver != 1) {
2291                                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2292                                 return;
2293                         }
2294
2295                         DEBUG(0,("DsAddEntry (R3) of '%s' failed: "
2296                                  "Errors: dir_err = %d, status = %s;\n",
2297                                  r->in.req->req3.first_object.object.identifier->dn,
2298                                  err_data->v1.dir_err,
2299                                  win_errstr(err_data->v1.status)));
2300
2301                         if (!err_data->v1.info) {
2302                                 DEBUG(0, ("DsAddEntry (R3): no error info returned!\n"));
2303                                 composite_error(c, werror_to_ntstatus(status));
2304                                 return;
2305                         }
2306
2307                         /* dump more detailed error */
2308                         switch (err_data->v1.dir_err) {
2309                         case DRSUAPI_DIRERR_ATTRIBUTE:
2310                                 /* Dump attribute errors */
2311                                 attr_err = &err_data->v1.info->attr_err;
2312                                 DEBUGADD(0,(" Attribute Error: object = %s, count = %d;\n",
2313                                             attr_err->id->dn,
2314                                             attr_err->count));
2315                                 attr_err_li = &attr_err->first;
2316                                 for (; attr_err_li; attr_err_li = attr_err_li->next) {
2317                                         struct drsuapi_DsAddEntry_AttrErr_V1 *err = &attr_err_li->err_data;
2318                                         DEBUGADD(0,(" Error: err = %s, problem = 0x%08X, attid = 0x%08X;\n",
2319                                                     win_errstr(err->extended_err),
2320                                                     err->problem,
2321                                                     err->attid));
2322                                         /* TODO: should we print attribute value here? */
2323                                 }
2324                                 break;
2325                         case DRSUAPI_DIRERR_NAME:
2326                                 /* Dump Name resolution error */
2327                                 name_err = &err_data->v1.info->name_err;
2328                                 DEBUGADD(0,(" Name Error: err = %s, problem = 0x%08X, id_matched = %s;\n",
2329                                             win_errstr(name_err->extended_err),
2330                                             name_err->problem,
2331                                             name_err->id_matched->dn));
2332                                 break;
2333                         case DRSUAPI_DIRERR_REFERRAL:
2334                                 /* Dump Referral errors */
2335                                 ref_err = &err_data->v1.info->referral_err;
2336                                 DEBUGADD(0,(" Referral Error: extended_err = %s\n",
2337                                             win_errstr(ref_err->extended_err)));
2338                                 ref_li = &ref_err->refer;
2339                                 for (; ref_li; ref_li = ref_li->next) {
2340                                         struct drsuapi_DsaAddressListItem_V1 *addr;
2341                                         DEBUGADD(0,(" Referral: id_target = %s, ref_type = 0x%04X,",
2342                                                     ref_li->id_target->dn,
2343                                                     ref_li->ref_type));
2344                                         if (ref_li->is_choice_set) {
2345                                                 DEBUGADD(0,(" choice = 0x%02X, ",
2346                                                             ref_li->choice));
2347                                         }
2348                                         DEBUGADD(0,(" add_list ("));
2349                                         for (addr = ref_li->addr_list; addr; addr = addr->next) {
2350                                                 DEBUGADD(0,("%s", addr->address->string));
2351                                                 if (addr->next) {
2352                                                         DEBUGADD(0,(", "));
2353                                                 }
2354                                         }
2355                                         DEBUGADD(0,(");\n"));
2356                                 }
2357                                 break;
2358                         case DRSUAPI_DIRERR_SECURITY:
2359                                 /* Dump Security error. */
2360                                 DEBUGADD(0,(" Security Error: extended_err = %s, problem = 0x%08X\n",
2361                                             win_errstr(err_data->v1.info->security_err.extended_err),
2362                                             err_data->v1.info->security_err.problem));
2363                                 break;
2364                         case DRSUAPI_DIRERR_SERVICE:
2365                                 /* Dump Service error. */
2366                                 DEBUGADD(0,(" Service Error: extended_err = %s, problem = 0x%08X\n",
2367                                             win_errstr(err_data->v1.info->service_err.extended_err),
2368                                             err_data->v1.info->service_err.problem));
2369                                 break;
2370                         case DRSUAPI_DIRERR_UPDATE:
2371                                 /* Dump Update error. */
2372                                 DEBUGADD(0,(" Update Error: extended_err = %s, problem = 0x%08X\n",
2373                                             win_errstr(err_data->v1.info->update_err.extended_err),
2374                                             err_data->v1.info->update_err.problem));
2375                                 break;
2376                         case DRSUAPI_DIRERR_SYSTEM:
2377                                 /* System error. */
2378                                 DEBUGADD(0,(" System Error: extended_err = %s, problem = 0x%08X\n",
2379                                             win_errstr(err_data->v1.info->system_err.extended_err),
2380                                             err_data->v1.info->system_err.problem));
2381                                 break;
2382                         case DRSUAPI_DIRERR_OK: /* mute compiler warnings */
2383                         default:
2384                                 DEBUGADD(0,(" Unknown DIRERR error class returned!\n"));
2385                                 break;
2386                         }
2387
2388                         composite_error(c, werror_to_ntstatus(status));
2389                         return;
2390                 }
2391
2392                 if (1 != r->out.ctr->ctr3.count) {
2393                         DEBUG(0,("DsAddEntry - Ctr3: something very wrong had happened - "
2394                                  "method succeeded but objects returned are %d (expected 1).\n",
2395                                  r->out.ctr->ctr3.count));
2396                         composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2397                 }
2398
2399                 s->dest_dsa.ntds_guid   = r->out.ctr->ctr3.objects[0].guid;
2400
2401         } else if (*r->out.level_out == 2) {
2402                 if (DRSUAPI_DIRERR_OK != r->out.ctr->ctr2.dir_err) {
2403                         DEBUG(0,("DsAddEntry failed with: dir_err = %d, extended_err = %s\n",
2404                                  r->out.ctr->ctr2.dir_err,
2405                                  win_errstr(r->out.ctr->ctr2.extended_err)));
2406                         composite_error(c, werror_to_ntstatus(r->out.ctr->ctr2.extended_err));
2407                         return;
2408                 }
2409
2410                 if (1 != r->out.ctr->ctr2.count) {
2411                         DEBUG(0,("DsAddEntry: something very wrong had happened - "
2412                                  "method succeeded but objects returned are %d (expected 1). "
2413                                  "Errors: dir_err = %d, extended_err = %s\n",
2414                                  r->out.ctr->ctr2.count,
2415                                  r->out.ctr->ctr2.dir_err,
2416                                  win_errstr(r->out.ctr->ctr2.extended_err)));
2417                         composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2418                 }
2419
2420                 s->dest_dsa.ntds_guid   = r->out.ctr->ctr2.objects[0].guid;
2421         } else {
2422                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2423                 return;
2424         }
2425
2426         talloc_free(r);
2427
2428         s->dest_dsa.ntds_dn_str = talloc_asprintf(s, "CN=NTDS Settings,%s",
2429                                                   s->dest_dsa.server_dn_str);
2430         if (composite_nomem(s->dest_dsa.ntds_dn_str, c)) return;
2431
2432         c->status = becomeDC_prepare_db(s);
2433         if (!composite_is_ok(c)) return;
2434
2435         /* this avoids the epmapper lookup on the 2nd connection */
2436         binding_str = dcerpc_binding_string(s, s->drsuapi1.binding);
2437         if (composite_nomem(binding_str, c)) return;
2438
2439         c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi2.binding);
2440         talloc_free(binding_str);
2441         if (!composite_is_ok(c)) return;
2442
2443         if (DEBUGLEVEL >= 10) {
2444                 s->drsuapi2.binding->flags |= DCERPC_DEBUG_PRINT_BOTH;
2445         }
2446
2447         /* w2k3 uses the same assoc_group_id as on the first connection, so we do */
2448         s->drsuapi2.binding->assoc_group_id     = s->drsuapi1.pipe->assoc_group_id;
2449
2450         becomeDC_drsuapi_connect_send(s, &s->drsuapi2, becomeDC_drsuapi2_connect_recv);
2451 }
2452
2453 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s)
2454 {
2455         if (!s->callbacks.prepare_db) return NT_STATUS_OK;
2456
2457         s->_pp.domain           = &s->domain;
2458         s->_pp.forest           = &s->forest;
2459         s->_pp.source_dsa       = &s->source_dsa;
2460         s->_pp.dest_dsa         = &s->dest_dsa;
2461
2462         return s->callbacks.prepare_db(s->callbacks.private_data, &s->_pp);
2463 }
2464
2465 static void becomeDC_drsuapi2_bind_recv(struct tevent_req *subreq);
2466
2467 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req)
2468 {
2469         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2470                                           struct libnet_BecomeDC_state);
2471         struct composite_context *c = s->creq;
2472
2473         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi2.pipe);
2474         if (!composite_is_ok(c)) return;
2475
2476         s->drsuapi2.drsuapi_handle = s->drsuapi2.pipe->binding_handle;
2477
2478         c->status = gensec_session_key(s->drsuapi2.pipe->conn->security_state.generic_state,
2479                                        s,
2480                                        &s->drsuapi2.gensec_skey);
2481         if (!composite_is_ok(c)) return;
2482
2483         becomeDC_drsuapi_bind_send(s, &s->drsuapi2, becomeDC_drsuapi2_bind_recv);
2484 }
2485
2486 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req);
2487
2488 static void becomeDC_drsuapi2_bind_recv(struct tevent_req *subreq)
2489 {
2490         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2491                                           struct libnet_BecomeDC_state);
2492         struct composite_context *c = s->creq;
2493         char *binding_str;
2494         WERROR status;
2495
2496         c->status = dcerpc_drsuapi_DsBind_r_recv(subreq, s);
2497         TALLOC_FREE(subreq);
2498         if (!composite_is_ok(c)) return;
2499
2500         status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi2);
2501         if (!W_ERROR_IS_OK(status)) {
2502                 composite_error(c, werror_to_ntstatus(status));
2503                 return;
2504         }
2505
2506         /* this avoids the epmapper lookup on the 3rd connection */
2507         binding_str = dcerpc_binding_string(s, s->drsuapi1.binding);
2508         if (composite_nomem(binding_str, c)) return;
2509
2510         c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi3.binding);
2511         talloc_free(binding_str);
2512         if (!composite_is_ok(c)) return;
2513
2514         if (DEBUGLEVEL >= 10) {
2515                 s->drsuapi3.binding->flags |= DCERPC_DEBUG_PRINT_BOTH;
2516         }
2517
2518         /* w2k3 uses the same assoc_group_id as on the first connection, so we do */
2519         s->drsuapi3.binding->assoc_group_id     = s->drsuapi1.pipe->assoc_group_id;
2520         /* w2k3 uses the concurrent multiplex feature on the 3rd connection, so we do */
2521         s->drsuapi3.binding->flags              |= DCERPC_CONCURRENT_MULTIPLEX;
2522
2523         becomeDC_drsuapi_connect_send(s, &s->drsuapi3, becomeDC_drsuapi3_connect_recv);
2524 }
2525
2526 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s);
2527
2528 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req)
2529 {
2530         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2531                                           struct libnet_BecomeDC_state);
2532         struct composite_context *c = s->creq;
2533
2534         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi3.pipe);
2535         if (!composite_is_ok(c)) return;
2536
2537         s->drsuapi3.drsuapi_handle = s->drsuapi3.pipe->binding_handle;
2538
2539         c->status = gensec_session_key(s->drsuapi3.pipe->conn->security_state.generic_state,
2540                                        s,
2541                                        &s->drsuapi3.gensec_skey);
2542         if (!composite_is_ok(c)) return;
2543
2544         becomeDC_drsuapi3_pull_schema_send(s);
2545 }
2546
2547 static void becomeDC_drsuapi_pull_partition_send(struct libnet_BecomeDC_state *s,
2548                                                  struct becomeDC_drsuapi *drsuapi_h,
2549                                                  struct becomeDC_drsuapi *drsuapi_p,
2550                                                  struct libnet_BecomeDC_Partition *partition,
2551                                                  void (*recv_fn)(struct tevent_req *subreq))
2552 {
2553         struct composite_context *c = s->creq;
2554         struct drsuapi_DsGetNCChanges *r;
2555         struct tevent_req *subreq;
2556
2557         r = talloc(s, struct drsuapi_DsGetNCChanges);
2558         if (composite_nomem(r, c)) return;
2559
2560         r->out.level_out = talloc(r, uint32_t);
2561         if (composite_nomem(r->out.level_out, c)) return;
2562         r->in.req = talloc(r, union drsuapi_DsGetNCChangesRequest);
2563         if (composite_nomem(r->in.req, c)) return;
2564         r->out.ctr = talloc(r, union drsuapi_DsGetNCChangesCtr);
2565         if (composite_nomem(r->out.ctr, c)) return;
2566
2567         r->in.bind_handle       = &drsuapi_h->bind_handle;
2568         if (drsuapi_h->remote_info28.supported_extensions & DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8) {
2569                 r->in.level                             = 8;
2570                 r->in.req->req8.destination_dsa_guid    = partition->destination_dsa_guid;
2571                 r->in.req->req8.source_dsa_invocation_id= partition->source_dsa_invocation_id;
2572                 r->in.req->req8.naming_context          = &partition->nc;
2573                 r->in.req->req8.highwatermark           = partition->highwatermark;
2574                 r->in.req->req8.uptodateness_vector     = NULL;
2575                 r->in.req->req8.replica_flags           = partition->replica_flags;
2576                 r->in.req->req8.max_object_count        = 133;
2577                 r->in.req->req8.max_ndr_size            = 1336811;
2578                 r->in.req->req8.extended_op             = DRSUAPI_EXOP_NONE;
2579                 r->in.req->req8.fsmo_info               = 0;
2580                 r->in.req->req8.partial_attribute_set   = NULL;
2581                 r->in.req->req8.partial_attribute_set_ex= NULL;
2582                 r->in.req->req8.mapping_ctr.num_mappings= 0;
2583                 r->in.req->req8.mapping_ctr.mappings    = NULL;
2584         } else {
2585                 r->in.level                             = 5;
2586                 r->in.req->req5.destination_dsa_guid    = partition->destination_dsa_guid;
2587                 r->in.req->req5.source_dsa_invocation_id= partition->source_dsa_invocation_id;
2588                 r->in.req->req5.naming_context          = &partition->nc;
2589                 r->in.req->req5.highwatermark           = partition->highwatermark;
2590                 r->in.req->req5.uptodateness_vector     = NULL;
2591                 r->in.req->req5.replica_flags           = partition->replica_flags;
2592                 r->in.req->req5.max_object_count        = 133;
2593                 r->in.req->req5.max_ndr_size            = 1336770;
2594                 r->in.req->req5.extended_op             = DRSUAPI_EXOP_NONE;
2595                 r->in.req->req5.fsmo_info               = 0;
2596         }
2597
2598         /*
2599          * we should try to use the drsuapi_p->pipe here, as w2k3 does
2600          * but it seems that some extra flags in the DCERPC Bind call
2601          * are needed for it. Or the same KRB5 TGS is needed on both
2602          * connections.
2603          */
2604         s->ndr_struct_ptr = r;
2605         subreq = dcerpc_drsuapi_DsGetNCChanges_r_send(s, c->event_ctx,
2606                                                       drsuapi_p->drsuapi_handle,
2607                                                       r);
2608         if (composite_nomem(subreq, c)) return;
2609         tevent_req_set_callback(subreq, recv_fn, s);
2610 }
2611
2612 static WERROR becomeDC_drsuapi_pull_partition_recv(struct libnet_BecomeDC_state *s,
2613                                                    struct becomeDC_drsuapi *drsuapi_h,
2614                                                    struct becomeDC_drsuapi *drsuapi_p,
2615                                                    struct libnet_BecomeDC_Partition *partition,
2616                                                    struct drsuapi_DsGetNCChanges *r)
2617 {
2618         uint32_t req_level = 0;
2619         struct drsuapi_DsGetNCChangesRequest5 *req5 = NULL;
2620         struct drsuapi_DsGetNCChangesRequest8 *req8 = NULL;
2621         struct drsuapi_DsGetNCChangesRequest10 *req10 = NULL;
2622         uint32_t ctr_level = 0;
2623         struct drsuapi_DsGetNCChangesCtr1 *ctr1 = NULL;
2624         struct drsuapi_DsGetNCChangesCtr6 *ctr6 = NULL;
2625         struct GUID *source_dsa_guid = NULL;
2626         struct GUID *source_dsa_invocation_id = NULL;
2627         struct drsuapi_DsReplicaHighWaterMark *new_highwatermark = NULL;
2628         bool more_data = false;
2629         NTSTATUS nt_status;
2630
2631         if (!W_ERROR_IS_OK(r->out.result)) {
2632                 return r->out.result;
2633         }
2634
2635         switch (r->in.level) {
2636         case 0:
2637                 /* none */
2638                 break;
2639         case 5:
2640                 req5 = &r->in.req->req5;
2641                 break;
2642         case 8:
2643                 req8 = &r->in.req->req8;
2644                 break;
2645         case 10:
2646                 req10 = &r->in.req->req10;
2647                 break;
2648         default:
2649                 return WERR_INVALID_PARAMETER;
2650         }
2651
2652         if (*r->out.level_out == 1) {
2653                 ctr_level = 1;
2654                 ctr1 = &r->out.ctr->ctr1;
2655         } else if (*r->out.level_out == 2 &&
2656                    r->out.ctr->ctr2.mszip1.ts) {
2657                 ctr_level = 1;
2658                 ctr1 = &r->out.ctr->ctr2.mszip1.ts->ctr1;
2659         } else if (*r->out.level_out == 6) {
2660                 ctr_level = 6;
2661                 ctr6 = &r->out.ctr->ctr6;
2662         } else if (*r->out.level_out == 7 &&
2663                    r->out.ctr->ctr7.level == 6 &&
2664                    r->out.ctr->ctr7.type == DRSUAPI_COMPRESSION_TYPE_MSZIP &&
2665                    r->out.ctr->ctr7.ctr.mszip6.ts) {
2666                 ctr_level = 6;
2667                 ctr6 = &r->out.ctr->ctr7.ctr.mszip6.ts->ctr6;
2668         } else if (*r->out.level_out == 7 &&
2669                    r->out.ctr->ctr7.level == 6 &&
2670                    r->out.ctr->ctr7.type == DRSUAPI_COMPRESSION_TYPE_XPRESS &&
2671                    r->out.ctr->ctr7.ctr.xpress6.ts) {
2672                 ctr_level = 6;
2673                 ctr6 = &r->out.ctr->ctr7.ctr.xpress6.ts->ctr6;
2674         } else {
2675                 return WERR_BAD_NET_RESP;
2676         }
2677
2678         if (!ctr1 && ! ctr6) {
2679                 return WERR_BAD_NET_RESP;
2680         }
2681
2682         if (ctr_level == 6) {
2683                 if (!W_ERROR_IS_OK(ctr6->drs_error)) {
2684                         return ctr6->drs_error;
2685                 }
2686         }
2687
2688         switch (ctr_level) {
2689         case 1:
2690                 source_dsa_guid                 = &ctr1->source_dsa_guid;
2691                 source_dsa_invocation_id        = &ctr1->source_dsa_invocation_id;
2692                 new_highwatermark               = &ctr1->new_highwatermark;
2693                 more_data                       = ctr1->more_data;
2694                 break;
2695         case 6:
2696                 source_dsa_guid                 = &ctr6->source_dsa_guid;
2697                 source_dsa_invocation_id        = &ctr6->source_dsa_invocation_id;
2698                 new_highwatermark               = &ctr6->new_highwatermark;
2699                 more_data                       = ctr6->more_data;
2700                 break;
2701         }
2702
2703         partition->highwatermark                = *new_highwatermark;
2704         partition->source_dsa_guid              = *source_dsa_guid;
2705         partition->source_dsa_invocation_id     = *source_dsa_invocation_id;
2706         partition->more_data                    = more_data;
2707
2708         if (!partition->store_chunk) return WERR_OK;
2709
2710         s->_sc.domain           = &s->domain;
2711         s->_sc.forest           = &s->forest;
2712         s->_sc.source_dsa       = &s->source_dsa;
2713         s->_sc.dest_dsa         = &s->dest_dsa;
2714         s->_sc.partition        = partition;
2715         s->_sc.req_level        = req_level;
2716         s->_sc.req5             = req5;
2717         s->_sc.req8             = req8;
2718         s->_sc.req10            = req10;
2719         s->_sc.ctr_level        = ctr_level;
2720         s->_sc.ctr1             = ctr1;
2721         s->_sc.ctr6             = ctr6;
2722         /*
2723          * we need to use the drsuapi_p->gensec_skey here,
2724          * when we use drsuapi_p->pipe in the for this request
2725          */
2726         s->_sc.gensec_skey      = &drsuapi_p->gensec_skey;
2727
2728         nt_status = partition->store_chunk(s->callbacks.private_data, &s->_sc);
2729         if (!NT_STATUS_IS_OK(nt_status)) {
2730                 return ntstatus_to_werror(nt_status);
2731         }
2732
2733         return WERR_OK;
2734 }
2735
2736 static void becomeDC_drsuapi3_pull_schema_recv(struct tevent_req *subreq);
2737
2738 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s)
2739 {
2740         s->schema_part.nc.guid  = GUID_zero();
2741         s->schema_part.nc.sid   = s->zero_sid;
2742         s->schema_part.nc.dn    = s->forest.schema_dn_str;
2743
2744         s->schema_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
2745
2746         s->schema_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
2747                                         | DRSUAPI_DRS_INIT_SYNC
2748                                         | DRSUAPI_DRS_PER_SYNC
2749                                         | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
2750                                         | DRSUAPI_DRS_NEVER_SYNCED
2751                                         | DRSUAPI_DRS_USE_COMPRESSION;
2752         if (s->rodc_join) {
2753             s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
2754         }
2755
2756         s->schema_part.store_chunk      = s->callbacks.schema_chunk;
2757
2758         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
2759                                              becomeDC_drsuapi3_pull_schema_recv);
2760 }
2761
2762 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s);
2763
2764 static void becomeDC_drsuapi3_pull_schema_recv(struct tevent_req *subreq)
2765 {
2766         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2767                                           struct libnet_BecomeDC_state);
2768         struct composite_context *c = s->creq;
2769         struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
2770                                            struct drsuapi_DsGetNCChanges);
2771         WERROR status;
2772
2773         s->ndr_struct_ptr = NULL;
2774
2775         c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
2776         TALLOC_FREE(subreq);
2777         if (!composite_is_ok(c)) return;
2778
2779         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part, r);
2780         if (!W_ERROR_IS_OK(status)) {
2781                 composite_error(c, werror_to_ntstatus(status));
2782                 return;
2783         }
2784
2785         talloc_free(r);
2786
2787         if (s->schema_part.more_data) {
2788                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
2789                                                      becomeDC_drsuapi3_pull_schema_recv);
2790                 return;
2791         }
2792
2793         becomeDC_drsuapi3_pull_config_send(s);
2794 }
2795
2796 static void becomeDC_drsuapi3_pull_config_recv(struct tevent_req *subreq);
2797
2798 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s)
2799 {
2800         s->config_part.nc.guid  = GUID_zero();
2801         s->config_part.nc.sid   = s->zero_sid;
2802         s->config_part.nc.dn    = s->forest.config_dn_str;
2803
2804         s->config_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
2805
2806         s->config_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
2807                                         | DRSUAPI_DRS_INIT_SYNC
2808                                         | DRSUAPI_DRS_PER_SYNC
2809                                         | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
2810                                         | DRSUAPI_DRS_NEVER_SYNCED
2811                                         | DRSUAPI_DRS_USE_COMPRESSION;
2812         if (s->rodc_join) {
2813             s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
2814         }
2815
2816         s->config_part.store_chunk      = s->callbacks.config_chunk;
2817
2818         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
2819                                              becomeDC_drsuapi3_pull_config_recv);
2820 }
2821
2822 static void becomeDC_drsuapi3_pull_config_recv(struct tevent_req *subreq)
2823 {
2824         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2825                                           struct libnet_BecomeDC_state);
2826         struct composite_context *c = s->creq;
2827         struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
2828                                            struct drsuapi_DsGetNCChanges);
2829         WERROR status;
2830
2831         s->ndr_struct_ptr = NULL;
2832
2833         c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
2834         TALLOC_FREE(subreq);
2835         if (!composite_is_ok(c)) return;
2836
2837         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->config_part, r);
2838         if (!W_ERROR_IS_OK(status)) {
2839                 composite_error(c, werror_to_ntstatus(status));
2840                 return;
2841         }
2842
2843         talloc_free(r);
2844
2845         if (s->config_part.more_data) {
2846                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
2847                                                      becomeDC_drsuapi3_pull_config_recv);
2848                 return;
2849         }
2850
2851         becomeDC_connect_ldap2(s);
2852 }
2853
2854 static void becomeDC_drsuapi3_pull_domain_recv(struct tevent_req *subreq);
2855
2856 static void becomeDC_drsuapi3_pull_domain_send(struct libnet_BecomeDC_state *s)
2857 {
2858         s->domain_part.nc.guid  = GUID_zero();
2859         s->domain_part.nc.sid   = s->zero_sid;
2860         s->domain_part.nc.dn    = s->domain.dn_str;
2861
2862         s->domain_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
2863
2864         s->domain_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
2865                                         | DRSUAPI_DRS_INIT_SYNC
2866                                         | DRSUAPI_DRS_PER_SYNC
2867                                         | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
2868                                         | DRSUAPI_DRS_NEVER_SYNCED
2869                                         | DRSUAPI_DRS_USE_COMPRESSION;
2870         if (s->rodc_join) {
2871             s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
2872         }
2873
2874         s->domain_part.store_chunk      = s->callbacks.domain_chunk;
2875
2876         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
2877                                              becomeDC_drsuapi3_pull_domain_recv);
2878 }
2879
2880 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
2881                                               struct becomeDC_drsuapi *drsuapi,
2882                                               struct libnet_BecomeDC_Partition *partition,
2883                                               void (*recv_fn)(struct tevent_req *subreq));
2884 static void becomeDC_drsuapi2_update_refs_schema_recv(struct tevent_req *subreq);
2885
2886 static void becomeDC_drsuapi3_pull_domain_recv(struct tevent_req *subreq)
2887 {
2888         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2889                                           struct libnet_BecomeDC_state);
2890         struct composite_context *c = s->creq;
2891         struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
2892                                            struct drsuapi_DsGetNCChanges);
2893         WERROR status;
2894
2895         s->ndr_struct_ptr = NULL;
2896
2897         c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
2898         TALLOC_FREE(subreq);
2899         if (!composite_is_ok(c)) return;
2900
2901         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part, r);
2902         if (!W_ERROR_IS_OK(status)) {
2903                 composite_error(c, werror_to_ntstatus(status));
2904                 return;
2905         }
2906
2907         talloc_free(r);
2908
2909         if (s->domain_part.more_data) {
2910                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
2911                                                      becomeDC_drsuapi3_pull_domain_recv);
2912                 return;
2913         }
2914
2915         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->schema_part,
2916                                           becomeDC_drsuapi2_update_refs_schema_recv);
2917 }
2918
2919 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
2920                                               struct becomeDC_drsuapi *drsuapi,
2921                                               struct libnet_BecomeDC_Partition *partition,
2922                                               void (*recv_fn)(struct tevent_req *subreq))
2923 {
2924         struct composite_context *c = s->creq;
2925         struct drsuapi_DsReplicaUpdateRefs *r;
2926         const char *ntds_guid_str;
2927         const char *ntds_dns_name;
2928         struct tevent_req *subreq;
2929
2930         r = talloc(s, struct drsuapi_DsReplicaUpdateRefs);
2931         if (composite_nomem(r, c)) return;
2932
2933         ntds_guid_str = GUID_string(r, &s->dest_dsa.ntds_guid);
2934         if (composite_nomem(ntds_guid_str, c)) return;
2935
2936         ntds_dns_name = talloc_asprintf(r, "%s._msdcs.%s",
2937                                         ntds_guid_str,
2938                                         s->forest.dns_name);
2939         if (composite_nomem(ntds_dns_name, c)) return;
2940
2941         r->in.bind_handle               = &drsuapi->bind_handle;
2942         r->in.level                     = 1;
2943         r->in.req.req1.naming_context   = &partition->nc;
2944         r->in.req.req1.dest_dsa_dns_name= ntds_dns_name;
2945         r->in.req.req1.dest_dsa_guid    = s->dest_dsa.ntds_guid;
2946         r->in.req.req1.options          = DRSUAPI_DRS_ADD_REF | DRSUAPI_DRS_DEL_REF;
2947
2948         /* I think this is how we mark ourselves as a RODC */
2949         if (!lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "repl", "RODC", false)) {
2950                 r->in.req.req1.options |= DRSUAPI_DRS_WRIT_REP;
2951         }
2952
2953         s->ndr_struct_ptr = r;
2954         subreq = dcerpc_drsuapi_DsReplicaUpdateRefs_r_send(s, c->event_ctx,
2955                                                            drsuapi->drsuapi_handle,
2956                                                            r);
2957         if (composite_nomem(subreq, c)) return;
2958         tevent_req_set_callback(subreq, recv_fn, s);
2959 }
2960
2961 static void becomeDC_drsuapi2_update_refs_config_recv(struct tevent_req *subreq);
2962
2963 static void becomeDC_drsuapi2_update_refs_schema_recv(struct tevent_req *subreq)
2964 {
2965         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2966                                           struct libnet_BecomeDC_state);
2967         struct composite_context *c = s->creq;
2968         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type_abort(s->ndr_struct_ptr,
2969                                            struct drsuapi_DsReplicaUpdateRefs);
2970
2971         s->ndr_struct_ptr = NULL;
2972
2973         c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
2974         TALLOC_FREE(subreq);
2975         if (!composite_is_ok(c)) return;
2976
2977         if (!W_ERROR_IS_OK(r->out.result)) {
2978                 composite_error(c, werror_to_ntstatus(r->out.result));
2979                 return;
2980         }
2981
2982         talloc_free(r);
2983
2984         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->config_part,
2985                                           becomeDC_drsuapi2_update_refs_config_recv);
2986 }
2987
2988 static void becomeDC_drsuapi2_update_refs_domain_recv(struct tevent_req *subreq);
2989
2990 static void becomeDC_drsuapi2_update_refs_config_recv(struct tevent_req *subreq)
2991 {
2992         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2993                                           struct libnet_BecomeDC_state);
2994         struct composite_context *c = s->creq;
2995         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(s->ndr_struct_ptr,
2996                                            struct drsuapi_DsReplicaUpdateRefs);
2997
2998         s->ndr_struct_ptr = NULL;
2999
3000         c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
3001         TALLOC_FREE(subreq);
3002         if (!composite_is_ok(c)) return;
3003
3004         if (!W_ERROR_IS_OK(r->out.result)) {
3005                 composite_error(c, werror_to_ntstatus(r->out.result));
3006                 return;
3007         }
3008
3009         talloc_free(r);
3010
3011         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->domain_part,
3012                                           becomeDC_drsuapi2_update_refs_domain_recv);
3013 }
3014
3015 static void becomeDC_drsuapi2_update_refs_domain_recv(struct tevent_req *subreq)
3016 {
3017         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
3018                                           struct libnet_BecomeDC_state);
3019         struct composite_context *c = s->creq;
3020         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(s->ndr_struct_ptr,
3021                                            struct drsuapi_DsReplicaUpdateRefs);
3022
3023         s->ndr_struct_ptr = NULL;
3024
3025         c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
3026         TALLOC_FREE(subreq);
3027         if (!composite_is_ok(c)) return;
3028
3029         if (!W_ERROR_IS_OK(r->out.result)) {
3030                 composite_error(c, werror_to_ntstatus(r->out.result));
3031                 return;
3032         }
3033
3034         talloc_free(r);
3035
3036         /* TODO: use DDNS updates and register dns names */
3037         composite_done(c);
3038 }
3039
3040 static NTSTATUS becomeDC_ldap2_modify_computer(struct libnet_BecomeDC_state *s)
3041 {
3042         int ret;
3043         struct ldb_message *msg;
3044         unsigned int i;
3045         uint32_t user_account_control = UF_SERVER_TRUST_ACCOUNT |
3046                                         UF_TRUSTED_FOR_DELEGATION;
3047
3048         /* as the value is already as we want it to be, we're done */
3049         if (s->dest_dsa.user_account_control == user_account_control) {
3050                 return NT_STATUS_OK;
3051         }
3052
3053         /* make a 'modify' msg, and only for serverReference */
3054         msg = ldb_msg_new(s);
3055         NT_STATUS_HAVE_NO_MEMORY(msg);
3056         msg->dn = ldb_dn_new(msg, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
3057         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
3058
3059         ret = samdb_msg_add_uint(s->ldap2.ldb, msg, msg, "userAccountControl",
3060                                  user_account_control);
3061         if (ret != LDB_SUCCESS) {
3062                 talloc_free(msg);
3063                 return NT_STATUS_NO_MEMORY;
3064         }
3065
3066         /* mark all the message elements (should be just one)
3067            as LDB_FLAG_MOD_REPLACE */
3068         for (i=0;i<msg->num_elements;i++) {
3069                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
3070         }
3071
3072         ret = ldb_modify(s->ldap2.ldb, msg);
3073         talloc_free(msg);
3074         if (ret != LDB_SUCCESS) {
3075                 return NT_STATUS_LDAP(ret);
3076         }
3077
3078         s->dest_dsa.user_account_control = user_account_control;
3079
3080         return NT_STATUS_OK;
3081 }
3082
3083 static NTSTATUS becomeDC_ldap2_move_computer(struct libnet_BecomeDC_state *s)
3084 {
3085         int ret;
3086         struct ldb_dn *old_dn;
3087         struct ldb_dn *new_dn;
3088
3089         ret = dsdb_wellknown_dn(s->ldap2.ldb, s,
3090                                 ldb_get_default_basedn(s->ldap2.ldb),
3091                                 DS_GUID_DOMAIN_CONTROLLERS_CONTAINER,
3092                                 &new_dn);
3093         if (ret != LDB_SUCCESS) {
3094                 return NT_STATUS_LDAP(ret);
3095         }
3096
3097         if (!ldb_dn_add_child_fmt(new_dn, "CN=%s", s->dest_dsa.netbios_name)) {
3098                 talloc_free(new_dn);
3099                 return NT_STATUS_NO_MEMORY;
3100         }
3101
3102         old_dn = ldb_dn_new(new_dn, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
3103         NT_STATUS_HAVE_NO_MEMORY(old_dn);
3104
3105         if (ldb_dn_compare(old_dn, new_dn) == 0) {
3106                 /* we don't need to rename if the old and new dn match */
3107                 talloc_free(new_dn);
3108                 return NT_STATUS_OK;
3109         }
3110
3111         ret = ldb_rename(s->ldap2.ldb, old_dn, new_dn);
3112         if (ret != LDB_SUCCESS) {
3113                 talloc_free(new_dn);
3114                 return NT_STATUS_LDAP(ret);
3115         }
3116
3117         s->dest_dsa.computer_dn_str = ldb_dn_alloc_linearized(s, new_dn);
3118         NT_STATUS_HAVE_NO_MEMORY(s->dest_dsa.computer_dn_str);
3119
3120         talloc_free(new_dn);
3121
3122         return NT_STATUS_OK;
3123 }
3124
3125 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s)
3126 {
3127         struct composite_context *c = s->creq;
3128
3129         c->status = becomeDC_ldap_connect(s, &s->ldap2);
3130         if (!composite_is_ok(c)) return;
3131
3132         c->status = becomeDC_ldap2_modify_computer(s);
3133         if (!composite_is_ok(c)) return;
3134
3135         c->status = becomeDC_ldap2_move_computer(s);
3136         if (!composite_is_ok(c)) return;
3137
3138         becomeDC_drsuapi3_pull_domain_send(s);
3139 }
3140
3141 struct composite_context *libnet_BecomeDC_send(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3142 {
3143         struct composite_context *c;
3144         struct libnet_BecomeDC_state *s;
3145         char *tmp_name;
3146
3147         c = composite_create(mem_ctx, ctx->event_ctx);
3148         if (c == NULL) return NULL;
3149
3150         s = talloc_zero(c, struct libnet_BecomeDC_state);
3151         if (composite_nomem(s, c)) return c;
3152         c->private_data = s;
3153         s->creq         = c;
3154         s->libnet       = ctx;
3155
3156         /* Domain input */
3157         s->domain.dns_name      = talloc_strdup(s, r->in.domain_dns_name);
3158         if (composite_nomem(s->domain.dns_name, c)) return c;
3159         s->domain.netbios_name  = talloc_strdup(s, r->in.domain_netbios_name);
3160         if (composite_nomem(s->domain.netbios_name, c)) return c;
3161         s->domain.sid           = dom_sid_dup(s, r->in.domain_sid);
3162         if (composite_nomem(s->domain.sid, c)) return c;
3163
3164         /* Source DSA input */
3165         s->source_dsa.address   = talloc_strdup(s, r->in.source_dsa_address);
3166         if (composite_nomem(s->source_dsa.address, c)) return c;
3167
3168         /* Destination DSA input */
3169         s->dest_dsa.netbios_name= talloc_strdup(s, r->in.dest_dsa_netbios_name);
3170         if (composite_nomem(s->dest_dsa.netbios_name, c)) return c;
3171
3172         /* Destination DSA dns_name construction */
3173         tmp_name        = strlower_talloc(s, s->dest_dsa.netbios_name);
3174         if (composite_nomem(tmp_name, c)) return c;
3175         tmp_name        = talloc_asprintf_append_buffer(tmp_name, ".%s",s->domain.dns_name);
3176         if (composite_nomem(tmp_name, c)) return c;
3177         s->dest_dsa.dns_name    = tmp_name;
3178
3179         /* Callback function pointers */
3180         s->callbacks = r->in.callbacks;
3181
3182         /* RODC join*/
3183         s->rodc_join = r->in.rodc_join;
3184
3185         becomeDC_send_cldap(s);
3186         return c;
3187 }
3188
3189 NTSTATUS libnet_BecomeDC_recv(struct composite_context *c, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3190 {
3191         NTSTATUS status;
3192
3193         status = composite_wait(c);
3194
3195         ZERO_STRUCT(r->out);
3196
3197         talloc_free(c);
3198         return status;
3199 }
3200
3201 NTSTATUS libnet_BecomeDC(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3202 {
3203         NTSTATUS status;
3204         struct composite_context *c;
3205         c = libnet_BecomeDC_send(ctx, mem_ctx, r);
3206         status = libnet_BecomeDC_recv(c, mem_ctx, r);
3207         return status;
3208 }