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 "lib/ldb/include/ldb.h"
  25 #include "lib/ldb/include/ldb_errors.h"
  26 #include "lib/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 compatible */
 743         return lp_parm_int(lp_ctx, NULL, "ads", "dc function level",
 744                 DS_DC_FUNCTION_2008);
 745 }
 746
 747 static int32_t get_min_function_level(struct loadparm_context *lp_ctx)
 748 {
 749         /* per default it is (Windows) 2003 Native compatible */
 750         return lp_parm_int(lp_ctx, NULL, "ads", "min function level",
 751                 DS_DOMAIN_FUNCTION_2003);
 752 }
 753
 754 static void becomeDC_recv_cldap(struct tevent_req *req);
 755
 756 static void becomeDC_send_cldap(struct libnet_BecomeDC_state *s)
 757 {
 758         struct composite_context *c = s->creq;
 759         struct tevent_req *req;
 760         struct tsocket_address *dest_address;
 761         int ret;
 762
 763         s->cldap.io.in.dest_address     = NULL;
 764         s->cldap.io.in.dest_port        = 0;
 765         s->cldap.io.in.realm            = s->domain.dns_name;
 766         s->cldap.io.in.host             = s->dest_dsa.netbios_name;
 767         s->cldap.io.in.user             = NULL;
 768         s->cldap.io.in.domain_guid      = NULL;
 769         s->cldap.io.in.domain_sid       = NULL;
 770         s->cldap.io.in.acct_control     = -1;
 771         s->cldap.io.in.version          = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
 772         s->cldap.io.in.map_response     = true;
 773
 774         ret = tsocket_address_inet_from_strings(s, "ip",
 775                                                 s->source_dsa.address,
 776                                                 lp_cldap_port(s->libnet->lp_ctx),
 777                                                 &dest_address);
 778         if (ret != 0) {
 779                 c->status = map_nt_error_from_unix(errno);
 780                 if (!composite_is_ok(c)) return;
 781         }
 782
 783         c->status = cldap_socket_init(s, s->libnet->event_ctx,
 784                                       NULL, dest_address, &s->cldap.sock);
 785         if (!composite_is_ok(c)) return;
 786
 787         req = cldap_netlogon_send(s, s->cldap.sock, &s->cldap.io);
 788         if (composite_nomem(req, c)) return;
 789         tevent_req_set_callback(req, becomeDC_recv_cldap, s);
 790 }
 791
 792 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s);
 793
 794 static void becomeDC_recv_cldap(struct tevent_req *req)
 795 {
 796         struct libnet_BecomeDC_state *s = tevent_req_callback_data(req,
 797                                           struct libnet_BecomeDC_state);
 798         struct composite_context *c = s->creq;
 799
 800         c->status = cldap_netlogon_recv(req,
 801                                         lp_iconv_convenience(s->libnet->lp_ctx),
 802                                         s, &s->cldap.io);
 803         talloc_free(req);
 804         if (!composite_is_ok(c)) {
 805                 DEBUG(0,("Failed to send, receive or parse CLDAP reply from server %s for our host %s: %s\n",
 806                          s->cldap.io.in.dest_address,
 807                          s->cldap.io.in.host,
 808                          nt_errstr(c->status)));
 809                 return;
 810         }
 811         s->cldap.netlogon = s->cldap.io.out.netlogon.data.nt5_ex;
 812
 813         s->domain.dns_name              = s->cldap.netlogon.dns_domain;
 814         s->domain.netbios_name          = s->cldap.netlogon.domain_name;
 815         s->domain.guid                  = s->cldap.netlogon.domain_uuid;
 816
 817         s->forest.dns_name              = s->cldap.netlogon.forest;
 818
 819         s->source_dsa.dns_name          = s->cldap.netlogon.pdc_dns_name;
 820         s->source_dsa.netbios_name      = s->cldap.netlogon.pdc_name;
 821         s->source_dsa.site_name         = s->cldap.netlogon.server_site;
 822
 823         s->dest_dsa.site_name           = s->cldap.netlogon.client_site;
 824
 825         DEBUG(0,("CLDAP response: forest=%s dns=%s netbios=%s server_site=%s  client_site=%s\n",
 826                  s->forest.dns_name, s->domain.dns_name, s->domain.netbios_name,
 827                  s->source_dsa.site_name, s->dest_dsa.site_name));
 828         if (!s->dest_dsa.site_name || strcmp(s->dest_dsa.site_name, "") == 0) {
 829                 DEBUG(0,("Got empty client site - using server site name %s\n",
 830                          s->source_dsa.site_name));
 831                 s->dest_dsa.site_name = s->source_dsa.site_name;
 832         }
 833
 834         becomeDC_connect_ldap1(s);
 835 }
 836
 837 static NTSTATUS becomeDC_ldap_connect(struct libnet_BecomeDC_state *s,
 838                                       struct becomeDC_ldap *ldap)
 839 {
 840         char *url;
 841
 842         url = talloc_asprintf(s, "ldap://%s/", s->source_dsa.dns_name);
 843         NT_STATUS_HAVE_NO_MEMORY(url);
 844
 845         ldap->ldb = ldb_wrap_connect(s, s->libnet->event_ctx, s->libnet->lp_ctx, url,
 846                                      NULL,
 847                                      s->libnet->cred,
 848                                      0);
 849         talloc_free(url);
 850         if (ldap->ldb == NULL) {
 851                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
 852         }
 853
 854         return NT_STATUS_OK;
 855 }
 856
 857 static NTSTATUS becomeDC_ldap1_rootdse(struct libnet_BecomeDC_state *s)
 858 {
 859         int ret;
 860         struct ldb_result *r;
 861         struct ldb_dn *basedn;
 862         static const char *attrs[] = {
 863                 "*",
 864                 NULL
 865         };
 866
 867         basedn = ldb_dn_new(s, s->ldap1.ldb, NULL);
 868         NT_STATUS_HAVE_NO_MEMORY(basedn);
 869
 870         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
 871                          "(objectClass=*)");
 872         talloc_free(basedn);
 873         if (ret != LDB_SUCCESS) {
 874                 return NT_STATUS_LDAP(ret);
 875         } else if (r->count != 1) {
 876                 talloc_free(r);
 877                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 878         }
 879
 880         s->ldap1.rootdse = r->msgs[0];
 881
 882         s->domain.dn_str        = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "defaultNamingContext", NULL);
 883         if (!s->domain.dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 884
 885         s->forest.root_dn_str   = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "rootDomainNamingContext", NULL);
 886         if (!s->forest.root_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 887         s->forest.config_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "configurationNamingContext", NULL);
 888         if (!s->forest.config_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 889         s->forest.schema_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "schemaNamingContext", NULL);
 890         if (!s->forest.schema_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 891
 892         s->source_dsa.server_dn_str     = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "serverName", NULL);
 893         if (!s->source_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 894         s->source_dsa.ntds_dn_str       = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "dsServiceName", NULL);
 895         if (!s->source_dsa.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 896
 897         return NT_STATUS_OK;
 898 }
 899
 900 static NTSTATUS becomeDC_ldap1_crossref_behavior_version(struct libnet_BecomeDC_state *s)
 901 {
 902         int ret;
 903         struct ldb_result *r;
 904         struct ldb_dn *basedn;
 905         static const char *attrs[] = {
 906                 "msDs-Behavior-Version",
 907                 NULL
 908         };
 909
 910         basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.config_dn_str);
 911         NT_STATUS_HAVE_NO_MEMORY(basedn);
 912
 913         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_ONELEVEL, attrs,
 914                          "(cn=Partitions)");
 915         talloc_free(basedn);
 916         if (ret != LDB_SUCCESS) {
 917                 return NT_STATUS_LDAP(ret);
 918         } else if (r->count != 1) {
 919                 talloc_free(r);
 920                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 921         }
 922
 923         s->forest.crossref_behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
 924         if (s->forest.crossref_behavior_version <
 925                          get_min_function_level(s->libnet->lp_ctx)) {
 926                 talloc_free(r);
 927                 DEBUG(0,("The servers function level %u is below 'ads:min function level' of %u\n",
 928                          s->forest.crossref_behavior_version,
 929                          get_min_function_level(s->libnet->lp_ctx)));
 930                 return NT_STATUS_NOT_SUPPORTED;
 931         }
 932         if (s->forest.crossref_behavior_version >
 933                         get_dc_function_level(s->libnet->lp_ctx)) {
 934                 talloc_free(r);
 935                 DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n",
 936                          s->forest.crossref_behavior_version,
 937                          get_dc_function_level(s->libnet->lp_ctx)));
 938                 return NT_STATUS_NOT_SUPPORTED;
 939         }
 940
 941         talloc_free(r);
 942         return NT_STATUS_OK;
 943 }
 944
 945 static NTSTATUS becomeDC_ldap1_domain_behavior_version(struct libnet_BecomeDC_state *s)
 946 {
 947         int ret;
 948         struct ldb_result *r;
 949         struct ldb_dn *basedn;
 950         static const char *attrs[] = {
 951                 "msDs-Behavior-Version",
 952                 NULL
 953         };
 954
 955         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
 956         NT_STATUS_HAVE_NO_MEMORY(basedn);
 957
 958         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
 959                          "(objectClass=*)");
 960         talloc_free(basedn);
 961         if (ret != LDB_SUCCESS) {
 962                 return NT_STATUS_LDAP(ret);
 963         } else if (r->count != 1) {
 964                 talloc_free(r);
 965                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 966         }
 967
 968         s->domain.behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
 969         if (s->domain.behavior_version <
 970                         get_min_function_level(s->libnet->lp_ctx)) {
 971                 talloc_free(r);
 972                 DEBUG(0,("The servers function level %u is below 'ads:min function level' of %u\n",
 973                          s->forest.crossref_behavior_version,
 974                          get_min_function_level(s->libnet->lp_ctx)));
 975                 return NT_STATUS_NOT_SUPPORTED;
 976         }
 977         if (s->domain.behavior_version >
 978                         get_dc_function_level(s->libnet->lp_ctx)) {
 979                 talloc_free(r);
 980                 DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n",
 981                          s->forest.crossref_behavior_version,
 982                          get_dc_function_level(s->libnet->lp_ctx)));
 983                 return NT_STATUS_NOT_SUPPORTED;
 984         }
 985
 986         talloc_free(r);
 987         return NT_STATUS_OK;
 988 }
 989
 990 static NTSTATUS becomeDC_ldap1_schema_object_version(struct libnet_BecomeDC_state *s)
 991 {
 992         int ret;
 993         struct ldb_result *r;
 994         struct ldb_dn *basedn;
 995         static const char *attrs[] = {
 996                 "objectVersion",
 997                 NULL
 998         };
 999
1000         basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.schema_dn_str);
1001         NT_STATUS_HAVE_NO_MEMORY(basedn);
1002
1003         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
1004                          "(objectClass=*)");
1005         talloc_free(basedn);
1006         if (ret != LDB_SUCCESS) {
1007                 return NT_STATUS_LDAP(ret);
1008         } else if (r->count != 1) {
1009                 talloc_free(r);
1010                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1011         }
1012
1013         s->forest.schema_object_version = ldb_msg_find_attr_as_uint(r->msgs[0], "objectVersion", 0);
1014
1015         talloc_free(r);
1016         return NT_STATUS_OK;
1017 }
1018
1019 static NTSTATUS becomeDC_ldap1_w2k3_update_revision(struct libnet_BecomeDC_state *s)
1020 {
1021         int ret;
1022         struct ldb_result *r;
1023         struct ldb_dn *basedn;
1024         static const char *attrs[] = {
1025                 "revision",
1026                 NULL
1027         };
1028
1029         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=Windows2003Update,CN=DomainUpdates,CN=System,%s",
1030                                 s->domain.dn_str);
1031         NT_STATUS_HAVE_NO_MEMORY(basedn);
1032
1033         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
1034                          "(objectClass=*)");
1035         talloc_free(basedn);
1036         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1037                 /* w2k doesn't have this object */
1038                 s->domain.w2k3_update_revision = 0;
1039                 return NT_STATUS_OK;
1040         } else if (ret != LDB_SUCCESS) {
1041                 return NT_STATUS_LDAP(ret);
1042         } else if (r->count != 1) {
1043                 talloc_free(r);
1044                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1045         }
1046
1047         s->domain.w2k3_update_revision = ldb_msg_find_attr_as_uint(r->msgs[0], "revision", 0);
1048
1049         talloc_free(r);
1050         return NT_STATUS_OK;
1051 }
1052
1053 static NTSTATUS becomeDC_ldap1_infrastructure_fsmo(struct libnet_BecomeDC_state *s)
1054 {
1055         int ret;
1056         struct ldb_result *r;
1057         struct ldb_dn *basedn;
1058         struct ldb_dn *ntds_dn;
1059         struct ldb_dn *server_dn;
1060         static const char *dns_attrs[] = {
1061                 "dnsHostName",
1062                 NULL
1063         };
1064         static const char *guid_attrs[] = {
1065                 "objectGUID",
1066                 NULL
1067         };
1068
1069         ret = dsdb_wellknown_dn(s->ldap1.ldb, s,
1070                                 ldb_get_default_basedn(s->ldap1.ldb),
1071                                 DS_GUID_INFRASTRUCTURE_CONTAINER,
1072                                 &basedn);
1073         if (ret != LDB_SUCCESS) {
1074                 return NT_STATUS_LDAP(ret);
1075         }
1076
1077         ret = samdb_reference_dn(s->ldap1.ldb, s, basedn, "fSMORoleOwner", &ntds_dn);
1078         if (ret != LDB_SUCCESS) {
1079                 talloc_free(basedn);
1080                 return NT_STATUS_LDAP(ret);
1081         }
1082
1083         s->infrastructure_fsmo.ntds_dn_str = ldb_dn_get_linearized(ntds_dn);
1084         NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.ntds_dn_str);
1085
1086         server_dn = ldb_dn_get_parent(s, ntds_dn);
1087         NT_STATUS_HAVE_NO_MEMORY(server_dn);
1088
1089         s->infrastructure_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
1090         NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.server_dn_str);
1091
1092         ret = ldb_search(s->ldap1.ldb, s, &r, server_dn, LDB_SCOPE_BASE,
1093                          dns_attrs, "(objectClass=*)");
1094         if (ret != LDB_SUCCESS) {
1095                 return NT_STATUS_LDAP(ret);
1096         } else if (r->count != 1) {
1097                 talloc_free(r);
1098                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1099         }
1100
1101         s->infrastructure_fsmo.dns_name = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
1102         if (!s->infrastructure_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1103         talloc_steal(s, s->infrastructure_fsmo.dns_name);
1104
1105         talloc_free(r);
1106
1107         ret = ldb_search(s->ldap1.ldb, s, &r, ntds_dn, LDB_SCOPE_BASE,
1108                          guid_attrs, "(objectClass=*)");
1109         if (ret != LDB_SUCCESS) {
1110                 return NT_STATUS_LDAP(ret);
1111         } else if (r->count != 1) {
1112                 talloc_free(r);
1113                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1114         }
1115
1116         s->infrastructure_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1117
1118         talloc_free(r);
1119
1120         return NT_STATUS_OK;
1121 }
1122
1123 static NTSTATUS becomeDC_ldap1_rid_manager_fsmo(struct libnet_BecomeDC_state *s)
1124 {
1125         int ret;
1126         struct ldb_result *r;
1127         struct ldb_dn *basedn;
1128         const char *reference_dn_str;
1129         struct ldb_dn *ntds_dn;
1130         struct ldb_dn *server_dn;
1131         static const char *rid_attrs[] = {
1132                 "rIDManagerReference",
1133                 NULL
1134         };
1135         static const char *fsmo_attrs[] = {
1136                 "fSMORoleOwner",
1137                 NULL
1138         };
1139         static const char *dns_attrs[] = {
1140                 "dnsHostName",
1141                 NULL
1142         };
1143         static const char *guid_attrs[] = {
1144                 "objectGUID",
1145                 NULL
1146         };
1147
1148         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
1149         NT_STATUS_HAVE_NO_MEMORY(basedn);
1150
1151         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1152                          rid_attrs, "(objectClass=*)");
1153         talloc_free(basedn);
1154         if (ret != LDB_SUCCESS) {
1155                 return NT_STATUS_LDAP(ret);
1156         } else if (r->count != 1) {
1157                 talloc_free(r);
1158                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1159         }
1160
1161         reference_dn_str        = samdb_result_string(r->msgs[0], "rIDManagerReference", NULL);
1162         if (!reference_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1163
1164         basedn = ldb_dn_new(s, s->ldap1.ldb, reference_dn_str);
1165         NT_STATUS_HAVE_NO_MEMORY(basedn);
1166
1167         talloc_free(r);
1168
1169         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1170                          fsmo_attrs, "(objectClass=*)");
1171         talloc_free(basedn);
1172         if (ret != LDB_SUCCESS) {
1173                 return NT_STATUS_LDAP(ret);
1174         } else if (r->count != 1) {
1175                 talloc_free(r);
1176                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1177         }
1178
1179         s->rid_manager_fsmo.ntds_dn_str = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
1180         if (!s->rid_manager_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1181         talloc_steal(s, s->rid_manager_fsmo.ntds_dn_str);
1182
1183         talloc_free(r);
1184
1185         ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->rid_manager_fsmo.ntds_dn_str);
1186         NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
1187
1188         server_dn = ldb_dn_get_parent(s, ntds_dn);
1189         NT_STATUS_HAVE_NO_MEMORY(server_dn);
1190
1191         s->rid_manager_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
1192         NT_STATUS_HAVE_NO_MEMORY(s->rid_manager_fsmo.server_dn_str);
1193
1194         ret = ldb_search(s->ldap1.ldb, s, &r, server_dn, LDB_SCOPE_BASE,
1195                          dns_attrs, "(objectClass=*)");
1196         if (ret != LDB_SUCCESS) {
1197                 return NT_STATUS_LDAP(ret);
1198         } else if (r->count != 1) {
1199                 talloc_free(r);
1200                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1201         }
1202
1203         s->rid_manager_fsmo.dns_name    = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
1204         if (!s->rid_manager_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1205         talloc_steal(s, s->rid_manager_fsmo.dns_name);
1206
1207         talloc_free(r);
1208
1209         ret = ldb_search(s->ldap1.ldb, s, &r, ntds_dn, LDB_SCOPE_BASE,
1210                          guid_attrs, "(objectClass=*)");
1211         if (ret != LDB_SUCCESS) {
1212                 return NT_STATUS_LDAP(ret);
1213         } else if (r->count != 1) {
1214                 talloc_free(r);
1215                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1216         }
1217
1218         s->rid_manager_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1219
1220         talloc_free(r);
1221
1222         return NT_STATUS_OK;
1223 }
1224
1225 static NTSTATUS becomeDC_ldap1_site_object(struct libnet_BecomeDC_state *s)
1226 {
1227         int ret;
1228         struct ldb_result *r;
1229         struct ldb_dn *basedn;
1230
1231         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Sites,%s",
1232                                 s->dest_dsa.site_name,
1233                                 s->forest.config_dn_str);
1234         NT_STATUS_HAVE_NO_MEMORY(basedn);
1235
1236         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1237                          NULL, "(objectClass=*)");
1238         talloc_free(basedn);
1239         if (ret != LDB_SUCCESS) {
1240                 return NT_STATUS_LDAP(ret);
1241         } else if (r->count != 1) {
1242                 talloc_free(r);
1243                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1244         }
1245
1246         s->dest_dsa.site_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1247
1248         talloc_free(r);
1249         return NT_STATUS_OK;
1250 }
1251
1252 static NTSTATUS becomeDC_check_options(struct libnet_BecomeDC_state *s)
1253 {
1254         if (!s->callbacks.check_options) return NT_STATUS_OK;
1255
1256         s->_co.domain           = &s->domain;
1257         s->_co.forest           = &s->forest;
1258         s->_co.source_dsa       = &s->source_dsa;
1259
1260         return s->callbacks.check_options(s->callbacks.private_data, &s->_co);
1261 }
1262
1263 static NTSTATUS becomeDC_ldap1_computer_object(struct libnet_BecomeDC_state *s)
1264 {
1265         int ret;
1266         struct ldb_result *r;
1267         struct ldb_dn *basedn;
1268         static const char *attrs[] = {
1269                 "distinguishedName",
1270                 "userAccountControl",
1271                 NULL
1272         };
1273
1274         basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
1275         NT_STATUS_HAVE_NO_MEMORY(basedn);
1276
1277         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_SUBTREE, attrs,
1278                          "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
1279                          s->dest_dsa.netbios_name);
1280         talloc_free(basedn);
1281         if (ret != LDB_SUCCESS) {
1282                 return NT_STATUS_LDAP(ret);
1283         } else if (r->count != 1) {
1284                 talloc_free(r);
1285                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1286         }
1287
1288         s->dest_dsa.computer_dn_str     = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
1289         if (!s->dest_dsa.computer_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1290         talloc_steal(s, s->dest_dsa.computer_dn_str);
1291
1292         s->dest_dsa.user_account_control = samdb_result_uint(r->msgs[0], "userAccountControl", 0);
1293
1294         talloc_free(r);
1295         return NT_STATUS_OK;
1296 }
1297
1298 static NTSTATUS becomeDC_ldap1_server_object_1(struct libnet_BecomeDC_state *s)
1299 {
1300         int ret;
1301         struct ldb_result *r;
1302         struct ldb_dn *basedn;
1303         const char *server_reference_dn_str;
1304         struct ldb_dn *server_reference_dn;
1305         struct ldb_dn *computer_dn;
1306
1307         basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
1308                                 s->dest_dsa.netbios_name,
1309                                 s->dest_dsa.site_name,
1310                                 s->forest.config_dn_str);
1311         NT_STATUS_HAVE_NO_MEMORY(basedn);
1312
1313         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1314                          NULL, "(objectClass=*)");
1315         talloc_free(basedn);
1316         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1317                 /* if the object doesn't exist, we'll create it later */
1318                 return NT_STATUS_OK;
1319         } else if (ret != LDB_SUCCESS) {
1320                 return NT_STATUS_LDAP(ret);
1321         } else if (r->count != 1) {
1322                 talloc_free(r);
1323                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1324         }
1325
1326         server_reference_dn_str = samdb_result_string(r->msgs[0], "serverReference", NULL);
1327         if (server_reference_dn_str) {
1328                 server_reference_dn     = ldb_dn_new(r, s->ldap1.ldb, server_reference_dn_str);
1329                 NT_STATUS_HAVE_NO_MEMORY(server_reference_dn);
1330
1331                 computer_dn             = ldb_dn_new(r, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
1332                 NT_STATUS_HAVE_NO_MEMORY(computer_dn);
1333
1334                 /*
1335                  * if the server object belongs to another DC in another domain
1336                  * in the forest, we should not touch this object!
1337                  */
1338                 if (ldb_dn_compare(computer_dn, server_reference_dn) != 0) {
1339                         talloc_free(r);
1340                         return NT_STATUS_OBJECT_NAME_COLLISION;
1341                 }
1342         }
1343
1344         /* if the server object is already for the dest_dsa, then we don't need to create it */
1345         s->dest_dsa.server_dn_str       = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
1346         if (!s->dest_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1347         talloc_steal(s, s->dest_dsa.server_dn_str);
1348
1349         talloc_free(r);
1350         return NT_STATUS_OK;
1351 }
1352
1353 static NTSTATUS becomeDC_ldap1_server_object_2(struct libnet_BecomeDC_state *s)
1354 {
1355         int ret;
1356         struct ldb_result *r;
1357         struct ldb_dn *basedn;
1358         const char *server_reference_bl_dn_str;
1359         static const char *attrs[] = {
1360                 "serverReferenceBL",
1361                 NULL
1362         };
1363
1364         /* if the server_dn_str has a valid value, we skip this lookup */
1365         if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
1366
1367         basedn = ldb_dn_new(s, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
1368         NT_STATUS_HAVE_NO_MEMORY(basedn);
1369
1370         ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1371                          attrs, "(objectClass=*)");
1372         talloc_free(basedn);
1373         if (ret != LDB_SUCCESS) {
1374                 return NT_STATUS_LDAP(ret);
1375         } else if (r->count != 1) {
1376                 talloc_free(r);
1377                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1378         }
1379
1380         server_reference_bl_dn_str = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
1381         if (!server_reference_bl_dn_str) {
1382                 /* if no back link is present, we're done for this function */
1383                 talloc_free(r);
1384                 return NT_STATUS_OK;
1385         }
1386
1387         /* if the server object is already for the dest_dsa, then we don't need to create it */
1388         s->dest_dsa.server_dn_str       = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
1389         if (s->dest_dsa.server_dn_str) {
1390                 /* if a back link is present, we know that the server object is present */
1391                 talloc_steal(s, s->dest_dsa.server_dn_str);
1392         }
1393
1394         talloc_free(r);
1395         return NT_STATUS_OK;
1396 }
1397
1398 static NTSTATUS becomeDC_ldap1_server_object_add(struct libnet_BecomeDC_state *s)
1399 {
1400         int ret;
1401         struct ldb_message *msg;
1402         char *server_dn_str;
1403
1404         /* if the server_dn_str has a valid value, we skip this lookup */
1405         if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
1406
1407         msg = ldb_msg_new(s);
1408         NT_STATUS_HAVE_NO_MEMORY(msg);
1409
1410         msg->dn = ldb_dn_new_fmt(msg, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
1411                                  s->dest_dsa.netbios_name,
1412                                  s->dest_dsa.site_name,
1413                                  s->forest.config_dn_str);
1414         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1415
1416         ret = ldb_msg_add_string(msg, "objectClass", "server");
1417         if (ret != 0) {
1418                 talloc_free(msg);
1419                 return NT_STATUS_NO_MEMORY;
1420         }
1421         ret = ldb_msg_add_string(msg, "systemFlags", "50000000");
1422         if (ret != 0) {
1423                 talloc_free(msg);
1424                 return NT_STATUS_NO_MEMORY;
1425         }
1426         ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
1427         if (ret != 0) {
1428                 talloc_free(msg);
1429                 return NT_STATUS_NO_MEMORY;
1430         }
1431
1432         server_dn_str = ldb_dn_alloc_linearized(s, msg->dn);
1433         NT_STATUS_HAVE_NO_MEMORY(server_dn_str);
1434
1435         ret = ldb_add(s->ldap1.ldb, msg);
1436         talloc_free(msg);
1437         if (ret != LDB_SUCCESS) {
1438                 talloc_free(server_dn_str);
1439                 return NT_STATUS_LDAP(ret);
1440         }
1441
1442         s->dest_dsa.server_dn_str = server_dn_str;
1443
1444         return NT_STATUS_OK;
1445 }
1446
1447 static NTSTATUS becomeDC_ldap1_server_object_modify(struct libnet_BecomeDC_state *s)
1448 {
1449         int ret;
1450         struct ldb_message *msg;
1451         unsigned int i;
1452
1453         /* make a 'modify' msg, and only for serverReference */
1454         msg = ldb_msg_new(s);
1455         NT_STATUS_HAVE_NO_MEMORY(msg);
1456         msg->dn = ldb_dn_new(msg, s->ldap1.ldb, s->dest_dsa.server_dn_str);
1457         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1458
1459         ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
1460         if (ret != 0) {
1461                 talloc_free(msg);
1462                 return NT_STATUS_NO_MEMORY;
1463         }
1464
1465         /* mark all the message elements (should be just one)
1466            as LDB_FLAG_MOD_ADD */
1467         for (i=0;i<msg->num_elements;i++) {
1468                 msg->elements[i].flags = LDB_FLAG_MOD_ADD;
1469         }
1470
1471         ret = ldb_modify(s->ldap1.ldb, msg);
1472         if (ret == LDB_SUCCESS) {
1473                 talloc_free(msg);
1474                 return NT_STATUS_OK;
1475         } else if (ret == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) {
1476                 /* retry with LDB_FLAG_MOD_REPLACE */
1477         } else {
1478                 talloc_free(msg);
1479                 return NT_STATUS_LDAP(ret);
1480         }
1481
1482         /* mark all the message elements (should be just one)
1483            as LDB_FLAG_MOD_REPLACE */
1484         for (i=0;i<msg->num_elements;i++) {
1485                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
1486         }
1487
1488         ret = ldb_modify(s->ldap1.ldb, msg);
1489         talloc_free(msg);
1490         if (ret != LDB_SUCCESS) {
1491                 return NT_STATUS_LDAP(ret);
1492         }
1493
1494         return NT_STATUS_OK;
1495 }
1496
1497 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
1498                                           struct becomeDC_drsuapi *drsuapi,
1499                                           void (*recv_fn)(struct composite_context *req));
1500 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req);
1501 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s);
1502
1503 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s)
1504 {
1505         struct composite_context *c = s->creq;
1506
1507         c->status = becomeDC_ldap_connect(s, &s->ldap1);
1508         if (!composite_is_ok(c)) return;
1509
1510         c->status = becomeDC_ldap1_rootdse(s);
1511         if (!composite_is_ok(c)) return;
1512
1513         c->status = becomeDC_ldap1_crossref_behavior_version(s);
1514         if (!composite_is_ok(c)) return;
1515
1516         c->status = becomeDC_ldap1_domain_behavior_version(s);
1517         if (!composite_is_ok(c)) return;
1518
1519         c->status = becomeDC_ldap1_schema_object_version(s);
1520         if (!composite_is_ok(c)) return;
1521
1522         c->status = becomeDC_ldap1_w2k3_update_revision(s);
1523         if (!composite_is_ok(c)) return;
1524
1525         c->status = becomeDC_ldap1_infrastructure_fsmo(s);
1526         if (!composite_is_ok(c)) return;
1527
1528         c->status = becomeDC_ldap1_rid_manager_fsmo(s);
1529         if (!composite_is_ok(c)) return;
1530
1531         c->status = becomeDC_ldap1_site_object(s);
1532         if (!composite_is_ok(c)) return;
1533
1534         c->status = becomeDC_check_options(s);
1535         if (!composite_is_ok(c)) return;
1536
1537         c->status = becomeDC_ldap1_computer_object(s);
1538         if (!composite_is_ok(c)) return;
1539
1540         c->status = becomeDC_ldap1_server_object_1(s);
1541         if (!composite_is_ok(c)) return;
1542
1543         c->status = becomeDC_ldap1_server_object_2(s);
1544         if (!composite_is_ok(c)) return;
1545
1546         c->status = becomeDC_ldap1_server_object_add(s);
1547         if (!composite_is_ok(c)) return;
1548
1549         c->status = becomeDC_ldap1_server_object_modify(s);
1550         if (!composite_is_ok(c)) return;
1551
1552         becomeDC_drsuapi_connect_send(s, &s->drsuapi1, becomeDC_drsuapi1_connect_recv);
1553 }
1554
1555 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
1556                                           struct becomeDC_drsuapi *drsuapi,
1557                                           void (*recv_fn)(struct composite_context *req))
1558 {
1559         struct composite_context *c = s->creq;
1560         struct composite_context *creq;
1561         char *binding_str;
1562
1563         drsuapi->s = s;
1564
1565         if (!drsuapi->binding) {
1566                 const char *krb5_str = "";
1567                 const char *print_str = "";
1568                 /*
1569                  * Note: Replication only works with Windows 2000 when 'krb5' is
1570                  *       passed as auth_type here. If NTLMSSP is used, Windows
1571                  *       2000 returns garbage in the DsGetNCChanges() response
1572                  *       if encrypted password attributes would be in the
1573                  *       response. That means the replication of the schema and
1574                  *       configuration partition works fine, but it fails for
1575                  *       the domain partition.
1576                  */
1577                 if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
1578                                  "force krb5", true))
1579                 {
1580                         krb5_str = "krb5,";
1581                 }
1582                 if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
1583                                  "print", false))
1584                 {
1585                         print_str = "print,";
1586                 }
1587                 binding_str = talloc_asprintf(s, "ncacn_ip_tcp:%s[%s%sseal]",
1588                                               s->source_dsa.dns_name,
1589                                               krb5_str, print_str);
1590                 if (composite_nomem(binding_str, c)) return;
1591                 c->status = dcerpc_parse_binding(s, binding_str, &drsuapi->binding);
1592                 talloc_free(binding_str);
1593                 if (!composite_is_ok(c)) return;
1594         }
1595
1596         creq = dcerpc_pipe_connect_b_send(s, drsuapi->binding, &ndr_table_drsuapi,
1597                                           s->libnet->cred, s->libnet->event_ctx,
1598                                           s->libnet->lp_ctx);
1599         composite_continue(c, creq, recv_fn, s);
1600 }
1601
1602 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
1603                                        struct becomeDC_drsuapi *drsuapi,
1604                                        void (*recv_fn)(struct tevent_req *subreq));
1605 static void becomeDC_drsuapi1_bind_recv(struct tevent_req *subreq);
1606
1607 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req)
1608 {
1609         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
1610                                           struct libnet_BecomeDC_state);
1611         struct composite_context *c = s->creq;
1612
1613         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi1.pipe);
1614         if (!composite_is_ok(c)) return;
1615
1616         s->drsuapi1.drsuapi_handle = s->drsuapi1.pipe->binding_handle;
1617
1618         c->status = gensec_session_key(s->drsuapi1.pipe->conn->security_state.generic_state,
1619                                        &s->drsuapi1.gensec_skey);
1620         if (!composite_is_ok(c)) return;
1621
1622         becomeDC_drsuapi_bind_send(s, &s->drsuapi1, becomeDC_drsuapi1_bind_recv);
1623 }
1624
1625 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
1626                                        struct becomeDC_drsuapi *drsuapi,
1627                                        void (*recv_fn)(struct tevent_req *subreq))
1628 {
1629         struct composite_context *c = s->creq;
1630         struct drsuapi_DsBindInfo28 *bind_info28;
1631         struct tevent_req *subreq;
1632
1633         GUID_from_string(DRSUAPI_DS_BIND_GUID_W2K3, &drsuapi->bind_guid);
1634
1635         bind_info28                             = &drsuapi->local_info28;
1636         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
1637         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION;
1638         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI;
1639         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2;
1640         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS;
1641         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1;
1642         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
1643         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
1644         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
1645         if (s->domain.behavior_version >= DS_DOMAIN_FUNCTION_2003) {
1646                 /* TODO: find out how this is really triggered! */
1647                 bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
1648         }
1649         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2;
1650         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD;
1651         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND;
1652         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO;
1653         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION;
1654         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01;
1655         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP;
1656         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
1657         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
1658         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5;
1659         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
1660         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
1661         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS;
1662         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8;
1663         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5;
1664         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6;
1665         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
1666         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
1667         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
1668 #if 0 /* we don't support XPRESS compression yet */
1669         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS;
1670 #endif
1671         bind_info28->site_guid                  = s->dest_dsa.site_guid;
1672         bind_info28->pid                        = 0;
1673         bind_info28->repl_epoch                 = 0;
1674
1675         drsuapi->bind_info_ctr.length           = 28;
1676         drsuapi->bind_info_ctr.info.info28      = *bind_info28;
1677
1678         drsuapi->bind_r.in.bind_guid = &drsuapi->bind_guid;
1679         drsuapi->bind_r.in.bind_info = &drsuapi->bind_info_ctr;
1680         drsuapi->bind_r.out.bind_handle = &drsuapi->bind_handle;
1681
1682         subreq = dcerpc_drsuapi_DsBind_r_send(s, c->event_ctx,
1683                                               drsuapi->drsuapi_handle,
1684                                               &drsuapi->bind_r);
1685         if (composite_nomem(subreq, c)) return;
1686         tevent_req_set_callback(subreq, recv_fn, s);
1687 }
1688
1689 static WERROR becomeDC_drsuapi_bind_recv(struct libnet_BecomeDC_state *s,
1690                                          struct becomeDC_drsuapi *drsuapi)
1691 {
1692         if (!W_ERROR_IS_OK(drsuapi->bind_r.out.result)) {
1693                 return drsuapi->bind_r.out.result;
1694         }
1695
1696         ZERO_STRUCT(drsuapi->remote_info28);
1697         if (drsuapi->bind_r.out.bind_info) {
1698                 switch (drsuapi->bind_r.out.bind_info->length) {
1699                 case 24: {
1700                         struct drsuapi_DsBindInfo24 *info24;
1701                         info24 = &drsuapi->bind_r.out.bind_info->info.info24;
1702                         drsuapi->remote_info28.supported_extensions     = info24->supported_extensions;
1703                         drsuapi->remote_info28.site_guid                = info24->site_guid;
1704                         drsuapi->remote_info28.pid                      = info24->pid;
1705                         drsuapi->remote_info28.repl_epoch               = 0;
1706                         break;
1707                 }
1708                 case 48: {
1709                         struct drsuapi_DsBindInfo48 *info48;
1710                         info48 = &drsuapi->bind_r.out.bind_info->info.info48;
1711                         drsuapi->remote_info28.supported_extensions     = info48->supported_extensions;
1712                         drsuapi->remote_info28.site_guid                = info48->site_guid;
1713                         drsuapi->remote_info28.pid                      = info48->pid;
1714                         drsuapi->remote_info28.repl_epoch               = info48->repl_epoch;
1715                         break;
1716                 }
1717                 case 28:
1718                         drsuapi->remote_info28 = drsuapi->bind_r.out.bind_info->info.info28;
1719                         break;
1720                 }
1721         }
1722
1723         return WERR_OK;
1724 }
1725
1726 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s);
1727
1728 static void becomeDC_drsuapi1_bind_recv(struct tevent_req *subreq)
1729 {
1730         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
1731                                           struct libnet_BecomeDC_state);
1732         struct composite_context *c = s->creq;
1733         WERROR status;
1734
1735         c->status = dcerpc_drsuapi_DsBind_r_recv(subreq, s);
1736         TALLOC_FREE(subreq);
1737         if (!composite_is_ok(c)) return;
1738
1739         status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi1);
1740         if (!W_ERROR_IS_OK(status)) {
1741                 composite_error(c, werror_to_ntstatus(status));
1742                 return;
1743         }
1744
1745         becomeDC_drsuapi1_add_entry_send(s);
1746 }
1747
1748 static void becomeDC_drsuapi1_add_entry_recv(struct tevent_req *subreq);
1749
1750 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s)
1751 {
1752         struct composite_context *c = s->creq;
1753         struct drsuapi_DsAddEntry *r;
1754         struct drsuapi_DsReplicaObjectIdentifier *identifier;
1755         uint32_t num_attrs, i = 0;
1756         struct drsuapi_DsReplicaAttribute *attrs;
1757         struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(s->libnet->lp_ctx);
1758         enum ndr_err_code ndr_err;
1759         bool w2k3;
1760         struct tevent_req *subreq;
1761
1762         /* choose a random invocationId */
1763         s->dest_dsa.invocation_id = GUID_random();
1764
1765         /*
1766          * if the schema version indicates w2k3, then also send some w2k3
1767          * specific attributes.
1768          */
1769         if (s->forest.schema_object_version >= 30) {
1770                 w2k3 = true;
1771         } else {
1772                 w2k3 = false;
1773         }
1774
1775         r = talloc_zero(s, struct drsuapi_DsAddEntry);
1776         if (composite_nomem(r, c)) return;
1777
1778         /* setup identifier */
1779         identifier              = talloc(r, struct drsuapi_DsReplicaObjectIdentifier);
1780         if (composite_nomem(identifier, c)) return;
1781         identifier->guid        = GUID_zero();
1782         identifier->sid         = s->zero_sid;
1783         identifier->dn          = talloc_asprintf(identifier, "CN=NTDS Settings,%s",
1784                                                   s->dest_dsa.server_dn_str);
1785         if (composite_nomem(identifier->dn, c)) return;
1786
1787         /* allocate attribute array */
1788         num_attrs       = 12;
1789         attrs           = talloc_array(r, struct drsuapi_DsReplicaAttribute, num_attrs);
1790         if (composite_nomem(attrs, c)) return;
1791
1792         /* ntSecurityDescriptor */
1793         {
1794                 struct drsuapi_DsAttributeValue *vs;
1795                 DATA_BLOB *vd;
1796                 struct security_descriptor *v;
1797                 struct dom_sid *domain_admins_sid;
1798                 const char *domain_admins_sid_str;
1799
1800                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1801                 if (composite_nomem(vs, c)) return;
1802
1803                 vd = talloc_array(vs, DATA_BLOB, 1);
1804                 if (composite_nomem(vd, c)) return;
1805
1806                 domain_admins_sid = dom_sid_add_rid(vs, s->domain.sid, DOMAIN_RID_ADMINS);
1807                 if (composite_nomem(domain_admins_sid, c)) return;
1808
1809                 domain_admins_sid_str = dom_sid_string(domain_admins_sid, domain_admins_sid);
1810                 if (composite_nomem(domain_admins_sid_str, c)) return;
1811
1812                 v = security_descriptor_dacl_create(vd,
1813                                                0,
1814                                                /* owner: domain admins */
1815                                                domain_admins_sid_str,
1816                                                /* owner group: domain admins */
1817                                                domain_admins_sid_str,
1818                                                /* authenticated users */
1819                                                SID_NT_AUTHENTICATED_USERS,
1820                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1821                                                SEC_STD_READ_CONTROL |
1822                                                SEC_ADS_LIST |
1823                                                SEC_ADS_READ_PROP |
1824                                                SEC_ADS_LIST_OBJECT,
1825                                                0,
1826                                                /* domain admins */
1827                                                domain_admins_sid_str,
1828                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1829                                                SEC_STD_REQUIRED |
1830                                                SEC_ADS_CREATE_CHILD |
1831                                                SEC_ADS_LIST |
1832                                                SEC_ADS_SELF_WRITE |
1833                                                SEC_ADS_READ_PROP |
1834                                                SEC_ADS_WRITE_PROP |
1835                                                SEC_ADS_DELETE_TREE |
1836                                                SEC_ADS_LIST_OBJECT |
1837                                                SEC_ADS_CONTROL_ACCESS,
1838                                                0,
1839                                                /* system */
1840                                                SID_NT_SYSTEM,
1841                                                SEC_ACE_TYPE_ACCESS_ALLOWED,
1842                                                SEC_STD_REQUIRED |
1843                                                SEC_ADS_CREATE_CHILD |
1844                                                SEC_ADS_DELETE_CHILD |
1845                                                SEC_ADS_LIST |
1846                                                SEC_ADS_SELF_WRITE |
1847                                                SEC_ADS_READ_PROP |
1848                                                SEC_ADS_WRITE_PROP |
1849                                                SEC_ADS_DELETE_TREE |
1850                                                SEC_ADS_LIST_OBJECT |
1851                                                SEC_ADS_CONTROL_ACCESS,
1852                                                0,
1853                                                /* end */
1854                                                NULL);
1855                 if (composite_nomem(v, c)) return;
1856
1857                 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, v,(ndr_push_flags_fn_t)ndr_push_security_descriptor);
1858                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1859                         c->status = ndr_map_error2ntstatus(ndr_err);
1860                         if (!composite_is_ok(c)) return;
1861                 }
1862
1863                 vs[0].blob              = &vd[0];
1864
1865                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_ntSecurityDescriptor;
1866                 attrs[i].value_ctr.num_values   = 1;
1867                 attrs[i].value_ctr.values       = vs;
1868
1869                 i++;
1870         }
1871
1872         /* objectClass: nTDSDSA */
1873         {
1874                 struct drsuapi_DsAttributeValue *vs;
1875                 DATA_BLOB *vd;
1876
1877                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1878                 if (composite_nomem(vs, c)) return;
1879
1880                 vd = talloc_array(vs, DATA_BLOB, 1);
1881                 if (composite_nomem(vd, c)) return;
1882
1883                 vd[0] = data_blob_talloc(vd, NULL, 4);
1884                 if (composite_nomem(vd[0].data, c)) return;
1885
1886                 /* value for nTDSDSA */
1887                 SIVAL(vd[0].data, 0, 0x0017002F);
1888
1889                 vs[0].blob              = &vd[0];
1890
1891                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_objectClass;
1892                 attrs[i].value_ctr.num_values   = 1;
1893                 attrs[i].value_ctr.values       = vs;
1894
1895                 i++;
1896         }
1897
1898         /* objectCategory: CN=NTDS-DSA,CN=Schema,... or CN=NTDS-DSA-RO,CN=Schema,... */
1899         {
1900                 struct drsuapi_DsAttributeValue *vs;
1901                 DATA_BLOB *vd;
1902                 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
1903
1904                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1905                 if (composite_nomem(vs, c)) return;
1906
1907                 vd = talloc_array(vs, DATA_BLOB, 1);
1908                 if (composite_nomem(vd, c)) return;
1909
1910                 v[0].guid               = GUID_zero();
1911                 v[0].sid                = s->zero_sid;
1912
1913                 if (s->rodc_join) {
1914                     v[0].dn             = talloc_asprintf(vd, "CN=NTDS-DSA-RO,%s",
1915                                                           s->forest.schema_dn_str);
1916                 } else {
1917                     v[0].dn             = talloc_asprintf(vd, "CN=NTDS-DSA,%s",
1918                                                           s->forest.schema_dn_str);
1919                 }
1920                 if (composite_nomem(v[0].dn, c)) return;
1921
1922                 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
1923                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1924                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1925                         c->status = ndr_map_error2ntstatus(ndr_err);
1926                         if (!composite_is_ok(c)) return;
1927                 }
1928
1929                 vs[0].blob              = &vd[0];
1930
1931                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_objectCategory;
1932                 attrs[i].value_ctr.num_values   = 1;
1933                 attrs[i].value_ctr.values       = vs;
1934
1935                 i++;
1936         }
1937
1938         /* invocationId: random guid */
1939         {
1940                 struct drsuapi_DsAttributeValue *vs;
1941                 DATA_BLOB *vd;
1942                 const struct GUID *v;
1943
1944                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1945                 if (composite_nomem(vs, c)) return;
1946
1947                 vd = talloc_array(vs, DATA_BLOB, 1);
1948                 if (composite_nomem(vd, c)) return;
1949
1950                 v = &s->dest_dsa.invocation_id;
1951
1952                 c->status = GUID_to_ndr_blob(v, vd, &vd[0]);
1953                 if (!composite_is_ok(c)) return;
1954
1955                 vs[0].blob              = &vd[0];
1956
1957                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_invocationId;
1958                 attrs[i].value_ctr.num_values   = 1;
1959                 attrs[i].value_ctr.values       = vs;
1960
1961                 i++;
1962         }
1963
1964         /* hasMasterNCs: ... */
1965         {
1966                 struct drsuapi_DsAttributeValue *vs;
1967                 DATA_BLOB *vd;
1968                 struct drsuapi_DsReplicaObjectIdentifier3 v[3];
1969
1970                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 3);
1971                 if (composite_nomem(vs, c)) return;
1972
1973                 vd = talloc_array(vs, DATA_BLOB, 3);
1974                 if (composite_nomem(vd, c)) return;
1975
1976                 v[0].guid               = GUID_zero();
1977                 v[0].sid                = s->zero_sid;
1978                 v[0].dn                 = s->forest.config_dn_str;
1979
1980                 v[1].guid               = GUID_zero();
1981                 v[1].sid                = s->zero_sid;
1982                 v[1].dn                 = s->domain.dn_str;
1983
1984                 v[2].guid               = GUID_zero();
1985                 v[2].sid                = s->zero_sid;
1986                 v[2].dn                 = s->forest.schema_dn_str;
1987
1988                 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
1989                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1990                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1991                         c->status = ndr_map_error2ntstatus(ndr_err);
1992                         if (!composite_is_ok(c)) return;
1993                 }
1994
1995                 ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
1996                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1997                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1998                         c->status = ndr_map_error2ntstatus(ndr_err);
1999                         if (!composite_is_ok(c)) return;
2000                 }
2001
2002                 ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
2003                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2004                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2005                         c->status = ndr_map_error2ntstatus(ndr_err);
2006                         if (!composite_is_ok(c)) return;
2007                 }
2008
2009                 vs[0].blob              = &vd[0];
2010                 vs[1].blob              = &vd[1];
2011                 vs[2].blob              = &vd[2];
2012
2013                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_hasMasterNCs;
2014                 attrs[i].value_ctr.num_values   = 3;
2015                 attrs[i].value_ctr.values       = vs;
2016
2017                 i++;
2018         }
2019
2020         /* msDS-hasMasterNCs: ... */
2021         if (w2k3) {
2022                 struct drsuapi_DsAttributeValue *vs;
2023                 DATA_BLOB *vd;
2024                 struct drsuapi_DsReplicaObjectIdentifier3 v[3];
2025
2026                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 3);
2027                 if (composite_nomem(vs, c)) return;
2028
2029                 vd = talloc_array(vs, DATA_BLOB, 3);
2030                 if (composite_nomem(vd, c)) return;
2031
2032                 v[0].guid               = GUID_zero();
2033                 v[0].sid                = s->zero_sid;
2034                 v[0].dn                 = s->forest.config_dn_str;
2035
2036                 v[1].guid               = GUID_zero();
2037                 v[1].sid                = s->zero_sid;
2038                 v[1].dn                 = s->domain.dn_str;
2039
2040                 v[2].guid               = GUID_zero();
2041                 v[2].sid                = s->zero_sid;
2042                 v[2].dn                 = s->forest.schema_dn_str;
2043
2044                 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2045                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2046                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2047                         c->status = ndr_map_error2ntstatus(ndr_err);
2048                         if (!composite_is_ok(c)) return;
2049                 }
2050
2051                 ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
2052                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2053                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2054                         c->status = ndr_map_error2ntstatus(ndr_err);
2055                         if (!composite_is_ok(c)) return;
2056                 }
2057
2058                 ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
2059                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2060                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2061                         c->status = ndr_map_error2ntstatus(ndr_err);
2062                         if (!composite_is_ok(c)) return;
2063                 }
2064
2065                 vs[0].blob              = &vd[0];
2066                 vs[1].blob              = &vd[1];
2067                 vs[2].blob              = &vd[2];
2068
2069                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs;
2070                 attrs[i].value_ctr.num_values   = 3;
2071                 attrs[i].value_ctr.values       = vs;
2072
2073                 i++;
2074         }
2075
2076         /* dMDLocation: CN=Schema,... */
2077         {
2078                 struct drsuapi_DsAttributeValue *vs;
2079                 DATA_BLOB *vd;
2080                 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2081
2082                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2083                 if (composite_nomem(vs, c)) return;
2084
2085                 vd = talloc_array(vs, DATA_BLOB, 1);
2086                 if (composite_nomem(vd, c)) return;
2087
2088                 v[0].guid               = GUID_zero();
2089                 v[0].sid                = s->zero_sid;
2090                 v[0].dn                 = s->forest.schema_dn_str;
2091
2092                 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2093                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2094                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2095                         c->status = ndr_map_error2ntstatus(ndr_err);
2096                         if (!composite_is_ok(c)) return;
2097                 }
2098
2099                 vs[0].blob              = &vd[0];
2100
2101                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_dMDLocation;
2102                 attrs[i].value_ctr.num_values   = 1;
2103                 attrs[i].value_ctr.values       = vs;
2104
2105                 i++;
2106         }
2107
2108         /* msDS-HasDomainNCs: <domain_partition> */
2109         if (w2k3) {
2110                 struct drsuapi_DsAttributeValue *vs;
2111                 DATA_BLOB *vd;
2112                 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2113
2114                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2115                 if (composite_nomem(vs, c)) return;
2116
2117                 vd = talloc_array(vs, DATA_BLOB, 1);
2118                 if (composite_nomem(vd, c)) return;
2119
2120                 v[0].guid               = GUID_zero();
2121                 v[0].sid                = s->zero_sid;
2122                 v[0].dn                 = s->domain.dn_str;
2123
2124                 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2125                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2126                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2127                         c->status = ndr_map_error2ntstatus(ndr_err);
2128                         if (!composite_is_ok(c)) return;
2129                 }
2130
2131                 vs[0].blob              = &vd[0];
2132
2133                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs;
2134                 attrs[i].value_ctr.num_values   = 1;
2135                 attrs[i].value_ctr.values       = vs;
2136
2137                 i++;
2138         }
2139
2140         /* msDS-Behavior-Version */
2141         if (w2k3) {
2142                 struct drsuapi_DsAttributeValue *vs;
2143                 DATA_BLOB *vd;
2144
2145                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2146                 if (composite_nomem(vs, c)) return;
2147
2148                 vd = talloc_array(vs, DATA_BLOB, 1);
2149                 if (composite_nomem(vd, c)) return;
2150
2151                 vd[0] = data_blob_talloc(vd, NULL, 4);
2152                 if (composite_nomem(vd[0].data, c)) return;
2153
2154                 SIVAL(vd[0].data, 0, get_dc_function_level(s->libnet->lp_ctx));
2155
2156                 vs[0].blob              = &vd[0];
2157
2158                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_msDS_Behavior_Version;
2159                 attrs[i].value_ctr.num_values   = 1;
2160                 attrs[i].value_ctr.values       = vs;
2161
2162                 i++;
2163         }
2164
2165         /* systemFlags */
2166         {
2167                 struct drsuapi_DsAttributeValue *vs;
2168                 DATA_BLOB *vd;
2169
2170                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2171                 if (composite_nomem(vs, c)) return;
2172
2173                 vd = talloc_array(vs, DATA_BLOB, 1);
2174                 if (composite_nomem(vd, c)) return;
2175
2176                 vd[0] = data_blob_talloc(vd, NULL, 4);
2177                 if (composite_nomem(vd[0].data, c)) return;
2178
2179                 if (s->rodc_join) {
2180                     SIVAL(vd[0].data, 0, SYSTEM_FLAG_CONFIG_ALLOW_RENAME);
2181                 } else {
2182                     SIVAL(vd[0].data, 0, SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
2183                 }
2184
2185                 vs[0].blob              = &vd[0];
2186
2187                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_systemFlags;
2188                 attrs[i].value_ctr.num_values   = 1;
2189                 attrs[i].value_ctr.values       = vs;
2190
2191                 i++;
2192         }
2193
2194         /* serverReference: ... */
2195         {
2196                 struct drsuapi_DsAttributeValue *vs;
2197                 DATA_BLOB *vd;
2198                 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2199
2200                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2201                 if (composite_nomem(vs, c)) return;
2202
2203                 vd = talloc_array(vs, DATA_BLOB, 1);
2204                 if (composite_nomem(vd, c)) return;
2205
2206                 v[0].guid               = GUID_zero();
2207                 v[0].sid                = s->zero_sid;
2208                 v[0].dn                 = s->dest_dsa.computer_dn_str;
2209
2210                 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2211                                                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2212                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2213                         c->status = ndr_map_error2ntstatus(ndr_err);
2214                         if (!composite_is_ok(c)) return;
2215                 }
2216
2217                 vs[0].blob              = &vd[0];
2218
2219                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_serverReference;
2220                 attrs[i].value_ctr.num_values   = 1;
2221                 attrs[i].value_ctr.values       = vs;
2222
2223                 i++;
2224         }
2225
2226         /* options:... */
2227         if (s->rodc_join) {
2228                 struct drsuapi_DsAttributeValue *vs;
2229                 DATA_BLOB *vd;
2230
2231                 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2232                 if (composite_nomem(vs, c)) return;
2233
2234                 vd = talloc_array(vs, DATA_BLOB, 1);
2235                 if (composite_nomem(vd, c)) return;
2236
2237                 vd[0] = data_blob_talloc(vd, NULL, 4);
2238                 if (composite_nomem(vd[0].data, c)) return;
2239
2240                 SIVAL(vd[0].data, 0, DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL);
2241
2242                 vs[0].blob              = &vd[0];
2243
2244                 attrs[i].attid                  = DRSUAPI_ATTRIBUTE_options;
2245                 attrs[i].value_ctr.num_values   = 1;
2246                 attrs[i].value_ctr.values       = vs;
2247
2248                 i++;
2249         }
2250
2251         /* truncate the attribute list to the attribute count we have filled in */
2252         num_attrs = i;
2253
2254         /* setup request structure */
2255         r->in.bind_handle                                               = &s->drsuapi1.bind_handle;
2256         r->in.level                                                     = 2;
2257         r->in.req                                                       = talloc(s, union drsuapi_DsAddEntryRequest);
2258         r->in.req->req2.first_object.next_object                        = NULL;
2259         r->in.req->req2.first_object.object.identifier                  = identifier;
2260         r->in.req->req2.first_object.object.flags                       = 0x00000000;
2261         r->in.req->req2.first_object.object.attribute_ctr.num_attributes= num_attrs;
2262         r->in.req->req2.first_object.object.attribute_ctr.attributes    = attrs;
2263
2264         r->out.level_out        = talloc(s, uint32_t);
2265         r->out.ctr              = talloc(s, union drsuapi_DsAddEntryCtr);
2266
2267         s->ndr_struct_ptr = r;
2268         subreq = dcerpc_drsuapi_DsAddEntry_r_send(s, c->event_ctx,
2269                                                   s->drsuapi1.drsuapi_handle, r);
2270         if (composite_nomem(subreq, c)) return;
2271         tevent_req_set_callback(subreq, becomeDC_drsuapi1_add_entry_recv, s);
2272 }
2273
2274 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req);
2275 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s);
2276
2277 static void becomeDC_drsuapi1_add_entry_recv(struct tevent_req *subreq)
2278 {
2279         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2280                                           struct libnet_BecomeDC_state);
2281         struct composite_context *c = s->creq;
2282         struct drsuapi_DsAddEntry *r = talloc_get_type_abort(s->ndr_struct_ptr,
2283                                        struct drsuapi_DsAddEntry);
2284         char *binding_str;
2285
2286         s->ndr_struct_ptr = NULL;
2287
2288         c->status = dcerpc_drsuapi_DsAddEntry_r_recv(subreq, r);
2289         TALLOC_FREE(subreq);
2290         if (!composite_is_ok(c)) return;
2291
2292         if (!W_ERROR_IS_OK(r->out.result)) {
2293                 composite_error(c, werror_to_ntstatus(r->out.result));
2294                 return;
2295         }
2296
2297         if (*r->out.level_out == 3) {
2298                 WERROR status;
2299                 union drsuapi_DsAddEntry_ErrData *err_data = r->out.ctr->ctr3.err_data;
2300
2301                 /* check for errors */
2302                 status = err_data ? err_data->v1.status : WERR_OK;
2303                 if (!W_ERROR_IS_OK(status)) {
2304                         struct drsuapi_DsAddEntryErrorInfo_Attr_V1 *attr_err;
2305                         struct drsuapi_DsAddEntry_AttrErrListItem_V1 *attr_err_li;
2306                         struct drsuapi_DsAddEntryErrorInfo_Name_V1 *name_err;
2307                         struct drsuapi_DsAddEntryErrorInfo_Referr_V1 *ref_err;
2308                         struct drsuapi_DsAddEntry_RefErrListItem_V1 *ref_li;
2309
2310                         if (r->out.ctr->ctr3.err_ver != 1) {
2311                                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2312                                 return;
2313                         }
2314
2315                         DEBUG(0,("DsAddEntry (R3) failed: "
2316                                  "Errors: dir_err = %d, status = %s;\n",
2317                                  err_data->v1.dir_err,
2318                                  win_errstr(err_data->v1.status)));
2319
2320                         if (!err_data->v1.info) {
2321                                 DEBUG(0, ("DsAddEntry (R3): no error info returned!\n"));
2322                                 composite_error(c, werror_to_ntstatus(status));
2323                                 return;
2324                         }
2325
2326                         /* dump more detailed error */
2327                         switch (err_data->v1.dir_err) {
2328                         case DRSUAPI_DIRERR_ATTRIBUTE:
2329                                 /* Dump attribute errors */
2330                                 attr_err = &err_data->v1.info->attr_err;
2331                                 DEBUGADD(0,(" Attribute Error: object = %s, count = %d;\n",
2332                                             attr_err->id->dn,
2333                                             attr_err->count));
2334                                 attr_err_li = &attr_err->first;
2335                                 for (; attr_err_li; attr_err_li = attr_err_li->next) {
2336                                         struct drsuapi_DsAddEntry_AttrErr_V1 *err = &attr_err_li->err_data;
2337                                         DEBUGADD(0,(" Error: err = %s, problem = 0x%08X, attid = 0x%08X;\n",
2338                                                     win_errstr(err->extended_err),
2339                                                     err->problem,
2340                                                     err->attid));
2341                                         /* TODO: should we print attribute value here? */
2342                                 }
2343                                 break;
2344                         case DRSUAPI_DIRERR_NAME:
2345                                 /* Dump Name resolution error */
2346                                 name_err = &err_data->v1.info->name_err;
2347                                 DEBUGADD(0,(" Name Error: err = %s, problem = 0x%08X, id_matched = %s;\n",
2348                                             win_errstr(name_err->extended_err),
2349                                             name_err->problem,
2350                                             name_err->id_matched->dn));
2351                                 break;
2352                         case DRSUAPI_DIRERR_REFERRAL:
2353                                 /* Dump Referral errors */
2354                                 ref_err = &err_data->v1.info->referral_err;
2355                                 DEBUGADD(0,(" Referral Error: extended_err = %s\n",
2356                                             win_errstr(ref_err->extended_err)));
2357                                 ref_li = &ref_err->refer;
2358                                 for (; ref_li; ref_li = ref_li->next) {
2359                                         struct drsuapi_DsaAddressListItem_V1 *addr;
2360                                         DEBUGADD(0,(" Referral: id_target = %s, ref_type = 0x%04X,",
2361                                                     ref_li->id_target->dn,
2362                                                     ref_li->ref_type));
2363                                         if (ref_li->is_choice_set) {
2364                                                 DEBUGADD(0,(" choice = 0x%02X, ",
2365                                                             ref_li->choice));
2366                                         }
2367                                         DEBUGADD(0,(" add_list ("));
2368                                         for (addr = ref_li->addr_list; addr; addr = addr->next) {
2369                                                 DEBUGADD(0,("%s", addr->address->string));
2370                                                 if (addr->next) {
2371                                                         DEBUGADD(0,(", "));
2372                                                 }
2373                                         }
2374                                         DEBUGADD(0,(");\n"));
2375                                 }
2376                                 break;
2377                         case DRSUAPI_DIRERR_SECURITY:
2378                                 /* Dump Security error. */
2379                                 DEBUGADD(0,(" Security Error: extended_err = %s, problem = 0x%08X\n",
2380                                             win_errstr(err_data->v1.info->security_err.extended_err),
2381                                             err_data->v1.info->security_err.problem));
2382                                 break;
2383                         case DRSUAPI_DIRERR_SERVICE:
2384                                 /* Dump Service error. */
2385                                 DEBUGADD(0,(" Service Error: extended_err = %s, problem = 0x%08X\n",
2386                                             win_errstr(err_data->v1.info->service_err.extended_err),
2387                                             err_data->v1.info->service_err.problem));
2388                                 break;
2389                         case DRSUAPI_DIRERR_UPDATE:
2390                                 /* Dump Update error. */
2391                                 DEBUGADD(0,(" Update Error: extended_err = %s, problem = 0x%08X\n",
2392                                             win_errstr(err_data->v1.info->update_err.extended_err),
2393                                             err_data->v1.info->update_err.problem));
2394                                 break;
2395                         case DRSUAPI_DIRERR_SYSTEM:
2396                                 /* System error. */
2397                                 DEBUGADD(0,(" System Error: extended_err = %s, problem = 0x%08X\n",
2398                                             win_errstr(err_data->v1.info->system_err.extended_err),
2399                                             err_data->v1.info->system_err.problem));
2400                                 break;
2401                         case DRSUAPI_DIRERR_OK: /* mute compiler warnings */
2402                         default:
2403                                 DEBUGADD(0,(" Unknown DIRERR error class returned!\n"));
2404                                 break;
2405                         }
2406
2407                         composite_error(c, werror_to_ntstatus(status));
2408                         return;
2409                 }
2410
2411                 if (1 != r->out.ctr->ctr3.count) {
2412                         DEBUG(0,("DsAddEntry - Ctr3: something very wrong had happened - "
2413                                  "method succeeded but objects returned are %d (expected 1).\n",
2414                                  r->out.ctr->ctr3.count));
2415                         composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2416                 }
2417
2418                 s->dest_dsa.ntds_guid   = r->out.ctr->ctr3.objects[0].guid;
2419
2420         } else if (*r->out.level_out == 2) {
2421                 if (DRSUAPI_DIRERR_OK != r->out.ctr->ctr2.dir_err) {
2422                         DEBUG(0,("DsAddEntry failed with: dir_err = %d, extended_err = %s\n",
2423                                  r->out.ctr->ctr2.dir_err,
2424                                  win_errstr(r->out.ctr->ctr2.extended_err)));
2425                         composite_error(c, werror_to_ntstatus(r->out.ctr->ctr2.extended_err));
2426                         return;
2427                 }
2428
2429                 if (1 != r->out.ctr->ctr2.count) {
2430                         DEBUG(0,("DsAddEntry: something very wrong had happened - "
2431                                  "method succeeded but objects returned are %d (expected 1). "
2432                                  "Errors: dir_err = %d, extended_err = %s\n",
2433                                  r->out.ctr->ctr2.count,
2434                                  r->out.ctr->ctr2.dir_err,
2435                                  win_errstr(r->out.ctr->ctr2.extended_err)));
2436                         composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2437                 }
2438
2439                 s->dest_dsa.ntds_guid   = r->out.ctr->ctr2.objects[0].guid;
2440         } else {
2441                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2442                 return;
2443         }
2444
2445         talloc_free(r);
2446
2447         s->dest_dsa.ntds_dn_str = talloc_asprintf(s, "CN=NTDS Settings,%s",
2448                                                   s->dest_dsa.server_dn_str);
2449         if (composite_nomem(s->dest_dsa.ntds_dn_str, c)) return;
2450
2451         c->status = becomeDC_prepare_db(s);
2452         if (!composite_is_ok(c)) return;
2453
2454         /* this avoids the epmapper lookup on the 2nd connection */
2455         binding_str = dcerpc_binding_string(s, s->drsuapi1.binding);
2456         if (composite_nomem(binding_str, c)) return;
2457
2458         c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi2.binding);
2459         talloc_free(binding_str);
2460         if (!composite_is_ok(c)) return;
2461
2462         /* w2k3 uses the same assoc_group_id as on the first connection, so we do */
2463         s->drsuapi2.binding->assoc_group_id     = s->drsuapi1.pipe->assoc_group_id;
2464
2465         becomeDC_drsuapi_connect_send(s, &s->drsuapi2, becomeDC_drsuapi2_connect_recv);
2466 }
2467
2468 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s)
2469 {
2470         if (!s->callbacks.prepare_db) return NT_STATUS_OK;
2471
2472         s->_pp.domain           = &s->domain;
2473         s->_pp.forest           = &s->forest;
2474         s->_pp.source_dsa       = &s->source_dsa;
2475         s->_pp.dest_dsa         = &s->dest_dsa;
2476
2477         return s->callbacks.prepare_db(s->callbacks.private_data, &s->_pp);
2478 }
2479
2480 static void becomeDC_drsuapi2_bind_recv(struct tevent_req *subreq);
2481
2482 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req)
2483 {
2484         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2485                                           struct libnet_BecomeDC_state);
2486         struct composite_context *c = s->creq;
2487
2488         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi2.pipe);
2489         if (!composite_is_ok(c)) return;
2490
2491         s->drsuapi2.drsuapi_handle = s->drsuapi2.pipe->binding_handle;
2492
2493         c->status = gensec_session_key(s->drsuapi2.pipe->conn->security_state.generic_state,
2494                                        &s->drsuapi2.gensec_skey);
2495         if (!composite_is_ok(c)) return;
2496
2497         becomeDC_drsuapi_bind_send(s, &s->drsuapi2, becomeDC_drsuapi2_bind_recv);
2498 }
2499
2500 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req);
2501
2502 static void becomeDC_drsuapi2_bind_recv(struct tevent_req *subreq)
2503 {
2504         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2505                                           struct libnet_BecomeDC_state);
2506         struct composite_context *c = s->creq;
2507         char *binding_str;
2508         WERROR status;
2509
2510         c->status = dcerpc_drsuapi_DsBind_r_recv(subreq, s);
2511         TALLOC_FREE(subreq);
2512         if (!composite_is_ok(c)) return;
2513
2514         status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi2);
2515         if (!W_ERROR_IS_OK(status)) {
2516                 composite_error(c, werror_to_ntstatus(status));
2517                 return;
2518         }
2519
2520         /* this avoids the epmapper lookup on the 3rd connection */
2521         binding_str = dcerpc_binding_string(s, s->drsuapi1.binding);
2522         if (composite_nomem(binding_str, c)) return;
2523
2524         c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi3.binding);
2525         talloc_free(binding_str);
2526         if (!composite_is_ok(c)) return;
2527
2528         /* w2k3 uses the same assoc_group_id as on the first connection, so we do */
2529         s->drsuapi3.binding->assoc_group_id     = s->drsuapi1.pipe->assoc_group_id;
2530         /* w2k3 uses the concurrent multiplex feature on the 3rd connection, so we do */
2531         s->drsuapi3.binding->flags              |= DCERPC_CONCURRENT_MULTIPLEX;
2532
2533         becomeDC_drsuapi_connect_send(s, &s->drsuapi3, becomeDC_drsuapi3_connect_recv);
2534 }
2535
2536 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s);
2537
2538 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req)
2539 {
2540         struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2541                                           struct libnet_BecomeDC_state);
2542         struct composite_context *c = s->creq;
2543
2544         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi3.pipe);
2545         if (!composite_is_ok(c)) return;
2546
2547         s->drsuapi3.drsuapi_handle = s->drsuapi3.pipe->binding_handle;
2548
2549         c->status = gensec_session_key(s->drsuapi3.pipe->conn->security_state.generic_state,
2550                                        &s->drsuapi3.gensec_skey);
2551         if (!composite_is_ok(c)) return;
2552
2553         becomeDC_drsuapi3_pull_schema_send(s);
2554 }
2555
2556 static void becomeDC_drsuapi_pull_partition_send(struct libnet_BecomeDC_state *s,
2557                                                  struct becomeDC_drsuapi *drsuapi_h,
2558                                                  struct becomeDC_drsuapi *drsuapi_p,
2559                                                  struct libnet_BecomeDC_Partition *partition,
2560                                                  void (*recv_fn)(struct tevent_req *subreq))
2561 {
2562         struct composite_context *c = s->creq;
2563         struct drsuapi_DsGetNCChanges *r;
2564         struct tevent_req *subreq;
2565
2566         r = talloc(s, struct drsuapi_DsGetNCChanges);
2567         if (composite_nomem(r, c)) return;
2568
2569         r->out.level_out = talloc(r, uint32_t);
2570         if (composite_nomem(r->out.level_out, c)) return;
2571         r->in.req = talloc(r, union drsuapi_DsGetNCChangesRequest);
2572         if (composite_nomem(r->in.req, c)) return;
2573         r->out.ctr = talloc(r, union drsuapi_DsGetNCChangesCtr);
2574         if (composite_nomem(r->out.ctr, c)) return;
2575
2576         r->in.bind_handle       = &drsuapi_h->bind_handle;
2577         if (drsuapi_h->remote_info28.supported_extensions & DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8) {
2578                 r->in.level                             = 8;
2579                 r->in.req->req8.destination_dsa_guid    = partition->destination_dsa_guid;
2580                 r->in.req->req8.source_dsa_invocation_id= partition->source_dsa_invocation_id;
2581                 r->in.req->req8.naming_context          = &partition->nc;
2582                 r->in.req->req8.highwatermark           = partition->highwatermark;
2583                 r->in.req->req8.uptodateness_vector     = NULL;
2584                 r->in.req->req8.replica_flags           = partition->replica_flags;
2585                 r->in.req->req8.max_object_count        = 133;
2586                 r->in.req->req8.max_ndr_size            = 1336811;
2587                 r->in.req->req8.extended_op             = DRSUAPI_EXOP_NONE;
2588                 r->in.req->req8.fsmo_info               = 0;
2589                 r->in.req->req8.partial_attribute_set   = NULL;
2590                 r->in.req->req8.partial_attribute_set_ex= NULL;
2591                 r->in.req->req8.mapping_ctr.num_mappings= 0;
2592                 r->in.req->req8.mapping_ctr.mappings    = NULL;
2593         } else {
2594                 r->in.level                             = 5;
2595                 r->in.req->req5.destination_dsa_guid    = partition->destination_dsa_guid;
2596                 r->in.req->req5.source_dsa_invocation_id= partition->source_dsa_invocation_id;
2597                 r->in.req->req5.naming_context          = &partition->nc;
2598                 r->in.req->req5.highwatermark           = partition->highwatermark;
2599                 r->in.req->req5.uptodateness_vector     = NULL;
2600                 r->in.req->req5.replica_flags           = partition->replica_flags;
2601                 r->in.req->req5.max_object_count        = 133;
2602                 r->in.req->req5.max_ndr_size            = 1336770;
2603                 r->in.req->req5.extended_op             = DRSUAPI_EXOP_NONE;
2604                 r->in.req->req5.fsmo_info               = 0;
2605         }
2606
2607         /*
2608          * we should try to use the drsuapi_p->pipe here, as w2k3 does
2609          * but it seems that some extra flags in the DCERPC Bind call
2610          * are needed for it. Or the same KRB5 TGS is needed on both
2611          * connections.
2612          */
2613         s->ndr_struct_ptr = r;
2614         subreq = dcerpc_drsuapi_DsGetNCChanges_r_send(s, c->event_ctx,
2615                                                       drsuapi_p->drsuapi_handle,
2616                                                       r);
2617         if (composite_nomem(subreq, c)) return;
2618         tevent_req_set_callback(subreq, recv_fn, s);
2619 }
2620
2621 static WERROR becomeDC_drsuapi_pull_partition_recv(struct libnet_BecomeDC_state *s,
2622                                                    struct becomeDC_drsuapi *drsuapi_h,
2623                                                    struct becomeDC_drsuapi *drsuapi_p,
2624                                                    struct libnet_BecomeDC_Partition *partition,
2625                                                    struct drsuapi_DsGetNCChanges *r)
2626 {
2627         uint32_t ctr_level = 0;
2628         struct drsuapi_DsGetNCChangesCtr1 *ctr1 = NULL;
2629         struct drsuapi_DsGetNCChangesCtr6 *ctr6 = NULL;
2630         struct GUID *source_dsa_guid = NULL;
2631         struct GUID *source_dsa_invocation_id = NULL;
2632         struct drsuapi_DsReplicaHighWaterMark *new_highwatermark = NULL;
2633         bool more_data = false;
2634         NTSTATUS nt_status;
2635
2636         if (!W_ERROR_IS_OK(r->out.result)) {
2637                 return r->out.result;
2638         }
2639
2640         if (*r->out.level_out == 1) {
2641                 ctr_level = 1;
2642                 ctr1 = &r->out.ctr->ctr1;
2643         } else if (*r->out.level_out == 2 &&
2644                    r->out.ctr->ctr2.mszip1.ts) {
2645                 ctr_level = 1;
2646                 ctr1 = &r->out.ctr->ctr2.mszip1.ts->ctr1;
2647         } else if (*r->out.level_out == 6) {
2648                 ctr_level = 6;
2649                 ctr6 = &r->out.ctr->ctr6;
2650         } else if (*r->out.level_out == 7 &&
2651                    r->out.ctr->ctr7.level == 6 &&
2652                    r->out.ctr->ctr7.type == DRSUAPI_COMPRESSION_TYPE_MSZIP &&
2653                    r->out.ctr->ctr7.ctr.mszip6.ts) {
2654                 ctr_level = 6;
2655                 ctr6 = &r->out.ctr->ctr7.ctr.mszip6.ts->ctr6;
2656         } else if (*r->out.level_out == 7 &&
2657                    r->out.ctr->ctr7.level == 6 &&
2658                    r->out.ctr->ctr7.type == DRSUAPI_COMPRESSION_TYPE_XPRESS &&
2659                    r->out.ctr->ctr7.ctr.xpress6.ts) {
2660                 ctr_level = 6;
2661                 ctr6 = &r->out.ctr->ctr7.ctr.xpress6.ts->ctr6;
2662         } else {
2663                 return WERR_BAD_NET_RESP;
2664         }
2665
2666         if (!ctr1 && ! ctr6) {
2667                 return WERR_BAD_NET_RESP;
2668         }
2669
2670         if (ctr_level == 6) {
2671                 if (!W_ERROR_IS_OK(ctr6->drs_error)) {
2672                         return ctr6->drs_error;
2673                 }
2674         }
2675
2676         switch (ctr_level) {
2677         case 1:
2678                 source_dsa_guid                 = &ctr1->source_dsa_guid;
2679                 source_dsa_invocation_id        = &ctr1->source_dsa_invocation_id;
2680                 new_highwatermark               = &ctr1->new_highwatermark;
2681                 more_data                       = ctr1->more_data;
2682                 break;
2683         case 6:
2684                 source_dsa_guid                 = &ctr6->source_dsa_guid;
2685                 source_dsa_invocation_id        = &ctr6->source_dsa_invocation_id;
2686                 new_highwatermark               = &ctr6->new_highwatermark;
2687                 more_data                       = ctr6->more_data;
2688                 break;
2689         }
2690
2691         partition->highwatermark                = *new_highwatermark;
2692         partition->source_dsa_guid              = *source_dsa_guid;
2693         partition->source_dsa_invocation_id     = *source_dsa_invocation_id;
2694         partition->more_data                    = more_data;
2695
2696         if (!partition->store_chunk) return WERR_OK;
2697
2698         s->_sc.domain           = &s->domain;
2699         s->_sc.forest           = &s->forest;
2700         s->_sc.source_dsa       = &s->source_dsa;
2701         s->_sc.dest_dsa         = &s->dest_dsa;
2702         s->_sc.partition        = partition;
2703         s->_sc.ctr_level        = ctr_level;
2704         s->_sc.ctr1             = ctr1;
2705         s->_sc.ctr6             = ctr6;
2706         /*
2707          * we need to use the drsuapi_p->gensec_skey here,
2708          * when we use drsuapi_p->pipe in the for this request
2709          */
2710         s->_sc.gensec_skey      = &drsuapi_p->gensec_skey;
2711
2712         nt_status = partition->store_chunk(s->callbacks.private_data, &s->_sc);
2713         if (!NT_STATUS_IS_OK(nt_status)) {
2714                 return ntstatus_to_werror(nt_status);
2715         }
2716
2717         return WERR_OK;
2718 }
2719
2720 static void becomeDC_drsuapi3_pull_schema_recv(struct tevent_req *subreq);
2721
2722 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s)
2723 {
2724         s->schema_part.nc.guid  = GUID_zero();
2725         s->schema_part.nc.sid   = s->zero_sid;
2726         s->schema_part.nc.dn    = s->forest.schema_dn_str;
2727
2728         s->schema_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
2729
2730         s->schema_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
2731                                         | DRSUAPI_DRS_INIT_SYNC
2732                                         | DRSUAPI_DRS_PER_SYNC
2733                                         | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
2734                                         | DRSUAPI_DRS_NEVER_SYNCED
2735                                         | DRSUAPI_DRS_USE_COMPRESSION;
2736         if (s->rodc_join) {
2737             s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
2738         }
2739
2740         s->schema_part.store_chunk      = s->callbacks.schema_chunk;
2741
2742         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
2743                                              becomeDC_drsuapi3_pull_schema_recv);
2744 }
2745
2746 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s);
2747
2748 static void becomeDC_drsuapi3_pull_schema_recv(struct tevent_req *subreq)
2749 {
2750         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2751                                           struct libnet_BecomeDC_state);
2752         struct composite_context *c = s->creq;
2753         struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
2754                                            struct drsuapi_DsGetNCChanges);
2755         WERROR status;
2756
2757         s->ndr_struct_ptr = NULL;
2758
2759         c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
2760         TALLOC_FREE(subreq);
2761         if (!composite_is_ok(c)) return;
2762
2763         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part, r);
2764         if (!W_ERROR_IS_OK(status)) {
2765                 composite_error(c, werror_to_ntstatus(status));
2766                 return;
2767         }
2768
2769         talloc_free(r);
2770
2771         if (s->schema_part.more_data) {
2772                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
2773                                                      becomeDC_drsuapi3_pull_schema_recv);
2774                 return;
2775         }
2776
2777         becomeDC_drsuapi3_pull_config_send(s);
2778 }
2779
2780 static void becomeDC_drsuapi3_pull_config_recv(struct tevent_req *subreq);
2781
2782 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s)
2783 {
2784         s->config_part.nc.guid  = GUID_zero();
2785         s->config_part.nc.sid   = s->zero_sid;
2786         s->config_part.nc.dn    = s->forest.config_dn_str;
2787
2788         s->config_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
2789
2790         s->config_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
2791                                         | DRSUAPI_DRS_INIT_SYNC
2792                                         | DRSUAPI_DRS_PER_SYNC
2793                                         | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
2794                                         | DRSUAPI_DRS_NEVER_SYNCED
2795                                         | DRSUAPI_DRS_USE_COMPRESSION;
2796         if (s->rodc_join) {
2797             s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
2798         }
2799
2800         s->config_part.store_chunk      = s->callbacks.config_chunk;
2801
2802         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
2803                                              becomeDC_drsuapi3_pull_config_recv);
2804 }
2805
2806 static void becomeDC_drsuapi3_pull_config_recv(struct tevent_req *subreq)
2807 {
2808         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2809                                           struct libnet_BecomeDC_state);
2810         struct composite_context *c = s->creq;
2811         struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
2812                                            struct drsuapi_DsGetNCChanges);
2813         WERROR status;
2814
2815         s->ndr_struct_ptr = NULL;
2816
2817         c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
2818         TALLOC_FREE(subreq);
2819         if (!composite_is_ok(c)) return;
2820
2821         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->config_part, r);
2822         if (!W_ERROR_IS_OK(status)) {
2823                 composite_error(c, werror_to_ntstatus(status));
2824                 return;
2825         }
2826
2827         talloc_free(r);
2828
2829         if (s->config_part.more_data) {
2830                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
2831                                                      becomeDC_drsuapi3_pull_config_recv);
2832                 return;
2833         }
2834
2835         becomeDC_connect_ldap2(s);
2836 }
2837
2838 static void becomeDC_drsuapi3_pull_domain_recv(struct tevent_req *subreq);
2839
2840 static void becomeDC_drsuapi3_pull_domain_send(struct libnet_BecomeDC_state *s)
2841 {
2842         s->domain_part.nc.guid  = GUID_zero();
2843         s->domain_part.nc.sid   = s->zero_sid;
2844         s->domain_part.nc.dn    = s->domain.dn_str;
2845
2846         s->domain_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
2847
2848         s->domain_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
2849                                         | DRSUAPI_DRS_INIT_SYNC
2850                                         | DRSUAPI_DRS_PER_SYNC
2851                                         | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
2852                                         | DRSUAPI_DRS_NEVER_SYNCED
2853                                         | DRSUAPI_DRS_USE_COMPRESSION;
2854         if (s->rodc_join) {
2855             s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
2856         }
2857
2858         s->domain_part.store_chunk      = s->callbacks.domain_chunk;
2859
2860         becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
2861                                              becomeDC_drsuapi3_pull_domain_recv);
2862 }
2863
2864 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
2865                                               struct becomeDC_drsuapi *drsuapi,
2866                                               struct libnet_BecomeDC_Partition *partition,
2867                                               void (*recv_fn)(struct tevent_req *subreq));
2868 static void becomeDC_drsuapi2_update_refs_schema_recv(struct tevent_req *subreq);
2869
2870 static void becomeDC_drsuapi3_pull_domain_recv(struct tevent_req *subreq)
2871 {
2872         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2873                                           struct libnet_BecomeDC_state);
2874         struct composite_context *c = s->creq;
2875         struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
2876                                            struct drsuapi_DsGetNCChanges);
2877         WERROR status;
2878
2879         s->ndr_struct_ptr = NULL;
2880
2881         c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
2882         TALLOC_FREE(subreq);
2883         if (!composite_is_ok(c)) return;
2884
2885         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part, r);
2886         if (!W_ERROR_IS_OK(status)) {
2887                 composite_error(c, werror_to_ntstatus(status));
2888                 return;
2889         }
2890
2891         talloc_free(r);
2892
2893         if (s->domain_part.more_data) {
2894                 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
2895                                                      becomeDC_drsuapi3_pull_domain_recv);
2896                 return;
2897         }
2898
2899         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->schema_part,
2900                                           becomeDC_drsuapi2_update_refs_schema_recv);
2901 }
2902
2903 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
2904                                               struct becomeDC_drsuapi *drsuapi,
2905                                               struct libnet_BecomeDC_Partition *partition,
2906                                               void (*recv_fn)(struct tevent_req *subreq))
2907 {
2908         struct composite_context *c = s->creq;
2909         struct drsuapi_DsReplicaUpdateRefs *r;
2910         const char *ntds_guid_str;
2911         const char *ntds_dns_name;
2912         struct tevent_req *subreq;
2913
2914         r = talloc(s, struct drsuapi_DsReplicaUpdateRefs);
2915         if (composite_nomem(r, c)) return;
2916
2917         ntds_guid_str = GUID_string(r, &s->dest_dsa.ntds_guid);
2918         if (composite_nomem(ntds_guid_str, c)) return;
2919
2920         ntds_dns_name = talloc_asprintf(r, "%s._msdcs.%s",
2921                                         ntds_guid_str,
2922                                         s->domain.dns_name);
2923         if (composite_nomem(ntds_dns_name, c)) return;
2924
2925         r->in.bind_handle               = &drsuapi->bind_handle;
2926         r->in.level                     = 1;
2927         r->in.req.req1.naming_context   = &partition->nc;
2928         r->in.req.req1.dest_dsa_dns_name= ntds_dns_name;
2929         r->in.req.req1.dest_dsa_guid    = s->dest_dsa.ntds_guid;
2930         r->in.req.req1.options          = DRSUAPI_DRS_ADD_REF | DRSUAPI_DRS_DEL_REF;
2931
2932         /* I think this is how we mark ourselves as a RODC */
2933         if (!lp_parm_bool(s->libnet->lp_ctx, NULL, "repl", "RODC", false)) {
2934                 r->in.req.req1.options |= DRSUAPI_DRS_WRIT_REP;
2935         }
2936
2937         s->ndr_struct_ptr = r;
2938         subreq = dcerpc_drsuapi_DsReplicaUpdateRefs_r_send(s, c->event_ctx,
2939                                                            drsuapi->drsuapi_handle,
2940                                                            r);
2941         if (composite_nomem(subreq, c)) return;
2942         tevent_req_set_callback(subreq, recv_fn, s);
2943 }
2944
2945 static void becomeDC_drsuapi2_update_refs_config_recv(struct tevent_req *subreq);
2946
2947 static void becomeDC_drsuapi2_update_refs_schema_recv(struct tevent_req *subreq)
2948 {
2949         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2950                                           struct libnet_BecomeDC_state);
2951         struct composite_context *c = s->creq;
2952         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type_abort(s->ndr_struct_ptr,
2953                                            struct drsuapi_DsReplicaUpdateRefs);
2954
2955         s->ndr_struct_ptr = NULL;
2956
2957         c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
2958         TALLOC_FREE(subreq);
2959         if (!composite_is_ok(c)) return;
2960
2961         if (!W_ERROR_IS_OK(r->out.result)) {
2962                 composite_error(c, werror_to_ntstatus(r->out.result));
2963                 return;
2964         }
2965
2966         talloc_free(r);
2967
2968         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->config_part,
2969                                           becomeDC_drsuapi2_update_refs_config_recv);
2970 }
2971
2972 static void becomeDC_drsuapi2_update_refs_domain_recv(struct tevent_req *subreq);
2973
2974 static void becomeDC_drsuapi2_update_refs_config_recv(struct tevent_req *subreq)
2975 {
2976         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
2977                                           struct libnet_BecomeDC_state);
2978         struct composite_context *c = s->creq;
2979         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(s->ndr_struct_ptr,
2980                                            struct drsuapi_DsReplicaUpdateRefs);
2981
2982         s->ndr_struct_ptr = NULL;
2983
2984         c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
2985         TALLOC_FREE(subreq);
2986         if (!composite_is_ok(c)) return;
2987
2988         if (!W_ERROR_IS_OK(r->out.result)) {
2989                 composite_error(c, werror_to_ntstatus(r->out.result));
2990                 return;
2991         }
2992
2993         talloc_free(r);
2994
2995         becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->domain_part,
2996                                           becomeDC_drsuapi2_update_refs_domain_recv);
2997 }
2998
2999 static void becomeDC_drsuapi2_update_refs_domain_recv(struct tevent_req *subreq)
3000 {
3001         struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
3002                                           struct libnet_BecomeDC_state);
3003         struct composite_context *c = s->creq;
3004         struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(s->ndr_struct_ptr,
3005                                            struct drsuapi_DsReplicaUpdateRefs);
3006
3007         s->ndr_struct_ptr = NULL;
3008
3009         c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
3010         TALLOC_FREE(subreq);
3011         if (!composite_is_ok(c)) return;
3012
3013         if (!W_ERROR_IS_OK(r->out.result)) {
3014                 composite_error(c, werror_to_ntstatus(r->out.result));
3015                 return;
3016         }
3017
3018         talloc_free(r);
3019
3020         /* TODO: use DDNS updates and register dns names */
3021         composite_done(c);
3022 }
3023
3024 static NTSTATUS becomeDC_ldap2_modify_computer(struct libnet_BecomeDC_state *s)
3025 {
3026         int ret;
3027         struct ldb_message *msg;
3028         unsigned int i;
3029         uint32_t user_account_control = UF_SERVER_TRUST_ACCOUNT |
3030                                         UF_TRUSTED_FOR_DELEGATION;
3031
3032         /* as the value is already as we want it to be, we're done */
3033         if (s->dest_dsa.user_account_control == user_account_control) {
3034                 return NT_STATUS_OK;
3035         }
3036
3037         /* make a 'modify' msg, and only for serverReference */
3038         msg = ldb_msg_new(s);
3039         NT_STATUS_HAVE_NO_MEMORY(msg);
3040         msg->dn = ldb_dn_new(msg, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
3041         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
3042
3043         ret = ldb_msg_add_fmt(msg, "userAccountControl", "%u", user_account_control);
3044         if (ret != 0) {
3045                 talloc_free(msg);
3046                 return NT_STATUS_NO_MEMORY;
3047         }
3048
3049         /* mark all the message elements (should be just one)
3050            as LDB_FLAG_MOD_REPLACE */
3051         for (i=0;i<msg->num_elements;i++) {
3052                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
3053         }
3054
3055         ret = ldb_modify(s->ldap2.ldb, msg);
3056         talloc_free(msg);
3057         if (ret != LDB_SUCCESS) {
3058                 return NT_STATUS_LDAP(ret);
3059         }
3060
3061         s->dest_dsa.user_account_control = user_account_control;
3062
3063         return NT_STATUS_OK;
3064 }
3065
3066 static NTSTATUS becomeDC_ldap2_move_computer(struct libnet_BecomeDC_state *s)
3067 {
3068         int ret;
3069         struct ldb_dn *old_dn;
3070         struct ldb_dn *new_dn;
3071
3072         ret = dsdb_wellknown_dn(s->ldap2.ldb, s,
3073                                 ldb_get_default_basedn(s->ldap2.ldb),
3074                                 DS_GUID_DOMAIN_CONTROLLERS_CONTAINER,
3075                                 &new_dn);
3076         if (ret != LDB_SUCCESS) {
3077                 return NT_STATUS_LDAP(ret);
3078         }
3079
3080         if (!ldb_dn_add_child_fmt(new_dn, "CN=%s", s->dest_dsa.netbios_name)) {
3081                 talloc_free(new_dn);
3082                 return NT_STATUS_NO_MEMORY;
3083         }
3084
3085         old_dn = ldb_dn_new(new_dn, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
3086         NT_STATUS_HAVE_NO_MEMORY(old_dn);
3087
3088         if (ldb_dn_compare(old_dn, new_dn) == 0) {
3089                 /* we don't need to rename if the old and new dn match */
3090                 talloc_free(new_dn);
3091                 return NT_STATUS_OK;
3092         }
3093
3094         ret = ldb_rename(s->ldap2.ldb, old_dn, new_dn);
3095         if (ret != LDB_SUCCESS) {
3096                 talloc_free(new_dn);
3097                 return NT_STATUS_LDAP(ret);
3098         }
3099
3100         s->dest_dsa.computer_dn_str = ldb_dn_alloc_linearized(s, new_dn);
3101         NT_STATUS_HAVE_NO_MEMORY(s->dest_dsa.computer_dn_str);
3102
3103         talloc_free(new_dn);
3104
3105         return NT_STATUS_OK;
3106 }
3107
3108 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s)
3109 {
3110         struct composite_context *c = s->creq;
3111
3112         c->status = becomeDC_ldap_connect(s, &s->ldap2);
3113         if (!composite_is_ok(c)) return;
3114
3115         c->status = becomeDC_ldap2_modify_computer(s);
3116         if (!composite_is_ok(c)) return;
3117
3118         c->status = becomeDC_ldap2_move_computer(s);
3119         if (!composite_is_ok(c)) return;
3120
3121         becomeDC_drsuapi3_pull_domain_send(s);
3122 }
3123
3124 struct composite_context *libnet_BecomeDC_send(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3125 {
3126         struct composite_context *c;
3127         struct libnet_BecomeDC_state *s;
3128         char *tmp_name;
3129
3130         c = composite_create(mem_ctx, ctx->event_ctx);
3131         if (c == NULL) return NULL;
3132
3133         s = talloc_zero(c, struct libnet_BecomeDC_state);
3134         if (composite_nomem(s, c)) return c;
3135         c->private_data = s;
3136         s->creq         = c;
3137         s->libnet       = ctx;
3138
3139         /* Domain input */
3140         s->domain.dns_name      = talloc_strdup(s, r->in.domain_dns_name);
3141         if (composite_nomem(s->domain.dns_name, c)) return c;
3142         s->domain.netbios_name  = talloc_strdup(s, r->in.domain_netbios_name);
3143         if (composite_nomem(s->domain.netbios_name, c)) return c;
3144         s->domain.sid           = dom_sid_dup(s, r->in.domain_sid);
3145         if (composite_nomem(s->domain.sid, c)) return c;
3146
3147         /* Source DSA input */
3148         s->source_dsa.address   = talloc_strdup(s, r->in.source_dsa_address);
3149         if (composite_nomem(s->source_dsa.address, c)) return c;
3150
3151         /* Destination DSA input */
3152         s->dest_dsa.netbios_name= talloc_strdup(s, r->in.dest_dsa_netbios_name);
3153         if (composite_nomem(s->dest_dsa.netbios_name, c)) return c;
3154
3155         /* Destination DSA dns_name construction */
3156         tmp_name        = strlower_talloc(s, s->dest_dsa.netbios_name);
3157         if (composite_nomem(tmp_name, c)) return c;
3158         tmp_name        = talloc_asprintf_append_buffer(tmp_name, ".%s",s->domain.dns_name);
3159         if (composite_nomem(tmp_name, c)) return c;
3160         s->dest_dsa.dns_name    = tmp_name;
3161
3162         /* Callback function pointers */
3163         s->callbacks = r->in.callbacks;
3164
3165         /* RODC join*/
3166         s->rodc_join = r->in.rodc_join;
3167
3168         becomeDC_send_cldap(s);
3169         return c;
3170 }
3171
3172 NTSTATUS libnet_BecomeDC_recv(struct composite_context *c, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3173 {
3174         NTSTATUS status;
3175
3176         status = composite_wait(c);
3177
3178         ZERO_STRUCT(r->out);
3179
3180         talloc_free(c);
3181         return status;
3182 }
3183
3184 NTSTATUS libnet_BecomeDC(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3185 {
3186         NTSTATUS status;
3187         struct composite_context *c;
3188         c = libnet_BecomeDC_send(ctx, mem_ctx, r);
3189         status = libnet_BecomeDC_recv(c, mem_ctx, r);
3190         return status;
3191 }