2 Unix SMB/CIFS implementation.
4 Copyright (C) Stefan Metzmacher <metze@samba.org> 2006
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.
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.
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/>.
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 "dsdb/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"
38 /*****************************************************************************
39 * Windows 2003 (w2k3) does the following steps when changing the server role
40 * from domain member to domain controller
42 * We mostly do the same.
43 *****************************************************************************/
47 * - using nbt name<1C> request and a samlogon mailslot request
49 * - using a DNS SRV _ldap._tcp.dc._msdcs. request and a CLDAP netlogon request
51 * see: becomeDC_recv_cldap() and becomeDC_send_cldap()
55 * Open 1st LDAP connection to the DC using admin credentials
57 * see: becomeDC_connect_ldap1() and becomeDC_ldap_connect()
61 * LDAP search 1st LDAP connection:
63 * see: becomeDC_ldap1_rootdse()
68 * filter: (objectClass=*)
72 * currentTime: 20061202155100.0Z
73 * subschemaSubentry: CN=Aggregate,CN=Schema,CN=Configuration,<domain_partition>
74 * dsServiceName: CN=<netbios_name>,CN=Servers,CN=<site_name>,CN=Sites,CN=Configuration,<domain_partition>
75 * namingContexts: <domain_partition>
76 * CN=Configuration,<domain_partition>
77 * CN=Schema,CN=Configuration,<domain_partition>
78 * defaultNamingContext: <domain_partition>
79 * schemaNamingContext: CN=Schema,CN=Configuration,<domain_partition>
80 * configurationNamingContext:CN=Configuration,<domain_partition>
81 * rootDomainNamingContext:<domain_partition>
82 * supportedControl: ...
83 * supportedLDAPVersion: 3
85 * supportedLDAPPolicies: ...
86 * highestCommitedUSN: ...
87 * supportedSASLMechanisms:GSSAPI
91 * dnsHostName: <dns_host_name>
92 * ldapServiceName: <domain_dns_name>:<netbios_name>$@<REALM>
93 * serverName: CN=Servers,CN=<site_name>,CN=Sites,CN=Configuration,<domain_partition>
94 * supportedCapabilities: ...
96 * isGlobalCatalogReady: TRUE
97 * domainFunctionality: 0
98 * forestFunctionality: 0
99 * domainControllerFunctionality: 2
103 * LDAP search 1st LDAP connection:
105 * see: becomeDC_ldap1_crossref_behavior_version()
108 * basedn: CN=Configuration,<domain_partition>
110 * filter: (cn=Partitions)
111 * attrs: msDS-Behavior-Version
113 * CN=Partitions,CN=Configuration,<domain_partition>
114 * msDS-Behavior-Version: 0
118 * LDAP search 1st LDAP connection:
120 * NOTE: this seems to be a bug! as the messageID of the LDAP message is corrupted!
122 * not implemented here
125 * basedn: CN=Schema,CN=Configuration,<domain_partition>
127 * filter: (cn=Partitions)
128 * attrs: msDS-Behavior-Version
135 * LDAP search 1st LDAP connection:
137 * see: becomeDC_ldap1_domain_behavior_version()
140 * basedn: <domain_partition>
142 * filter: (objectClass=*)
143 * attrs: msDS-Behavior-Version
146 * msDS-Behavior-Version: 0
150 * LDAP search 1st LDAP connection:
152 * see: becomeDC_ldap1_schema_object_version()
155 * basedn: CN=Schema,CN=Configuration,<domain_partition>
157 * filter: (objectClass=*)
158 * attrs: objectVersion
160 * CN=Schema,CN=Configuration,<domain_partition>
165 * LDAP search 1st LDAP connection:
167 * not implemented, because the information is already there
172 * filter: (objectClass=*)
173 * attrs: defaultNamingContext
177 * defaultNamingContext: <domain_partition>
178 * dnsHostName: <dns_host_name>
182 * LDAP search 1st LDAP connection:
184 * see: becomeDC_ldap1_infrastructure_fsmo()
187 * basedn: <WKGUID=2fbac1870ade11d297c400c04fd8d5cd,domain_partition>
189 * filter: (objectClass=*)
192 * CN=Infrastructure,<domain_partition>
196 * LDAP search 1st LDAP connection:
198 * see: becomeDC_ldap1_w2k3_update_revision()
201 * basedn: CN=Windows2003Update,CN=DomainUpdates,CN=System,<domain_partition>
203 * filter: (objectClass=*)
206 * CN=Windows2003Update,CN=DomainUpdates,CN=System,<domain_partition>
211 * LDAP search 1st LDAP connection:
213 * see: becomeDC_ldap1_infrastructure_fsmo()
216 * basedn: CN=Infrastructure,<domain_partition>
218 * filter: (objectClass=*)
219 * attrs: fSMORoleOwner
221 * CN=Infrastructure,<domain_partition>
222 * fSMORoleOwner: CN=NTDS Settings,<infrastructure_fsmo_server_object>
226 * LDAP search 1st LDAP connection:
228 * see: becomeDC_ldap1_infrastructure_fsmo()
231 * basedn: <infrastructure_fsmo_server_object>
233 * filter: (objectClass=*)
236 * <infrastructure_fsmo_server_object>
237 * dnsHostName: <dns_host_name>
241 * LDAP search 1st LDAP connection:
243 * see: becomeDC_ldap1_infrastructure_fsmo()
246 * basedn: CN=NTDS Settings,<infrastructure_fsmo_server_object>
248 * filter: (objectClass=*)
251 * CN=NTDS Settings,<infrastructure_fsmo_server_object>
252 * objectGUID: <object_guid>
256 * LDAP search 1st LDAP connection:
258 * see: becomeDC_ldap1_rid_manager_fsmo()
261 * basedn: <domain_partition>
263 * filter: (objectClass=*)
264 * attrs: rIDManagerReference
267 * rIDManagerReference: CN=RID Manager$,CN=System,<domain_partition>
271 * LDAP search 1st LDAP connection:
273 * see: becomeDC_ldap1_rid_manager_fsmo()
276 * basedn: CN=RID Manager$,CN=System,<domain_partition>
278 * filter: (objectClass=*)
279 * attrs: fSMORoleOwner
281 * CN=Infrastructure,<domain_partition>
282 * fSMORoleOwner: CN=NTDS Settings,<rid_manager_fsmo_server_object>
286 * LDAP search 1st LDAP connection:
288 * see: becomeDC_ldap1_rid_manager_fsmo()
291 * basedn: <rid_manager_fsmo_server_object>
293 * filter: (objectClass=*)
296 * <rid_manager_fsmo_server_object>
297 * dnsHostName: <dns_host_name>
301 * LDAP search 1st LDAP connection:
303 * see: becomeDC_ldap1_rid_manager_fsmo()
306 * basedn: CN=NTDS Settings,<rid_manager_fsmo_server_object>
308 * filter: (objectClass=*)
309 * attrs: msDs-ReplicationEpoch
311 * CN=NTDS Settings,<rid_manager_fsmo_server_object>
315 * LDAP search 1st LDAP connection:
317 * see: becomeDC_ldap1_site_object()
320 * basedn: CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
322 * filter: (objectClass=*)
325 * CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
328 * cn: <new_dc_site_name>
329 * distinguishedName:CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
335 * showInAdvancedViewOnly: TRUE
336 * name: <new_dc_site_name>
337 * objectGUID: <object_guid>
338 * systemFlags: 1107296256 <0x42000000>
339 * objectCategory: CN=Site,C=Schema,CN=Configuration,<domain_partition>
342 /***************************************************************
343 * Add this stage we call the check_options() callback function
344 * of the caller, to see if he wants us to continue
346 * see: becomeDC_check_options()
347 ***************************************************************/
350 * LDAP search 1st LDAP connection:
352 * see: becomeDC_ldap1_computer_object()
355 * basedn: <domain_partition>
357 * filter: (&(|(objectClass=user)(objectClass=computer))(sAMAccountName=<new_dc_account_name>))
358 * attrs: distinguishedName
361 * CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
362 * distinguishedName: CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
363 * userAccoountControl: 4096 <0x1000>
367 * LDAP search 1st LDAP connection:
369 * see: becomeDC_ldap1_server_object_1()
372 * basedn: CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
374 * filter: (objectClass=*)
378 * <matchedDN:CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>>
382 * LDAP search 1st LDAP connection:
384 * see: becomeDC_ldap1_server_object_2()
387 * basedn: CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
389 * filter: (objectClass=*)
390 * attrs: serverReferenceBL
393 * CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
397 * LDAP add 1st LDAP connection:
399 * see: becomeDC_ldap1_server_object_add()
402 * CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
403 * objectClass: server
404 * systemFlags: 50000000 <0x2FAF080>
405 * serverReference:CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
411 * LDAP search 1st LDAP connection:
413 * not implemented, maybe we can add that later
416 * basedn: CN=NTDS Settings,CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>
418 * filter: (objectClass=*)
422 * <matchedDN:CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>>
426 * LDAP search 1st LDAP connection:
428 * not implemented because it gives no new information
431 * basedn: CN=Partitions,CN=Configuration,<domain_partition>
433 * filter: (nCName=<domain_partition>)
436 * controls: LDAP_SERVER_EXTENDED_DN_OID:critical=false
438 * <GUID=<hex_guid>>;CN=<domain_netbios_name>,CN=Partitions,<domain_partition>>
439 * nCName: <GUID=<hex_guid>>;<SID=<hex_sid>>;<domain_partition>>
440 * dnsRoot: <domain_dns_name>
444 * LDAP modify 1st LDAP connection:
446 * see: becomeDC_ldap1_server_object_modify()
449 * CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>>
450 * serverReference:CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
452 * <attributeOrValueExist>
456 * LDAP modify 1st LDAP connection:
458 * see: becomeDC_ldap1_server_object_modify()
461 * CN=<new_dc_netbios_name>,CN=Servers,CN=<new_dc_site_name>,CN=Sites,CN=Configuration,<domain_partition>>
462 * serverReference:CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
468 * Open 1st DRSUAPI connection to the DC using admin credentials
469 * DsBind with DRSUAPI_DS_BIND_GUID_W2K3 ("6afab99c-6e26-464a-975f-f58f105218bc")
470 * (w2k3 does 2 DsBind() calls here..., where is first is unused and contains garbage at the end)
472 * see: becomeDC_drsuapi_connect_send(), becomeDC_drsuapi1_connect_recv(),
473 * becomeDC_drsuapi_bind_send(), becomeDC_drsuapi_bind_recv() and becomeDC_drsuapi1_bind_recv()
477 * DsAddEntry to create the CN=NTDS Settings,CN=<machine_name>,CN=Servers,CN=Default-First-Site-Name, ...
478 * on the 1st DRSUAPI connection
480 * see: becomeDC_drsuapi1_add_entry_send() and becomeDC_drsuapi1_add_entry_recv()
483 /***************************************************************
484 * Add this stage we call the prepare_db() callback function
485 * of the caller, to see if he wants us to continue
487 * see: becomeDC_prepare_db()
488 ***************************************************************/
491 * Open 2nd and 3rd DRSUAPI connection to the DC using admin credentials
492 * - a DsBind with DRSUAPI_DS_BIND_GUID_W2K3 ("6afab99c-6e26-464a-975f-f58f105218bc")
493 * on the 2nd connection
495 * see: becomeDC_drsuapi_connect_send(), becomeDC_drsuapi2_connect_recv(),
496 * becomeDC_drsuapi_bind_send(), becomeDC_drsuapi_bind_recv(), becomeDC_drsuapi2_bind_recv()
497 * and becomeDC_drsuapi3_connect_recv()
501 * replicate CN=Schema,CN=Configuration,...
502 * on the 3rd DRSUAPI connection and the bind_handle from the 2nd connection
504 * see: becomeDC_drsuapi_pull_partition_send(), becomeDC_drsuapi_pull_partition_recv(),
505 * becomeDC_drsuapi3_pull_schema_send() and becomeDC_drsuapi3_pull_schema_recv()
507 ***************************************************************
508 * Add this stage we call the schema_chunk() callback function
509 * for each replication message
510 ***************************************************************/
513 * replicate CN=Configuration,...
514 * on the 3rd DRSUAPI connection and the bind_handle from the 2nd connection
516 * see: becomeDC_drsuapi_pull_partition_send(), becomeDC_drsuapi_pull_partition_recv(),
517 * becomeDC_drsuapi3_pull_config_send() and becomeDC_drsuapi3_pull_config_recv()
519 ***************************************************************
520 * Add this stage we call the config_chunk() callback function
521 * for each replication message
522 ***************************************************************/
525 * LDAP unbind on the 1st LDAP connection
527 * not implemented, because it's not needed...
531 * Open 2nd LDAP connection to the DC using admin credentials
533 * see: becomeDC_connect_ldap2() and becomeDC_ldap_connect()
537 * LDAP search 2nd LDAP connection:
539 * not implemented because it gives no new information
540 * same as becomeDC_ldap1_computer_object()
543 * basedn: <domain_partition>
545 * filter: (&(|(objectClass=user)(objectClass=computer))(sAMAccountName=<new_dc_account_name>))
546 * attrs: distinguishedName
549 * CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
550 * distinguishedName: CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
551 * userAccoountControl: 4096 <0x00001000>
555 * LDAP search 2nd LDAP connection:
557 * not implemented because it gives no new information
558 * same as becomeDC_ldap1_computer_object()
561 * basedn: CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
563 * filter: (objectClass=*)
564 * attrs: userAccountControl
566 * CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
567 * userAccoountControl: 4096 <0x00001000>
571 * LDAP modify 2nd LDAP connection:
573 * see: becomeDC_ldap2_modify_computer()
576 * CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
577 * userAccoountControl: 532480 <0x82000>
583 * LDAP search 2nd LDAP connection:
585 * see: becomeDC_ldap2_move_computer()
588 * basedn: <WKGUID=2fbac1870ade11d297c400c04fd8d5cd,<domain_partition>>
590 * filter: (objectClass=*)
593 * CN=Domain Controllers,<domain_partition>
597 * LDAP search 2nd LDAP connection:
599 * not implemented because it gives no new information
602 * basedn: CN=Domain Controllers,<domain_partition>
604 * filter: (objectClass=*)
605 * attrs: distinguishedName
607 * CN=Domain Controller,<domain_partition>
608 * distinguishedName: CN=Domain Controllers,<domain_partition>
612 * LDAP modifyRDN 2nd LDAP connection:
614 * see: becomeDC_ldap2_move_computer()
617 * entry: CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
618 * newrdn: CN=<new_dc_netbios_name>
620 * newparent: CN=Domain Controllers,<domain_partition>
626 * LDAP unbind on the 2nd LDAP connection
628 * not implemented, because it's not needed...
632 * replicate Domain Partition
633 * on the 3rd DRSUAPI connection and the bind_handle from the 2nd connection
635 * see: becomeDC_drsuapi_pull_partition_send(), becomeDC_drsuapi_pull_partition_recv(),
636 * becomeDC_drsuapi3_pull_domain_send() and becomeDC_drsuapi3_pull_domain_recv()
638 ***************************************************************
639 * Add this stage we call the domain_chunk() callback function
640 * for each replication message
641 ***************************************************************/
643 /* call DsReplicaUpdateRefs() for all partitions like this:
644 * req1: struct drsuapi_DsReplicaUpdateRefsRequest1
646 * naming_context: struct drsuapi_DsReplicaObjectIdentifier
647 * __ndr_size : 0x000000ae (174)
648 * __ndr_size_sid : 0x00000000 (0)
649 * guid : 00000000-0000-0000-0000-000000000000
651 * dn : 'CN=Schema,CN=Configuration,DC=w2k3,DC=vmnet1,DC=vm,DC=base'
653 * dest_dsa_dns_name : '4a0df188-a0b8-47ea-bbe5-e614723f16dd._msdcs.w2k3.vmnet1.vm.base'
654 * dest_dsa_guid : 4a0df188-a0b8-47ea-bbe5-e614723f16dd
655 * options : 0x0000001c (28)
656 * 0: DRSUAPI_DS_REPLICA_UPDATE_ASYNCHRONOUS_OPERATION
657 * 0: DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE
658 * 1: DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE
659 * 1: DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE
660 * 1: DRSUAPI_DS_REPLICA_UPDATE_0x00000010
662 * 4a0df188-a0b8-47ea-bbe5-e614723f16dd is the objectGUID the DsAddEntry() returned for the
663 * CN=NTDS Settings,CN=<machine_name>,CN=Servers,CN=Default-First-Site-Name, ...
664 * on the 2nd!!! DRSUAPI connection
666 * see: becomeDC_drsuapi_update_refs_send(), becomeDC_drsuapi2_update_refs_schema_recv(),
667 * becomeDC_drsuapi2_update_refs_config_recv() and becomeDC_drsuapi2_update_refs_domain_recv()
671 * Windows does opens the 4th and 5th DRSUAPI connection...
672 * and does a DsBind() with the objectGUID from DsAddEntry() as bind_guid
673 * on the 4th connection
675 * and then 2 full replications of the domain partition on the 5th connection
676 * with the bind_handle from the 4th connection
678 * not implemented because it gives no new information
681 struct libnet_BecomeDC_state {
682 struct composite_context *creq;
684 struct libnet_context *libnet;
686 struct dom_sid zero_sid;
689 struct cldap_socket *sock;
690 struct cldap_netlogon io;
691 struct NETLOGON_SAM_LOGON_RESPONSE_EX netlogon;
694 struct becomeDC_ldap {
695 struct ldb_context *ldb;
696 const struct ldb_message *rootdse;
699 struct becomeDC_drsuapi {
700 struct libnet_BecomeDC_state *s;
701 struct dcerpc_binding *binding;
702 struct dcerpc_pipe *pipe;
703 DATA_BLOB gensec_skey;
704 struct drsuapi_DsBind bind_r;
705 struct GUID bind_guid;
706 struct drsuapi_DsBindInfoCtr bind_info_ctr;
707 struct drsuapi_DsBindInfo28 local_info28;
708 struct drsuapi_DsBindInfo28 remote_info28;
709 struct policy_handle bind_handle;
710 } drsuapi1, drsuapi2, drsuapi3;
712 struct libnet_BecomeDC_Domain domain;
713 struct libnet_BecomeDC_Forest forest;
714 struct libnet_BecomeDC_SourceDSA source_dsa;
715 struct libnet_BecomeDC_DestDSA dest_dsa;
717 struct libnet_BecomeDC_Partition schema_part, config_part, domain_part;
719 struct becomeDC_fsmo {
720 const char *dns_name;
721 const char *server_dn_str;
722 const char *ntds_dn_str;
723 struct GUID ntds_guid;
724 } infrastructure_fsmo;
726 struct becomeDC_fsmo rid_manager_fsmo;
728 struct libnet_BecomeDC_CheckOptions _co;
729 struct libnet_BecomeDC_PrepareDB _pp;
730 struct libnet_BecomeDC_StoreChunk _sc;
731 struct libnet_BecomeDC_Callbacks callbacks;
734 static void becomeDC_recv_cldap(struct cldap_request *req);
736 static void becomeDC_send_cldap(struct libnet_BecomeDC_state *s)
738 struct composite_context *c = s->creq;
739 struct cldap_request *req;
741 s->cldap.io.in.dest_address = s->source_dsa.address;
742 s->cldap.io.in.dest_port = lp_cldap_port(s->libnet->lp_ctx);
743 s->cldap.io.in.realm = s->domain.dns_name;
744 s->cldap.io.in.host = s->dest_dsa.netbios_name;
745 s->cldap.io.in.user = NULL;
746 s->cldap.io.in.domain_guid = NULL;
747 s->cldap.io.in.domain_sid = NULL;
748 s->cldap.io.in.acct_control = -1;
749 s->cldap.io.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
750 s->cldap.io.in.map_response = true;
752 s->cldap.sock = cldap_socket_init(s, s->libnet->event_ctx,
753 lp_iconv_convenience(s->libnet->lp_ctx));
754 if (composite_nomem(s->cldap.sock, c)) return;
756 req = cldap_netlogon_send(s->cldap.sock, &s->cldap.io);
757 if (composite_nomem(req, c)) return;
758 req->async.fn = becomeDC_recv_cldap;
759 req->async.private = s;
762 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s);
764 static void becomeDC_recv_cldap(struct cldap_request *req)
766 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private,
767 struct libnet_BecomeDC_state);
768 struct composite_context *c = s->creq;
770 c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
771 if (!composite_is_ok(c)) return;
773 s->cldap.netlogon = s->cldap.io.out.netlogon.nt5_ex;
775 s->domain.dns_name = s->cldap.netlogon.dns_domain;
776 s->domain.netbios_name = s->cldap.netlogon.domain;
777 s->domain.guid = s->cldap.netlogon.domain_uuid;
779 s->forest.dns_name = s->cldap.netlogon.forest;
781 s->source_dsa.dns_name = s->cldap.netlogon.pdc_dns_name;
782 s->source_dsa.netbios_name = s->cldap.netlogon.pdc_name;
783 s->source_dsa.site_name = s->cldap.netlogon.server_site;
785 s->dest_dsa.site_name = s->cldap.netlogon.client_site;
787 becomeDC_connect_ldap1(s);
790 static NTSTATUS becomeDC_ldap_connect(struct libnet_BecomeDC_state *s,
791 struct becomeDC_ldap *ldap)
795 url = talloc_asprintf(s, "ldap://%s/", s->source_dsa.dns_name);
796 NT_STATUS_HAVE_NO_MEMORY(url);
798 ldap->ldb = ldb_wrap_connect(s, s->libnet->event_ctx, s->libnet->lp_ctx, url,
803 if (ldap->ldb == NULL) {
804 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
810 static NTSTATUS becomeDC_ldap1_rootdse(struct libnet_BecomeDC_state *s)
813 struct ldb_result *r;
814 struct ldb_dn *basedn;
815 static const char *attrs[] = {
820 basedn = ldb_dn_new(s, s->ldap1.ldb, NULL);
821 NT_STATUS_HAVE_NO_MEMORY(basedn);
823 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
824 "(objectClass=*)", attrs, &r);
826 if (ret != LDB_SUCCESS) {
827 return NT_STATUS_LDAP(ret);
828 } else if (r->count != 1) {
830 return NT_STATUS_INVALID_NETWORK_RESPONSE;
834 s->ldap1.rootdse = r->msgs[0];
836 s->domain.dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "defaultNamingContext", NULL);
837 if (!s->domain.dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
839 s->forest.root_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "rootDomainNamingContext", NULL);
840 if (!s->forest.root_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
841 s->forest.config_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "configurationNamingContext", NULL);
842 if (!s->forest.config_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
843 s->forest.schema_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "schemaNamingContext", NULL);
844 if (!s->forest.schema_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
846 s->source_dsa.server_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "serverName", NULL);
847 if (!s->source_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
848 s->source_dsa.ntds_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "dsServiceName", NULL);
849 if (!s->source_dsa.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
854 static NTSTATUS becomeDC_ldap1_crossref_behavior_version(struct libnet_BecomeDC_state *s)
857 struct ldb_result *r;
858 struct ldb_dn *basedn;
859 static const char *attrs[] = {
860 "msDs-Behavior-Version",
864 basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.config_dn_str);
865 NT_STATUS_HAVE_NO_MEMORY(basedn);
867 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_ONELEVEL,
868 "(cn=Partitions)", attrs, &r);
870 if (ret != LDB_SUCCESS) {
871 return NT_STATUS_LDAP(ret);
872 } else if (r->count != 1) {
874 return NT_STATUS_INVALID_NETWORK_RESPONSE;
877 s->forest.crossref_behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
883 static NTSTATUS becomeDC_ldap1_domain_behavior_version(struct libnet_BecomeDC_state *s)
886 struct ldb_result *r;
887 struct ldb_dn *basedn;
888 static const char *attrs[] = {
889 "msDs-Behavior-Version",
893 basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
894 NT_STATUS_HAVE_NO_MEMORY(basedn);
896 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
897 "(objectClass=*)", attrs, &r);
899 if (ret != LDB_SUCCESS) {
900 return NT_STATUS_LDAP(ret);
901 } else if (r->count != 1) {
903 return NT_STATUS_INVALID_NETWORK_RESPONSE;
906 s->domain.behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
912 static NTSTATUS becomeDC_ldap1_schema_object_version(struct libnet_BecomeDC_state *s)
915 struct ldb_result *r;
916 struct ldb_dn *basedn;
917 static const char *attrs[] = {
922 basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.schema_dn_str);
923 NT_STATUS_HAVE_NO_MEMORY(basedn);
925 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
926 "(objectClass=*)", attrs, &r);
928 if (ret != LDB_SUCCESS) {
929 return NT_STATUS_LDAP(ret);
930 } else if (r->count != 1) {
932 return NT_STATUS_INVALID_NETWORK_RESPONSE;
935 s->forest.schema_object_version = ldb_msg_find_attr_as_uint(r->msgs[0], "objectVersion", 0);
941 static NTSTATUS becomeDC_ldap1_w2k3_update_revision(struct libnet_BecomeDC_state *s)
944 struct ldb_result *r;
945 struct ldb_dn *basedn;
946 static const char *attrs[] = {
951 basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=Windows2003Update,CN=DomainUpdates,CN=System,%s",
953 NT_STATUS_HAVE_NO_MEMORY(basedn);
955 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
956 "(objectClass=*)", attrs, &r);
958 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
959 /* w2k doesn't have this object */
960 s->domain.w2k3_update_revision = 0;
962 } else if (ret != LDB_SUCCESS) {
963 return NT_STATUS_LDAP(ret);
964 } else if (r->count != 1) {
966 return NT_STATUS_INVALID_NETWORK_RESPONSE;
969 s->domain.w2k3_update_revision = ldb_msg_find_attr_as_uint(r->msgs[0], "revision", 0);
975 static NTSTATUS becomeDC_ldap1_infrastructure_fsmo(struct libnet_BecomeDC_state *s)
978 struct ldb_result *r;
979 struct ldb_dn *basedn;
980 struct ldb_dn *ntds_dn;
981 struct ldb_dn *server_dn;
982 static const char *_1_1_attrs[] = {
986 static const char *fsmo_attrs[] = {
990 static const char *dns_attrs[] = {
994 static const char *guid_attrs[] = {
999 basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "<WKGUID=2fbac1870ade11d297c400c04fd8d5cd,%s>",
1001 NT_STATUS_HAVE_NO_MEMORY(basedn);
1003 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
1004 "(objectClass=*)", _1_1_attrs, &r);
1005 talloc_free(basedn);
1006 if (ret != LDB_SUCCESS) {
1007 return NT_STATUS_LDAP(ret);
1008 } else if (r->count != 1) {
1010 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1013 basedn = talloc_steal(s, r->msgs[0]->dn);
1016 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
1017 "(objectClass=*)", fsmo_attrs, &r);
1018 talloc_free(basedn);
1019 if (ret != LDB_SUCCESS) {
1020 return NT_STATUS_LDAP(ret);
1021 } else if (r->count != 1) {
1023 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1026 s->infrastructure_fsmo.ntds_dn_str = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
1027 if (!s->infrastructure_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1028 talloc_steal(s, s->infrastructure_fsmo.ntds_dn_str);
1032 ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->infrastructure_fsmo.ntds_dn_str);
1033 NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
1035 server_dn = ldb_dn_get_parent(s, ntds_dn);
1036 NT_STATUS_HAVE_NO_MEMORY(server_dn);
1038 s->infrastructure_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
1039 NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.server_dn_str);
1041 ret = ldb_search(s->ldap1.ldb, server_dn, LDB_SCOPE_BASE,
1042 "(objectClass=*)", dns_attrs, &r);
1043 if (ret != LDB_SUCCESS) {
1044 return NT_STATUS_LDAP(ret);
1045 } else if (r->count != 1) {
1047 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1050 s->infrastructure_fsmo.dns_name = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
1051 if (!s->infrastructure_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1052 talloc_steal(s, s->infrastructure_fsmo.dns_name);
1056 ret = ldb_search(s->ldap1.ldb, ntds_dn, LDB_SCOPE_BASE,
1057 "(objectClass=*)", guid_attrs, &r);
1058 if (ret != LDB_SUCCESS) {
1059 return NT_STATUS_LDAP(ret);
1060 } else if (r->count != 1) {
1062 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1065 s->infrastructure_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1069 return NT_STATUS_OK;
1072 static NTSTATUS becomeDC_ldap1_rid_manager_fsmo(struct libnet_BecomeDC_state *s)
1075 struct ldb_result *r;
1076 struct ldb_dn *basedn;
1077 const char *reference_dn_str;
1078 struct ldb_dn *ntds_dn;
1079 struct ldb_dn *server_dn;
1080 static const char *rid_attrs[] = {
1081 "rIDManagerReference",
1084 static const char *fsmo_attrs[] = {
1088 static const char *dns_attrs[] = {
1092 static const char *guid_attrs[] = {
1097 basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
1098 NT_STATUS_HAVE_NO_MEMORY(basedn);
1100 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
1101 "(objectClass=*)", rid_attrs, &r);
1102 talloc_free(basedn);
1103 if (ret != LDB_SUCCESS) {
1104 return NT_STATUS_LDAP(ret);
1105 } else if (r->count != 1) {
1107 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1110 reference_dn_str = samdb_result_string(r->msgs[0], "rIDManagerReference", NULL);
1111 if (!reference_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1113 basedn = ldb_dn_new(s, s->ldap1.ldb, reference_dn_str);
1114 NT_STATUS_HAVE_NO_MEMORY(basedn);
1118 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
1119 "(objectClass=*)", fsmo_attrs, &r);
1120 talloc_free(basedn);
1121 if (ret != LDB_SUCCESS) {
1122 return NT_STATUS_LDAP(ret);
1123 } else if (r->count != 1) {
1125 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1128 s->rid_manager_fsmo.ntds_dn_str = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
1129 if (!s->rid_manager_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1130 talloc_steal(s, s->rid_manager_fsmo.ntds_dn_str);
1134 ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->rid_manager_fsmo.ntds_dn_str);
1135 NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
1137 server_dn = ldb_dn_get_parent(s, ntds_dn);
1138 NT_STATUS_HAVE_NO_MEMORY(server_dn);
1140 s->rid_manager_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
1141 NT_STATUS_HAVE_NO_MEMORY(s->rid_manager_fsmo.server_dn_str);
1143 ret = ldb_search(s->ldap1.ldb, server_dn, LDB_SCOPE_BASE,
1144 "(objectClass=*)", dns_attrs, &r);
1145 if (ret != LDB_SUCCESS) {
1146 return NT_STATUS_LDAP(ret);
1147 } else if (r->count != 1) {
1149 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1152 s->rid_manager_fsmo.dns_name = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
1153 if (!s->rid_manager_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1154 talloc_steal(s, s->rid_manager_fsmo.dns_name);
1158 ret = ldb_search(s->ldap1.ldb, ntds_dn, LDB_SCOPE_BASE,
1159 "(objectClass=*)", guid_attrs, &r);
1160 if (ret != LDB_SUCCESS) {
1161 return NT_STATUS_LDAP(ret);
1162 } else if (r->count != 1) {
1164 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1167 s->rid_manager_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1171 return NT_STATUS_OK;
1174 static NTSTATUS becomeDC_ldap1_site_object(struct libnet_BecomeDC_state *s)
1177 struct ldb_result *r;
1178 struct ldb_dn *basedn;
1180 basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Sites,%s",
1181 s->dest_dsa.site_name,
1182 s->forest.config_dn_str);
1183 NT_STATUS_HAVE_NO_MEMORY(basedn);
1185 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
1186 "(objectClass=*)", NULL, &r);
1187 talloc_free(basedn);
1188 if (ret != LDB_SUCCESS) {
1189 return NT_STATUS_LDAP(ret);
1190 } else if (r->count != 1) {
1192 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1195 s->dest_dsa.site_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1198 return NT_STATUS_OK;
1201 static NTSTATUS becomeDC_check_options(struct libnet_BecomeDC_state *s)
1203 if (!s->callbacks.check_options) return NT_STATUS_OK;
1205 s->_co.domain = &s->domain;
1206 s->_co.forest = &s->forest;
1207 s->_co.source_dsa = &s->source_dsa;
1209 return s->callbacks.check_options(s->callbacks.private_data, &s->_co);
1212 static NTSTATUS becomeDC_ldap1_computer_object(struct libnet_BecomeDC_state *s)
1215 struct ldb_result *r;
1216 struct ldb_dn *basedn;
1218 static const char *attrs[] = {
1219 "distinguishedName",
1220 "userAccountControl",
1224 basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
1225 NT_STATUS_HAVE_NO_MEMORY(basedn);
1227 filter = talloc_asprintf(basedn, "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
1228 s->dest_dsa.netbios_name);
1229 NT_STATUS_HAVE_NO_MEMORY(filter);
1231 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_SUBTREE,
1233 talloc_free(basedn);
1234 if (ret != LDB_SUCCESS) {
1235 return NT_STATUS_LDAP(ret);
1236 } else if (r->count != 1) {
1238 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1241 s->dest_dsa.computer_dn_str = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
1242 if (!s->dest_dsa.computer_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1243 talloc_steal(s, s->dest_dsa.computer_dn_str);
1245 s->dest_dsa.user_account_control = samdb_result_uint(r->msgs[0], "userAccountControl", 0);
1248 return NT_STATUS_OK;
1251 static NTSTATUS becomeDC_ldap1_server_object_1(struct libnet_BecomeDC_state *s)
1254 struct ldb_result *r;
1255 struct ldb_dn *basedn;
1256 const char *server_reference_dn_str;
1257 struct ldb_dn *server_reference_dn;
1258 struct ldb_dn *computer_dn;
1260 basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
1261 s->dest_dsa.netbios_name,
1262 s->dest_dsa.site_name,
1263 s->forest.config_dn_str);
1264 NT_STATUS_HAVE_NO_MEMORY(basedn);
1266 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
1267 "(objectClass=*)", NULL, &r);
1268 talloc_free(basedn);
1269 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1270 /* if the object doesn't exist, we'll create it later */
1271 return NT_STATUS_OK;
1272 } else if (ret != LDB_SUCCESS) {
1273 return NT_STATUS_LDAP(ret);
1274 } else if (r->count != 1) {
1276 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1279 server_reference_dn_str = samdb_result_string(r->msgs[0], "serverReference", NULL);
1280 if (server_reference_dn_str) {
1281 server_reference_dn = ldb_dn_new(r, s->ldap1.ldb, server_reference_dn_str);
1282 NT_STATUS_HAVE_NO_MEMORY(server_reference_dn);
1284 computer_dn = ldb_dn_new(r, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
1285 NT_STATUS_HAVE_NO_MEMORY(computer_dn);
1288 * if the server object belongs to another DC in another domain in the forest,
1289 * we should not touch this object!
1291 if (ldb_dn_compare(computer_dn, server_reference_dn) != 0) {
1293 return NT_STATUS_OBJECT_NAME_COLLISION;
1297 /* if the server object is already for the dest_dsa, then we don't need to create it */
1298 s->dest_dsa.server_dn_str = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
1299 if (!s->dest_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1300 talloc_steal(s, s->dest_dsa.server_dn_str);
1303 return NT_STATUS_OK;
1306 static NTSTATUS becomeDC_ldap1_server_object_2(struct libnet_BecomeDC_state *s)
1309 struct ldb_result *r;
1310 struct ldb_dn *basedn;
1311 const char *server_reference_bl_dn_str;
1312 static const char *attrs[] = {
1313 "serverReferenceBL",
1317 /* if the server_dn_str has a valid value, we skip this lookup */
1318 if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
1320 basedn = ldb_dn_new(s, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
1321 NT_STATUS_HAVE_NO_MEMORY(basedn);
1323 ret = ldb_search(s->ldap1.ldb, basedn, LDB_SCOPE_BASE,
1324 "(objectClass=*)", attrs, &r);
1325 talloc_free(basedn);
1326 if (ret != LDB_SUCCESS) {
1327 return NT_STATUS_LDAP(ret);
1328 } else if (r->count != 1) {
1330 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1333 server_reference_bl_dn_str = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
1334 if (!server_reference_bl_dn_str) {
1335 /* if no back link is present, we're done for this function */
1337 return NT_STATUS_OK;
1340 /* if the server object is already for the dest_dsa, then we don't need to create it */
1341 s->dest_dsa.server_dn_str = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
1342 if (s->dest_dsa.server_dn_str) {
1343 /* if a back link is present, we know that the server object is present */
1344 talloc_steal(s, s->dest_dsa.server_dn_str);
1348 return NT_STATUS_OK;
1351 static NTSTATUS becomeDC_ldap1_server_object_add(struct libnet_BecomeDC_state *s)
1354 struct ldb_message *msg;
1355 char *server_dn_str;
1357 /* if the server_dn_str has a valid value, we skip this lookup */
1358 if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
1360 msg = ldb_msg_new(s);
1361 NT_STATUS_HAVE_NO_MEMORY(msg);
1363 msg->dn = ldb_dn_new_fmt(msg, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
1364 s->dest_dsa.netbios_name,
1365 s->dest_dsa.site_name,
1366 s->forest.config_dn_str);
1367 NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1369 ret = ldb_msg_add_string(msg, "objectClass", "server");
1372 return NT_STATUS_NO_MEMORY;
1374 ret = ldb_msg_add_string(msg, "systemFlags", "50000000");
1377 return NT_STATUS_NO_MEMORY;
1379 ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
1382 return NT_STATUS_NO_MEMORY;
1385 server_dn_str = ldb_dn_alloc_linearized(s, msg->dn);
1386 NT_STATUS_HAVE_NO_MEMORY(server_dn_str);
1388 ret = ldb_add(s->ldap1.ldb, msg);
1390 if (ret != LDB_SUCCESS) {
1391 talloc_free(server_dn_str);
1392 return NT_STATUS_LDAP(ret);
1395 s->dest_dsa.server_dn_str = server_dn_str;
1397 return NT_STATUS_OK;
1400 static NTSTATUS becomeDC_ldap1_server_object_modify(struct libnet_BecomeDC_state *s)
1403 struct ldb_message *msg;
1406 /* make a 'modify' msg, and only for serverReference */
1407 msg = ldb_msg_new(s);
1408 NT_STATUS_HAVE_NO_MEMORY(msg);
1409 msg->dn = ldb_dn_new(msg, s->ldap1.ldb, s->dest_dsa.server_dn_str);
1410 NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1412 ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
1415 return NT_STATUS_NO_MEMORY;
1418 /* mark all the message elements (should be just one)
1419 as LDB_FLAG_MOD_ADD */
1420 for (i=0;i<msg->num_elements;i++) {
1421 msg->elements[i].flags = LDB_FLAG_MOD_ADD;
1424 ret = ldb_modify(s->ldap1.ldb, msg);
1425 if (ret == LDB_SUCCESS) {
1427 return NT_STATUS_OK;
1428 } else if (ret == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) {
1429 /* retry with LDB_FLAG_MOD_REPLACE */
1432 return NT_STATUS_LDAP(ret);
1435 /* mark all the message elements (should be just one)
1436 as LDB_FLAG_MOD_REPLACE */
1437 for (i=0;i<msg->num_elements;i++) {
1438 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
1441 ret = ldb_modify(s->ldap1.ldb, msg);
1443 if (ret != LDB_SUCCESS) {
1444 return NT_STATUS_LDAP(ret);
1447 return NT_STATUS_OK;
1450 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
1451 struct becomeDC_drsuapi *drsuapi,
1452 void (*recv_fn)(struct composite_context *req));
1453 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req);
1454 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s);
1456 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s)
1458 struct composite_context *c = s->creq;
1460 c->status = becomeDC_ldap_connect(s, &s->ldap1);
1461 if (!composite_is_ok(c)) return;
1463 c->status = becomeDC_ldap1_rootdse(s);
1464 if (!composite_is_ok(c)) return;
1466 c->status = becomeDC_ldap1_crossref_behavior_version(s);
1467 if (!composite_is_ok(c)) return;
1469 c->status = becomeDC_ldap1_domain_behavior_version(s);
1470 if (!composite_is_ok(c)) return;
1472 c->status = becomeDC_ldap1_schema_object_version(s);
1473 if (!composite_is_ok(c)) return;
1475 c->status = becomeDC_ldap1_w2k3_update_revision(s);
1476 if (!composite_is_ok(c)) return;
1478 c->status = becomeDC_ldap1_infrastructure_fsmo(s);
1479 if (!composite_is_ok(c)) return;
1481 c->status = becomeDC_ldap1_rid_manager_fsmo(s);
1482 if (!composite_is_ok(c)) return;
1484 c->status = becomeDC_ldap1_site_object(s);
1485 if (!composite_is_ok(c)) return;
1487 c->status = becomeDC_check_options(s);
1488 if (!composite_is_ok(c)) return;
1490 c->status = becomeDC_ldap1_computer_object(s);
1491 if (!composite_is_ok(c)) return;
1493 c->status = becomeDC_ldap1_server_object_1(s);
1494 if (!composite_is_ok(c)) return;
1496 c->status = becomeDC_ldap1_server_object_2(s);
1497 if (!composite_is_ok(c)) return;
1499 c->status = becomeDC_ldap1_server_object_add(s);
1500 if (!composite_is_ok(c)) return;
1502 c->status = becomeDC_ldap1_server_object_modify(s);
1503 if (!composite_is_ok(c)) return;
1505 becomeDC_drsuapi_connect_send(s, &s->drsuapi1, becomeDC_drsuapi1_connect_recv);
1508 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
1509 struct becomeDC_drsuapi *drsuapi,
1510 void (*recv_fn)(struct composite_context *req))
1512 struct composite_context *c = s->creq;
1513 struct composite_context *creq;
1518 if (!drsuapi->binding) {
1519 char *krb5_str = "";
1520 char *print_str = "";
1522 * Note: Replication only works with Windows 2000 when 'krb5' is
1523 * passed as auth_type here. If NTLMSSP is used, Windows
1524 * 2000 returns garbage in the DsGetNCChanges() response
1525 * if encrypted password attributes would be in the response.
1526 * That means the replication of the schema and configuration
1527 * partition works fine, but it fails for the domain partition.
1529 if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
1530 "force krb5", true))
1534 if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
1537 print_str = "print,";
1539 binding_str = talloc_asprintf(s, "ncacn_ip_tcp:%s[%s%sseal]",
1540 s->source_dsa.dns_name,
1541 krb5_str, print_str);
1542 if (composite_nomem(binding_str, c)) return;
1543 c->status = dcerpc_parse_binding(s, binding_str, &drsuapi->binding);
1544 talloc_free(binding_str);
1545 if (!composite_is_ok(c)) return;
1548 creq = dcerpc_pipe_connect_b_send(s, drsuapi->binding, &ndr_table_drsuapi,
1549 s->libnet->cred, s->libnet->event_ctx,
1551 composite_continue(c, creq, recv_fn, s);
1554 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
1555 struct becomeDC_drsuapi *drsuapi,
1556 void (*recv_fn)(struct rpc_request *req));
1557 static void becomeDC_drsuapi1_bind_recv(struct rpc_request *req);
1559 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req)
1561 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
1562 struct libnet_BecomeDC_state);
1563 struct composite_context *c = s->creq;
1565 c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi1.pipe);
1566 if (!composite_is_ok(c)) return;
1568 c->status = gensec_session_key(s->drsuapi1.pipe->conn->security_state.generic_state,
1569 &s->drsuapi1.gensec_skey);
1570 if (!composite_is_ok(c)) return;
1572 becomeDC_drsuapi_bind_send(s, &s->drsuapi1, becomeDC_drsuapi1_bind_recv);
1575 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
1576 struct becomeDC_drsuapi *drsuapi,
1577 void (*recv_fn)(struct rpc_request *req))
1579 struct composite_context *c = s->creq;
1580 struct rpc_request *req;
1581 struct drsuapi_DsBindInfo28 *bind_info28;
1583 GUID_from_string(DRSUAPI_DS_BIND_GUID_W2K3, &drsuapi->bind_guid);
1585 bind_info28 = &drsuapi->local_info28;
1586 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
1587 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION;
1588 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI;
1589 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2;
1590 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS;
1591 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1;
1592 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
1593 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
1594 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
1595 if (s->domain.behavior_version == 2) {
1596 /* TODO: find out how this is really triggered! */
1597 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
1599 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2;
1600 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD;
1601 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND;
1602 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO;
1603 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION;
1604 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01;
1605 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP;
1606 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
1607 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
1608 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_00100000;
1609 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
1610 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
1611 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS;
1612 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8;
1613 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5;
1614 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6;
1615 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
1616 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
1617 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
1618 #if 0 /* we don't support XPRESS compression yet */
1619 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS;
1621 bind_info28->site_guid = s->dest_dsa.site_guid;
1622 bind_info28->pid = 0;
1623 bind_info28->repl_epoch = 0;
1625 drsuapi->bind_info_ctr.length = 28;
1626 drsuapi->bind_info_ctr.info.info28 = *bind_info28;
1628 drsuapi->bind_r.in.bind_guid = &drsuapi->bind_guid;
1629 drsuapi->bind_r.in.bind_info = &drsuapi->bind_info_ctr;
1630 drsuapi->bind_r.out.bind_handle = &drsuapi->bind_handle;
1632 req = dcerpc_drsuapi_DsBind_send(drsuapi->pipe, s, &drsuapi->bind_r);
1633 composite_continue_rpc(c, req, recv_fn, s);
1636 static WERROR becomeDC_drsuapi_bind_recv(struct libnet_BecomeDC_state *s,
1637 struct becomeDC_drsuapi *drsuapi)
1639 if (!W_ERROR_IS_OK(drsuapi->bind_r.out.result)) {
1640 return drsuapi->bind_r.out.result;
1643 ZERO_STRUCT(drsuapi->remote_info28);
1644 if (drsuapi->bind_r.out.bind_info) {
1645 switch (drsuapi->bind_r.out.bind_info->length) {
1647 struct drsuapi_DsBindInfo24 *info24;
1648 info24 = &drsuapi->bind_r.out.bind_info->info.info24;
1649 drsuapi->remote_info28.supported_extensions = info24->supported_extensions;
1650 drsuapi->remote_info28.site_guid = info24->site_guid;
1651 drsuapi->remote_info28.pid = info24->pid;
1652 drsuapi->remote_info28.repl_epoch = 0;
1656 struct drsuapi_DsBindInfo48 *info48;
1657 info48 = &drsuapi->bind_r.out.bind_info->info.info48;
1658 drsuapi->remote_info28.supported_extensions = info48->supported_extensions;
1659 drsuapi->remote_info28.site_guid = info48->site_guid;
1660 drsuapi->remote_info28.pid = info48->pid;
1661 drsuapi->remote_info28.repl_epoch = info48->repl_epoch;
1665 drsuapi->remote_info28 = drsuapi->bind_r.out.bind_info->info.info28;
1673 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s);
1675 static void becomeDC_drsuapi1_bind_recv(struct rpc_request *req)
1677 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
1678 struct libnet_BecomeDC_state);
1679 struct composite_context *c = s->creq;
1684 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
1688 c->status = dcerpc_ndr_request_recv(req);
1689 if (!composite_is_ok(c)) return;
1692 NDR_PRINT_OUT_DEBUG(drsuapi_DsBind, &s->drsuapi1.bind_r);
1695 status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi1);
1696 if (!W_ERROR_IS_OK(status)) {
1697 composite_error(c, werror_to_ntstatus(status));
1701 becomeDC_drsuapi1_add_entry_send(s);
1704 static void becomeDC_drsuapi1_add_entry_recv(struct rpc_request *req);
1706 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s)
1708 struct composite_context *c = s->creq;
1709 struct rpc_request *req;
1710 struct drsuapi_DsAddEntry *r;
1711 struct drsuapi_DsReplicaObjectIdentifier *identifier;
1712 uint32_t num_attrs, i = 0;
1713 struct drsuapi_DsReplicaAttribute *attrs;
1714 struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(s->libnet->lp_ctx);
1715 enum ndr_err_code ndr_err;
1718 /* choose a random invocationId */
1719 s->dest_dsa.invocation_id = GUID_random();
1722 * if the schema version indicates w2k3, then
1723 * also send some w2k3 specific attributes
1725 if (s->forest.schema_object_version >= 30) {
1731 r = talloc_zero(s, struct drsuapi_DsAddEntry);
1732 if (composite_nomem(r, c)) return;
1734 /* setup identifier */
1735 identifier = talloc(r, struct drsuapi_DsReplicaObjectIdentifier);
1736 if (composite_nomem(identifier, c)) return;
1737 identifier->guid = GUID_zero();
1738 identifier->sid = s->zero_sid;
1739 identifier->dn = talloc_asprintf(identifier, "CN=NTDS Settings,%s",
1740 s->dest_dsa.server_dn_str);
1741 if (composite_nomem(identifier->dn, c)) return;
1743 /* allocate attribute array */
1745 attrs = talloc_array(r, struct drsuapi_DsReplicaAttribute, num_attrs);
1746 if (composite_nomem(attrs, c)) return;
1748 /* ntSecurityDescriptor */
1750 struct drsuapi_DsAttributeValue *vs;
1752 struct security_descriptor *v;
1753 struct dom_sid *domain_admins_sid;
1754 const char *domain_admins_sid_str;
1756 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1757 if (composite_nomem(vs, c)) return;
1759 vd = talloc_array(vs, DATA_BLOB, 1);
1760 if (composite_nomem(vd, c)) return;
1762 domain_admins_sid = dom_sid_add_rid(vs, s->domain.sid, DOMAIN_RID_ADMINS);
1763 if (composite_nomem(domain_admins_sid, c)) return;
1765 domain_admins_sid_str = dom_sid_string(domain_admins_sid, domain_admins_sid);
1766 if (composite_nomem(domain_admins_sid_str, c)) return;
1768 v = security_descriptor_dacl_create(vd,
1770 /* owner: domain admins */
1771 domain_admins_sid_str,
1772 /* owner group: domain admins */
1773 domain_admins_sid_str,
1774 /* authenticated users */
1775 SID_NT_AUTHENTICATED_USERS,
1776 SEC_ACE_TYPE_ACCESS_ALLOWED,
1777 SEC_STD_READ_CONTROL |
1780 SEC_ADS_LIST_OBJECT,
1783 domain_admins_sid_str,
1784 SEC_ACE_TYPE_ACCESS_ALLOWED,
1786 SEC_ADS_CREATE_CHILD |
1788 SEC_ADS_SELF_WRITE |
1790 SEC_ADS_WRITE_PROP |
1791 SEC_ADS_DELETE_TREE |
1792 SEC_ADS_LIST_OBJECT |
1793 SEC_ADS_CONTROL_ACCESS,
1797 SEC_ACE_TYPE_ACCESS_ALLOWED,
1799 SEC_ADS_CREATE_CHILD |
1800 SEC_ADS_DELETE_CHILD |
1802 SEC_ADS_SELF_WRITE |
1804 SEC_ADS_WRITE_PROP |
1805 SEC_ADS_DELETE_TREE |
1806 SEC_ADS_LIST_OBJECT |
1807 SEC_ADS_CONTROL_ACCESS,
1811 if (composite_nomem(v, c)) return;
1813 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, v,(ndr_push_flags_fn_t)ndr_push_security_descriptor);
1814 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1815 c->status = ndr_map_error2ntstatus(ndr_err);
1816 if (!composite_is_ok(c)) return;
1819 vs[0].blob = &vd[0];
1821 attrs[i].attid = DRSUAPI_ATTRIBUTE_ntSecurityDescriptor;
1822 attrs[i].value_ctr.num_values = 1;
1823 attrs[i].value_ctr.values = vs;
1828 /* objectClass: nTDSDSA */
1830 struct drsuapi_DsAttributeValue *vs;
1833 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1834 if (composite_nomem(vs, c)) return;
1836 vd = talloc_array(vs, DATA_BLOB, 1);
1837 if (composite_nomem(vd, c)) return;
1839 vd[0] = data_blob_talloc(vd, NULL, 4);
1840 if (composite_nomem(vd[0].data, c)) return;
1842 /* value for nTDSDSA */
1843 SIVAL(vd[0].data, 0, 0x0017002F);
1845 vs[0].blob = &vd[0];
1847 attrs[i].attid = DRSUAPI_ATTRIBUTE_objectClass;
1848 attrs[i].value_ctr.num_values = 1;
1849 attrs[i].value_ctr.values = vs;
1854 /* objectCategory: CN=NTDS-DSA,CN=Schema,... */
1856 struct drsuapi_DsAttributeValue *vs;
1858 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
1860 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1861 if (composite_nomem(vs, c)) return;
1863 vd = talloc_array(vs, DATA_BLOB, 1);
1864 if (composite_nomem(vd, c)) return;
1866 v[0].guid = GUID_zero();
1867 v[0].sid = s->zero_sid;
1868 v[0].dn = talloc_asprintf(vd, "CN=NTDS-DSA,%s",
1869 s->forest.schema_dn_str);
1870 if (composite_nomem(v[0].dn, c)) return;
1872 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
1873 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1874 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1875 c->status = ndr_map_error2ntstatus(ndr_err);
1876 if (!composite_is_ok(c)) return;
1879 vs[0].blob = &vd[0];
1881 attrs[i].attid = DRSUAPI_ATTRIBUTE_objectCategory;
1882 attrs[i].value_ctr.num_values = 1;
1883 attrs[i].value_ctr.values = vs;
1888 /* invocationId: random guid */
1890 struct drsuapi_DsAttributeValue *vs;
1892 const struct GUID *v;
1894 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1895 if (composite_nomem(vs, c)) return;
1897 vd = talloc_array(vs, DATA_BLOB, 1);
1898 if (composite_nomem(vd, c)) return;
1900 v = &s->dest_dsa.invocation_id;
1902 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, v, (ndr_push_flags_fn_t)ndr_push_GUID);
1903 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1904 c->status = ndr_map_error2ntstatus(ndr_err);
1905 if (!composite_is_ok(c)) return;
1908 vs[0].blob = &vd[0];
1910 attrs[i].attid = DRSUAPI_ATTRIBUTE_invocationId;
1911 attrs[i].value_ctr.num_values = 1;
1912 attrs[i].value_ctr.values = vs;
1917 /* hasMasterNCs: ... */
1919 struct drsuapi_DsAttributeValue *vs;
1921 struct drsuapi_DsReplicaObjectIdentifier3 v[3];
1923 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 3);
1924 if (composite_nomem(vs, c)) return;
1926 vd = talloc_array(vs, DATA_BLOB, 3);
1927 if (composite_nomem(vd, c)) return;
1929 v[0].guid = GUID_zero();
1930 v[0].sid = s->zero_sid;
1931 v[0].dn = s->forest.config_dn_str;
1933 v[1].guid = GUID_zero();
1934 v[1].sid = s->zero_sid;
1935 v[1].dn = s->domain.dn_str;
1937 v[2].guid = GUID_zero();
1938 v[2].sid = s->zero_sid;
1939 v[2].dn = s->forest.schema_dn_str;
1941 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
1942 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1943 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1944 c->status = ndr_map_error2ntstatus(ndr_err);
1945 if (!composite_is_ok(c)) return;
1948 ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
1949 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1950 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1951 c->status = ndr_map_error2ntstatus(ndr_err);
1952 if (!composite_is_ok(c)) return;
1955 ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
1956 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1957 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1958 c->status = ndr_map_error2ntstatus(ndr_err);
1959 if (!composite_is_ok(c)) return;
1962 vs[0].blob = &vd[0];
1963 vs[1].blob = &vd[1];
1964 vs[2].blob = &vd[2];
1966 attrs[i].attid = DRSUAPI_ATTRIBUTE_hasMasterNCs;
1967 attrs[i].value_ctr.num_values = 3;
1968 attrs[i].value_ctr.values = vs;
1973 /* msDS-hasMasterNCs: ... */
1975 struct drsuapi_DsAttributeValue *vs;
1977 struct drsuapi_DsReplicaObjectIdentifier3 v[3];
1979 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 3);
1980 if (composite_nomem(vs, c)) return;
1982 vd = talloc_array(vs, DATA_BLOB, 3);
1983 if (composite_nomem(vd, c)) return;
1985 v[0].guid = GUID_zero();
1986 v[0].sid = s->zero_sid;
1987 v[0].dn = s->forest.config_dn_str;
1989 v[1].guid = GUID_zero();
1990 v[1].sid = s->zero_sid;
1991 v[1].dn = s->domain.dn_str;
1993 v[2].guid = GUID_zero();
1994 v[2].sid = s->zero_sid;
1995 v[2].dn = s->forest.schema_dn_str;
1997 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
1998 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1999 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2000 c->status = ndr_map_error2ntstatus(ndr_err);
2001 if (!composite_is_ok(c)) return;
2004 ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
2005 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2006 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2007 c->status = ndr_map_error2ntstatus(ndr_err);
2008 if (!composite_is_ok(c)) return;
2011 ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
2012 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2013 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2014 c->status = ndr_map_error2ntstatus(ndr_err);
2015 if (!composite_is_ok(c)) return;
2018 vs[0].blob = &vd[0];
2019 vs[1].blob = &vd[1];
2020 vs[2].blob = &vd[2];
2022 attrs[i].attid = DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs;
2023 attrs[i].value_ctr.num_values = 3;
2024 attrs[i].value_ctr.values = vs;
2029 /* dMDLocation: CN=Schema,... */
2031 struct drsuapi_DsAttributeValue *vs;
2033 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2035 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2036 if (composite_nomem(vs, c)) return;
2038 vd = talloc_array(vs, DATA_BLOB, 1);
2039 if (composite_nomem(vd, c)) return;
2041 v[0].guid = GUID_zero();
2042 v[0].sid = s->zero_sid;
2043 v[0].dn = s->forest.schema_dn_str;
2045 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2046 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2047 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2048 c->status = ndr_map_error2ntstatus(ndr_err);
2049 if (!composite_is_ok(c)) return;
2052 vs[0].blob = &vd[0];
2054 attrs[i].attid = DRSUAPI_ATTRIBUTE_dMDLocation;
2055 attrs[i].value_ctr.num_values = 1;
2056 attrs[i].value_ctr.values = vs;
2061 /* msDS-HasDomainNCs: <domain_partition> */
2063 struct drsuapi_DsAttributeValue *vs;
2065 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2067 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2068 if (composite_nomem(vs, c)) return;
2070 vd = talloc_array(vs, DATA_BLOB, 1);
2071 if (composite_nomem(vd, c)) return;
2073 v[0].guid = GUID_zero();
2074 v[0].sid = s->zero_sid;
2075 v[0].dn = s->domain.dn_str;
2077 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2078 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2079 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2080 c->status = ndr_map_error2ntstatus(ndr_err);
2081 if (!composite_is_ok(c)) return;
2084 vs[0].blob = &vd[0];
2086 attrs[i].attid = DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs;
2087 attrs[i].value_ctr.num_values = 1;
2088 attrs[i].value_ctr.values = vs;
2093 /* msDS-Behavior-Version */
2095 struct drsuapi_DsAttributeValue *vs;
2098 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2099 if (composite_nomem(vs, c)) return;
2101 vd = talloc_array(vs, DATA_BLOB, 1);
2102 if (composite_nomem(vd, c)) return;
2104 vd[0] = data_blob_talloc(vd, NULL, 4);
2105 if (composite_nomem(vd[0].data, c)) return;
2107 SIVAL(vd[0].data, 0, DS_BEHAVIOR_WIN2008);
2109 vs[0].blob = &vd[0];
2111 attrs[i].attid = DRSUAPI_ATTRIBUTE_msDS_Behavior_Version;
2112 attrs[i].value_ctr.num_values = 1;
2113 attrs[i].value_ctr.values = vs;
2120 struct drsuapi_DsAttributeValue *vs;
2123 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2124 if (composite_nomem(vs, c)) return;
2126 vd = talloc_array(vs, DATA_BLOB, 1);
2127 if (composite_nomem(vd, c)) return;
2129 vd[0] = data_blob_talloc(vd, NULL, 4);
2130 if (composite_nomem(vd[0].data, c)) return;
2132 SIVAL(vd[0].data, 0, SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
2134 vs[0].blob = &vd[0];
2136 attrs[i].attid = DRSUAPI_ATTRIBUTE_systemFlags;
2137 attrs[i].value_ctr.num_values = 1;
2138 attrs[i].value_ctr.values = vs;
2143 /* serverReference: ... */
2145 struct drsuapi_DsAttributeValue *vs;
2147 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2149 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2150 if (composite_nomem(vs, c)) return;
2152 vd = talloc_array(vs, DATA_BLOB, 1);
2153 if (composite_nomem(vd, c)) return;
2155 v[0].guid = GUID_zero();
2156 v[0].sid = s->zero_sid;
2157 v[0].dn = s->dest_dsa.computer_dn_str;
2159 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2160 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2161 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2162 c->status = ndr_map_error2ntstatus(ndr_err);
2163 if (!composite_is_ok(c)) return;
2166 vs[0].blob = &vd[0];
2168 attrs[i].attid = DRSUAPI_ATTRIBUTE_serverReference;
2169 attrs[i].value_ctr.num_values = 1;
2170 attrs[i].value_ctr.values = vs;
2175 /* truncate the attribute list to the attribute count we have filled in */
2178 /* setup request structure */
2179 r->in.bind_handle = &s->drsuapi1.bind_handle;
2181 r->in.req.req2.first_object.next_object = NULL;
2182 r->in.req.req2.first_object.object.identifier = identifier;
2183 r->in.req.req2.first_object.object.flags = 0x00000000;
2184 r->in.req.req2.first_object.object.attribute_ctr.num_attributes = num_attrs;
2185 r->in.req.req2.first_object.object.attribute_ctr.attributes = attrs;
2187 req = dcerpc_drsuapi_DsAddEntry_send(s->drsuapi1.pipe, r, r);
2188 composite_continue_rpc(c, req, becomeDC_drsuapi1_add_entry_recv, s);
2191 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req);
2192 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s);
2194 static void becomeDC_drsuapi1_add_entry_recv(struct rpc_request *req)
2196 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2197 struct libnet_BecomeDC_state);
2198 struct composite_context *c = s->creq;
2199 struct drsuapi_DsAddEntry *r = talloc_get_type(req->ndr.struct_ptr,
2200 struct drsuapi_DsAddEntry);
2204 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2208 c->status = dcerpc_ndr_request_recv(req);
2209 if (!composite_is_ok(c)) return;
2212 NDR_PRINT_OUT_DEBUG(drsuapi_DsAddEntry, r);
2215 if (!W_ERROR_IS_OK(r->out.result)) {
2216 composite_error(c, werror_to_ntstatus(r->out.result));
2220 if (r->out.level == 3) {
2221 if (r->out.ctr.ctr3.count != 1) {
2224 if (r->out.ctr.ctr3.level != 1) {
2225 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2229 if (!r->out.ctr.ctr3.error) {
2230 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2234 status = r->out.ctr.ctr3.error->info1.status;
2236 if (!r->out.ctr.ctr3.error->info1.info) {
2237 composite_error(c, werror_to_ntstatus(status));
2241 /* see if we can get a more detailed error */
2242 switch (r->out.ctr.ctr3.error->info1.level) {
2244 status = r->out.ctr.ctr3.error->info1.info->error1.status;
2250 status = r->out.ctr.ctr3.error->info1.info->errorX.status;
2254 composite_error(c, werror_to_ntstatus(status));
2258 s->dest_dsa.ntds_guid = r->out.ctr.ctr3.objects[0].guid;
2259 } else if (r->out.level == 2) {
2260 if (r->out.ctr.ctr2.count != 1) {
2261 composite_error(c, werror_to_ntstatus(r->out.ctr.ctr2.error.status));
2265 s->dest_dsa.ntds_guid = r->out.ctr.ctr2.objects[0].guid;
2267 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2273 s->dest_dsa.ntds_dn_str = talloc_asprintf(s, "CN=NTDS Settings,%s",
2274 s->dest_dsa.server_dn_str);
2275 if (composite_nomem(s->dest_dsa.ntds_dn_str, c)) return;
2277 c->status = becomeDC_prepare_db(s);
2278 if (!composite_is_ok(c)) return;
2280 /* this avoids the epmapper lookup on the 2nd connection */
2281 binding_str = dcerpc_binding_string(s, s->drsuapi1.binding);
2282 if (composite_nomem(binding_str, c)) return;
2284 c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi2.binding);
2285 talloc_free(binding_str);
2286 if (!composite_is_ok(c)) return;
2288 /* w2k3 uses the same assoc_group_id as on the first connection, so we do */
2289 s->drsuapi2.binding->assoc_group_id = s->drsuapi1.pipe->assoc_group_id;
2291 becomeDC_drsuapi_connect_send(s, &s->drsuapi2, becomeDC_drsuapi2_connect_recv);
2294 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s)
2296 if (!s->callbacks.prepare_db) return NT_STATUS_OK;
2298 s->_pp.domain = &s->domain;
2299 s->_pp.forest = &s->forest;
2300 s->_pp.source_dsa = &s->source_dsa;
2301 s->_pp.dest_dsa = &s->dest_dsa;
2303 return s->callbacks.prepare_db(s->callbacks.private_data, &s->_pp);
2306 static void becomeDC_drsuapi2_bind_recv(struct rpc_request *req);
2308 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req)
2310 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2311 struct libnet_BecomeDC_state);
2312 struct composite_context *c = s->creq;
2314 c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi2.pipe);
2315 if (!composite_is_ok(c)) return;
2317 c->status = gensec_session_key(s->drsuapi2.pipe->conn->security_state.generic_state,
2318 &s->drsuapi2.gensec_skey);
2319 if (!composite_is_ok(c)) return;
2321 becomeDC_drsuapi_bind_send(s, &s->drsuapi2, becomeDC_drsuapi2_bind_recv);
2324 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req);
2326 static void becomeDC_drsuapi2_bind_recv(struct rpc_request *req)
2328 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2329 struct libnet_BecomeDC_state);
2330 struct composite_context *c = s->creq;
2336 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2340 c->status = dcerpc_ndr_request_recv(req);
2341 if (!composite_is_ok(c)) return;
2344 NDR_PRINT_OUT_DEBUG(drsuapi_DsBind, &s->drsuapi2.bind_r);
2347 status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi2);
2348 if (!W_ERROR_IS_OK(status)) {
2349 composite_error(c, werror_to_ntstatus(status));
2353 /* this avoids the epmapper lookup on the 3rd connection */
2354 binding_str = dcerpc_binding_string(s, s->drsuapi1.binding);
2355 if (composite_nomem(binding_str, c)) return;
2357 c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi3.binding);
2358 talloc_free(binding_str);
2359 if (!composite_is_ok(c)) return;
2361 /* w2k3 uses the same assoc_group_id as on the first connection, so we do */
2362 s->drsuapi3.binding->assoc_group_id = s->drsuapi1.pipe->assoc_group_id;
2363 /* w2k3 uses the concurrent multiplex feature on the 3rd connection, so we do */
2364 s->drsuapi3.binding->flags |= DCERPC_CONCURRENT_MULTIPLEX;
2366 becomeDC_drsuapi_connect_send(s, &s->drsuapi3, becomeDC_drsuapi3_connect_recv);
2369 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s);
2371 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req)
2373 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2374 struct libnet_BecomeDC_state);
2375 struct composite_context *c = s->creq;
2377 c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi3.pipe);
2378 if (!composite_is_ok(c)) return;
2380 c->status = gensec_session_key(s->drsuapi3.pipe->conn->security_state.generic_state,
2381 &s->drsuapi3.gensec_skey);
2382 if (!composite_is_ok(c)) return;
2384 becomeDC_drsuapi3_pull_schema_send(s);
2387 static void becomeDC_drsuapi_pull_partition_send(struct libnet_BecomeDC_state *s,
2388 struct becomeDC_drsuapi *drsuapi_h,
2389 struct becomeDC_drsuapi *drsuapi_p,
2390 struct libnet_BecomeDC_Partition *partition,
2391 void (*recv_fn)(struct rpc_request *req))
2393 struct composite_context *c = s->creq;
2394 struct rpc_request *req;
2395 struct drsuapi_DsGetNCChanges *r;
2397 r = talloc(s, struct drsuapi_DsGetNCChanges);
2398 if (composite_nomem(r, c)) return;
2400 r->in.level = talloc(r, int32_t);
2401 if (composite_nomem(r->in.level, c)) return;
2402 r->out.level = talloc(r, int32_t);
2403 if (composite_nomem(r->out.level, c)) return;
2405 r->in.bind_handle = &drsuapi_h->bind_handle;
2406 if (drsuapi_h->remote_info28.supported_extensions & DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8) {
2408 r->in.req.req8.destination_dsa_guid = partition->destination_dsa_guid;
2409 r->in.req.req8.source_dsa_invocation_id = partition->source_dsa_invocation_id;
2410 r->in.req.req8.naming_context = &partition->nc;
2411 r->in.req.req8.highwatermark = partition->highwatermark;
2412 r->in.req.req8.uptodateness_vector = NULL;
2413 r->in.req.req8.replica_flags = partition->replica_flags;
2414 r->in.req.req8.max_object_count = 133;
2415 r->in.req.req8.max_ndr_size = 1336811;
2416 r->in.req.req8.extended_op = DRSUAPI_EXOP_NONE;
2417 r->in.req.req8.fsmo_info = 0;
2418 r->in.req.req8.partial_attribute_set = NULL;
2419 r->in.req.req8.partial_attribute_set_ex = NULL;
2420 r->in.req.req8.mapping_ctr.num_mappings = 0;
2421 r->in.req.req8.mapping_ctr.mappings = NULL;
2424 r->in.req.req5.destination_dsa_guid = partition->destination_dsa_guid;
2425 r->in.req.req5.source_dsa_invocation_id = partition->source_dsa_invocation_id;
2426 r->in.req.req5.naming_context = &partition->nc;
2427 r->in.req.req5.highwatermark = partition->highwatermark;
2428 r->in.req.req5.uptodateness_vector = NULL;
2429 r->in.req.req5.replica_flags = partition->replica_flags;
2430 r->in.req.req5.max_object_count = 133;
2431 r->in.req.req5.max_ndr_size = 1336770;
2432 r->in.req.req5.extended_op = DRSUAPI_EXOP_NONE;
2433 r->in.req.req5.fsmo_info = 0;
2437 * we should try to use the drsuapi_p->pipe here, as w2k3 does
2438 * but it seems that some extra flags in the DCERPC Bind call
2439 * are needed for it. Or the same KRB5 TGS is needed on both
2442 req = dcerpc_drsuapi_DsGetNCChanges_send(drsuapi_p->pipe, r, r);
2443 composite_continue_rpc(c, req, recv_fn, s);
2446 static WERROR becomeDC_drsuapi_pull_partition_recv(struct libnet_BecomeDC_state *s,
2447 struct becomeDC_drsuapi *drsuapi_h,
2448 struct becomeDC_drsuapi *drsuapi_p,
2449 struct libnet_BecomeDC_Partition *partition,
2450 struct drsuapi_DsGetNCChanges *r)
2452 uint32_t ctr_level = 0;
2453 struct drsuapi_DsGetNCChangesCtr1 *ctr1 = NULL;
2454 struct drsuapi_DsGetNCChangesCtr6 *ctr6 = NULL;
2455 struct GUID *source_dsa_guid;
2456 struct GUID *source_dsa_invocation_id;
2457 struct drsuapi_DsReplicaHighWaterMark *new_highwatermark;
2458 bool more_data = false;
2461 if (!W_ERROR_IS_OK(r->out.result)) {
2462 return r->out.result;
2465 if (*r->out.level == 1) {
2467 ctr1 = &r->out.ctr.ctr1;
2468 } else if (*r->out.level == 2) {
2470 ctr1 = r->out.ctr.ctr2.ctr.mszip1.ctr1;
2471 } else if (*r->out.level == 6) {
2473 ctr6 = &r->out.ctr.ctr6;
2474 } else if (*r->out.level == 7 &&
2475 r->out.ctr.ctr7.level == 6 &&
2476 r->out.ctr.ctr7.type == DRSUAPI_COMPRESSION_TYPE_MSZIP) {
2478 ctr6 = r->out.ctr.ctr7.ctr.mszip6.ctr6;
2479 } else if (*r->out.level == 7 &&
2480 r->out.ctr.ctr7.level == 6 &&
2481 r->out.ctr.ctr7.type == DRSUAPI_COMPRESSION_TYPE_XPRESS) {
2483 ctr6 = r->out.ctr.ctr7.ctr.xpress6.ctr6;
2485 return WERR_BAD_NET_RESP;
2488 if (ctr_level == 6) {
2489 if (!W_ERROR_IS_OK(ctr6->drs_error)) {
2490 return ctr6->drs_error;
2494 switch (ctr_level) {
2496 source_dsa_guid = &ctr1->source_dsa_guid;
2497 source_dsa_invocation_id = &ctr1->source_dsa_invocation_id;
2498 new_highwatermark = &ctr1->new_highwatermark;
2499 more_data = ctr1->more_data;
2502 source_dsa_guid = &ctr6->source_dsa_guid;
2503 source_dsa_invocation_id = &ctr6->source_dsa_invocation_id;
2504 new_highwatermark = &ctr6->new_highwatermark;
2505 more_data = ctr6->more_data;
2509 partition->highwatermark = *new_highwatermark;
2510 partition->source_dsa_guid = *source_dsa_guid;
2511 partition->source_dsa_invocation_id = *source_dsa_invocation_id;
2512 partition->more_data = more_data;
2514 if (!partition->store_chunk) return WERR_OK;
2516 s->_sc.domain = &s->domain;
2517 s->_sc.forest = &s->forest;
2518 s->_sc.source_dsa = &s->source_dsa;
2519 s->_sc.dest_dsa = &s->dest_dsa;
2520 s->_sc.partition = partition;
2521 s->_sc.ctr_level = ctr_level;
2525 * we need to use the drsuapi_p->gensec_skey here,
2526 * when we use drsuapi_p->pipe in the for this request
2528 s->_sc.gensec_skey = &drsuapi_p->gensec_skey;
2530 nt_status = partition->store_chunk(s->callbacks.private_data, &s->_sc);
2531 if (!NT_STATUS_IS_OK(nt_status)) {
2532 return ntstatus_to_werror(nt_status);
2538 static void becomeDC_drsuapi3_pull_schema_recv(struct rpc_request *req);
2540 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s)
2542 s->schema_part.nc.guid = GUID_zero();
2543 s->schema_part.nc.sid = s->zero_sid;
2544 s->schema_part.nc.dn = s->forest.schema_dn_str;
2546 s->schema_part.destination_dsa_guid = s->drsuapi2.bind_guid;
2548 s->schema_part.replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
2549 | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
2550 | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
2551 | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
2552 | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
2553 | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
2555 s->schema_part.store_chunk = s->callbacks.schema_chunk;
2557 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
2558 becomeDC_drsuapi3_pull_schema_recv);
2561 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s);
2563 static void becomeDC_drsuapi3_pull_schema_recv(struct rpc_request *req)
2565 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2566 struct libnet_BecomeDC_state);
2567 struct composite_context *c = s->creq;
2568 struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
2569 struct drsuapi_DsGetNCChanges);
2574 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2578 c->status = dcerpc_ndr_request_recv(req);
2579 if (!composite_is_ok(c)) return;
2582 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
2585 status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part, r);
2586 if (!W_ERROR_IS_OK(status)) {
2587 composite_error(c, werror_to_ntstatus(status));
2593 if (s->schema_part.more_data) {
2594 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
2595 becomeDC_drsuapi3_pull_schema_recv);
2599 becomeDC_drsuapi3_pull_config_send(s);
2602 static void becomeDC_drsuapi3_pull_config_recv(struct rpc_request *req);
2604 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s)
2606 s->config_part.nc.guid = GUID_zero();
2607 s->config_part.nc.sid = s->zero_sid;
2608 s->config_part.nc.dn = s->forest.config_dn_str;
2610 s->config_part.destination_dsa_guid = s->drsuapi2.bind_guid;
2612 s->config_part.replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
2613 | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
2614 | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
2615 | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
2616 | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
2617 | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
2619 s->config_part.store_chunk = s->callbacks.config_chunk;
2621 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
2622 becomeDC_drsuapi3_pull_config_recv);
2625 static void becomeDC_drsuapi3_pull_config_recv(struct rpc_request *req)
2627 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2628 struct libnet_BecomeDC_state);
2629 struct composite_context *c = s->creq;
2630 struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
2631 struct drsuapi_DsGetNCChanges);
2636 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2640 c->status = dcerpc_ndr_request_recv(req);
2641 if (!composite_is_ok(c)) return;
2644 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
2647 status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->config_part, r);
2648 if (!W_ERROR_IS_OK(status)) {
2649 composite_error(c, werror_to_ntstatus(status));
2655 if (s->config_part.more_data) {
2656 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
2657 becomeDC_drsuapi3_pull_config_recv);
2661 becomeDC_connect_ldap2(s);
2664 static void becomeDC_drsuapi3_pull_domain_recv(struct rpc_request *req);
2666 static void becomeDC_drsuapi3_pull_domain_send(struct libnet_BecomeDC_state *s)
2668 s->domain_part.nc.guid = GUID_zero();
2669 s->domain_part.nc.sid = s->zero_sid;
2670 s->domain_part.nc.dn = s->domain.dn_str;
2672 s->domain_part.destination_dsa_guid = s->drsuapi2.bind_guid;
2674 s->domain_part.replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
2675 | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
2676 | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
2677 | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
2678 | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
2679 | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
2681 s->domain_part.store_chunk = s->callbacks.domain_chunk;
2683 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
2684 becomeDC_drsuapi3_pull_domain_recv);
2687 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
2688 struct becomeDC_drsuapi *drsuapi,
2689 struct libnet_BecomeDC_Partition *partition,
2690 void (*recv_fn)(struct rpc_request *req));
2691 static void becomeDC_drsuapi2_update_refs_schema_recv(struct rpc_request *req);
2693 static void becomeDC_drsuapi3_pull_domain_recv(struct rpc_request *req)
2695 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2696 struct libnet_BecomeDC_state);
2697 struct composite_context *c = s->creq;
2698 struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
2699 struct drsuapi_DsGetNCChanges);
2703 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2707 c->status = dcerpc_ndr_request_recv(req);
2708 if (!composite_is_ok(c)) return;
2711 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
2714 status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part, r);
2715 if (!W_ERROR_IS_OK(status)) {
2716 composite_error(c, werror_to_ntstatus(status));
2722 if (s->domain_part.more_data) {
2723 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
2724 becomeDC_drsuapi3_pull_domain_recv);
2728 becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->schema_part,
2729 becomeDC_drsuapi2_update_refs_schema_recv);
2732 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
2733 struct becomeDC_drsuapi *drsuapi,
2734 struct libnet_BecomeDC_Partition *partition,
2735 void (*recv_fn)(struct rpc_request *req))
2737 struct composite_context *c = s->creq;
2738 struct rpc_request *req;
2739 struct drsuapi_DsReplicaUpdateRefs *r;
2740 const char *ntds_guid_str;
2741 const char *ntds_dns_name;
2743 r = talloc(s, struct drsuapi_DsReplicaUpdateRefs);
2744 if (composite_nomem(r, c)) return;
2746 ntds_guid_str = GUID_string(r, &s->dest_dsa.ntds_guid);
2747 if (composite_nomem(ntds_guid_str, c)) return;
2749 ntds_dns_name = talloc_asprintf(r, "%s._msdcs.%s",
2751 s->domain.dns_name);
2752 if (composite_nomem(ntds_dns_name, c)) return;
2754 r->in.bind_handle = &drsuapi->bind_handle;
2756 r->in.req.req1.naming_context = &partition->nc;
2757 r->in.req.req1.dest_dsa_dns_name= ntds_dns_name;
2758 r->in.req.req1.dest_dsa_guid = s->dest_dsa.ntds_guid;
2759 r->in.req.req1.options = DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE
2760 | DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE
2761 | DRSUAPI_DS_REPLICA_UPDATE_0x00000010;
2763 req = dcerpc_drsuapi_DsReplicaUpdateRefs_send(drsuapi->pipe, r, r);
2764 composite_continue_rpc(c, req, recv_fn, s);
2767 static void becomeDC_drsuapi2_update_refs_config_recv(struct rpc_request *req);
2769 static void becomeDC_drsuapi2_update_refs_schema_recv(struct rpc_request *req)
2771 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2772 struct libnet_BecomeDC_state);
2773 struct composite_context *c = s->creq;
2774 struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
2775 struct drsuapi_DsReplicaUpdateRefs);
2778 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2782 c->status = dcerpc_ndr_request_recv(req);
2783 if (!composite_is_ok(c)) return;
2786 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaUpdateRefs, r);
2789 if (!W_ERROR_IS_OK(r->out.result)) {
2790 composite_error(c, werror_to_ntstatus(r->out.result));
2796 becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->config_part,
2797 becomeDC_drsuapi2_update_refs_config_recv);
2800 static void becomeDC_drsuapi2_update_refs_domain_recv(struct rpc_request *req);
2802 static void becomeDC_drsuapi2_update_refs_config_recv(struct rpc_request *req)
2804 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2805 struct libnet_BecomeDC_state);
2806 struct composite_context *c = s->creq;
2807 struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
2808 struct drsuapi_DsReplicaUpdateRefs);
2810 c->status = dcerpc_ndr_request_recv(req);
2811 if (!composite_is_ok(c)) return;
2813 if (!W_ERROR_IS_OK(r->out.result)) {
2814 composite_error(c, werror_to_ntstatus(r->out.result));
2820 becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->domain_part,
2821 becomeDC_drsuapi2_update_refs_domain_recv);
2824 static void becomeDC_drsuapi2_update_refs_domain_recv(struct rpc_request *req)
2826 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2827 struct libnet_BecomeDC_state);
2828 struct composite_context *c = s->creq;
2829 struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
2830 struct drsuapi_DsReplicaUpdateRefs);
2832 c->status = dcerpc_ndr_request_recv(req);
2833 if (!composite_is_ok(c)) return;
2835 if (!W_ERROR_IS_OK(r->out.result)) {
2836 composite_error(c, werror_to_ntstatus(r->out.result));
2842 /* TODO: use DDNS updates and register dns names */
2846 static NTSTATUS becomeDC_ldap2_modify_computer(struct libnet_BecomeDC_state *s)
2849 struct ldb_message *msg;
2851 uint32_t user_account_control = UF_SERVER_TRUST_ACCOUNT |
2852 UF_TRUSTED_FOR_DELEGATION;
2854 /* as the value is already as we want it to be, we're done */
2855 if (s->dest_dsa.user_account_control == user_account_control) {
2856 return NT_STATUS_OK;
2859 /* make a 'modify' msg, and only for serverReference */
2860 msg = ldb_msg_new(s);
2861 NT_STATUS_HAVE_NO_MEMORY(msg);
2862 msg->dn = ldb_dn_new(msg, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
2863 NT_STATUS_HAVE_NO_MEMORY(msg->dn);
2865 ret = ldb_msg_add_fmt(msg, "userAccountControl", "%u", user_account_control);
2868 return NT_STATUS_NO_MEMORY;
2871 /* mark all the message elements (should be just one)
2872 as LDB_FLAG_MOD_REPLACE */
2873 for (i=0;i<msg->num_elements;i++) {
2874 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
2877 ret = ldb_modify(s->ldap2.ldb, msg);
2879 if (ret != LDB_SUCCESS) {
2880 return NT_STATUS_LDAP(ret);
2883 s->dest_dsa.user_account_control = user_account_control;
2885 return NT_STATUS_OK;
2888 static NTSTATUS becomeDC_ldap2_move_computer(struct libnet_BecomeDC_state *s)
2891 struct ldb_result *r;
2892 struct ldb_dn *basedn;
2893 struct ldb_dn *old_dn;
2894 struct ldb_dn *new_dn;
2895 static const char *_1_1_attrs[] = {
2900 basedn = ldb_dn_new_fmt(s, s->ldap2.ldb, "<WKGUID=a361b2ffffd211d1aa4b00c04fd7d83a,%s>",
2902 NT_STATUS_HAVE_NO_MEMORY(basedn);
2904 ret = ldb_search(s->ldap2.ldb, basedn, LDB_SCOPE_BASE,
2905 "(objectClass=*)", _1_1_attrs, &r);
2906 talloc_free(basedn);
2907 if (ret != LDB_SUCCESS) {
2908 return NT_STATUS_LDAP(ret);
2909 } else if (r->count != 1) {
2911 return NT_STATUS_INVALID_NETWORK_RESPONSE;
2914 old_dn = ldb_dn_new(r, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
2915 NT_STATUS_HAVE_NO_MEMORY(old_dn);
2917 new_dn = r->msgs[0]->dn;
2919 if (!ldb_dn_add_child_fmt(new_dn, "CN=%s", s->dest_dsa.netbios_name)) {
2921 return NT_STATUS_NO_MEMORY;
2924 if (ldb_dn_compare(old_dn, new_dn) == 0) {
2925 /* we don't need to rename if the old and new dn match */
2927 return NT_STATUS_OK;
2930 ret = ldb_rename(s->ldap2.ldb, old_dn, new_dn);
2931 if (ret != LDB_SUCCESS) {
2933 return NT_STATUS_LDAP(ret);
2936 s->dest_dsa.computer_dn_str = ldb_dn_alloc_linearized(s, new_dn);
2937 NT_STATUS_HAVE_NO_MEMORY(s->dest_dsa.computer_dn_str);
2941 return NT_STATUS_OK;
2944 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s)
2946 struct composite_context *c = s->creq;
2948 c->status = becomeDC_ldap_connect(s, &s->ldap2);
2949 if (!composite_is_ok(c)) return;
2951 c->status = becomeDC_ldap2_modify_computer(s);
2952 if (!composite_is_ok(c)) return;
2954 c->status = becomeDC_ldap2_move_computer(s);
2955 if (!composite_is_ok(c)) return;
2957 becomeDC_drsuapi3_pull_domain_send(s);
2960 struct composite_context *libnet_BecomeDC_send(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
2962 struct composite_context *c;
2963 struct libnet_BecomeDC_state *s;
2966 c = composite_create(mem_ctx, ctx->event_ctx);
2967 if (c == NULL) return NULL;
2969 s = talloc_zero(c, struct libnet_BecomeDC_state);
2970 if (composite_nomem(s, c)) return c;
2971 c->private_data = s;
2976 s->domain.dns_name = talloc_strdup(s, r->in.domain_dns_name);
2977 if (composite_nomem(s->domain.dns_name, c)) return c;
2978 s->domain.netbios_name = talloc_strdup(s, r->in.domain_netbios_name);
2979 if (composite_nomem(s->domain.netbios_name, c)) return c;
2980 s->domain.sid = dom_sid_dup(s, r->in.domain_sid);
2981 if (composite_nomem(s->domain.sid, c)) return c;
2983 /* Source DSA input */
2984 s->source_dsa.address = talloc_strdup(s, r->in.source_dsa_address);
2985 if (composite_nomem(s->source_dsa.address, c)) return c;
2987 /* Destination DSA input */
2988 s->dest_dsa.netbios_name= talloc_strdup(s, r->in.dest_dsa_netbios_name);
2989 if (composite_nomem(s->dest_dsa.netbios_name, c)) return c;
2991 /* Destination DSA dns_name construction */
2992 tmp_name = strlower_talloc(s, s->dest_dsa.netbios_name);
2993 if (composite_nomem(tmp_name, c)) return c;
2994 tmp_name = talloc_asprintf_append_buffer(tmp_name, ".%s",s->domain.dns_name);
2995 if (composite_nomem(tmp_name, c)) return c;
2996 s->dest_dsa.dns_name = tmp_name;
2998 /* Callback function pointers */
2999 s->callbacks = r->in.callbacks;
3001 becomeDC_send_cldap(s);
3005 NTSTATUS libnet_BecomeDC_recv(struct composite_context *c, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3009 status = composite_wait(c);
3011 ZERO_STRUCT(r->out);
3017 NTSTATUS libnet_BecomeDC(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3020 struct composite_context *c;
3021 c = libnet_BecomeDC_send(ctx, mem_ctx, r);
3022 status = libnet_BecomeDC_recv(c, mem_ctx, r);