Changeset 740 for vendor/current/source4/libnet

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/source4/libnet

Files:

• config.mk (deleted)
• groupinfo.c (modified) (12 diffs)
• groupman.c (modified) (9 diffs)
• libnet.c (modified) (2 diffs)
• libnet.h (modified) (3 diffs)
• libnet_become_dc.c (modified) (90 diffs)
• libnet_become_dc.h (modified) (1 diff)
• libnet_domain.c (modified) (39 diffs)
• libnet_export_keytab.c (modified) (3 diffs)
• libnet_group.c (modified) (15 diffs)
• libnet_join.c (modified) (29 diffs)
• libnet_lookup.c (modified) (9 diffs)
• libnet_passwd.c (modified) (19 diffs)
• libnet_rpc.c (modified) (18 diffs)
• libnet_samdump.c (modified) (1 diff)
• libnet_samdump_keytab.c (deleted)
• libnet_samsync.c (modified) (4 diffs)
• libnet_samsync_ldb.c (modified) (34 diffs)
• libnet_share.c (modified) (3 diffs)
• libnet_site.c (modified) (13 diffs)
• libnet_time.c (modified) (1 diff)
• libnet_unbecome_dc.c (modified) (14 diffs)
• libnet_user.c (modified) (17 diffs)
• libnet_vampire.c (modified) (30 diffs)
• libnet_vampire.h (modified) (1 diff)
• py_net.c (modified) (2 diffs)
• userinfo.c (modified) (12 diffs)
• userman.c (modified) (28 diffs)
• wscript_build (added)

vendor/current/source4/libnet/groupinfo.c

@@ -47 +47 @@
 
 
-static void continue_groupinfo_lookup(struct rpc_request *req);
-static void continue_groupinfo_opengroup(struct rpc_request *req);
-static void continue_groupinfo_getgroup(struct rpc_request *req);
-static void continue_groupinfo_closegroup(struct rpc_request *req);
+static void continue_groupinfo_lookup(struct tevent_req *subreq);
+static void continue_groupinfo_opengroup(struct tevent_req *subreq);
+static void continue_groupinfo_getgroup(struct tevent_req *subreq);
+static void continue_groupinfo_closegroup(struct tevent_req *subreq);
 
 
@@ -56 +56 @@
  * Stage 1 (optional): Look for a group name in SAM server.
  */
-static void continue_groupinfo_lookup(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct groupinfo_state *s;
-        struct rpc_request *opengroup_req;
+static void continue_groupinfo_lookup(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct groupinfo_state *s;
         struct monitor_msg msg;
         struct msg_rpc_lookup_name *msg_lookup;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct groupinfo_state);
 
         /* receive samr_Lookup reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_LookupNames_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
         
@@ -105 +105 @@
 
         /* send request */
-        opengroup_req = dcerpc_samr_OpenGroup_send(s->pipe, c, &s->opengroup);
-        if (composite_nomem(opengroup_req, c)) return;
-
-        composite_continue_rpc(c, opengroup_req, continue_groupinfo_opengroup, c);
+        subreq = dcerpc_samr_OpenGroup_r_send(s, c->event_ctx,
+                                              s->pipe->binding_handle,
+                                              &s->opengroup);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_groupinfo_opengroup, c);
 }
 
@@ -115 +117 @@
  * Stage 2: Open group policy handle.
  */
-static void continue_groupinfo_opengroup(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct groupinfo_state *s;
-        struct rpc_request *querygroup_req;
+static void continue_groupinfo_opengroup(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct groupinfo_state *s;
         struct monitor_msg msg;
         struct msg_rpc_open_group *msg_open;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct groupinfo_state);
 
         /* receive samr_OpenGroup reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_OpenGroup_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -154 +156 @@
         
         /* queue rpc call, set event handling and new state */
-        querygroup_req = dcerpc_samr_QueryGroupInfo_send(s->pipe, c, &s->querygroupinfo);
-        if (composite_nomem(querygroup_req, c)) return;
-        
-        composite_continue_rpc(c, querygroup_req, continue_groupinfo_getgroup, c);
+        subreq = dcerpc_samr_QueryGroupInfo_r_send(s,
+                                                   c->event_ctx,
+                                                   s->pipe->binding_handle,
+                                                   &s->querygroupinfo);
+        if (composite_nomem(subreq, c)) return;
+        
+        tevent_req_set_callback(subreq, continue_groupinfo_getgroup, c);
 }
 
@@ -164 +169 @@
  * Stage 3: Get requested group information.
  */
-static void continue_groupinfo_getgroup(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct groupinfo_state *s;
-        struct rpc_request *close_req;
+static void continue_groupinfo_getgroup(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct groupinfo_state *s;
         struct monitor_msg msg;
         struct msg_rpc_query_group *msg_query;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct groupinfo_state);
 
         /* receive samr_QueryGroupInfo reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_QueryGroupInfo_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -203 +208 @@
         
         /* queue rpc call, set event handling and new state */
-        close_req = dcerpc_samr_Close_send(s->pipe, c, &s->samrclose);
-        if (composite_nomem(close_req, c)) return;
-        
-        composite_continue_rpc(c, close_req, continue_groupinfo_closegroup, c);
+        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
+                                          s->pipe->binding_handle,
+                                          &s->samrclose);
+        if (composite_nomem(subreq, c)) return;
+        
+        tevent_req_set_callback(subreq, continue_groupinfo_closegroup, c);
 }
 
@@ -213 +220 @@
  * Stage 4: Close policy handle associated with opened group.
  */
-static void continue_groupinfo_closegroup(struct rpc_request *req)
+static void continue_groupinfo_closegroup(struct tevent_req *subreq)
 {
         struct composite_context *c;
@@ -220 +227 @@
         struct msg_rpc_close_group *msg_close;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct groupinfo_state);
 
         /* receive samr_Close reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_Close_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -260 +268 @@
         struct groupinfo_state *s;
         struct dom_sid *sid;
-        struct rpc_request *opengroup_req, *lookup_req;
+        struct tevent_req *subreq;
 
         if (!p || !io) return NULL;
@@ -287 +295 @@
                 
                 /* send request */
-                opengroup_req = dcerpc_samr_OpenGroup_send(p, c, &s->opengroup);
-                if (composite_nomem(opengroup_req, c)) return c;
-
-                composite_continue_rpc(c, opengroup_req, continue_groupinfo_opengroup, c);
+                subreq = dcerpc_samr_OpenGroup_r_send(s, c->event_ctx,
+                                                      p->binding_handle,
+                                                      &s->opengroup);
+                if (composite_nomem(subreq, c)) return c;
+
+                tevent_req_set_callback(subreq, continue_groupinfo_opengroup, c);
 
         } else {
@@ -307 +317 @@
 
                 /* send request */
-                lookup_req = dcerpc_samr_LookupNames_send(p, c, &s->lookup);
-                if (composite_nomem(lookup_req, c)) return c;
-                
-                composite_continue_rpc(c, lookup_req, continue_groupinfo_lookup, c);
+                subreq = dcerpc_samr_LookupNames_r_send(s, c->event_ctx,
+                                                        p->binding_handle,
+                                                        &s->lookup);
+                if (composite_nomem(subreq, c)) return c;
+                
+                tevent_req_set_callback(subreq, continue_groupinfo_lookup, c);
         }
 

vendor/current/source4/libnet/groupman.c

@@ -39 +39 @@
 
 
-static void continue_groupadd_created(struct rpc_request *req);
+static void continue_groupadd_created(struct tevent_req *subreq);
 
 
@@ -48 +48 @@
         struct composite_context *c;
         struct groupadd_state *s;
-        struct rpc_request *create_req;
+        struct tevent_req *subreq;
 
         if (!p || !io) return NULL;
@@ -77 +77 @@
         s->creategroup.out.rid           = &s->group_rid;
         
-        create_req = dcerpc_samr_CreateDomainGroup_send(s->pipe, c, &s->creategroup);
-        if (composite_nomem(create_req, c)) return c;
-
-        composite_continue_rpc(c, create_req, continue_groupadd_created, c);
+        subreq = dcerpc_samr_CreateDomainGroup_r_send(s, c->event_ctx,
+                                                      s->pipe->binding_handle,
+                                                      &s->creategroup);
+        if (composite_nomem(subreq, c)) return c;
+
+        tevent_req_set_callback(subreq, continue_groupadd_created, c);
         return c;
 }
@@ -100 +102 @@
 
 
-static void continue_groupadd_created(struct rpc_request *req)
+static void continue_groupadd_created(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct groupadd_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct groupadd_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_CreateDomainGroup_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -141 +144 @@
 
 
-static void continue_groupdel_name_found(struct rpc_request *req);
-static void continue_groupdel_group_opened(struct rpc_request *req);
-static void continue_groupdel_deleted(struct rpc_request *req);
+static void continue_groupdel_name_found(struct tevent_req *subreq);
+static void continue_groupdel_group_opened(struct tevent_req *subreq);
+static void continue_groupdel_deleted(struct tevent_req *subreq);
 
 
@@ -152 +155 @@
         struct composite_context *c;
         struct groupdel_state *s;
-        struct rpc_request *lookup_req;
+        struct tevent_req *subreq;
 
         /* composite context allocation and setup */
@@ -179 +182 @@
 
         /* send the request */
-        lookup_req = dcerpc_samr_LookupNames_send(p, c, &s->lookupname);
-        if (composite_nomem(lookup_req, c)) return c;
-
-        composite_continue_rpc(c, lookup_req, continue_groupdel_name_found, c);
+        subreq = dcerpc_samr_LookupNames_r_send(s, c->event_ctx,
+                                                p->binding_handle,
+                                                &s->lookupname);
+        if (composite_nomem(subreq, c)) return c;
+
+        tevent_req_set_callback(subreq, continue_groupdel_name_found, c);
         return c;
 }
 
 
-static void continue_groupdel_name_found(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct groupdel_state *s;
-        struct rpc_request *opengroup_req;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+static void continue_groupdel_name_found(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct groupdel_state *s;
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct groupdel_state);
 
         /* receive samr_LookupNames result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_LookupNames_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -226 +231 @@
 
         /* send rpc request */
-        opengroup_req = dcerpc_samr_OpenGroup_send(s->pipe, c, &s->opengroup);
-        if (composite_nomem(opengroup_req, c)) return;
-
-        composite_continue_rpc(c, opengroup_req, continue_groupdel_group_opened, c);
-}
-
-
-static void continue_groupdel_group_opened(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct groupdel_state *s;
-        struct rpc_request *delgroup_req;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        subreq = dcerpc_samr_OpenGroup_r_send(s, c->event_ctx,
+                                              s->pipe->binding_handle,
+                                              &s->opengroup);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_groupdel_group_opened, c);
+}
+
+
+static void continue_groupdel_group_opened(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct groupdel_state *s;
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct groupdel_state);
 
         /* receive samr_OpenGroup result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_OpenGroup_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -257 +264 @@
         
         /* send rpc request */
-        delgroup_req = dcerpc_samr_DeleteDomainGroup_send(s->pipe, c, &s->deletegroup);
-        if (composite_nomem(delgroup_req, c)) return;
+        subreq = dcerpc_samr_DeleteDomainGroup_r_send(s, c->event_ctx,
+                                                      s->pipe->binding_handle,
+                                                      &s->deletegroup);
+        if (composite_nomem(subreq, c)) return;
 
         /* callback handler setup */
-        composite_continue_rpc(c, delgroup_req, continue_groupdel_deleted, c);
-}
-
-
-static void continue_groupdel_deleted(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct groupdel_state *s;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        tevent_req_set_callback(subreq, continue_groupdel_deleted, c);
+}
+
+
+static void continue_groupdel_deleted(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct groupdel_state *s;
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct groupdel_state);
 
         /* receive samr_DeleteGroup result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_DeleteDomainGroup_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 

vendor/current/source4/libnet/libnet.c

@@ -43 +43 @@
         ctx->lp_ctx = lp_ctx;
 
+        /* make sure dcerpc is initialized */
+        dcerpc_init(lp_ctx);
+
         /* name resolution methods */
-        ctx->resolve_ctx = lp_resolve_context(lp_ctx);
+        ctx->resolve_ctx = lpcfg_resolve_context(lp_ctx);
 
         /* connected services' params */
@@ -53 +56 @@
         ctx->samr.buf_size = 128;
 
+        ctx->server_address = NULL;
+
         return ctx;
 }

vendor/current/source4/libnet/libnet.h

@@ -31 +31 @@
         struct {
                 struct dcerpc_pipe *pipe;
+                struct dcerpc_binding_handle *samr_handle;
                 const char *name;
                 struct dom_sid *sid;
@@ -42 +43 @@
         struct {
                 struct dcerpc_pipe *pipe;
+                struct dcerpc_binding_handle *lsa_handle;
                 const char *name;
                 uint32_t access_mask;
@@ -53 +55 @@
 
         struct loadparm_context *lp_ctx;
+
+        /* if non-null then override the server address */
+        const char *server_address;
 };
 
 
-#include "lib/ldb/include/ldb.h"
+#include <ldb.h>
 #include "libnet/composite.h"
 #include "libnet/userman.h"

vendor/current/source4/libnet/libnet_become_dc.c

@@ -22 +22 @@
 #include "libcli/composite/composite.h"
 #include "libcli/cldap/cldap.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
-#include "lib/ldb_wrap.h"
+#include <ldb.h>
+#include <ldb_errors.h>
+#include "ldb_wrap.h"
 #include "dsdb/samdb/samdb.h"
 #include "../libds/common/flags.h"
@@ -35 +35 @@
 #include "auth/gensec/gensec.h"
 #include "param/param.h"
+#include "lib/tsocket/tsocket.h"
 
 /*****************************************************************************
@@ -337 +338 @@
  *              objectGUID:     <object_guid>
  *              systemFlags:    1107296256 <0x42000000>
- *              objectCategory: CN=Site,C=Schema,CN=Configuration,<domain_partition>
+ *              objectCategory: CN=Site,CN=Schema,CN=Configuration,<domain_partition>
  */
 
@@ -701 +702 @@
                 struct dcerpc_binding *binding;
                 struct dcerpc_pipe *pipe;
+                struct dcerpc_binding_handle *drsuapi_handle;
                 DATA_BLOB gensec_skey;
                 struct drsuapi_DsBind bind_r;
@@ -710 +712 @@
         } drsuapi1, drsuapi2, drsuapi3;
 
+        void *ndr_struct_ptr;
+
         struct libnet_BecomeDC_Domain domain;
         struct libnet_BecomeDC_Forest forest;
@@ -730 +734 @@
         struct libnet_BecomeDC_StoreChunk _sc;
         struct libnet_BecomeDC_Callbacks callbacks;
+
+        bool rodc_join;
 };
+
+static int32_t get_dc_function_level(struct loadparm_context *lp_ctx)
+{
+        /* per default we are (Windows) 2008 R2 compatible */
+        return lpcfg_parm_int(lp_ctx, NULL, "ads", "dc function level",
+                           DS_DOMAIN_FUNCTION_2008_R2);
+}
 
 static void becomeDC_recv_cldap(struct tevent_req *req);
@@ -738 +751 @@
         struct composite_context *c = s->creq;
         struct tevent_req *req;
-
-        s->cldap.io.in.dest_address     = s->source_dsa.address;
-        s->cldap.io.in.dest_port        = lp_cldap_port(s->libnet->lp_ctx);
+        struct tsocket_address *dest_address;
+        int ret;
+
+        s->cldap.io.in.dest_address     = NULL;
+        s->cldap.io.in.dest_port        = 0;
         s->cldap.io.in.realm            = s->domain.dns_name;
         s->cldap.io.in.host             = s->dest_dsa.netbios_name;
@@ -750 +765 @@
         s->cldap.io.in.map_response     = true;
 
+        ret = tsocket_address_inet_from_strings(s, "ip",
+                                                s->source_dsa.address,
+                                                lpcfg_cldap_port(s->libnet->lp_ctx),
+                                                &dest_address);
+        if (ret != 0) {
+                c->status = map_nt_error_from_unix(errno);
+                if (!composite_is_ok(c)) return;
+        }
+
         c->status = cldap_socket_init(s, s->libnet->event_ctx,
-                                      NULL, NULL, &s->cldap.sock);//TODO
+                                      NULL, dest_address, &s->cldap.sock);
         if (!composite_is_ok(c)) return;
 
@@ -767 +791 @@
         struct composite_context *c = s->creq;
 
-        c->status = cldap_netlogon_recv(req,
-                                        lp_iconv_convenience(s->libnet->lp_ctx),
-                                        s, &s->cldap.io);
+        c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
         talloc_free(req);
-        if (!composite_is_ok(c)) return;
-
+        if (!composite_is_ok(c)) {
+                DEBUG(0,("Failed to send, receive or parse CLDAP reply from server %s for our host %s: %s\n", 
+                         s->cldap.io.in.dest_address, 
+                         s->cldap.io.in.host, 
+                         nt_errstr(c->status)));
+                return;
+        }
         s->cldap.netlogon = s->cldap.io.out.netlogon.data.nt5_ex;
 
         s->domain.dns_name              = s->cldap.netlogon.dns_domain;
-        s->domain.netbios_name          = s->cldap.netlogon.domain;
+        s->domain.netbios_name          = s->cldap.netlogon.domain_name;
         s->domain.guid                  = s->cldap.netlogon.domain_uuid;
 
@@ -787 +814 @@
         s->dest_dsa.site_name           = s->cldap.netlogon.client_site;
 
+        DEBUG(0,("CLDAP response: forest=%s dns=%s netbios=%s server_site=%s  client_site=%s\n",
+                 s->forest.dns_name, s->domain.dns_name, s->domain.netbios_name,
+                 s->source_dsa.site_name, s->dest_dsa.site_name));
+        if (!s->dest_dsa.site_name || strcmp(s->dest_dsa.site_name, "") == 0) {
+                DEBUG(0,("Got empty client site - using server site name %s\n",
+                         s->source_dsa.site_name));
+                s->dest_dsa.site_name = s->source_dsa.site_name;
+        }
+
         becomeDC_connect_ldap1(s);
 }
@@ -801 +837 @@
                                      NULL,
                                      s->libnet->cred,
-                                     0, NULL);
+                                     0);
         talloc_free(url);
         if (ldap->ldb == NULL) {
@@ -877 +913 @@
 
         s->forest.crossref_behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
+        if (s->forest.crossref_behavior_version >
+                        get_dc_function_level(s->libnet->lp_ctx)) {
+                talloc_free(r);
+                DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n", 
+                         s->forest.crossref_behavior_version, 
+                         get_dc_function_level(s->libnet->lp_ctx)));
+                return NT_STATUS_NOT_SUPPORTED;
+        }
 
         talloc_free(r);
@@ -906 +950 @@
 
         s->domain.behavior_version = ldb_msg_find_attr_as_uint(r->msgs[0], "msDs-Behavior-Version", 0);
+        if (s->domain.behavior_version >
+                        get_dc_function_level(s->libnet->lp_ctx)) {
+                talloc_free(r);
+                DEBUG(0,("The servers function level %u is above 'ads:dc function level' of %u\n", 
+                         s->forest.crossref_behavior_version, 
+                         get_dc_function_level(s->libnet->lp_ctx)));
+                return NT_STATUS_NOT_SUPPORTED;
+        }
 
         talloc_free(r);
@@ -981 +1033 @@
         struct ldb_dn *ntds_dn;
         struct ldb_dn *server_dn;
-        static const char *_1_1_attrs[] = {
-                "1.1",
-                NULL
-        };
-        static const char *fsmo_attrs[] = {
-                "fSMORoleOwner",
-                NULL
-        };
         static const char *dns_attrs[] = {
                 "dnsHostName",
@@ -998 +1042 @@
         };
 
-        basedn = ldb_dn_new_fmt(s, s->ldap1.ldb, "<WKGUID=2fbac1870ade11d297c400c04fd8d5cd,%s>",
-                                s->domain.dn_str);
-        NT_STATUS_HAVE_NO_MEMORY(basedn);
-
-        ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
-                         _1_1_attrs, "(objectClass=*)");
-        talloc_free(basedn);
+        ret = dsdb_wellknown_dn(s->ldap1.ldb, s,
+                                ldb_get_default_basedn(s->ldap1.ldb),
+                                DS_GUID_INFRASTRUCTURE_CONTAINER,
+                                &basedn);
         if (ret != LDB_SUCCESS) {
                 return NT_STATUS_LDAP(ret);
-        } else if (r->count != 1) {
-                talloc_free(r);
-                return NT_STATUS_INVALID_NETWORK_RESPONSE;
-        }
-
-        basedn = talloc_steal(s, r->msgs[0]->dn);
-        talloc_free(r);
-
-        ret = ldb_search(s->ldap1.ldb, s, &r, basedn, LDB_SCOPE_BASE,
-                         fsmo_attrs, "(objectClass=*)");
-        talloc_free(basedn);
+        }
+
+        ret = samdb_reference_dn(s->ldap1.ldb, s, basedn, "fSMORoleOwner", &ntds_dn);
         if (ret != LDB_SUCCESS) {
+                talloc_free(basedn);
                 return NT_STATUS_LDAP(ret);
-        } else if (r->count != 1) {
-                talloc_free(r);
-                return NT_STATUS_INVALID_NETWORK_RESPONSE;
-        }
-
-        s->infrastructure_fsmo.ntds_dn_str      = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
-        if (!s->infrastructure_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
-        talloc_steal(s, s->infrastructure_fsmo.ntds_dn_str);
-
-        talloc_free(r);
-
-        ntds_dn = ldb_dn_new(s, s->ldap1.ldb, s->infrastructure_fsmo.ntds_dn_str);
-        NT_STATUS_HAVE_NO_MEMORY(ntds_dn);
+        }
+
+        s->infrastructure_fsmo.ntds_dn_str = ldb_dn_get_linearized(ntds_dn);
+        NT_STATUS_HAVE_NO_MEMORY(s->infrastructure_fsmo.ntds_dn_str);
 
         server_dn = ldb_dn_get_parent(s, ntds_dn);
@@ -1049 +1074 @@
         }
 
-        s->infrastructure_fsmo.dns_name = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
+        s->infrastructure_fsmo.dns_name = ldb_msg_find_attr_as_string(r->msgs[0], "dnsHostName", NULL);
         if (!s->infrastructure_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
         talloc_steal(s, s->infrastructure_fsmo.dns_name);
@@ -1109 +1134 @@
         }
 
-        reference_dn_str        = samdb_result_string(r->msgs[0], "rIDManagerReference", NULL);
+        reference_dn_str        = ldb_msg_find_attr_as_string(r->msgs[0], "rIDManagerReference", NULL);
         if (!reference_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 
@@ -1127 +1152 @@
         }
 
-        s->rid_manager_fsmo.ntds_dn_str = samdb_result_string(r->msgs[0], "fSMORoleOwner", NULL);
+        s->rid_manager_fsmo.ntds_dn_str = ldb_msg_find_attr_as_string(r->msgs[0], "fSMORoleOwner", NULL);
         if (!s->rid_manager_fsmo.ntds_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
         talloc_steal(s, s->rid_manager_fsmo.ntds_dn_str);
@@ -1151 +1176 @@
         }
 
-        s->rid_manager_fsmo.dns_name    = samdb_result_string(r->msgs[0], "dnsHostName", NULL);
+        s->rid_manager_fsmo.dns_name    = ldb_msg_find_attr_as_string(r->msgs[0], "dnsHostName", NULL);
         if (!s->rid_manager_fsmo.dns_name) return NT_STATUS_INVALID_NETWORK_RESPONSE;
         talloc_steal(s, s->rid_manager_fsmo.dns_name);
@@ -1236 +1261 @@
         }
 
-        s->dest_dsa.computer_dn_str     = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
+        s->dest_dsa.computer_dn_str     = ldb_msg_find_attr_as_string(r->msgs[0], "distinguishedName", NULL);
         if (!s->dest_dsa.computer_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
         talloc_steal(s, s->dest_dsa.computer_dn_str);
 
-        s->dest_dsa.user_account_control = samdb_result_uint(r->msgs[0], "userAccountControl", 0);
+        s->dest_dsa.user_account_control = ldb_msg_find_attr_as_uint(r->msgs[0], "userAccountControl", 0);
 
         talloc_free(r);
@@ -1274 +1299 @@
         }
 
-        server_reference_dn_str = samdb_result_string(r->msgs[0], "serverReference", NULL);
+        server_reference_dn_str = ldb_msg_find_attr_as_string(r->msgs[0], "serverReference", NULL);
         if (server_reference_dn_str) {
                 server_reference_dn     = ldb_dn_new(r, s->ldap1.ldb, server_reference_dn_str);
@@ -1283 +1308 @@
 
                 /*
-                 * if the server object belongs to another DC in another domain in the forest,
-                 * we should not touch this object!
+                 * if the server object belongs to another DC in another domain
+                 * in the forest, we should not touch this object!
                  */
                 if (ldb_dn_compare(computer_dn, server_reference_dn) != 0) {
@@ -1293 +1318 @@
 
         /* if the server object is already for the dest_dsa, then we don't need to create it */
-        s->dest_dsa.server_dn_str       = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
+        s->dest_dsa.server_dn_str       = ldb_msg_find_attr_as_string(r->msgs[0], "distinguishedName", NULL);
         if (!s->dest_dsa.server_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
         talloc_steal(s, s->dest_dsa.server_dn_str);
@@ -1328 +1353 @@
         }
 
-        server_reference_bl_dn_str = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
+        server_reference_bl_dn_str = ldb_msg_find_attr_as_string(r->msgs[0], "serverReferenceBL", NULL);
         if (!server_reference_bl_dn_str) {
                 /* if no back link is present, we're done for this function */
@@ -1336 +1361 @@
 
         /* if the server object is already for the dest_dsa, then we don't need to create it */
-        s->dest_dsa.server_dn_str       = samdb_result_string(r->msgs[0], "serverReferenceBL", NULL);
+        s->dest_dsa.server_dn_str       = ldb_msg_find_attr_as_string(r->msgs[0], "serverReferenceBL", NULL);
         if (s->dest_dsa.server_dn_str) {
                 /* if a back link is present, we know that the server object is present */
@@ -1399 +1424 @@
         int ret;
         struct ldb_message *msg;
-        uint32_t i;
+        unsigned int i;
 
         /* make a 'modify' msg, and only for serverReference */
@@ -1520 +1545 @@
                  *       passed as auth_type here. If NTLMSSP is used, Windows
                  *       2000 returns garbage in the DsGetNCChanges() response
-                 *       if encrypted password attributes would be in the response.
-                 *       That means the replication of the schema and configuration
-                 *       partition works fine, but it fails for the domain partition.
+                 *       if encrypted password attributes would be in the
+                 *       response. That means the replication of the schema and
+                 *       configuration partition works fine, but it fails for
+                 *       the domain partition.
                  */
-                if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
+                if (lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
                                  "force krb5", true))
                 {
                         krb5_str = "krb5,";
                 }
-                if (lp_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
+                if (lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "become_dc",
                                  "print", false))
                 {
@@ -1551 +1577 @@
 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
                                        struct becomeDC_drsuapi *drsuapi,
-                                       void (*recv_fn)(struct rpc_request *req));
-static void becomeDC_drsuapi1_bind_recv(struct rpc_request *req);
+                                       void (*recv_fn)(struct tevent_req *subreq));
+static void becomeDC_drsuapi1_bind_recv(struct tevent_req *subreq);
 
 static void becomeDC_drsuapi1_connect_recv(struct composite_context *req)
@@ -1563 +1589 @@
         if (!composite_is_ok(c)) return;
 
+        s->drsuapi1.drsuapi_handle = s->drsuapi1.pipe->binding_handle;
+
         c->status = gensec_session_key(s->drsuapi1.pipe->conn->security_state.generic_state,
                                        &s->drsuapi1.gensec_skey);
@@ -1572 +1600 @@
 static void becomeDC_drsuapi_bind_send(struct libnet_BecomeDC_state *s,
                                        struct becomeDC_drsuapi *drsuapi,
-                                       void (*recv_fn)(struct rpc_request *req))
+                                       void (*recv_fn)(struct tevent_req *subreq))
 {
         struct composite_context *c = s->creq;
-        struct rpc_request *req;
         struct drsuapi_DsBindInfo28 *bind_info28;
+        struct tevent_req *subreq;
 
         GUID_from_string(DRSUAPI_DS_BIND_GUID_W2K3, &drsuapi->bind_guid);
@@ -1590 +1618 @@
         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
-        if (s->domain.behavior_version == 2) {
+        if (s->domain.behavior_version >= DS_DOMAIN_FUNCTION_2003) {
                 /* TODO: find out how this is really triggered! */
                 bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
@@ -1603 +1631 @@
         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
-        bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_00100000;
+        bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V5;
         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
         bind_info28->supported_extensions       |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
@@ -1627 +1655 @@
         drsuapi->bind_r.out.bind_handle = &drsuapi->bind_handle;
 
-        req = dcerpc_drsuapi_DsBind_send(drsuapi->pipe, s, &drsuapi->bind_r);
-        composite_continue_rpc(c, req, recv_fn, s);
+        subreq = dcerpc_drsuapi_DsBind_r_send(s, c->event_ctx,
+                                              drsuapi->drsuapi_handle,
+                                              &drsuapi->bind_r);
+        if (composite_nomem(subreq, c)) return;
+        tevent_req_set_callback(subreq, recv_fn, s);
 }
 
@@ -1670 +1701 @@
 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s);
 
-static void becomeDC_drsuapi1_bind_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+static void becomeDC_drsuapi1_bind_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
         WERROR status;
 
-        bool print = false;
-
-        if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
-                print = true;
-        }
-
-        c->status = dcerpc_ndr_request_recv(req);
-        if (!composite_is_ok(c)) return;
-
-        if (print) {
-                NDR_PRINT_OUT_DEBUG(drsuapi_DsBind, &s->drsuapi1.bind_r);
-        }
+        c->status = dcerpc_drsuapi_DsBind_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
+        if (!composite_is_ok(c)) return;
 
         status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi1);
@@ -1699 +1721 @@
 }
 
-static void becomeDC_drsuapi1_add_entry_recv(struct rpc_request *req);
+static void becomeDC_drsuapi1_add_entry_recv(struct tevent_req *subreq);
 
 static void becomeDC_drsuapi1_add_entry_send(struct libnet_BecomeDC_state *s)
 {
         struct composite_context *c = s->creq;
-        struct rpc_request *req;
         struct drsuapi_DsAddEntry *r;
         struct drsuapi_DsReplicaObjectIdentifier *identifier;
         uint32_t num_attrs, i = 0;
         struct drsuapi_DsReplicaAttribute *attrs;
-        struct smb_iconv_convenience *iconv_convenience = lp_iconv_convenience(s->libnet->lp_ctx);
         enum ndr_err_code ndr_err;
         bool w2k3;
+        struct tevent_req *subreq;
 
         /* choose a random invocationId */
@@ -1717 +1738 @@
 
         /*
-         * if the schema version indicates w2k3, then
-         * also send some w2k3 specific attributes
+         * if the schema version indicates w2k3, then also send some w2k3
+         * specific attributes.
          */
         if (s->forest.schema_object_version >= 30) {
@@ -1739 +1760 @@
 
         /* allocate attribute array */
-        num_attrs       = 11;
+        num_attrs       = 12;
         attrs           = talloc_array(r, struct drsuapi_DsReplicaAttribute, num_attrs);
         if (composite_nomem(attrs, c)) return;
@@ -1808 +1829 @@
                 if (composite_nomem(v, c)) return;
 
-                ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, v,(ndr_push_flags_fn_t)ndr_push_security_descriptor);
+                ndr_err = ndr_push_struct_blob(&vd[0], vd, v,
+                (ndr_push_flags_fn_t)ndr_push_security_descriptor);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -1816 +1838 @@
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_ntSecurityDescriptor;
+                attrs[i].attid                  = DRSUAPI_ATTID_ntSecurityDescriptor;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -1842 +1864 @@
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_objectClass;
+                attrs[i].attid                  = DRSUAPI_ATTID_objectClass;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -1849 +1871 @@
         }
 
-        /* objectCategory: CN=NTDS-DSA,CN=Schema,... */
+        /* objectCategory: CN=NTDS-DSA,CN=Schema,... or CN=NTDS-DSA-RO,CN=Schema,... */
         {
                 struct drsuapi_DsAttributeValue *vs;
@@ -1863 +1885 @@
                 v[0].guid               = GUID_zero();
                 v[0].sid                = s->zero_sid;
-                v[0].dn                 = talloc_asprintf(vd, "CN=NTDS-DSA,%s",
+
+                if (s->rodc_join) {
+                    v[0].dn             = talloc_asprintf(vd, "CN=NTDS-DSA-RO,%s",
                                                           s->forest.schema_dn_str);
+                } else {
+                    v[0].dn             = talloc_asprintf(vd, "CN=NTDS-DSA,%s",
+                                                          s->forest.schema_dn_str);
+                }
                 if (composite_nomem(v[0].dn, c)) return;
 
-                ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0], 
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0], 
+                        (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -1876 +1904 @@
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_objectCategory;
+                attrs[i].attid                  = DRSUAPI_ATTID_objectCategory;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -1897 +1925 @@
                 v = &s->dest_dsa.invocation_id;
 
-                ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, v, (ndr_push_flags_fn_t)ndr_push_GUID);
-                if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                        c->status = ndr_map_error2ntstatus(ndr_err);
-                        if (!composite_is_ok(c)) return;
-                }
+                c->status = GUID_to_ndr_blob(v, vd, &vd[0]);
+                if (!composite_is_ok(c)) return;
 
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_invocationId;
+                attrs[i].attid                  = DRSUAPI_ATTID_invocationId;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -1936 +1961 @@
                 v[2].dn                 = s->forest.schema_dn_str;
 
-                ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+                        (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -1943 +1968 @@
                 }
 
-                ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[1], vd, &v[1],
+                (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -1950 +1975 @@
                 }
 
-                ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[2], vd, &v[2],
+                   (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -1961 +1986 @@
                 vs[2].blob              = &vd[2];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_hasMasterNCs;
+                attrs[i].attid                  = DRSUAPI_ATTID_hasMasterNCs;
                 attrs[i].value_ctr.num_values   = 3;
                 attrs[i].value_ctr.values       = vs;
@@ -1992 +2017 @@
                 v[2].dn                 = s->forest.schema_dn_str;
 
-                ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+                        (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -1999 +2024 @@
                 }
 
-                ndr_err = ndr_push_struct_blob(&vd[1], vd, iconv_convenience, &v[1],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[1], vd, &v[1],
+                        (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -2006 +2031 @@
                 }
 
-                ndr_err = ndr_push_struct_blob(&vd[2], vd, iconv_convenience, &v[2],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[2], vd, &v[2],
+                        (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -2017 +2042 @@
                 vs[2].blob              = &vd[2];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_msDS_hasMasterNCs;
+                attrs[i].attid                  = DRSUAPI_ATTID_msDS_hasMasterNCs;
                 attrs[i].value_ctr.num_values   = 3;
                 attrs[i].value_ctr.values       = vs;
@@ -2040 +2065 @@
                 v[0].dn                 = s->forest.schema_dn_str;
 
-                ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+                        (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -2049 +2074 @@
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_dMDLocation;
+                attrs[i].attid                  = DRSUAPI_ATTID_dMDLocation;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -2072 +2097 @@
                 v[0].dn                 = s->domain.dn_str;
 
-                ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+                        (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -2081 +2106 @@
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_msDS_HasDomainNCs;
+                attrs[i].attid                  = DRSUAPI_ATTID_msDS_HasDomainNCs;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -2102 +2127 @@
                 if (composite_nomem(vd[0].data, c)) return;
 
-                SIVAL(vd[0].data, 0, 
-                      lp_parm_int(s->libnet->lp_ctx, NULL, "ads", "functional level", DS_DC_FUNCTION_2008));
+                SIVAL(vd[0].data, 0, get_dc_function_level(s->libnet->lp_ctx));
 
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_msDS_Behavior_Version;
+                attrs[i].attid                  = DRSUAPI_ATTID_msDS_Behavior_Version;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -2128 +2152 @@
                 if (composite_nomem(vd[0].data, c)) return;
 
-                SIVAL(vd[0].data, 0, SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
+                if (s->rodc_join) {
+                    SIVAL(vd[0].data, 0, SYSTEM_FLAG_CONFIG_ALLOW_RENAME);
+                } else {
+                    SIVAL(vd[0].data, 0, SYSTEM_FLAG_DISALLOW_MOVE_ON_DELETE);
+                }
 
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_systemFlags;
+                attrs[i].attid                  = DRSUAPI_ATTID_systemFlags;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -2155 +2183 @@
                 v[0].dn                 = s->dest_dsa.computer_dn_str;
 
-                ndr_err = ndr_push_struct_blob(&vd[0], vd, iconv_convenience, &v[0],
-                                               (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
+                ndr_err = ndr_push_struct_blob(&vd[0], vd, &v[0],
+                        (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
                 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                         c->status = ndr_map_error2ntstatus(ndr_err);
@@ -2164 +2192 @@
                 vs[0].blob              = &vd[0];
 
-                attrs[i].attid                  = DRSUAPI_ATTRIBUTE_serverReference;
+                attrs[i].attid                  = DRSUAPI_ATTID_serverReference;
+                attrs[i].value_ctr.num_values   = 1;
+                attrs[i].value_ctr.values       = vs;
+
+                i++;
+        }
+
+        /* options:... */
+        if (s->rodc_join) {
+                struct drsuapi_DsAttributeValue *vs;
+                DATA_BLOB *vd;
+
+                vs = talloc_array(attrs, struct drsuapi_DsAttributeValue, 1);
+                if (composite_nomem(vs, c)) return;
+
+                vd = talloc_array(vs, DATA_BLOB, 1);
+                if (composite_nomem(vd, c)) return;
+
+                vd[0] = data_blob_talloc(vd, NULL, 4);
+                if (composite_nomem(vd[0].data, c)) return;
+
+                SIVAL(vd[0].data, 0, DS_NTDSDSA_OPT_DISABLE_OUTBOUND_REPL);
+
+                vs[0].blob              = &vd[0];
+
+                attrs[i].attid                  = DRSUAPI_ATTID_options;
                 attrs[i].value_ctr.num_values   = 1;
                 attrs[i].value_ctr.values       = vs;
@@ -2184 +2237 @@
         r->in.req->req2.first_object.object.attribute_ctr.attributes    = attrs;
 
-        r->out.level_out        = talloc(s, int32_t);
+        r->out.level_out        = talloc(s, uint32_t);
         r->out.ctr              = talloc(s, union drsuapi_DsAddEntryCtr);
 
-        req = dcerpc_drsuapi_DsAddEntry_send(s->drsuapi1.pipe, r, r);
-        composite_continue_rpc(c, req, becomeDC_drsuapi1_add_entry_recv, s);
+        s->ndr_struct_ptr = r;
+        subreq = dcerpc_drsuapi_DsAddEntry_r_send(s, c->event_ctx,
+                                                  s->drsuapi1.drsuapi_handle, r);
+        if (composite_nomem(subreq, c)) return;
+        tevent_req_set_callback(subreq, becomeDC_drsuapi1_add_entry_recv, s);
 }
 
@@ -2194 +2250 @@
 static NTSTATUS becomeDC_prepare_db(struct libnet_BecomeDC_state *s);
 
-static void becomeDC_drsuapi1_add_entry_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+static void becomeDC_drsuapi1_add_entry_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
-        struct drsuapi_DsAddEntry *r = talloc_get_type(req->ndr.struct_ptr,
+        struct drsuapi_DsAddEntry *r = talloc_get_type_abort(s->ndr_struct_ptr,
                                        struct drsuapi_DsAddEntry);
         char *binding_str;
-        bool print = false;
-
-        if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
-                print = true;
-        }
-
-        c->status = dcerpc_ndr_request_recv(req);
-        if (!composite_is_ok(c)) return;
-
-        if (print) {
-                NDR_PRINT_OUT_DEBUG(drsuapi_DsAddEntry, r);
-        }
+
+        s->ndr_struct_ptr = NULL;
+
+        c->status = dcerpc_drsuapi_DsAddEntry_r_recv(subreq, r);
+        TALLOC_FREE(subreq);
+        if (!composite_is_ok(c)) return;
 
         if (!W_ERROR_IS_OK(r->out.result)) {
@@ -2221 +2271 @@
 
         if (*r->out.level_out == 3) {
-                if (r->out.ctr->ctr3.count != 1) {
-                        WERROR status;
-
-                        if (r->out.ctr->ctr3.level != 1) {
+                WERROR status;
+                union drsuapi_DsAddEntry_ErrData *err_data = r->out.ctr->ctr3.err_data;
+
+                /* check for errors */
+                status = err_data ? err_data->v1.status : WERR_OK;
+                if (!W_ERROR_IS_OK(status)) {
+                        struct drsuapi_DsAddEntryErrorInfo_Attr_V1 *attr_err;
+                        struct drsuapi_DsAddEntry_AttrErrListItem_V1 *attr_err_li;
+                        struct drsuapi_DsAddEntryErrorInfo_Name_V1 *name_err;
+                        struct drsuapi_DsAddEntryErrorInfo_Referr_V1 *ref_err;
+                        struct drsuapi_DsAddEntry_RefErrListItem_V1 *ref_li;
+
+                        if (r->out.ctr->ctr3.err_ver != 1) {
                                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
                                 return;
                         }
 
-                        if (!r->out.ctr->ctr3.error) {
-                                composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
-                                return;
-                        }
-
-                        status = r->out.ctr->ctr3.error->info1.status;
-
-                        if (!r->out.ctr->ctr3.error->info1.info) {
+                        DEBUG(0,("DsAddEntry (R3) of '%s' failed: "
+                                 "Errors: dir_err = %d, status = %s;\n",
+                                 r->in.req->req3.first_object.object.identifier->dn,
+                                 err_data->v1.dir_err,
+                                 win_errstr(err_data->v1.status)));
+
+                        if (!err_data->v1.info) {
+                                DEBUG(0, ("DsAddEntry (R3): no error info returned!\n"));
                                 composite_error(c, werror_to_ntstatus(status));
                                 return;
                         }
 
-                        /* see if we can get a more detailed error */
-                        switch (r->out.ctr->ctr3.error->info1.level) {
-                        case 1:
-                                status = r->out.ctr->ctr3.error->info1.info->error1.status;
+                        /* dump more detailed error */
+                        switch (err_data->v1.dir_err) {
+                        case DRSUAPI_DIRERR_ATTRIBUTE:
+                                /* Dump attribute errors */
+                                attr_err = &err_data->v1.info->attr_err;
+                                DEBUGADD(0,(" Attribute Error: object = %s, count = %d;\n",
+                                            attr_err->id->dn,
+                                            attr_err->count));
+                                attr_err_li = &attr_err->first;
+                                for (; attr_err_li; attr_err_li = attr_err_li->next) {
+                                        struct drsuapi_DsAddEntry_AttrErr_V1 *err = &attr_err_li->err_data;
+                                        DEBUGADD(0,(" Error: err = %s, problem = 0x%08X, attid = 0x%08X;\n",
+                                                    win_errstr(err->extended_err),
+                                                    err->problem,
+                                                    err->attid));
+                                        /* TODO: should we print attribute value here? */
+                                }
                                 break;
-                        case 4:
-                        case 5:
-                        case 6:
-                        case 7:
-                                status = r->out.ctr->ctr3.error->info1.info->errorX.status;
+                        case DRSUAPI_DIRERR_NAME:
+                                /* Dump Name resolution error */
+                                name_err = &err_data->v1.info->name_err;
+                                DEBUGADD(0,(" Name Error: err = %s, problem = 0x%08X, id_matched = %s;\n",
+                                            win_errstr(name_err->extended_err),
+                                            name_err->problem,
+                                            name_err->id_matched->dn));
+                                break;
+                        case DRSUAPI_DIRERR_REFERRAL:
+                                /* Dump Referral errors */
+                                ref_err = &err_data->v1.info->referral_err;
+                                DEBUGADD(0,(" Referral Error: extended_err = %s\n",
+                                            win_errstr(ref_err->extended_err)));
+                                ref_li = &ref_err->refer;
+                                for (; ref_li; ref_li = ref_li->next) {
+                                        struct drsuapi_DsaAddressListItem_V1 *addr;
+                                        DEBUGADD(0,(" Referral: id_target = %s, ref_type = 0x%04X,",
+                                                    ref_li->id_target->dn,
+                                                    ref_li->ref_type));
+                                        if (ref_li->is_choice_set) {
+                                                DEBUGADD(0,(" choice = 0x%02X, ",
+                                                            ref_li->choice));
+                                        }
+                                        DEBUGADD(0,(" add_list ("));
+                                        for (addr = ref_li->addr_list; addr; addr = addr->next) {
+                                                DEBUGADD(0,("%s", addr->address->string));
+                                                if (addr->next) {
+                                                        DEBUGADD(0,(", "));
+                                                }
+                                        }
+                                        DEBUGADD(0,(");\n"));
+                                }
+                                break;
+                        case DRSUAPI_DIRERR_SECURITY:
+                                /* Dump Security error. */
+                                DEBUGADD(0,(" Security Error: extended_err = %s, problem = 0x%08X\n",
+                                            win_errstr(err_data->v1.info->security_err.extended_err),
+                                            err_data->v1.info->security_err.problem));
+                                break;
+                        case DRSUAPI_DIRERR_SERVICE:
+                                /* Dump Service error. */
+                                DEBUGADD(0,(" Service Error: extended_err = %s, problem = 0x%08X\n",
+                                            win_errstr(err_data->v1.info->service_err.extended_err),
+                                            err_data->v1.info->service_err.problem));
+                                break;
+                        case DRSUAPI_DIRERR_UPDATE:
+                                /* Dump Update error. */
+                                DEBUGADD(0,(" Update Error: extended_err = %s, problem = 0x%08X\n",
+                                            win_errstr(err_data->v1.info->update_err.extended_err),
+                                            err_data->v1.info->update_err.problem));
+                                break;
+                        case DRSUAPI_DIRERR_SYSTEM:
+                                /* System error. */
+                                DEBUGADD(0,(" System Error: extended_err = %s, problem = 0x%08X\n",
+                                            win_errstr(err_data->v1.info->system_err.extended_err),
+                                            err_data->v1.info->system_err.problem));
+                                break;
+                        case DRSUAPI_DIRERR_OK: /* mute compiler warnings */
+                        default:
+                                DEBUGADD(0,(" Unknown DIRERR error class returned!\n"));
                                 break;
                         }
@@ -2258 +2385 @@
                 }
 
+                if (1 != r->out.ctr->ctr3.count) {
+                        DEBUG(0,("DsAddEntry - Ctr3: something very wrong had happened - "
+                                 "method succeeded but objects returned are %d (expected 1).\n",
+                                 r->out.ctr->ctr3.count));
+                        composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
+                }
+
                 s->dest_dsa.ntds_guid   = r->out.ctr->ctr3.objects[0].guid;
+
         } else if (*r->out.level_out == 2) {
-                if (r->out.ctr->ctr2.count != 1) {
-                        composite_error(c, werror_to_ntstatus(r->out.ctr->ctr2.error.status));
+                if (DRSUAPI_DIRERR_OK != r->out.ctr->ctr2.dir_err) {
+                        DEBUG(0,("DsAddEntry failed with: dir_err = %d, extended_err = %s\n",
+                                 r->out.ctr->ctr2.dir_err,
+                                 win_errstr(r->out.ctr->ctr2.extended_err)));
+                        composite_error(c, werror_to_ntstatus(r->out.ctr->ctr2.extended_err));
                         return;
+                }
+
+                if (1 != r->out.ctr->ctr2.count) {
+                        DEBUG(0,("DsAddEntry: something very wrong had happened - "
+                                 "method succeeded but objects returned are %d (expected 1). "
+                                 "Errors: dir_err = %d, extended_err = %s\n",
+                                 r->out.ctr->ctr2.count,
+                                 r->out.ctr->ctr2.dir_err,
+                                 win_errstr(r->out.ctr->ctr2.extended_err)));
+                        composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
                 }
 
@@ -2306 +2454 @@
 }
 
-static void becomeDC_drsuapi2_bind_recv(struct rpc_request *req);
+static void becomeDC_drsuapi2_bind_recv(struct tevent_req *subreq);
 
 static void becomeDC_drsuapi2_connect_recv(struct composite_context *req)
@@ -2317 +2465 @@
         if (!composite_is_ok(c)) return;
 
+        s->drsuapi2.drsuapi_handle = s->drsuapi2.pipe->binding_handle;
+
         c->status = gensec_session_key(s->drsuapi2.pipe->conn->security_state.generic_state,
                                        &s->drsuapi2.gensec_skey);
@@ -2326 +2476 @@
 static void becomeDC_drsuapi3_connect_recv(struct composite_context *req);
 
-static void becomeDC_drsuapi2_bind_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+static void becomeDC_drsuapi2_bind_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
@@ -2334 +2484 @@
         WERROR status;
 
-        bool print = false;
-
-        if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
-                print = true;
-        }
-
-        c->status = dcerpc_ndr_request_recv(req);
-        if (!composite_is_ok(c)) return;
-
-        if (print) {
-                NDR_PRINT_OUT_DEBUG(drsuapi_DsBind, &s->drsuapi2.bind_r);
-        }
+        c->status = dcerpc_drsuapi_DsBind_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
+        if (!composite_is_ok(c)) return;
 
         status = becomeDC_drsuapi_bind_recv(s, &s->drsuapi2);
@@ -2380 +2521 @@
         if (!composite_is_ok(c)) return;
 
+        s->drsuapi3.drsuapi_handle = s->drsuapi3.pipe->binding_handle;
+
         c->status = gensec_session_key(s->drsuapi3.pipe->conn->security_state.generic_state,
                                        &s->drsuapi3.gensec_skey);
@@ -2391 +2534 @@
                                                  struct becomeDC_drsuapi *drsuapi_p,
                                                  struct libnet_BecomeDC_Partition *partition,
-                                                 void (*recv_fn)(struct rpc_request *req))
+                                                 void (*recv_fn)(struct tevent_req *subreq))
 {
         struct composite_context *c = s->creq;
-        struct rpc_request *req;
         struct drsuapi_DsGetNCChanges *r;
+        struct tevent_req *subreq;
 
         r = talloc(s, struct drsuapi_DsGetNCChanges);
         if (composite_nomem(r, c)) return;
 
-        r->out.level_out = talloc(r, int32_t);
+        r->out.level_out = talloc(r, uint32_t);
         if (composite_nomem(r->out.level_out, c)) return;
         r->in.req = talloc(r, union drsuapi_DsGetNCChangesRequest);
@@ -2444 +2587 @@
          * connections.
          */
-        req = dcerpc_drsuapi_DsGetNCChanges_send(drsuapi_p->pipe, r, r);
-        composite_continue_rpc(c, req, recv_fn, s);
+        s->ndr_struct_ptr = r;
+        subreq = dcerpc_drsuapi_DsGetNCChanges_r_send(s, c->event_ctx,
+                                                      drsuapi_p->drsuapi_handle,
+                                                      r);
+        if (composite_nomem(subreq, c)) return;
+        tevent_req_set_callback(subreq, recv_fn, s);
 }
 
@@ -2547 +2694 @@
 }
 
-static void becomeDC_drsuapi3_pull_schema_recv(struct rpc_request *req);
+static void becomeDC_drsuapi3_pull_schema_recv(struct tevent_req *subreq);
 
 static void becomeDC_drsuapi3_pull_schema_send(struct libnet_BecomeDC_state *s)
@@ -2557 +2704 @@
         s->schema_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
 
-        s->schema_part.replica_flags    = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
+        s->schema_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
+                                        | DRSUAPI_DRS_INIT_SYNC
+                                        | DRSUAPI_DRS_PER_SYNC
+                                        | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
+                                        | DRSUAPI_DRS_NEVER_SYNCED
+                                        | DRSUAPI_DRS_USE_COMPRESSION;
+        if (s->rodc_join) {
+            s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
+        }
 
         s->schema_part.store_chunk      = s->callbacks.schema_chunk;
@@ -2572 +2722 @@
 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s);
 
-static void becomeDC_drsuapi3_pull_schema_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+static void becomeDC_drsuapi3_pull_schema_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
-        struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
+        struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
                                            struct drsuapi_DsGetNCChanges);
         WERROR status;
 
-        bool print = false;
-
-        if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
-                print = true;
-        }
-
-        c->status = dcerpc_ndr_request_recv(req);
-        if (!composite_is_ok(c)) return;
-
-        if (print) {
-                NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
-        }
+        s->ndr_struct_ptr = NULL;
+
+        c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
+        TALLOC_FREE(subreq);
+        if (!composite_is_ok(c)) return;
 
         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->schema_part, r);
@@ -2611 +2754 @@
 }
 
-static void becomeDC_drsuapi3_pull_config_recv(struct rpc_request *req);
+static void becomeDC_drsuapi3_pull_config_recv(struct tevent_req *subreq);
 
 static void becomeDC_drsuapi3_pull_config_send(struct libnet_BecomeDC_state *s)
@@ -2621 +2764 @@
         s->config_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
 
-        s->config_part.replica_flags    = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
+        s->config_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
+                                        | DRSUAPI_DRS_INIT_SYNC
+                                        | DRSUAPI_DRS_PER_SYNC
+                                        | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
+                                        | DRSUAPI_DRS_NEVER_SYNCED
+                                        | DRSUAPI_DRS_USE_COMPRESSION;
+        if (s->rodc_join) {
+            s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
+        }
 
         s->config_part.store_chunk      = s->callbacks.config_chunk;
@@ -2634 +2780 @@
 }
 
-static void becomeDC_drsuapi3_pull_config_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+static void becomeDC_drsuapi3_pull_config_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
-        struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
+        struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
                                            struct drsuapi_DsGetNCChanges);
         WERROR status;
 
-        bool print = false;
-
-        if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
-                print = true;
-        }
-
-        c->status = dcerpc_ndr_request_recv(req);
-        if (!composite_is_ok(c)) return;
-
-        if (print) {
-                NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
-        }
+        s->ndr_struct_ptr = NULL;
+
+        c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
+        TALLOC_FREE(subreq);
+        if (!composite_is_ok(c)) return;
 
         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->config_part, r);
@@ -2673 +2812 @@
 }
 
-static void becomeDC_drsuapi3_pull_domain_recv(struct rpc_request *req);
+static void becomeDC_drsuapi3_pull_domain_recv(struct tevent_req *subreq);
 
 static void becomeDC_drsuapi3_pull_domain_send(struct libnet_BecomeDC_state *s)
@@ -2683 +2822 @@
         s->domain_part.destination_dsa_guid     = s->drsuapi2.bind_guid;
 
-        s->domain_part.replica_flags    = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_FULL_IN_PROGRESS
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_NEVER_SYNCED
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_COMPRESS_CHANGES;
+        s->domain_part.replica_flags    = DRSUAPI_DRS_WRIT_REP
+                                        | DRSUAPI_DRS_INIT_SYNC
+                                        | DRSUAPI_DRS_PER_SYNC
+                                        | DRSUAPI_DRS_FULL_SYNC_IN_PROGRESS
+                                        | DRSUAPI_DRS_NEVER_SYNCED
+                                        | DRSUAPI_DRS_USE_COMPRESSION;
+        if (s->rodc_join) {
+            s->schema_part.replica_flags &= ~DRSUAPI_DRS_WRIT_REP;
+        }
 
         s->domain_part.store_chunk      = s->callbacks.domain_chunk;
@@ -2699 +2841 @@
                                               struct becomeDC_drsuapi *drsuapi,
                                               struct libnet_BecomeDC_Partition *partition,
-                                              void (*recv_fn)(struct rpc_request *req));
-static void becomeDC_drsuapi2_update_refs_schema_recv(struct rpc_request *req);
-
-static void becomeDC_drsuapi3_pull_domain_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+                                              void (*recv_fn)(struct tevent_req *subreq));
+static void becomeDC_drsuapi2_update_refs_schema_recv(struct tevent_req *subreq);
+
+static void becomeDC_drsuapi3_pull_domain_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
-        struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
+        struct drsuapi_DsGetNCChanges *r = talloc_get_type_abort(s->ndr_struct_ptr,
                                            struct drsuapi_DsGetNCChanges);
         WERROR status;
-        bool print = false;
-
-        if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
-                print = true;
-        }
-
-        c->status = dcerpc_ndr_request_recv(req);
-        if (!composite_is_ok(c)) return;
-
-        if (print) {
-                NDR_PRINT_OUT_DEBUG(drsuapi_DsGetNCChanges, r);
-        }
+
+        s->ndr_struct_ptr = NULL;
+
+        c->status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, r);
+        TALLOC_FREE(subreq);
+        if (!composite_is_ok(c)) return;
 
         status = becomeDC_drsuapi_pull_partition_recv(s, &s->drsuapi2, &s->drsuapi3, &s->domain_part, r);
@@ -2744 +2880 @@
                                               struct becomeDC_drsuapi *drsuapi,
                                               struct libnet_BecomeDC_Partition *partition,
-                                              void (*recv_fn)(struct rpc_request *req))
+                                              void (*recv_fn)(struct tevent_req *subreq))
 {
         struct composite_context *c = s->creq;
-        struct rpc_request *req;
         struct drsuapi_DsReplicaUpdateRefs *r;
         const char *ntds_guid_str;
         const char *ntds_dns_name;
+        struct tevent_req *subreq;
 
         r = talloc(s, struct drsuapi_DsReplicaUpdateRefs);
@@ -2768 +2904 @@
         r->in.req.req1.dest_dsa_dns_name= ntds_dns_name;
         r->in.req.req1.dest_dsa_guid    = s->dest_dsa.ntds_guid;
-        r->in.req.req1.options          = DRSUAPI_DS_REPLICA_UPDATE_ADD_REFERENCE
-                                        | DRSUAPI_DS_REPLICA_UPDATE_DELETE_REFERENCE;
+        r->in.req.req1.options          = DRSUAPI_DRS_ADD_REF | DRSUAPI_DRS_DEL_REF;
 
         /* I think this is how we mark ourselves as a RODC */
-        if (!lp_parm_bool(s->libnet->lp_ctx, NULL, "repl", "RODC", false)) {
-                r->in.req.req1.options |= DRSUAPI_DS_REPLICA_UPDATE_WRITEABLE;
-        }
-
-        req = dcerpc_drsuapi_DsReplicaUpdateRefs_send(drsuapi->pipe, r, r);
-        composite_continue_rpc(c, req, recv_fn, s);
-}
-
-static void becomeDC_drsuapi2_update_refs_config_recv(struct rpc_request *req);
-
-static void becomeDC_drsuapi2_update_refs_schema_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+        if (!lpcfg_parm_bool(s->libnet->lp_ctx, NULL, "repl", "RODC", false)) {
+                r->in.req.req1.options |= DRSUAPI_DRS_WRIT_REP;
+        }
+
+        s->ndr_struct_ptr = r;
+        subreq = dcerpc_drsuapi_DsReplicaUpdateRefs_r_send(s, c->event_ctx,
+                                                           drsuapi->drsuapi_handle,
+                                                           r);
+        if (composite_nomem(subreq, c)) return;
+        tevent_req_set_callback(subreq, recv_fn, s);
+}
+
+static void becomeDC_drsuapi2_update_refs_config_recv(struct tevent_req *subreq);
+
+static void becomeDC_drsuapi2_update_refs_schema_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
-        struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
+        struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type_abort(s->ndr_struct_ptr,
                                            struct drsuapi_DsReplicaUpdateRefs);
-        bool print = false;
-
-        if (req->p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
-                print = true;
-        }
-
-        c->status = dcerpc_ndr_request_recv(req);
-        if (!composite_is_ok(c)) return;
-
-        if (print) {
-                NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaUpdateRefs, r);
-        }
+
+        s->ndr_struct_ptr = NULL;
+
+        c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
+        TALLOC_FREE(subreq);
+        if (!composite_is_ok(c)) return;
 
         if (!W_ERROR_IS_OK(r->out.result)) {
@@ -2813 +2946 @@
 }
 
-static void becomeDC_drsuapi2_update_refs_domain_recv(struct rpc_request *req);
-
-static void becomeDC_drsuapi2_update_refs_config_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+static void becomeDC_drsuapi2_update_refs_domain_recv(struct tevent_req *subreq);
+
+static void becomeDC_drsuapi2_update_refs_config_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
-        struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
+        struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(s->ndr_struct_ptr,
                                            struct drsuapi_DsReplicaUpdateRefs);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        s->ndr_struct_ptr = NULL;
+
+        c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -2837 +2973 @@
 }
 
-static void becomeDC_drsuapi2_update_refs_domain_recv(struct rpc_request *req)
-{
-        struct libnet_BecomeDC_state *s = talloc_get_type(req->async.private_data,
+static void becomeDC_drsuapi2_update_refs_domain_recv(struct tevent_req *subreq)
+{
+        struct libnet_BecomeDC_state *s = tevent_req_callback_data(subreq,
                                           struct libnet_BecomeDC_state);
         struct composite_context *c = s->creq;
-        struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(req->ndr.struct_ptr,
+        struct drsuapi_DsReplicaUpdateRefs *r = talloc_get_type(s->ndr_struct_ptr,
                                            struct drsuapi_DsReplicaUpdateRefs);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        s->ndr_struct_ptr = NULL;
+
+        c->status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, r);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -2863 +3002 @@
         int ret;
         struct ldb_message *msg;
-        uint32_t i;
+        unsigned int i;
         uint32_t user_account_control = UF_SERVER_TRUST_ACCOUNT |
                                         UF_TRUSTED_FOR_DELEGATION;
@@ -2878 +3017 @@
         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
 
-        ret = ldb_msg_add_fmt(msg, "userAccountControl", "%u", user_account_control);
-        if (ret != 0) {
+        ret = samdb_msg_add_uint(s->ldap2.ldb, msg, msg, "userAccountControl",
+                                 user_account_control);
+        if (ret != LDB_SUCCESS) {
                 talloc_free(msg);
                 return NT_STATUS_NO_MEMORY;
@@ -2904 +3044 @@
 {
         int ret;
-        struct ldb_result *r;
-        struct ldb_dn *basedn;
         struct ldb_dn *old_dn;
         struct ldb_dn *new_dn;
-        static const char *_1_1_attrs[] = {
-                "1.1",
-                NULL
-        };
-
-        basedn = ldb_dn_new_fmt(s, s->ldap2.ldb, "<WKGUID=a361b2ffffd211d1aa4b00c04fd7d83a,%s>",
-                                s->domain.dn_str);
-        NT_STATUS_HAVE_NO_MEMORY(basedn);
-
-        ret = ldb_search(s->ldap2.ldb, s, &r, basedn, LDB_SCOPE_BASE,
-                         _1_1_attrs, "(objectClass=*)");
-        talloc_free(basedn);
+
+        ret = dsdb_wellknown_dn(s->ldap2.ldb, s,
+                                ldb_get_default_basedn(s->ldap2.ldb),
+                                DS_GUID_DOMAIN_CONTROLLERS_CONTAINER,
+                                &new_dn);
         if (ret != LDB_SUCCESS) {
                 return NT_STATUS_LDAP(ret);
-        } else if (r->count != 1) {
-                talloc_free(r);
-                return NT_STATUS_INVALID_NETWORK_RESPONSE;
-        }
-
-        old_dn = ldb_dn_new(r, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
+        }
+
+        if (!ldb_dn_add_child_fmt(new_dn, "CN=%s", s->dest_dsa.netbios_name)) {
+                talloc_free(new_dn);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        old_dn = ldb_dn_new(new_dn, s->ldap2.ldb, s->dest_dsa.computer_dn_str);
         NT_STATUS_HAVE_NO_MEMORY(old_dn);
-
-        new_dn = r->msgs[0]->dn;
-
-        if (!ldb_dn_add_child_fmt(new_dn, "CN=%s", s->dest_dsa.netbios_name)) {
-                talloc_free(r);
-                return NT_STATUS_NO_MEMORY;
-        }
 
         if (ldb_dn_compare(old_dn, new_dn) == 0) {
                 /* we don't need to rename if the old and new dn match */
-                talloc_free(r);
+                talloc_free(new_dn);
                 return NT_STATUS_OK;
         }
@@ -2945 +3071 @@
         ret = ldb_rename(s->ldap2.ldb, old_dn, new_dn);
         if (ret != LDB_SUCCESS) {
-                talloc_free(r);
+                talloc_free(new_dn);
                 return NT_STATUS_LDAP(ret);
         }
@@ -2952 +3078 @@
         NT_STATUS_HAVE_NO_MEMORY(s->dest_dsa.computer_dn_str);
 
-        talloc_free(r);
+        talloc_free(new_dn);
 
         return NT_STATUS_OK;
@@ -3014 +3140 @@
         s->callbacks = r->in.callbacks;
 
+        /* RODC join*/
+        s->rodc_join = r->in.rodc_join;
+
         becomeDC_send_cldap(s);
         return c;

vendor/current/source4/libnet/libnet_become_dc.h

@@ -137 +137 @@
 
                 struct libnet_BecomeDC_Callbacks callbacks;
-        } in;
+
+                bool rodc_join;
+        } in;
 
         struct {

vendor/current/source4/libnet/libnet_domain.c

@@ -48 +48 @@
 
 
-static void continue_domain_open_close(struct rpc_request *req);
-static void continue_domain_open_connect(struct rpc_request *req);
-static void continue_domain_open_lookup(struct rpc_request *req);
-static void continue_domain_open_open(struct rpc_request *req);
+static void continue_domain_open_close(struct tevent_req *subreq);
+static void continue_domain_open_connect(struct tevent_req *subreq);
+static void continue_domain_open_lookup(struct tevent_req *subreq);
+static void continue_domain_open_open(struct tevent_req *subreq);
 
 
@@ -61 +61 @@
         struct composite_context *c;
         struct domain_open_samr_state *s;
-        struct rpc_request *conn_req;
+        struct tevent_req *subreq;
 
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -77 +77 @@
 
         /* send request */
-        conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
-        if (composite_nomem(conn_req, c)) return;
+        subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
+                                            s->pipe->binding_handle,
+                                            &s->connect);
+        if (composite_nomem(subreq, c)) return;
 
         /* callback handler */
-        composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
+        tevent_req_set_callback(subreq, continue_domain_open_connect, c);
 }
 
@@ -89 +91 @@
  * handle
  */
-static void continue_domain_open_close(struct rpc_request *req)
+static void continue_domain_open_close(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_open_samr_state *s;
-        struct rpc_request *conn_req;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
 
         /* receive samr_Close reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_Close_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -122 +124 @@
         
         /* send request */
-        conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
-        if (composite_nomem(conn_req, c)) return;
+        subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
+                                            s->pipe->binding_handle,
+                                            &s->connect);
+        if (composite_nomem(subreq, c)) return;
 
         /* callback handler */
-        composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
+        tevent_req_set_callback(subreq, continue_domain_open_connect, c);
 }
 
@@ -133 +137 @@
  * Stage 1: Connect to SAM server.
  */
-static void continue_domain_open_connect(struct rpc_request *req)
+static void continue_domain_open_connect(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_open_samr_state *s;
-        struct rpc_request *lookup_req;
         struct samr_LookupDomain *r;
         
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
 
         /* receive samr_Connect reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_Connect_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -164 +168 @@
         if (composite_nomem(r->out.sid, c)) return;
 
-        lookup_req = dcerpc_samr_LookupDomain_send(s->pipe, c, r);
-        if (composite_nomem(lookup_req, c)) return;
-
-        composite_continue_rpc(c, lookup_req, continue_domain_open_lookup, c);
+        subreq = dcerpc_samr_LookupDomain_r_send(s, c->event_ctx,
+                                                 s->pipe->binding_handle,
+                                                 r);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_domain_open_lookup, c);
 }
 
@@ -174 +180 @@
  * Stage 2: Lookup domain by name.
  */
-static void continue_domain_open_lookup(struct rpc_request *req)
+static void continue_domain_open_lookup(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_open_samr_state *s;
-        struct rpc_request *opendom_req;
         struct samr_OpenDomain *r;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
         
         /* receive samr_LookupDomain reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_LookupDomain_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
 
         if (s->monitor_fn) {
@@ -216 +222 @@
         r->out.domain_handle = &s->domain_handle;
 
-        opendom_req = dcerpc_samr_OpenDomain_send(s->pipe, c, r);
-        if (composite_nomem(opendom_req, c)) return;
-
-        composite_continue_rpc(c, opendom_req, continue_domain_open_open, c);
+        subreq = dcerpc_samr_OpenDomain_r_send(s, c->event_ctx,
+                                               s->pipe->binding_handle,
+                                               r);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_domain_open_open, c);
 }
 
@@ -226 +234 @@
  * Stage 3: Open domain.
  */
-static void continue_domain_open_open(struct rpc_request *req)
+static void continue_domain_open_open(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_open_samr_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_open_samr_state);
 
         /* receive samr_OpenDomain reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_OpenDomain_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -266 +275 @@
         struct domain_open_samr_state *s;
         struct composite_context *rpcconn_req;
-        struct rpc_request *close_req, *conn_req;
+        struct tevent_req *subreq;
 
         c = composite_create(ctx, ctx->event_ctx);
@@ -314 +323 @@
 
                         /* send request to close domain handle */
-                        close_req = dcerpc_samr_Close_send(s->pipe, c, &s->close);
-                        if (composite_nomem(close_req, c)) return c;
+                        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
+                                                          s->pipe->binding_handle,
+                                                          &s->close);
+                        if (composite_nomem(subreq, c)) return c;
 
                         /* callback handler */
-                        composite_continue_rpc(c, close_req, continue_domain_open_close, c);
+                        tevent_req_set_callback(subreq, continue_domain_open_close, c);
                         return c;
                 }
@@ -329 +340 @@
         
         /* send request */
-        conn_req = dcerpc_samr_Connect_send(s->pipe, c, &s->connect);
-        if (composite_nomem(conn_req, c)) return c;
+        subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
+                                            s->pipe->binding_handle,
+                                            &s->connect);
+        if (composite_nomem(subreq, c)) return c;
 
         /* callback handler */
-        composite_continue_rpc(c, conn_req, continue_domain_open_connect, c);
+        tevent_req_set_callback(subreq, continue_domain_open_connect, c);
         return c;
 }
@@ -390 +403 @@
 
 static void continue_rpc_connect_lsa(struct composite_context *ctx);
-static void continue_lsa_policy_open(struct rpc_request *req);
+static void continue_lsa_policy_open(struct tevent_req *subreq);
 
 
@@ -408 +421 @@
         struct domain_open_lsa_state *s;
         struct composite_context *rpcconn_req;
-        struct rpc_request *openpol_req;
+        struct tevent_req *subreq;
         struct lsa_QosInfo *qos;
 
@@ -460 +473 @@
         
         /* send rpc request */
-        openpol_req = dcerpc_lsa_OpenPolicy2_send(s->pipe, c, &s->openpol);
-        if (composite_nomem(openpol_req, c)) return c;
-
-        composite_continue_rpc(c, openpol_req, continue_lsa_policy_open, c);
+        subreq = dcerpc_lsa_OpenPolicy2_r_send(s, c->event_ctx,
+                                               s->pipe->binding_handle,
+                                               &s->openpol);
+        if (composite_nomem(subreq, c)) return c;
+
+        tevent_req_set_callback(subreq, continue_lsa_policy_open, c);
         return c;
 }
@@ -476 +491 @@
         struct domain_open_lsa_state *s;
         struct lsa_QosInfo *qos;
-        struct rpc_request *openpol_req;
+        struct tevent_req *subreq;
 
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -504 +519 @@
 
         /* send rpc request */
-        openpol_req = dcerpc_lsa_OpenPolicy2_send(s->pipe, c, &s->openpol);
-        if (composite_nomem(openpol_req, c)) return;
-
-        composite_continue_rpc(c, openpol_req, continue_lsa_policy_open, c);
+        subreq = dcerpc_lsa_OpenPolicy2_r_send(s, c->event_ctx,
+                                               s->pipe->binding_handle,
+                                               &s->openpol);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_lsa_policy_open, c);
 }
 
@@ -514 +531 @@
   Stage 1: Lsa policy opened - we're done, if successfully
  */
-static void continue_lsa_policy_open(struct rpc_request *req)
+static void continue_lsa_policy_open(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_open_lsa_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_open_lsa_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_lsa_OpenPolicy2_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -667 +685 @@
 
 
-static void continue_lsa_close(struct rpc_request *req);
+static void continue_lsa_close(struct tevent_req *subreq);
 
 
@@ -676 +694 @@
         struct composite_context *c;
         struct domain_close_lsa_state *s;
-        struct rpc_request *close_req;
+        struct tevent_req *subreq;
 
         /* composite context and state structure allocation */
@@ -703 +721 @@
 
         /* send the request */
-        close_req = dcerpc_lsa_Close_send(s->pipe, c, &s->close);
-        if (composite_nomem(close_req, c)) return c;
-
-        composite_continue_rpc(c, close_req, continue_lsa_close, c);
+        subreq = dcerpc_lsa_Close_r_send(s, c->event_ctx,
+                                         s->pipe->binding_handle,
+                                         &s->close);
+        if (composite_nomem(subreq, c)) return c;
+
+        tevent_req_set_callback(subreq, continue_lsa_close, c);
         return c;
 }
@@ -714 +734 @@
   Stage 1: Receive result of lsa close call
 */
-static void continue_lsa_close(struct rpc_request *req)
+static void continue_lsa_close(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_close_lsa_state *s;
         
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_close_lsa_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_lsa_Close_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -771 +792 @@
 
 
-static void continue_samr_close(struct rpc_request *req);
+static void continue_samr_close(struct tevent_req *subreq);
 
 
@@ -780 +801 @@
         struct composite_context *c;
         struct domain_close_samr_state *s;
-        struct rpc_request *close_req;
+        struct tevent_req *subreq;
 
         /* composite context and state structure allocation */
@@ -805 +826 @@
 
         /* send the request */
-        close_req = dcerpc_samr_Close_send(ctx->samr.pipe, ctx, &s->close);
-        if (composite_nomem(close_req, c)) return c;
-
-        composite_continue_rpc(c, close_req, continue_samr_close, c);
+        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
+                                          ctx->samr.pipe->binding_handle,
+                                          &s->close);
+        if (composite_nomem(subreq, c)) return c;
+
+        tevent_req_set_callback(subreq, continue_samr_close, c);
         return c;
 }
@@ -816 +839 @@
   Stage 1: Receive result of samr close call
 */
-static void continue_samr_close(struct rpc_request *req)
+static void continue_samr_close(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_close_samr_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_close_samr_state);
         
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_Close_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -941 +965 @@
 
 static void continue_rpc_connect(struct composite_context *c);
-static void continue_samr_connect(struct rpc_request *c);
-static void continue_samr_enum_domains(struct rpc_request *req);
-static void continue_samr_close_handle(struct rpc_request *req);
+static void continue_samr_connect(struct tevent_req *subreq);
+static void continue_samr_enum_domains(struct tevent_req *subreq);
+static void continue_samr_close_handle(struct tevent_req *subreq);
 
 static struct domainlist* get_domain_list(TALLOC_CTX *mem_ctx, struct domain_list_state *s);
@@ -956 +980 @@
         struct composite_context *c;
         struct domain_list_state *s;
-        struct rpc_request *samrconn_req;
+        struct tevent_req *subreq;
 
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -968 +992 @@
         s->samrconn.out.connect_handle = &s->connect_handle;
 
-        samrconn_req = dcerpc_samr_Connect_send(s->ctx->samr.pipe, c, &s->samrconn);
-        if (composite_nomem(samrconn_req, c)) return;
-
-        composite_continue_rpc(c, samrconn_req, continue_samr_connect, c);
+        subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
+                                            s->ctx->samr.pipe->binding_handle,
+                                            &s->samrconn);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_samr_connect, c);
 }
 
@@ -979 +1005 @@
   a request to enumerate domain databases available
 */
-static void continue_samr_connect(struct rpc_request *req)
+static void continue_samr_connect(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_list_state *s;
-        struct rpc_request *enumdom_req;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_list_state);
         
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_Connect_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -1009 +1035 @@
         if (composite_nomem(s->enumdom.out.sam, c)) return;
 
-        enumdom_req = dcerpc_samr_EnumDomains_send(s->ctx->samr.pipe, c, &s->enumdom);
-        if (composite_nomem(enumdom_req, c)) return;
-
-        composite_continue_rpc(c, enumdom_req, continue_samr_enum_domains, c);
+        subreq = dcerpc_samr_EnumDomains_r_send(s, c->event_ctx,
+                                                s->ctx->samr.pipe->binding_handle,
+                                                &s->enumdom);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_samr_enum_domains, c);
 }
 
@@ -1021 +1049 @@
   upon completion.
 */
-static void continue_samr_enum_domains(struct rpc_request *req)
+static void continue_samr_enum_domains(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_list_state *s;
-        struct rpc_request *enumdom_req;
-        struct rpc_request *samrclose_req;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_list_state);
         
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_EnumDomains_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -1058 +1085 @@
 
                 /* send the request */
-                enumdom_req = dcerpc_samr_EnumDomains_send(s->ctx->samr.pipe, c, &s->enumdom);
-                if (composite_nomem(enumdom_req, c)) return;
-
-                composite_continue_rpc(c, enumdom_req, continue_samr_enum_domains, c);
+                subreq = dcerpc_samr_EnumDomains_r_send(s, c->event_ctx,
+                                                        s->ctx->samr.pipe->binding_handle,
+                                                        &s->enumdom);
+                if (composite_nomem(subreq, c)) return;
+
+                tevent_req_set_callback(subreq, continue_samr_enum_domains, c);
 
         } else {
@@ -1073 +1102 @@
         
         /* send the request */
-        samrclose_req = dcerpc_samr_Close_send(s->ctx->samr.pipe, c, &s->samrclose);
-        if (composite_nomem(samrclose_req, c)) return;
-
-        composite_continue_rpc(c, samrclose_req, continue_samr_close_handle, c);
+        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
+                                          s->ctx->samr.pipe->binding_handle,
+                                          &s->samrclose);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_samr_close_handle, c);
 }
 
@@ -1083 +1114 @@
   Stage 4: Receive result of closing samr connection handle.
 */
-static void continue_samr_close_handle(struct rpc_request *req)
+static void continue_samr_close_handle(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct domain_list_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct domain_list_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_Close_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -1117 +1149 @@
 static struct domainlist* get_domain_list(TALLOC_CTX *mem_ctx, struct domain_list_state *s)
 {
-        int i;
+        uint32_t i;
         if (mem_ctx == NULL || s == NULL) return NULL;
 
@@ -1164 +1196 @@
         struct domain_list_state *s;
         struct composite_context *rpcconn_req;
-        struct rpc_request *samrconn_req;
+        struct tevent_req *subreq;
 
         /* composite context and state structure allocation */
@@ -1200 +1232 @@
                 s->samrconn.out.connect_handle = &s->connect_handle;
                 
-                samrconn_req = dcerpc_samr_Connect_send(s->ctx->samr.pipe, c, &s->samrconn);
-                if (composite_nomem(samrconn_req, c)) return c;
-
-                composite_continue_rpc(c, samrconn_req, continue_samr_connect, c);
+                subreq = dcerpc_samr_Connect_r_send(s, c->event_ctx,
+                                                    s->ctx->samr.pipe->binding_handle,
+                                                    &s->samrconn);
+                if (composite_nomem(subreq, c)) return c;
+
+                tevent_req_set_callback(subreq, continue_samr_connect, c);
         }
 

vendor/current/source4/libnet/libnet_export_keytab.c

@@ -3 +3 @@
 #include "auth/kerberos/kerberos.h"
 #include <hdb.h>
-#include "kdc/hdb-samba4.h"
+#include "kdc/samba_kdc.h"
 #include "libnet/libnet.h"
+
+extern struct hdb_method hdb_samba4;
 
 NTSTATUS libnet_export_keytab(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_export_keytab *r)
@@ -14 +16 @@
         /* Register hdb-samba4 hooks for use as a keytab */
 
-        struct hdb_samba4_context *hdb_samba4_context = talloc(mem_ctx, struct hdb_samba4_context);
-        if (!hdb_samba4_context) {
+        struct samba_kdc_base_context *base_ctx = talloc_zero(mem_ctx, struct samba_kdc_base_context);
+        if (!base_ctx) {
                 return NT_STATUS_NO_MEMORY; 
         }
 
-        hdb_samba4_context->ev_ctx = ctx->event_ctx;
-        hdb_samba4_context->lp_ctx = ctx->lp_ctx;
+        base_ctx->ev_ctx = ctx->event_ctx;
+        base_ctx->lp_ctx = ctx->lp_ctx;
 
-        from_keytab = talloc_asprintf(hdb_samba4_context, "HDB:samba4&%p", hdb_samba4_context);
+        from_keytab = talloc_asprintf(base_ctx, "HDB:samba4&%p", base_ctx);
         if (!from_keytab) {
                 return NT_STATUS_NO_MEMORY;
@@ -44 +46 @@
         }
 
+        unlink(r->in.keytab_name);
+
         ret = kt_copy(smb_krb5_context->krb5_context, from_keytab, r->in.keytab_name);
         if(ret) {

vendor/current/source4/libnet/libnet_group.c

@@ -148 +148 @@
         }
 
+        talloc_free(c);
         return status;
 }
@@ -409 +410 @@
 
         talloc_free(c);
-
         return status;
 }
@@ -448 +448 @@
 
 static void continue_lsa_domain_opened(struct composite_context *ctx);
-static void continue_domain_queried(struct rpc_request *req);
+static void continue_domain_queried(struct tevent_req *subreq);
 static void continue_samr_domain_opened(struct composite_context *ctx);
-static void continue_domain_queried(struct rpc_request *req);
-static void continue_groups_enumerated(struct rpc_request *req);
+static void continue_groups_enumerated(struct tevent_req *subreq);
 
 
@@ -470 +469 @@
         struct composite_context *c;
         struct grouplist_state *s;
-        struct rpc_request *query_req;
+        struct tevent_req *subreq;
         bool prereq_met = false;
 
@@ -501 +500 @@
 
         /* send the request */
-        query_req = dcerpc_lsa_QueryInfoPolicy_send(ctx->lsa.pipe, c, &s->query_domain);
-        if (composite_nomem(query_req, c)) return c;
-        
-        composite_continue_rpc(c, query_req, continue_domain_queried, c);
+        subreq = dcerpc_lsa_QueryInfoPolicy_r_send(s, c->event_ctx,
+                                                   ctx->lsa.pipe->binding_handle,
+                                                   &s->query_domain);
+        if (composite_nomem(subreq, c)) return c;
+        
+        tevent_req_set_callback(subreq, continue_domain_queried, c);
         return c;
 }
@@ -517 +518 @@
         struct composite_context *c;
         struct grouplist_state *s;
-        struct rpc_request *query_req;
+        struct tevent_req *subreq;
         
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -533 +534 @@
 
         /* send the request */
-        query_req = dcerpc_lsa_QueryInfoPolicy_send(s->ctx->lsa.pipe, c, &s->query_domain);
-        if (composite_nomem(query_req, c)) return;
-
-        composite_continue_rpc(c, query_req, continue_domain_queried, c);
+        subreq = dcerpc_lsa_QueryInfoPolicy_r_send(s, c->event_ctx,
+                                                   s->ctx->lsa.pipe->binding_handle,
+                                                   &s->query_domain);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_domain_queried, c);
 }
 
@@ -544 +547 @@
  * provided a valid samr handle is opened
  */
-static void continue_domain_queried(struct rpc_request *req)
+static void continue_domain_queried(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct grouplist_state *s;
-        struct rpc_request *enum_req;
         bool prereq_met = false;
         
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct grouplist_state);
 
         /* receive result of rpc request */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_lsa_QueryInfoPolicy_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -577 +580 @@
 
         /* send the request */
-        enum_req = dcerpc_samr_EnumDomainGroups_send(s->ctx->samr.pipe, c, &s->group_list);
-        if (composite_nomem(enum_req, c)) return;
-
-        composite_continue_rpc(c, enum_req, continue_groups_enumerated, c);
+        subreq = dcerpc_samr_EnumDomainGroups_r_send(s, c->event_ctx,
+                                                     s->ctx->samr.pipe->binding_handle,
+                                                     &s->group_list);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_groups_enumerated, c);
 }
 
@@ -592 +597 @@
         struct composite_context *c;
         struct grouplist_state *s;
-        struct rpc_request *enum_req;
+        struct tevent_req *subreq;
 
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -612 +617 @@
 
         /* send the request */
-        enum_req = dcerpc_samr_EnumDomainGroups_send(s->ctx->samr.pipe, c, &s->group_list);
-        if (composite_nomem(enum_req, c)) return;
-
-        composite_continue_rpc(c, enum_req, continue_groups_enumerated, c);
+        subreq = dcerpc_samr_EnumDomainGroups_r_send(s, c->event_ctx,
+                                                     s->ctx->samr.pipe->binding_handle,
+                                                     &s->group_list);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_groups_enumerated, c);
 }
 
@@ -622 +629 @@
  * Stage 2: receive enumerated groups and their rids
  */
-static void continue_groups_enumerated(struct rpc_request *req)
+static void continue_groups_enumerated(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct grouplist_state *s;
-        int i;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        uint32_t i;
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct grouplist_state);
 
         /* receive result of rpc request */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_EnumDomainGroups_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -664 +672 @@
 
                         /* groupname */
-                        s->groups[i].groupname = talloc_strdup(c, entry->name.string);
+                        s->groups[i].groupname = talloc_strdup(s->groups, entry->name.string);
                         if (composite_nomem(s->groups[i].groupname, c)) return;
 
                         /* sid string */
-                        s->groups[i].sid = dom_sid_string(c, group_sid);
+                        s->groups[i].sid = dom_sid_string(s->groups, group_sid);
                         if (composite_nomem(s->groups[i].sid, c)) return;
                 }
@@ -697 +705 @@
 
         if (c == NULL || mem_ctx == NULL || io == NULL) {
+                talloc_free(c);
                 return NT_STATUS_INVALID_PARAMETER;
         }
@@ -724 +733 @@
         }
 
+        talloc_free(c);
         return status;
 }

vendor/current/source4/libnet/libnet_join.c

@@ -23 +23 @@
 #include "libnet/libnet.h"
 #include "librpc/gen_ndr/ndr_drsuapi_c.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
-#include "param/secrets.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "dsdb/samdb/samdb.h"
 #include "ldb_wrap.h"
-#include "../lib/util/util_ldb.h"
 #include "libcli/security/security.h"
 #include "auth/credentials/credentials.h"
@@ -35 +33 @@
 #include "param/param.h"
 #include "param/provision.h"
+#include "system/kerberos.h"
+#include "auth/kerberos/kerberos.h"
 
 /*
@@ -95 +95 @@
         }
                                                    
-        drsuapi_binding = talloc(tmp_ctx, struct dcerpc_binding);
+        drsuapi_binding = talloc_zero(tmp_ctx, struct dcerpc_binding);
         if (!drsuapi_binding) {
                 r->out.error_string = NULL;
@@ -134 +134 @@
         r_drsuapi_bind.out.bind_handle = &drsuapi_bind_handle;
 
-        status = dcerpc_drsuapi_DsBind(drsuapi_pipe, tmp_ctx, &r_drsuapi_bind);
-        if (!NT_STATUS_IS_OK(status)) {
-                if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                        r->out.error_string
-                                = talloc_asprintf(r,
-                                                  "dcerpc_drsuapi_DsBind failed - %s", 
-                                                  dcerpc_errstr(tmp_ctx, drsuapi_pipe->last_fault_code));
-                        talloc_free(tmp_ctx);
-                        return status;
-                } else {
-                        r->out.error_string
-                                = talloc_asprintf(r,
-                                                  "dcerpc_drsuapi_DsBind failed - %s", 
-                                                  nt_errstr(status));
-                        talloc_free(tmp_ctx);
-                        return status;
-                }
+        status = dcerpc_drsuapi_DsBind_r(drsuapi_pipe->binding_handle, tmp_ctx, &r_drsuapi_bind);
+        if (!NT_STATUS_IS_OK(status)) {
+                r->out.error_string
+                        = talloc_asprintf(r,
+                                          "dcerpc_drsuapi_DsBind failed - %s",
+                                          nt_errstr(status));
+                talloc_free(tmp_ctx);
+                return status;
         } else if (!W_ERROR_IS_OK(r_drsuapi_bind.out.result)) {
                 r->out.error_string
@@ -185 +176 @@
 
         r_crack_names.out.ctr                   = talloc(r, union drsuapi_DsNameCtr);
-        r_crack_names.out.level_out             = talloc(r, int32_t);
+        r_crack_names.out.level_out             = talloc(r, uint32_t);
         if (!r_crack_names.out.ctr || !r_crack_names.out.level_out) {
                 r->out.error_string = NULL;
@@ -192 +183 @@
         }
 
-        status = dcerpc_drsuapi_DsCrackNames(drsuapi_pipe, tmp_ctx, &r_crack_names);
-        if (!NT_STATUS_IS_OK(status)) {
-                if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                        r->out.error_string
-                                = talloc_asprintf(r,
-                                                  "dcerpc_drsuapi_DsCrackNames for [%s] failed - %s", 
-                                                  names[0].str,
-                                                  dcerpc_errstr(tmp_ctx, drsuapi_pipe->last_fault_code));
-                        talloc_free(tmp_ctx);
-                        return status;
-                } else {
-                        r->out.error_string
-                                = talloc_asprintf(r,
-                                                  "dcerpc_drsuapi_DsCrackNames for [%s] failed - %s", 
-                                                  names[0].str,
-                                                  nt_errstr(status));
-                        talloc_free(tmp_ctx);
-                        return status;
-                }
+        status = dcerpc_drsuapi_DsCrackNames_r(drsuapi_pipe->binding_handle, tmp_ctx, &r_crack_names);
+        if (!NT_STATUS_IS_OK(status)) {
+                r->out.error_string
+                        = talloc_asprintf(r,
+                                          "dcerpc_drsuapi_DsCrackNames for [%s] failed - %s",
+                                          names[0].str,
+                                          nt_errstr(status));
+                talloc_free(tmp_ctx);
+                return status;
         } else if (!W_ERROR_IS_OK(r_crack_names.out.result)) {
                 r->out.error_string
@@ -246 +227 @@
         }
 
-        remote_ldb = ldb_wrap_connect(tmp_ctx, ctx->event_ctx, ctx->lp_ctx, 
+        remote_ldb = ldb_wrap_connect(tmp_ctx, ctx->event_ctx, ctx->lp_ctx,
                                       remote_ldb_url, 
-                                      NULL, ctx->cred, 0, NULL);
+                                      NULL, ctx->cred, 0);
         if (!remote_ldb) {
                 r->out.error_string = NULL;
@@ -256 +237 @@
 
         account_dn = ldb_dn_new(tmp_ctx, remote_ldb, account_dn_str);
-        if (! ldb_dn_validate(account_dn)) {
+        if (account_dn == NULL) {
                 r->out.error_string = talloc_asprintf(r, "Invalid account dn: %s",
                                                       account_dn_str);
@@ -290 +271 @@
 
         {
-                int i;
-                const char *service_principal_name[6];
-                const char *dns_host_name = strlower_talloc(tmp_ctx, 
-                                                            talloc_asprintf(tmp_ctx, 
+                unsigned int i;
+                const char *service_principal_name[2];
+                const char *dns_host_name = strlower_talloc(msg,
+                                                            talloc_asprintf(msg, 
                                                                             "%s.%s", 
                                                                             r->in.netbios_name, 
@@ -304 +285 @@
                 }
 
-                service_principal_name[0] = talloc_asprintf(tmp_ctx, "host/%s", dns_host_name);
-                service_principal_name[1] = talloc_asprintf(tmp_ctx, "host/%s", strlower_talloc(tmp_ctx, r->in.netbios_name));
-                service_principal_name[2] = talloc_asprintf(tmp_ctx, "host/%s/%s", dns_host_name, realm);
-                service_principal_name[3] = talloc_asprintf(tmp_ctx, "host/%s/%s", strlower_talloc(tmp_ctx, r->in.netbios_name), realm);
-                service_principal_name[4] = talloc_asprintf(tmp_ctx, "host/%s/%s", dns_host_name, r->out.domain_name);
-                service_principal_name[5] = talloc_asprintf(tmp_ctx, "host/%s/%s", strlower_talloc(tmp_ctx, r->in.netbios_name), r->out.domain_name);
+                service_principal_name[0] = talloc_asprintf(msg, "HOST/%s",
+                                                            dns_host_name);
+                service_principal_name[1] = talloc_asprintf(msg, "HOST/%s",
+                                                            r->in.netbios_name);
                 
                 for (i=0; i < ARRAY_SIZE(service_principal_name); i++) {
@@ -317 +296 @@
                                 return NT_STATUS_NO_MEMORY;
                         }
-                        rtn = samdb_msg_add_string(remote_ldb, tmp_ctx, msg, "servicePrincipalName", service_principal_name[i]);
-                        if (rtn == -1) {
+                        rtn = ldb_msg_add_string(msg, "servicePrincipalName",
+                                                 service_principal_name[i]);
+                        if (rtn != LDB_SUCCESS) {
                                 r->out.error_string = NULL;
                                 talloc_free(tmp_ctx);
@@ -325 +305 @@
                 }
 
-                rtn = samdb_msg_add_string(remote_ldb, tmp_ctx, msg, "dNSHostName", dns_host_name);
-                if (rtn == -1) {
+                rtn = ldb_msg_add_string(msg, "dNSHostName", dns_host_name);
+                if (rtn != LDB_SUCCESS) {
                         r->out.error_string = NULL;
                         talloc_free(tmp_ctx);
@@ -332 +312 @@
                 }
 
-                rtn = samdb_replace(remote_ldb, tmp_ctx, msg);
-                if (rtn != 0) {
+                rtn = dsdb_replace(remote_ldb, msg, 0);
+                if (rtn != LDB_SUCCESS) {
                         r->out.error_string
                                 = talloc_asprintf(r, 
@@ -343 +323 @@
         }
                                 
+        msg = ldb_msg_new(tmp_ctx);
+        if (!msg) {
+                r->out.error_string = NULL;
+                talloc_free(tmp_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
+        msg->dn = res->msgs[0]->dn;
+
+        rtn = samdb_msg_add_uint(remote_ldb, msg, msg,
+                                 "msDS-SupportedEncryptionTypes", ENC_ALL_TYPES);
+        if (rtn != LDB_SUCCESS) {
+                r->out.error_string = NULL;
+                talloc_free(tmp_ctx);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        rtn = dsdb_replace(remote_ldb, msg, 0);
+        /* The remote server may not support this attribute, if it
+         * isn't a modern schema */
+        if (rtn != LDB_SUCCESS && rtn != LDB_ERR_NO_SUCH_ATTRIBUTE) {
+                r->out.error_string
+                        = talloc_asprintf(r,
+                                          "Failed to replace msDS-SupportedEncryptionTypes on %s",
+                                          ldb_dn_get_linearized(msg->dn));
+                talloc_free(tmp_ctx);
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
+
         /* DsCrackNames to find out the DN of the domain. */
         r_crack_names.in.req->req1.format_offered = DRSUAPI_DS_NAME_FORMAT_NT4_ACCOUNT;
@@ -353 +361 @@
         }
 
-        status = dcerpc_drsuapi_DsCrackNames(drsuapi_pipe, tmp_ctx, &r_crack_names);
-        if (!NT_STATUS_IS_OK(status)) {
-                if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
-                        r->out.error_string
-                                = talloc_asprintf(r,
-                                                  "dcerpc_drsuapi_DsCrackNames for [%s] failed - %s", 
-                                                  r->in.domain_name, 
-                                                  dcerpc_errstr(tmp_ctx, drsuapi_pipe->last_fault_code));
-                        talloc_free(tmp_ctx);
-                        return status;
-                } else {
-                        r->out.error_string
-                                = talloc_asprintf(r,
-                                                  "dcerpc_drsuapi_DsCrackNames for [%s] failed - %s", 
-                                                  r->in.domain_name, 
-                                                  nt_errstr(status));
-                        talloc_free(tmp_ctx);
-                        return status;
-                }
+        status = dcerpc_drsuapi_DsCrackNames_r(drsuapi_pipe->binding_handle, tmp_ctx, &r_crack_names);
+        if (!NT_STATUS_IS_OK(status)) {
+                r->out.error_string
+                        = talloc_asprintf(r,
+                                          "dcerpc_drsuapi_DsCrackNames for [%s] failed - %s",
+                                          r->in.domain_name,
+                                          nt_errstr(status));
+                talloc_free(tmp_ctx);
+                return status;
         } else if (!W_ERROR_IS_OK(r_crack_names.out.result)) {
                 r->out.error_string
@@ -540 +538 @@
 
         /* 2. do a samr_Connect to get a policy handle */
-        status = dcerpc_samr_Connect(samr_pipe, tmp_ctx, &sc);
+        status = dcerpc_samr_Connect_r(samr_pipe->binding_handle, tmp_ctx, &sc);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(sc.out.result)) {
+                status = sc.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->out.error_string = talloc_asprintf(mem_ctx,
@@ -554 +555 @@
                         connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, r->in.domain_name);
                 } else {
-                        /* Bugger, we just lost our way to automaticly find the domain name */
-                        connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, lp_workgroup(ctx->lp_ctx));
-                        connect_with_info->out.realm = talloc_strdup(tmp_ctx, lp_realm(ctx->lp_ctx));
+                        /* Bugger, we just lost our way to automatically find the domain name */
+                        connect_with_info->out.domain_name = talloc_strdup(tmp_ctx, lpcfg_workgroup(ctx->lp_ctx));
+                        connect_with_info->out.realm = talloc_strdup(tmp_ctx, lpcfg_realm(ctx->lp_ctx));
                 }
         }
@@ -570 +571 @@
                 l.out.sid = &sid;
                 
-                status = dcerpc_samr_LookupDomain(samr_pipe, tmp_ctx, &l);
+                status = dcerpc_samr_LookupDomain_r(samr_pipe->binding_handle, tmp_ctx, &l);
+                if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(l.out.result)) {
+                        status = l.out.result;
+                }
                 if (!NT_STATUS_IS_OK(status)) {
                         r->out.error_string = talloc_asprintf(mem_ctx,
@@ -589 +593 @@
 
         /* do a samr_OpenDomain to get a domain handle */
-        status = dcerpc_samr_OpenDomain(samr_pipe, tmp_ctx, &od);                       
+        status = dcerpc_samr_OpenDomain_r(samr_pipe->binding_handle, tmp_ctx, &od);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(od.out.result)) {
+                status = od.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->out.error_string = talloc_asprintf(mem_ctx,
@@ -611 +618 @@
 
         /* do a samr_CreateUser2 to get an account handle, or an error */
-        cu_status = dcerpc_samr_CreateUser2(samr_pipe, tmp_ctx, &cu);                   
+        cu_status = dcerpc_samr_CreateUser2_r(samr_pipe->binding_handle, tmp_ctx, &cu);
+        if (NT_STATUS_IS_OK(cu_status) && !NT_STATUS_IS_OK(cu.out.result)) {
+                cu_status = cu.out.result;
+        }
         status = cu_status;
         if (NT_STATUS_EQUAL(status, NT_STATUS_USER_EXISTS)) {
@@ -628 +638 @@
                 
                 /* 5. do a samr_LookupNames to get the users rid */
-                status = dcerpc_samr_LookupNames(samr_pipe, tmp_ctx, &ln);
+                status = dcerpc_samr_LookupNames_r(samr_pipe->binding_handle, tmp_ctx, &ln);
+                if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ln.out.result)) {
+                        status = ln.out.result;
+                }
                 if (!NT_STATUS_IS_OK(status)) {
                         r->out.error_string = talloc_asprintf(mem_ctx,
@@ -656 +669 @@
                 
                 /* 6. do a samr_OpenUser to get a user handle */
-                status = dcerpc_samr_OpenUser(samr_pipe, tmp_ctx, &ou); 
+                status = dcerpc_samr_OpenUser_r(samr_pipe->binding_handle, tmp_ctx, &ou);
+                if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ou.out.result)) {
+                        status = ou.out.result;
+                }
                 if (!NT_STATUS_IS_OK(status)) {
                         r->out.error_string = talloc_asprintf(mem_ctx,
@@ -670 +686 @@
                         d.in.user_handle = u_handle;
                         d.out.user_handle = u_handle;
-                        status = dcerpc_samr_DeleteUser(samr_pipe, mem_ctx, &d);
+                        status = dcerpc_samr_DeleteUser_r(samr_pipe->binding_handle, mem_ctx, &d);
+                        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(d.out.result)) {
+                                status = d.out.result;
+                        }
                         if (!NT_STATUS_IS_OK(status)) {
                                 r->out.error_string = talloc_asprintf(mem_ctx,
@@ -683 +702 @@
                         
                         /* &cu filled in above */
-                        status = dcerpc_samr_CreateUser2(samr_pipe, tmp_ctx, &cu);                      
+                        status = dcerpc_samr_CreateUser2_r(samr_pipe->binding_handle, tmp_ctx, &cu);
+                        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(cu.out.result)) {
+                                status = cu.out.result;
+                        }
                         if (!NT_STATUS_IS_OK(status)) {
                                 r->out.error_string = talloc_asprintf(mem_ctx,
@@ -705 +727 @@
         qui.out.info = &uinfo;
         
-        status = dcerpc_samr_QueryUserInfo(samr_pipe, tmp_ctx, &qui);
+        status = dcerpc_samr_QueryUserInfo_r(samr_pipe->binding_handle, tmp_ctx, &qui);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(qui.out.result)) {
+                status = qui.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->out.error_string = talloc_asprintf(mem_ctx,
@@ -790 +815 @@
         pwp.out.info = &info;
 
-        status = dcerpc_samr_GetUserPwInfo(samr_pipe, tmp_ctx, &pwp);                           
+        status = dcerpc_samr_GetUserPwInfo_r(samr_pipe->binding_handle, tmp_ctx, &pwp);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(pwp.out.result)) {
+                status = pwp.out.result;
+        }
         if (NT_STATUS_IS_OK(status)) {
                 policy_min_pw_len = pwp.out.info->min_password_length;
@@ -797 +825 @@
         /* Grab a password of that minimum length */
         
-        password_str = generate_random_str(tmp_ctx, MAX(8, policy_min_pw_len)); 
+        password_str = generate_random_password(tmp_ctx, MAX(8, policy_min_pw_len), 255);
 
         /* set full_name and reset flags */
@@ -902 +930 @@
                 netbios_name = r->in.netbios_name;
         } else {
-                netbios_name = talloc_strdup(tmp_mem, lp_netbios_name(ctx->lp_ctx));
+                netbios_name = talloc_strdup(tmp_mem, lpcfg_netbios_name(ctx->lp_ctx));
                 if (!netbios_name) {
                         r->out.error_string = NULL;
@@ -944 +972 @@
         set_secrets->domain_name = r2->out.domain_name;
         set_secrets->realm = r2->out.realm;
-        set_secrets->account_name = account_name;
         set_secrets->netbios_name = netbios_name;
         set_secrets->secure_channel_type = r->in.join_type;

vendor/current/source4/libnet/libnet_lookup.c

@@ -23 +23 @@
 
 #include "includes.h"
-#include "lib/events/events.h"
 #include "libnet/libnet.h"
 #include "libcli/composite/composite.h"
 #include "auth/credentials/credentials.h"
-#include "lib/messaging/messaging.h"
-#include "lib/messaging/irpc.h"
 #include "libcli/resolve/resolve.h"
-#include "libcli/finddcs.h"
+#include "libcli/finddc.h"
 #include "libcli/security/security.h"
-#include "librpc/gen_ndr/lsa.h"
 #include "librpc/gen_ndr/ndr_lsa_c.h"
-
 #include "param/param.h"
 
@@ -187 +182 @@
  * Sends asynchronous LookupDCs request
  */
-struct composite_context* libnet_LookupDCs_send(struct libnet_context *ctx,
-                                                TALLOC_CTX *mem_ctx,
-                                                struct libnet_LookupDCs *io)
-{
-        struct composite_context *c;
-        struct messaging_context *msg_ctx = 
-                messaging_client_init(mem_ctx, lp_messaging_path(mem_ctx, ctx->lp_ctx), 
-                                      lp_iconv_convenience(ctx->lp_ctx), ctx->event_ctx);
-
-        c = finddcs_send(mem_ctx, lp_netbios_name(ctx->lp_ctx), lp_nbt_port(ctx->lp_ctx),
-                         io->in.domain_name, io->in.name_type,
-                         NULL, lp_iconv_convenience(ctx->lp_ctx), 
-                         ctx->resolve_ctx, ctx->event_ctx, msg_ctx);
-        return c;
+struct tevent_req *libnet_LookupDCs_send(struct libnet_context *ctx,
+                                         TALLOC_CTX *mem_ctx,
+                                         struct libnet_LookupDCs *io)
+{
+        struct tevent_req *req;
+        struct finddcs finddcs_io;
+
+        ZERO_STRUCT(finddcs_io);
+
+        if (strcasecmp_m(io->in.domain_name, lpcfg_workgroup(ctx->lp_ctx)) == 0) {
+                finddcs_io.in.domain_name = lpcfg_dnsdomain(ctx->lp_ctx);
+        } else {
+                finddcs_io.in.domain_name = io->in.domain_name;
+        }
+        finddcs_io.in.minimum_dc_flags = NBT_SERVER_LDAP | NBT_SERVER_DS | NBT_SERVER_WRITABLE;
+        finddcs_io.in.server_address = ctx->server_address;
+
+        req = finddcs_cldap_send(mem_ctx, &finddcs_io, ctx->resolve_ctx, ctx->event_ctx);
+        return req;
 }
 
@@ -212 +212 @@
  */
 
-NTSTATUS libnet_LookupDCs_recv(struct composite_context *c, TALLOC_CTX *mem_ctx,
+NTSTATUS libnet_LookupDCs_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
                                struct libnet_LookupDCs *io)
 {
         NTSTATUS status;
-        status = finddcs_recv(c, mem_ctx, &io->out.num_dcs, &io->out.dcs);
-        if (!NT_STATUS_IS_OK(status)) {
-                return status;
-        }
+        struct finddcs finddcs_io;
+        status = finddcs_cldap_recv(req, mem_ctx, &finddcs_io);
+        talloc_free(req);
+        io->out.num_dcs = 1;
+        io->out.dcs = talloc(mem_ctx, struct nbt_dc_name);
+        NT_STATUS_HAVE_NO_MEMORY(io->out.dcs);
+        io->out.dcs[0].address = finddcs_io.out.address;
+        io->out.dcs[0].name = finddcs_io.out.netlogon.data.nt5_ex.pdc_dns_name;
         return status;
 }
@@ -230 +234 @@
                           struct libnet_LookupDCs *io)
 {
-        struct composite_context *c = libnet_LookupDCs_send(ctx, mem_ctx, io);
-        return libnet_LookupDCs_recv(c, mem_ctx, io);
+        struct tevent_req *req = libnet_LookupDCs_send(ctx, mem_ctx, io);
+        return libnet_LookupDCs_recv(req, mem_ctx, io);
 }
 
@@ -253 +257 @@
                                   struct lookup_name_state *s);
 static void continue_lookup_name(struct composite_context *ctx);
-static void continue_name_found(struct rpc_request *req);
+static void continue_name_found(struct tevent_req *subreq);
 
 
@@ -263 +267 @@
         struct composite_context *c;
         struct lookup_name_state *s;
-        struct rpc_request *lookup_req;
+        struct tevent_req *subreq;
         bool prereq_met = false;
 
@@ -284 +288 @@
         if (!prepare_lookup_params(ctx, c, s)) return c;
 
-        lookup_req = dcerpc_lsa_LookupNames_send(ctx->lsa.pipe, c, &s->lookup);
-        if (composite_nomem(lookup_req, c)) return c;
-
-        composite_continue_rpc(c, lookup_req, continue_name_found, c);
+        subreq = dcerpc_lsa_LookupNames_r_send(s, c->event_ctx,
+                                               ctx->lsa.pipe->binding_handle,
+                                               &s->lookup);
+        if (composite_nomem(subreq, c)) return c;
+
+        tevent_req_set_callback(subreq, continue_name_found, c);
         return c;
 }
@@ -324 +330 @@
         struct composite_context *c;
         struct lookup_name_state *s;
-        struct rpc_request *lookup_req;
+        struct tevent_req *subreq;
 
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -334 +340 @@
         if (!prepare_lookup_params(s->ctx, c, s)) return;
 
-        lookup_req = dcerpc_lsa_LookupNames_send(s->ctx->lsa.pipe, c, &s->lookup);
-        if (composite_nomem(lookup_req, c)) return;
-        
-        composite_continue_rpc(c, lookup_req, continue_name_found, c);
-}
-
-
-static void continue_name_found(struct rpc_request *req)
+        subreq = dcerpc_lsa_LookupNames_r_send(s, c->event_ctx,
+                                               s->ctx->lsa.pipe->binding_handle,
+                                               &s->lookup);
+        if (composite_nomem(subreq, c)) return;
+        
+        tevent_req_set_callback(subreq, continue_name_found, c);
+}
+
+
+static void continue_name_found(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct lookup_name_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct lookup_name_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_lsa_LookupNames_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 

vendor/current/source4/libnet/libnet_passwd.c

@@ -52 +52 @@
         uint8_t old_lm_hash[16], new_lm_hash[16];
         struct samr_DomInfo1 *dominfo = NULL;
-        struct samr_ChangeReject *reject = NULL;
+        struct userPwdChangeFailureInformation *reject = NULL;
 
         ZERO_STRUCT(c);
@@ -102 +102 @@
 
         /* 2. try samr_ChangePasswordUser3 */
-        status = dcerpc_samr_ChangePasswordUser3(c.out.dcerpc_pipe, mem_ctx, &pw3);
-        if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
+        status = dcerpc_samr_ChangePasswordUser3_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &pw3);
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
+                if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(pw3.out.result)) {
+                        status = pw3.out.result;
+                }
                 if (!NT_STATUS_IS_OK(status)) {
                         r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -110 +113 @@
                         r->samr.out.error_string = talloc_asprintf(mem_ctx,
                                                                    "samr_ChangePasswordUser3 for '%s\\%s' failed: %s",
-                                                                   r->samr.in.domain_name, r->samr.in.account_name, 
+                                                                   r->samr.in.domain_name, r->samr.in.account_name,
                                                                    nt_errstr(status));
                 }
                 goto disconnect;
-        } 
+        }
 
         /* prepare samr_ChangePasswordUser2 */
@@ -134 +137 @@
 
         /* 3. try samr_ChangePasswordUser2 */
-        status = dcerpc_samr_ChangePasswordUser2(c.out.dcerpc_pipe, mem_ctx, &pw2);
-        if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
+        status = dcerpc_samr_ChangePasswordUser2_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &pw2);
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
+                if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(pw2.out.result)) {
+                        status = pw2.out.result;
+                }
                 if (!NT_STATUS_IS_OK(status)) {
                         r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -160 +166 @@
 
         /* 4. try samr_OemChangePasswordUser2 */
-        status = dcerpc_samr_OemChangePasswordUser2(c.out.dcerpc_pipe, mem_ctx, &oe2);
-        if (!NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
+        status = dcerpc_samr_OemChangePasswordUser2_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &oe2);
+        if (!NT_STATUS_EQUAL(status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
+                if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(oe2.out.result)) {
+                        status = oe2.out.result;
+                }
                 if (!NT_STATUS_IS_OK(oe2.out.result)) {
                         r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -194 +203 @@
 
         /* 5. try samr_ChangePasswordUser */
-        status = dcerpc_samr_ChangePasswordUser(c.pdc.out.dcerpc_pipe, mem_ctx, &pw);
+        status = dcerpc_samr_ChangePasswordUser_r(c.pdc.out.dcerpc_pipe->binding_handle, mem_ctx, &pw);
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -217 +226 @@
 disconnect:
         /* close connection */
-        talloc_free(c.out.dcerpc_pipe);
+        talloc_unlink(ctx, c.out.dcerpc_pipe);
 
         return status;
@@ -300 +309 @@
         
         /* 7. try samr_SetUserInfo2 level 26 to set the password */
-        status = dcerpc_samr_SetUserInfo2(r->samr_handle.in.dcerpc_pipe, mem_ctx, &sui);
+        status = dcerpc_samr_SetUserInfo2_r(r->samr_handle.in.dcerpc_pipe->binding_handle, mem_ctx, &sui);
         /* check result of samr_SetUserInfo2 level 26 */
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(sui.out.result)) {
+                status = sui.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr_handle.out.error_string
@@ -354 +366 @@
 
         /* 8. try samr_SetUserInfo2 level 25 to set the password */
-        status = dcerpc_samr_SetUserInfo2(r->samr_handle.in.dcerpc_pipe, mem_ctx, &sui);
+        status = dcerpc_samr_SetUserInfo2_r(r->samr_handle.in.dcerpc_pipe->binding_handle, mem_ctx, &sui);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(sui.out.result)) {
+                status = sui.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr_handle.out.error_string
@@ -395 +410 @@
 
         /* 9. try samr_SetUserInfo2 level 24 to set the password */
-        status = dcerpc_samr_SetUserInfo2(r->samr_handle.in.dcerpc_pipe, mem_ctx, &sui);
+        status = dcerpc_samr_SetUserInfo2_r(r->samr_handle.in.dcerpc_pipe->binding_handle, mem_ctx, &sui);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(sui.out.result)) {
+                status = sui.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr_handle.out.error_string
@@ -438 +456 @@
 
         /* 10. try samr_SetUserInfo2 level 23 to set the password */
-        status = dcerpc_samr_SetUserInfo2(r->samr_handle.in.dcerpc_pipe, mem_ctx, &sui);
+        status = dcerpc_samr_SetUserInfo2_r(r->samr_handle.in.dcerpc_pipe->binding_handle, mem_ctx, &sui);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(sui.out.result)) {
+                status = sui.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr_handle.out.error_string
@@ -464 +485 @@
                 LIBNET_SET_PASSWORD_SAMR_HANDLE_23,
         };
-        int i;
+        unsigned int i;
 
         for (i=0; i < ARRAY_SIZE(levels); i++) {
@@ -471 +492 @@
                 if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_INFO_CLASS)
                     || NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER_MIX)
-                    || NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
+                    || NT_STATUS_EQUAL(status, NT_STATUS_RPC_ENUM_VALUE_OUT_OF_RANGE)) {
                         /* Try another password set mechanism */
                         continue;
@@ -530 +551 @@
 
         /* 2. do a samr_Connect to get a policy handle */
-        status = dcerpc_samr_Connect(c.out.dcerpc_pipe, mem_ctx, &sc);
+        status = dcerpc_samr_Connect_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &sc);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(sc.out.result)) {
+                status = sc.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -545 +569 @@
 
         /* 3. do a samr_LookupDomain to get the domain sid */
-        status = dcerpc_samr_LookupDomain(c.out.dcerpc_pipe, mem_ctx, &ld);
+        status = dcerpc_samr_LookupDomain_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &ld);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ld.out.result)) {
+                status = ld.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -561 +588 @@
 
         /* 4. do a samr_OpenDomain to get a domain handle */
-        status = dcerpc_samr_OpenDomain(c.out.dcerpc_pipe, mem_ctx, &od);
+        status = dcerpc_samr_OpenDomain_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &od);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(od.out.result)) {
+                status = od.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -582 +612 @@
 
         /* 5. do a samr_LookupNames to get the users rid */
-        status = dcerpc_samr_LookupNames(c.out.dcerpc_pipe, mem_ctx, &ln);
+        status = dcerpc_samr_LookupNames_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &ln);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ln.out.result)) {
+                status = ln.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -607 +640 @@
 
         /* 6. do a samr_OpenUser to get a user handle */
-        status = dcerpc_samr_OpenUser(c.out.dcerpc_pipe, mem_ctx, &ou);
+        status = dcerpc_samr_OpenUser_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &ou);
+        if (NT_STATUS_IS_OK(status) && !NT_STATUS_IS_OK(ou.out.result)) {
+                status = ou.out.result;
+        }
         if (!NT_STATUS_IS_OK(status)) {
                 r->samr.out.error_string = talloc_asprintf(mem_ctx,
@@ -628 +664 @@
 disconnect:
         /* close connection */
-        talloc_free(c.out.dcerpc_pipe);
+        talloc_unlink(ctx, c.out.dcerpc_pipe);
 
         return status;

vendor/current/source4/libnet/libnet_rpc.c

@@ -23 +23 @@
 #include "libcli/libcli.h"
 #include "libcli/composite/composite.h"
-#include "librpc/rpc/dcerpc.h"
 #include "librpc/rpc/dcerpc_proto.h"
 #include "librpc/gen_ndr/ndr_lsa_c.h"
@@ -111 +110 @@
         case LIBNET_RPC_CONNECT_SERVER_ADDRESS:
                 b->flags = r->in.dcerpc_flags;
+        }
+
+        if (DEBUGLEVEL >= 10) {
+                b->flags |= DCERPC_DEBUG_PRINT_BOTH;
         }
 
@@ -225 +228 @@
 
 
-static void continue_lookup_dc(struct composite_context *ctx);
+static void continue_lookup_dc(struct tevent_req *req);
 static void continue_rpc_connect(struct composite_context *ctx);
 
@@ -245 +248 @@
         struct composite_context *c;
         struct rpc_connect_dc_state *s;
-        struct composite_context *lookup_dc_req;
+        struct tevent_req *lookup_dc_req;
 
         /* composite context allocation and setup */
@@ -282 +285 @@
         if (composite_nomem(lookup_dc_req, c)) return c;
 
-        composite_continue(c, lookup_dc_req, continue_lookup_dc, c);
+        tevent_req_set_callback(lookup_dc_req, continue_lookup_dc, c);
         return c;
 }
@@ -291 +294 @@
   initiate RpcConnect to it
 */
-static void continue_lookup_dc(struct composite_context *ctx)
+static void continue_lookup_dc(struct tevent_req *req)
 {
         struct composite_context *c;
@@ -298 +301 @@
         struct monitor_msg msg;
         struct msg_net_lookup_dc data;
-        
-        c = talloc_get_type(ctx->async.private_data, struct composite_context);
-        s = talloc_get_type(c->private_data, struct rpc_connect_dc_state);
+
+        c = tevent_req_callback_data(req, struct composite_context);
+        s = talloc_get_type_abort(c->private_data, struct rpc_connect_dc_state);
         
         /* receive result of domain controller lookup */
-        c->status = libnet_LookupDCs_recv(ctx, c, &s->f);
+        c->status = libnet_LookupDCs_recv(req, c, &s->f);
         if (!composite_is_ok(c)) return;
 
@@ -455 +458 @@
 
 static void continue_dci_rpc_connect(struct composite_context *ctx);
-static void continue_lsa_policy(struct rpc_request *req);
-static void continue_lsa_query_info(struct rpc_request *req);
-static void continue_lsa_query_info2(struct rpc_request *req);
+static void continue_lsa_policy(struct tevent_req *subreq);
+static void continue_lsa_query_info(struct tevent_req *subreq);
+static void continue_lsa_query_info2(struct tevent_req *subreq);
 static void continue_epm_map_binding(struct composite_context *ctx);
 static void continue_secondary_conn(struct composite_context *ctx);
@@ -529 +532 @@
         struct composite_context *c;
         struct rpc_connect_dci_state *s;
-        struct rpc_request *open_pol_req;
+        struct tevent_req *subreq;
 
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -574 +577 @@
         s->lsa_open_policy.out.handle     = &s->lsa_handle;
 
-        open_pol_req = dcerpc_lsa_OpenPolicy2_send(s->lsa_pipe, c, &s->lsa_open_policy);
-        if (composite_nomem(open_pol_req, c)) return;
-
-        composite_continue_rpc(c, open_pol_req, continue_lsa_policy, c);
+        subreq = dcerpc_lsa_OpenPolicy2_r_send(s, c->event_ctx,
+                                               s->lsa_pipe->binding_handle,
+                                               &s->lsa_open_policy);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_lsa_policy, c);
 }
 
@@ -585 +590 @@
   for kerberos realm (dns name) and guid. The query may fail.
 */
-static void continue_lsa_policy(struct rpc_request *req)
+static void continue_lsa_policy(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct rpc_connect_dci_state *s;
-        struct rpc_request *query_info_req;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_lsa_OpenPolicy2_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(c->status)) {
                 composite_error(c, c->status);
@@ -631 +636 @@
         if (composite_nomem(s->lsa_query_info2.out.info, c)) return;
 
-        query_info_req = dcerpc_lsa_QueryInfoPolicy2_send(s->lsa_pipe, c, &s->lsa_query_info2);
-        if (composite_nomem(query_info_req, c)) return;
-
-        composite_continue_rpc(c, query_info_req, continue_lsa_query_info2, c);
+        subreq = dcerpc_lsa_QueryInfoPolicy2_r_send(s, c->event_ctx,
+                                                    s->lsa_pipe->binding_handle,
+                                                    &s->lsa_query_info2);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_lsa_query_info2, c);
 }
 
@@ -642 +649 @@
   may result in failure) and query lsa info for domain name and sid.
 */
-static void continue_lsa_query_info2(struct rpc_request *req)
+static void continue_lsa_query_info2(struct tevent_req *subreq)
 {       
         struct composite_context *c;
         struct rpc_connect_dci_state *s;
-        struct rpc_request *query_info_req;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_lsa_QueryInfoPolicy2_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         
         /* In case of error just null the realm and guid and proceed
@@ -657 +664 @@
            controller we talking to - NT-style PDC also counts */
 
-        if (NT_STATUS_EQUAL(c->status, NT_STATUS_NET_WRITE_FAULT)) {
+        if (NT_STATUS_EQUAL(c->status, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE)) {
                 s->r.out.realm = NULL;
                 s->r.out.guid  = NULL;
@@ -706 +713 @@
         if (composite_nomem(s->lsa_query_info.out.info, c)) return;
 
-        query_info_req = dcerpc_lsa_QueryInfoPolicy_send(s->lsa_pipe, c, &s->lsa_query_info);
-        if (composite_nomem(query_info_req, c)) return;
-
-        composite_continue_rpc(c, query_info_req, continue_lsa_query_info, c);
+        subreq = dcerpc_lsa_QueryInfoPolicy_r_send(s, c->event_ctx,
+                                                   s->lsa_pipe->binding_handle,
+                                                   &s->lsa_query_info);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_lsa_query_info, c);
 }
 
@@ -716 +725 @@
   Step 5 of RpcConnectDCInfo: Get domain name and sid
 */
-static void continue_lsa_query_info(struct rpc_request *req)
+static void continue_lsa_query_info(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct rpc_connect_dci_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct rpc_connect_dci_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_lsa_QueryInfoPolicy_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!NT_STATUS_IS_OK(c->status)) {
                 s->r.out.error_string = talloc_asprintf(c,
@@ -763 +773 @@
 
         /* prepare to get endpoint mapping for the requested interface */
-        s->final_binding = talloc(s, struct dcerpc_binding);
+        s->final_binding = talloc_zero(s, struct dcerpc_binding);
         if (composite_nomem(s->final_binding, c)) return;
         
@@ -885 +895 @@
                 if (r->in.dcerpc_iface == &ndr_table_samr) {
                         ctx->samr.pipe = talloc_reference(ctx, r->out.dcerpc_pipe);
+                        ctx->samr.samr_handle = ctx->samr.pipe->binding_handle;
 
                 } else if (r->in.dcerpc_iface == &ndr_table_lsarpc) {
                         ctx->lsa.pipe = talloc_reference(ctx, r->out.dcerpc_pipe);
+                        ctx->lsa.lsa_handle = ctx->lsa.pipe->binding_handle;
                 }
 

vendor/current/source4/libnet/libnet_samdump.c

@@ -186 +186 @@
                                 continue;
                         }
-                        if (!convert_string_talloc_convenience(mem_ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF16, CH_UNIX, 
+                        if (!convert_string_talloc_convenience(mem_ctx, lpcfg_iconv_convenience(ctx->lp_ctx), CH_UTF16, CH_UNIX,
                                                   s->secret.data, s->secret.length, 
                                                   (void **)&secret_string, NULL, false)) {

vendor/current/source4/libnet/libnet_samsync.c

@@ -27 +27 @@
 #include "auth/gensec/gensec.h"
 #include "auth/credentials/credentials.h"
-#include "auth/gensec/schannel_proto.h"
+#include "libcli/auth/schannel.h"
 #include "librpc/gen_ndr/ndr_netlogon.h"
 #include "librpc/gen_ndr/ndr_netlogon_c.h"
@@ -46 +46 @@
         struct libnet_SamSync_state *state;
         const enum netr_SamDatabaseID database_ids[] = {SAM_DATABASE_DOMAIN, SAM_DATABASE_BUILTIN, SAM_DATABASE_PRIVS}; 
-        int i;
+        unsigned int i;
 
         samsync_ctx = talloc_named(mem_ctx, 0, "SamSync top context");
@@ -210 +210 @@
                 
                 do {
-                        int d;
+                        uint32_t d;
                         loop_ctx = talloc_named(samsync_ctx, 0, "DatabaseSync loop context");
                         netlogon_creds_client_authenticator(creds, &credential);
@@ -216 +216 @@
                         dbsync.in.credential = &credential;
                         
-                        dbsync_nt_status = dcerpc_netr_DatabaseSync(p, loop_ctx, &dbsync);
+                        dbsync_nt_status = dcerpc_netr_DatabaseSync_r(p->binding_handle, loop_ctx, &dbsync);
+                        if (NT_STATUS_IS_OK(dbsync_nt_status) && !NT_STATUS_IS_OK(dbsync.out.result)) {
+                                dbsync_nt_status = dbsync.out.result;
+                        }
                         if (!NT_STATUS_IS_OK(dbsync_nt_status) &&
                             !NT_STATUS_EQUAL(dbsync_nt_status, STATUS_MORE_ENTRIES)) {

vendor/current/source4/libnet/libnet_samsync_ldb.c

@@ -32 +32 @@
 #include "ldb_wrap.h"
 #include "libcli/security/security.h"
-#include "librpc/rpc/dcerpc.h"
 #include "param/param.h"
 
@@ -53 +52 @@
 
         struct dom_sid *dom_sid[3];
-        struct ldb_context *sam_ldb, *remote_ldb;
+        struct ldb_context *sam_ldb, *remote_ldb, *pdb;
         struct ldb_dn *base_dn[3];
         struct samsync_ldb_secret *secrets;
         struct samsync_ldb_trusted_domain *trusted_domains;
 };
+
+/* This wrapper is needed for the "ADD_OR_DEL" macros */
+static int samdb_msg_add_string(struct ldb_context *sam_ldb,
+                                TALLOC_CTX *mem_ctx, struct ldb_message *msg,
+                                const char *attr_name, const char *str)
+{
+        return ldb_msg_add_string(msg, attr_name, str);
+}
 
 static NTSTATUS samsync_ldb_add_foreignSecurityPrincipal(TALLOC_CTX *mem_ctx,
@@ -95 +102 @@
                 return NT_STATUS_UNSUCCESSFUL;
         
-        samdb_msg_add_string(state->sam_ldb, mem_ctx, msg,
-                             "objectClass",
-                             "foreignSecurityPrincipal");
+        ldb_msg_add_string(msg, "objectClass", "foreignSecurityPrincipal");
 
         *fsp_dn = msg->dn;
@@ -103 +108 @@
         /* create the alias */
         ret = ldb_add(state->sam_ldb, msg);
-        if (ret != 0) {
+        if (ret != LDB_SUCCESS) {
                 *error_string = talloc_asprintf(mem_ctx, "Failed to create foreignSecurityPrincipal "
                                                 "record %s: %s",
@@ -167 +172 @@
 
                 if (state->samsync_state->domain_guid) {
-                        enum ndr_err_code ndr_err;
                         struct ldb_val v;
-                        ndr_err = ndr_push_struct_blob(&v, msg, NULL, 
-                                                       state->samsync_state->domain_guid,
-                                                         (ndr_push_flags_fn_t)ndr_push_GUID);
-                        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        NTSTATUS status;
+                        status = GUID_to_ndr_blob(state->samsync_state->domain_guid, msg, &v);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 *error_string = talloc_asprintf(mem_ctx, "ndr_push of domain GUID failed!");
-                                return ndr_map_error2ntstatus(ndr_err);
+                                return status;
                         }
                         
@@ -198 +201 @@
         }
 
-        samdb_msg_add_string(state->sam_ldb, mem_ctx, 
-                             msg, "oEMInformation", domain->oem_information.string);
+        ldb_msg_add_string(msg, "oEMInformation",
+                           domain->oem_information.string);
 
         samdb_msg_add_int64(state->sam_ldb, mem_ctx, 
@@ -225 +228 @@
         /* TODO: Account lockout, password properties */
         
-        ret = samdb_replace(state->sam_ldb, mem_ctx, msg);
-
-        if (ret) {
-                return NT_STATUS_INTERNAL_ERROR;
+        ret = dsdb_replace(state->sam_ldb, msg, 0);
+        if (ret != LDB_SUCCESS) {
+                *error_string = talloc_asprintf(mem_ctx,
+                                                "Failed to modify domain record %s: %s",
+                                                ldb_dn_get_linearized(msg->dn),
+                                                ldb_errstring(state->sam_ldb));
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
         return NT_STATUS_OK;
@@ -248 +254 @@
         struct ldb_message **msgs;
         struct ldb_message **remote_msgs = NULL;
-        int ret, i;
+        unsigned int i;
+        int ret;
         uint32_t acb;
         bool add = false;
@@ -311 +318 @@
                         /* Try to put things in the same location as the remote server */
                 } else if (add) {
-                        msg->dn = remote_msgs[0]->dn;
-                        talloc_steal(msg, remote_msgs[0]->dn);
+                        msg->dn = talloc_steal(msg, remote_msgs[0]->dn);
                 }
         }
@@ -363 +369 @@
         } 
         
-        if (!add) {
-                /* Passwords.  Ensure there is no plaintext stored against
-                 * this entry, as we only have hashes */
-                samdb_msg_add_delete(state->sam_ldb, mem_ctx, msg,  
-                                     "userPassword"); 
-        }
         if (user->lm_password_present) {
                 samdb_msg_add_hash(state->sam_ldb, mem_ctx, msg,  
@@ -425 +425 @@
         }
         if (add) {
-                samdb_msg_add_string(state->sam_ldb, mem_ctx, msg, 
-                                     "objectClass", obj_class);
+                ldb_msg_add_string(msg, "objectClass", obj_class);
                 if (!msg->dn) {
                         msg->dn = ldb_dn_copy(mem_ctx, state->base_dn[database]);
@@ -436 +435 @@
 
                 ret = ldb_add(state->sam_ldb, msg);
-                if (ret != 0) {
+                if (ret != LDB_SUCCESS) {
                         struct ldb_dn *first_try_dn = msg->dn;
                         /* Try again with the default DN */
@@ -447 +446 @@
                                 msg->dn = talloc_steal(msg, remote_msgs[0]->dn);
                                 ret = ldb_add(state->sam_ldb, msg);
-                                if (ret != 0) {
+                                if (ret != LDB_SUCCESS) {
                                         *error_string = talloc_asprintf(mem_ctx, "Failed to create user record.  Tried both %s and %s: %s",
                                                                         ldb_dn_get_linearized(first_try_dn),
@@ -457 +456 @@
                 }
         } else {
-                ret = samdb_replace(state->sam_ldb, mem_ctx, msg);
-                if (ret != 0) {
+                ret = dsdb_replace(state->sam_ldb, msg, 0);
+                if (ret != LDB_SUCCESS) {
                         *error_string = talloc_asprintf(mem_ctx, "Failed to modify user record %s: %s",
                                                         ldb_dn_get_linearized(msg->dn),
@@ -500 +499 @@
 
         ret = ldb_delete(state->sam_ldb, msgs[0]->dn);
-        if (ret != 0) {
+        if (ret != LDB_SUCCESS) {
                 *error_string = talloc_asprintf(mem_ctx, "Failed to delete user record %s: %s",
                                                 ldb_dn_get_linearized(msgs[0]->dn),
@@ -580 +579 @@
 
         if (add) {
-                samdb_msg_add_string(state->sam_ldb, mem_ctx, msg, 
-                                     "objectClass", obj_class);
+                ldb_msg_add_string(msg, "objectClass", obj_class);
                 msg->dn = ldb_dn_copy(mem_ctx, state->base_dn[database]);
                 ldb_dn_add_child_fmt(msg->dn, "CN=%s,CN=%s", cn_name, container);
@@ -589 +587 @@
 
                 ret = ldb_add(state->sam_ldb, msg);
-                if (ret != 0) {
+                if (ret != LDB_SUCCESS) {
                         *error_string = talloc_asprintf(mem_ctx, "Failed to create group record %s: %s",
                                                         ldb_dn_get_linearized(msg->dn),
@@ -596 +594 @@
                 }
         } else {
-                ret = samdb_replace(state->sam_ldb, mem_ctx, msg);
-                if (ret != 0) {
+                ret = dsdb_replace(state->sam_ldb, msg, 0);
+                if (ret != LDB_SUCCESS) {
                         *error_string = talloc_asprintf(mem_ctx, "Failed to modify group record %s: %s",
                                                         ldb_dn_get_linearized(msg->dn),
@@ -639 +637 @@
         
         ret = ldb_delete(state->sam_ldb, msgs[0]->dn);
-        if (ret != 0) {
+        if (ret != LDB_SUCCESS) {
                 *error_string = talloc_asprintf(mem_ctx, "Failed to delete group record %s: %s",
                                                 ldb_dn_get_linearized(msgs[0]->dn),
@@ -661 +659 @@
         int ret;
         const char *attrs[] = { NULL };
-        int i;
+        const char *str_dn;
+        uint32_t i;
 
         msg = ldb_msg_new(mem_ctx);
@@ -705 +704 @@
                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
                 } else {
-                        samdb_msg_add_string(state->sam_ldb, mem_ctx, msg, "member", ldb_dn_alloc_linearized(mem_ctx, msgs[0]->dn));
+                        str_dn = ldb_dn_alloc_linearized(msg, msgs[0]->dn);
+                        NT_STATUS_HAVE_NO_MEMORY(str_dn);
+                        ret = ldb_msg_add_string(msg, "member", str_dn);
+                        if (ret != LDB_SUCCESS) return NT_STATUS_NO_MEMORY;
                 }
                 
@@ -711 +713 @@
         }
         
-        ret = samdb_replace(state->sam_ldb, mem_ctx, msg);
-        if (ret != 0) {
+        ret = dsdb_replace(state->sam_ldb, msg, 0);
+        if (ret != LDB_SUCCESS) {
                 *error_string = talloc_asprintf(mem_ctx, "Failed to modify group record %s: %s",
                                                 ldb_dn_get_linearized(msg->dn),
@@ -794 +796 @@
 
         if (add) {
-                samdb_msg_add_string(state->sam_ldb, mem_ctx, msg, 
-                                     "objectClass", obj_class);
+                ldb_msg_add_string(msg, "objectClass", obj_class);
                 msg->dn = ldb_dn_copy(mem_ctx, state->base_dn[database]);
                 ldb_dn_add_child_fmt(msg->dn, "CN=%s,CN=%s", cn_name, container);
@@ -803 +804 @@
 
                 ret = ldb_add(state->sam_ldb, msg);
-                if (ret != 0) {
+                if (ret != LDB_SUCCESS) {
                         *error_string = talloc_asprintf(mem_ctx, "Failed to create alias record %s: %s",
                                                         ldb_dn_get_linearized(msg->dn),
@@ -810 +811 @@
                 }
         } else {
-                ret = samdb_replace(state->sam_ldb, mem_ctx, msg);
-                if (ret != 0) {
+                ret = dsdb_replace(state->sam_ldb, msg, 0);
+                if (ret != LDB_SUCCESS) {
                         *error_string = talloc_asprintf(mem_ctx, "Failed to modify alias record %s: %s",
                                                         ldb_dn_get_linearized(msg->dn),
@@ -848 +849 @@
 
         ret = ldb_delete(state->sam_ldb, msgs[0]->dn);
-        if (ret != 0) {
+        if (ret != LDB_SUCCESS) {
                 *error_string = talloc_asprintf(mem_ctx, "Failed to delete alias record %s: %s",
                                                 ldb_dn_get_linearized(msgs[0]->dn),
@@ -870 +871 @@
         int ret;
         const char *attrs[] = { NULL };
-        int i;
+        uint32_t i;
 
         msg = ldb_msg_new(mem_ctx);
@@ -902 +903 @@
         for (i=0; i<alias_member->sids.num_sids; i++) {
                 struct ldb_dn *alias_member_dn;
+                const char *str_dn;
                 /* search for members, in the top basedn (normal users are builtin aliases) */
                 ret = gendb_search(state->sam_ldb, mem_ctx, state->base_dn[SAM_DATABASE_DOMAIN], &msgs, attrs,
@@ -924 +926 @@
                         alias_member_dn = msgs[0]->dn;
                 }
-                samdb_msg_add_string(state->sam_ldb, mem_ctx, msg, "member", ldb_dn_alloc_linearized(mem_ctx, alias_member_dn));
+                str_dn = ldb_dn_alloc_linearized(msg, alias_member_dn);
+                NT_STATUS_HAVE_NO_MEMORY(str_dn);
+                ret = ldb_msg_add_string(msg, "member", str_dn);
+                if (ret != LDB_SUCCESS) return NT_STATUS_NO_MEMORY;
         
                 talloc_free(msgs);
         }
 
-        ret = samdb_replace(state->sam_ldb, mem_ctx, msg);
-        if (ret != 0) {
+        ret = dsdb_replace(state->sam_ldb, msg, 0);
+        if (ret != LDB_SUCCESS) {
                 *error_string = talloc_asprintf(mem_ctx, "Failed to modify group record %s: %s",
                                                 ldb_dn_get_linearized(msg->dn),
@@ -950 +955 @@
 
         struct ldb_message *msg;
-        struct ldb_message **msgs;
-        struct ldb_dn *privilege_dn;
         int ret;
-        const char *attrs[] = { NULL };
-        int i;
+        uint32_t i;
+        char *dnstr, *sidstr;
 
         msg = ldb_msg_new(mem_ctx);
@@ -961 +964 @@
         }
 
-        /* search for the account, by sid, in the top basedn */
-        ret = gendb_search(state->sam_ldb, mem_ctx, state->base_dn[SAM_DATABASE_DOMAIN], &msgs, attrs,
-                           "(objectSid=%s)", ldap_encode_ndr_dom_sid(mem_ctx, sid)); 
-
-        if (ret == -1) {
-                *error_string = talloc_asprintf(mem_ctx, "gendb_search failed: %s", ldb_errstring(state->sam_ldb));
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        } else if (ret == 0) {
-                NTSTATUS nt_status;
-                nt_status = samsync_ldb_add_foreignSecurityPrincipal(mem_ctx, state,
-                                                                     sid,
-                                                                     &privilege_dn,
-                                                                     error_string);
-                privilege_dn = talloc_steal(msg, privilege_dn);
-                if (!NT_STATUS_IS_OK(nt_status)) {
-                        return nt_status;
-                }
-        } else if (ret > 1) {
-                *error_string = talloc_asprintf(mem_ctx, "More than one account with SID: %s", 
-                                                dom_sid_string(mem_ctx, sid));
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        } else {
-                privilege_dn = talloc_steal(msg, msgs[0]->dn);
-        }
-
-        msg->dn = privilege_dn;
+        sidstr = dom_sid_string(msg, sid);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(sidstr, msg);
+
+        dnstr = talloc_asprintf(msg, "sid=%s", sidstr);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(dnstr, msg);
+
+        msg->dn = ldb_dn_new(msg, state->pdb, dnstr);
+        NT_STATUS_HAVE_NO_MEMORY_AND_FREE(msg->dn, msg);
 
         for (i=0; i< account->privilege_entries; i++) {
-                samdb_msg_add_string(state->sam_ldb, mem_ctx, msg, "privilege",
-                                     account->privilege_name[i].string);
-        }
-
-        ret = samdb_replace(state->sam_ldb, mem_ctx, msg);
-        if (ret != 0) {
+                ldb_msg_add_string(msg, "privilege", account->privilege_name[i].string);
+        }
+
+        ret = dsdb_replace(state->pdb, msg, 0);
+        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                if (samdb_msg_add_dom_sid(state->pdb, msg, msg, "objectSid", sid) != LDB_SUCCESS) {
+                        talloc_free(msg);
+                        return NT_STATUS_NO_MEMORY;
+                }
+                ldb_msg_add_string(msg, "comment", "added via samsync");
+                ret = ldb_add(state->pdb, msg);         
+        }
+
+        if (ret != LDB_SUCCESS) {
                 *error_string = talloc_asprintf(mem_ctx, "Failed to modify privilege record %s",
                                                 ldb_dn_get_linearized(msg->dn));
@@ -1042 +1035 @@
                              "privilege");
 
-        ret = samdb_replace(state->sam_ldb, mem_ctx, msg);
-        if (ret != 0) {
+        ret = dsdb_replace(state->sam_ldb, msg, 0);
+        if (ret != LDB_SUCCESS) {
                 *error_string = talloc_asprintf(mem_ctx, "Failed to modify privilege record %s",
                                                 ldb_dn_get_linearized(msg->dn));
@@ -1199 +1192 @@
                 
                 state->remote_ldb = ldb_wrap_connect(mem_ctx, 
-                                                     state->samsync_state->machine_net_ctx->event_ctx,
-                                                     state->samsync_state->machine_net_ctx->lp_ctx, 
+                                                     NULL,
+                                                     state->samsync_state->machine_net_ctx->lp_ctx,
                                                      ldap_url, 
                                                      NULL, state->samsync_state->machine_net_ctx->cred,
-                                                     0, NULL);
+                                                     0);
                 if (!state->remote_ldb) {
                         *error_string = talloc_asprintf(mem_ctx, "Failed to connect to remote LDAP server at %s (used to extract additional data in SamSync replication)", ldap_url);
@@ -1229 +1222 @@
         state->sam_ldb         = samdb_connect(mem_ctx, 
                                                ctx->event_ctx,
-                                               ctx->lp_ctx, 
-                                               r->in.session_info);
+                                               ctx->lp_ctx,
+                                               r->in.session_info,
+                                                   0);
+        if (!state->sam_ldb) {
+                return NT_STATUS_INTERNAL_DB_ERROR;
+        }
+
+        state->pdb             = privilege_connect(mem_ctx, 
+                                                   ctx->lp_ctx);
+        if (!state->pdb) {
+                return NT_STATUS_INTERNAL_DB_ERROR;
+        }
 
         r2.out.error_string    = NULL;

vendor/current/source4/libnet/libnet_share.c

@@ -90 +90 @@
         s.out.totalentries = &totalentries;
 
-        status = dcerpc_srvsvc_NetShareEnumAll(c.out.dcerpc_pipe, mem_ctx, &s);
+        status = dcerpc_srvsvc_NetShareEnumAll_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &s);
         
         if (!NT_STATUS_IS_OK(status)) {
@@ -145 +145 @@
         s.in.server_unc         = talloc_asprintf(mem_ctx, "\\\\%s", r->in.server_name);
  
-        status = dcerpc_srvsvc_NetShareAdd(c.out.dcerpc_pipe, mem_ctx, &s);     
+        status = dcerpc_srvsvc_NetShareAdd_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &s);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -193 +193 @@
         s.in.share_name = r->in.share_name;
 
-        status = dcerpc_srvsvc_NetShareDel(c.out.dcerpc_pipe, mem_ctx, &s);
+        status = dcerpc_srvsvc_NetShareDel_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &s);
         if (!NT_STATUS_IS_OK(status)) {
                 r->out.error_string = talloc_asprintf(mem_ctx,

vendor/current/source4/libnet/libnet_site.c

@@ -21 +21 @@
 #include "libnet/libnet.h"
 #include "libcli/cldap/cldap.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
-#include "librpc/rpc/dcerpc.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "libcli/resolve/resolve.h"
 #include "param/param.h"
+#include "lib/tsocket/tsocket.h"
 
 /**
@@ -42 +42 @@
         struct cldap_socket *cldap = NULL;
         struct cldap_netlogon search;
+        int ret;
+        struct tsocket_address *dest_address;
 
         tmp_ctx = talloc_named(ctx, 0, "libnet_FindSite temp context");
@@ -51 +53 @@
         /* Resolve the site name. */
         ZERO_STRUCT(search);
-        search.in.dest_address = r->in.dest_address;
-        search.in.dest_port = r->in.cldap_port;
+        search.in.dest_address = NULL;
+        search.in.dest_port = 0;
         search.in.acct_control = -1;
         search.in.version = NETLOGON_NT_VERSION_5 | NETLOGON_NT_VERSION_5EX;
         search.in.map_response = true;
 
+        ret = tsocket_address_inet_from_strings(tmp_ctx, "ip",
+                                                r->in.dest_address,
+                                                r->in.cldap_port,
+                                                &dest_address);
+        if (ret != 0) {
+                r->out.error_string = NULL;
+                status = map_nt_error_from_unix(errno);
+                return status;
+        }
+
         /* we want to use non async calls, so we're not passing an event context */
-        status = cldap_socket_init(tmp_ctx, NULL, NULL, NULL, &cldap);//TODO
+        status = cldap_socket_init(tmp_ctx, NULL, NULL, dest_address, &cldap);
         if (!NT_STATUS_IS_OK(status)) {
                 talloc_free(tmp_ctx);
@@ -64 +76 @@
                 return status;
         }
-        status = cldap_netlogon(cldap, lp_iconv_convenience(lctx->lp_ctx), tmp_ctx, &search);
+        status = cldap_netlogon(cldap, tmp_ctx, &search);
         if (!NT_STATUS_IS_OK(status)
             || !search.out.netlogon.data.nt5_ex.client_site) {
@@ -157 +169 @@
 
         make_nbt_name_client(&name, libnet_r->out.samr_binding->host);
-        status = resolve_name(lp_resolve_context(ctx->lp_ctx), &name, r, &dest_addr, ctx->event_ctx);
+        status = resolve_name(lpcfg_resolve_context(ctx->lp_ctx), &name, r, &dest_addr, ctx->event_ctx);
         if (!NT_STATUS_IS_OK(status)) {
                 libnet_r->out.error_string = NULL;
@@ -168 +180 @@
         r->in.netbios_name = libnet_r->in.netbios_name;
         r->in.domain_dn_str = libnet_r->out.domain_dn_str;
-        r->in.cldap_port = lp_cldap_port(ctx->lp_ctx);
+        r->in.cldap_port = lpcfg_cldap_port(ctx->lp_ctx);
 
         status = libnet_FindSite(tmp_ctx, ctx, r);
@@ -192 +204 @@
 
         rtn = ldb_msg_add_string(msg, "objectClass", "server");
-        if (rtn != 0) {
+        if (rtn != LDB_SUCCESS) {
                 libnet_r->out.error_string = NULL;
                 talloc_free(tmp_ctx);
@@ -198 +210 @@
         }
         rtn = ldb_msg_add_string(msg, "systemFlags", "50000000");
-        if (rtn != 0) {
+        if (rtn != LDB_SUCCESS) {
                 libnet_r->out.error_string = NULL;
                 talloc_free(tmp_ctx);
@@ -204 +216 @@
         }
         rtn = ldb_msg_add_string(msg, "serverReference", libnet_r->out.account_dn_str);
-        if (rtn != 0) {
+        if (rtn != LDB_SUCCESS) {
                 libnet_r->out.error_string = NULL;
                 talloc_free(tmp_ctx);
@@ -223 +235 @@
         rtn = ldb_add(remote_ldb, msg);
         if (rtn == LDB_ERR_ENTRY_ALREADY_EXISTS) {
-                int i;
+                unsigned int i;
 
                 /* make a 'modify' msg, and only for serverReference */
@@ -235 +247 @@
 
                 rtn = ldb_msg_add_string(msg, "serverReference",libnet_r->out.account_dn_str);
-                if (rtn != 0) {
+                if (rtn != LDB_SUCCESS) {
                         libnet_r->out.error_string = NULL;
                         talloc_free(tmp_ctx);
@@ -248 +260 @@
 
                 rtn = ldb_modify(remote_ldb, msg);
-                if (rtn != 0) {
+                if (rtn != LDB_SUCCESS) {
                         libnet_r->out.error_string
                                 = talloc_asprintf(libnet_r,
@@ -257 +269 @@
                         return NT_STATUS_INTERNAL_DB_CORRUPTION;
                 }
-        } else if (rtn != 0) {
+        } else if (rtn != LDB_SUCCESS) {
                 libnet_r->out.error_string
                         = talloc_asprintf(libnet_r,

vendor/current/source4/libnet/libnet_time.c

@@ -55 +55 @@
 
         /* 2. try srvsvc_NetRemoteTOD */
-        status = dcerpc_srvsvc_NetRemoteTOD(c.out.dcerpc_pipe, mem_ctx, &tod);
+        status = dcerpc_srvsvc_NetRemoteTOD_r(c.out.dcerpc_pipe->binding_handle, mem_ctx, &tod);
         if (!NT_STATUS_IS_OK(status)) {
                 r->srvsvc.out.error_string = talloc_asprintf(mem_ctx,

vendor/current/source4/libnet/libnet_unbecome_dc.c

@@ -22 +22 @@
 #include "libcli/composite/composite.h"
 #include "libcli/cldap/cldap.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
-#include "lib/ldb_wrap.h"
+#include <ldb.h>
+#include <ldb_errors.h>
+#include "ldb_wrap.h"
 #include "dsdb/samdb/samdb.h"
 #include "../libds/common/flags.h"
 #include "librpc/gen_ndr/ndr_drsuapi_c.h"
 #include "param/param.h"
+#include "lib/tsocket/tsocket.h"
 
 /*****************************************************************************
@@ -204 +205 @@
                 struct dcerpc_binding *binding;
                 struct dcerpc_pipe *pipe;
+                struct dcerpc_binding_handle *drsuapi_handle;
                 struct drsuapi_DsBind bind_r;
                 struct GUID bind_guid;
@@ -257 +259 @@
         struct composite_context *c = s->creq;
         struct tevent_req *req;
-
-        s->cldap.io.in.dest_address     = s->source_dsa.address;
-        s->cldap.io.in.dest_port        = lp_cldap_port(s->libnet->lp_ctx);
+        struct tsocket_address *dest_address;
+        int ret;
+
+        s->cldap.io.in.dest_address     = NULL;
+        s->cldap.io.in.dest_port        = 0;
         s->cldap.io.in.realm            = s->domain.dns_name;
         s->cldap.io.in.host             = s->dest_dsa.netbios_name;
@@ -269 +273 @@
         s->cldap.io.in.map_response     = true;
 
+        ret = tsocket_address_inet_from_strings(s, "ip",
+                                                s->source_dsa.address,
+                                                lpcfg_cldap_port(s->libnet->lp_ctx),
+                                                &dest_address);
+        if (ret != 0) {
+                c->status = map_nt_error_from_unix(errno);
+                if (!composite_is_ok(c)) return;
+        }
+
         c->status = cldap_socket_init(s, s->libnet->event_ctx,
-                                      NULL, NULL, &s->cldap.sock);//TODO
+                                      NULL, dest_address, &s->cldap.sock);
         if (!composite_is_ok(c)) return;
 
@@ -286 +299 @@
         struct composite_context *c = s->creq;
 
-        c->status = cldap_netlogon_recv(req,
-                                        lp_iconv_convenience(s->libnet->lp_ctx),
-                                        s, &s->cldap.io);
+        c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
         talloc_free(req);
         if (!composite_is_ok(c)) return;
@@ -295 +306 @@
 
         s->domain.dns_name              = s->cldap.netlogon.dns_domain;
-        s->domain.netbios_name          = s->cldap.netlogon.domain;
+        s->domain.netbios_name          = s->cldap.netlogon.domain_name;
         s->domain.guid                  = s->cldap.netlogon.domain_uuid;
 
@@ -317 +328 @@
                                        NULL,
                                        s->libnet->cred,
-                                       0, NULL);
+                                       0);
         talloc_free(url);
         if (s->ldap.ldb == NULL) {
@@ -393 +404 @@
         }
 
-        s->dest_dsa.computer_dn_str     = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
+        s->dest_dsa.computer_dn_str     = ldb_msg_find_attr_as_string(r->msgs[0], "distinguishedName", NULL);
         if (!s->dest_dsa.computer_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
         talloc_steal(s, s->dest_dsa.computer_dn_str);
 
-        s->dest_dsa.user_account_control = samdb_result_uint(r->msgs[0], "userAccountControl", 0);
+        s->dest_dsa.user_account_control = ldb_msg_find_attr_as_uint(r->msgs[0], "userAccountControl", 0);
 
         talloc_free(r);
@@ -408 +419 @@
         struct ldb_message *msg;
         uint32_t user_account_control = UF_WORKSTATION_TRUST_ACCOUNT;
-        uint32_t i;
+        unsigned int i;
 
         /* as the value is already as we want it to be, we're done */
@@ -421 +432 @@
         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
 
-        ret = ldb_msg_add_fmt(msg, "userAccountControl", "%u", user_account_control);
-        if (ret != 0) {
+        ret = samdb_msg_add_uint(s->ldap.ldb, msg, msg, "userAccountControl",
+                                 user_account_control);
+        if (ret != LDB_SUCCESS) {
                 talloc_free(msg);
                 return NT_STATUS_NO_MEMORY;
@@ -556 +568 @@
         if (!composite_is_ok(c)) return;
 
+        s->drsuapi.drsuapi_handle = s->drsuapi.pipe->binding_handle;
+
         unbecomeDC_drsuapi_bind_send(s);
 }
 
-static void unbecomeDC_drsuapi_bind_recv(struct rpc_request *req);
+static void unbecomeDC_drsuapi_bind_recv(struct tevent_req *subreq);
 
 static void unbecomeDC_drsuapi_bind_send(struct libnet_UnbecomeDC_state *s)
 {
         struct composite_context *c = s->creq;
-        struct rpc_request *req;
         struct drsuapi_DsBindInfo28 *bind_info28;
+        struct tevent_req *subreq;
 
         GUID_from_string(DRSUAPI_DS_BIND_GUID, &s->drsuapi.bind_guid);
@@ -582 +596 @@
         s->drsuapi.bind_r.out.bind_handle = &s->drsuapi.bind_handle;
 
-        req = dcerpc_drsuapi_DsBind_send(s->drsuapi.pipe, s, &s->drsuapi.bind_r);
-        composite_continue_rpc(c, req, unbecomeDC_drsuapi_bind_recv, s);
+        subreq = dcerpc_drsuapi_DsBind_r_send(s, c->event_ctx,
+                                              s->drsuapi.drsuapi_handle,
+                                              &s->drsuapi.bind_r);
+        if (composite_nomem(subreq, c)) return;
+        tevent_req_set_callback(subreq, unbecomeDC_drsuapi_bind_recv, s);
 }
 
 static void unbecomeDC_drsuapi_remove_ds_server_send(struct libnet_UnbecomeDC_state *s);
 
-static void unbecomeDC_drsuapi_bind_recv(struct rpc_request *req)
-{
-        struct libnet_UnbecomeDC_state *s = talloc_get_type(req->async.private_data,
+static void unbecomeDC_drsuapi_bind_recv(struct tevent_req *subreq)
+{
+        struct libnet_UnbecomeDC_state *s = tevent_req_callback_data(subreq,
                                             struct libnet_UnbecomeDC_state);
         struct composite_context *c = s->creq;
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_drsuapi_DsBind_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -632 +650 @@
 }
 
-static void unbecomeDC_drsuapi_remove_ds_server_recv(struct rpc_request *req);
+static void unbecomeDC_drsuapi_remove_ds_server_recv(struct tevent_req *subreq);
 
 static void unbecomeDC_drsuapi_remove_ds_server_send(struct libnet_UnbecomeDC_state *s)
 {
         struct composite_context *c = s->creq;
-        struct rpc_request *req;
         struct drsuapi_DsRemoveDSServer *r = &s->drsuapi.rm_ds_srv_r;
+        struct tevent_req *subreq;
 
         r->in.bind_handle       = &s->drsuapi.bind_handle;
@@ -647 +665 @@
         r->in.req->req1.commit  = true;
 
-        r->out.level_out        = talloc(s, int32_t);
+        r->out.level_out        = talloc(s, uint32_t);
         r->out.res              = talloc(s, union drsuapi_DsRemoveDSServerResult);
 
-        req = dcerpc_drsuapi_DsRemoveDSServer_send(s->drsuapi.pipe, s, r);
-        composite_continue_rpc(c, req, unbecomeDC_drsuapi_remove_ds_server_recv, s);
-}
-
-static void unbecomeDC_drsuapi_remove_ds_server_recv(struct rpc_request *req)
-{
-        struct libnet_UnbecomeDC_state *s = talloc_get_type(req->async.private_data,
+        subreq = dcerpc_drsuapi_DsRemoveDSServer_r_send(s, c->event_ctx,
+                                                        s->drsuapi.drsuapi_handle,
+                                                        r);
+        if (composite_nomem(subreq, c)) return;
+        tevent_req_set_callback(subreq, unbecomeDC_drsuapi_remove_ds_server_recv, s);
+}
+
+static void unbecomeDC_drsuapi_remove_ds_server_recv(struct tevent_req *subreq)
+{
+        struct libnet_UnbecomeDC_state *s = tevent_req_callback_data(subreq,
                                             struct libnet_UnbecomeDC_state);
         struct composite_context *c = s->creq;
         struct drsuapi_DsRemoveDSServer *r = &s->drsuapi.rm_ds_srv_r;
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_drsuapi_DsRemoveDSServer_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 

vendor/current/source4/libnet/libnet_user.c

@@ -179 +179 @@
         }
 
+        talloc_free(c);
         return status;
 }
@@ -347 +348 @@
         }
         
+        talloc_free(c);
         return status;
 }
@@ -573 +575 @@
 {
         NTSTATUS status = composite_wait(c);
+
+        talloc_free(c);
         return status;
 }
@@ -869 +873 @@
 
         talloc_free(c);
-        
         return status;
 }
@@ -910 +913 @@
 
 static void continue_lsa_domain_opened(struct composite_context *ctx);
-static void continue_domain_queried(struct rpc_request *req);
+static void continue_domain_queried(struct tevent_req *subreq);
 static void continue_samr_domain_opened(struct composite_context *ctx);
-static void continue_users_enumerated(struct rpc_request *req);
+static void continue_users_enumerated(struct tevent_req *subreq);
 
 
@@ -931 +934 @@
         struct composite_context *c;
         struct userlist_state *s;
-        struct rpc_request *query_req;
+        struct tevent_req *subreq;
         bool prereq_met = false;
 
@@ -962 +965 @@
 
         /* send the request */
-        query_req = dcerpc_lsa_QueryInfoPolicy_send(ctx->lsa.pipe, c, &s->query_domain);
-        if (composite_nomem(query_req, c)) return c;
-
-        composite_continue_rpc(c, query_req, continue_domain_queried, c);
+        subreq = dcerpc_lsa_QueryInfoPolicy_r_send(s, c->event_ctx,
+                                                   ctx->lsa.pipe->binding_handle,
+                                                   &s->query_domain);
+        if (composite_nomem(subreq, c)) return c;
+
+        tevent_req_set_callback(subreq, continue_domain_queried, c);
         return c;
 }
@@ -978 +983 @@
         struct composite_context *c;
         struct userlist_state *s;
-        struct rpc_request *query_req;
+        struct tevent_req *subreq;
         
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -994 +999 @@
 
         /* send the request */
-        query_req = dcerpc_lsa_QueryInfoPolicy_send(s->ctx->lsa.pipe, c, &s->query_domain);
-        if (composite_nomem(query_req, c)) return;
-
-        composite_continue_rpc(c, query_req, continue_domain_queried, c);
+        subreq = dcerpc_lsa_QueryInfoPolicy_r_send(s, c->event_ctx,
+                                                   s->ctx->lsa.pipe->binding_handle,
+                                                   &s->query_domain);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_domain_queried, c);
 }
 
@@ -1005 +1012 @@
  * provided a valid samr handle is opened
  */
-static void continue_domain_queried(struct rpc_request *req)
+static void continue_domain_queried(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct userlist_state *s;
-        struct rpc_request *enum_req;
         bool prereq_met = false;
         
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userlist_state);
 
         /* receive result of rpc request */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_lsa_QueryInfoPolicy_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -1039 +1046 @@
 
         /* send the request */
-        enum_req = dcerpc_samr_EnumDomainUsers_send(s->ctx->samr.pipe, c, &s->user_list);
-        if (composite_nomem(enum_req, c)) return;
-
-        composite_continue_rpc(c, enum_req, continue_users_enumerated, c);
+        subreq = dcerpc_samr_EnumDomainUsers_r_send(s, c->event_ctx,
+                                                    s->ctx->samr.pipe->binding_handle,
+                                                    &s->user_list);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_users_enumerated, c);
 }
 
@@ -1054 +1063 @@
         struct composite_context *c;
         struct userlist_state *s;
-        struct rpc_request *enum_req;
+        struct tevent_req *subreq;
 
         c = talloc_get_type(ctx->async.private_data, struct composite_context);
@@ -1075 +1084 @@
         
         /* send the request */
-        enum_req = dcerpc_samr_EnumDomainUsers_send(s->ctx->samr.pipe, c, &s->user_list);
-        if (composite_nomem(enum_req, c)) return;
-
-        composite_continue_rpc(c, enum_req, continue_users_enumerated, c);
+        subreq = dcerpc_samr_EnumDomainUsers_r_send(s, c->event_ctx,
+                                                    s->ctx->samr.pipe->binding_handle,
+                                                    &s->user_list);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_users_enumerated, c);
 }
 
@@ -1085 +1096 @@
  * Stage 2: receive enumerated users and their rids
  */
-static void continue_users_enumerated(struct rpc_request *req)
+static void continue_users_enumerated(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct userlist_state *s;
-        int i;
-
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        uint32_t i;
+
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userlist_state);
 
         /* receive result of rpc request */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_EnumDomainUsers_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -1127 +1139 @@
                         
                         /* username */
-                        s->users[i].username = talloc_strdup(c, entry->name.string);
+                        s->users[i].username = talloc_strdup(s->users, entry->name.string);
                         if (composite_nomem(s->users[i].username, c)) return;
 
                         /* sid string */
-                        s->users[i].sid = dom_sid_string(c, user_sid);
+                        s->users[i].sid = dom_sid_string(s->users, user_sid);
                         if (composite_nomem(s->users[i].sid, c)) return;
                 }
@@ -1160 +1172 @@
 
         if (c == NULL || mem_ctx == NULL || r == NULL) {
+                talloc_free(c);
                 return NT_STATUS_INVALID_PARAMETER;
         }
-        
+
         status = composite_wait(c);
         if (NT_STATUS_IS_OK(status) ||
@@ -1187 +1200 @@
         }
 
+        talloc_free(c);
         return status;
 }

vendor/current/source4/libnet/libnet_vampire.c

@@ -28 +28 @@
 #include "dsdb/samdb/samdb.h"
 #include "../lib/util/dlinklist.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "librpc/ndr/libndr.h"
 #include "librpc/gen_ndr/ndr_drsuapi.h"
@@ -35 +35 @@
 #include "librpc/gen_ndr/ndr_misc.h"
 #include "system/time.h"
-#include "lib/ldb_wrap.h"
+#include "ldb_wrap.h"
 #include "auth/auth.h"
+#include "auth/credentials/credentials.h"
 #include "param/param.h"
 #include "param/provision.h"
-#include "libcli/security/dom_sid.h"
+#include "libcli/security/security.h"
+#include "dsdb/common/util.h"
 
 /* 
@@ -54 +56 @@
 
 */
-struct vampire_state {
+struct libnet_vampire_cb_state {
         const char *netbios_name;
-        struct libnet_JoinDomain *join;
+        const char *domain_name;
+        const char *realm;
         struct cli_credentials *machine_account;
+
+        /* Schema loaded from local LDIF files */
+        struct dsdb_schema *provision_schema;
+
+        /* 1st pass, with some OIDs/attribute names/class names not
+         * converted, because we may not know them yet */
         struct dsdb_schema *self_made_schema;
+
+        /* prefixMap in LDB format, from the remote DRS server */
+        DATA_BLOB prefixmap_blob;
         const struct dsdb_schema *schema;
 
@@ -75 +87 @@
         unsigned total_objects;
         char *last_partition;
+        const char *server_dn_str;
 };
 
-static NTSTATUS vampire_prepare_db(void *private_data,
-                                              const struct libnet_BecomeDC_PrepareDB *p)
-{
-        struct vampire_state *s = talloc_get_type(private_data, struct vampire_state);
+/* initialise a state structure ready for replication of chunks */
+void *libnet_vampire_replicate_init(TALLOC_CTX *mem_ctx,
+                                    struct ldb_context *samdb,
+                                    struct loadparm_context *lp_ctx)
+{
+        struct libnet_vampire_cb_state *s = talloc_zero(mem_ctx, struct libnet_vampire_cb_state);
+        if (!s) {
+                return NULL;
+        }
+
+        s->ldb              = samdb;
+        s->lp_ctx           = lp_ctx;
+        s->provision_schema = dsdb_get_schema(s->ldb, s);
+        s->schema           = s->provision_schema;
+        s->netbios_name     = lpcfg_netbios_name(lp_ctx);
+        s->domain_name      = lpcfg_workgroup(lp_ctx);
+        s->realm            = lpcfg_realm(lp_ctx);
+
+        return s;
+}
+
+/* Caller is expected to keep supplied pointers around for the lifetime of the structure */
+void *libnet_vampire_cb_state_init(TALLOC_CTX *mem_ctx,
+                                   struct loadparm_context *lp_ctx, struct tevent_context *event_ctx,
+                                   const char *netbios_name, const char *domain_name, const char *realm,
+                                   const char *targetdir)
+{
+        struct libnet_vampire_cb_state *s = talloc_zero(mem_ctx, struct libnet_vampire_cb_state);
+        if (!s) {
+                return NULL;
+        }
+
+        s->lp_ctx = lp_ctx;
+        s->event_ctx = event_ctx;
+        s->netbios_name = netbios_name;
+        s->domain_name = domain_name;
+        s->realm = realm;
+        s->targetdir = targetdir;
+        return s;
+}
+
+struct ldb_context *libnet_vampire_cb_ldb(struct libnet_vampire_cb_state *state)
+{
+        state = talloc_get_type_abort(state, struct libnet_vampire_cb_state);
+        return state->ldb;
+}
+
+struct loadparm_context *libnet_vampire_cb_lp_ctx(struct libnet_vampire_cb_state *state)
+{
+        state = talloc_get_type_abort(state, struct libnet_vampire_cb_state);
+        return state->lp_ctx;
+}
+
+NTSTATUS libnet_vampire_cb_prepare_db(void *private_data,
+                                      const struct libnet_BecomeDC_PrepareDB *p)
+{
+        struct libnet_vampire_cb_state *s = talloc_get_type(private_data, struct libnet_vampire_cb_state);
         struct provision_settings settings;
         struct provision_result result;
@@ -92 +158 @@
         settings.schema_dn_str = p->forest->schema_dn_str;
         settings.netbios_name = p->dest_dsa->netbios_name;
-        settings.realm = s->join->out.realm;
-        settings.domain = s->join->out.domain_name;
+        settings.realm = s->realm;
+        settings.domain = s->domain_name;
         settings.server_dn_str = p->dest_dsa->server_dn_str;
-        settings.machine_password = generate_random_str(s, 16);
+        settings.machine_password = generate_random_password(s, 16, 255);
         settings.targetdir = s->targetdir;
 
@@ -104 +170 @@
         }
 
-        s->ldb = result.samdb;
-        s->lp_ctx = result.lp_ctx;
+        s->ldb = talloc_steal(s, result.samdb);
+        s->lp_ctx = talloc_reparent(talloc_parent(result.lp_ctx), s, result.lp_ctx);
+        s->provision_schema = dsdb_get_schema(s->ldb, s);
+        s->server_dn_str = talloc_steal(s, p->dest_dsa->server_dn_str);
 
         /* wrap the entire vapire operation in a transaction.  This
@@ -125 +193 @@
 }
 
-static NTSTATUS vampire_check_options(void *private_data,
-                                             const struct libnet_BecomeDC_CheckOptions *o)
-{
-        struct vampire_state *s = talloc_get_type(private_data, struct vampire_state);
+NTSTATUS libnet_vampire_cb_check_options(void *private_data,
+                                         const struct libnet_BecomeDC_CheckOptions *o)
+{
+        struct libnet_vampire_cb_state *s = talloc_get_type(private_data, struct libnet_vampire_cb_state);
 
         DEBUG(0,("Become DC [%s] of Domain[%s]/[%s]\n",
@@ -149 +217 @@
 }
 
-static NTSTATUS vampire_apply_schema(struct vampire_state *s,
-                                  const struct libnet_BecomeDC_StoreChunk *c)
-{
+static NTSTATUS libnet_vampire_cb_apply_schema(struct libnet_vampire_cb_state *s,
+                                               const struct libnet_BecomeDC_StoreChunk *c)
+{
+        struct schema_list {
+                struct schema_list *next, *prev;
+                const struct drsuapi_DsReplicaObjectListItemEx *obj;
+        };
+
         WERROR status;
+        struct dsdb_schema_prefixmap *pfm_remote;
         const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
-        uint32_t object_count;
+        struct schema_list *schema_list = NULL, *schema_list_item, *schema_list_next_item;
+        struct dsdb_schema *working_schema;
+        struct dsdb_schema *provision_schema;
+        uint32_t object_count = 0;
         struct drsuapi_DsReplicaObjectListItemEx *first_object;
-        struct drsuapi_DsReplicaObjectListItemEx *cur;
+        const struct drsuapi_DsReplicaObjectListItemEx *cur;
         uint32_t linked_attributes_count;
         struct drsuapi_DsReplicaLinkedAttribute *linked_attributes;
         const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector;
-        struct dsdb_extended_replicated_objects *objs;
+        struct dsdb_extended_replicated_objects *schema_objs;
         struct repsFromTo1 *s_dsa;
         char *tmp_dns_name;
+        struct ldb_context *schema_ldb;
         struct ldb_message *msg;
-        struct ldb_val prefixMap_val;
         struct ldb_message_element *prefixMap_el;
-        struct ldb_val schemaInfo_val;
         uint32_t i;
-        int ret;
+        int ret, pass_no;
         bool ok;
         uint64_t seq_num;
+        uint32_t ignore_attids[] = {
+                        DRSUAPI_ATTID_auxiliaryClass,
+                        DRSUAPI_ATTID_mayContain,
+                        DRSUAPI_ATTID_mustContain,
+                        DRSUAPI_ATTID_possSuperiors,
+                        DRSUAPI_ATTID_systemPossSuperiors,
+                        DRSUAPI_ATTID_INVALID
+        };
 
         DEBUG(0,("Analyze and apply schema objects\n"));
@@ -206 +290 @@
         }
 
-        s_dsa->replica_flags            = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS;
+        status = dsdb_schema_pfm_from_drsuapi_pfm(mapping_ctr, true,
+                                                  s, &pfm_remote, NULL);
+        if (!W_ERROR_IS_OK(status)) {
+                DEBUG(0,(__location__ ": Failed to decode remote prefixMap: %s",
+                         win_errstr(status)));
+                return werror_to_ntstatus(status);
+        }
+
+        s_dsa->replica_flags            = DRSUAPI_DRS_WRIT_REP
+                                        | DRSUAPI_DRS_INIT_SYNC
+                                        | DRSUAPI_DRS_PER_SYNC;
         memset(s_dsa->schedule, 0x11, sizeof(s_dsa->schedule));
 
@@ -217 +309 @@
         s_dsa->other_info->dns_name = tmp_dns_name;
 
+        schema_ldb = provision_get_schema(s, s->lp_ctx, &s->prefixmap_blob);
+        if (!schema_ldb) {
+                DEBUG(0,("Failed to re-load from local provision using remote prefixMap. "
+                         "Will continue with local prefixMap\n"));
+                provision_schema = dsdb_get_schema(s->ldb, s);
+        } else {
+                provision_schema = dsdb_get_schema(schema_ldb, s);
+                ret = dsdb_reference_schema(s->ldb, provision_schema, false);
+                if (ret != LDB_SUCCESS) {
+                        DEBUG(0,("Failed to attach schema from local provision using remote prefixMap."));
+                        return NT_STATUS_UNSUCCESSFUL;
+                }
+                talloc_free(schema_ldb);
+        }
+
+        /* create a list of objects yet to be converted */
         for (cur = first_object; cur; cur = cur->next_object) {
-                bool is_attr = false;
-                bool is_class = false;
-
-                for (i=0; i < cur->object.attribute_ctr.num_attributes; i++) {
-                        struct drsuapi_DsReplicaAttribute *a;
-                        uint32_t j;
-                        const char *oid = NULL;
-
-                        a = &cur->object.attribute_ctr.attributes[i];
-                        status = dsdb_map_int2oid(s->self_made_schema, a->attid, s, &oid);
+                schema_list_item = talloc(s, struct schema_list);
+                schema_list_item->obj = cur;
+                DLIST_ADD_END(schema_list, schema_list_item, struct schema_list);
+        }
+
+        /* resolve objects until all are resolved and in local schema */
+        pass_no = 1;
+        working_schema = provision_schema;
+
+        while (schema_list) {
+                uint32_t converted_obj_count = 0;
+                uint32_t failed_obj_count = 0;
+                TALLOC_CTX *tmp_ctx = talloc_new(s);
+                NT_STATUS_HAVE_NO_MEMORY(tmp_ctx);
+
+                for (schema_list_item = schema_list; schema_list_item; schema_list_item=schema_list_next_item) {
+                        struct dsdb_extended_replicated_object object;
+
+                        cur = schema_list_item->obj;
+
+                        /* Save the next item, now we have saved out
+                         * the current one, so we can DLIST_REMOVE it
+                         * safely */
+                        schema_list_next_item = schema_list_item->next;
+
+                        /*
+                         * Convert the objects into LDB messages using the
+                         * schema we have so far. It's ok if we fail to convert
+                         * an object. We should convert more objects on next pass.
+                         */
+                        status = dsdb_convert_object_ex(s->ldb, working_schema, pfm_remote,
+                                                        cur, c->gensec_skey,
+                                                        ignore_attids,
+                                                        tmp_ctx, &object);
                         if (!W_ERROR_IS_OK(status)) {
-                                return werror_to_ntstatus(status);
+                                DEBUG(1,("Warning: Failed to convert schema object %s into ldb msg\n",
+                                         cur->object.identifier->dn));
+
+                                failed_obj_count++;
+                        } else {
+                                /*
+                                 * Convert the schema from ldb_message format
+                                 * (OIDs as OID strings) into schema, using
+                                 * the remote prefixMap
+                                 */
+                                status = dsdb_schema_set_el_from_ldb_msg(s->ldb,
+                                                                         s->self_made_schema,
+                                                                         object.msg);
+                                if (!W_ERROR_IS_OK(status)) {
+                                        DEBUG(1,("Warning: failed to convert object %s into a schema element: %s\n",
+                                                 ldb_dn_get_linearized(object.msg->dn),
+                                                 win_errstr(status)));
+                                        failed_obj_count++;
+                                } else {
+                                        DLIST_REMOVE(schema_list, schema_list_item);
+                                        converted_obj_count++;
+                                }
                         }
-
-                        switch (a->attid) {
-                        case DRSUAPI_ATTRIBUTE_objectClass:
-                                for (j=0; j < a->value_ctr.num_values; j++) {
-                                        uint32_t val = 0xFFFFFFFF;
-
-                                        if (a->value_ctr.values[j].blob
-                                            && a->value_ctr.values[j].blob->length == 4) {
-                                                val = IVAL(a->value_ctr.values[j].blob->data,0);
-                                        }
-
-                                        if (val == DRSUAPI_OBJECTCLASS_attributeSchema) {
-                                                is_attr = true;
-                                        }
-                                        if (val == DRSUAPI_OBJECTCLASS_classSchema) {
-                                                is_class = true;
-                                        }
-                                }
-
-                                break;
-                        default:
-                                break;
+                }
+                talloc_free(tmp_ctx);
+
+                DEBUG(4,("Schema load pass %d: %d/%d of %d objects left to be converted.\n",
+                         pass_no, failed_obj_count, converted_obj_count, object_count));
+                pass_no++;
+
+                /* check if we converted any objects in this pass */
+                if (converted_obj_count == 0) {
+                        DEBUG(0,("Can't continue Schema load: didn't manage to convert any objects: all %d remaining of %d objects failed to convert\n", failed_obj_count, object_count));
+                        return NT_STATUS_INTERNAL_ERROR;
+                }
+
+                if (schema_list) {
+                        /* prepare for another cycle */
+                        working_schema = s->self_made_schema;
+
+                        ret = dsdb_setup_sorted_accessors(s->ldb, working_schema);
+                        if (LDB_SUCCESS != ret) {
+                                DEBUG(0,("Failed to create schema-cache indexes!\n"));
+                                return NT_STATUS_INTERNAL_ERROR;
                         }
                 }
-
-                if (is_attr) {
-                        struct dsdb_attribute *sa;
-
-                        sa = talloc_zero(s->self_made_schema, struct dsdb_attribute);
-                        NT_STATUS_HAVE_NO_MEMORY(sa);
-
-                        status = dsdb_attribute_from_drsuapi(s->ldb, s->self_made_schema, &cur->object, s, sa);
-                        if (!W_ERROR_IS_OK(status)) {
-                                return werror_to_ntstatus(status);
-                        }
-
-                        DLIST_ADD_END(s->self_made_schema->attributes, sa, struct dsdb_attribute *);
-                }
-
-                if (is_class) {
-                        struct dsdb_class *sc;
-
-                        sc = talloc_zero(s->self_made_schema, struct dsdb_class);
-                        NT_STATUS_HAVE_NO_MEMORY(sc);
-
-                        status = dsdb_class_from_drsuapi(s->self_made_schema, &cur->object, s, sc);
-                        if (!W_ERROR_IS_OK(status)) {
-                                return werror_to_ntstatus(status);
-                        }
-
-                        DLIST_ADD_END(s->self_made_schema->classes, sc, struct dsdb_class *);
-                }
-        }
-
-        /* attach the schema to the ldb */
+        };
+
+        /* free temp objects for 1st conversion phase */
+        talloc_unlink(s, provision_schema);
+        TALLOC_FREE(schema_list);
+
+        /*
+         * attach the schema we just brought over DRS to the ldb,
+         * so we can use it in dsdb_convert_object_ex below
+         */
         ret = dsdb_set_schema(s->ldb, s->self_made_schema);
         if (ret != LDB_SUCCESS) {
+                DEBUG(0,("Failed to attach working schema from DRS.\n"));
                 return NT_STATUS_FOOBAR;
         }
+
         /* we don't want to access the self made schema anymore */
+        s->schema = s->self_made_schema;
         s->self_made_schema = NULL;
-        s->schema = dsdb_get_schema(s->ldb);
-
-        status = dsdb_extended_replicated_objects_commit(s->ldb,
-                                                         c->partition->nc.dn,
-                                                         mapping_ctr,
-                                                         object_count,
-                                                         first_object,
-                                                         linked_attributes_count,
-                                                         linked_attributes,
-                                                         s_dsa,
-                                                         uptodateness_vector,
-                                                         c->gensec_skey,
-                                                         s, &objs, &seq_num);
+
+        /* Now convert the schema elements again, using the schema we finalised, ready to actually import */
+        status = dsdb_replicated_objects_convert(s->ldb,
+                                                 s->schema,
+                                                 c->partition->nc.dn,
+                                                 mapping_ctr,
+                                                 object_count,
+                                                 first_object,
+                                                 linked_attributes_count,
+                                                 linked_attributes,
+                                                 s_dsa,
+                                                 uptodateness_vector,
+                                                 c->gensec_skey,
+                                                 s, &schema_objs);
+        if (!W_ERROR_IS_OK(status)) {
+                DEBUG(0,("Failed to convert objects when trying to import over DRS (2nd pass, to store remote schema): %s\n", win_errstr(status)));
+                return werror_to_ntstatus(status);
+        }
+
+        if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+                for (i=0; i < schema_objs->num_objects; i++) {
+                        struct ldb_ldif ldif;
+                        fprintf(stdout, "#\n");
+                        ldif.changetype = LDB_CHANGETYPE_NONE;
+                        ldif.msg = schema_objs->objects[i].msg;
+                        ldb_ldif_write_file(s->ldb, stdout, &ldif);
+                        NDR_PRINT_DEBUG(replPropertyMetaDataBlob, schema_objs->objects[i].meta_data);
+                }
+        }
+
+        status = dsdb_replicated_objects_commit(s->ldb, NULL, schema_objs, &seq_num);
         if (!W_ERROR_IS_OK(status)) {
                 DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
@@ -310 +462 @@
         }
 
-        if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
-                for (i=0; i < objs->num_objects; i++) {
-                        struct ldb_ldif ldif;
-                        fprintf(stdout, "#\n");
-                        ldif.changetype = LDB_CHANGETYPE_NONE;
-                        ldif.msg = objs->objects[i].msg;
-                        ldb_ldif_write_file(s->ldb, stdout, &ldif);
-                        NDR_PRINT_DEBUG(replPropertyMetaDataBlob, objs->objects[i].meta_data);
-                }
-        }
-
-        msg = ldb_msg_new(objs);
+        msg = ldb_msg_new(schema_objs);
         NT_STATUS_HAVE_NO_MEMORY(msg);
-        msg->dn = objs->partition_dn;
-
-        status = dsdb_get_oid_mappings_ldb(s->schema, msg, &prefixMap_val, &schemaInfo_val);
-        if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("Failed dsdb_get_oid_mappings_ldb(%s)\n", win_errstr(status)));
-                return werror_to_ntstatus(status);
-        }
-
-        /* we only add prefixMap here, because schemaInfo is a replicated attribute and already applied */
-        ret = ldb_msg_add_value(msg, "prefixMap", &prefixMap_val, &prefixMap_el);
+        msg->dn = schema_objs->partition_dn;
+
+        /* We must ensure a prefixMap has been written.  Unlike other
+         * attributes (including schemaInfo), it is not replicated in
+         * the normal replication stream.  We can use the one from
+         * s->prefixmap_blob because we operate with one, unchanging
+         * prefixMap for this entire operation.  */
+        ret = ldb_msg_add_value(msg, "prefixMap", &s->prefixmap_blob, &prefixMap_el);
         if (ret != LDB_SUCCESS) {
                 return NT_STATUS_FOOBAR;
         }
-        prefixMap_el->flags = LDB_FLAG_MOD_REPLACE;
+        /* We want to know if a prefixMap was written already, as it
+         * would mean that the above comment was not true, and we have
+         * somehow updated the prefixMap during this transaction */
+        prefixMap_el->flags = LDB_FLAG_MOD_ADD;
 
         ret = ldb_modify(s->ldb, msg);
         if (ret != LDB_SUCCESS) {
-                DEBUG(0,("Failed to add prefixMap and schemaInfo %s\n", ldb_strerror(ret)));
+                DEBUG(0,("Failed to add prefixMap: %s\n", ldb_errstring(s->ldb)));
                 return NT_STATUS_FOOBAR;
         }
 
         talloc_free(s_dsa);
-        talloc_free(objs);
+        talloc_free(schema_objs);
 
         /* We must set these up to ensure the replMetaData is written
@@ -360 +502 @@
         }
 
-        s->schema = dsdb_get_schema(s->ldb);
+        s->schema = dsdb_get_schema(s->ldb, s);
         if (!s->schema) {
                 DEBUG(0,("Failed to get loaded dsdb_schema\n"));
@@ -369 +511 @@
 }
 
-static NTSTATUS vampire_schema_chunk(void *private_data,
-                                            const struct libnet_BecomeDC_StoreChunk *c)
-{
-        struct vampire_state *s = talloc_get_type(private_data, struct vampire_state);
+NTSTATUS libnet_vampire_cb_schema_chunk(void *private_data,
+                                        const struct libnet_BecomeDC_StoreChunk *c)
+{
+        struct libnet_vampire_cb_state *s = talloc_get_type(private_data, struct libnet_vampire_cb_state);
         WERROR status;
         const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
@@ -415 +557 @@
         }
 
-        if (!s->schema) {
-                s->self_made_schema = dsdb_new_schema(s, lp_iconv_convenience(s->lp_ctx));
-
+        if (!s->self_made_schema) {
+                WERROR werr;
+                struct drsuapi_DsReplicaOIDMapping_Ctr mapping_ctr_without_schema_info;
+                /* Put the DRS prefixmap aside for the schema we are
+                 * about to load in the provision, and into the one we
+                 * are making with the help of DRS */
+
+                mapping_ctr_without_schema_info = *mapping_ctr;
+
+                /* This strips off the 0xFF schema info from the end,
+                 * because we don't want it in the blob */
+                if (mapping_ctr_without_schema_info.num_mappings > 0) {
+                        mapping_ctr_without_schema_info.num_mappings--;
+                }
+                werr = dsdb_get_drsuapi_prefixmap_as_blob(&mapping_ctr_without_schema_info, s, &s->prefixmap_blob);
+                if (!W_ERROR_IS_OK(werr)) {
+                        return werror_to_ntstatus(werr);
+                }
+
+                /* Set up two manually-constructed schema - the local
+                 * schema from the provision will be used to build
+                 * one, which will then in turn be used to build the
+                 * other. */
+                s->self_made_schema = dsdb_new_schema(s);
                 NT_STATUS_HAVE_NO_MEMORY(s->self_made_schema);
 
-                status = dsdb_load_oid_mappings_drsuapi(s->self_made_schema, mapping_ctr);
+                status = dsdb_load_prefixmap_from_drsuapi(s->self_made_schema, mapping_ctr);
                 if (!W_ERROR_IS_OK(status)) {
                         return werror_to_ntstatus(status);
                 }
-
-                s->schema = s->self_made_schema;
         } else {
-                status = dsdb_verify_oid_mappings_drsuapi(s->schema, mapping_ctr);
+                status = dsdb_schema_pfm_contains_drsuapi_pfm(s->self_made_schema->prefixmap, mapping_ctr);
                 if (!W_ERROR_IS_OK(status)) {
                         return werror_to_ntstatus(status);
@@ -445 +606 @@
 
         if (!c->partition->more_data) {
-                return vampire_apply_schema(s, c);
+                return libnet_vampire_cb_apply_schema(s, c);
         }
 
@@ -451 +612 @@
 }
 
-static NTSTATUS vampire_store_chunk(void *private_data,
-                                           const struct libnet_BecomeDC_StoreChunk *c)
-{
-        struct vampire_state *s = talloc_get_type(private_data, struct vampire_state);
+NTSTATUS libnet_vampire_cb_store_chunk(void *private_data,
+                             const struct libnet_BecomeDC_StoreChunk *c)
+{
+        struct libnet_vampire_cb_state *s = talloc_get_type(private_data, struct libnet_vampire_cb_state);
         WERROR status;
+        struct dsdb_schema *schema;
         const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
         uint32_t nc_object_count;
@@ -506 +668 @@
         }
 
-        s_dsa->replica_flags            = DRSUAPI_DS_REPLICA_NEIGHBOUR_WRITEABLE
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_SYNC_ON_STARTUP
-                                        | DRSUAPI_DS_REPLICA_NEIGHBOUR_DO_SCHEDULED_SYNCS;
+        s_dsa->replica_flags            = DRSUAPI_DRS_WRIT_REP
+                                        | DRSUAPI_DRS_INIT_SYNC
+                                        | DRSUAPI_DRS_PER_SYNC;
         memset(s_dsa->schedule, 0x11, sizeof(s_dsa->schedule));
 
@@ -535 +697 @@
 
 
-        status = dsdb_extended_replicated_objects_commit(s->ldb,
-                                                         c->partition->nc.dn,
-                                                         mapping_ctr,
-                                                         object_count,
-                                                         first_object,
-                                                         linked_attributes_count,
-                                                         linked_attributes,
-                                                         s_dsa,
-                                                         uptodateness_vector,
-                                                         c->gensec_skey,
-                                                         s, &objs, &seq_num);
+        schema = dsdb_get_schema(s->ldb, NULL);
+        if (!schema) {
+                DEBUG(0,(__location__ ": Schema is not loaded yet!\n"));
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+
+        status = dsdb_replicated_objects_convert(s->ldb,
+                                                 schema,
+                                                 c->partition->nc.dn,
+                                                 mapping_ctr,
+                                                 object_count,
+                                                 first_object,
+                                                 linked_attributes_count,
+                                                 linked_attributes,
+                                                 s_dsa,
+                                                 uptodateness_vector,
+                                                 c->gensec_skey,
+                                                 s, &objs);
         if (!W_ERROR_IS_OK(status)) {
-                DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
+                DEBUG(0,("Failed to convert objects: %s\n", win_errstr(status)));
                 return werror_to_ntstatus(status);
         }
 
-        if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+        if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
                 for (i=0; i < objs->num_objects; i++) {
                         struct ldb_ldif ldif;
@@ -561 +730 @@
                 }
         }
+        status = dsdb_replicated_objects_commit(s->ldb, NULL, objs, &seq_num);
+        if (!W_ERROR_IS_OK(status)) {
+                DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
+                return werror_to_ntstatus(status);
+        }
+
         talloc_free(s_dsa);
         talloc_free(objs);
@@ -581 +756 @@
                 }
 
-                if (lp_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
+                if (lpcfg_parm_bool(s->lp_ctx, NULL, "become dc", "dump objects", false)) {
                         DEBUG(0,("# %s\n", sa->lDAPDisplayName));
                         NDR_PRINT_DEBUG(drsuapi_DsReplicaLinkedAttribute, &linked_attributes[i]);
@@ -593 +768 @@
 }
 
+static NTSTATUS update_dnshostname_for_server(TALLOC_CTX *mem_ctx,
+                                              struct ldb_context *ldb,
+                                              const char *server_dn_str,
+                                              const char *netbios_name,
+                                              const char *realm)
+{
+        int ret;
+        struct ldb_message *msg;
+        struct ldb_message_element *el;
+        struct ldb_dn *server_dn;
+        const char *dNSHostName = strlower_talloc(mem_ctx,
+                                                  talloc_asprintf(mem_ctx,
+                                                                  "%s.%s",
+                                                                  netbios_name,
+                                                                  realm));
+        msg = ldb_msg_new(mem_ctx);
+        if (msg == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        server_dn = ldb_dn_new(mem_ctx, ldb, server_dn_str);
+        if (!server_dn) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+
+        msg->dn = server_dn;
+        ret = ldb_msg_add_empty(msg, "dNSHostName", LDB_FLAG_MOD_ADD, &el);
+        if (ret != LDB_SUCCESS) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+
+        ret = ldb_msg_add_steal_string(msg,
+                                       "dNSHostName",
+                                       talloc_asprintf(el->values, "%s", dNSHostName));
+        if (ret != LDB_SUCCESS) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+
+        ret = dsdb_modify(ldb, msg, DSDB_MODIFY_PERMISSIVE);
+        if (ret != LDB_SUCCESS) {
+                DEBUG(0,(__location__ ": Failed to add dnsHostName to the Server object: %s\n",
+                         ldb_errstring(ldb)));
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+
+        return NT_STATUS_OK;
+}
+
+
 NTSTATUS libnet_Vampire(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, 
                         struct libnet_Vampire *r)
 {
         struct libnet_JoinDomain *join;
-        struct provision_store_self_join_settings *set_secrets;
-        struct libnet_BecomeDC b;
-        struct vampire_state *s;
-        struct ldb_message *msg;
-        const char *error_string;
-        int ldb_ret;
-        uint32_t i;
+        struct libnet_Replicate rep;
         NTSTATUS status;
 
@@ -611 +829 @@
         r->out.error_string = NULL;
 
-        s = talloc_zero(mem_ctx, struct vampire_state);
-        if (!s) {
-                return NT_STATUS_NO_MEMORY;
-        }
-
-        s->lp_ctx = ctx->lp_ctx;
-        s->event_ctx = ctx->event_ctx;
-
-        join = talloc_zero(s, struct libnet_JoinDomain);
+        join = talloc_zero(mem_ctx, struct libnet_JoinDomain);
         if (!join) {
                 return NT_STATUS_NO_MEMORY;
@@ -627 +837 @@
                 netbios_name = r->in.netbios_name;
         } else {
-                netbios_name = talloc_reference(join, lp_netbios_name(ctx->lp_ctx));
+                netbios_name = talloc_reference(join, lpcfg_netbios_name(ctx->lp_ctx));
                 if (!netbios_name) {
+                        talloc_free(join);
                         r->out.error_string = NULL;
-                        talloc_free(s);
                         return NT_STATUS_NO_MEMORY;
                 }
@@ -637 +847 @@
         account_name = talloc_asprintf(join, "%s$", netbios_name);
         if (!account_name) {
+                talloc_free(join);
                 r->out.error_string = NULL;
-                talloc_free(s);
                 return NT_STATUS_NO_MEMORY;
         }
         
+        /* Re-use the domain we are joining as the domain for the user
+         * to be authenticated with, unless they specified
+         * otherwise */
+        cli_credentials_set_domain(ctx->cred, r->in.domain_name, CRED_GUESS_ENV);
+
         join->in.domain_name    = r->in.domain_name;
         join->in.account_name   = account_name;
@@ -651 +866 @@
         if (!NT_STATUS_IS_OK(status)) {
                 r->out.error_string = talloc_steal(mem_ctx, join->out.error_string);
-                talloc_free(s);
+                talloc_free(join);
                 return status;
         }
+
+        rep.in.domain_name   = join->out.domain_name;
+        rep.in.netbios_name  = netbios_name;
+        rep.in.targetdir     = r->in.targetdir;
+        rep.in.domain_sid    = join->out.domain_sid;
+        rep.in.realm         = join->out.realm;
+        rep.in.server        = join->out.samr_binding->host;
+        rep.in.join_password = join->out.join_password;
+        rep.in.kvno          = join->out.kvno;
+
+        status = libnet_Replicate(ctx, mem_ctx, &rep);
+
+        r->out.domain_sid   = join->out.domain_sid;
+        r->out.domain_name  = join->out.domain_name;
+        r->out.error_string = rep.out.error_string;
+
+        return status;
+}
+
+
+
+NTSTATUS libnet_Replicate(struct libnet_context *ctx, TALLOC_CTX *mem_ctx,
+                          struct libnet_Replicate *r)
+{
+        struct provision_store_self_join_settings *set_secrets;
+        struct libnet_BecomeDC b;
+        struct libnet_vampire_cb_state *s;
+        struct ldb_message *msg;
+        const char *error_string;
+        int ldb_ret;
+        uint32_t i;
+        NTSTATUS status;
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
+        const char *account_name;
+        const char *netbios_name;
+
+        r->out.error_string = NULL;
+
+        netbios_name = r->in.netbios_name;
+        account_name = talloc_asprintf(tmp_ctx, "%s$", netbios_name);
+        if (!account_name) {
+                talloc_free(tmp_ctx);
+                r->out.error_string = NULL;
+                return NT_STATUS_NO_MEMORY;
+        }
         
-        s->join = join;
-
-        s->targetdir = r->in.targetdir;
+        /* Re-use the domain we are joining as the domain for the user
+         * to be authenticated with, unless they specified
+         * otherwise */
+        cli_credentials_set_domain(ctx->cred, r->in.domain_name, CRED_GUESS_ENV);
+
+        s = libnet_vampire_cb_state_init(mem_ctx, ctx->lp_ctx, ctx->event_ctx,
+                                         netbios_name, r->in.domain_name, r->in.realm,
+                                         r->in.targetdir);
+        if (!s) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        talloc_steal(s, tmp_ctx);
 
         ZERO_STRUCT(b);
-        b.in.domain_dns_name            = join->out.realm;
-        b.in.domain_netbios_name        = join->out.domain_name;
-        b.in.domain_sid                 = join->out.domain_sid;
-        b.in.source_dsa_address         = join->out.samr_binding->host;
+
+        /* Be more robust:
+         * We now know the domain and realm for sure - if they didn't
+         * put one on the command line, use this for the rest of the
+         * join */
+        cli_credentials_set_realm(ctx->cred, r->in.realm, CRED_GUESS_ENV);
+        cli_credentials_set_domain(ctx->cred, r->in.domain_name, CRED_GUESS_ENV);
+
+        /* Now set these values into the smb.conf - we probably had
+         * empty or useless defaults here from whatever smb.conf we
+         * started with */
+        lpcfg_set_cmdline(s->lp_ctx, "realm", r->in.realm);
+        lpcfg_set_cmdline(s->lp_ctx, "workgroup", r->in.domain_name);
+
+        b.in.domain_dns_name            = r->in.realm;
+        b.in.domain_netbios_name        = r->in.domain_name;
+        b.in.domain_sid                 = r->in.domain_sid;
+        b.in.source_dsa_address         = r->in.server;
         b.in.dest_dsa_netbios_name      = netbios_name;
 
         b.in.callbacks.private_data     = s;
-        b.in.callbacks.check_options    = vampire_check_options;
-        b.in.callbacks.prepare_db       = vampire_prepare_db;
-        b.in.callbacks.schema_chunk     = vampire_schema_chunk;
-        b.in.callbacks.config_chunk     = vampire_store_chunk;
-        b.in.callbacks.domain_chunk     = vampire_store_chunk;
+        b.in.callbacks.check_options    = libnet_vampire_cb_check_options;
+        b.in.callbacks.prepare_db       = libnet_vampire_cb_prepare_db;
+        b.in.callbacks.schema_chunk     = libnet_vampire_cb_schema_chunk;
+        b.in.callbacks.config_chunk     = libnet_vampire_cb_store_chunk;
+        b.in.callbacks.domain_chunk     = libnet_vampire_cb_store_chunk;
+
+        b.in.rodc_join = lpcfg_parm_bool(s->lp_ctx, NULL, "repl", "RODC", false);
 
         status = libnet_BecomeDC(ctx, s, &b);
@@ -707 +992 @@
         ldb_ret = ldb_modify(s->ldb, msg);
         if (ldb_ret != LDB_SUCCESS) {
-                printf("ldb_modify() failed: %d\n", ldb_ret);
+                printf("ldb_modify() failed: %d : %s\n", ldb_ret, ldb_errstring(s->ldb));
                 talloc_free(s);
                 return NT_STATUS_INTERNAL_DB_ERROR;
         }
-
+        /* during dcpromo the 2nd computer adds dNSHostName attribute to his Server object
+         * the attribute appears on the original DC after replication
+         */
+        status = update_dnshostname_for_server(s, s->ldb, s->server_dn_str, s->netbios_name, s->realm);
+        if (!NT_STATUS_IS_OK(status)) {
+                printf("Failed to update dNSHostName on Server object - %s\n", nt_errstr(status));
+                talloc_free(s);
+                return status;
+        }
         /* prepare the transaction - this prepares to commit all the changes in
            the ldb from the whole vampire.  Note that this 
@@ -717 +1010 @@
         */
         if (ldb_transaction_prepare_commit(s->ldb) != LDB_SUCCESS) {
-                printf("Failed to prepare_commit vampire transaction\n");
+                printf("Failed to prepare_commit vampire transaction: %s\n", ldb_errstring(s->ldb));
                 return NT_STATUS_INTERNAL_DB_ERROR;
         }
@@ -729 +1022 @@
         
         ZERO_STRUCTP(set_secrets);
-        set_secrets->domain_name = join->out.domain_name;
-        set_secrets->realm = join->out.realm;
-        set_secrets->account_name = account_name;
+        set_secrets->domain_name = r->in.domain_name;
+        set_secrets->realm = r->in.realm;
         set_secrets->netbios_name = netbios_name;
         set_secrets->secure_channel_type = SEC_CHAN_BDC;
-        set_secrets->machine_password = join->out.join_password;
-        set_secrets->key_version_number = join->out.kvno;
-        set_secrets->domain_sid = join->out.domain_sid;
+        set_secrets->machine_password = r->in.join_password;
+        set_secrets->key_version_number = r->in.kvno;
+        set_secrets->domain_sid = r->in.domain_sid;
         
-        status = provision_store_self_join(ctx, ctx->lp_ctx, ctx->event_ctx, set_secrets, &error_string);
+        status = provision_store_self_join(ctx, s->lp_ctx, ctx->event_ctx, set_secrets, &error_string);
         if (!NT_STATUS_IS_OK(status)) {
                 r->out.error_string = talloc_steal(mem_ctx, error_string);
@@ -745 +1037 @@
         }
 
-        r->out.domain_name = talloc_steal(r, join->out.domain_name);
-        r->out.domain_sid = dom_sid_dup(r, join->out.domain_sid);
-        
         /* commit the transaction now we know the secrets were written
          * out properly
@@ -759 +1048 @@
 
         return NT_STATUS_OK;
-
-}
+}

vendor/current/source4/libnet/libnet_vampire.h

@@ -37 +37 @@
 };
 
+struct libnet_Replicate {
+        struct {
+                const char *domain_name;
+                const char *netbios_name;
+                const char *targetdir; /* optional, may be NULL */
+                struct dom_sid *domain_sid;
+                const char *realm;
+                const char *server;
+                const char *join_password;
+                uint32_t kvno;
+        } in;
+        struct {
+                const char *error_string;
+        } out;
+};
+
+/* Private context for the default callbacks */
+struct libnet_vampire_cb_state;
 
 #endif /* __LIBNET_VAMPIRE_H__ */

vendor/current/source4/libnet/py_net.c

@@ -1 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Samba utility functions
-   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
-   
+   Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008-2010
+   Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <Python.h>
 #include "includes.h"
-#include <Python.h>
+#include <ldb.h>
+#include <pyldb.h>
 #include "libnet.h"
 #include "auth/credentials/pycredentials.h"
 #include "libcli/security/security.h"
 #include "lib/events/events.h"
-#include "param/param.h"
-
-/* FIXME: This prototype should be in param/pyparam.h */
-struct loadparm_context *py_default_loadparm_context(TALLOC_CTX *mem_ctx);
-
-static struct libnet_context *py_net_ctx(PyObject *obj, struct tevent_context *ev, struct cli_credentials *creds)
-{
-/* FIXME: Use obj */
-        struct libnet_context *libnet;
-        libnet = libnet_context_init(ev, py_default_loadparm_context(NULL));
-        if (!libnet) {
-                return NULL;
-        }
-        libnet->cred = creds;
-        return libnet;
-}
-
-static PyObject *py_net_join(PyObject *cls, PyObject *args, PyObject *kwargs)
+#include "param/pyparam.h"
+#include "auth/gensec/gensec.h"
+#include "librpc/rpc/pyrpc_util.h"
+#include "libcli/finddc.h"
+#include "libcli/resolve/resolve.h"
+
+void initnet(void);
+
+typedef struct {
+        PyObject_HEAD
+        TALLOC_CTX *mem_ctx;
+        struct libnet_context *libnet_ctx;
+        struct tevent_context *ev;
+} py_net_Object;
+
+static PyObject *py_net_join(py_net_Object *self, PyObject *args, PyObject *kwargs)
 {
         struct libnet_Join r;
@@ -47 +48 @@
         PyObject *result;
         TALLOC_CTX *mem_ctx;
+        const char *kwnames[] = { "domain_name", "netbios_name", "join_type", "level", NULL };
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ssii:Join", discard_const_p(char *, kwnames), 
+                                         &r.in.domain_name, &r.in.netbios_name, 
+                                         &r.in.join_type, &r.in.level))
+                return NULL;
+
+        mem_ctx = talloc_new(self->mem_ctx);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        status = libnet_Join(self->libnet_ctx, mem_ctx, &r);
+        if (NT_STATUS_IS_ERR(status)) {
+                PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        result = Py_BuildValue("sss", r.out.join_password,
+                               dom_sid_string(mem_ctx, r.out.domain_sid),
+                               r.out.domain_name);
+
+        talloc_free(mem_ctx);
+
+        return result;
+}
+
+static const char py_net_join_doc[] = "join(domain_name, netbios_name, join_type, level) -> (join_password, domain_sid, domain_name)\n\n" \
+"Join the domain with the specified name.";
+
+static PyObject *py_net_set_password(py_net_Object *self, PyObject *args, PyObject *kwargs)
+{
+        union libnet_SetPassword r;
+        NTSTATUS status;
+        PyObject *py_creds;
+        TALLOC_CTX *mem_ctx;
         struct tevent_context *ev;
-        struct libnet_context *libnet_ctx;
-        struct cli_credentials *creds;
-        PyObject *py_creds;     
-        const char *kwnames[] = { "domain_name", "netbios_name", "join_type", "level", "credentials", NULL };
-
-        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ssiiO:Join", discard_const_p(char *, kwnames), 
-                                         &r.in.domain_name, &r.in.netbios_name, 
-                                         &r.in.join_type, &r.in.level, &py_creds))
-                return NULL;
+        const char *kwnames[] = { "account_name", "domain_name", "newpassword", "credentials", NULL };
+
+        r.generic.level = LIBNET_SET_PASSWORD_GENERIC;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sssO:set_password", discard_const_p(char *, kwnames),
+                                         &r.generic.in.account_name, &r.generic.in.domain_name,
+                                         &r.generic.in.newpassword, &py_creds)) {
+                return NULL;
+        }
 
         /* FIXME: we really need to get a context from the caller or we may end
          * up with 2 event contexts */
         ev = s4_event_context_init(NULL);
+
         mem_ctx = talloc_new(ev);
-
-        creds = cli_credentials_from_py_object(py_creds);
-        if (creds == NULL) {
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        status = libnet_SetPassword(self->libnet_ctx, mem_ctx, &r);
+        if (NT_STATUS_IS_ERR(status)) {
+                PyErr_SetString(PyExc_RuntimeError,
+                                r.generic.out.error_string?r.generic.out.error_string:nt_errstr(status));
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        talloc_free(mem_ctx);
+
+        Py_RETURN_NONE;
+}
+
+static const char py_net_set_password_doc[] = "set_password(account_name, domain_name, newpassword) -> True\n\n" \
+"Set password for a user. You must supply credential with enough rights to do this.\n\n" \
+"Sample usage is:\n" \
+"net.set_password(account_name=<account_name>,\n" \
+"                domain_name=domain_name,\n" \
+"                newpassword=new_pass)\n";
+
+
+static PyObject *py_net_export_keytab(py_net_Object *self, PyObject *args, PyObject *kwargs)
+{
+        struct libnet_export_keytab r;
+        TALLOC_CTX *mem_ctx;
+        const char *kwnames[] = { "keytab", NULL };
+        NTSTATUS status;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:export_keytab", discard_const_p(char *, kwnames),
+                                         &r.in.keytab_name)) {
+                return NULL;
+        }
+
+        mem_ctx = talloc_new(self->mem_ctx);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        status = libnet_export_keytab(self->libnet_ctx, mem_ctx, &r);
+        if (NT_STATUS_IS_ERR(status)) {
+                PyErr_SetString(PyExc_RuntimeError,
+                                r.out.error_string?r.out.error_string:nt_errstr(status));
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        talloc_free(mem_ctx);
+
+        Py_RETURN_NONE;
+}
+
+static const char py_net_export_keytab_doc[] = "export_keytab(keytab, name)\n\n"
+"Export the DC keytab to a keytab file.";
+
+static PyObject *py_net_time(py_net_Object *self, PyObject *args, PyObject *kwargs)
+{
+        const char *kwnames[] = { "server_name", NULL };
+        union libnet_RemoteTOD r;
+        NTSTATUS status;
+        TALLOC_CTX *mem_ctx;
+        char timestr[64];
+        PyObject *ret;
+        struct tm *tm;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s",
+                discard_const_p(char *, kwnames), &r.generic.in.server_name))
+                return NULL;
+
+        r.generic.level                 = LIBNET_REMOTE_TOD_GENERIC;
+
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        status = libnet_RemoteTOD(self->libnet_ctx, mem_ctx, &r);
+        if (!NT_STATUS_IS_OK(status)) {
+                PyErr_SetString(PyExc_RuntimeError,
+                                r.generic.out.error_string?r.generic.out.error_string:nt_errstr(status));
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        ZERO_STRUCT(timestr);
+        tm = localtime(&r.generic.out.time);
+        strftime(timestr, sizeof(timestr)-1, "%c %Z",tm);
+        
+        ret = PyString_FromString(timestr);
+
+        talloc_free(mem_ctx);
+
+        return ret;
+}
+
+static const char py_net_time_doc[] = "time(server_name) -> timestr\n"
+"Retrieve the remote time on a server";
+
+static PyObject *py_net_user_create(py_net_Object *self, PyObject *args, PyObject *kwargs)
+{
+        const char *kwnames[] = { "username", NULL };
+        NTSTATUS status;
+        TALLOC_CTX *mem_ctx;
+        struct libnet_CreateUser r;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", discard_const_p(char *, kwnames), 
+                                                                         &r.in.user_name))
+                return NULL;
+
+        r.in.domain_name = cli_credentials_get_domain(self->libnet_ctx->cred);
+
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        status = libnet_CreateUser(self->libnet_ctx, mem_ctx, &r);
+        if (!NT_STATUS_IS_OK(status)) {
+                PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        talloc_free(mem_ctx);
+        
+        Py_RETURN_NONE;
+}
+
+static const char py_net_create_user_doc[] = "create_user(username)\n"
+"Create a new user.";
+
+static PyObject *py_net_user_delete(py_net_Object *self, PyObject *args, PyObject *kwargs)
+{
+        const char *kwnames[] = { "username", NULL };
+        NTSTATUS status;
+        TALLOC_CTX *mem_ctx;
+        struct libnet_DeleteUser r;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", discard_const_p(char *, kwnames), 
+                                                                         &r.in.user_name))
+                return NULL;
+
+        r.in.domain_name = cli_credentials_get_domain(self->libnet_ctx->cred);
+
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        status = libnet_DeleteUser(self->libnet_ctx, mem_ctx, &r);
+        if (!NT_STATUS_IS_OK(status)) {
+                PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        talloc_free(mem_ctx);
+        
+        Py_RETURN_NONE;
+}
+
+static const char py_net_delete_user_doc[] = "delete_user(username)\n"
+"Delete a user.";
+
+static PyObject *py_dom_sid_FromSid(struct dom_sid *sid)
+{
+        PyObject *mod_security, *dom_sid_Type;
+
+        mod_security = PyImport_ImportModule("samba.dcerpc.security");
+        if (mod_security == NULL)
+                return NULL;
+
+        dom_sid_Type = PyObject_GetAttrString(mod_security, "dom_sid");
+        if (dom_sid_Type == NULL)
+                return NULL;
+
+        return py_talloc_reference((PyTypeObject *)dom_sid_Type, sid);
+}
+
+static PyObject *py_net_vampire(py_net_Object *self, PyObject *args, PyObject *kwargs)
+{
+        const char *kwnames[] = { "domain", "target_dir", NULL };
+        NTSTATUS status;
+        TALLOC_CTX *mem_ctx;
+        PyObject *ret;
+        struct libnet_Vampire r;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|z", discard_const_p(char *, kwnames),
+                                         &r.in.domain_name, &r.in.targetdir)) {
+                return NULL;
+        }
+
+        r.in.netbios_name  = lpcfg_netbios_name(self->libnet_ctx->lp_ctx);
+        r.out.error_string = NULL;
+
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        status = libnet_Vampire(self->libnet_ctx, mem_ctx, &r);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                PyErr_SetString(PyExc_RuntimeError,
+                                r.out.error_string ? r.out.error_string : nt_errstr(status));
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        ret = Py_BuildValue("(sO)", r.out.domain_name, py_dom_sid_FromSid(r.out.domain_sid));
+
+        talloc_free(mem_ctx);
+
+        return ret;
+}
+
+struct replicate_state {
+        void *vampire_state;
+        dcerpc_InterfaceObject *drs_pipe;
+        struct libnet_BecomeDC_StoreChunk chunk;
+        DATA_BLOB gensec_skey;
+        struct libnet_BecomeDC_Partition partition;
+        struct libnet_BecomeDC_Forest forest;
+        struct libnet_BecomeDC_DestDSA dest_dsa;
+};
+
+/*
+  setup for replicate_chunk() calls
+ */
+static PyObject *py_net_replicate_init(py_net_Object *self, PyObject *args, PyObject *kwargs)
+{
+        const char *kwnames[] = { "samdb", "lp", "drspipe", NULL };
+        PyObject *py_ldb, *py_lp, *py_drspipe;
+        struct ldb_context *samdb;
+        struct loadparm_context *lp;
+        struct replicate_state *s;
+        NTSTATUS status;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO",
+                                         discard_const_p(char *, kwnames),
+                                         &py_ldb, &py_lp, &py_drspipe)) {
+                return NULL;
+        }
+
+        s = talloc_zero(NULL, struct replicate_state);
+        if (!s) return NULL;
+
+        lp = lpcfg_from_py_object(s, py_lp);
+        if (lp == NULL) {
+                PyErr_SetString(PyExc_TypeError, "Expected lp object");
+                talloc_free(s);
+                return NULL;
+        }
+
+        samdb = PyLdb_AsLdbContext(py_ldb);
+        if (samdb == NULL) {
+                PyErr_SetString(PyExc_TypeError, "Expected ldb object");
+                talloc_free(s);
+                return NULL;
+        }
+
+        s->drs_pipe = (dcerpc_InterfaceObject *)(py_drspipe);
+
+        s->vampire_state = libnet_vampire_replicate_init(s, samdb, lp);
+        if (s->vampire_state == NULL) {
+                PyErr_SetString(PyExc_TypeError, "Failed to initialise vampire_state");
+                talloc_free(s);
+                return NULL;
+        }
+
+        status = gensec_session_key(s->drs_pipe->pipe->conn->security_state.generic_state,
+                                    &s->gensec_skey);
+        if (!NT_STATUS_IS_OK(status)) {
+                PyErr_Format(PyExc_RuntimeError, "Unable to get session key from drspipe: %s",
+                             nt_errstr(status));
+                talloc_free(s);
+                return NULL;
+        }
+
+        s->forest.dns_name = lpcfg_dnsdomain(lp);
+
+        s->chunk.gensec_skey = &s->gensec_skey;
+        s->chunk.partition = &s->partition;
+        s->chunk.forest = &s->forest;
+        s->chunk.dest_dsa = &s->dest_dsa;
+
+        return PyCObject_FromTallocPtr(s);
+}
+
+
+/*
+  process one replication chunk
+ */
+static PyObject *py_net_replicate_chunk(py_net_Object *self, PyObject *args, PyObject *kwargs)
+{
+        const char *kwnames[] = { "state", "level", "ctr", "schema", NULL };
+        PyObject *py_state, *py_ctr, *py_schema;
+        struct replicate_state *s;
+        unsigned level;
+        NTSTATUS (*chunk_handler)(void *private_data, const struct libnet_BecomeDC_StoreChunk *c);
+        NTSTATUS status;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OIO|O",
+                                         discard_const_p(char *, kwnames),
+                                         &py_state, &level, &py_ctr, &py_schema)) {
+                return NULL;
+        }
+
+        s = talloc_get_type(PyCObject_AsVoidPtr(py_state), struct replicate_state);
+        if (!s) {
+                PyErr_SetString(PyExc_TypeError, "Expected replication_state");
+                return NULL;
+        }
+
+        switch (level) {
+        case 1:
+                if (!py_check_dcerpc_type(py_ctr, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr1")) {
+                        return NULL;
+                }
+                s->chunk.ctr1                         = py_talloc_get_ptr(py_ctr);
+                s->partition.nc                       = *s->chunk.ctr1->naming_context;
+                s->partition.more_data                = s->chunk.ctr1->more_data;
+                s->partition.source_dsa_guid          = s->chunk.ctr1->source_dsa_guid;
+                s->partition.source_dsa_invocation_id = s->chunk.ctr1->source_dsa_invocation_id;
+                s->partition.highwatermark            = s->chunk.ctr1->new_highwatermark;
+                break;
+        case 6:
+                if (!py_check_dcerpc_type(py_ctr, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr6")) {
+                        return NULL;
+                }
+                s->chunk.ctr6                         = py_talloc_get_ptr(py_ctr);
+                s->partition.nc                       = *s->chunk.ctr6->naming_context;
+                s->partition.more_data                = s->chunk.ctr6->more_data;
+                s->partition.source_dsa_guid          = s->chunk.ctr6->source_dsa_guid;
+                s->partition.source_dsa_invocation_id = s->chunk.ctr6->source_dsa_invocation_id;
+                s->partition.highwatermark            = s->chunk.ctr6->new_highwatermark;
+                break;
+        default:
+                PyErr_Format(PyExc_TypeError, "Bad level %u in replicate_chunk", level);
+                return NULL;
+        }
+
+        chunk_handler = libnet_vampire_cb_store_chunk;
+        if (py_schema) {
+                if (!PyBool_Check(py_schema)) {
+                        PyErr_SetString(PyExc_TypeError, "Expected boolean schema");
+                        return NULL;
+                }
+                if (py_schema == Py_True) {
+                        chunk_handler = libnet_vampire_cb_schema_chunk;
+                }
+        }
+
+        s->chunk.ctr_level = level;
+
+        status = chunk_handler(s->vampire_state, &s->chunk);
+        if (!NT_STATUS_IS_OK(status)) {
+                PyErr_Format(PyExc_TypeError, "Failed to process chunk: %s", nt_errstr(status));
+                return NULL;
+        }
+
+        Py_RETURN_NONE;
+}
+
+
+/*
+  find a DC given a domain name and server type
+ */
+static PyObject *py_net_finddc(py_net_Object *self, PyObject *args)
+{
+        const char *domain_name;
+        unsigned server_type;
+        NTSTATUS status;
+        struct finddcs *io;
+        TALLOC_CTX *mem_ctx;
+        PyObject *ret;
+
+        if (!PyArg_ParseTuple(args, "sI", &domain_name, &server_type)) {
+                return NULL;
+        }
+
+        mem_ctx = talloc_new(self->mem_ctx);
+
+        io = talloc_zero(mem_ctx, struct finddcs);
+        io->in.domain_name = domain_name;
+        io->in.minimum_dc_flags = server_type;
+
+        status = finddcs_cldap(io, io,
+                               lpcfg_resolve_context(self->libnet_ctx->lp_ctx), self->ev);
+        if (NT_STATUS_IS_ERR(status)) {
+                PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        ret = py_return_ndr_struct("samba.dcerpc.nbt", "NETLOGON_SAM_LOGON_RESPONSE_EX",
+                                   io, &io->out.netlogon.data.nt5_ex);
+        talloc_free(mem_ctx);
+
+        return ret;
+}
+
+
+static const char py_net_vampire_doc[] = "vampire(domain, target_dir=None)\n"
+                                         "Vampire a domain.";
+
+static const char py_net_replicate_init_doc[] = "replicate_init(samdb, lp, drspipe)\n"
+                                         "Setup for replicate_chunk calls.";
+
+static const char py_net_replicate_chunk_doc[] = "replicate_chunk(state, level, ctr, schema)\n"
+                                         "Process replication for one chunk";
+
+static const char py_net_finddc_doc[] = "finddc(domain, server_type)\n"
+                                         "find a DC with the specified server_type bits. Return the DNS name";
+
+static PyMethodDef net_obj_methods[] = {
+        {"join", (PyCFunction)py_net_join, METH_VARARGS|METH_KEYWORDS, py_net_join_doc},
+        {"set_password", (PyCFunction)py_net_set_password, METH_VARARGS|METH_KEYWORDS, py_net_set_password_doc},
+        {"export_keytab", (PyCFunction)py_net_export_keytab, METH_VARARGS|METH_KEYWORDS, py_net_export_keytab_doc},
+        {"time", (PyCFunction)py_net_time, METH_VARARGS|METH_KEYWORDS, py_net_time_doc},
+        {"create_user", (PyCFunction)py_net_user_create, METH_VARARGS|METH_KEYWORDS, py_net_create_user_doc},
+        {"delete_user", (PyCFunction)py_net_user_delete, METH_VARARGS|METH_KEYWORDS, py_net_delete_user_doc},
+        {"vampire", (PyCFunction)py_net_vampire, METH_VARARGS|METH_KEYWORDS, py_net_vampire_doc},
+        {"replicate_init", (PyCFunction)py_net_replicate_init, METH_VARARGS|METH_KEYWORDS, py_net_replicate_init_doc},
+        {"replicate_chunk", (PyCFunction)py_net_replicate_chunk, METH_VARARGS|METH_KEYWORDS, py_net_replicate_chunk_doc},
+        {"finddc", (PyCFunction)py_net_finddc, METH_VARARGS, py_net_finddc_doc},
+        { NULL }
+};
+
+static void py_net_dealloc(py_net_Object *self)
+{
+        talloc_free(self->mem_ctx);
+        PyObject_Del(self);
+}
+
+static PyObject *net_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+        PyObject *py_creds, *py_lp = Py_None;
+        const char *kwnames[] = { "creds", "lp", "server", NULL };
+        py_net_Object *ret;
+        struct loadparm_context *lp;
+        const char *server_address = NULL;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Oz",
+                                         discard_const_p(char *, kwnames), &py_creds, &py_lp,
+                                         &server_address))
+                return NULL;
+
+        ret = PyObject_New(py_net_Object, type);
+        if (ret == NULL) {
+                return NULL;
+        }
+
+        /* FIXME: we really need to get a context from the caller or we may end
+         * up with 2 event contexts */
+        ret->ev = s4_event_context_init(NULL);
+        ret->mem_ctx = talloc_new(ret->ev);
+
+        lp = lpcfg_from_py_object(ret->mem_ctx, py_lp);
+        if (lp == NULL) {
+                Py_DECREF(ret);
+                return NULL;
+        }
+
+        ret->libnet_ctx = libnet_context_init(ret->ev, lp);
+        if (ret->libnet_ctx == NULL) {
+                PyErr_SetString(PyExc_RuntimeError, "Unable to initialize net");
+                Py_DECREF(ret);
+                return NULL;
+        }
+
+        ret->libnet_ctx->server_address = server_address;
+
+        ret->libnet_ctx->cred = cli_credentials_from_py_object(py_creds);
+        if (ret->libnet_ctx->cred == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected credentials object");
-                return NULL;
-        }
-
-        libnet_ctx = py_net_ctx(cls, ev, creds);
-
-        status = libnet_Join(libnet_ctx, mem_ctx, &r);
-        if (NT_STATUS_IS_ERR(status)) {
-                PyErr_SetString(PyExc_RuntimeError, r.out.error_string);
-                talloc_free(mem_ctx);
-                return NULL;
-        }
-
-        result = Py_BuildValue("sss", r.out.join_password, 
-                               dom_sid_string(mem_ctx, r.out.domain_sid),
-                               r.out.domain_name);
-
-        talloc_free(mem_ctx);
-
-        if (result == NULL)
-                return NULL;
-
-        return result;
-}
-
-static char py_net_join_doc[] = "join(domain_name, netbios_name, join_type, level) -> (join_password, domain_sid, domain_name)\n\n" \
-"Join the domain with the specified name.";
-
-static struct PyMethodDef net_methods[] = {
-        {"Join", (PyCFunction)py_net_join, METH_VARARGS|METH_KEYWORDS, py_net_join_doc},
-        {NULL }
+                Py_DECREF(ret);
+                return NULL;
+        }
+
+        return (PyObject *)ret;
+}
+
+
+PyTypeObject py_net_Type = {
+        PyObject_HEAD_INIT(NULL) 0,
+        .tp_name = "net.Net",
+        .tp_basicsize = sizeof(py_net_Object),
+        .tp_dealloc = (destructor)py_net_dealloc,
+        .tp_methods = net_obj_methods,
+        .tp_new = net_obj_new,
 };
 
 void initnet(void)
 {
-        Py_InitModule("net", net_methods);
-}
+        PyObject *m;
+
+        if (PyType_Ready(&py_net_Type) < 0)
+                return;
+
+        m = Py_InitModule3("net", NULL, NULL);
+        if (m == NULL)
+                return;
+
+        Py_INCREF(&py_net_Type);
+        PyModule_AddObject(m, "Net", (PyObject *)&py_net_Type);
+        PyModule_AddObject(m, "LIBNET_JOINDOMAIN_AUTOMATIC", PyInt_FromLong(LIBNET_JOINDOMAIN_AUTOMATIC));
+        PyModule_AddObject(m, "LIBNET_JOINDOMAIN_SPECIFIED", PyInt_FromLong(LIBNET_JOINDOMAIN_SPECIFIED));
+        PyModule_AddObject(m, "LIBNET_JOIN_AUTOMATIC", PyInt_FromLong(LIBNET_JOIN_AUTOMATIC));
+        PyModule_AddObject(m, "LIBNET_JOIN_SPECIFIED", PyInt_FromLong(LIBNET_JOIN_SPECIFIED));
+}

vendor/current/source4/libnet/userinfo.c

@@ -46 +46 @@
 
 
-static void continue_userinfo_lookup(struct rpc_request *req);
-static void continue_userinfo_openuser(struct rpc_request *req);
-static void continue_userinfo_getuser(struct rpc_request *req);
-static void continue_userinfo_closeuser(struct rpc_request *req);
+static void continue_userinfo_lookup(struct tevent_req *subreq);
+static void continue_userinfo_openuser(struct tevent_req *subreq);
+static void continue_userinfo_getuser(struct tevent_req *subreq);
+static void continue_userinfo_closeuser(struct tevent_req *subreq);
 
 
@@ -55 +55 @@
  * Stage 1 (optional): Look for a username in SAM server.
  */
-static void continue_userinfo_lookup(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct userinfo_state *s;
-        struct rpc_request *openuser_req;
+static void continue_userinfo_lookup(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct userinfo_state *s;
         struct monitor_msg msg;
         struct msg_rpc_lookup_name *msg_lookup;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userinfo_state);
 
         /* receive samr_Lookup reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_LookupNames_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
         
@@ -104 +104 @@
 
         /* send request */
-        openuser_req = dcerpc_samr_OpenUser_send(s->pipe, c, &s->openuser);
-        if (composite_nomem(openuser_req, c)) return;
-
-        composite_continue_rpc(c, openuser_req, continue_userinfo_openuser, c);
+        subreq = dcerpc_samr_OpenUser_r_send(s, c->event_ctx,
+                                             s->pipe->binding_handle,
+                                             &s->openuser);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_userinfo_openuser, c);
 }
 
@@ -114 +116 @@
  * Stage 2: Open user policy handle.
  */
-static void continue_userinfo_openuser(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct userinfo_state *s;
-        struct rpc_request *queryuser_req;
+static void continue_userinfo_openuser(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct userinfo_state *s;
         struct monitor_msg msg;
         struct msg_rpc_open_user *msg_open;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userinfo_state);
 
         /* receive samr_OpenUser reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_OpenUser_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -153 +155 @@
         
         /* queue rpc call, set event handling and new state */
-        queryuser_req = dcerpc_samr_QueryUserInfo_send(s->pipe, c, &s->queryuserinfo);
-        if (composite_nomem(queryuser_req, c)) return;
-        
-        composite_continue_rpc(c, queryuser_req, continue_userinfo_getuser, c);
+        subreq = dcerpc_samr_QueryUserInfo_r_send(s, c->event_ctx,
+                                                  s->pipe->binding_handle,
+                                                  &s->queryuserinfo);
+        if (composite_nomem(subreq, c)) return;
+        
+        tevent_req_set_callback(subreq, continue_userinfo_getuser, c);
 }
 
@@ -163 +167 @@
  * Stage 3: Get requested user information.
  */
-static void continue_userinfo_getuser(struct rpc_request *req)
-{
-        struct composite_context *c;
-        struct userinfo_state *s;
-        struct rpc_request *close_req;
+static void continue_userinfo_getuser(struct tevent_req *subreq)
+{
+        struct composite_context *c;
+        struct userinfo_state *s;
         struct monitor_msg msg;
         struct msg_rpc_query_user *msg_query;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userinfo_state);
 
         /* receive samr_QueryUserInfo reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_QueryUserInfo_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -202 +206 @@
         
         /* queue rpc call, set event handling and new state */
-        close_req = dcerpc_samr_Close_send(s->pipe, c, &s->samrclose);
-        if (composite_nomem(close_req, c)) return;
-        
-        composite_continue_rpc(c, close_req, continue_userinfo_closeuser, c);
+        subreq = dcerpc_samr_Close_r_send(s, c->event_ctx,
+                                          s->pipe->binding_handle,
+                                          &s->samrclose);
+        if (composite_nomem(subreq, c)) return;
+        
+        tevent_req_set_callback(subreq, continue_userinfo_closeuser, c);
 }
 
@@ -212 +218 @@
  * Stage 4: Close policy handle associated with opened user.
  */
-static void continue_userinfo_closeuser(struct rpc_request *req)
+static void continue_userinfo_closeuser(struct tevent_req *subreq)
 {
         struct composite_context *c;
@@ -219 +225 @@
         struct msg_rpc_close_user *msg_close;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userinfo_state);
 
         /* receive samr_Close reply */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_Close_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -259 +266 @@
         struct userinfo_state *s;
         struct dom_sid *sid;
-        struct rpc_request *openuser_req, *lookup_req;
+        struct tevent_req *subreq;
 
         if (!p || !io) return NULL;
@@ -286 +293 @@
                 
                 /* send request */
-                openuser_req = dcerpc_samr_OpenUser_send(p, c, &s->openuser);
-                if (composite_nomem(openuser_req, c)) return c;
-
-                composite_continue_rpc(c, openuser_req, continue_userinfo_openuser, c);
+                subreq = dcerpc_samr_OpenUser_r_send(s, c->event_ctx,
+                                                     p->binding_handle,
+                                                     &s->openuser);
+                if (composite_nomem(subreq, c)) return c;
+
+                tevent_req_set_callback(subreq, continue_userinfo_openuser, c);
 
         } else {
@@ -306 +315 @@
                 
                 /* send request */
-                lookup_req = dcerpc_samr_LookupNames_send(p, c, &s->lookup);
-                if (composite_nomem(lookup_req, c)) return c;
-                
-                composite_continue_rpc(c, lookup_req, continue_userinfo_lookup, c);
+                subreq = dcerpc_samr_LookupNames_r_send(s, c->event_ctx,
+                                                        p->binding_handle,
+                                                        &s->lookup);
+                if (composite_nomem(subreq, c)) return c;
+                
+                tevent_req_set_callback(subreq, continue_userinfo_lookup, c);
         }
 

vendor/current/source4/libnet/userman.c

@@ -33 +33 @@
 struct useradd_state {
         struct dcerpc_pipe       *pipe;
-        struct rpc_request       *req;
         struct policy_handle     domain_handle;
         struct samr_CreateUser   createuser;
@@ -44 +43 @@
 
 
-static void continue_useradd_create(struct rpc_request *req);
+static void continue_useradd_create(struct tevent_req *subreq);
 
 
@@ -50 +49 @@
  * Stage 1 (and the only one for now): Create user account.
  */
-static void continue_useradd_create(struct rpc_request *req)
+static void continue_useradd_create(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct useradd_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct useradd_state);
 
         /* check rpc layer status code */
-        c->status = dcerpc_ndr_request_recv(s->req);
+        c->status = dcerpc_samr_CreateUser_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -101 +101 @@
         struct composite_context *c;
         struct useradd_state *s;
+        struct tevent_req *subreq;
 
         if (!p || !io) return NULL;
@@ -131 +132 @@
 
         /* send the request */
-        s->req = dcerpc_samr_CreateUser_send(p, c, &s->createuser);
-        if (composite_nomem(s->req, c)) return c;
-
-        composite_continue_rpc(c, s->req, continue_useradd_create, c);
+        subreq = dcerpc_samr_CreateUser_r_send(s, c->event_ctx,
+                                               p->binding_handle,
+                                               &s->createuser);
+        if (composite_nomem(subreq, c)) return c;
+
+        tevent_req_set_callback(subreq, continue_useradd_create, c);
         return c;
 }
@@ -204 +207 @@
 
 
-static void continue_userdel_name_found(struct rpc_request *req);
-static void continue_userdel_user_opened(struct rpc_request* req);
-static void continue_userdel_deleted(struct rpc_request *req);
+static void continue_userdel_name_found(struct tevent_req *subreq);
+static void continue_userdel_user_opened(struct tevent_req *subreq);
+static void continue_userdel_deleted(struct tevent_req *subreq);
 
 
@@ -212 +215 @@
  * Stage 1: Lookup the user name and resolve it to rid
  */
-static void continue_userdel_name_found(struct rpc_request *req)
+static void continue_userdel_name_found(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct userdel_state *s;
-        struct rpc_request *openuser_req;
         struct monitor_msg msg;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userdel_state);
 
         /* receive samr_LookupNames result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_LookupNames_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -265 +268 @@
 
         /* send rpc request */
-        openuser_req = dcerpc_samr_OpenUser_send(s->pipe, c, &s->openuser);
-        if (composite_nomem(openuser_req, c)) return;
-
-        composite_continue_rpc(c, openuser_req, continue_userdel_user_opened, c);
+        subreq = dcerpc_samr_OpenUser_r_send(s, c->event_ctx,
+                                             s->pipe->binding_handle,
+                                             &s->openuser);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_userdel_user_opened, c);
 }
 
@@ -275 +280 @@
  * Stage 2: Open user account.
  */
-static void continue_userdel_user_opened(struct rpc_request* req)
+static void continue_userdel_user_opened(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct userdel_state *s;
-        struct rpc_request *deluser_req;
         struct monitor_msg msg;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userdel_state);
 
         /* receive samr_OpenUser result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_OpenUser_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -313 +318 @@
         
         /* send rpc request */
-        deluser_req = dcerpc_samr_DeleteUser_send(s->pipe, c, &s->deleteuser);
-        if (composite_nomem(deluser_req, c)) return;
+        subreq = dcerpc_samr_DeleteUser_r_send(s, c->event_ctx,
+                                               s->pipe->binding_handle,
+                                               &s->deleteuser);
+        if (composite_nomem(subreq, c)) return;
 
         /* callback handler setup */
-        composite_continue_rpc(c, deluser_req, continue_userdel_deleted, c);
+        tevent_req_set_callback(subreq, continue_userdel_deleted, c);
 }
 
@@ -324 +331 @@
  * Stage 3: Delete user account
  */
-static void continue_userdel_deleted(struct rpc_request *req)
+static void continue_userdel_deleted(struct tevent_req *subreq)
 {
         struct composite_context *c;
@@ -330 +337 @@
         struct monitor_msg msg;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct userdel_state);
 
         /* receive samr_DeleteUser result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_DeleteUser_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -370 +378 @@
         struct composite_context *c;
         struct userdel_state *s;
-        struct rpc_request *lookup_req;
+        struct tevent_req *subreq;
 
         /* composite context allocation and setup */
@@ -397 +405 @@
 
         /* send the request */
-        lookup_req = dcerpc_samr_LookupNames_send(p, c, &s->lookupname);
-        if (composite_nomem(lookup_req, c)) return c;
+        subreq = dcerpc_samr_LookupNames_r_send(s, c->event_ctx,
+                                                p->binding_handle,
+                                                &s->lookupname);
+        if (composite_nomem(subreq, c)) return c;
 
         /* set the next stage */
-        composite_continue_rpc(c, lookup_req, continue_userdel_name_found, c);
+        tevent_req_set_callback(subreq, continue_userdel_name_found, c);
         return c;
 }
@@ -455 +465 @@
  */
 
-static void continue_usermod_name_found(struct rpc_request *req);
-static void continue_usermod_user_opened(struct rpc_request *req);
-static void continue_usermod_user_queried(struct rpc_request *req);
-static void continue_usermod_user_changed(struct rpc_request *req);
+static void continue_usermod_name_found(struct tevent_req *subreq);
+static void continue_usermod_user_opened(struct tevent_req *subreq);
+static void continue_usermod_user_queried(struct tevent_req *subreq);
+static void continue_usermod_user_changed(struct tevent_req *subreq);
 
 
@@ -480 +490 @@
  * Step 1: Lookup user name
  */
-static void continue_usermod_name_found(struct rpc_request *req)
+static void continue_usermod_name_found(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct usermod_state *s;
-        struct rpc_request *openuser_req;
         struct monitor_msg msg;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct usermod_state);
 
         /* receive samr_LookupNames result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_LookupNames_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -533 +543 @@
 
         /* send the rpc request */
-        openuser_req = dcerpc_samr_OpenUser_send(s->pipe, c, &s->openuser);
-        if (composite_nomem(openuser_req, c)) return;
-
-        composite_continue_rpc(c, openuser_req, continue_usermod_user_opened, c);
+        subreq = dcerpc_samr_OpenUser_r_send(s, c->event_ctx,
+                                             s->pipe->binding_handle,
+                                             &s->openuser);
+        if (composite_nomem(subreq, c)) return;
+
+        tevent_req_set_callback(subreq, continue_usermod_user_opened, c);
 }
 
@@ -656 +668 @@
                                struct usermod_state *s)
 {
-        struct rpc_request *query_req, *setuser_req;
         bool do_set;
         union samr_UserInfo *i = &s->info;
+        struct tevent_req *subreq;
 
         /* set the level to invalid value, so that unless setfields routine 
@@ -687 +699 @@
                 /* send query user info request to retrieve complete data of
                    a particular info level */
-                query_req = dcerpc_samr_QueryUserInfo_send(s->pipe, c, &s->queryuser);
-                composite_continue_rpc(c, query_req, continue_usermod_user_queried, c);
+                subreq = dcerpc_samr_QueryUserInfo_r_send(s, c->event_ctx,
+                                                          s->pipe->binding_handle,
+                                                          &s->queryuser);
+                if (composite_nomem(subreq, c)) return NT_STATUS_NO_MEMORY;
+                tevent_req_set_callback(subreq, continue_usermod_user_queried, c);
 
         } else {
@@ -696 +711 @@
 
                 /* send set user info request after making required change */
-                setuser_req = dcerpc_samr_SetUserInfo_send(s->pipe, c, &s->setuser);
-                composite_continue_rpc(c, setuser_req, continue_usermod_user_changed, c);
+                subreq = dcerpc_samr_SetUserInfo_r_send(s, c->event_ctx,
+                                                        s->pipe->binding_handle,
+                                                        &s->setuser);
+                if (composite_nomem(subreq, c)) return NT_STATUS_NO_MEMORY;
+                tevent_req_set_callback(subreq, continue_usermod_user_changed, c);
         }
         
@@ -707 +725 @@
  * Stage 2: Open user account
  */
-static void continue_usermod_user_opened(struct rpc_request *req)
+static void continue_usermod_user_opened(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct usermod_state *s;
 
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct usermod_state);
 
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_OpenUser_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -731 +750 @@
  * Stage 2a (optional): Query the user information
  */
-static void continue_usermod_user_queried(struct rpc_request *req)
+static void continue_usermod_user_queried(struct tevent_req *subreq)
 {
         struct composite_context *c;
@@ -737 +756 @@
         union samr_UserInfo *i;
         uint16_t level;
-        struct rpc_request *setuser_req;
-        
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct usermod_state);
 
@@ -745 +763 @@
 
         /* receive samr_QueryUserInfo result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_QueryUserInfo_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -766 +785 @@
 
         /* send the rpc request */
-        setuser_req = dcerpc_samr_SetUserInfo_send(s->pipe, c, &s->setuser);
-        composite_continue_rpc(c, setuser_req, continue_usermod_user_changed, c);
+        subreq = dcerpc_samr_SetUserInfo_r_send(s, c->event_ctx,
+                                                s->pipe->binding_handle,
+                                                &s->setuser);
+        if (composite_nomem(subreq, c)) return;
+        tevent_req_set_callback(subreq, continue_usermod_user_changed, c);
 }
 
@@ -774 +796 @@
  * Stage 3: Set new user account data
  */
-static void continue_usermod_user_changed(struct rpc_request *req)
+static void continue_usermod_user_changed(struct tevent_req *subreq)
 {
         struct composite_context *c;
         struct usermod_state *s;
         
-        c = talloc_get_type(req->async.private_data, struct composite_context);
+        c = tevent_req_callback_data(subreq, struct composite_context);
         s = talloc_get_type(c->private_data, struct usermod_state);
 
         /* receive samr_SetUserInfo result */
-        c->status = dcerpc_ndr_request_recv(req);
+        c->status = dcerpc_samr_SetUserInfo_r_recv(subreq, s);
+        TALLOC_FREE(subreq);
         if (!composite_is_ok(c)) return;
 
@@ -818 +841 @@
         struct composite_context *c;
         struct usermod_state *s;
-        struct rpc_request *lookup_req;
+        struct tevent_req *subreq;
 
         /* composite context allocation and setup */
@@ -845 +868 @@
 
         /* send the rpc request */
-        lookup_req = dcerpc_samr_LookupNames_send(p, c, &s->lookupname);
-        if (composite_nomem(lookup_req, c)) return c;
+        subreq = dcerpc_samr_LookupNames_r_send(s, c->event_ctx,
+                                                p->binding_handle,
+                                                &s->lookupname);
+        if (composite_nomem(subreq, c)) return c;
         
         /* callback handler setup */
-        composite_continue_rpc(c, lookup_req, continue_usermod_name_found, c);
+        tevent_req_set_callback(subreq, continue_usermod_name_found, c);
         return c;
 }