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 "../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"
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 int32_t get_dc_function_level(struct loadparm_context *lp_ctx)
736 /* per default we are (Windows) 2008 compatible */
737 return lp_parm_int(lp_ctx, NULL, "ads", "dc function level",
738 DS_DC_FUNCTION_2008);
741 static int32_t get_min_function_level(struct loadparm_context *lp_ctx)
743 /* per default it is (Windows) 2003 Native compatible */
744 return lp_parm_int(lp_ctx, NULL, "ads", "min function level",
745 DS_DOMAIN_FUNCTION_2003);
748 static void becomeDC_recv_cldap(struct tevent_req *req);
750 static void becomeDC_send_cldap(struct libnet_BecomeDC_state *s)
752 struct composite_context *c = s->creq;
753 struct tevent_req *req;
755 s->cldap.io.in.dest_address = s->source_dsa.address;
756 s->cldap.io.in.dest_port = lp_cldap_port(s->libnet->lp_ctx);
757 s->cldap.io.in.realm = s->domain.dns_name;
758 s->cldap.io.in.host = s->dest_dsa.netbios_name;
759 s->cldap.io.in.user = NULL;
760 s->cldap.io.in.domain_guid = NULL;
761 s->cldap.io.in.domain_sid = NULL;
762 s->cldap.io.in.acct_control = -1;
763 s->cldap.io.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
764 s->cldap.io.in.map_response = true;
766 c->status = cldap_socket_init(s, s->libnet->event_ctx,
767 NULL, NULL, &s->cldap.sock);//TODO
768 if (!composite_is_ok(c)) return;
770 req = cldap_netlogon_send(s, s->cldap.sock, &s->cldap.io);
771 if (composite_nomem(req, c)) return;
772 tevent_req_set_callback(req, becomeDC_recv_cldap, s);
775 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s);
777 static void becomeDC_recv_cldap(struct tevent_req *req)
779 struct libnet_BecomeDC_state *s = tevent_req_callback_data(req,
780 struct libnet_BecomeDC_state);
781 struct composite_context *c = s->creq;
783 c->status = cldap_netlogon_recv(req,
784 lp_iconv_convenience(s->libnet->lp_ctx),
787 if (!composite_is_ok(c)) return;
789 s->cldap.netlogon = s->cldap.io.out.netlogon.data.nt5_ex;
791 s->domain.dns_name = s->cldap.netlogon.dns_domain;
792 s->domain.netbios_name = s->cldap.netlogon.domain;
793 s->domain.guid = s->cldap.netlogon.domain_uuid;
795 s->forest.dns_name = s->cldap.netlogon.forest;
797 s->source_dsa.dns_name = s->cldap.netlogon.pdc_dns_name;
798 s->source_dsa.netbios_name = s->cldap.netlogon.pdc_name;
799 s->source_dsa.site_name = s->cldap.netlogon.server_site;
801 s->dest_dsa.site_name = s->cldap.netlogon.client_site;
803 becomeDC_connect_ldap1(s);
806 static NTSTATUS becomeDC_ldap_connect(struct libnet_BecomeDC_state *s,
807 struct becomeDC_ldap *ldap)
811 url = talloc_asprintf(s, "ldap://%s/", s->source_dsa.dns_name);
812 NT_STATUS_HAVE_NO_MEMORY(url);
814 ldap->ldb = ldb_wrap_connect(s, s->libnet->event_ctx, s->libnet->lp_ctx, url,
819 if (ldap->ldb == NULL) {
820 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
826 static NTSTATUS becomeDC_ldap1_rootdse(struct libnet_BecomeDC_state *s)
829 struct ldb_result *r;
830 struct ldb_dn *basedn;
831 static const char *attrs[] = {
836 basedn = ldb_dn_new(s, s->ldap1.ldb, NULL);
837 NT_STATUS_HAVE_NO_MEMORY(basedn);
839 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
842 if (ret != LDB_SUCCESS) {
843 return NT_STATUS_LDAP(ret);
844 } else if (r->count != 1) {
846 return NT_STATUS_INVALID_NETWORK_RESPONSE;
849 s->ldap1.rootdse = r->msgs[0];
851 s->domain.dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "defaultNamingContext", NULL);
852 if (!s->domain.dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
854 s->forest.root_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "rootDomainNamingContext", NULL);
855 if (!s->forest.root_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
856 s->forest.config_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "configurationNamingContext", NULL);
857 if (!s->forest.config_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
858 s->forest.schema_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "schemaNamingContext", NULL);
859 if (!s->forest.schema_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
861 s->source_dsa.server_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "serverName", NULL);
862 if (!s->source_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
863 s->source_dsa.ntds_dn_str = ldb_msg_find_attr_as_string(s->ldap1.rootdse, "dsServiceName", NULL);
864 if (!s->source_dsa.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
869 static NTSTATUS becomeDC_ldap1_crossref_behavior_version(struct libnet_BecomeDC_state *s)
872 struct ldb_result *r;
873 struct ldb_dn *basedn;
874 static const char *attrs[] = {
875 "msDs-Behavior-Version",
879 basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.config_dn_str);
880 NT_STATUS_HAVE_NO_MEMORY(basedn);
882 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_ONELEVEL, attrs,
885 if (ret != LDB_SUCCESS) {
886 return NT_STATUS_LDAP(ret);
887 } else if (r->count != 1) {
889 return NT_STATUS_INVALID_NETWORK_RESPONSE;
892 s->forest.crossref_behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
893 if (s->forest.crossref_behavior_version <
894 get_min_function_level(s->libnet->lp_ctx)) {
896 DEBUG(0,("The servers function level %u is below 'ads:min function level' of %u\n",
897 s->forest.crossref_behavior_version,
898 get_min_function_level(s->libnet->lp_ctx)));
899 return NT_STATUS_NOT_SUPPORTED;
901 if (s->forest.crossref_behavior_version >
902 get_dc_function_level(s->libnet->lp_ctx)) {
904 DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n",
905 s->forest.crossref_behavior_version,
906 get_dc_function_level(s->libnet->lp_ctx)));
907 return NT_STATUS_NOT_SUPPORTED;
914 static NTSTATUS becomeDC_ldap1_domain_behavior_version(struct libnet_BecomeDC_state *s)
917 struct ldb_result *r;
918 struct ldb_dn *basedn;
919 static const char *attrs[] = {
920 "msDs-Behavior-Version",
924 basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
925 NT_STATUS_HAVE_NO_MEMORY(basedn);
927 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
930 if (ret != LDB_SUCCESS) {
931 return NT_STATUS_LDAP(ret);
932 } else if (r->count != 1) {
934 return NT_STATUS_INVALID_NETWORK_RESPONSE;
937 s->domain.behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
938 if (s->domain.behavior_version <
939 get_min_function_level(s->libnet->lp_ctx)) {
941 DEBUG(0,("The servers function level %u is below 'ads:min function level' of %u\n",
942 s->forest.crossref_behavior_version,
943 get_min_function_level(s->libnet->lp_ctx)));
944 return NT_STATUS_NOT_SUPPORTED;
946 if (s->domain.behavior_version >
947 get_dc_function_level(s->libnet->lp_ctx)) {
949 DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n",
950 s->forest.crossref_behavior_version,
951 get_dc_function_level(s->libnet->lp_ctx)));
952 return NT_STATUS_NOT_SUPPORTED;
959 static NTSTATUS becomeDC_ldap1_schema_object_version(struct libnet_BecomeDC_state *s)
962 struct ldb_result *r;
963 struct ldb_dn *basedn;
964 static const char *attrs[] = {
969 basedn = ldb_dn_new(s, s->ldap1.ldb, s->forest.schema_dn_str);
970 NT_STATUS_HAVE_NO_MEMORY(basedn);
972 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
975 if (ret != LDB_SUCCESS) {
976 return NT_STATUS_LDAP(ret);
977 } else if (r->count != 1) {
979 return NT_STATUS_INVALID_NETWORK_RESPONSE;
982 s->forest.schema_object_version = ldb_msg_find_attr_as_uint(r->msgs[0], "objectVersion", 0);
988 static NTSTATUS becomeDC_ldap1_w2k3_update_revision(struct libnet_BecomeDC_state *s)
991 struct ldb_result *r;
992 struct ldb_dn *basedn;
993 static const char *attrs[] = {
998 basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=Windows2003Update,CN=DomainUpdates,CN=System,%s",
1000 NT_STATUS_HAVE_NO_MEMORY(basedn);
1002 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE, attrs,
1004 talloc_free(basedn);
1005 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1006 /* w2k doesn't have this object */
1007 s->domain.w2k3_update_revision = 0;
1008 return NT_STATUS_OK;
1009 } else if (ret != LDB_SUCCESS) {
1010 return NT_STATUS_LDAP(ret);
1011 } else if (r->count != 1) {
1013 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1016 s->domain.w2k3_update_revision = ldb_msg_find_attr_as_uint(r->msgs[0], "revision", 0);
1019 return NT_STATUS_OK;
1022 static NTSTATUS becomeDC_ldap1_infrastructure_fsmo(struct libnet_BecomeDC_state *s)
1025 struct ldb_result *r;
1026 struct ldb_dn *basedn;
1027 struct ldb_dn *ntds_dn;
1028 struct ldb_dn *server_dn;
1029 static const char *_1_1_attrs[] = {
1033 static const char *fsmo_attrs[] = {
1037 static const char *dns_attrs[] = {
1041 static const char *guid_attrs[] = {
1046 basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "<WKGUID=2fbac1870ade11d297c400c04fd8d5cd,%s>",
1048 NT_STATUS_HAVE_NO_MEMORY(basedn);
1050 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1051 _1_1_attrs, "(objectClass=*)");
1052 talloc_free(basedn);
1053 if (ret != LDB_SUCCESS) {
1054 return NT_STATUS_LDAP(ret);
1055 } else if (r->count != 1) {
1057 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1060 basedn = talloc_steal(s, r->msgs[0]->dn);
1063 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1064 fsmo_attrs, "(objectClass=*)");
1065 talloc_free(basedn);
1066 if (ret != LDB_SUCCESS) {
1067 return NT_STATUS_LDAP(ret);
1068 } else if (r->count != 1) {
1070 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1073 s->infrastructure_fsmo.ntds_dn_str = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
1074 if (!s->infrastructure_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1075 talloc_steal(s, s->infrastructure_fsmo.ntds_dn_str);
1079 ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->infrastructure_fsmo.ntds_dn_str);
1080 NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
1082 server_dn = ldb_dn_get_parent(s, ntds_dn);
1083 NT_STATUS_HAVE_NO_MEMORY(server_dn);
1085 s->infrastructure_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
1086 NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.server_dn_str);
1088 ret = ldb_search(s->ldap1.ldb, s, &r, server_dn, LDB_SCOPE_BASE,
1089 dns_attrs, "(objectClass=*)");
1090 if (ret != LDB_SUCCESS) {
1091 return NT_STATUS_LDAP(ret);
1092 } else if (r->count != 1) {
1094 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1097 s->infrastructure_fsmo.dns_name = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
1098 if (!s->infrastructure_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1099 talloc_steal(s, s->infrastructure_fsmo.dns_name);
1103 ret = ldb_search(s->ldap1.ldb, s, &r, ntds_dn, LDB_SCOPE_BASE,
1104 guid_attrs, "(objectClass=*)");
1105 if (ret != LDB_SUCCESS) {
1106 return NT_STATUS_LDAP(ret);
1107 } else if (r->count != 1) {
1109 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1112 s->infrastructure_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1116 return NT_STATUS_OK;
1119 static NTSTATUS becomeDC_ldap1_rid_manager_fsmo(struct libnet_BecomeDC_state *s)
1122 struct ldb_result *r;
1123 struct ldb_dn *basedn;
1124 const char *reference_dn_str;
1125 struct ldb_dn *ntds_dn;
1126 struct ldb_dn *server_dn;
1127 static const char *rid_attrs[] = {
1128 "rIDManagerReference",
1131 static const char *fsmo_attrs[] = {
1135 static const char *dns_attrs[] = {
1139 static const char *guid_attrs[] = {
1144 basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
1145 NT_STATUS_HAVE_NO_MEMORY(basedn);
1147 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1148 rid_attrs, "(objectClass=*)");
1149 talloc_free(basedn);
1150 if (ret != LDB_SUCCESS) {
1151 return NT_STATUS_LDAP(ret);
1152 } else if (r->count != 1) {
1154 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1157 reference_dn_str = samdb_result_string(r->msgs[0], "rIDManagerReference", NULL);
1158 if (!reference_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1160 basedn = ldb_dn_new(s, s->ldap1.ldb, reference_dn_str);
1161 NT_STATUS_HAVE_NO_MEMORY(basedn);
1165 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1166 fsmo_attrs, "(objectClass=*)");
1167 talloc_free(basedn);
1168 if (ret != LDB_SUCCESS) {
1169 return NT_STATUS_LDAP(ret);
1170 } else if (r->count != 1) {
1172 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1175 s->rid_manager_fsmo.ntds_dn_str = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
1176 if (!s->rid_manager_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1177 talloc_steal(s, s->rid_manager_fsmo.ntds_dn_str);
1181 ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->rid_manager_fsmo.ntds_dn_str);
1182 NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
1184 server_dn = ldb_dn_get_parent(s, ntds_dn);
1185 NT_STATUS_HAVE_NO_MEMORY(server_dn);
1187 s->rid_manager_fsmo.server_dn_str = ldb_dn_alloc_linearized(s, server_dn);
1188 NT_STATUS_HAVE_NO_MEMORY(s->rid_manager_fsmo.server_dn_str);
1190 ret = ldb_search(s->ldap1.ldb, s, &r, server_dn, LDB_SCOPE_BASE,
1191 dns_attrs, "(objectClass=*)");
1192 if (ret != LDB_SUCCESS) {
1193 return NT_STATUS_LDAP(ret);
1194 } else if (r->count != 1) {
1196 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1199 s->rid_manager_fsmo.dns_name = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
1200 if (!s->rid_manager_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1201 talloc_steal(s, s->rid_manager_fsmo.dns_name);
1205 ret = ldb_search(s->ldap1.ldb, s, &r, ntds_dn, LDB_SCOPE_BASE,
1206 guid_attrs, "(objectClass=*)");
1207 if (ret != LDB_SUCCESS) {
1208 return NT_STATUS_LDAP(ret);
1209 } else if (r->count != 1) {
1211 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1214 s->rid_manager_fsmo.ntds_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1218 return NT_STATUS_OK;
1221 static NTSTATUS becomeDC_ldap1_site_object(struct libnet_BecomeDC_state *s)
1224 struct ldb_result *r;
1225 struct ldb_dn *basedn;
1227 basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Sites,%s",
1228 s->dest_dsa.site_name,
1229 s->forest.config_dn_str);
1230 NT_STATUS_HAVE_NO_MEMORY(basedn);
1232 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1233 NULL, "(objectClass=*)");
1234 talloc_free(basedn);
1235 if (ret != LDB_SUCCESS) {
1236 return NT_STATUS_LDAP(ret);
1237 } else if (r->count != 1) {
1239 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1242 s->dest_dsa.site_guid = samdb_result_guid(r->msgs[0], "objectGUID");
1245 return NT_STATUS_OK;
1248 static NTSTATUS becomeDC_check_options(struct libnet_BecomeDC_state *s)
1250 if (!s->callbacks.check_options) return NT_STATUS_OK;
1252 s->_co.domain = &s->domain;
1253 s->_co.forest = &s->forest;
1254 s->_co.source_dsa = &s->source_dsa;
1256 return s->callbacks.check_options(s->callbacks.private_data, &s->_co);
1259 static NTSTATUS becomeDC_ldap1_computer_object(struct libnet_BecomeDC_state *s)
1262 struct ldb_result *r;
1263 struct ldb_dn *basedn;
1264 static const char *attrs[] = {
1265 "distinguishedName",
1266 "userAccountControl",
1270 basedn = ldb_dn_new(s, s->ldap1.ldb, s->domain.dn_str);
1271 NT_STATUS_HAVE_NO_MEMORY(basedn);
1273 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_SUBTREE, attrs,
1274 "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
1275 s->dest_dsa.netbios_name);
1276 talloc_free(basedn);
1277 if (ret != LDB_SUCCESS) {
1278 return NT_STATUS_LDAP(ret);
1279 } else if (r->count != 1) {
1281 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1284 s->dest_dsa.computer_dn_str = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
1285 if (!s->dest_dsa.computer_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1286 talloc_steal(s, s->dest_dsa.computer_dn_str);
1288 s->dest_dsa.user_account_control = samdb_result_uint(r->msgs[0], "userAccountControl", 0);
1291 return NT_STATUS_OK;
1294 static NTSTATUS becomeDC_ldap1_server_object_1(struct libnet_BecomeDC_state *s)
1297 struct ldb_result *r;
1298 struct ldb_dn *basedn;
1299 const char *server_reference_dn_str;
1300 struct ldb_dn *server_reference_dn;
1301 struct ldb_dn *computer_dn;
1303 basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
1304 s->dest_dsa.netbios_name,
1305 s->dest_dsa.site_name,
1306 s->forest.config_dn_str);
1307 NT_STATUS_HAVE_NO_MEMORY(basedn);
1309 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1310 NULL, "(objectClass=*)");
1311 talloc_free(basedn);
1312 if (ret == LDB_ERR_NO_SUCH_OBJECT) {
1313 /* if the object doesn't exist, we'll create it later */
1314 return NT_STATUS_OK;
1315 } else if (ret != LDB_SUCCESS) {
1316 return NT_STATUS_LDAP(ret);
1317 } else if (r->count != 1) {
1319 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1322 server_reference_dn_str = samdb_result_string(r->msgs[0], "serverReference", NULL);
1323 if (server_reference_dn_str) {
1324 server_reference_dn = ldb_dn_new(r, s->ldap1.ldb, server_reference_dn_str);
1325 NT_STATUS_HAVE_NO_MEMORY(server_reference_dn);
1327 computer_dn = ldb_dn_new(r, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
1328 NT_STATUS_HAVE_NO_MEMORY(computer_dn);
1331 * if the server object belongs to another DC in another domain
1332 * in the forest, we should not touch this object!
1334 if (ldb_dn_compare(computer_dn, server_reference_dn) != 0) {
1336 return NT_STATUS_OBJECT_NAME_COLLISION;
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], "distinguishedName", NULL);
1342 if (!s->dest_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
1343 talloc_steal(s, s->dest_dsa.server_dn_str);
1346 return NT_STATUS_OK;
1349 static NTSTATUS becomeDC_ldap1_server_object_2(struct libnet_BecomeDC_state *s)
1352 struct ldb_result *r;
1353 struct ldb_dn *basedn;
1354 const char *server_reference_bl_dn_str;
1355 static const char *attrs[] = {
1356 "serverReferenceBL",
1360 /* if the server_dn_str has a valid value, we skip this lookup */
1361 if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
1363 basedn = ldb_dn_new(s, s->ldap1.ldb, s->dest_dsa.computer_dn_str);
1364 NT_STATUS_HAVE_NO_MEMORY(basedn);
1366 ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
1367 attrs, "(objectClass=*)");
1368 talloc_free(basedn);
1369 if (ret != LDB_SUCCESS) {
1370 return NT_STATUS_LDAP(ret);
1371 } else if (r->count != 1) {
1373 return NT_STATUS_INVALID_NETWORK_RESPONSE;
1376 server_reference_bl_dn_str = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
1377 if (!server_reference_bl_dn_str) {
1378 /* if no back link is present, we're done for this function */
1380 return NT_STATUS_OK;
1383 /* if the server object is already for the dest_dsa, then we don't need to create it */
1384 s->dest_dsa.server_dn_str = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
1385 if (s->dest_dsa.server_dn_str) {
1386 /* if a back link is present, we know that the server object is present */
1387 talloc_steal(s, s->dest_dsa.server_dn_str);
1391 return NT_STATUS_OK;
1394 static NTSTATUS becomeDC_ldap1_server_object_add(struct libnet_BecomeDC_state *s)
1397 struct ldb_message *msg;
1398 char *server_dn_str;
1400 /* if the server_dn_str has a valid value, we skip this lookup */
1401 if (s->dest_dsa.server_dn_str) return NT_STATUS_OK;
1403 msg = ldb_msg_new(s);
1404 NT_STATUS_HAVE_NO_MEMORY(msg);
1406 msg->dn = ldb_dn_new_fmt(msg, s->ldap1.ldb, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
1407 s->dest_dsa.netbios_name,
1408 s->dest_dsa.site_name,
1409 s->forest.config_dn_str);
1410 NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1412 ret = ldb_msg_add_string(msg, "objectClass", "server");
1415 return NT_STATUS_NO_MEMORY;
1417 ret = ldb_msg_add_string(msg, "systemFlags", "50000000");
1420 return NT_STATUS_NO_MEMORY;
1422 ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
1425 return NT_STATUS_NO_MEMORY;
1428 server_dn_str = ldb_dn_alloc_linearized(s, msg->dn);
1429 NT_STATUS_HAVE_NO_MEMORY(server_dn_str);
1431 ret = ldb_add(s->ldap1.ldb, msg);
1433 if (ret != LDB_SUCCESS) {
1434 talloc_free(server_dn_str);
1435 return NT_STATUS_LDAP(ret);
1438 s->dest_dsa.server_dn_str = server_dn_str;
1440 return NT_STATUS_OK;
1443 static NTSTATUS becomeDC_ldap1_server_object_modify(struct libnet_BecomeDC_state *s)
1446 struct ldb_message *msg;
1449 /* make a 'modify' msg, and only for serverReference */
1450 msg = ldb_msg_new(s);
1451 NT_STATUS_HAVE_NO_MEMORY(msg);
1452 msg->dn = ldb_dn_new(msg, s->ldap1.ldb, s->dest_dsa.server_dn_str);
1453 NT_STATUS_HAVE_NO_MEMORY(msg->dn);
1455 ret = ldb_msg_add_string(msg, "serverReference", s->dest_dsa.computer_dn_str);
1458 return NT_STATUS_NO_MEMORY;
1461 /* mark all the message elements (should be just one)
1462 as LDB_FLAG_MOD_ADD */
1463 for (i=0;i<msg->num_elements;i++) {
1464 msg->elements[i].flags = LDB_FLAG_MOD_ADD;
1467 ret = ldb_modify(s->ldap1.ldb, msg);
1468 if (ret == LDB_SUCCESS) {
1470 return NT_STATUS_OK;
1471 } else if (ret == LDB_ERR_ATTRIBUTE_OR_VALUE_EXISTS) {
1472 /* retry with LDB_FLAG_MOD_REPLACE */
1475 return NT_STATUS_LDAP(ret);
1478 /* mark all the message elements (should be just one)
1479 as LDB_FLAG_MOD_REPLACE */
1480 for (i=0;i<msg->num_elements;i++) {
1481 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
1484 ret = ldb_modify(s->ldap1.ldb, msg);
1486 if (ret != LDB_SUCCESS) {
1487 return NT_STATUS_LDAP(ret);
1490 return NT_STATUS_OK;
1493 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
1494 struct becomeDC_drsuapi *drsuapi,
1495 void (*recv_fn)(struct composite_context *req));
1496 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req);
1497 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s);
1499 static void becomeDC_connect_ldap1(struct libnet_BecomeDC_state *s)
1501 struct composite_context *c = s->creq;
1503 c->status = becomeDC_ldap_connect(s, &s->ldap1);
1504 if (!composite_is_ok(c)) return;
1506 c->status = becomeDC_ldap1_rootdse(s);
1507 if (!composite_is_ok(c)) return;
1509 c->status = becomeDC_ldap1_crossref_behavior_version(s);
1510 if (!composite_is_ok(c)) return;
1512 c->status = becomeDC_ldap1_domain_behavior_version(s);
1513 if (!composite_is_ok(c)) return;
1515 c->status = becomeDC_ldap1_schema_object_version(s);
1516 if (!composite_is_ok(c)) return;
1518 c->status = becomeDC_ldap1_w2k3_update_revision(s);
1519 if (!composite_is_ok(c)) return;
1521 c->status = becomeDC_ldap1_infrastructure_fsmo(s);
1522 if (!composite_is_ok(c)) return;
1524 c->status = becomeDC_ldap1_rid_manager_fsmo(s);
1525 if (!composite_is_ok(c)) return;
1527 c->status = becomeDC_ldap1_site_object(s);
1528 if (!composite_is_ok(c)) return;
1530 c->status = becomeDC_check_options(s);
1531 if (!composite_is_ok(c)) return;
1533 c->status = becomeDC_ldap1_computer_object(s);
1534 if (!composite_is_ok(c)) return;
1536 c->status = becomeDC_ldap1_server_object_1(s);
1537 if (!composite_is_ok(c)) return;
1539 c->status = becomeDC_ldap1_server_object_2(s);
1540 if (!composite_is_ok(c)) return;
1542 c->status = becomeDC_ldap1_server_object_add(s);
1543 if (!composite_is_ok(c)) return;
1545 c->status = becomeDC_ldap1_server_object_modify(s);
1546 if (!composite_is_ok(c)) return;
1548 becomeDC_drsuapi_connect_send(s, &s->drsuapi1, becomeDC_drsuapi1_connect_recv);
1551 static void becomeDC_drsuapi_connect_send(struct libnet_BecomeDC_state *s,
1552 struct becomeDC_drsuapi *drsuapi,
1553 void (*recv_fn)(struct composite_context *req))
1555 struct composite_context *c = s->creq;
1556 struct composite_context *creq;
1561 if (!drsuapi->binding) {
1562 const char *krb5_str = "";
1563 const char *print_str = "";
1565 * Note: Replication only works with Windows 2000 when 'krb5' is
1566 * passed as auth_type here. If NTLMSSP is used, Windows
1567 * 2000 returns garbage in the DsGetNCChanges() response
1568 * if encrypted password attributes would be in the
1569 * response. That means the replication of the schema and
1570 * configuration partition works fine, but it fails for
1571 * the domain partition.
1573 if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
1574 "force krb5", true))
1578 if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
1581 print_str = "print,";
1583 binding_str = talloc_asprintf(s, "ncacn_ip_tcp:%s[%s%sseal]",
1584 s->source_dsa.dns_name,
1585 krb5_str, print_str);
1586 if (composite_nomem(binding_str, c)) return;
1587 c->status = dcerpc_parse_binding(s, binding_str, &drsuapi->binding);
1588 talloc_free(binding_str);
1589 if (!composite_is_ok(c)) return;
1592 creq = dcerpc_pipe_connect_b_send(s, drsuapi->binding, &ndr_table_drsuapi,
1593 s->libnet->cred, s->libnet->event_ctx,
1595 composite_continue(c, creq, recv_fn, s);
1598 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
1599 struct becomeDC_drsuapi *drsuapi,
1600 void (*recv_fn)(struct rpc_request *req));
1601 static void becomeDC_drsuapi1_bind_recv(struct rpc_request *req);
1603 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req)
1605 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
1606 struct libnet_BecomeDC_state);
1607 struct composite_context *c = s->creq;
1609 c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi1.pipe);
1610 if (!composite_is_ok(c)) return;
1612 c->status = gensec_session_key(s->drsuapi1.pipe->conn->security_state.generic_state,
1613 &s->drsuapi1.gensec_skey);
1614 if (!composite_is_ok(c)) return;
1616 becomeDC_drsuapi_bind_send(s, &s->drsuapi1, becomeDC_drsuapi1_bind_recv);
1619 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
1620 struct becomeDC_drsuapi *drsuapi,
1621 void (*recv_fn)(struct rpc_request *req))
1623 struct composite_context *c = s->creq;
1624 struct rpc_request *req;
1625 struct drsuapi_DsBindInfo28 *bind_info28;
1627 GUID_from_string(DRSUAPI_DS_BIND_GUID_W2K3, &drsuapi->bind_guid);
1629 bind_info28 = &drsuapi->local_info28;
1630 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
1631 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION;
1632 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI;
1633 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2;
1634 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS;
1635 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1;
1636 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
1637 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
1638 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
1639 if (s->domain.behavior_version >= DS_DOMAIN_FUNCTION_2003) {
1640 /* TODO: find out how this is really triggered! */
1641 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
1643 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2;
1644 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD;
1645 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND;
1646 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO;
1647 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION;
1648 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01;
1649 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP;
1650 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
1651 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
1652 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_00100000;
1653 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
1654 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
1655 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS;
1656 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8;
1657 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5;
1658 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6;
1659 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
1660 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
1661 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
1662 #if 0 /* we don't support XPRESS compression yet */
1663 bind_info28->supported_extensions |= DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS;
1665 bind_info28->site_guid = s->dest_dsa.site_guid;
1666 bind_info28->pid = 0;
1667 bind_info28->repl_epoch = 0;
1669 drsuapi->bind_info_ctr.length = 28;
1670 drsuapi->bind_info_ctr.info.info28 = *bind_info28;
1672 drsuapi->bind_r.in.bind_guid = &drsuapi->bind_guid;
1673 drsuapi->bind_r.in.bind_info = &drsuapi->bind_info_ctr;
1674 drsuapi->bind_r.out.bind_handle = &drsuapi->bind_handle;
1676 req = dcerpc_drsuapi_DsBind_send(drsuapi->pipe, s, &drsuapi->bind_r);
1677 composite_continue_rpc(c, req, recv_fn, s);
1680 static WERROR becomeDC_drsuapi_bind_recv(struct libnet_BecomeDC_state *s,
1681 struct becomeDC_drsuapi *drsuapi)
1683 if (!W_ERROR_IS_OK(drsuapi->bind_r.out.result)) {
1684 return drsuapi->bind_r.out.result;
1687 ZERO_STRUCT(drsuapi->remote_info28);
1688 if (drsuapi->bind_r.out.bind_info) {
1689 switch (drsuapi->bind_r.out.bind_info->length) {
1691 struct drsuapi_DsBindInfo24 *info24;
1692 info24 = &drsuapi->bind_r.out.bind_info->info.info24;
1693 drsuapi->remote_info28.supported_extensions = info24->supported_extensions;
1694 drsuapi->remote_info28.site_guid = info24->site_guid;
1695 drsuapi->remote_info28.pid = info24->pid;
1696 drsuapi->remote_info28.repl_epoch = 0;
1700 struct drsuapi_DsBindInfo48 *info48;
1701 info48 = &drsuapi->bind_r.out.bind_info->info.info48;
1702 drsuapi->remote_info28.supported_extensions = info48->supported_extensions;
1703 drsuapi->remote_info28.site_guid = info48->site_guid;
1704 drsuapi->remote_info28.pid = info48->pid;
1705 drsuapi->remote_info28.repl_epoch = info48->repl_epoch;
1709 drsuapi->remote_info28 = drsuapi->bind_r.out.bind_info->info.info28;
1717 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s);
1719 static void becomeDC_drsuapi1_bind_recv(struct rpc_request *req)
1721 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
1722 struct libnet_BecomeDC_state);
1723 struct composite_context *c = s->creq;
1728 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
1732 c->status = dcerpc_ndr_request_recv(req);
1733 if (!composite_is_ok(c)) return;
1736 NDR_PRINT_OUT_DEBUG(drsuapi_DsBind, &s->drsuapi1.bind_r);
1739 status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi1);
1740 if (!W_ERROR_IS_OK(status)) {
1741 composite_error(c, werror_to_ntstatus(status));
1745 becomeDC_drsuapi1_add_entry_send(s);
1748 static void becomeDC_drsuapi1_add_entry_recv(struct rpc_request *req);
1750 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s)
1752 struct composite_context *c = s->creq;
1753 struct rpc_request *req;
1754 struct drsuapi_DsAddEntry *r;
1755 struct drsuapi_DsReplicaObjectIdentifier *identifier;
1756 uint32_t num_attrs, i = 0;
1757 struct drsuapi_DsReplicaAttribute *attrs;
1758 struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(s->libnet->lp_ctx);
1759 enum ndr_err_code ndr_err;
1762 /* choose a random invocationId */
1763 s->dest_dsa.invocation_id = GUID_random();
1766 * if the schema version indicates w2k3, then also send some w2k3
1767 * specific attributes.
1769 if (s->forest.schema_object_version >= 30) {
1775 r = talloc_zero(s, struct drsuapi_DsAddEntry);
1776 if (composite_nomem(r, c)) return;
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;
1787 /* allocate attribute array */
1789 attrs = talloc_array(r, struct drsuapi_DsReplicaAttribute, num_attrs);
1790 if (composite_nomem(attrs, c)) return;
1792 /* ntSecurityDescriptor */
1794 struct drsuapi_DsAttributeValue *vs;
1796 struct security_descriptor *v;
1797 struct dom_sid *domain_admins_sid;
1798 const char *domain_admins_sid_str;
1800 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1801 if (composite_nomem(vs, c)) return;
1803 vd = talloc_array(vs, DATA_BLOB, 1);
1804 if (composite_nomem(vd, c)) return;
1806 domain_admins_sid = dom_sid_add_rid(vs, s->domain.sid, DOMAIN_RID_ADMINS);
1807 if (composite_nomem(domain_admins_sid, c)) return;
1809 domain_admins_sid_str = dom_sid_string(domain_admins_sid, domain_admins_sid);
1810 if (composite_nomem(domain_admins_sid_str, c)) return;
1812 v = security_descriptor_dacl_create(vd,
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 |
1824 SEC_ADS_LIST_OBJECT,
1827 domain_admins_sid_str,
1828 SEC_ACE_TYPE_ACCESS_ALLOWED,
1830 SEC_ADS_CREATE_CHILD |
1832 SEC_ADS_SELF_WRITE |
1834 SEC_ADS_WRITE_PROP |
1835 SEC_ADS_DELETE_TREE |
1836 SEC_ADS_LIST_OBJECT |
1837 SEC_ADS_CONTROL_ACCESS,
1841 SEC_ACE_TYPE_ACCESS_ALLOWED,
1843 SEC_ADS_CREATE_CHILD |
1844 SEC_ADS_DELETE_CHILD |
1846 SEC_ADS_SELF_WRITE |
1848 SEC_ADS_WRITE_PROP |
1849 SEC_ADS_DELETE_TREE |
1850 SEC_ADS_LIST_OBJECT |
1851 SEC_ADS_CONTROL_ACCESS,
1855 if (composite_nomem(v, c)) return;
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;
1863 vs[0].blob = &vd[0];
1865 attrs[i].attid = DRSUAPI_ATTRIBUTE_ntSecurityDescriptor;
1866 attrs[i].value_ctr.num_values = 1;
1867 attrs[i].value_ctr.values = vs;
1872 /* objectClass: nTDSDSA */
1874 struct drsuapi_DsAttributeValue *vs;
1877 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1878 if (composite_nomem(vs, c)) return;
1880 vd = talloc_array(vs, DATA_BLOB, 1);
1881 if (composite_nomem(vd, c)) return;
1883 vd[0] = data_blob_talloc(vd, NULL, 4);
1884 if (composite_nomem(vd[0].data, c)) return;
1886 /* value for nTDSDSA */
1887 SIVAL(vd[0].data, 0, 0x0017002F);
1889 vs[0].blob = &vd[0];
1891 attrs[i].attid = DRSUAPI_ATTRIBUTE_objectClass;
1892 attrs[i].value_ctr.num_values = 1;
1893 attrs[i].value_ctr.values = vs;
1898 /* objectCategory: CN=NTDS-DSA,CN=Schema,... */
1900 struct drsuapi_DsAttributeValue *vs;
1902 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
1904 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1905 if (composite_nomem(vs, c)) return;
1907 vd = talloc_array(vs, DATA_BLOB, 1);
1908 if (composite_nomem(vd, c)) return;
1910 v[0].guid = GUID_zero();
1911 v[0].sid = s->zero_sid;
1912 v[0].dn = talloc_asprintf(vd, "CN=NTDS-DSA,%s",
1913 s->forest.schema_dn_str);
1914 if (composite_nomem(v[0].dn, c)) return;
1916 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
1917 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1918 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1919 c->status = ndr_map_error2ntstatus(ndr_err);
1920 if (!composite_is_ok(c)) return;
1923 vs[0].blob = &vd[0];
1925 attrs[i].attid = DRSUAPI_ATTRIBUTE_objectCategory;
1926 attrs[i].value_ctr.num_values = 1;
1927 attrs[i].value_ctr.values = vs;
1932 /* invocationId: random guid */
1934 struct drsuapi_DsAttributeValue *vs;
1936 const struct GUID *v;
1938 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
1939 if (composite_nomem(vs, c)) return;
1941 vd = talloc_array(vs, DATA_BLOB, 1);
1942 if (composite_nomem(vd, c)) return;
1944 v = &s->dest_dsa.invocation_id;
1946 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, v, (ndr_push_flags_fn_t)ndr_push_GUID);
1947 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1948 c->status = ndr_map_error2ntstatus(ndr_err);
1949 if (!composite_is_ok(c)) return;
1952 vs[0].blob = &vd[0];
1954 attrs[i].attid = DRSUAPI_ATTRIBUTE_invocationId;
1955 attrs[i].value_ctr.num_values = 1;
1956 attrs[i].value_ctr.values = vs;
1961 /* hasMasterNCs: ... */
1963 struct drsuapi_DsAttributeValue *vs;
1965 struct drsuapi_DsReplicaObjectIdentifier3 v[3];
1967 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 3);
1968 if (composite_nomem(vs, c)) return;
1970 vd = talloc_array(vs, DATA_BLOB, 3);
1971 if (composite_nomem(vd, c)) return;
1973 v[0].guid = GUID_zero();
1974 v[0].sid = s->zero_sid;
1975 v[0].dn = s->forest.config_dn_str;
1977 v[1].guid = GUID_zero();
1978 v[1].sid = s->zero_sid;
1979 v[1].dn = s->domain.dn_str;
1981 v[2].guid = GUID_zero();
1982 v[2].sid = s->zero_sid;
1983 v[2].dn = s->forest.schema_dn_str;
1985 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
1986 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1987 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1988 c->status = ndr_map_error2ntstatus(ndr_err);
1989 if (!composite_is_ok(c)) return;
1992 ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
1993 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
1994 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1995 c->status = ndr_map_error2ntstatus(ndr_err);
1996 if (!composite_is_ok(c)) return;
1999 ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
2000 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2001 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2002 c->status = ndr_map_error2ntstatus(ndr_err);
2003 if (!composite_is_ok(c)) return;
2006 vs[0].blob = &vd[0];
2007 vs[1].blob = &vd[1];
2008 vs[2].blob = &vd[2];
2010 attrs[i].attid = DRSUAPI_ATTRIBUTE_hasMasterNCs;
2011 attrs[i].value_ctr.num_values = 3;
2012 attrs[i].value_ctr.values = vs;
2017 /* msDS-hasMasterNCs: ... */
2019 struct drsuapi_DsAttributeValue *vs;
2021 struct drsuapi_DsReplicaObjectIdentifier3 v[3];
2023 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 3);
2024 if (composite_nomem(vs, c)) return;
2026 vd = talloc_array(vs, DATA_BLOB, 3);
2027 if (composite_nomem(vd, c)) return;
2029 v[0].guid = GUID_zero();
2030 v[0].sid = s->zero_sid;
2031 v[0].dn = s->forest.config_dn_str;
2033 v[1].guid = GUID_zero();
2034 v[1].sid = s->zero_sid;
2035 v[1].dn = s->domain.dn_str;
2037 v[2].guid = GUID_zero();
2038 v[2].sid = s->zero_sid;
2039 v[2].dn = s->forest.schema_dn_str;
2041 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2042 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2043 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2044 c->status = ndr_map_error2ntstatus(ndr_err);
2045 if (!composite_is_ok(c)) return;
2048 ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
2049 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2050 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2051 c->status = ndr_map_error2ntstatus(ndr_err);
2052 if (!composite_is_ok(c)) return;
2055 ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
2056 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2057 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2058 c->status = ndr_map_error2ntstatus(ndr_err);
2059 if (!composite_is_ok(c)) return;
2062 vs[0].blob = &vd[0];
2063 vs[1].blob = &vd[1];
2064 vs[2].blob = &vd[2];
2066 attrs[i].attid = DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs;
2067 attrs[i].value_ctr.num_values = 3;
2068 attrs[i].value_ctr.values = vs;
2073 /* dMDLocation: CN=Schema,... */
2075 struct drsuapi_DsAttributeValue *vs;
2077 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2079 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2080 if (composite_nomem(vs, c)) return;
2082 vd = talloc_array(vs, DATA_BLOB, 1);
2083 if (composite_nomem(vd, c)) return;
2085 v[0].guid = GUID_zero();
2086 v[0].sid = s->zero_sid;
2087 v[0].dn = s->forest.schema_dn_str;
2089 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2090 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2091 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2092 c->status = ndr_map_error2ntstatus(ndr_err);
2093 if (!composite_is_ok(c)) return;
2096 vs[0].blob = &vd[0];
2098 attrs[i].attid = DRSUAPI_ATTRIBUTE_dMDLocation;
2099 attrs[i].value_ctr.num_values = 1;
2100 attrs[i].value_ctr.values = vs;
2105 /* msDS-HasDomainNCs: <domain_partition> */
2107 struct drsuapi_DsAttributeValue *vs;
2109 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2111 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2112 if (composite_nomem(vs, c)) return;
2114 vd = talloc_array(vs, DATA_BLOB, 1);
2115 if (composite_nomem(vd, c)) return;
2117 v[0].guid = GUID_zero();
2118 v[0].sid = s->zero_sid;
2119 v[0].dn = s->domain.dn_str;
2121 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2122 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2123 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2124 c->status = ndr_map_error2ntstatus(ndr_err);
2125 if (!composite_is_ok(c)) return;
2128 vs[0].blob = &vd[0];
2130 attrs[i].attid = DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs;
2131 attrs[i].value_ctr.num_values = 1;
2132 attrs[i].value_ctr.values = vs;
2137 /* msDS-Behavior-Version */
2139 struct drsuapi_DsAttributeValue *vs;
2142 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2143 if (composite_nomem(vs, c)) return;
2145 vd = talloc_array(vs, DATA_BLOB, 1);
2146 if (composite_nomem(vd, c)) return;
2148 vd[0] = data_blob_talloc(vd, NULL, 4);
2149 if (composite_nomem(vd[0].data, c)) return;
2151 SIVAL(vd[0].data, 0, get_dc_function_level(s->libnet->lp_ctx));
2153 vs[0].blob = &vd[0];
2155 attrs[i].attid = DRSUAPI_ATTRIBUTE_msDS_Behavior_Version;
2156 attrs[i].value_ctr.num_values = 1;
2157 attrs[i].value_ctr.values = vs;
2164 struct drsuapi_DsAttributeValue *vs;
2167 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2168 if (composite_nomem(vs, c)) return;
2170 vd = talloc_array(vs, DATA_BLOB, 1);
2171 if (composite_nomem(vd, c)) return;
2173 vd[0] = data_blob_talloc(vd, NULL, 4);
2174 if (composite_nomem(vd[0].data, c)) return;
2176 SIVAL(vd[0].data, 0, SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
2178 vs[0].blob = &vd[0];
2180 attrs[i].attid = DRSUAPI_ATTRIBUTE_systemFlags;
2181 attrs[i].value_ctr.num_values = 1;
2182 attrs[i].value_ctr.values = vs;
2187 /* serverReference: ... */
2189 struct drsuapi_DsAttributeValue *vs;
2191 struct drsuapi_DsReplicaObjectIdentifier3 v[1];
2193 vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
2194 if (composite_nomem(vs, c)) return;
2196 vd = talloc_array(vs, DATA_BLOB, 1);
2197 if (composite_nomem(vd, c)) return;
2199 v[0].guid = GUID_zero();
2200 v[0].sid = s->zero_sid;
2201 v[0].dn = s->dest_dsa.computer_dn_str;
2203 ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
2204 (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
2205 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2206 c->status = ndr_map_error2ntstatus(ndr_err);
2207 if (!composite_is_ok(c)) return;
2210 vs[0].blob = &vd[0];
2212 attrs[i].attid = DRSUAPI_ATTRIBUTE_serverReference;
2213 attrs[i].value_ctr.num_values = 1;
2214 attrs[i].value_ctr.values = vs;
2219 /* truncate the attribute list to the attribute count we have filled in */
2222 /* setup request structure */
2223 r->in.bind_handle = &s->drsuapi1.bind_handle;
2225 r->in.req = talloc(s, union drsuapi_DsAddEntryRequest);
2226 r->in.req->req2.first_object.next_object = NULL;
2227 r->in.req->req2.first_object.object.identifier = identifier;
2228 r->in.req->req2.first_object.object.flags = 0x00000000;
2229 r->in.req->req2.first_object.object.attribute_ctr.num_attributes= num_attrs;
2230 r->in.req->req2.first_object.object.attribute_ctr.attributes = attrs;
2232 r->out.level_out = talloc(s, int32_t);
2233 r->out.ctr = talloc(s, union drsuapi_DsAddEntryCtr);
2235 req = dcerpc_drsuapi_DsAddEntry_send(s->drsuapi1.pipe, r, r);
2236 composite_continue_rpc(c, req, becomeDC_drsuapi1_add_entry_recv, s);
2239 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req);
2240 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s);
2242 static void becomeDC_drsuapi1_add_entry_recv(struct rpc_request *req)
2244 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2245 struct libnet_BecomeDC_state);
2246 struct composite_context *c = s->creq;
2247 struct drsuapi_DsAddEntry *r = talloc_get_type(req->ndr.struct_ptr,
2248 struct drsuapi_DsAddEntry);
2252 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2256 c->status = dcerpc_ndr_request_recv(req);
2257 if (!composite_is_ok(c)) return;
2260 NDR_PRINT_OUT_DEBUG(drsuapi_DsAddEntry, r);
2263 if (!W_ERROR_IS_OK(r->out.result)) {
2264 composite_error(c, werror_to_ntstatus(r->out.result));
2268 if (*r->out.level_out == 3) {
2269 if (r->out.ctr->ctr3.count != 1) {
2272 if (r->out.ctr->ctr3.level != 1) {
2273 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2277 if (!r->out.ctr->ctr3.error) {
2278 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2282 status = r->out.ctr->ctr3.error->info1.status;
2284 if (!r->out.ctr->ctr3.error->info1.info) {
2285 composite_error(c, werror_to_ntstatus(status));
2289 /* see if we can get a more detailed error */
2290 switch (r->out.ctr->ctr3.error->info1.level) {
2292 status = r->out.ctr->ctr3.error->info1.info->error1.status;
2298 status = r->out.ctr->ctr3.error->info1.info->errorX.status;
2302 composite_error(c, werror_to_ntstatus(status));
2306 s->dest_dsa.ntds_guid = r->out.ctr->ctr3.objects[0].guid;
2307 } else if (*r->out.level_out == 2) {
2308 if (r->out.ctr->ctr2.count != 1) {
2309 composite_error(c, werror_to_ntstatus(r->out.ctr->ctr2.error.status));
2313 s->dest_dsa.ntds_guid = r->out.ctr->ctr2.objects[0].guid;
2315 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
2321 s->dest_dsa.ntds_dn_str = talloc_asprintf(s, "CN=NTDS Settings,%s",
2322 s->dest_dsa.server_dn_str);
2323 if (composite_nomem(s->dest_dsa.ntds_dn_str, c)) return;
2325 c->status = becomeDC_prepare_db(s);
2326 if (!composite_is_ok(c)) return;
2328 /* this avoids the epmapper lookup on the 2nd connection */
2329 binding_str = dcerpc_binding_string(s, s->drsuapi1.binding);
2330 if (composite_nomem(binding_str, c)) return;
2332 c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi2.binding);
2333 talloc_free(binding_str);
2334 if (!composite_is_ok(c)) return;
2336 /* w2k3 uses the same assoc_group_id as on the first connection, so we do */
2337 s->drsuapi2.binding->assoc_group_id = s->drsuapi1.pipe->assoc_group_id;
2339 becomeDC_drsuapi_connect_send(s, &s->drsuapi2, becomeDC_drsuapi2_connect_recv);
2342 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s)
2344 if (!s->callbacks.prepare_db) return NT_STATUS_OK;
2346 s->_pp.domain = &s->domain;
2347 s->_pp.forest = &s->forest;
2348 s->_pp.source_dsa = &s->source_dsa;
2349 s->_pp.dest_dsa = &s->dest_dsa;
2351 return s->callbacks.prepare_db(s->callbacks.private_data, &s->_pp);
2354 static void becomeDC_drsuapi2_bind_recv(struct rpc_request *req);
2356 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req)
2358 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2359 struct libnet_BecomeDC_state);
2360 struct composite_context *c = s->creq;
2362 c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi2.pipe);
2363 if (!composite_is_ok(c)) return;
2365 c->status = gensec_session_key(s->drsuapi2.pipe->conn->security_state.generic_state,
2366 &s->drsuapi2.gensec_skey);
2367 if (!composite_is_ok(c)) return;
2369 becomeDC_drsuapi_bind_send(s, &s->drsuapi2, becomeDC_drsuapi2_bind_recv);
2372 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req);
2374 static void becomeDC_drsuapi2_bind_recv(struct rpc_request *req)
2376 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2377 struct libnet_BecomeDC_state);
2378 struct composite_context *c = s->creq;
2384 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2388 c->status = dcerpc_ndr_request_recv(req);
2389 if (!composite_is_ok(c)) return;
2392 NDR_PRINT_OUT_DEBUG(drsuapi_DsBind, &s->drsuapi2.bind_r);
2395 status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi2);
2396 if (!W_ERROR_IS_OK(status)) {
2397 composite_error(c, werror_to_ntstatus(status));
2401 /* this avoids the epmapper lookup on the 3rd connection */
2402 binding_str = dcerpc_binding_string(s, s->drsuapi1.binding);
2403 if (composite_nomem(binding_str, c)) return;
2405 c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi3.binding);
2406 talloc_free(binding_str);
2407 if (!composite_is_ok(c)) return;
2409 /* w2k3 uses the same assoc_group_id as on the first connection, so we do */
2410 s->drsuapi3.binding->assoc_group_id = s->drsuapi1.pipe->assoc_group_id;
2411 /* w2k3 uses the concurrent multiplex feature on the 3rd connection, so we do */
2412 s->drsuapi3.binding->flags |= DCERPC_CONCURRENT_MULTIPLEX;
2414 becomeDC_drsuapi_connect_send(s, &s->drsuapi3, becomeDC_drsuapi3_connect_recv);
2417 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s);
2419 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req)
2421 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2422 struct libnet_BecomeDC_state);
2423 struct composite_context *c = s->creq;
2425 c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi3.pipe);
2426 if (!composite_is_ok(c)) return;
2428 c->status = gensec_session_key(s->drsuapi3.pipe->conn->security_state.generic_state,
2429 &s->drsuapi3.gensec_skey);
2430 if (!composite_is_ok(c)) return;
2432 becomeDC_drsuapi3_pull_schema_send(s);
2435 static void becomeDC_drsuapi_pull_partition_send(struct libnet_BecomeDC_state *s,
2436 struct becomeDC_drsuapi *drsuapi_h,
2437 struct becomeDC_drsuapi *drsuapi_p,
2438 struct libnet_BecomeDC_Partition *partition,
2439 void (*recv_fn)(struct rpc_request *req))
2441 struct composite_context *c = s->creq;
2442 struct rpc_request *req;
2443 struct drsuapi_DsGetNCChanges *r;
2445 r = talloc(s, struct drsuapi_DsGetNCChanges);
2446 if (composite_nomem(r, c)) return;
2448 r->out.level_out = talloc(r, int32_t);
2449 if (composite_nomem(r->out.level_out, c)) return;
2450 r->in.req = talloc(r, union drsuapi_DsGetNCChangesRequest);
2451 if (composite_nomem(r->in.req, c)) return;
2452 r->out.ctr = talloc(r, union drsuapi_DsGetNCChangesCtr);
2453 if (composite_nomem(r->out.ctr, c)) return;
2455 r->in.bind_handle = &drsuapi_h->bind_handle;
2456 if (drsuapi_h->remote_info28.supported_extensions & DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8) {
2458 r->in.req->req8.destination_dsa_guid = partition->destination_dsa_guid;
2459 r->in.req->req8.source_dsa_invocation_id= partition->source_dsa_invocation_id;
2460 r->in.req->req8.naming_context = &partition->nc;
2461 r->in.req->req8.highwatermark = partition->highwatermark;
2462 r->in.req->req8.uptodateness_vector = NULL;
2463 r->in.req->req8.replica_flags = partition->replica_flags;
2464 r->in.req->req8.max_object_count = 133;
2465 r->in.req->req8.max_ndr_size = 1336811;
2466 r->in.req->req8.extended_op = DRSUAPI_EXOP_NONE;
2467 r->in.req->req8.fsmo_info = 0;
2468 r->in.req->req8.partial_attribute_set = NULL;
2469 r->in.req->req8.partial_attribute_set_ex= NULL;
2470 r->in.req->req8.mapping_ctr.num_mappings= 0;
2471 r->in.req->req8.mapping_ctr.mappings = NULL;
2474 r->in.req->req5.destination_dsa_guid = partition->destination_dsa_guid;
2475 r->in.req->req5.source_dsa_invocation_id= partition->source_dsa_invocation_id;
2476 r->in.req->req5.naming_context = &partition->nc;
2477 r->in.req->req5.highwatermark = partition->highwatermark;
2478 r->in.req->req5.uptodateness_vector = NULL;
2479 r->in.req->req5.replica_flags = partition->replica_flags;
2480 r->in.req->req5.max_object_count = 133;
2481 r->in.req->req5.max_ndr_size = 1336770;
2482 r->in.req->req5.extended_op = DRSUAPI_EXOP_NONE;
2483 r->in.req->req5.fsmo_info = 0;
2487 * we should try to use the drsuapi_p->pipe here, as w2k3 does
2488 * but it seems that some extra flags in the DCERPC Bind call
2489 * are needed for it. Or the same KRB5 TGS is needed on both
2492 req = dcerpc_drsuapi_DsGetNCChanges_send(drsuapi_p->pipe, r, r);
2493 composite_continue_rpc(c, req, recv_fn, s);
2496 static WERROR becomeDC_drsuapi_pull_partition_recv(struct libnet_BecomeDC_state *s,
2497 struct becomeDC_drsuapi *drsuapi_h,
2498 struct becomeDC_drsuapi *drsuapi_p,
2499 struct libnet_BecomeDC_Partition *partition,
2500 struct drsuapi_DsGetNCChanges *r)
2502 uint32_t ctr_level = 0;
2503 struct drsuapi_DsGetNCChangesCtr1 *ctr1 = NULL;
2504 struct drsuapi_DsGetNCChangesCtr6 *ctr6 = NULL;
2505 struct GUID *source_dsa_guid = NULL;
2506 struct GUID *source_dsa_invocation_id = NULL;
2507 struct drsuapi_DsReplicaHighWaterMark *new_highwatermark = NULL;
2508 bool more_data = false;
2511 if (!W_ERROR_IS_OK(r->out.result)) {
2512 return r->out.result;
2515 if (*r->out.level_out == 1) {
2517 ctr1 = &r->out.ctr->ctr1;
2518 } else if (*r->out.level_out == 2 &&
2519 r->out.ctr->ctr2.mszip1.ts) {
2521 ctr1 = &r->out.ctr->ctr2.mszip1.ts->ctr1;
2522 } else if (*r->out.level_out == 6) {
2524 ctr6 = &r->out.ctr->ctr6;
2525 } else if (*r->out.level_out == 7 &&
2526 r->out.ctr->ctr7.level == 6 &&
2527 r->out.ctr->ctr7.type == DRSUAPI_COMPRESSION_TYPE_MSZIP &&
2528 r->out.ctr->ctr7.ctr.mszip6.ts) {
2530 ctr6 = &r->out.ctr->ctr7.ctr.mszip6.ts->ctr6;
2531 } else if (*r->out.level_out == 7 &&
2532 r->out.ctr->ctr7.level == 6 &&
2533 r->out.ctr->ctr7.type == DRSUAPI_COMPRESSION_TYPE_XPRESS &&
2534 r->out.ctr->ctr7.ctr.xpress6.ts) {
2536 ctr6 = &r->out.ctr->ctr7.ctr.xpress6.ts->ctr6;
2538 return WERR_BAD_NET_RESP;
2541 if (!ctr1 && ! ctr6) {
2542 return WERR_BAD_NET_RESP;
2545 if (ctr_level == 6) {
2546 if (!W_ERROR_IS_OK(ctr6->drs_error)) {
2547 return ctr6->drs_error;
2551 switch (ctr_level) {
2553 source_dsa_guid = &ctr1->source_dsa_guid;
2554 source_dsa_invocation_id = &ctr1->source_dsa_invocation_id;
2555 new_highwatermark = &ctr1->new_highwatermark;
2556 more_data = ctr1->more_data;
2559 source_dsa_guid = &ctr6->source_dsa_guid;
2560 source_dsa_invocation_id = &ctr6->source_dsa_invocation_id;
2561 new_highwatermark = &ctr6->new_highwatermark;
2562 more_data = ctr6->more_data;
2566 partition->highwatermark = *new_highwatermark;
2567 partition->source_dsa_guid = *source_dsa_guid;
2568 partition->source_dsa_invocation_id = *source_dsa_invocation_id;
2569 partition->more_data = more_data;
2571 if (!partition->store_chunk) return WERR_OK;
2573 s->_sc.domain = &s->domain;
2574 s->_sc.forest = &s->forest;
2575 s->_sc.source_dsa = &s->source_dsa;
2576 s->_sc.dest_dsa = &s->dest_dsa;
2577 s->_sc.partition = partition;
2578 s->_sc.ctr_level = ctr_level;
2582 * we need to use the drsuapi_p->gensec_skey here,
2583 * when we use drsuapi_p->pipe in the for this request
2585 s->_sc.gensec_skey = &drsuapi_p->gensec_skey;
2587 nt_status = partition->store_chunk(s->callbacks.private_data, &s->_sc);
2588 if (!NT_STATUS_IS_OK(nt_status)) {
2589 return ntstatus_to_werror(nt_status);
2595 static void becomeDC_drsuapi3_pull_schema_recv(struct rpc_request *req);
2597 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s)
2599 s->schema_part.nc.guid = GUID_zero();
2600 s->schema_part.nc.sid = s->zero_sid;
2601 s->schema_part.nc.dn = s->forest.schema_dn_str;
2603 s->schema_part.destination_dsa_guid = s->drsuapi2.bind_guid;
2605 s->schema_part.replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
2606 | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
2607 | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
2608 | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
2609 | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
2610 | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
2612 s->schema_part.store_chunk = s->callbacks.schema_chunk;
2614 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
2615 becomeDC_drsuapi3_pull_schema_recv);
2618 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s);
2620 static void becomeDC_drsuapi3_pull_schema_recv(struct rpc_request *req)
2622 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2623 struct libnet_BecomeDC_state);
2624 struct composite_context *c = s->creq;
2625 struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
2626 struct drsuapi_DsGetNCChanges);
2631 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2635 c->status = dcerpc_ndr_request_recv(req);
2636 if (!composite_is_ok(c)) return;
2639 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
2642 status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part, r);
2643 if (!W_ERROR_IS_OK(status)) {
2644 composite_error(c, werror_to_ntstatus(status));
2650 if (s->schema_part.more_data) {
2651 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part,
2652 becomeDC_drsuapi3_pull_schema_recv);
2656 becomeDC_drsuapi3_pull_config_send(s);
2659 static void becomeDC_drsuapi3_pull_config_recv(struct rpc_request *req);
2661 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s)
2663 s->config_part.nc.guid = GUID_zero();
2664 s->config_part.nc.sid = s->zero_sid;
2665 s->config_part.nc.dn = s->forest.config_dn_str;
2667 s->config_part.destination_dsa_guid = s->drsuapi2.bind_guid;
2669 s->config_part.replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
2670 | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
2671 | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
2672 | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
2673 | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
2674 | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
2676 s->config_part.store_chunk = s->callbacks.config_chunk;
2678 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
2679 becomeDC_drsuapi3_pull_config_recv);
2682 static void becomeDC_drsuapi3_pull_config_recv(struct rpc_request *req)
2684 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2685 struct libnet_BecomeDC_state);
2686 struct composite_context *c = s->creq;
2687 struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
2688 struct drsuapi_DsGetNCChanges);
2693 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2697 c->status = dcerpc_ndr_request_recv(req);
2698 if (!composite_is_ok(c)) return;
2701 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
2704 status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->config_part, r);
2705 if (!W_ERROR_IS_OK(status)) {
2706 composite_error(c, werror_to_ntstatus(status));
2712 if (s->config_part.more_data) {
2713 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->config_part,
2714 becomeDC_drsuapi3_pull_config_recv);
2718 becomeDC_connect_ldap2(s);
2721 static void becomeDC_drsuapi3_pull_domain_recv(struct rpc_request *req);
2723 static void becomeDC_drsuapi3_pull_domain_send(struct libnet_BecomeDC_state *s)
2725 s->domain_part.nc.guid = GUID_zero();
2726 s->domain_part.nc.sid = s->zero_sid;
2727 s->domain_part.nc.dn = s->domain.dn_str;
2729 s->domain_part.destination_dsa_guid = s->drsuapi2.bind_guid;
2731 s->domain_part.replica_flags = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
2732 | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
2733 | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
2734 | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
2735 | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
2736 | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
2738 s->domain_part.store_chunk = s->callbacks.domain_chunk;
2740 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
2741 becomeDC_drsuapi3_pull_domain_recv);
2744 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
2745 struct becomeDC_drsuapi *drsuapi,
2746 struct libnet_BecomeDC_Partition *partition,
2747 void (*recv_fn)(struct rpc_request *req));
2748 static void becomeDC_drsuapi2_update_refs_schema_recv(struct rpc_request *req);
2750 static void becomeDC_drsuapi3_pull_domain_recv(struct rpc_request *req)
2752 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2753 struct libnet_BecomeDC_state);
2754 struct composite_context *c = s->creq;
2755 struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
2756 struct drsuapi_DsGetNCChanges);
2760 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2764 c->status = dcerpc_ndr_request_recv(req);
2765 if (!composite_is_ok(c)) return;
2768 NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
2771 status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part, r);
2772 if (!W_ERROR_IS_OK(status)) {
2773 composite_error(c, werror_to_ntstatus(status));
2779 if (s->domain_part.more_data) {
2780 becomeDC_drsuapi_pull_partition_send(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part,
2781 becomeDC_drsuapi3_pull_domain_recv);
2785 becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->schema_part,
2786 becomeDC_drsuapi2_update_refs_schema_recv);
2789 static void becomeDC_drsuapi_update_refs_send(struct libnet_BecomeDC_state *s,
2790 struct becomeDC_drsuapi *drsuapi,
2791 struct libnet_BecomeDC_Partition *partition,
2792 void (*recv_fn)(struct rpc_request *req))
2794 struct composite_context *c = s->creq;
2795 struct rpc_request *req;
2796 struct drsuapi_DsReplicaUpdateRefs *r;
2797 const char *ntds_guid_str;
2798 const char *ntds_dns_name;
2800 r = talloc(s, struct drsuapi_DsReplicaUpdateRefs);
2801 if (composite_nomem(r, c)) return;
2803 ntds_guid_str = GUID_string(r, &s->dest_dsa.ntds_guid);
2804 if (composite_nomem(ntds_guid_str, c)) return;
2806 ntds_dns_name = talloc_asprintf(r, "%s._msdcs.%s",
2808 s->domain.dns_name);
2809 if (composite_nomem(ntds_dns_name, c)) return;
2811 r->in.bind_handle = &drsuapi->bind_handle;
2813 r->in.req.req1.naming_context = &partition->nc;
2814 r->in.req.req1.dest_dsa_dns_name= ntds_dns_name;
2815 r->in.req.req1.dest_dsa_guid = s->dest_dsa.ntds_guid;
2816 r->in.req.req1.options = DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE
2817 | DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE;
2819 /* I think this is how we mark ourselves as a RODC */
2820 if (!lp_parm_bool(s->libnet->lp_ctx, NULL, "repl", "RODC", false)) {
2821 r->in.req.req1.options |= DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE;
2824 req = dcerpc_drsuapi_DsReplicaUpdateRefs_send(drsuapi->pipe, r, r);
2825 composite_continue_rpc(c, req, recv_fn, s);
2828 static void becomeDC_drsuapi2_update_refs_config_recv(struct rpc_request *req);
2830 static void becomeDC_drsuapi2_update_refs_schema_recv(struct rpc_request *req)
2832 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2833 struct libnet_BecomeDC_state);
2834 struct composite_context *c = s->creq;
2835 struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
2836 struct drsuapi_DsReplicaUpdateRefs);
2839 if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
2843 c->status = dcerpc_ndr_request_recv(req);
2844 if (!composite_is_ok(c)) return;
2847 NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaUpdateRefs, r);
2850 if (!W_ERROR_IS_OK(r->out.result)) {
2851 composite_error(c, werror_to_ntstatus(r->out.result));
2857 becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->config_part,
2858 becomeDC_drsuapi2_update_refs_config_recv);
2861 static void becomeDC_drsuapi2_update_refs_domain_recv(struct rpc_request *req);
2863 static void becomeDC_drsuapi2_update_refs_config_recv(struct rpc_request *req)
2865 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2866 struct libnet_BecomeDC_state);
2867 struct composite_context *c = s->creq;
2868 struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
2869 struct drsuapi_DsReplicaUpdateRefs);
2871 c->status = dcerpc_ndr_request_recv(req);
2872 if (!composite_is_ok(c)) return;
2874 if (!W_ERROR_IS_OK(r->out.result)) {
2875 composite_error(c, werror_to_ntstatus(r->out.result));
2881 becomeDC_drsuapi_update_refs_send(s, &s->drsuapi2, &s->domain_part,
2882 becomeDC_drsuapi2_update_refs_domain_recv);
2885 static void becomeDC_drsuapi2_update_refs_domain_recv(struct rpc_request *req)
2887 struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
2888 struct libnet_BecomeDC_state);
2889 struct composite_context *c = s->creq;
2890 struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
2891 struct drsuapi_DsReplicaUpdateRefs);
2893 c->status = dcerpc_ndr_request_recv(req);
2894 if (!composite_is_ok(c)) return;
2896 if (!W_ERROR_IS_OK(r->out.result)) {
2897 composite_error(c, werror_to_ntstatus(r->out.result));
2903 /* TODO: use DDNS updates and register dns names */
2907 static NTSTATUS becomeDC_ldap2_modify_computer(struct libnet_BecomeDC_state *s)
2910 struct ldb_message *msg;
2912 uint32_t user_account_control = UF_SERVER_TRUST_ACCOUNT |
2913 UF_TRUSTED_FOR_DELEGATION;
2915 /* as the value is already as we want it to be, we're done */
2916 if (s->dest_dsa.user_account_control == user_account_control) {
2917 return NT_STATUS_OK;
2920 /* make a 'modify' msg, and only for serverReference */
2921 msg = ldb_msg_new(s);
2922 NT_STATUS_HAVE_NO_MEMORY(msg);
2923 msg->dn = ldb_dn_new(msg, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
2924 NT_STATUS_HAVE_NO_MEMORY(msg->dn);
2926 ret = ldb_msg_add_fmt(msg, "userAccountControl", "%u", user_account_control);
2929 return NT_STATUS_NO_MEMORY;
2932 /* mark all the message elements (should be just one)
2933 as LDB_FLAG_MOD_REPLACE */
2934 for (i=0;i<msg->num_elements;i++) {
2935 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
2938 ret = ldb_modify(s->ldap2.ldb, msg);
2940 if (ret != LDB_SUCCESS) {
2941 return NT_STATUS_LDAP(ret);
2944 s->dest_dsa.user_account_control = user_account_control;
2946 return NT_STATUS_OK;
2949 static NTSTATUS becomeDC_ldap2_move_computer(struct libnet_BecomeDC_state *s)
2952 struct ldb_result *r;
2953 struct ldb_dn *basedn;
2954 struct ldb_dn *old_dn;
2955 struct ldb_dn *new_dn;
2956 static const char *_1_1_attrs[] = {
2961 basedn = ldb_dn_new_fmt(s, s->ldap2.ldb, "<WKGUID=a361b2ffffd211d1aa4b00c04fd7d83a,%s>",
2963 NT_STATUS_HAVE_NO_MEMORY(basedn);
2965 ret = ldb_search(s->ldap2.ldb, s, &r, basedn, LDB_SCOPE_BASE,
2966 _1_1_attrs, "(objectClass=*)");
2967 talloc_free(basedn);
2968 if (ret != LDB_SUCCESS) {
2969 return NT_STATUS_LDAP(ret);
2970 } else if (r->count != 1) {
2972 return NT_STATUS_INVALID_NETWORK_RESPONSE;
2975 old_dn = ldb_dn_new(r, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
2976 NT_STATUS_HAVE_NO_MEMORY(old_dn);
2978 new_dn = r->msgs[0]->dn;
2980 if (!ldb_dn_add_child_fmt(new_dn, "CN=%s", s->dest_dsa.netbios_name)) {
2982 return NT_STATUS_NO_MEMORY;
2985 if (ldb_dn_compare(old_dn, new_dn) == 0) {
2986 /* we don't need to rename if the old and new dn match */
2988 return NT_STATUS_OK;
2991 ret = ldb_rename(s->ldap2.ldb, old_dn, new_dn);
2992 if (ret != LDB_SUCCESS) {
2994 return NT_STATUS_LDAP(ret);
2997 s->dest_dsa.computer_dn_str = ldb_dn_alloc_linearized(s, new_dn);
2998 NT_STATUS_HAVE_NO_MEMORY(s->dest_dsa.computer_dn_str);
3002 return NT_STATUS_OK;
3005 static void becomeDC_connect_ldap2(struct libnet_BecomeDC_state *s)
3007 struct composite_context *c = s->creq;
3009 c->status = becomeDC_ldap_connect(s, &s->ldap2);
3010 if (!composite_is_ok(c)) return;
3012 c->status = becomeDC_ldap2_modify_computer(s);
3013 if (!composite_is_ok(c)) return;
3015 c->status = becomeDC_ldap2_move_computer(s);
3016 if (!composite_is_ok(c)) return;
3018 becomeDC_drsuapi3_pull_domain_send(s);
3021 struct composite_context *libnet_BecomeDC_send(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3023 struct composite_context *c;
3024 struct libnet_BecomeDC_state *s;
3027 c = composite_create(mem_ctx, ctx->event_ctx);
3028 if (c == NULL) return NULL;
3030 s = talloc_zero(c, struct libnet_BecomeDC_state);
3031 if (composite_nomem(s, c)) return c;
3032 c->private_data = s;
3037 s->domain.dns_name = talloc_strdup(s, r->in.domain_dns_name);
3038 if (composite_nomem(s->domain.dns_name, c)) return c;
3039 s->domain.netbios_name = talloc_strdup(s, r->in.domain_netbios_name);
3040 if (composite_nomem(s->domain.netbios_name, c)) return c;
3041 s->domain.sid = dom_sid_dup(s, r->in.domain_sid);
3042 if (composite_nomem(s->domain.sid, c)) return c;
3044 /* Source DSA input */
3045 s->source_dsa.address = talloc_strdup(s, r->in.source_dsa_address);
3046 if (composite_nomem(s->source_dsa.address, c)) return c;
3048 /* Destination DSA input */
3049 s->dest_dsa.netbios_name= talloc_strdup(s, r->in.dest_dsa_netbios_name);
3050 if (composite_nomem(s->dest_dsa.netbios_name, c)) return c;
3052 /* Destination DSA dns_name construction */
3053 tmp_name = strlower_talloc(s, s->dest_dsa.netbios_name);
3054 if (composite_nomem(tmp_name, c)) return c;
3055 tmp_name = talloc_asprintf_append_buffer(tmp_name, ".%s",s->domain.dns_name);
3056 if (composite_nomem(tmp_name, c)) return c;
3057 s->dest_dsa.dns_name = tmp_name;
3059 /* Callback function pointers */
3060 s->callbacks = r->in.callbacks;
3062 becomeDC_send_cldap(s);
3066 NTSTATUS libnet_BecomeDC_recv(struct composite_context *c, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3070 status = composite_wait(c);
3072 ZERO_STRUCT(r->out);
3078 NTSTATUS libnet_BecomeDC(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_BecomeDC *r)
3081 struct composite_context *c;
3082 c = libnet_BecomeDC_send(ctx, mem_ctx, r);
3083 status = libnet_BecomeDC_recv(c, mem_ctx, r);